Wie kann ich alle Variablen in der aktuellen Python-Sitzung speichern?

Ich möchte alle Variablen in meiner aktuellen Python-Umgebung speichern. Es scheint eine Möglichkeit zu sein, das 'Pickle'-Modul zu verwenden. Ich möchte dies jedoch aus zwei Gründen nicht tun:

1) Ich muss pickle.dump () für jede Variable aufrufen.
2) Wenn ich die Variablen abrufen möchte, muss ich mir die Reihenfolge merken, in der ich die Variablen gespeichert habe, und dann pickle.load () ausführen, um jede Variable abzurufen.

Ich suche nach einem Befehl, der die gesamte Sitzung speichert, damit beim Laden dieser gespeicherten Sitzung alle meine Variablen wiederhergestellt werden. Ist das möglich?

Vielen Dank!
Gaurav

Bearbeiten: Ich denke, es macht mir nichts aus, pickle.dump () für jede Variable aufzurufen, die ich speichern möchte, aber sich an die genaue Reihenfolge zu erinnern, in der die Variablen gespeichert wurden, scheint eine große Einschränkung zu sein. Das möchte ich vermeiden.

Wenn Sie Shelve verwenden , müssen Sie sich nicht an die Reihenfolge erinnern, in der die Objekte eingelegt werden, da shelveSie ein wörterbuchähnliches Objekt erhalten:

So stellen Sie Ihre Arbeit ein:

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

Etwas wiederherstellen:

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]

Nachdem ich hier gesessen und das globals()Wörterbuch nicht gespeichert hatte, stellte ich fest, dass Sie eine Sitzung mithilfe der Dill-Bibliothek auswählen können.

Dies kann erreicht werden mit:

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

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

Ein sehr einfacher Weg, der Ihre Bedürfnisse befriedigen könnte. Für mich hat es ganz gut geklappt:

Klicken Sie einfach auf dieses Symbol im Variablen-Explorer (rechte Seite von Spider):

Speichern aller Variablen im * .spydata-Format

Laden aller Variablen oder Bilder etc.

Hier ist eine Möglichkeit, die Spyder-Arbeitsbereichsvariablen mithilfe der Spyderlib-Funktionen zu speichern

#%%  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) 

Lassen Sie mich wissen, ob es für Sie funktioniert. David BH

Sie versuchen, Ihren Prozess in den Ruhezustand zu versetzen. Dies wurde bereits diskutiert . Die Schlussfolgerung ist, dass es bei diesem Versuch mehrere schwer zu lösende Probleme gibt. Zum Beispiel beim Wiederherstellen offener Dateideskriptoren.

Es ist besser, über das Subsystem Serialisierung / Deserialisierung für Ihr Programm nachzudenken. Es ist in vielen Fällen nicht trivial, aber in einer langfristigen Perspektive eine weitaus bessere Lösung.

Obwohl, wenn ich das Problem übertrieben habe. Sie können versuchen, Ihre globalen Variablen diktieren . Verwenden Sie globals()diese Option, um auf das Wörterbuch zuzugreifen. Da es varname-indiziert ist, müssen Sie sich nicht um die Reihenfolge kümmern.

Wenn die akzeptierte Antwort abstrahiert werden soll, können Sie Folgendes verwenden:

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

So rufen Sie den Arbeitsbereich ab:

import my_pkg as mp

x=1

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

print x #print 3 for me

es hat funktioniert, als ich es ausgeführt habe. Ich gebe zu, ich verstehe nicht dir()und zu globals()100%, daher bin ich mir nicht sicher, ob es eine seltsame Einschränkung geben könnte, aber bisher scheint es zu funktionieren. Kommentare sind willkommen :)

Nach einigen weiteren Recherchen funktioniert es nicht wie erwartet, wenn Sie die Überprüfungen in einem lokalen Bereich speichern, wenn Sie save_workspacewie von mir vorgeschlagen mit Globals anrufen und save_workspacesich in einer Funktion befinden. Für diesen Gebrauchlocals() . Dies geschieht, weil Globals die Globals aus dem Modul entnimmt, in dem die Funktion definiert ist, und nicht aus dem Ort, an dem sie aufgerufen wird.

Sie können es als Textdatei oder CVS-Datei speichern. Menschen verwenden Spyder zum Beispiel zum Speichern von Variablen, aber es gibt ein bekanntes Problem: Für bestimmte Datentypen kann es später nicht importiert werden.