Ich verstehe wirklich nicht, wo __str__und __repr__in Python verwendet. Ich meine, ich bekomme, dass __str__die Zeichenfolgendarstellung eines Objekts zurückgegeben wird. Aber warum sollte ich das brauchen? In welchem ​​Anwendungsfall? Außerdem habe ich über die Verwendung von gelesen__repr__

Aber was ich nicht verstehe ist, wo würde ich sie verwenden?

__repr__

Wird von der repr()integrierten Funktion und von Zeichenfolgenkonvertierungen (umgekehrte Anführungszeichen) aufgerufen , um die "offizielle" Zeichenfolgendarstellung eines Objekts zu berechnen. Wenn möglich, sollte dies wie ein gültiger Python-Ausdruck aussehen, mit dem ein Objekt mit demselben Wert (in einer geeigneten Umgebung) neu erstellt werden kann.

__str__

Wird von der str()integrierten Funktion und von der print-Anweisung aufgerufen , um die "informelle" Zeichenfolgendarstellung eines Objekts zu berechnen.

Verwenden __str__Sie diese Option, wenn Sie eine Klasse haben und eine informative / informelle Ausgabe wünschen, wenn Sie dieses Objekt als Teil einer Zeichenfolge verwenden. Sie können beispielsweise __str__Methoden für Django-Modelle definieren, die dann in der Django-Verwaltungsoberfläche gerendert werden. Anstelle von so etwas erhalten <Model object>Sie den Vor- und Nachnamen einer Person, den Namen und das Datum eines Ereignisses usw.

__repr__und __str__sind ähnlich, in der Tat manchmal gleich (Beispiel aus der BaseSetKlasse in sets.pyder Standardbibliothek):

def __repr__(self):
    """Return string representation of a set.

    This looks like 'Set([<list of elements>])'.
    """
    return self._repr()

# __str__ is the same as __repr__
__str__ = __repr__

Der einzige Ort, an dem Sie beide häufig verwenden, ist eine interaktive Sitzung. Wenn Sie ein Objekt drucken, wird seine __str__Methode aufgerufen. Wenn Sie nur ein Objekt selbst verwenden, __repr__wird Folgendes angezeigt:

>>> from decimal import Decimal
>>> a = Decimal(1.25)
>>> print(a)
1.25                  <---- this is from __str__
>>> a
Decimal('1.25')       <---- this is from __repr__

Das __str__soll so gut wie möglich lesbar sein, während das__repr__ Ziel sein sollte, etwas zu sein, mit dem das Objekt neu erstellt werden kann, obwohl es oft nicht genau so ist, wie es erstellt wurde, wie in diesem Fall.

Es ist auch nicht ungewöhnlich für beide __str__und __repr__denselben Wert zurück ( auf jeden Fall für integrierte Typen).

Heuschrecke, wenn Sie Zweifel haben, gehen Sie zum Berg und lesen Sie die alten Texte . In ihnen finden Sie, dass __repr __ ():

Wenn möglich, sollte dies wie ein gültiger Python-Ausdruck aussehen, mit dem ein Objekt mit demselben Wert neu erstellt werden kann.

Aufbauend auf den vorherigen Antworten und Zeigen einiger weiterer Beispiele. Bei sachgemäßer Verwendung ist der Unterschied zwischen strund reprklar. Kurz gesagt, reprsollte eine Zeichenfolge zurückgegeben werden, die kopiert werden kann, um den genauen Status des Objekts wiederherzustellen, während strdies für das Debuggen loggingund observingDebuggen von Ergebnissen nützlich ist . Hier sind einige Beispiele, um die verschiedenen Ausgaben für einige bekannte Bibliotheken zu sehen.

Terminzeit

print repr(datetime.now())    #datetime.datetime(2017, 12, 12, 18, 49, 27, 134411)
print str(datetime.now())     #2017-12-12 18:49:27.134452

Das strist gut, um in eine Protokolldatei zu drucken, wo reprdies zweckentfremdet werden kann, wenn Sie es direkt ausführen oder als Befehle in eine Datei kopieren möchten.

x = datetime.datetime(2017, 12, 12, 18, 49, 27, 134411)

Numpy

