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 utilisez étagère Il n'est pas nécessaire de se souvenir de l'ordre dans lequel les objets sont marinés, puisque shelve vous donne un objet de type dictionnaire :

Pour mettre votre travail de côté :

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()

Pour 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]

Answer 2

Ayant siégé ici et n'ayant pas réussi à sauver le globals() En tant que dictionnaire, j'ai découvert que l'on pouvait décaper une session en utilisant la bibliothèque de l'aneth.

Ceci 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)

Answer 3

Un moyen très simple de répondre à vos besoins. Pour ma part, j'ai obtenu d'excellents résultats :

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

Answer 4

Voici une façon de sauvegarder les variables de l'espace de travail Spyder en utilisant les 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

Answer 5

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 lorsque l'on essaie de le faire. Par exemple, la restauration des descripteurs de fichiers ouverts.

Il est préférable de penser à un 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 bien meilleure solution à long terme.

Même si j'ai exagéré le problème. Vous pouvez essayer de décaper vos variables globales dictée . Utiliser globals() pour accéder au dictionnaire. Comme il est indexé par Varname, vous n'avez pas à vous préoccuper de l'ordre.