Der Unterschied zwischen __str__ und __repr__?

Question

Was ist der Unterschied zwischen __str__ und __repr__ in Python?

Answer 1

Alex zusammengefasst gut, aber überraschenderweise war zu prägnant.

Lassen Sie mich zunächst die wichtigsten Punkte in Alex Post wiederholen:

• Die Standardimplementierung ist nutzlos (es ist schwer, von einem zu denken, das wäre nicht, aber ja)
• __repr__ Ziel ist eindeutig sein
• __str__ Ziel ist es lesbar sein
• Container des __str__ verwendet enthaltenen Objekte __repr__

Standard-Implementierung ist nutzlos

Dies ist vor allem eine Überraschung, weil Python Standardwerte sind in der Regel ziemlich nützlich sein. Doch in diesem Fall für __repr__ einen Standard zu haben, die handeln würde wie:

return "%s(%r)" % (self.__class__, self.__dict__)

wäre zu gefährlich gewesen (zum Beispiel zu leicht in eine unendliche Rekursion zu erhalten, wenn Objekte sich gegenseitig referenzieren). So Cops Python aus. Beachten Sie, dass ein Standard ist, die wahr ist. Wenn __repr__ definiert ist, und __str__ ist nicht, wird das Objekt verhalten, als ob __str__=__repr__

Das bedeutet, in einfachen Worten: fast jedes Objekt, das Sie implementieren soll eine funktionelles __repr__ haben, die für das Verständnis des Objekts verwendbar ist. __str__ Die Implementierung ist optional: tun, wenn Sie eine „ziemlich print“ Funktionalität (zum Beispiel durch einen Report-Generator verwendet wird)

.

Das Ziel des __repr__ ist eindeutig sein

Lassen Sie mich kommen direkt aus und sagen, es ist - ich glaube nicht an Debugger. Ich weiß wirklich nicht, wie jeder Debugger zu verwenden, und haben nie ein ernst verwendet. Darüber hinaus glaube ich, dass der große Fehler in Debugger ihre grundlegende Natur ist - die meisten Ausfälle ich Debug für eine lange, lange Zeit vor, in einer Galaxie weit, weit weg passiert ist. Das bedeutet, dass ich glaube, tun, mit religiöser Inbrunst, in Protokollierung. Die Protokollierung ist das Lebenselixier eines jeden anständigen fire-and-forget-Server-System. Python macht es einfach, zu protokollieren: mit vielleicht einigen projektspezifische Verpackungen, alles, was Sie brauchen, ist ein

log(INFO, "I am in the weird function and a is", a, "and b is", b, "but I got a null C — using default", default_c)

Sie haben aber den letzten Schritt zu tun - stellen Sie sicher, eine nützliche repr jedes Objekt, das Sie implementieren hat, so Code wie das kann nur funktionieren. Deshalb ist die „eval“ Sache kommt: Wenn Sie genügend Informationen, so eval(repr(c))==c haben, das heißt, Sie wissen alles über c wissen. Wenn das einfach genug ist, zumindest in einem Fuzzy-Weg, tun Sie es. Wenn nicht, stellen Sie sicher, haben Sie genügend Informationen über c sowieso. Normalerweise verwende ich ein eval-ähnliches Format: "MyClass(this=%r,that=%r)" % (self.this,self.that). Es bedeutet nicht, dass Sie tatsächlich MyClass konstruieren können, oder dass das ist die richtige Konstruktorargumente -. Aber es ist eine nützliche Form auszudrücken: „Das ist alles, was Sie brauchen, um über diese Instanz wissen“

Hinweis: Früher habe ich %r oben, nicht %s. Sie wollen immer repr() [oder %r Formatierungszeichen äquivalent] innerhalb __repr__ Implementierung verwenden, oder Sie besiegen das Ziel, repr. Sie wollen in der Lage sein MyClass(3) und MyClass("3") zu unterscheiden.

Das Ziel von __str__ lesbar sein

