reprlib — Alternative repr() Implementierung

Quellcode: Lib/reprlib.py

Das Modul reprlib bietet eine Möglichkeit, Objekt-Repräsentationen mit Grenzwerten für die Größe der resultierenden Strings zu erzeugen. Dies wird im Python-Debugger verwendet und kann auch in anderen Kontexten nützlich sein.

Dieses Modul stellt eine Klasse, eine Instanz und eine Funktion bereit

class reprlib.Repr(*, maxlevel=6, maxtuple=6, maxlist=6, maxarray=5, maxdict=4, maxset=6, maxfrozenset=6, maxdeque=6, maxstring=30, maxlong=40, maxother=30, fillvalue='...', indent=None)

Klasse, die Formatierungsdienste bereitstellt, die für die Implementierung von Funktionen ähnlich der eingebauten repr() nützlich sind; Größenbeschränkungen für verschiedene Objekttypen werden hinzugefügt, um die Erzeugung von übermäßig langen Repräsentationen zu vermeiden.

Die Schlüsselwortargumente des Konstruktors können als Abkürzung verwendet werden, um die Attribute der Repr-Instanz festzulegen. Das bedeutet, dass die folgende Initialisierung

aRepr = reprlib.Repr(maxlevel=3)

Ist äquivalent zu

aRepr = reprlib.Repr()
aRepr.maxlevel = 3

Siehe Abschnitt Repr-Objekte für weitere Informationen zu Repr-Attributen.

Geändert in Version 3.12: Attribute können über Schlüsselwortargumente gesetzt werden.

reprlib.aRepr

Dies ist eine Instanz von Repr, die zur Bereitstellung der unten beschriebenen repr()-Funktion verwendet wird. Das Ändern der Attribute dieses Objekts wirkt sich auf die von repr() und dem Python-Debugger verwendeten Größenbeschränkungen aus.

reprlib.repr(obj)

Dies ist die repr()-Methode von aRepr. Sie gibt einen String zurück, der dem von der eingebauten Funktion mit demselben Namen zurückgegebenen String ähnelt, jedoch mit Grenzwerten für die meisten Größen.

Zusätzlich zu den Werkzeugen zur Größenbegrenzung bietet das Modul auch einen Dekorator zur Erkennung rekursiver Aufrufe von __repr__() und zum Ersetzen durch einen Platzhalter-String.

@reprlib.recursive_repr(fillvalue='...')

Dekorator für __repr__()-Methoden zur Erkennung rekursiver Aufrufe innerhalb desselben Threads. Wenn ein rekursiver Aufruf erfolgt, wird der fillvalue zurückgegeben, andernfalls wird der übliche __repr__()-Aufruf ausgeführt. Zum Beispiel

>>> from reprlib import recursive_repr
>>> class MyList(list):
...     @recursive_repr()
...     def __repr__(self):
...         return '<' + '|'.join(map(repr, self)) + '>'
...
>>> m = MyList('abc')
>>> m.append(m)
>>> m.append('x')
>>> print(m)
<'a'|'b'|'c'|...|'x'>

Hinzugefügt in Version 3.2.

Repr-Objekte

Repr-Instanzen stellen mehrere Attribute bereit, die zur Festlegung von Größenbeschränkungen für die Repräsentationen verschiedener Objekttypen verwendet werden können, sowie Methoden, die spezifische Objekttypen formatieren.

Repr.fillvalue

Dieser String wird für rekursive Referenzen angezeigt. Er ist standardmäßig ....

Hinzugefügt in Version 3.11.

Repr.maxlevel

Tiefenbeschränkung für die Erstellung rekursiver Repräsentationen. Der Standardwert ist 6.

Repr.maxdict
Repr.maxlist
Repr.maxtuple
Repr.maxset
Repr.maxfrozenset
Repr.maxdeque
Repr.maxarray

Grenzen für die Anzahl der Einträge, die für den benannten Objekttyp repräsentiert werden. Der Standardwert ist 4 für maxdict, 5 für maxarray und 6 für die anderen.

Repr.maxlong

