Czy istnieje wbudowana funkcja do drukowania wszystkich aktualnych właściwości i wartości obiektu?

Chcesz vars() zmieszać z 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)))

Istnieje wiele funkcji zewnętrznych, które dodają takie rzeczy jak obsługa wyjątków, drukowanie znaków narodowych/specjalnych, rekurencje do zagnieżdżonych obiektów itp. zgodnie z preferencjami ich autorów. Ale wszystko sprowadza się do tego.

dir został wymieniony, ale to da Ci tylko nazwy atrybutów. Jeśli chcesz ich wartości, spróbuj __dict__.

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

o = O()

Oto wyjście:

>>> o.__dict__

{'value': 3}

Aby wyświetlić aktualny stan obiektu, możesz:

>>> obj # in an interpreter

Lub

print repr(obj) # in a script

Lub

print obj

Dla klas zdefiniuj __str__ lub __repr__ metody. Z dokumentacji Pythona :

__repr__(self) wywołane przez wbudowaną funkcję repr() oraz przez łańcuch konwersje (odwrotne cudzysłowy) do Oblicz ciąg" oficjalny" reprezentacja obiektu. Jeśli w ogóle możliwe, powinno to wyglądać jak poprawne wyrażenie Pythona, które może być używane do odtworzyć obiekt z tej samej wartości (biorąc pod uwagę odpowiednią środowiska). Jeśli nie jest to możliwe, ciąg postaci"<...niekt> "należy zwrócić. Zwracana wartość musi być ciągiem znaków obiekt. Jeśli klasa definiuje repr () ale nie __str__(), to __repr__() jest używany również, gdy ciąg" nieformalny" reprezentacja tego wymagana jest klasa. Jest to zazwyczaj używany do debugowania, dlatego ważne jest że reprezentacja jest bogate i jednoznaczne informacje.

__str__(self) wywołane przez wbudowaną funkcję str() oraz przez print oświadczenie do obliczenia " Nieformalnego" string reprezentacja obiektu. Różni się to od __repr__() tym, że nie musi to być poprawny Python wyrażenie: wygodniejszy lub można użyć zwięzłej reprezentacji zamiast tego. Zwracana wartość musi być obiekt typu string.

Możesz użyć funkcji " dir ()", aby to zrobić.

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

Kolejną przydatną funkcją jest pomoc.

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

Może warto sprawdzić --

Czy istnieje Python równoważny do danych::Dumper Perla?

Moja rekomendacja jest taka --

Https://gist.github.com/1071857

Zauważ, że perl ma moduł o nazwie Data:: Dumper, który tłumaczy dane obiektowe z powrotem na kod źródłowy Perla(NB: Nie tłumaczy kodu z powrotem na źródło i prawie zawsze nie chcesz, aby metoda obiektowa funkcjonowała na wyjściu). Można to wykorzystać do wytrwałości, ale często służy do debugowania.

Jest wiele rzeczy, których standardowy python pprint nie jest w stanie osiągnąć, w szczególności po prostu przestaje malować, gdy widzi instancję obiektu i daje wewnętrzny wskaźnik szesnastkowy obiektu(errr, ten wskaźnik nie jest zbyt duży). Tak więc w skrócie, python polega na tym wspaniałym paradygmacie zorientowanym obiektowo, ale narzędzia, które wyjmujesz z pudełka, są zaprojektowane do pracy z czymś innym niż obiekty.

Perl Data:: Dumper pozwala kontrolować, jak głęboko chcesz iść, a także wykrywa okrągłe struktury połączone (to naprawdę ważne). Proces ten jest zasadniczo łatwiejszy do osiągnięcia w Perlu, ponieważ obiekty nie mają szczególnej magii poza swoim błogosławieństwem (powszechnie dobrze zdefiniowany proces).

W większości przypadków użycie __dict__ LUB dir() zapewni Ci informacje, których potrzebujesz. Jeśli potrzebujesz więcej szczegółów, biblioteka Standardowa zawiera moduł inspect , który pozwala uzyskać imponującą ilość szczegółów. Niektóre z prawdziwych nuggestów info to:

