如何保存当前 python 会话中的所有变量？

问题描述：

我想保存当前 Python 环境中的所有变量。似乎一个选项是使用“pickle”模块。但是，出于两个原因，我不想这样做：

1. 我必须调用pickle.dump()每个变量

2. 当我想要检索变量时，我必须记住我保存变量的顺序，然后执行pickle.load()检索每个变量的顺序。

我正在寻找一些可以保存整个会话的命令，这样当我加载这个已保存的会话时，我的所有变量都会被恢复。这可能吗？

编辑：我想我不介意调用pickle.dump()我想要保存的每个变量，但记住变量保存的确切顺序似乎是一个很大的限制。我想避免这种情况。

解决方案 1：

如果您使用shelve，则不必记住对象的腌制顺序，因为它shelve会给您一个类似字典的对象：

搁置你的工作：

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

恢复方法：

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]

解决方案 2：

坐在这里却无法将其保存globals()为字典，我发现你可以使用 dill 库来腌制会话。

可以使用以下方法完成：

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

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

解决方案 3：

有一种非常简单的方法可以满足您的需求。对我来说，它做得很好：

只需单击变量资源管理器（Spider 的右侧）上的此图标：

解决方案 4：

以下是使用 spyderlib 函数保存 Spyder 工作区变量的一种方法

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

让我知道它是否对你有用。David BH

解决方案 5：

您要尝试做的是让进程休眠。这已经讨论过了。结论是，在尝试这样做时存在几个难以解决的问题。例如，恢复打开的文件描述符。

最好为你的程序考虑序列化/反序列化子系统。这在很多情况下并不简单，但从长远来看是一个更好的解决方案。

尽管我夸大了这个问题。您可以尝试腌制全局变量dict。用于globals()访问字典。由于它是 varname-indexed 的，因此您不必担心顺序。

解决方案 6：

如果您希望将接受的答案抽象出来以发挥作用，您可以使用：

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

获取/加载工作区：

import my_pkg as mp

x=1

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

print x #print 3 for me

我运行它时它成功了。我承认我并不完全理解dir()，globals()所以我不确定是否存在一些奇怪的警告，但到目前为止它似乎有效。欢迎评论 :)

经过进一步的研究，如果您save_workspace按照我的建议使用全局变量并save_workspace在函数内调用，如果您想将变量保存在本地范围内，它将无法按预期工作。为此使用locals()。发生这种情况是因为 globals 从定义函数的模块中获取全局变量，而不是从调用函数的地方获取全局变量，这是我的猜测。

解决方案 7：

您可以将其保存为文本文件或 CVS 文件。例如，人们使用 Spyder 来保存变量，但它有一个已知问题：对于特定数据类型，它无法在以后导入。