Gardez persistante des variables en mémoire entre les pistes de script Python

Est-il possible de garder un résultat variable en mémoire pour ne pas avoir à les recalculer à chaque fois que je lance le début de mon script?
Je suis en train de faire une longue (5 à 10 sec) de la série de l'exacte des opérations sur un ensemble de données (dont je suis la lecture du disque), chaque fois que je lance mon script.
Ce ne serait pas trop un problème depuis que je suis assez bon à l'aide de l'éditeur interactif pour déboguer mon code entre les pistes; cependant, parfois, l'interactivité n'est pas suffisant.

Je sais que je pourrais écrire mes résultats dans un fichier sur le disque, mais j'aimerais éviter de le faire si possible. Ce devrait être une solution qui génère une variable la première fois que je lance le script, et le garde en mémoire jusqu'à ce que le shell lui-même est fermé ou jusqu'à ce que je indiquer explicitement qu'il s'essoufflent. Quelque chose comme ceci:

# Check if variable already created this session
in_mem = var_in_memory() # Returns pointer to var, or False if not in memory yet
if not in_mem:
    # Read data set from disk
    with open('mydata', 'r') as in_handle:
        mytext = in_handle.read()
    # Extract relevant results from data set
    mydata = parse_data(mytext)
    result = initial_operations(mydata)
    in_mem = store_persistent(result)

J'ai une petite idée que la étagère module peut-être ce que je cherche ici, mais on dirait que dans le but d'ouvrir une étagère variable je dois spécifier un nom de fichier pour la persistance de l'objet, et donc je ne suis pas sûr si c'est tout à fait ce que je cherche.

Des conseils sur la mise en veilleuse de faire ce que je veux faire? Toutes les idées alternatives?

InformationsquelleAutor machine yearning | 2011-07-14
  1. 44

    Vous pouvez obtenir quelque chose comme ceci en utilisant la reload fonction globale pour ré-exécuter votre script principal du code. Vous devez écrire un script qui importe votre script principal, lui demande la variable elle veut cache, cache une copie de cette dans le script du module du champ d'application, et puis quand vous le souhaitez (lorsque vous appuyez sur ENTRÉE sur stdin ou quoi que ce soit), il appelle reload(yourscriptmodule) mais cette fois-ci la transmet à l'objet mis en cache tels que yourscript peut contourner le calcul coûteux. Voici un exemple rapide.

    wrapper.py 

    import sys
import mainscript

part1Cache = None
if __name__ == "__main__":
    while True:
        if not part1Cache:
            part1Cache = mainscript.part1()
        mainscript.part2(part1Cache)
        print "Press enter to re-run the script, CTRL-C to exit"
        sys.stdin.readline()
        reload(mainscript)

    mainscript.py

    def part1():
    print "part1 expensive computation running"
    return "This was expensive to compute"

