wake-up-neo.com

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 mich an die Reihenfolge erinnern, in der ich die Variablen gespeichert habe, und dann eine pickle.load () ausführen, um jede Variable abzurufen.

Ich suche nach einem Befehl, der die gesamte Sitzung speichern würde, sodass beim Laden dieser gespeicherten Sitzung alle meine Variablen wiederhergestellt werden. Ist das möglich?

Danke vielmals!
Gaurav

Edit: Ich denke, es macht mir nichts aus, pickle.dump () für jede Variable aufzurufen, die ich speichern möchte. Die genaue Reihenfolge, in der die Variablen gespeichert wurden, ist jedoch eine große Einschränkung. Ich möchte das vermeiden.

67
user10

Wenn Sie shelve verwenden, müssen Sie sich nicht die Reihenfolge der Objekte merken, da shelve Ihnen ein wörterbuchähnliches Objekt gibt:

Um Ihre Arbeit zu regeln:

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]
63
unutbu

Als ich hier saß und die globals() nicht als Wörterbuch speichern konnte, stellte ich fest, dass Sie eine Sitzung mit der Dill-Bibliothek auswählen können. 

Dies kann gemacht 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)
39
user2589273

Hier können Sie die Spyder-Arbeitsbereichsvariablen mithilfe der Spyderlib-Funktionen 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 B-H

4
David BH

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

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

Speichern aller Variablen im * .spydata-Format

Laden aller Variablen oder Bilder usw.

3
shm2008

Sie versuchen, Ihren Prozess in den Ruhezustand zu versetzen. Dies war bereits diskutiert . Die Schlussfolgerung ist, dass es beim Versuch mehrere Probleme gibt, die schwer zu lösen sind. Zum Beispiel bei der Wiederherstellung offener Dateideskriptoren.

Es ist besser, über das Serialisierungs-/Deserialisierungs-Subsystem für Ihr Programm nachzudenken. Es ist in vielen Fällen nicht trivial, aber aus langfristiger Perspektive eine weitaus bessere Lösung.

Obwohl, wenn ich das Problem übertrieben habe. Sie können versuchen, Ihre globalen Variablen dict zu definieren. Verwenden Sie globals() , um auf das Wörterbuch zuzugreifen. Da es sich um einen Variablennamen handelt, müssen Sie sich nicht um die Bestellung kümmern.

2
nkrkv

Sie können es als Textdatei oder CVS-Datei speichern. Die Leute verwenden Spyder zum Beispiel zum Speichern von Variablen, es gibt jedoch ein bekanntes Problem: Bei bestimmten Datentypen kann der Import nicht auf der Straße erfolgen.

0
Navid Farhoudi

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

den Arbeitsbereich abrufen/laden:

import my_pkg as mp

x=1

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

print x #print 3 for me

es hat funktioniert, als ich es lief. Ich gebe zu, dass ich dir() und globals() 100% nicht verstehe, daher bin ich mir nicht sicher, ob es irgendwelche seltsamen Vorbehalte gibt, aber bisher scheint es zu funktionieren. Kommentare sind willkommen :)


nach einigen weiteren Untersuchungen, wenn Sie save_workspace aufrufen, wie ich mit globals und save_workspace innerhalb einer Funktion vorgeschlagen habe, funktioniert es nicht wie erwartet, wenn Sie die veriables in einem lokalen Bereich speichern möchten. Verwenden Sie dazu locals(). Dies geschieht, weil Globals die Globals aus dem Modul entnimmt, in dem die Funktion definiert ist, und nicht von dem Ort, an dem sie aufgerufen wird.

0
Pinocchio