print repr(np.array([1,2,3,4,5])) #array([1, 2, 3, 4, 5])
print str(np.array([1,2,3,4,5]))  #[1 2 3 4 5]

in Numpy reprist das wieder direkt verbrauchbar.

Beispiel für einen benutzerdefinierten Vektor3

class Vector3(object):
    def __init__(self, args):
        self.x = args[0]
        self.y = args[1]
        self.z = args[2]

    def __str__(self):
        return "x: {0}, y: {1}, z: {2}".format(self.x, self.y, self.z)

    def __repr__(self):
        return "Vector3([{0},{1},{2}])".format(self.x, self.y, self.z)

In diesem Beispiel wird reprerneut eine Zeichenfolge zurückgegeben, die direkt verwendet / ausgeführt werden kann, während strdies als Debug-Ausgabe nützlicher ist.

v = Vector3([1,2,3])
print str(v)     #x: 1, y: 2, z: 3
print repr(v)    #Vector3([1,2,3])

Eine Sache, die Sie beachten sollten , wird automatisch aufgerufen , wenn sie strnicht definiert reprist . Es ist also immer gut, zumindest zu definierenstrreprrepr

Lassen Sie uns eine Klasse ohne __str__Funktion haben.

class Employee:

    def __init__(self, first, last, pay):
        self.first = first 
        self.last = last
        self.pay = pay

emp1 = Employee('Ivan', 'Smith', 90000)

print(emp1)

Wenn wir diese Instanz der Klasse drucken emp1, erhalten wir Folgendes:

<__main__.Employee object at 0x7ff6fc0a0e48>

Dies ist nicht sehr hilfreich, und dies ist sicherlich nicht das, was wir drucken möchten, wenn wir es zur Anzeige verwenden (wie in HTML).

Also jetzt die gleiche Klasse, aber mit __str__Funktion:

class Employee:

    def __init__(self, first, last, pay):
        self.first = first 
        self.last = last
        self.pay = pay

    def __str__(self):
        return(f"The employee {self.first} {self.last} earns {self.pay}.")
        # you can edit this and use any attributes of the class

emp2 = Employee('John', 'Williams', 90000)

print(emp2)

Anstatt zu drucken, dass es ein Objekt gibt, erhalten wir jetzt das, was wir mit der Rückgabe der __str__Funktion angegeben haben:

The employee John Williams earns 90000

strwird ein informelles und lesbares Format sein, während repreine offizielle Objektdarstellung gegeben wird.

class Complex:
    # Constructor
    def __init__(self, real, imag):
        self.real = real
        self.imag = imag

    # "official" string representation of an object
    def __repr__(self):
        return 'Rational(%s, %s)' % (self.real, self.imag)

    # "informal" string representation of an object (readable)
    def __str__(self):
        return '%s + i%s' % (self.real, self.imag)

    t = Complex(10, 20)

    print (t)     # this is usual way we print the object
    print (str(t))  # this is str representation of object 
    print (repr(t))  # this is repr representation of object   

Answers : 

Rational(10, 20) # usual representation
10 + i20      # str representation
Rational(10, 20)  # repr representation

str und repr sind beide Darstellungsweisen. Sie können sie verwenden, wenn Sie eine Klasse schreiben.

class Fraction:
def __init__(self, n, d):
    self.n = n
    self.d = d
def __repr__(self):
    return "{}/{}".format(self.n, self.d)

Wenn ich beispielsweise eine Instanz davon drucke, werden Dinge zurückgegeben.

print(Fraction(1, 2))

führt zu

1/2

während

class Fraction:
def __init__(self, n, d):
    self.n = n
    self.d = d
def __str__(self):
    return "{}/{}".format(self.n, self.d)
print(Fraction(1, 2))

führt auch zu

1/2

Aber was ist, wenn Sie beide schreiben, welches verwendet Python?

class Fraction:
def __init__(self, n, d):
    self.n = n
    self.d = d
def __str__(self):
    return "str"
def __repr__(self):
    return "repr"

print(Fraction(None, None))

Das führt zu

str

Python verwendet also tatsächlich die str- Methode und nicht die repr- Methode, wenn beide geschrieben sind.