def part2(value):
    print "part2 running with %s" % value

    Tout wrapper.py est en cours d'exécution, vous pouvez modifier mainscript.py, ajouter un nouveau code à l' part2 fonction et être en mesure d'exécuter votre nouveau code par rapport à la pré-calculé part1Cache.

    • Je voudrais envisager l'ajout d'un gestionnaire d'exception, où vous exécutez la source externe.
    • Ce qui se passe si une dépendance de mainscript.py est mis à jour? Ai-je besoin de la recharger de façon explicite?
    • Serait le stockage de la variable dans l'os.environ suffisent pas?
    • Non sans recharger, pas de. L'environnement serait effacée lors de votre python processus de mort. Mais en utilisant le mécanisme ci-dessus vous pouvez stocker dans les os.environ mais maintenant vous exposer les données en dehors de votre processus et sont limitées à des cordes d'une certaine longueur. En utilisant une simple variable python, vous éviter ces limitations.
    • bonne suggestion que j'ai besoin du gestionnaire d'exception tout de suite faire l'exemple réalisable.
    • Excellente réponse! Pour Python3, comprennent: "a partir de importlib importation recharger" dans wrapper.py

    InformationsquelleAutor Peter Lyons
  2. 6

    De conserver les données en mémoire, le processus doit garder en cours d'exécution. La mémoire appartient au processus d'exécuter le script, de ne PAS le shell. Le shell ne peut pas tenir en mémoire pour vous.

    Donc, si vous voulez changer votre code et de garder votre processus en cours d'exécution, vous aurez pour recharger les modules lorsqu'ils sont modifiés. Si l'une des données dans la mémoire est une instance d'une classe qui change, vous devrez trouver un moyen de le convertir à une instance de la nouvelle classe. C'est un peu le bazar. Pas beaucoup de langues ont jamais été bon à ce genre de hot patching (Common Lisp vient à l'esprit), et il y a beaucoup de chances pour que les choses aillent mal.

    • Merci beaucoup pour la réponse informative. Il est bon de savoir pourquoi telle solution ne fonctionne pas de la façon dont je le veux, je vous remercie de votre explication.
    InformationsquelleAutor Dietrich Epp
  3. 6

    Si vous ne voulez persister un objet (ou d'un objet graphique) pour les prochaines sessions, l'étagère module est probablement exagéré. Juste pickle l'objet que vous vous souciez. Faire le travail et d'enregistrer le cornichon si vous n'avez pas de cornichon-fichier, la charge ou le cornichon-fichier si vous en avez un.

    import os
import cPickle as pickle

pickle_filepath = "/path/to/picklefile.pickle"

if not os.path.exists(pickle_filepath):
    # Read data set from disk
    with open('mydata', 'r') as in_handle:
        mytext = in_handle.read()
    # Extract relevant results from data set
    mydata = parse_data(mytext)
    result = initial_operations(mydata)
    with open(pickle_filepath, 'w') as pickle_handle:
        pickle.dump(result, pickle_handle)
else:
    with open(pickle_filepath) as pickle_handle:
        result = pickle.load(pickle_handle)
    • Cornichon a également tendance à être plus rapide que de mettre en veilleuse
    InformationsquelleAutor Matt Anderson
  4. 3

    Python étagère est une persistance solution pour marinés (sérialisés) les objets et est basé sur les fichiers. L'avantage est qu'il stocke des objets Python directement, au sens de l'API est assez simple.

    Si vous voulez vraiment éviter le disque, la technologie que vous êtes à la recherche d'une "base de données en mémoire." Plusieurs alternatives existent, voir ce DONC, la question: en mémoire de la base de données en Python.

    • Merci, semble bon pour les autres applications, mais il semble un peu trop puissant pour mes besoins.
    InformationsquelleAutor Ray Toal
  5. 1

    C'est un os dépendant de la solution...

    $mkfifo inpipe

#/usr/bin/python3
#firstprocess.py
complicated_calculation()
while True:
 with open('inpipe') as f:
  try:
   print( exec (f.read()))
  except Exception as e: print(e)

$./first_process.py &
$cat second_process.py > inpipe

    Cela vous permettra de modifier et redéfinir les variables dans le premier processus, sans copie ou d'un recalcul quoi que ce soit. Il devrait être la solution la plus efficace par rapport à multitraitement, memcached, cornichon, enterrent des modules ou des bases de données.

    C'est vraiment sympa si vous voulez modifier et redéfinir second_process.py de manière itérative dans votre éditeur de texte ou IDE jusqu'à ce que vous l'avez droit, sans avoir à attendre pour le premier processus (par exemple, l'initialisation d'un grand dict, etc.) pour exécuter chaque fois que vous apportez une modification.

    • Merci, je veux utiliser quelque chose comme ceci comme une alternative légère à un serveur HTTP pour un calcul sur localhost pour appeler à partir d'une autre langue. De cette façon, je peux empêcher le chargement du module de surcharge répétée pour chaque demande. Je me demande bien, ce que ne with open('inpipe') as f faire quand il n'y a rien de mis en à l'autre bout?
    InformationsquelleAutor John
  6. 0

    Vous pouvez faire cela, mais vous devez utiliser une interface Python. En d'autres termes, le shell que vous utilisez pour lancer des scripts Python doit être un Python processus. Ensuite, toutes les variables globales ou des classes de vivre jusqu'à la fermeture de la coquille.

    Regarder la cmd module qui le rend facile d'écrire un programme shell. Vous pouvez même organiser de sorte que tout commmands qui ne sont pas mises en œuvre dans votre shell se passait à l'interpréteur de commandes du système d'exécution (sans fermer votre shell). Alors que vous auriez à mettre en œuvre une sorte de commande, prun par exemple, qui exécute un script Python à l'aide de la runpy module.

    http://docs.python.org/library/runpy.html

    Vous devez utiliser le init_globals paramètre à transmettre vos données spéciale pour le programme de l'espace de noms, idéalement, d'un dictionnaire ou d'une seule instance de la classe.

    InformationsquelleAutor Michael Dillon
  7. 0

    Vous pouvez exécuter une persistance de script sur le serveur via le système d'exploitation dont charges/cvac, et, même régulièrement des recharges/recalcs le sql des données dans les structures de la mémoire, de la sorte, et puis daccéder au à des données en mémoire à partir de votre script par l'intermédiaire d'un support.

    InformationsquelleAutor Stephen