Wie schaue ich in ein Python-Objekt?

Ich fange an, in verschiedenen Projekten mit Python zu programmieren (einschließlich Django-Webentwicklung und Panda3D-Spieleentwicklung).

Um zu verstehen, was los ist, möchte ich im Grunde genommen in die Python-Objekte schauen, um zu sehen, wie sie ticken - wie ihre Methoden und Eigenschaften.

Angenommen, ich habe ein Python-Objekt. Was würde ich benötigen, um dessen Inhalt auszudrucken? Ist das überhaupt möglich?

Python verfügt über zahlreiche Funktionen zur Selbstbeobachtung.

Sehen Sie sich die folgenden integrierten Funktionen an :

• type()
• dir()
• id()
• getattr()
• hasattr()
• globals()
• locals()
• callable()

type()und dir()sind besonders nützlich, um den Typ eines Objekts bzw. seinen Satz von Attributen zu untersuchen.

object.__dict__

Lesen Sie zuerst die Quelle.

Zweitens verwenden Sie die dir()Funktion.

Ich bin überrascht, dass noch niemand die Hilfe erwähnt hat!

In [1]: def foo():
   ...:     "foo!"
   ...:

In [2]: help(foo)
Help on function foo in module __main__:

foo()
    foo!

Mithilfe der Hilfe können Sie die Dokumentzeichenfolge lesen und sich ein Bild davon machen, welche Attribute eine Klasse möglicherweise hat. Dies ist sehr hilfreich.

Wenn dies zur Erkundung dient, um zu sehen, was los ist, würde ich empfehlen, sich IPython anzusehen . Dadurch werden verschiedene Verknüpfungen hinzugefügt, um eine Objektdokumentation, Eigenschaften und sogar Quellcode zu erhalten. Zum Beispiel ein "?" zu einer Funktion gibt die Hilfe für das Objekt (effektiv eine Verknüpfung für "Hilfe (obj)", wobei bei Verwendung von zwei? 's (" func??") der Quellcode angezeigt wird, wenn er verfügbar ist.

Es gibt auch viele zusätzliche Annehmlichkeiten wie das Ausfüllen von Registerkarten, das hübsche Drucken von Ergebnissen, den Ergebnisverlauf usw., die es für diese Art der explorativen Programmierung sehr praktisch machen.

Für weitere programmatische Verwendung von Selbstbeobachtung, wie die grundlegenden builtins dir(), vars(), getattrwird usw. nützlich sein, aber es lohnt sich, Ihre Zeit das zu prüfen , inspizieren Modul. Um die Quelle einer Funktion abzurufen, verwenden Sie " inspect.getsource", z. B. und wenden Sie sie auf sich selbst an:

>>> print inspect.getsource(inspect.getsource)
def getsource(object):
    """Return the text of the source code for an object.

    The argument may be a module, class, method, function, traceback, frame,
    or code object.  The source code is returned as a single string.  An
    IOError is raised if the source code cannot be retrieved."""
    lines, lnum = getsourcelines(object)
    return string.join(lines, '')

inspect.getargspec ist auch häufig nützlich, wenn Sie sich mit dem Umschließen oder Bearbeiten von Funktionen befassen, da hier die Namen und Standardwerte der Funktionsparameter angegeben werden.

Wenn Sie an einer grafischen Benutzeroberfläche interessiert sind, schauen Sie sich objbrowser an . Es verwendet das Inspect-Modul aus der Python-Standardbibliothek für die darunter liegende Objektinspektion.

Sie können die Attribute eines Objekts mit dir () in der Shell auflisten:

>>> dir(object())
['__class__', '__delattr__', '__doc__', '__format__', '__getattribute__', '__hash__', '__init__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']

Natürlich gibt es auch das Inspect-Modul: http://docs.python.org/library/inspect.html#module-inspect

"""Visit http://diveintopython.net/"""

__author__ = "Mark Pilgrim ([email protected])"


def info(object, spacing=10, collapse=1):
    """Print methods and doc strings.

    Takes module, class, list, dictionary, or string."""
    methodList = [e for e in dir(object) if callable(getattr(object, e))]
    processFunc = collapse and (lambda s: " ".join(s.split())) or (lambda s: s)
    print "\n".join(["%s %s" %
                     (method.ljust(spacing),
                      processFunc(str(getattr(object, method).__doc__)))
                     for method in methodList])

if __name__ == "__main__":
    print help.__doc__

Versuchen Sie es mit 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(), indent='    ', depth=2, width=30, seq_length=6,
              show_protected=True, show_private=False, show_static=True,
              show_properties=True, show_address=True)

Ausgabe:

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

Andere haben bereits das eingebaute dir () erwähnt, das sich nach dem anhört, wonach Sie suchen, aber hier ist ein weiterer guter Tipp. Viele Bibliotheken - einschließlich der meisten Standardbibliotheken - werden in Quellform verteilt. Das heißt, Sie können den Quellcode ziemlich einfach direkt lesen. Der Trick besteht darin, es zu finden; beispielsweise:

>>> import string
>>> string.__file__
'/usr/lib/python2.5/string.pyc'

Die * .pyc-Datei wird kompiliert. Entfernen Sie daher das nachfolgende 'c' und öffnen Sie die nicht kompilierte * .py-Datei in Ihrem bevorzugten Editor oder Datei-Viewer:

/usr/lib/python2.5/string.py