Insbesondere ist es nicht eindeutig sein soll - das str(3)==str("3") bemerken. Ebenso, wenn Sie eine IP-Abstraktion implementieren, mit der str es wie 192.168.1.1 aussehen ist einfach gut. Wenn ein Datum / Zeit-Abstraktion der Umsetzung kann die str „2010.04.12 15.35.22“ sein usw. Das Ziel ist es, in einer Art und Weise darzustellen, dass ein Benutzer, kein Programmierer, würde es lesen will. Abhacken nutzlos Stellen, so tun, als eine andere Klasse zu sein -. So lange ist es unterstützt Lesbarkeit, es ist eine Verbesserung

Container des __str__ Anwendungen enthaltenen Objekte __repr__

Das scheint überraschend, nicht wahr? Es ist ein wenig, aber wie lesbar würde

[moshe is, 3, hello
world, this is a list, oh I don't know, containing just 4 elements]

sein? Nicht sehr. Insbesondere wird die sTrings in einem Behälter würde es viel zu einfach, seine String-Darstellung zu stören. Angesichts der Mehrdeutigkeit, denken Sie daran, widersteht der Versuchung, Python zu erraten. Wenn Sie das oben beschriebene Verhalten wünschen, wenn Sie eine Liste drucken, nur

print "[" + ", ".join(l) + "]"

(man kann wohl auch herausfinden, was über Wörterbücher zu tun.

Zusammenfassung

Implementieren __repr__ für jede Klasse, die Sie implementieren. Dies sollte zur zweiten Natur sein. Implementieren Sie __str__ wenn Sie denken, es wäre sinnvoll, eine String-Version zu haben, die auf der Seite der Lesbarkeit irrt.

Answer 2

Meine Faustregel:. __repr__ für Entwickler ist, __str__ ist für Kunden

Answer 3

Wenn Sie nicht ausdrücklich anders gewährleisten handeln, die meisten Klassen haben keine hilfreichen Ergebnisse für entweder:

>>> class Sic(object): pass
... 
>>> print str(Sic())
<__main__.Sic object at 0x8b7d0>
>>> print repr(Sic())
<__main__.Sic object at 0x8b7d0>
>>> 

Wie Sie sehen - kein Unterschied, und keine Informationen über die Klasse und id des Objekts. Wenn Sie nur eine der beiden außer Kraft setzen ...:

>>> class Sic(object): 
...   def __repr__(object): return 'foo'
... 
>>> print str(Sic())
foo
>>> print repr(Sic())
foo
>>> class Sic(object):
...   def __str__(object): return 'foo'
... 
>>> print str(Sic())
foo
>>> print repr(Sic())
<__main__.Sic object at 0x2617f0>
>>> 

Wie Sie sehen, wenn Sie __repr__ außer Kraft setzen, ist das auch für __str__ verwendet, aber nicht umgekehrt.

Weitere wichtige tidbits zu wissen: __str__ auf einem integrierten auf Behälter verwendet die __repr__, NICHT der __str__, für die Elemente, die sie enthält. Und trotz der Worte zu diesem Thema im typischen docs gefunden, kaum stört jemand machte die __repr__ von Objekten eine Zeichenfolge sein, dass eval verwendet das gleiche Objekt zu bauen (es ist einfach zu hart und nicht zu wissen, wie das betreffende Modul tatsächlich Marken importiert wurde es tatsächlich flach heraus unmöglich).

Also, mein Rat: Schwerpunkt machen __str__ maßen den Menschen lesbaren und __repr__ so eindeutig wie es Ihnen möglich ist, auch wenn das mit dem Fuzzy-unerreichbares Ziel stört zurückWert machen __repr__ akzeptabel als Eingabe für __eval__

Answer 4

__repr__ : Darstellung von Python-Objekt wird in der Regel eval es auf das Objekt konvertieren zurück

__str__ : ist, was denken Sie, ist, dass das Objekt in Textform

z.

>>> s="""w'o"w"""
>>> repr(s)
'\'w\\\'o"w\''
>>> str(s)
'w\'o"w'
>>> eval(str(s))==s
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<string>", line 1
    w'o"w
       ^
SyntaxError: EOL while scanning single-quoted string
>>> eval(repr(s))==s
True

Answer 5

  

Kurz gesagt, ist das Ziel des __repr__ sein eindeutig und __str__ ist zu sein   lesbar.

Hier ist ein gutes Beispiel:

>>> import datetime
>>> today = datetime.datetime.now()
>>> str(today)
'2012-03-14 09:21:58.130922'
>>> repr(today)
'datetime.datetime(2012, 3, 14, 9, 21, 58, 130922)'

Lesen Sie diese Dokumentation für repr:

  

repr(object)

     

Gibt eine Zeichenfolge, die eine druckbare Darstellung eines Objekts enthält. Dies ist der gleiche Wert, erhalten durch Conversions (Reverse   Anführungszeichen). Es ist manchmal nützlich, in der Lage sein, diesen Vorgang zugreifen, als   eine normale Funktion. Für viele Arten, macht diese Funktion einen Versuch   eine Zeichenkette zurück, die ein Objekt mit dem gleichen Wert ergeben würde, wenn   bestanden eval(), sonst wird die Darstellung eine Zeichenkette in geschlossenen   Winkelstützen, die den Namen des Typs des Objekts enthält   zusammen mit zusätzlichen Informationen oft den Namen einschließlich und   Adresse des Objekts. Eine Klasse kann kontrollieren, was diese Funktion zurückgibt   für ihre Instanzen durch eine __repr__() Methode definieren.

Hier ist die Dokumentation für str:

  

str(object='')

     

Gibt eine Zeichenfolge, die eine gut bedruckbar enthält   Darstellung eines Objekts. Bei Strings gibt diese Eigenschaft die Zeichenfolge   selbst. Der Unterschied ist, dass repr(object) str(object) nicht   versuchen immer eine Zeichenkette zurück, die akzeptabel eval() ist; es ist   Ziel ist es, eine druckbare Zeichenfolge zurück. Wenn kein Argument angegeben wird, kehrt   die leere Zeichenkette, ''.

Answer 6

  

Was ist der Unterschied zwischen __str__ und __repr__ in Python?

__str__ (gelesen als „dunder (Doppelstrich) string“) und __repr__ (lesen als „dunder-repper“ (für „Repräsentation“)) sind beide speziellen Methoden, die Strings basierend auf dem Zustand des Objekts zurück.

__repr__ bietet Backup Verhalten, wenn __str__ fehlt.

So sollte man zuerst eine __repr__ schreiben, dass Sie ein äquivalentes Objekt aus dem String Reinstanziierung ermöglicht es gibt z Verwendung eval oder indem es in Zeichen für Zeichen in einer Python Shell eingeben.

Sie können jederzeit später kann man eine __str__ für eine vom Benutzer lesbaren String-Darstellung der Instanz schreiben, wenn man glaubt, es notwendig zu sein.

__str__

Wenn Sie ein Objekt drucken, oder geben es an format, str.format oder str, dann, wenn eine __str__ Methode definiert ist, wird das Verfahren, sonst genannt wird, wird __repr__ verwendet werden.

__repr__

Die __repr__ Methode wird durch die eingebaute Funktion repr genannt und ist das, was auf dem Python-Shell Echo wird, wenn es einen Ausdruck auswertet, die ein Objekt zurückgibt.

Da es eine Sicherung für __str__ bietet, wenn Sie nur einen schreiben können, beginnen Sie mit __repr__

Hier ist die eingebaute Hilfe auf repr:

repr(...)
    repr(object) -> string

    Return the canonical string representation of the object.
    For most object types, eval(repr(object)) == object.

Das heißt, für die meisten Objekte, wenn Sie in geben, was von repr gedruckt wird, sollten Sie in der Lage sein, ein entsprechendes Objekt zu erstellen. Aber das ist nicht die Standardimplementierung.

Standardimplementierung von __repr__

Das Standardobjekt __repr__ ist ( C Python Quelle ) so etwas wie:

def __repr__(self):
    return '<{0}.{1} object at {2}>'.format(
      self.__module__, type(self).__name__, hex(id(self)))

Das bedeutet, dass standardmäßig das Modul drucken würdest das Objekt aus ist, die Klassennamen und die hexadezimale Darstellung seiner Position im Speicher - zum Beispiel:

<__main__.Foo object at 0x7f80665abdd0>

Diese Information ist nicht sehr nützlich, aber es gibt keine Möglichkeit ableiten, wie man genau eine kanonische Darstellung einer beliebige Instanz erstellen könnte, und es ist besser als nichts, zumindest uns sagen, wie wir es eindeutig im Speicher identifizieren könnten.

Wie kann __repr__ nützlich sein?

Schauen wir uns an, wie nützlich es sein kann, die Python-Shell und datetime Objekte verwenden. Zunächst müssen wir die datetime Modul importieren:

import datetime

Wenn wir datetime.now in der Schale nennen, werden wir alles, was wir brauchen, sehen ein äquivalentes Datetime-Objekt zu erstellen. Dies wird durch die Datetime __repr__ erstellt:

>>> datetime.datetime.now()
datetime.datetime(2015, 1, 24, 20, 5, 36, 491180)

Wenn wir ein Datetime-Objekt zu drucken, sehen wir ein schönes Menschen lesbares (in der Tat, ISO) Format. Dies wird durch Datumzeit der __str__ implementiert:

>>> print(datetime.datetime.now())
2015-01-24 20:05:44.977951

Es ist eine einfache Sache, das Objekt, das wir verloren neu zu erstellen, weil wir es nicht zu einer Variablen zugewiesen wurden durch Kopieren und Einfügen aus dem __repr__ Ausgang, und dann den Druck, und wir es in der gleichen Menschen lesbare Ausgabe als das bekommen anderes Objekt:

>>> the_past = datetime.datetime(2015, 1, 24, 20, 5, 36, 491180)
>>> print(the_past)
2015-01-24 20:05:36.491180

Wie kann ich sie umsetzen?

Wie Sie entwickeln, sollten Sie in der Lage sein, Objekte in dem gleichen Zustand zu reproduzieren, wenn möglich. Dies ist zum Beispiel, ist, wie das Datetime-Objekt __repr__ ( Python Quelle ). Es ist ziemlich komplex, weil alle Attribute eines solchen Objekts zu reproduzieren benötigt:

def __repr__(self):
    """Convert to formal string, for repr()."""
    L = [self._year, self._month, self._day,  # These are never zero
         self._hour, self._minute, self._second, self._microsecond]
    if L[-1] == 0:
        del L[-1]
    if L[-1] == 0:
        del L[-1]
    s = "%s.%s(%s)" % (self.__class__.__module__,
                       self.__class__.__qualname__,
                       ", ".join(map(str, L)))
    if self._tzinfo is not None:
        assert s[-1:] == ")"
        s = s[:-1] + ", tzinfo=%r" % self._tzinfo + ")"
    if self._fold:
        assert s[-1:] == ")"
        s = s[:-1] + ", fold=1)"
    return s

Wenn Sie Ihr Objekt wünschen sich einen Menschen lesbare Darstellung haben, können Sie __str__ nächste implementieren. Hier ist, wie das Datetime-Objekt ( Python Quelle ) implementiert __str__, die es leicht macht, weil es bereits eine Funktion hat, angezeigt werden es im ISO-Format:

def __str__(self):
    "Convert to string, for str()."
    return self.isoformat(sep=' ')

Set __repr__ = __str__?

Dies ist eine Kritik an einer anderen Antwort hier die __repr__ = __str__ schlägt Einstellung.

Einstellung __repr__ = __str__ ist albern - __repr__ ein Rückfall für __str__ ist und eine __repr__, für Entwickler Verwendung in Debugging geschrieben, geschrieben werden sollten, bevor Sie eine __str__ schreiben

.

Sie benötigen einen __str__ nur, wenn Sie eine Textdarstellung des Objekts benötigen.

Fazit

definieren __repr__ für Objekte, die Sie schreiben, so dass Sie und andere Entwickler haben ein reproduzierbares Beispiel, wenn Sie es, wie Sie entwickeln. Definieren __str__, wenn Sie einen Menschen lesbare String-Darstellung benötigen.

Answer 7

Neben all die Antworten gegeben, ich möchte einige Punkte hinzuzufügen: -

1) __repr__() aufgerufen wird, wenn Sie einfach Objektnamen auf der interaktiven Python-Konsole ein und drücken Sie schreiben ein.

2) __str__() wird aufgerufen, wenn Sie Objekt mit print-Anweisung verwendet werden.