• nazwy funkcji i parametrów metody
• hierarchie klas
• kod źródłowy implementacji obiektów funkcji / klasy
• zmienne lokalne poza ramką obiekt

Jeśli szukasz "jakie wartości atrybutów ma mój obiekt?", wtedy dir() i __dict__ są prawdopodobnie wystarczające. Jeśli naprawdę chcesz zagłębić się w aktualny stan arbitralnych obiektów (pamiętając, że w Pythonie prawie wszystko jest obiektem), To inspect jest godne uwagi.

Przykład metaprogramowania zrzutu obiektu za pomocą magii :

$ 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

Bez argumentów:

$ python dump.py

<__main__.Data instance at 0x00A052D8>

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

Jest trochę przestarzały, ale nadal działa.

Jeśli używasz tego do debugowania i chcesz tylko rekurencyjnego zrzutu wszystkiego, zaakceptowana odpowiedź jest niezadowalająca, ponieważ wymaga, aby Twoje klasy miały już dobre implementacje {1]}. Jeśli tak nie jest, to działa znacznie lepiej:

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

Musiałem wydrukować informacje o debugowaniu w niektórych logach i nie mogłem użyć pprint, ponieważ to by go złamało. Zamiast tego zrobiłem to i dostałem praktycznie to samo.

DO = DemoObject()

itemDir = DO.__dict__

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

Aby zrzucić "myObject":

from bson import json_util
import json

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

Próbowałem vars () i dir (); oba zawiodły dla tego, czego szukałem. Vars () nie działa, ponieważ obiekt nie miał __dict__ (wyjątki.TypeError: Vars () argument musi mieć atrybut__ dict__). dir() nie było tym, czego szukałem: to tylko lista nazw pól, nie podaje wartości ani struktury obiektu.

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

Wypisuje rekurencyjnie całą zawartość obiektu w formacie JSON lub 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)

Po prostu spróbuj beeprint .

Pomoże Ci to nie tylko w drukowaniu zmiennych obiektu, ale także w pięknym wyjściu, jak to:

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

Pprint zawiera "ładną drukarkę" do tworzenia estetycznych reprezentacji struktur danych. Formatator tworzy reprezentacje struktur danych, które mogą być poprawnie parsowane przez interpreter, a także są łatwe do odczytania przez człowieka. Wyjście jest utrzymywane w pojedynczej linii, jeśli to możliwe, i wcięte po podzieleniu na wiele linii.

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)

Wyjście:

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

Dlaczego nie coś prostego:

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

Podniosłem odpowiedź, która mówi tylko o pprint. Aby było jasne, jeśli chcesz zobaczyć wszystkie wartości w złożonej strukturze danych, zrób coś w stylu:

from pprint import pprint
pprint(my_var)

Gdzie my_var jest twoją zmienną zainteresowania. Kiedy użyłem pprint(vars (my_var)) nic nie dostałem, a inne odpowiedzi tutaj nie pomogły lub metoda wyglądała niepotrzebnie długo. Przy okazji, w moim konkretnym przypadku kod, który sprawdzałem, miał słownik słowników.

Warto zwrócić uwagę, że z niektóre niestandardowe klasy mogą po prostu skończyć się nieprzydatnym wyjściem <someobject.ExampleClass object at 0x7f739267f400>. W takim przypadku może być konieczne zaimplementowanie metody __str__ lub wypróbowanie innych rozwiązań. Nadal chciałbym znaleźć coś prostego, który działa we wszystkich scenariuszach, bez bibliotek stron trzecich.

Możesz wypróbować Pasek debugowania 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)

Lubię pracować z obiektami Pythona wbudowanymi w typy kluczelub wartości .

Dla atrybutów niezależnie od tego, czy są to metody czy zmienne:

o.keys()

Dla wartości tych atrybutów:

o.values()

Dla wszystkich zmagających się z

• vars() nie zwracanie wszystkich atrybutów.
• dir() nie zwracanie wartości atrybutów.

Następujący kod drukuje wszystkie atrybuty obj wraz z ich wartościami:

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