Como posso salvar todas as variáveis ​​na sessão Python atual?

Eu quero salvar todas as variáveis ​​em meu ambiente Python atual. Parece que uma opção é usar o módulo 'pickle'. No entanto, não quero fazer isso por 2 motivos:

1) Tenho que chamar pickle.dump () para cada variável
2) Quando eu quiser recuperar as variáveis, devo lembrar a ordem em que salvei as variáveis ​​e, em seguida, fazer pickle.load () para recuperar cada variável.

Estou procurando algum comando que salvaria toda a sessão, para que quando eu carregar esta sessão salva, todas as minhas variáveis ​​sejam restauradas. Isso é possível?

Muito obrigado!
Gaurav

Edit: Acho que não me importo de chamar pickle.dump () para cada variável que gostaria de salvar, mas lembrar a ordem exata em que as variáveis ​​foram salvas parece uma grande restrição. Eu quero evitar isso.

Se você usar shelve , não é necessário lembrar a ordem em que os objetos são conservados, pois shelveoferece um objeto semelhante a um dicionário:

Para arquivar seu trabalho:

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

Restaurar:

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]

Tendo sentado aqui e falhado em salvar o globals()como um dicionário, descobri que você pode selecionar uma sessão usando a biblioteca de endro.

Isso pode ser feito usando:

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

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

Uma maneira muito fácil de satisfazer suas necessidades. Para mim, funcionou muito bem:

Basta clicar neste ícone no Explorador de variáveis ​​(lado direito do Spider):

Salvando todas as variáveis ​​no formato * .spydata

Carregando todas as variáveis ​​ou fotos etc.

Aqui está uma maneira de salvar as variáveis ​​do espaço de trabalho do Spyder usando as funções do 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) 

Deixe-me saber se funciona para você. David BH

O que você está tentando fazer é hibernar o processo. Isso já foi discutido . A conclusão é que existem vários problemas difíceis de resolver ao tentar fazê-lo. Por exemplo, com a restauração de descritores de arquivos abertos.

É melhor pensar sobre o subsistema de serialização / desserialização para seu programa. Não é trivial em muitos casos, mas é uma solução muito melhor em uma perspectiva de longo prazo.

Embora eu tenha exagerado o problema. Você pode tentar conservar seu dict de variáveis ​​globais . Use globals()para acessar o dicionário. Uma vez que é indexado por varname, você não precisa se preocupar com o pedido.

Se quiser que a resposta aceita resumida funcione, você pode usar:

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

para obter / carregar o espaço de trabalho:

import my_pkg as mp

x=1

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

print x #print 3 for me

funcionou quando o executei. Admito que não entendo dir()e globals()100%, então não tenho certeza se pode haver alguma advertência estranha, mas até agora parece funcionar. Comentários são bem-vindos :)

depois de mais pesquisas se você chamar save_workspacecomo sugeri com globais e save_workspaceestiver dentro de uma função, ela não funcionará como esperado se você quiser salvar os verificáveis ​​em um escopo local. Para esse uso locals(). Isso acontece porque os globais pegam os globais do módulo onde a função é definida, não de onde ela é chamada, seria o meu palpite.

Você pode salvá-lo como um arquivo de texto ou um arquivo CVS. As pessoas usam o Spyder, por exemplo, para salvar variáveis, mas ele tem um problema conhecido: para tipos de dados específicos, ele não consegue importar na estrada.