for - ¿Cómo miro dentro de un objeto de Python?

python inspect

Question

Estoy empezando a codificar en varios proyectos usando Python (incluido el desarrollo web Django y el desarrollo de juegos Panda3D).

Para ayudarme a entender lo que está pasando, me gustaría básicamente ''mirar'' dentro de los objetos de Python para ver cómo funcionan, como sus métodos y propiedades.

Entonces, digamos que tengo un objeto Python, ¿qué necesitaría para imprimir su contenido? ¿Es eso posible?

Answer 1

¡Me sorprende que nadie haya mencionado la ayuda todavía!

In [1]: def foo():
   ...:     "foo!"
   ...:

In [2]: help(foo)
Help on function foo in module __main__:

foo()
    foo!

La ayuda te permite leer la cadena de documentos y tener una idea de qué atributos podría tener una clase, lo cual es bastante útil.

Answer 2

Además, si desea buscar en la lista y los diccionarios, puede usar pprint ()

Answer 3

Dos grandes herramientas para inspeccionar el código son:

1. IPython . Una terminal de python que te permite inspeccionar usando la tabulación.

2. Eclipse con el plugin PyDev . Cuenta con un excelente depurador que le permite interrumpir en un lugar determinado e inspeccionar objetos explorando todas las variables como un árbol. Incluso puede usar el terminal incorporado para probar el código en ese lugar o escriba el objeto y presione ''.'' para que te dé consejos de código para ti.

Answer 4

Hay una compilación de la biblioteca de código de Python solo para este propósito: inspect Introduced in Python 2.7

Answer 5

Otros ya han mencionado el dir () incorporado que suena como lo que estás buscando, pero aquí hay otro buen consejo. Muchas bibliotecas, incluida la mayoría de las bibliotecas estándar, se distribuyen en formato fuente. Lo que significa que puedes leer fácilmente el código fuente directamente. El truco está en encontrarlo; por ejemplo:

>>> import string
>>> string.__file__
''/usr/lib/python2.5/string.pyc''

El archivo * .pyc está compilado, así que elimine la ''c'' y abra el archivo * .py sin compilar en su editor o visor de archivos favorito:

/usr/lib/python2.5/string.py

He encontrado esto increíblemente útil para descubrir cosas como qué excepciones se generan desde una API determinada. Este tipo de detalle rara vez está bien documentado en el mundo Python.

Answer 6

Primero, lea la fuente.

Segundo, usa la función dir() .

Answer 7

Prueba ppretty

from ppretty import ppretty


class A(object):
    s = 5

    def __init__(self):
        self._p = 8

    @property
    def foo(self):
        return range(10)


print ppretty(A(), indent=''    '', depth=2, width=30, seq_length=6,
              show_protected=True, show_private=False, show_static=True,
              show_properties=True, show_address=True)

Salida:

__main__.A at 0x1debd68L (
    _p = 8, 
    foo = [0, 1, 2, ..., 7, 8, 9], 
    s = 5
)

Answer 8

Puede listar los atributos de un objeto con dir () en el shell:

>>> dir(object())
[''__class__'', ''__delattr__'', ''__doc__'', ''__format__'', ''__getattribute__'', ''__hash__'', ''__init__'', ''__new__'', ''__reduce__'', ''__reduce_ex__'', ''__repr__'', ''__setattr__'', ''__sizeof__'', ''__str__'', ''__subclasshook__'']

Por supuesto, también está el módulo de inspección: http://docs.python.org/library/inspect.html#module-inspect

Answer 9

Python tiene un fuerte conjunto de características de introspección.

Echa un vistazo a las siguientes funciones integradas :

• type()
• dir()
• id()
• getattr()
• hasattr()
• globals()
• locals()
• callable()

type() y dir() son particularmente útiles para inspeccionar el tipo de un objeto y su conjunto de atributos, respectivamente.

Answer 10

Si bien la pprint ha sido mencionada por otros, me gustaría agregar algo de contexto.

El módulo pprint proporciona la capacidad de "imprimir bastante" estructuras de datos de Python arbitrarias en una forma que se puede usar como entrada para el intérprete. Si las estructuras con formato incluyen objetos que no son tipos fundamentales de Python, es posible que la representación no se pueda cargar. Este puede ser el caso si se incluyen objetos como archivos, sockets, clases o instancias, así como muchos otros objetos incorporados que no se pueden representar como constantes de Python.

pprint puede estar en alta demanda por desarrolladores con un fondo PHP que buscan una alternativa a var_dump() .

Los objetos con un atributo dict pueden pprint() bien usando pprint() mezclado con vars() , que devuelve el atributo __dict__ para un módulo, clase, instancia, etc.

from pprint import pprint
pprint(vars(your_object))

