Existe um built-in função para imprimir todas as propriedades atuais e os valores de um objeto?

Question

Então, o que eu estou procurando aqui é algo como href="http://us2.php.net/print_r" rel="noreferrer"> print_r função do PHP. Isso é para que eu possa depurar meus scripts, vendo qual é o estado do objeto em questão.

Answer 1

Você está realmente misturando duas coisas diferentes.

Use dir() , vars() ou o inspect módulo para conseguir o que você está interessado em (eu uso __builtins__ como um exemplo, você pode usar qualquer objeto em seu lugar).

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

Imprimir que dicionário entanto fantasia você gosta:

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

ou

>>> 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',
...

impressão bonita também é disponível no depurador interativo como um 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

Você quer vars() misturado com 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)))

Existem muitas funções 3-parte lá fora, que adicionam coisas como tratamento de exceção, impressão caráter nacional / especial, recursivo em objetos aninhados etc acordo com as preferências de seus autores. Mas eles todos basicamente se resumem a isso.

Answer 4

dir tem sido mencionado, mas que só vai dar-lhe os nomes dos atributos. Se você quiser seus valores também tentar __dict __.

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

o = O()

Aqui está a saída:

>>> o.__dict__

{'value': 3}

Answer 5

Para imprimir o estado atual do objeto que você pode:

>>> obj # in an interpreter

ou

print repr(obj) # in a script

ou

print obj

Para suas classes definir métodos __str__ ou __repr__. Do Python documentação :

__repr__(self) Chamado pelo repr() built-in função e por corda conversões (citações reversa) para calcular a string "oficial" representação de um objecto. Se em tudo possível, isso deve parecer um expressão Python válido que poderia ser utilizado para recriar um objecto com o mesmo valor (dado um adequado meio Ambiente). Se isso não for possível, uma corda da forma "<... alguns útil descrição ...>" deve ser devolvido. O valor de retorno deve ser uma string objeto. Se uma classe define repr () mas não __str__(), então __repr__() é Também usado quando um "informal" string representação de instâncias de que classe é necessária. Este é tipicamente usado para depuração, por isso é importante que é a representação Rico em informações e inequívoca.

__str__(self) Chamado pelo str() built-in função e pela impressão declaração para calcular a "informal" representação de um objecto. Isso difere do __repr__() em que ele não tem que ser um Python válida expressão: a mais conveniente ou representação concisa podem ser utilizados em vez de. O valor de retorno deve ser um string de objeto.

Answer 6

Você pode usar o "dir ()" função para fazer isso.

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

Outro recurso útil é de ajuda.

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

Pode ser vale a pena conferir -

Existe uma Python equivalente a do Perl Data :: Dumper

A minha recomendação é esta -

https://gist.github.com/1071857

Note que perl tem um módulo chamado Data :: Dumper que se traduz dados de volta objeto para o código-fonte perl (NB: não traduzir código de volta para a fonte, e quase sempre você não quer as funções de método de objeto no resultado). Isso pode ser usado para persistência, mas o objetivo comum é para depuração.

Há uma série de coisas python padrão pprint não consegue atingir, em especial, ele simplesmente pára descendente quando vê uma instância de um objeto e dá-lhe o ponteiro hex interno do objeto (errr, esse ponteiro não é um lote inteiro de uso pela maneira). Assim, em poucas palavras, python é tudo sobre este grande orientada a objeto paradigma, mas as ferramentas que você começa fora da caixa são projetados para trabalhar com algo diferente de objetos.

O perl Data :: Dumper permite controlar quão profundo você quer ir, e também detecta estruturas ligadas circulares (que é realmente importante). Este processo é fundamentalmente mais fácil de conseguir em perl porque os objetos não têm nenhuma mágica especial além de sua bênção (um processo universalmente bem definido).

Answer 8

Na maioria dos casos, usando __dict__ ou dir() você vai ter a informação que você está querendo. Se por acaso você precisar de mais detalhes, a biblioteca padrão inclui a inspecionar módulo, que permite obter alguma quantidade impressionante de detalhes. Alguns dos nuggests reais de informação incluem:

• nomes dos parâmetros da função e método
• hierarquias de classe
• código fonte da implementação de uma série de funções / class objetos
• variáveis ??locais fora de um objeto de quadro

Se você está apenas procurando "o que valores atributo que meu objeto tem?", Então dir() e __dict__ são provavelmente suficientes. Se você está procurando realmente a cavar o estado atual de objetos arbitrários (tendo em mente que em python quase tudo é um objeto), então inspect é digno de consideração.

Answer 9

Um exemplo metaprogramming objeto Dump com mágica:

$ 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

Sem argumentos:

$ python dump.py

<__main__.Data instance at 0x00A052D8>

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

É um pouco desatualizado, mas ainda funcionando.

Answer 10

Se você estiver usando este para depuração, e você só quer um despejo recursiva de tudo, a resposta aceita é insatisfatória porque requer que suas aulas têm boas implementações __str__ já. Se isso não for o caso, isso funciona muito melhor:

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

Answer 11

Isso mostra todo o conteúdo do objeto de forma recursiva em JSON ou yaml formato recuado:

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

Eu recomendo 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

Eu estava precisando para imprimir informações de depuração em alguns troncos e era incapaz de usar pprint porque iria quebrá-lo. Em vez eu fiz isso e tem praticamente a mesma coisa.

DO = DemoObject()

itemDir = DO.__dict__

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

Answer 14

Para despejar "myObject":

from bson import json_util
import json

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

Eu tentei vars () e dir (); ambos falharam para o que eu estava procurando. vars () não funcionou porque o objeto não tinha __dict__ (exceptions.TypeError: argumento vars () deve ter __dict__ atributo). dir () não era o que eu estava procurando:. é apenas uma lista de nomes de campos, não dá os valores ou a estrutura do objeto

Eu acho json.dumps () iria funcionar para a maioria dos objetos sem o default = json_util.default, mas eu tinha um campo de data e hora no objeto para o serializador JSON padrão falhou. Consulte Como superar "datetime.datetime não JSON serializado" em 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

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

Output:

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

Answer 17

pprint contém uma “impressora bonito” para a produção de representações esteticamente agradável de suas estruturas de dados. O formatador produz representações de estruturas de dados que podem ser analisados ??corretamente pelo intérprete, e são também fácil para um ser humano para ler. A saída é mantido em uma única linha, se possível, e recuado quando dividida em várias linhas.

Answer 18

Por que não algo simples:

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

Answer 19

Eu upvoted a resposta que menciona apenas pprint. Para ser claro, se você quiser ver todo o valores em uma complexa estrutura de dados, em seguida, fazer algo como:

from pprint import pprint
pprint(my_var)

Onde my_var é a variável de interesse. Quando eu usei pprint (VARs (my_var)) Eu não tenho nada, e outras respostas aqui não ajudou ou o método parecia desnecessariamente longo. By the way, no meu caso particular, o código que eu estava inspecionando teve um dicionário de dicionários.

Vale destacar que, com algumas classes personalizadas que você pode acabar com um tipo <someobject.ExampleClass object at 0x7f739267f400> inútil de saída. Nesse caso, você pode ter que implementar um método __str__, ou tentar algumas das outras soluções. Eu ainda gostaria de encontrar algo simples que funciona em todos os cenários, sem bibliotecas de terceiros.

Answer 20

Apenas tente beeprint .

Ele irá ajudá-lo não apenas com a impressão de variáveis ??de objeto, mas de saída bonito como bem, como este:

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

Answer 21

Para todos lutando com

• vars() não retornar todos os atributos.
• dir() não retornando os valores dos atributos.

O código a seguir imprime todas atributos de obj com seus valores:

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

Answer 22

Você pode tentar o Debug Toolbar 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)

Answer 23

Eu gosto de trabalhar com objeto python tipos built-in chaves ou valores .

Para atributos independentemente são métodos ou variáveis:

o.keys()

Para valores desses atributos:

o.values()