Deci, ceea ce am'caut aici este ceva de genul PHP's print_r funcție. Acest lucru este așa că am putea depana scenariile mele de a vedea ce's starea obiectului în cauză.
Vrei vars()amestecat cu pprint()
:
from pprint import pprint
pprint(vars(your_object))
Sunteți într-adevăr de amestecare împreună două lucruri diferite.
Folosi dir()
, vars()
sau inspecta
modul de a obține ceea ce vă interesează (eu folosesc __builtins__
ca un exemplu; puteți folosi orice obiect în loc).
>>> l = dir(__builtins__)
>>> d = __builtins__.__dict__
Imprimare asta dicționar cu toate acestea place de tine, cum ar fi:
>>> print l
['ArithmeticError', 'AssertionError', 'AttributeError',...
sau
>>> 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',
...
Destul de imprimare este, de asemenea, disponibil în debugger interactiv ca o comandă:
(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__'}
def dump(obj):
for attr in dir(obj):
print("obj.%s = %r" % (attr, getattr(obj, attr)))
Există multe 3rd-party funcții de acolo, care adăugați lucruri cum ar fi manipulare excepție, naționale/speciale de caractere de imprimare, recursing în obiecte imbricate etc. potrivit autorilor lor' preferințe. Dar toate acestea, practic se reduce la asta.
dir a fost menționat, dar care'll vă dau doar atributele' nume. Dacă doriți valorile lor, precum și să încerce __dict__.
class O:
def __init__ (self):
self.value = 3
o = O()
Aici este rezultatul:
>>> o.__dict__
{'value': 3}
Puteți utiliza "dir()" funcție pentru a face acest lucru.
>>> 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']
>>>
O altă caracteristică utilă este de ajutor.
>>> 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
Să tipăriți starea curentă a obiectului s-ar putea:
>>> obj # in an interpreter
sau
print repr(obj) # in a script
sau
print obj
Pentru clase defini __str__ " sau " __repr__
metode. De Python documentația:
__repr__(self) Numit de către
repr()built-in funcție și de string conversii (reverse ghilimele) pentru a calcula "oficial" string reprezentare a unui obiect. Dacă la toate este posibil, aceasta ar trebui să arate ca un expresie validă în Python, care ar putea fi folosit pentru a recrea un obiect cu aceeași valoare (având în vedere un caz mediu). Dacă acest lucru nu este posibil, un șir de caractere de forma "<...unele utile descriere...>" ar trebui să fie returnate. valoarea returnată trebuie să fie un șir de caractere obiect. Dacă o clasă definește __repr__() dar nu
str ()", apoi " repr()` este de asemenea, utilizat atunci când un "informale" string reprezentare de instanțele de clasa este necesar. Acest lucru este de obicei folosit pentru depanare, de aceea este important că reprezentarea este informații bogate și lipsite de ambiguitate.
__str__(self) Numit de către
str()built-in funcție și de imprimare declarație pentru a calcula "informale" string reprezentare a unui obiect. Aceasta diferă de la__repr__()
în care aceasta nu trebuie să fie validă, Python expresie: o mai convenabil sau concis reprezentare poate fi folosit în loc. Valoarea returnată trebuie să fie un obiect string.
Ar putea fi în valoare de verificat --
https://stackoverflow.com/questions/2540567/is-there-a-python-equivalent-to-perls-datadumper
Recomandarea mea este asta ...
https://gist.github.com/1071857
Rețineți că perl are un modul numit Date::Autobasculantă care se traduce obiect date înapoi la perl codul sursă (NB: asta NU se traduce codul înapoi la sursă, și aproape întotdeauna nu't doriți să obiectului metoda funcțiilor de ieșire). Acest lucru poate fi folosit pentru insistenta, dar scopul comun este pentru depanare.
Există o serie de lucruri standard python pprint nu reușește să realizeze, în special, se oprește descrescătoare atunci când vede o instanță a unui obiect și vă oferă interne hex pointer de obiect (errr, că indicatorul nu este o mulțime de utilizare de altfel). Deci, într-un cuvânt, python este totul despre acest mare orientat obiect paradigmă, dar instrumentele de care aveți iesi din cutie sunt concepute pentru a lucra cu altceva decât obiecte.
Perl Date::Autobasculantă vă permite să controlați cât de adânc vrei să mergi, și, de asemenea, detectează circulare legate de structuri (ca'e foarte important). Acest proces este fundamental mai ușor pentru a obține în perl pentru că obiectele nu au nici o anumită magie dincolo de binecuvântarea lor (universal bine definite proces).
În cele mai multe cazuri, folosind __dict__ " sau " dir()
veți obține informațiile de care aveți're doresc. Dacă se întâmplă să nevoie de mai multe detalii, biblioteca standard include inspecta modul, care vă permite pentru a obține un volum impresionant de detaliu. Unele dintre real nuggests de informații includ:
Daca're în căutarea doar pentru "ce valori de atribute face obiectul meu avea?", apoi dir () " și " __dict__
sunt probabil suficiente. Daca're într-adevăr în căutarea de a săpa în starea actuală de obiecte arbitrare (ținând cont de faptul că în python aproape totul este un obiect), apoi inspecta` este demn de luat în considerare.
Un metaprogram exemplu Basculante obiect cu magie:
$ 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
Fără argumente:
$ python dump.py<__main__.Date de exemplu la 0x00A052D8>
Cu Gnoza Utils:
$ python dump.py gnoza.magic MetaXMLPickler<?xml version="1.0"?>
Este un pic învechit, dar încă de lucru.
Am recomandăm să utilizați ajutor(your_object)`.
ajuta(dir)
Dacă sunat fara un argument, pentru a reveni numele în aplicare actual. Altfel, întoarce-o listă alfabetică de numele cuprinde (unele dintre) atributele de obiectul dat, și de atribute poate ajunge la ea. în Cazul în care obiectul furnizează o metodă numită dir, care va fi folosit; în caz contrar implicit dir() logica este folosit și se întoarce: pentru un modul obiect: modul's atribute. pentru un obiect de clasă: atributele sale, și recursiv atributele de bazele sale. pentru orice alt obiect: atributele sale, clasa sa's atribute, și recursiv atributele din clasa sa's clase de bază.
ajuta(vars)
Fără argumente, echivalent cu localnicii(). Cu un argument, echivalent a obiectului.dict.
Acest lucru imprimă tot conținutul obiect recursiv în json sau yaml indentat format:
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)
Daca're folosind acest lucru pentru depanare, și vrei doar un recursiv basculante de tot, acceptat răspunsul este nesatisfăcător, deoarece necesită orele au bun __str__
implementări deja. Dacă asta's nu este cazul, acest lucru funcționează mult mai bine:
import json
print(json.dumps(YOUR_OBJECT,
default=lambda obj: vars(obj),
indent=1))
Încerca 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)
Ieșire:
__main__.A(_p = 8, foo = [0, 1, ..., 8, 9], s = 5)
Am'am upvoted răspunsul care menționează doar pprint. Să fie clar, dacă vrei să vezi toate valori într-o complexă structură de date, apoi fac ceva de genul:
from pprint import pprint
pprint(my_var)
Unde my_var este variabila de interes. Atunci când am folosit `pprint(vars(my_var)) am primit nimic, și alte răspunsuri aici am't ajuta sau metoda uitat inutil de lung. Apropo, în cazul meu particular, codul nu a fost inspectarea avut un dicționar de dicționare.
Merită subliniat faptul că, cu unele cursuri personalizate poate doar cu o nefolositoare <someobject.ExampleClass obiect la 0x7f739267f400>
un fel de ieșire. În acest caz, s-ar putea să pună în aplicare o __str__
metoda, sau încercați unele din alte solutii. Am'd tot ca să găsească ceva simplu, care funcționează în toate scenariile, fără biblioteci terțe.
Am fost nevoie pentru a imprima informații de DEBUG în niște bușteni și a fost în imposibilitatea de a utiliza pprint pentru că s-ar rupe. În schimb am făcut acest lucru și a fost, practic, același lucru.
DO = DemoObject()
itemDir = DO.__dict__
for i in itemDir:
print '{0} : {1}'.format(i, itemDir[i])
La groapa de gunoi "myObject":
from bson import json_util
import json
print(json.dumps(myObject, default=json_util.default, sort_keys=True, indent=4, separators=(',', ': ')))
Am încercat vars() și dir(); ambele nu a reușit pentru ceea ce am fost în căutarea pentru. vars() am't de lucru pentru că obiectul nu't au __dict (excepții.TypeError: vars() argument trebuie să aibă \dict__ atribut). dir() nu't ceea ce am fost în căutarea pentru: it's doar o listă de nume de câmpuri, nu't da valorile sau structura de obiect.
Cred json.haldele() va lucra pentru cele mai multe obiecte fără default=json_util.default,, dar am avut o datetime domeniul în obiect atât standard json serializer nu a reușit. Vezi https://stackoverflow.com/questions/11875770/how-to-overcome-datetime-datetime-not-json-serializable-in-python
Doar încercați să - beeprint.
Acesta vă va ajuta nu numai cu imprimare variabile obiect, dar frumoasă ieșire la fel de bine, ca aceasta:
class(NormalClassNewStyle):
dicts: {
},
lists: [],
static_props: 1,
tupl: (1, 2)
pprint conține o "destul de imprimantă" pentru producerea punct de vedere estetic reprezentări de structuri de date. Formator produce reprezentări de structuri de date care pot fi analizate în mod corect de către interpret, și sunt, de asemenea, ușor pentru un om să citească. De ieșire este menținută pe o singură linie, dacă este posibil, și alin când împărțiți pe mai multe linii.