Viendo todas las variables definidas

Actualmente estoy trabajando en una computación en shell de python. Lo que quiero es tener una lista de estilo de Matlab donde pueda ver todas las variables que se han definido hasta cierto punto (para saber qué nombres he usado, sus valores y demás).

¿Hay una manera, y cómo puedo hacer eso?

Algunas cosas que podrías usar:

  • dir() le dará la lista de variables de scope:
  • globals() te dará un diccionario de variables globales
  • locals() te dará un diccionario de variables locales

Si es posible, es posible que desee utilizar IPython .

Para obtener una lista de todas las variables actuales definidas por el usuario, IPython proporciona un comando mágico llamado who (las mágicas deben tener un prefijo con el carácter de módulo a menos que la función automagic esté habilitada):

 In [1]: foo = 'bar' In [2]: %who foo 

Puedes usar la magia de whos para obtener más detalles:

 In [3]: %whos Variable Type Data/Info ---------------------------- foo str bar 

Hay una gran cantidad de otras magias disponibles. IPython es básicamente el intérprete de Python para los esteroides. Una magia conveniente es la store , que le permite guardar variables entre sesiones (utilizando pickle ).

Si tienes unos minutos, echa un vistazo a los excelentes screencasts de demostración de IPython de Jeff Rush.

Nota: No estoy asociado con IPython Dev, solo un usuario satisfecho.

Como dijo RedBlueThing y análogo:

  • dir() da una lista de variables de scope
  • globals() da un diccionario de variables globales
  • locals() da un diccionario de variables locales

Usando el shell interactivo (versión 2.6.9), después de crear las variables a = 1 y b = 2 , ejecutar dir() da

 ['__builtins__', '__doc__', '__name__', '__package__', 'a', 'b'] 

ejecutando locals() da

 {'a': 1, 'b': 2, '__builtins__': , '__package__': None, '__name__': '__main__', '__doc__': None} 

Ejecutar globals() da exactamente la misma respuesta que locals() en este caso.

No me he metido en ningún módulo, por lo que todas las variables están disponibles como variables locales y globales. locals() y globals() enumeran los valores de las variables, así como los nombres; dir() solo lista los nombres.

Si importo un módulo y ejecuto locals() o globals() dentro del módulo, dir() todavía proporciona solo un pequeño número de variables; agrega __file__ a las variables enumeradas anteriormente. locals() y globals() también enumeran las mismas variables, pero en el proceso de imprimir el valor del diccionario para __builtin__ , enumera un número mucho mayor de variables: funciones incorporadas, excepciones y tipos como ” 'type': “, en lugar de solo el breve como se muestra arriba.

Para obtener más información sobre dir() consulte la referencia rápida de Python 2.7 en New Mexico Tech o la función dir () en ibiblio.org.

Para obtener más información sobre locals() y globals() visite locals y globals en Dive Into Python y una página sobre globals en New Mexico Tech.

[Comentario: @Kurt: Usted dio un enlace para enumerar o enumerar todas las variables en un progtwig de su idioma favorito aquí, pero esa respuesta tiene un error. El problema allí es: el type(name) en ese ejemplo siempre devolverá . Obtiene una lista de las variables, que responde a la pregunta, pero con los tipos incorrectos listados a su lado. Esto no fue obvio en su ejemplo porque todas las variables resultaron ser cadenas de todos modos; sin embargo, lo que está devolviendo es el tipo de nombre de la variable en lugar del tipo de la variable. Para solucionar esto: en lugar de print type(name) use print eval('type(' + name + ')') . Me disculpo por publicar un comentario en la sección de respuestas, pero no tengo privilegios para publicar comentarios, y la otra pregunta está cerrada.]

Para obtener los nombres:

 for name in vars().keys(): print(name) 

Para obtener los valores:

 for value in vars().values(): print(value) 

vars () también toma un argumento opcional para averiguar qué vars se definen dentro de un objeto en sí.

imprimir locales ()

Edición continuada del comentario.

Para que se vea un poco más bonito al imprimir:

 import sys, pprint sys.displayhook = pprint.pprint locals() 

Eso debería darle una impresión más vertical.

tenga en cuenta que dir () devolverá todas las importaciones Y variables actuales.

Si solo desea sus variables, sugeriría un esquema de nombres que sea fácil de extraer de dir, como varScore, varNames, etc.

De esa manera, simplemente puede hacer esto:

 for vars in dir(): if vars.startswith("var"): print vars 

Editar

si desea enumerar todas las variables, pero excluir módulos y variables importados como:

 __builtins__ 

Puedes usar algo así:

 import os import re x = 11 imports = "os","re" for vars in dir(): if vars.startswith("__") == 0 and vars not in imports: print vars 

Como puede ver, mostrará la variable “importaciones”, porque es una variable (bueno, una tupla). Una solución rápida es agregar la palabra “importaciones” a la tupla de importaciones.

Una forma un poco más inteligente (Python 3):

 def printvars(): tmp = globals().copy() [print(k,' : ',v,' type:' , type(v)) for k,v in tmp.items() if not k.startswith('_') and k!='tmp' and k!='In' and k!='Out' and not hasattr(v, '__call__')] 

globals (), locals (), vars () y dir () pueden ayudarlo en lo que desee.

En mi intérprete de Python 2.7, el mismo comando whos que existe en MATLAB existe en Python. Muestra los mismos detalles que el análogo de MATLAB (nombre de variable, tipo y valor / datos).

En el intérprete de Python, whos enumera todas las variables en el “espacio de nombres interactivo”.

 def MyWho(): print [v for v in globals().keys() if not v.startswith('_')] 

Esto tiene que ser definido en el shell interactivo.

import os, a = 10, import sys, MyWho () luego da

[‘a’, ‘MyWho’, ‘sys’, ‘os’]