3) Im Falle, wenn __str__ fehlt, wird dann drucken und jede Funktion str() mit ruft __repr__() des Objekts.

4) __str__() von Behältern, wenn sie aufgerufen __repr__() Methode seiner enthaltenen Elemente auszuführen.

5) str() innerhalb __str__() genannt könnte potenziell recurse ohne Basisfall, und Fehler auf maximale Rekursionstiefe.

6) __repr__() kann repr() aufrufen, die automatisch eine unendliche Rekursion zu vermeiden wird versuchen, eine bereits dargestellte Objekt mit ... ersetzt werden.

Answer 8

Auf Seite 358 des Buchs Python Scripting für Computational Science von Hans Petter Langtangen, es stellt klar, dass

• Die __repr__ zielt auf eine vollständige String-Darstellung des Objekts;
• Die __str__ ist eine schöne Schnur zum Drucken zurückzukehren.

Also, ich ziehe sich als

verstehen

• repr = reproduzieren
• str = string (Darstellung)

vom Standpunkt des Benutzers aus gesehen obwohl dies ist ein Missverständnis ich gemacht, wenn Python zu lernen.

Ein kleines, aber gutes Beispiel ist auch auf der gleichen Seite wie folgt angegeben:

Beispiel

In [38]: str('s')
Out[38]: 's'