Por lo tanto, no hay necesidad de un bucle .

Para volcar todas las variables contenidas en el ámbito global o local, simplemente use:

pprint(globals())
pprint(locals())

locals() muestra variables definidas en una función.
También es útil acceder a las funciones con su nombre correspondiente como clave de cadena, entre otros usos :

locals()[''foo'']() # foo()
globals()[''foo'']() # foo()

De manera similar, usar dir() para ver el contenido de un módulo o los atributos de un objeto.

Y todavía hay más.

Answer 11

Si desea mirar dentro de un objeto vivo, entonces el módulo de inspect de Python es una buena respuesta. En general, funciona para obtener el código fuente de las funciones que están definidas en un archivo fuente en algún lugar del disco. Si desea obtener el origen de las funciones en vivo y las lambdas que se definieron en el intérprete, puede usar dill.source.getsource de dill . También puede obtener el código para los métodos y funciones de clase enlazados o no enlazados definidos en curries ... sin embargo, es posible que no pueda compilar ese código sin el código del objeto que lo contiene.

>>> from dill.source import getsource
>>> 
>>> def add(x,y):
...   return x+y
... 
>>> squared = lambda x:x**2
>>> 
>>> print getsource(add)
def add(x,y):
  return x+y

>>> print getsource(squared)
squared = lambda x:x**2

>>> 
>>> class Foo(object):
...   def bar(self, x):
...     return x*x+x
... 
>>> f = Foo()
>>> 
>>> print getsource(f.bar)
def bar(self, x):
    return x*x+x

>>> 

Answer 12

Si desea ver parámetros y métodos, como han señalado otros, puede usar pprint o dir()

Si quieres ver el valor real de los contenidos, puedes hacerlo.

object.__dict__

Answer 13

Si está interesado en una GUI para esto, eche un vistazo a objbrowser . Utiliza el módulo de inspección de la biblioteca estándar de Python para la introspección de objetos que se encuentra debajo.

Answer 14

Si está interesado en ver el código fuente de la función correspondiente al objeto myobj , puede escribir iPython o Jupyter Notebook :

myobj??

Answer 15

Si esto es para exploración para ver qué está pasando, recomiendo mirar IPython . Esto agrega varios accesos directos para obtener una documentación de objetos, propiedades e incluso código fuente. Por ejemplo, añadiendo un "?" a una función le dará la ayuda para el objeto (de hecho, un atajo para "help (obj)", cuando se utilicen dos? ''s (" func?? ") mostrará el código fuente si está disponible.

También hay una gran cantidad de comodidades adicionales, como la finalización de pestañas, una bonita impresión de resultados, el historial de resultados, etc. que lo hacen muy útil para este tipo de programación exploratoria.

Para un uso más programático de la introspección, las funciones básicas como dir() , vars() , getattr , etc. serán útiles, pero vale la pena su tiempo para revisar el módulo de inspect . Para obtener la fuente de una función, use " inspect.getsource ", por ejemplo, aplicándola a sí misma:

>>> print inspect.getsource(inspect.getsource)
def getsource(object):
    """Return the text of the source code for an object.

    The argument may be a module, class, method, function, traceback, frame,
    or code object.  The source code is returned as a single string.  An
    IOError is raised if the source code cannot be retrieved."""
    lines, lnum = getsourcelines(object)
    return string.join(lines, '''')

inspect.getargspec también suele ser útil si está tratando con funciones de inspect.getargspec o manipulación, ya que proporcionará los nombres y valores predeterminados de los parámetros de función.

Answer 16

Trate de usar:

print(object.stringify())

• donde object es el nombre de la variable del objeto que está intentando inspeccionar.

Esto imprime una salida bien formateada y con pestañas que muestra toda la jerarquía de claves y valores en el objeto.

NOTA: Esto funciona en python3. No estoy seguro si funciona en versiones anteriores.

Answer 17

pprint y dir juntos funcionan muy bien

Answer 18

vars (obj) devuelve los atributos de un objeto.

Answer 19

object.__dict__

Answer 20

"""Visit http://diveintopython.net/"""

__author__ = "Mark Pilgrim ([email protected])"


def info(object, spacing=10, collapse=1):
    """Print methods and doc strings.

    Takes module, class, list, dictionary, or string."""
    methodList = [e for e in dir(object) if callable(getattr(object, e))]
    processFunc = collapse and (lambda s: " ".join(s.split())) or (lambda s: s)
    print "/n".join(["%s %s" %
                     (method.ljust(spacing),
                      processFunc(str(getattr(object, method).__doc__)))
                     for method in methodList])

if __name__ == "__main__":
    print help.__doc__

Answer 21

import pprint

pprint.pprint(obj.__dict__)

o

pprint.pprint(vars(obj))