reprlib — Alternativ repr() implementation

Källkod: Lib/reprlib.py

Modulen reprlib ger möjlighet att producera objektrepresentationer med begränsningar av storleken på de strängar som blir resultatet. Detta används i Pythons felsökare och kan vara användbart även i andra sammanhang.

Denna modul tillhandahåller en klass, en instans och en funktion:

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)

Klass som tillhandahåller formateringstjänster som är användbara vid implementering av funktioner som liknar den inbyggda repr(); storleksgränser för olika objekttyper har lagts till för att undvika att representationer genereras som är alltför långa.

Nyckelordsargumenten i konstruktorn kan användas som en genväg för att ställa in attributen för Repr-instansen. Vilket innebär att följande initialisering:

aRepr = reprlib.Repr(maxlevel=3)

Är likvärdig med:

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

Se avsnittet Repr Objects för mer information om Repr-attribut.

Ändrad i version 3.12: Tillåt att attribut ställs in via nyckelordsargument.

reprlib.aRepr

Detta är en instans av Repr som används för att tillhandahålla funktionen repr() som beskrivs nedan. Om du ändrar attributen för detta objekt påverkas de storleksgränser som används av repr() och Pythons debugger.

reprlib.repr(obj)

Detta är repr()-metoden för aRepr. Den returnerar en sträng som liknar den som returneras av den inbyggda funktionen med samma namn, men med begränsningar för de flesta storlekar.

Förutom verktyg för storleksbegränsning innehåller modulen också en dekorator för att upptäcka rekursiva anrop till __repr__() och ersätta dem med en platshållarsträng.

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

Dekorator för __repr__() metoder för att upptäcka rekursiva anrop inom samma tråd. Om ett rekursivt anrop görs returneras fillvärdet, annars görs det vanliga __repr__()-anropet. Ett exempel:

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

Tillagd i version 3.2.

Repr-objekt

Repr-instanser innehåller flera attribut som kan användas för att ange storleksgränser för representationer av olika objekttyper och metoder som formaterar specifika objekttyper.

Repr.fillvalue

Denna sträng visas för rekursiva referenser. Standardvärdet är ....

Tillagd i version 3.11.

Repr.maxlevel

Djupgräns för skapandet av rekursiva representationer. Standardvärdet är 6.

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

Begränsar antalet poster som representeras för den angivna objekttypen. Standardvärdet är 4 för maxdict, 5 för maxarray och 6 för de övriga.

Repr.maxlong

Maximalt antal tecken i representationen för ett heltal. Siffrorna tas bort från mitten. Standardvärdet är 40.

Repr.maxstring

Begränsning av antalet tecken i representationen av strängen. Observera att den ”normala” representationen av strängen används som teckenkälla: om escape-sekvenser behövs i representationen kan dessa manglas när representationen förkortas. Standardvärdet är 30.

Repr.maxother

Denna gräns används för att kontrollera storleken på objekttyper för vilka ingen specifik formateringsmetod är tillgänglig på Repr-objektet. Den tillämpas på liknande sätt som maxstring. Standardvärdet är 20.

Repr.indent

Om detta attribut är inställt på None (standard) formateras utdata utan radbrytning eller indragning, som standard repr(). Ett exempel:

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

Om indent är satt till en sträng placeras varje rekursionsnivå på en egen rad, indragen med strängen:

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

Om du anger ett positivt heltalsvärde för indent fungerar det som om det hade angetts för en sträng med det antalet mellanslag:

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

Tillagd i version 3.12.

Repr.repr(obj)

Motsvarigheten till den inbyggda repr() som använder den formatering som instansen föreskriver.

Repr.repr1(obj, level)

Rekursiv implementering som används av repr(). Den använder typen av obj för att avgöra vilken formateringsmetod som ska anropas, och skickar obj och level till den. De typspecifika metoderna bör anropa repr1() för att utföra rekursiv formatering, med level - 1 för värdet på level i det rekursiva anropet.

Repr.repr_TYPE(obj, level)

Formateringsmetoder för specifika typer implementeras som metoder med ett namn som baseras på typnamnet. I metodnamnet ersätts TYPE med '_'.join(type(obj).__name__.split()). Dispatch till dessa metoder hanteras av repr1(). Typspecifika metoder som behöver formatera ett värde rekursivt bör anropa self.repr1(subobj, level - 1).

Underklassificering av Repr-objekt

Användningen av dynamisk dispatching av Repr.repr1() gör det möjligt för subklasser av Repr att lägga till stöd för ytterligare inbyggda objekttyper eller att modifiera hanteringen av typer som redan stöds. Detta exempel visar hur specialstöd för filobjekt kan läggas till:

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>