web-dev-qa-db-fra.com

Comment puis-je sauvegarder toutes les variables de la session python actuelle?

Je souhaite enregistrer toutes les variables dans mon environnement python actuel. Il semble qu'une option consiste à utiliser le module "pickle". Cependant, je ne veux pas faire cela pour 2 raisons:

1) Je dois appeler pickle.dump () pour chaque variable
2) Lorsque je veux récupérer les variables, je dois me rappeler l’ordre dans lequel j’ai sauvegardé les variables, puis effectuer un pickle.load () pour récupérer chaque variable.

Je cherche une commande qui permettrait de sauvegarder toute la session, de sorte que lorsque je charge cette session enregistrée, toutes mes variables soient restaurées. Est-ce possible?

Merci beaucoup!
Gaurav

Edit: J'imagine que cela ne me dérange pas d'appeler pickle.dump () pour chaque variable que j'aimerais sauvegarder, mais le fait de se souvenir de l'ordre exact dans lequel les variables ont été enregistrées semble être une restriction importante. Je veux éviter ça.

pythonsave
67
user10

Si vous utilisez shelve , vous ne devez pas vous souvenir de l'ordre dans lequel les objets sont décapés, car shelve vous donne un objet de type dictionnaire:

Pour ranger votre travail:

import shelve

T='Hiya'
val=[1,2,3]

filename='/tmp/shelve.out'
my_shelf = shelve.open(filename,'n') # 'n' for new

for key in dir():
    try:
        my_shelf[key] = globals()[key]
    except TypeError:
        #
        # __builtins__, my_shelf, and imported modules can not be shelved.
        #
        print('ERROR shelving: {0}'.format(key))
my_shelf.close()

Restaurer:

my_shelf = shelve.open(filename)
for key in my_shelf:
    globals()[key]=my_shelf[key]
my_shelf.close()

print(T)
# Hiya
print(val)
# [1, 2, 3]
63
unutbu

Ayant siégé ici et n’ayant pas réussi à enregistrer la globals() en tant que dictionnaire, j’ai découvert que vous pouvez choisir une session en utilisant la bibliothèque Dill. 

Cela peut être fait en utilisant:

import dill                            #pip install dill --user
filename = 'globalsave.pkl'
dill.dump_session(filename)

# and to load the session again:
dill.load_session(filename)
39
user2589273

Voici un moyen de sauvegarder les variables de l'espace de travail Spyder à l'aide des fonctions spyderlib 

#%%  Load data from .spydata file
from spyderlib.utils.iofuncs import load_dictionary

globals().update(load_dictionary(fpath)[0])
data = load_dictionary(fpath)



#%% Save data to .spydata file
from spyderlib.utils.iofuncs import save_dictionary
def variablesfilter(d):
    from spyderlib.widgets.dicteditorutils import globalsfilter
    from spyderlib.plugins.variableexplorer import VariableExplorer
    from spyderlib.baseconfig import get_conf_path, get_supported_types

    data = globals()
    settings = VariableExplorer.get_settings()

    get_supported_types()
    data = globalsfilter(data,                   
                         check_all=True,
                         filters=Tuple(get_supported_types()['picklable']),
                         exclude_private=settings['exclude_private'],
                         exclude_uppercase=settings['exclude_uppercase'],
                         exclude_capitalized=settings['exclude_capitalized'],
                         exclude_unsupported=settings['exclude_unsupported'],
                         excluded_names=settings['excluded_names']+['settings','In'])
    return data

def saveglobals(filename):
    data = globalsfiltered()
    save_dictionary(data,filename)


#%%

savepath = 'test.spydata'

saveglobals(savepath)

Faites-moi savoir si cela fonctionne pour vous . David B-H

4
David BH

Un moyen très simple qui pourrait satisfaire vos besoins. Pour moi, ça a plutôt bien marché:

Cliquez simplement sur cette icône dans l'explorateur de variables (côté droit de l'araignée):

Sauvegarde de toutes les variables au format * .spydata

Chargement de toutes les variables ou des images, etc.

3
shm2008

Ce que vous essayez de faire, c'est d'hiberner votre processus. C'était discuté déjà. La conclusion est qu'il existe plusieurs problèmes difficiles à résoudre tout en essayant de le faire. Par exemple, lors de la restauration de descripteurs de fichiers ouverts.

Il est préférable de penser au sous-système de sérialisation/désérialisation pour votre programme. Ce n'est pas trivial dans de nombreux cas, mais c'est une solution bien meilleure dans une perspective à long terme.

Bien que si j'ai exagéré le problème. Vous pouvez essayer de décaper vos variables globales dict. Utilisez globals() pour accéder au dictionnaire. Comme il est indexé varname, vous ne devez pas vous soucier de la commande.

2
nkrkv

Vous pouvez l'enregistrer sous forme de fichier texte ou de fichier CVS. Les utilisateurs utilisent Spyder par exemple pour enregistrer des variables, mais le problème est connu: il ne parvient pas à importer des types de données spécifiques.

0
Navid Farhoudi

Si vous voulez que la réponse acceptée résumée fonctionne, 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

cela a fonctionné quand je l'ai couru. Je vais admettre que je ne comprends pas dir() et globals() 100%, donc je ne sais pas s'il pourrait y avoir 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 globals et que save_workspace fait partie d'une fonction, cela ne fonctionnera pas comme prévu si vous souhaitez enregistrer les variables dans une portée locale. Pour cela, utilisez locals(). Cela se produit parce que globals prend les globals du module où la fonction est définie, et non d'où il est appelé serait ce que je suppose.

0
Pinocchio