valor - que es id en python

¿Cómo puedo guardar todas las variables en la sesión de python actual?

Question

Quiero guardar todas las variables en mi entorno python actual. Parece que una opción es usar el módulo ''pickle''. Sin embargo, no quiero hacer esto por 2 razones:

1) Tengo que llamar a pickle.dump () para cada variable
2) Cuando quiero recuperar las variables, debo recordar el orden en que guardé las variables, y luego hacer un pickle.load () para recuperar cada variable.

Estoy buscando algún comando que guarde toda la sesión, de modo que cuando cargue esta sesión guardada, todas mis variables se restauren. es posible?

¡Muchas gracias!
Gaurav

Editar: Supongo que no me importa llamar a pickle.dump () para cada variable que me gustaría guardar, pero recordar el orden exacto en el que se guardaron las variables parece una gran restricción. Quiero evitar eso.

Answer 1

Aquí hay una manera de guardar las variables de espacio de trabajo de Spyder usando las funciones de 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) 

Avíseme si funciona para usted. David BH

Answer 2

Después de haberme sentado aquí y no haber podido guardar los globals() como un diccionario, descubrí que puedes organizar una sesión usando la biblioteca de eneldo.

Esto se puede hacer usando:

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

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

Answer 3

Lo que intenta hacer es hibernar su proceso. Esto ya fue discussed . La conclusión es que existen varios problemas difíciles de resolver al tratar de hacerlo. Por ejemplo, al restaurar los descriptores de archivos abiertos.

Es mejor pensar en el subsistema de serialización / deserialización para su programa. No es trivial en muchos casos, pero es una solución mucho mejor en una perspectiva a largo plazo.

Aunque si he exagerado el problema. Puedes intentar seleccionar tus variables globales dict . Use globals() para acceder al diccionario. Dado que está indexado con varname, no tiene que preocuparse por el orden.

Answer 4

Puede guardarlo como un archivo de texto o un archivo CVS. La gente usa Spyder, por ejemplo, para guardar variables, pero tiene un problema conocido: para tipos de datos específicos, no puede importar hacia abajo en el camino.

Answer 5

Si desea que la respuesta aceptada abstraída funcione, puede 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 obtener / cargar el espacio de trabajo:

import my_pkg as mp

x=1

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

print x #print 3 for me

Funcionó cuando lo ejecuté. Admitiré que no entiendo dir() y globals() 100%, así que no estoy seguro de si podría haber alguna advertencia extraña, pero hasta ahora parece funcionar. Los comentarios son bienvenidos :)

después de investigar un poco más si llama a save_workspace como sugerí con globals y save_workspace está dentro de una función, no funcionará como se espera si desea guardar los veriables en un ámbito local. Para eso usa locals() . Esto sucede porque globals toma los globales del módulo donde se define la función, no desde donde se llama sería mi suposición.

Answer 6

Una manera muy fácil que podría satisfacer tus necesidades. Para mí, me fue bastante bien:

Simplemente, haga clic en este icono en Variable Explorer (lado derecho de Spider):

Guardando todas las variables en formato * .spydata

Cargando todas las variables o fotos, etc.

Answer 7

Si usa shelve , no tiene que recordar el orden en que los objetos están en escabeche, ya que shelve le da un objeto tipo diccionario:

Para dejar de lado su trabajo:

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

Para 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]