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

Question

Así que lo que estoy buscando aquí es algo parecido a PHP print_r la función.Esto es así ya que depurar mis scripts por ver cuál es el estado del objeto en cuestión.

Answer 1

Realmente estás mezclando dos cosas diferentes.

Use dir() , vars() o el inspect módulo para obtener lo que le interesa (yo uso __builtins__ como ejemplo; puede usar cualquier objeto en su lugar).

>>> l = dir(__builtins__)
>>> d = __builtins__.__dict__

Imprime ese diccionario como quieras:

>>> print l
['ArithmeticError', 'AssertionError', 'AttributeError',...

o

>>> from pprint import pprint
>>> pprint(l)
['ArithmeticError',
 'AssertionError',
 'AttributeError',
 'BaseException',
 'DeprecationWarning',
...

>>> pprint(d, indent=2)
{ 'ArithmeticError': <type 'exceptions.ArithmeticError'>,
  'AssertionError': <type 'exceptions.AssertionError'>,
  'AttributeError': <type 'exceptions.AttributeError'>,
...
  '_': [ 'ArithmeticError',
         'AssertionError',
         'AttributeError',
         'BaseException',
         'DeprecationWarning',
...

La impresión bonita también está disponible en el depurador interactivo como un comando:

(Pdb) pp vars()
{'__builtins__': {'ArithmeticError': <type 'exceptions.ArithmeticError'>,
                  'AssertionError': <type 'exceptions.AssertionError'>,
                  'AttributeError': <type 'exceptions.AttributeError'>,
                  'BaseException': <type 'exceptions.BaseException'>,
                  'BufferError': <type 'exceptions.BufferError'>,
                  ...
                  'zip': <built-in function zip>},
 '__file__': 'pass.py',
 '__name__': '__main__'}

Answer 2

Desea vars() mezclado con pprint():

from pprint import pprint
pprint(vars(your_object))

Answer 3

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

Existen muchas funciones de terceros que añaden cosas como el manejo de excepciones, la impresión de caracteres nacionales / especiales, el recursivo en objetos anidados, etc., de acuerdo con las preferencias de sus autores. Pero todos básicamente se reducen a esto.

Answer 4

Se ha mencionado

dir , pero eso solo le dará los nombres de los atributos. Si también quieres sus valores, prueba __dict__.

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

o = O()

Aquí está el resultado:

>>> o.__dict__

{'value': 3}

Answer 5

Para imprimir el estado actual del objeto, usted puede:

>>> obj # in an interpreter

o

print repr(obj) # in a script

o

print obj

Para sus clases de definir __str__ o __repr__ métodos.A partir de la Documentación de Python:

__repr__(self) Llamado por el repr() construido-en la función y por la cadena de conversiones (inversa comillas simples) calcular el "oficial" de la cadena la representación de un objeto.Si en todos los es posible, esto debe verse como una válida para Python expresión que podría ser se utiliza para recrear un objeto con el mismo valor (dado un adecuado medio ambiente).Si esto no es posible, una cadena de la forma "<...útil descripción de la...>" debe ser devuelto.El valor de retorno debe ser una cadena objeto.Si una clase se define repr() pero no __str__(), a continuación, __repr__() es también se utiliza cuando un "informal" de la cadena la representación de los casos en los que la clase necesaria.Normalmente, esto se se utiliza para la depuración, por lo que es importante que la representación es información rica y sin ambigüedades.

__str__(self) Llamado por el str() construido-en la función y por la impresión instrucción para el cálculo de la "informal" representación de cadena de un objeto.Esto difiere de __repr__() en que no tiene que ser válida para Python expresión:más conveniente, o representación concisa puede ser utilizado en su lugar.El valor devuelto debe ser un objeto string.

Answer 6

Puede usar " dir () " función 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

Answer 7

Podría valer la pena echarle un vistazo -

¿Hay un Python equivalente a los datos de Perl :: Dumper?

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 nuevamente a la fuente, y casi siempre no desea que las funciones del método del objeto en el salida). Esto se puede usar para persistencia, pero el propósito común es la depuración.

Hay una serie de cosas que el pprint estándar de Python 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 mucho de uso por cierto). En pocas palabras, python tiene que ver con este gran paradigma orientado a objetos, pero las herramientas que obtiene de la caja están diseñadas para trabajar con algo que no sean objetos.

El Perl Data :: Dumper le permite controlar qué tan profundo quiere llegar, 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).

Answer 8

En la mayoría de los casos, el uso de __dict__ o dir() va a llegar la info estás queriendo.Si llegara a necesitar más detalles, la biblioteca estándar incluye el inspeccionar el módulo, que le permite obtener algunas impresionante cantidad de detalles.Algunos de los verdaderos nuggests de información incluyen:

• los nombres de función y los parámetros del método
• jerarquías de clases
• el código fuente de la aplicación de una de las funciones/objetos de la clase
• las variables locales de un marco de objeto

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

Answer 9

Un ejemplo de metaprogramación Volcar 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.

Answer 10

Si está usando esto para depurar, y solo quiere un volcado recursivo de todo, la respuesta aceptada es insatisfactoria porque requiere que sus 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))

Answer 11

Esto imprime todo el contenido del objeto de forma recursiva en formato sangrado json o yaml:

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)

Answer 12

Recomiendo usar help(your_object).

help(dir)

 If called without an argument, return the names in the current scope.
 Else, return an alphabetized list of names comprising (some of) the attributes
 of the given object, and of attributes reachable from it.
 If the object supplies a method named __dir__, it will be used; otherwise
 the default dir() logic is used and returns:
 for a module object: the module's attributes.
 for a class object:  its attributes, and recursively the attributes
 of its bases.
 for any other object: its attributes, its class's attributes, and
 recursively the attributes of its class's base classes.

help(vars)

Without arguments, equivalent to locals().
With an argument, equivalent to object.__dict__.

Answer 13

Necesitaba imprimir información de DEPURACIÓN en algunos registros y no pude usar pprint porque la 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])

Answer 14

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 por 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 campo, 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.default, pero tenía un campo de fecha y hora en el objeto, por lo que el serializador json estándar falló. Consulte Cómo superar & Quot; datetime.datetime no JSON serializable " en python?

Answer 15

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

Answer 16

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

Answer 17

pprint contiene un & # 8220; impresora bonita < !> # 8221; para producir representaciones estéticamente agradables de sus estructuras de datos. El formateador produce representaciones de estructuras de datos que el intérprete puede analizar correctamente, 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.

Answer 18

¿Por qué no algo simple?

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

Answer 19

He votado a favor la respuesta que menciona solo pprint. 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 puede terminar con un tipo de salida <someobject.ExampleClass object at 0x7f739267f400> inútil. En ese caso, es posible que deba 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.

Answer 20

Simplemente intente beeprint .

Le ayudará no solo a imprimir variables de objeto, sino también a resultados hermosos, como este:

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

Answer 21

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

Answer 22

Puede probar la barra de herramientas de depuración de frascos.
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)

Answer 23

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

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

o.keys()

Para valores de esos atributos:

o.values()