Comment sauvegarder toutes les variables de la session python en cours ?

Question

Je veux sauvegarder toutes les variables de mon environnement python actuel. Il semble qu'une option soit d'utiliser le module 'pickle'. Cependant, je ne veux pas le faire pour 2 raisons :

1. Je dois appeler pickle.dump() pour chaque variable
2. Lorsque je veux récupérer les variables, je dois me souvenir de l'ordre dans lequel j'ai enregistré les variables, puis effectuer une commande pickle.load() pour récupérer chaque variable.

Je cherche une commande qui permette de sauvegarder l'ensemble de la session, de sorte que lorsque je charge cette session sauvegardée, toutes mes variables soient restaurées. Est-ce possible ?

Edit : I guess I don't mind calling pickle.dump() pour chaque variable que je souhaite sauvegarder, mais se souvenir de l'ordre exact dans lequel les variables ont été sauvegardées semble être une grande restriction. Je veux éviter cela.

Answer 1

Si vous souhaitez que la réponse acceptée soit résumée en fonction, vous pouvez utiliser :

    import shelve

    def save_workspace(filename, names_of_spaces_to_save, dict_of_values_to_save):
    '''
        filename = location to save workspace.
        names_of_spaces_to_save = use dir() from parent to save all variables in previous scope.
            -dir() = return the list of names in the current local scope
        dict_of_values_to_save = use globals() or locals() to save all variables.
            -globals() = Return a dictionary representing the current global symbol table.
            This is always the dictionary of the current module (inside a function or method,
            this is the module where it is defined, not the module from which it is called).
            -locals() = Update and return a dictionary representing the current local symbol table.
            Free variables are returned by locals() when it is called in function blocks, but not in class blocks.

        Example of globals and dir():
            >>> x = 3 #note variable value and name bellow
            >>> globals()
            {'__builtins__': <module '__builtin__' (built-in)>, '__name__': '__main__', 'x': 3, '__doc__': None, '__package__': None}
            >>> dir()
            ['__builtins__', '__doc__', '__name__', '__package__', 'x']
    '''
    print 'save_workspace'
    print 'C_hat_bests' in names_of_spaces_to_save
    print dict_of_values_to_save
    my_shelf = shelve.open(filename,'n') # 'n' for new
    for key in names_of_spaces_to_save:
        try:
            my_shelf[key] = dict_of_values_to_save[key]
        except TypeError:
            #
            # __builtins__, my_shelf, and imported modules can not be shelved.
            #
            #print('ERROR shelving: {0}'.format(key))
            pass
    my_shelf.close()

    def load_workspace(filename, parent_globals):
        '''
            filename = location to load workspace.
            parent_globals use globals() to load the workspace saved in filename to current scope.
        '''
        my_shelf = shelve.open(filename)
        for key in my_shelf:
            parent_globals[key]=my_shelf[key]
        my_shelf.close()

an example script of using this:
import my_pkg as mp

x = 3

mp.save_workspace('a', dir(), globals())

pour obtenir/charger l'espace de travail :

import my_pkg as mp

x=1

mp.load_workspace('a', globals())

print x #print 3 for me

il a fonctionné lorsque je l'ai exécuté. Je dois admettre que je ne comprends pas dir() y globals() 100%, donc je ne sais pas s'il n'y a pas une mise en garde bizarre, mais jusqu'à présent cela semble fonctionner. Les commentaires sont les bienvenus :)

---

après quelques recherches supplémentaires si vous appelez save_workspace comme je l'ai suggéré avec les globaux et les save_workspace se trouve à l'intérieur d'une fonction, cela ne fonctionnera pas comme prévu si vous voulez sauvegarder les variables dans une portée locale. Pour cela, utilisez locals() . Cela est dû au fait que globals prend les globals du module où la fonction est définie, et non de l'endroit où elle est appelée, à mon avis.

Answer 2

Vous pouvez l'enregistrer sous la forme d'un fichier texte ou d'un fichier CVS. Les gens utilisent Spyder, par exemple, pour enregistrer des variables, mais ce logiciel présente un problème connu : pour certains types de données, il ne parvient pas à les importer en cours de route.