In [39]: repr('s')
Out[39]: "'s'"

In [40]: eval(str('s'))
Traceback (most recent call last):

  File "<ipython-input-40-abd46c0c43e7>", line 1, in <module>
    eval(str('s'))

  File "<string>", line 1, in <module>

NameError: name 's' is not defined


In [41]: eval(repr('s'))
Out[41]: 's'

Answer 9

In aller Ehrlichkeit, ist eval(repr(obj)) nie benutzt. Wenn Sie sich mit ihm zu finden, sollten Sie aufhören, weil eval gefährlich ist, und Saiten sind ein sehr ineffizienter Weg, um Ihre Objekte (Verwendung pickle statt) serialisiert werden.

Deshalb würde ich empfehlen __repr__ = __str__ Einstellung. Der Grund dafür ist, dass str(list) ruft repr auf die Elemente (Ich halte dies für eine der größten Design-Fehler von Python sein, die nicht von Python 3 angesprochen wurde). Eine tatsächliche repr wird wahrscheinlich nicht sehr hilfreich, da die Ausgabe von print [your, objects].

Um dies zu qualifizieren, in meiner Erfahrung, der nützlichsten Anwendungsfall der repr Funktion ist eine Zeichenfolge in einer anderen Zeichenfolge zu setzen (string Formatierung verwenden). Auf diese Weise müssen Sie sich nicht über zu entkommen Anführungszeichen oder nichts kümmern. Aber beachten Sie, dass es keine eval hier passiert ist.

