Visualización de todas las variables definidas

Question

Actualmente estoy trabajando en un cómputo en Python Shell. Lo que quiero tener es una lista de estilos de Matlab donde se puedan ver todas las variables que se han definido hasta cierto punto (para saber qué nombres he usado, sus valores y demás).

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

Answer 1

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í.

Answer 2

imprimir locales()

editar continúa desde el comentario.

para que se vea un poco más bonita cuando se imprime:

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

Eso te dará una impresión más vertical.

Answer 3

par de cosas que podría usar:

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

Answer 4

globals(), locals(), vars(), y dir() pueden ayudarte en lo que quieras.

Answer 5

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

si sólo quiere sus variables, sugeriría un esquema de nombres que es fácil de extraer de dir, como varScore, nombres de variables, etc.

de esa manera, sólo tiene que hacer esto:

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

Editar

si desea una lista de todas las variables, pero excluyen los módulos y variables importados, tales como:

__builtins__ 

se puede 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 se puede ver, se mostrará las "importaciones" variables, sin embargo, debido a que es una variable (bueno, una tupla). Una solución rápida es agregar la palabra "importaciones" en la propia tupla de importación.

Answer 6

Si esta es una opción para usted, es posible que desee mirar a IPython:

Para obtener una lista de todas las variables definidas actualmente, el tipo who:

In [1]: foo = 'bar' 

In [2]: who 
foo 

Puede escribir whos para obtener más detalle:

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

Hay una gran cantidad de otras funciones disponibles - básicamente es el intérprete de Python en st eroides. Una una conveniente es store de comandos, que le permite guardar las variables entre las sesiones (como una especie de super fácil pickle)

Si usted tiene unos pocos minutos, echa un vistazo a Jeff Rush's excellent IPython demonstration screencasts:

estoy de ninguna manera asociado con el equipo detrás de IPython, solo un usuario satisfecho.

Answer 7

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

Esto debe definirse en el shell interactivo.

os de importación, a = 10, import sys, MyWho() luego da

[ 'a', 'MyWho', 'sys', 'os']

Answer 8

un poco más inteligente (pitón 3) forma:

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__')] 

Answer 9

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 la variable, tipo y valor/datos).

En el intérprete de Python, whos enumera todas las variables en el "espacio de nombre interactivo".

Answer 10

Como RedBlueThing y analógico dijo:

• dir() da una lista de las variables de ámbito
• globals() da un diccionario de variables globales
• locals() da un diccionario de variables locales

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

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

corriendo locals() da

{'a': 1, 'b': 2, '__builtins__': <module '__builtin__' (built-in)>, '__package__': None, '__name__': '__main__', '__doc__': None} 

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

No he entrado 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 enumera 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 de diccionario para __builtin__, enumera un número mucho mayor de variables: funciones incorporadas, excepciones y tipos como "'type': <type 'type'>", en lugar de simplemente el breve <module '__builtin__' (built-in)> como se muestra arriba.

Para obtener más información acerca de dir(), vea Python 2.7 quick reference en New Mexico Tech o the dir() function en ibiblio.org.

Para más información sobre locals()globals() y ver locals and globals en Inmersión en Python y una página sobre globals Tecnológico de Nuevo México.

[Comentario: @Kurt: Dio un enlace a enumerate-or-list-all-variables-in-a-program-of-your-favorite-language-here pero esa respuesta tiene un error. El problema allí es: type(name) en ese ejemplo siempre devolverá <type 'str'>. Obtiene una lista de las variables, que responde a la pregunta, pero con los tipos incorrectos enumerados al lado. Esto no era obvio en su ejemplo porque todas las variables pasaban a ser cadenas de todos modos; sin embargo, lo que está devolviendo es el tipo del 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.]