Ich fand das unglaublich nützlich, um herauszufinden, welche Ausnahmen von einer bestimmten API ausgelöst werden. Diese Art von Details ist in der Python-Welt selten gut dokumentiert.

Während pprintbereits von anderen erwähnt wurde, möchte ich einen Kontext hinzufügen.

Das pprint-Modul bietet die Möglichkeit, beliebige Python-Datenstrukturen in einer Form „hübsch zu drucken“, die als Eingabe für den Interpreter verwendet werden kann. Wenn die formatierten Strukturen Objekte enthalten, die keine grundlegenden Python-Typen sind, kann die Darstellung möglicherweise nicht geladen werden. Dies kann der Fall sein, wenn Objekte wie Dateien, Sockets, Klassen oder Instanzen sowie viele andere integrierte Objekte enthalten sind, die nicht als Python-Konstanten dargestellt werden können.

pprint Möglicherweise sind Entwickler mit PHP-Hintergrund, die nach einer Alternative zu suchen, sehr gefragt var_dump() .

Objekte mit einem dict-Attribut können mithilfe von pprint()gemischt mit gut ausgegeben werden vars(), wodurch das __dict__Attribut für ein Modul, eine Klasse, eine Instanz usw.: Zurückgegeben wird.

from pprint import pprint
pprint(vars(your_object))

Es ist also keine Schleife erforderlich .

Um alle im globalen oder lokalen Bereich enthaltenen Variablen zu sichern, verwenden Sie einfach:

pprint(globals())
pprint(locals())

locals()zeigt in einer Funktion definierte Variablen.
Es ist auch nützlich , um Zugriffsfunktionen mit ihren entsprechenden Namen als String - Schlüssel, unter anderen Verwendungen :

locals()['foo']() # foo()
globals()['foo']() # foo()

Ebenso mit dir() Sie den Inhalt eines Moduls oder die Attribute eines Objekts anzeigen.

Und es gibt noch mehr.

Wenn Sie sich Parameter und Methoden ansehen möchten, wie andere bereits betont haben, können Sie pprintoder verwendendir()

Wenn Sie den tatsächlichen Wert des Inhalts sehen möchten, können Sie dies tun

object.__dict__

Zwei großartige Tools zum Überprüfen von Code sind:

1. IPython . Ein Python-Terminal, mit dem Sie die Tab-Vervollständigung überprüfen können.

2. Eclipse mit dem PyDev-Plugin . Es verfügt über einen hervorragenden Debugger, mit dem Sie an einer bestimmten Stelle brechen und Objekte untersuchen können, indem Sie alle Variablen als Baum durchsuchen. Sie können sogar das eingebettete Terminal verwenden, um Code an dieser Stelle zu testen, oder das Objekt eingeben und '.' Drücken. damit es Code-Hinweise für Sie gibt.

pprint und dir arbeiten hervorragend zusammen

Es gibt eine Python-Codebibliothek, die nur für diesen Zweck erstellt wurde: inspect Eingeführt in Python 2.7

Wenn Sie interessiert sind , den Quellcode der Funktion zu sehen , zu dem Objekt entspricht myobj, können Sie eintippen iPythonoder Jupyter Notebook:

myobj??

import pprint

pprint.pprint(obj.__dict__)

oder

pprint.pprint(vars(obj))

Wenn Sie in ein Live-Objekt schauen möchten, ist das Python- inspectModul eine gute Antwort. Im Allgemeinen funktioniert es, um den Quellcode von Funktionen abzurufen, die in einer Quelldatei irgendwo auf der Festplatte definiert sind. Wenn Sie die Quelle von Live-Funktionen und Lambdas erhalten möchten, die im Interpreter definiert wurden, können Sie dill.source.getsourcevon verwenden dill. Es kann auch den Code für gebundene oder ungebundene Klassenmethoden und -funktionen abrufen, die in Currys definiert sind. Möglicherweise können Sie diesen Code jedoch nicht ohne den Code des umschließenden Objekts kompilieren.

>>> from dill.source import getsource
>>> 
>>> def add(x,y):
...   return x+y
... 
>>> squared = lambda x:x**2
>>> 
>>> print getsource(add)
def add(x,y):
  return x+y

>>> print getsource(squared)
squared = lambda x:x**2

>>> 
>>> class Foo(object):
...   def bar(self, x):
...     return x*x+x
... 
>>> f = Foo()
>>> 
>>> print getsource(f.bar)
def bar(self, x):
    return x*x+x

>>> 

vars (obj) gibt die Attribute eines Objekts zurück.

Wenn Sie in Listen und Wörterbüchern suchen möchten, können Sie außerdem pprint () verwenden.

Viele gute Tipps schon, aber der kürzeste und einfachste (nicht unbedingt der beste) muss noch erwähnt werden:

object?

Versuchen Sie es mit:

print(object.stringify())

• Wo objectist der Variablenname des Objekts, das Sie untersuchen möchten?

Dadurch wird eine gut formatierte Ausgabe mit Registerkarten gedruckt, in der die gesamte Hierarchie der Schlüssel und Werte im Objekt angezeigt wird.

HINWEIS: Dies funktioniert in Python3. Nicht sicher, ob es in früheren Versionen funktioniert

UPDATE: Dies funktioniert nicht bei allen Objekttypen. Wenn Sie auf einen dieser Typen stoßen (z. B. ein Anforderungsobjekt), verwenden Sie stattdessen einen der folgenden Typen:

• dir(object())

oder

import pprint dann: pprint.pprint(object.__dict__)