Answer 10

Um es einfach auszudrücken:

__str__ verwendet wird, in eine String-Darstellung des Objekts zeigen leicht zu lesenden durch andere.

__repr__ wird verwendet, um eine String-Darstellung von zu zeigen, die Objekt.

Lassen Sie uns sagen, ich will eine Fraction Klasse erstellen, in dem die Zeichenfolgendarstellung einer Fraktion ‚(1/2)‘ und das Objekt (Klasse Fraction) ist als ‚Fraktion (1,2)‘ dargestellt werden

So wir eine einfache Klasse Fraction erstellen:

class Fraction:
    def __init__(self, num, den):
        self.__num = num
        self.__den = den

    def __str__(self):
        return '(' + str(self.__num) + '/' + str(self.__den) + ')'

    def __repr__(self):
        return 'Fraction (' + str(self.__num) + ',' + str(self.__den) + ')'



f = Fraction(1,2)
print('I want to represent the Fraction STRING as ' + str(f)) # (1/2)
print('I want to represent the Fraction OBJECT as ', repr(f)) # Fraction (1,2)

Answer 11

ein (eine inoffizielle) Python Reference Wiki (Archivkopie) von effbot:

__str__ „ berechnet die‚informelle‘String-Darstellung eines Objekts Diese von __repr__ unterscheidet sich darin, dass es keine gültige Python-Ausdruck sein muss:.. Eine bequemere oder prägnante Darstellung verwendet werden können, anstatt "

Answer 12

Ein Aspekt, der in anderen Antworten fehlen. Es stimmt, dass im Allgemeinen das Muster:

• Tor von __str__: Menschen lesbaren
• Tor von __repr__: eindeutig, möglicherweise maschinenlesbar über eval

