Wie kann ich save alle Variablen der aktuellen python-session?

Nachdem saß hier und konnte nicht speichern Sie die globals() als ein Wörterbuch, entdeckte ich, können Sie Gurke, eine Sitzung mit der dill-Bibliothek.

Dies kann geschehen, indem man:

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

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

InformationsquelleAutor user2589273

Hier ist eine Möglichkeit, das speichern der Spyder-workspace-Variablen mit den spyderlib Funktionen

#%%  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, wenn es für Sie arbeitet.
David B-H

InformationsquelleAutor David BH

Wenn Sie möchten, dass die akzeptierte Antwort abstrahierte Funktion, die Sie verwenden können:

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

bekommen/laden des workspace:

import my_pkg as mp

x=1

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

print x #print 3 for me

es funktionierte, wenn ich es lief. Ich gebe zu ich verstehe nicht dir() und globals() 100%, so dass ich nicht sicher bin, ob es möglicherweise einige seltsame Einschränkung, aber bisher scheint es zu funktionieren. Kommentare sind willkommen 🙂

nach etwas mehr Forschung, wenn Sie anrufen save_workspace wie ich vorgeschlagen mit globals und save_workspace ist in einer Funktion funktioniert es nicht wie erwartet, wenn Sie möchten, speichern Sie die veriables in einem lokalen Bereich. Für diese Verwendung locals(). Dies geschieht, weil globals nimmt die globals aus dem Modul, in dem die Funktion definiert wurde, nicht, von wo es aufgerufen wird, wäre meine Vermutung.

InformationsquelleAutor Pinocchio