¿Hay una función integrada para imprimir todas las propiedades y valores actuales de un objeto?

Quieres vars() mezclado con pprint():

from pprint import pprint
pprint(vars(your_object))

def dump(obj):
  for attr in dir(obj):
    print("obj.%s = %r" % (attr, getattr(obj, attr)))

Hay muchas funciones de terceros que agregan cosas como el manejo de excepciones, la impresión de caracteres nacionales/especiales, la recursividad en objetos anidados, etc. según las preferencias de sus autores. Pero todos básicamente se reducen a esto.

dir ha sido mencionado, pero eso solo le dará los nombres de los atributos. Si quieres sus valores también prueba _ _ dict__.

class O:
   def __init__ (self):
      self.value = 3

o = O()

Aquí está la salida:

>>> o.__dict__

{'value': 3}

Para imprimir el estado actual del objeto es posible que:

>>> obj # in an interpreter

O

print repr(obj) # in a script

O

print obj

Para sus clases defina __str__ o __repr__ métodos. De la documentación de Python :

__repr__(self) Llamada por la función incorporada repr() y por cadena conversiones (cotizaciones inversas) a calcular la cadena" oficial" representación de un objeto. En todo caso posible, esto debería parecerse a un expresión válida de Python que podría ser utilizado para recrear un objeto con el mismo valor (dado un valor apropiado ambiente). Si esto no es posible, una cadena de la forma "<...algunos>" debe ser devuelto. El valor devuelto debe ser una cadena objeto. Si una clase define repr () pero no __str__(), entonces __repr__() es también se usa cuando una cadena" informal" representación de los casos de que se requiere clase. Esto es típicamente se utiliza para depurar, por lo que es importante que la representación es rica en información e inequívoca.

__str__(self) Llamada por la función incorporada str() y por la impresión declaración para calcular el " informal" representación de cadena de un objeto. Esto difiere de __repr__() en que no tiene que ser un Python válido expresión: un más conveniente o puede utilizarse una representación concisa en su lugar. El valor devuelto debe ser un objeto string.

Puede usar la función "dir()" para hacer esto.