Leider ist diese Differenzierung ist fehlerhaft, weil der Python REPL und IPython auch __repr__ verwenden für Objekte in einer REPL Konsole Druck (siehe Fragen Python und IPython ). So Projekte, die für interaktive Konsole Arbeit ausgerichtet sind (zum Beispiel Numpy oder Pandas) haben damit begonnen, über Regeln zu ignorieren und stattdessen eine menschenlesbare __repr__ Umsetzung.

Answer 13

str - Erstellt ein neues String-Objekt aus dem gegebenen Objekt

.

repr - Liefert die kanonische String-Darstellung des Objekts

.

Die Unterschiede:

str ():

• macht lesbar
Objekt
• erzeugt Ausgang für Endbenutzer

repr ():

• muss Code, Objekt reproduziert
• erzeugt Ausgabe für Entwickler

Answer 14

Ausgezeichnete Antworten bereits den Unterschied zwischen __str__ und __repr__, was für mich in dem ehemaligen lesbar läuft darauf hinaus, sogar durch einen Endbenutzer, und dies so nützlich wie möglich an den Entwickler zu sein. Da finde ich, dass die Standardimplementierung von __repr__ oft nicht dieses Ziel zu erreichen, weil es weglässt Informationen für Entwickler nützlich.

Aus diesem Grund, wenn ich eine einfache genug __str__ haben, ich in der Regel nur versuchen, das Beste aus beiden Welten zu bekommen, so etwas wie:

def __repr__(self):
    return '{0} ({1})'.format(object.__repr__(self), str(self))

Answer 15

Aus dem Buch Fluent Python :

  

Eine Grundvoraussetzung für ein Python-Objekt ist verwendbar zur Verfügung zu stellen        String-Darstellungen von sich selbst, ein verwendet für das Debuggen und        Protokollierung, eine andere für die Präsentation an Endverbraucher. Deshalb ist die
       spezielle Methoden __repr__ und __str__ existieren im Datenmodell.

Answer 16

  

Eine wichtige Sache im Auge zu behalten ist, dass __str__ Verwendungen des Container-Objekte __repr__ enthalten ist.

>>> from datetime import datetime
>>> from decimal import Decimal
>>> print (Decimal('52'), datetime.now())
(Decimal('52'), datetime.datetime(2015, 11, 16, 10, 51, 26, 185000))
>>> str((Decimal('52'), datetime.now()))
"(Decimal('52'), datetime.datetime(2015, 11, 16, 10, 52, 22, 176000))"

Python begünstigt Eindeutigkeit über Lesbarkeit , die __str__ Aufruf eines tuple ruft die __repr__ enthaltenen Objekte, die "formal" Darstellung eines Objekts. Obwohl die formale Darstellung als informeller ein zu lesen ist härter, es ist eindeutig und robuster gegenüber Fehlern.

Answer 17

Auf den Punkt gebracht:

class Demo:
  def __repr__(self):
    return 'repr'
  def __str__(self):
    return 'str'

demo = Demo()
print(demo) # use __str__, output 'str' to stdout

s = str(demo) # __str__ is used, return 'str'
r = repr(demo) # __repr__ is used, return 'repr'

import logging
logger = logging.getLogger(logging.INFO)
logger.info(demo) # use __str__, output 'str' to stdout

from pprint import pprint, pformat
pprint(demo) # use __repr__, output 'repr' to stdout
result = pformat(demo) # use __repr__, result is string which value is 'str'

Answer 18

>>> print(decimal.Decimal(23) / decimal.Decimal("1.05"))
21.90476190476190476190476190
>>> decimal.Decimal(23) / decimal.Decimal("1.05")
Decimal('21.90476190476190476190476190')

Wenn print() auf dem Ergebnis der decimal.Decimal(23) / decimal.Decimal("1.05") die rohe Zahl gedruckt wird genannt wird; Dieser Ausgang ist in string Form , die mit __str__() erreicht werden können. Wenn wir einfach den Ausdruck eingeben wir einen decimal.Decimal Ausgang bekommen - dieser Ausgang in Darstellungsform , die mit __repr__() erreicht werden kann. Alle Python-Objekte haben zwei Ausgabeformen. String-Form ist so konzipiert, vom Menschen lesbar zu sein. Die Darstellungsform ist so konzipiert, Ausgabe zu erzeugen, das zu einem Python-Interpreter zugeführt, wenn würde (wenn möglich) das dargestellte Objekt reproduzieren.