Maximale Anzahl von Zeichen in der Repräsentation für eine Ganzzahl. Ziffern werden aus der Mitte entfernt. Der Standardwert ist 40.

Repr.maxstring

Grenze für die Anzahl der Zeichen in der Repräsentation des Strings. Beachten Sie, dass die "normale" Repräsentation des Strings als Zeichenquelle verwendet wird: Wenn Escape-Sequenzen in der Repräsentation benötigt werden, können diese beim Kürzen der Repräsentation verändert werden. Der Standardwert ist 30.

Repr.maxother

Diese Grenze wird verwendet, um die Größe von Objekttypen zu steuern, für die keine spezifische Formatierungsmethode im Repr-Objekt verfügbar ist. Sie wird ähnlich wie maxstring angewendet. Der Standardwert ist 20.

Repr.indent

Wenn dieses Attribut auf None (Standard) gesetzt ist, wird die Ausgabe ohne Zeilenumbrüche oder Einrückungen formatiert, wie die Standard repr(). Zum Beispiel

>>> example = [
...     1, 'spam', {'a': 2, 'b': 'spam eggs', 'c': {3: 4.5, 6: []}}, 'ham']
>>> import reprlib
>>> aRepr = reprlib.Repr()
>>> print(aRepr.repr(example))
[1, 'spam', {'a': 2, 'b': 'spam eggs', 'c': {3: 4.5, 6: []}}, 'ham']

Wenn indent auf einen String gesetzt wird, wird jede Rekursionsebene auf einer eigenen Zeile platziert, eingerückt mit diesem String

>>> aRepr.indent = '-->'
>>> print(aRepr.repr(example))
[
-->1,
-->'spam',
-->{
-->-->'a': 2,
-->-->'b': 'spam eggs',
-->-->'c': {
-->-->-->3: 4.5,
-->-->-->6: [],
-->-->},
-->},
-->'ham',
]

Das Setzen von indent auf einen positiven ganzzahligen Wert verhält sich so, als ob er auf einen String mit dieser Anzahl von Leerzeichen gesetzt worden wäre

>>> aRepr.indent = 4
>>> print(aRepr.repr(example))
[
    1,
    'spam',
    {
        'a': 2,
        'b': 'spam eggs',
        'c': {
            3: 4.5,
            6: [],
        },
    },
    'ham',
]

Hinzugefügt in Version 3.12.

Repr.repr(obj)

Das Äquivalent zur eingebauten repr(), das die Formatierung verwendet, die von der Instanz auferlegt wird.

Repr.repr1(obj, level)

Rekursive Implementierung, die von repr() verwendet wird. Diese verwendet den Typ von obj, um zu bestimmen, welche Formatierungsmethode aufgerufen werden soll, und übergibt obj und level daran. Die typspezifischen Methoden sollten repr1() aufrufen, um rekursive Formatierung durchzuführen, mit level - 1 für den Wert von level im rekursiven Aufruf.

Repr.repr_TYPE(obj, level)

Formatierungsmethoden für spezifische Typen werden als Methoden mit einem Namen implementiert, der auf dem Typnamen basiert. Im Methodennamen wird **TYPE** durch '_'.join(type(obj).__name__.split()) ersetzt. Die Weiterleitung an diese Methoden wird von repr1() gehandhabt. Typspezifische Methoden, die einen Wert rekursiv formatieren müssen, sollten self.repr1(subobj, level - 1) aufrufen.

Unterklassen von Repr-Objekten

Die Verwendung von dynamischer Weiterleitung durch Repr.repr1() ermöglicht es Unterklassen von Repr, Unterstützung für zusätzliche eingebaute Objekttypen hinzuzufügen oder die Behandlung bereits unterstützter Typen zu ändern. Dieses Beispiel zeigt, wie spezielle Unterstützung für Datei-Objekte hinzugefügt werden könnte

import reprlib
import sys

class MyRepr(reprlib.Repr):

    def repr_TextIOWrapper(self, obj, level):
        if obj.name in {'<stdin>', '<stdout>', '<stderr>'}:
            return obj.name
        return repr(obj)

aRepr = MyRepr()
print(aRepr.repr(sys.stdin))         # prints '<stdin>'

<stdin>