>>> import sys
>>> dir(sys)
['__displayhook__', '__doc__', '__excepthook__', '__name__', '__stderr__', '__stdin__', '__stdo
t__', '_current_frames', '_getframe', 'api_version', 'argv', 'builtin_module_names', 'byteorder
, 'call_tracing', 'callstats', 'copyright', 'displayhook', 'dllhandle', 'exc_clear', 'exc_info'
 'exc_type', 'excepthook', 'exec_prefix', 'executable', 'exit', 'getcheckinterval', 'getdefault
ncoding', 'getfilesystemencoding', 'getrecursionlimit', 'getrefcount', 'getwindowsversion', 'he
version', 'maxint', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_
ache', 'platform', 'prefix', 'ps1', 'ps2', 'setcheckinterval', 'setprofile', 'setrecursionlimit
, 'settrace', 'stderr', 'stdin', 'stdout', 'subversion', 'version', 'version_info', 'warnoption
', 'winver']
>>>

Otra característica útil es la ayuda.

>>> help(sys)
Help on built-in module sys:

NAME
    sys

FILE
    (built-in)

MODULE DOCS
    http://www.python.org/doc/current/lib/module-sys.html

DESCRIPTION
    This module provides access to some objects used or maintained by the
    interpreter and to functions that interact strongly with the interpreter.

    Dynamic objects:

    argv -- command line arguments; argv[0] is the script pathname if known

Podría valer la pena echarle un vistazo {

¿Hay un Python equivalente a Data::Dumper de Perl?

Mi recomendación es esta {

Https://gist.github.com/1071857

Tenga en cuenta que perl tiene un módulo llamado Data::Dumper que traduce los datos del objeto de nuevo al código fuente de perl (NB: NO traduce el código de nuevo a la fuente, y casi siempre no desea que las funciones del método objeto en la salida). Esto se puede utilizar para la persistencia, pero el común el propósito es depurar.

Hay una serie de cosas que el estándar python pprint no logra, en particular, simplemente deja de descender cuando ve una instancia de un objeto y le da el puntero hexadecimal interno del objeto (errr, ese puntero no es un montón de uso por cierto). Así que en pocas palabras, Python es todo acerca de este gran paradigma orientado a objetos, pero las herramientas que se obtienen de la caja están diseñadas para trabajar con algo más que objetos.

El perl Data:: Dumper le permite controlar la profundidad que desea ir, y también detecta estructuras circulares vinculadas (eso es realmente importante). Este proceso es fundamentalmente más fácil de lograr en perl porque los objetos no tienen magia particular más allá de su bendición (un proceso universalmente bien definido).

En la mayoría de los casos, usando __dict__ o dir() obtendrá la información que desea. Si necesita más detalles, la biblioteca estándar incluye el módulo inspect, que le permite obtener una cantidad impresionante de detalles. Algunos de los verdaderos nuggests de información incluyen:

• nombres de parámetros de función y método
• jerarquías de clase
• código fuente de la implementación de un objeto functions/class
• variables locales fuera de un marco objeto

Si solo está buscando "¿qué valores de atributo tiene mi objeto?"entonces dir() y __dict__ son probablemente suficientes. Si realmente está buscando profundizar en el estado actual de los objetos arbitrarios (teniendo en cuenta que en python casi todo es un objeto), entonces inspect es digno de consideración.

Un ejemplo de metaprogramación Volcado de objeto con magia :

$ cat dump.py

#!/usr/bin/python
import sys
if len(sys.argv) > 2:
    module, metaklass  = sys.argv[1:3]
    m = __import__(module, globals(), locals(), [metaklass])
    __metaclass__ = getattr(m, metaklass)

class Data:
    def __init__(self):
        self.num = 38
        self.lst = ['a','b','c']
        self.str = 'spam'
    dumps   = lambda self: repr(self)
    __str__ = lambda self: self.dumps()

data = Data()
print data

Sin argumentos:

$ python dump.py

<__main__.Data instance at 0x00A052D8>

Con Gnosis Utils :

$ python dump.py gnosis.magic MetaXMLPickler

<?xml version="1.0"?>
<!DOCTYPE PyObject SYSTEM "PyObjects.dtd">
<PyObject module="__main__" class="Data" id="11038416">
<attr name="lst" type="list" id="11196136" >
  <item type="string" value="a" />
  <item type="string" value="b" />
  <item type="string" value="c" />
</attr>
<attr name="num" type="numeric" value="38" />
<attr name="str" type="string" value="spam" />
</PyObject>

Está un poco desactualizado pero sigue funcionando.

Si estás usando esto para depurar, y solo quieres un volcado recursivo de todo, la respuesta aceptada es insatisfactoria porque requiere que tus clases ya tengan buenas implementaciones __str__. Si ese no es el caso, esto funciona mucho mejor:

import json
print(json.dumps(YOUR_OBJECT, 
                 default=lambda obj: vars(obj),
                 indent=1))

Necesitaba imprimir información de DEPURACIÓN en algunos registros y no pude usar pprint porque lo rompería. En cambio, hice esto y obtuve prácticamente lo mismo.

DO = DemoObject()

itemDir = DO.__dict__

for i in itemDir:
    print '{0}  :  {1}'.format(i, itemDir[i])

Para volcar "myObject":

from bson import json_util
import json

print(json.dumps(myObject, default=json_util.default, sort_keys=True, indent=4, separators=(',', ': ')))

Probé vars() y dir(); ambos fallaron para lo que estaba buscando. vars () no funcionó porque el objeto no tenía __dict__ (excepciones.TypeError: el argumento vars () debe tener el atributo__ dict__). dir () no era lo que estaba buscando: es solo una lista de nombres de campos, no da los valores o la estructura del objeto.

Creo que json.dumps () funcionaría para la mayoría de los objetos sin el valor predeterminado=json_util.por defecto, pero tenía un campo datetime en el objeto por lo que el serializador json estándar falló. Ver Cómo superar "datetime.datetime not JSON serializable " en python?

from pprint import pprint

def print_r(the_object):
    print ("CLASS: ", the_object.__class__.__name__, " (BASE CLASS: ", the_object.__class__.__bases__,")")
    pprint(vars(the_object))

Esto imprime todo el contenido del objeto recursivamente en formato json o yaml con sangría:

import jsonpickle # pip install jsonpickle
import json
import yaml # pip install pyyaml

serialized = jsonpickle.encode(obj, max_depth=2) # max_depth is optional
print json.dumps(json.loads(serialized), indent=4)
print yaml.dump(yaml.load(serialized), indent=4)

Solo prueba beeprint.

No solo le ayudará a imprimir variables de objeto, sino también una salida hermosa, como esta:

class(NormalClassNewStyle):
  dicts: {
  },
  lists: [],
  static_props: 1,
  tupl: (1, 2)

Pprint contiene una "impresora bonita" para producir representaciones estéticamente agradables de sus estructuras de datos. El formateador produce representaciones de estructuras de datos que pueden ser analizadas correctamente por el intérprete, y también son fáciles de leer para un humano. La salida se mantiene en una sola línea, si es posible, y se sangra cuando se divide en varias líneas.

Try 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(), show_protected=True, show_static=True, show_properties=True)

Salida:

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

¿Por qué no algo simple:

for key,value in obj.__dict__.iteritems():
    print key,value

He votado a favor de la respuesta que menciona solo ppr. Para ser claros, si desea ver todos los valores en una estructura de datos compleja, haga algo como:

from pprint import pprint
pprint(my_var)

Donde my_var es su variable de interés. Cuando usé pprint(vars (my_var)) no obtuve nada, y otras respuestas aquí no ayudaron o el método parecía innecesariamente largo. Por cierto, en mi caso particular, el código que estaba inspeccionando tenía un diccionario de diccionarios.

Vale la pena señalar que con algunas clases personalizadas pueden terminar con un tipo de salida <someobject.ExampleClass object at 0x7f739267f400> poco útil. En ese caso, es posible que tenga que implementar un método __str__, o probar algunas de las otras soluciones. Todavía me gustaría encontrar algo simple que funcione en todos los escenarios, sin bibliotecas de terceros.

Puede probar la barra de herramientas de depuración de Flask.
https://pypi.python.org/pypi/Flask-DebugToolbar

from flask import Flask
from flask_debugtoolbar import DebugToolbarExtension

app = Flask(__name__)

# the toolbar is only enabled in debug mode:
app.debug = True

# set a 'SECRET_KEY' to enable the Flask session cookies
app.config['SECRET_KEY'] = '<replace with a secret key>'

toolbar = DebugToolbarExtension(app)

Me gusta trabajar con tipos incorporados de objetos python claves o valores.

Para atributos independientemente de que sean métodos o variables:

o.keys()

Para los valores de esos atributos:

o.values()

Para todos los que luchan con

• vars() no devuelve todos los atributos.
• dir() no devuelve los valores de los atributos.

El siguiente código imprime todos los atributos de obj con sus valores:

for attr in dir(obj):
        try:
            print("obj.{} = {}".format(attr, getattr(obj, attr)))
        except AttributeError:
            print("obj.{} = ?".format(attr))