Answer 19

Verstehen __str__ und __repr__ intuitiv und sie permanent überhaupt unterscheiden zu können.

__str__ die Zeichenfolge verkleidet Körper eines gegebenen Objekt zurückgeben für lesbares Augen
__repr__ das wirkliche Fleisch Körper eines bestimmten Objekts zurückkehren (selbst zurück) für Eindeutigkeit zu identifizieren.

Sehen Sie es in einem Beispiel

In [30]: str(datetime.datetime.now())
Out[30]: '2017-12-07 15:41:14.002752'
Disguised in string form

In Bezug auf __repr__

In [32]: datetime.datetime.now()
Out[32]: datetime.datetime(2017, 12, 7, 15, 43, 27, 297769)
Presence in real body which allows to be manipulated directly.

Wir tun arithmetische Operation auf __repr__ Ergebnisse bequem.

In [33]: datetime.datetime.now()
Out[33]: datetime.datetime(2017, 12, 7, 15, 47, 9, 741521)
In [34]: datetime.datetime(2017, 12, 7, 15, 47, 9, 741521) - datetime.datetime(2
    ...: 017, 12, 7, 15, 43, 27, 297769)
Out[34]: datetime.timedelta(0, 222, 443752)

Wenn gilt den Betrieb auf __str__

In [35]: '2017-12-07 15:43:14.002752' - '2017-12-07 15:41:14.002752'
TypeError: unsupported operand type(s) for -: 'str' and 'str'

Gibt nichts als Fehler.

Ein weiteres Beispiel.

In [36]: str('string_body')
Out[36]: 'string_body' # in string form

In [37]: repr('real_body')
Out[37]: "'real_body'" #its real body hide inside

Hoffe diese Hilfe Sie konkrete Gründe zu bauen, um mehr Antworten zu erkunden.

Answer 20

__repr__ überall verwendet wird, mit der Ausnahme von print und str Methoden (wenn ein __str__is definiert!)

Answer 21

1. __str__ muß String-Objekt zurück, während __repr__ jeden Python Ausdruck zurückgeben kann.
2. Wenn __str__ Implementierung fehlt dann __repr__ Funktion als Ausweichlösung verwendet. Es gibt keinen Rückfall, wenn __repr__ Funktion Umsetzung fehlt.
3. Wenn __repr__ Funktion String-Darstellung des Objekts zurückkehrt, können wir die Umsetzung von __str__ Funktion überspringen.

Quelle: https://www.journaldev.com/22460/python -str-repr-Funktionen

Answer 22

__str__ kann auf einem Objekt aufgerufen werden, indem str(obj) Aufruf und soll ein für Menschen lesbaren String zurück.

__repr__ kann auf einem Objekt aufgerufen werden, indem repr(obj) Aufruf und soll zurückkehrt internes Objekt (Objektfelder / Attribute)

In diesem Beispiel kann helfen:

class C1:pass

class C2:        
    def __str__(self):
        return str(f"{self.__class__.__name__} class str ")

class C3:        
    def __repr__(self):        
         return str(f"{self.__class__.__name__} class repr")

class C4:        
    def __str__(self):
        return str(f"{self.__class__.__name__} class str ")
    def __repr__(self):        
         return str(f"{self.__class__.__name__} class repr")


ci1 = C1()    
ci2 = C2()  
ci3 = C3()  
ci4 = C4()

print(ci1)       #<__main__.C1 object at 0x0000024C44A80C18>
print(str(ci1))  #<__main__.C1 object at 0x0000024C44A80C18>
print(repr(ci1)) #<__main__.C1 object at 0x0000024C44A80C18>
print(ci2)       #C2 class str
print(str(ci2))  #C2 class str
print(repr(ci2)) #<__main__.C2 object at 0x0000024C44AE12E8>
print(ci3)       #C3 class repr
print(str(ci3))  #C3 class repr
print(repr(ci3)) #C3 class repr
print(ci4)       #C4 class str 
print(str(ci4))  #C4 class str 
print(repr(ci4)) #C4 class repr