Moja zasada: __repr__ jest dla programistów, __str__ jest dla klientów.

O ile nie działasz specjalnie w celu zapewnienia, że jest inaczej, większość klas nie ma przydatnych wyników dla obu:

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

Jak widzisz -- brak różnicy i żadnych informacji poza klasą i obiektem id. Jeśli obejdziesz tylko jedno z dwóch...:

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

Jak widzisz, Jeśli nadpisujesz __repr__, to jest również używane dla __str__, ale nie odwrotnie.

Inne ważne Ciekawostki: __str__ na wbudowanym kontenerze używa __repr__, a nie __str__, dla elementów, które zawiera. I pomimo słowa na ten temat Znalezione w typowych dokumentach, prawie nikt nie przeszkadza czyniąc __repr__ obiektów ciągiem znaków, który eval może użyć do zbudowania równego obiektu(jest to po prostu zbyt trudne ,a nie wiedząc, jak dany moduł został zaimportowany, sprawia, że jest to rzeczywiście niemożliwe).

Tak więc, moja rada: skup się na uczynieniu __str__ w miarę czytelnym dla człowieka i __repr__ tak jednoznacznym, jak tylko możesz, nawet jeśli przeszkadza to w rozmytym, nieosiągalnym celu tworzenia zwracanej wartości __repr__ akceptowalne jako wejście do __eval__!

__repr__: reprezentacja obiektu Pythona Zwykle EVAL przekonwertuje go z powrotem do tego obiektu

__str__: czy cokolwiek myślisz jest tym obiektem w formie tekstowej

Np.

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

W skrócie, celem {[1] } jest być jednoznacznym i __str__ jest być czytelne.

Oto dobry przykład:

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

Przeczytaj tę dokumentację do repr:

repr(object)

Zwraca łańcuch zawierający drukowalną reprezentację obiektu. Jest to ta sama wartość otrzymywana przez konwersje (odwrotność cytaty). Czasami warto mieć dostęp do tej operacji jako zwykła funkcja. Dla wielu typów funkcja ta sprawia, że próba zwracać ciąg znaków, który dałby obiekt o tej samej wartości, gdy przekazywana do eval(), w przeciwnym wypadku reprezentacja jest łańcuchem zamkniętym w nawiasy kątowe zawierające nazwę typu obiektu wraz z dodatkowymi informacjami często zawierającymi nazwę i adres obiektu. Klasa może kontrolować to, co zwraca ta funkcja dla jego instancji poprzez zdefiniowanie metody __repr__().

Oto dokumentacja dla str:

str(object='')

Return a string containing a nice printable reprezentacja obiektu. W przypadku łańcuchów zwraca łańcuch siebie. Różnica z repr(object) jest taka, że str(object) nie zawsze próbuje zwrócić łańcuch, który jest akceptowalny dla eval(); jego celem jest zwrócenie drukowalnego ciągu znaków. Jeśli nie podano argumentu, zwraca pusty łańcuch ''.

Jaka jest różnica między __str__ a __repr__ w Pythonie?

__str__ (odczytywane jako "Dunder (double-underscore) string") oraz __repr__ (odczytywane jako "Dunder-repper" (dla "reprezentacji")) są specjalnymi metodami, które zwracają łańcuchy znaków na podstawie stanu obiektu.

__repr__ zapewnia zachowanie kopii zapasowej, jeśli brakuje __str__.

Należy więc najpierw napisać __repr__, który pozwala na ponowne określenie równoważnego obiektu z zwracanego ciągu znaków np. za pomocą eval lub wpisując go w znak-za-znak w powłoce Pythona.

W dowolnym momencie później można napisać __str__ dla czytelnej dla użytkownika reprezentacji łańcuchowej instancji, jeśli uważa się, że jest to konieczne.

__str__

Jeśli wydrukować obiekt, lub przekazać go do format, str.format, lub str, wtedy jeśli zdefiniowana jest metoda __str__, zostanie ona wywołana, w przeciwnym razie zostanie użyta metoda __repr__.

__repr__

Metoda __repr__ jest wywoływana przez wbudowaną funkcję {[26] } i jest tym, co odbija się echem w powłoce Pythona, gdy ocenia wyrażenie, które zwraca obiekt.

Ponieważ zapewnia kopię zapasową dla __str__, jeśli możesz napisać tylko jedną, zacznij od __repr__

Oto pomoc narepr:

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

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

Oznacza to, że dla większości obiektów, jeśli wpiszesz to, co jest wydrukowane przez repr, powinieneś być w stanie utworzyć równoważny obiekt. ale nie jest to domyślna implementacja.

Domyślna implementacja __repr__

Domyślnym obiektem __repr__ jest (C Python source ) coś w stylu:

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

Oznacza to, że domyślnie wyświetli się moduł, z którego pochodzi obiekt, nazwa klasy i szesnastkowa reprezentacja jego lokalizacji w pamięci - na przykład:

<__main__.Foo object at 0x7f80665abdd0>

Ta informacja nie jest zbyt przydatna, ale nie ma sposobu, aby wyprowadzić, jak można dokładnie stworzyć kanoniczną reprezentację danej instancji, a to lepsze niż nic, przynajmniej mówienie nam, jak może go jednoznacznie zidentyfikować w pamięci.

W Jaki Sposób __repr__ może być przydatny?

Przyjrzyjmy się, jak przydatna może być powłoka Pythona i Obiekty datetime. Najpierw musimy zaimportować moduł datetime:

import datetime

Jeśli wywołamy datetime.now w powłoce, zobaczymy wszystko, czego potrzebujemy do odtworzenia równoważnego obiektu datetime. To jest tworzone przez datetime __repr__:

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

Jeśli drukujemy obiekt datetime, widzimy ładny czytelny dla człowieka format (w rzeczywistości ISO). Jest to realizowane by datetime ' s __str__:

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

Jest to prosta sprawa, aby odtworzyć obiekt, który straciliśmy, ponieważ nie przypisaliśmy go do zmiennej, kopiując i wklejając z wyjścia __repr__, a następnie drukując go, i otrzymujemy go w tym samym czytelnym dla człowieka wyjściu, co drugi obiekt:

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

Jak je wdrożyć?

W miarę rozwoju, będziesz chciał móc reprodukować obiekty w tym samym stanie, jeśli to możliwe. Tak na przykład obiekt datetime definiuje __repr__ (źródło Pythona ). Jest to dość skomplikowane, ze względu na wszystkie atrybuty potrzebne do odtworzenia takiego obiektu: [58]}

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 = ", ".join(map(str, L))
    s = "%s(%s)" % ('datetime.' + self.__class__.__name__, s)
    if self._tzinfo is not None:
        assert s[-1:] == ")"
        s = s[:-1] + ", tzinfo=%r" % self._tzinfo + ")"
    return s

Jeśli chcesz, aby twój obiekt miał bardziej czytelną reprezentację, możesz zaimplementować __str__ next. Oto jak obiekt datetime (źródło Pythona ) implementuje __str__, co łatwo robi, ponieważ ma już funkcję wyświetlania go w formacie ISO:

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

Zestaw __repr__ = __str__?

Jest to krytyka innej odpowiedzi tutaj, że sugeruje ustawienie __repr__ = __str__.

Ustawienie __repr__ = __str__ jest głupie - __repr__ jest alternatywą dla __str__ i __repr__, napisany dla programistów użycie w debugowaniu, powinien być napisany przed napisaniem __str__.

Potrzebujesz __str__ tylko wtedy, gdy potrzebujesz tekstowej reprezentacji obiektu.

Podsumowanie

Zdefiniuj __repr__ dla obiektów, które piszesz, więc ty i inni programiści macie powtarzalny przykład, gdy używacie go podczas tworzenia. Define __str__ gdy potrzebujesz czytelnego dla człowieka ciągu znaków reprezentowanie go.

Oprócz wszystkich udzielonych odpowiedzi, chciałbym dodać kilka punktów:-

1) __repr__() jest wywoływane, gdy po prostu wpisujesz nazwę obiektu na interaktywnej konsoli Pythona i naciskasz klawisz enter.

2) __str__() jest wywoływana podczas używania obiektu z instrukcją print.

3) w przypadku braku __str__, print i Dowolna funkcja używająca str() wywołuje __repr__() obiektu.

4) __str__() kontenerów, po wywołaniu wykona metodę __repr__() z zawartych w niej elementów.

5) str() wywołane wewnątrz __str__() może potencjalnie rekurencyjnie bez przypadku podstawowego i błędu na maksymalnej głębokości rekurencji.

6) __repr__() może wywołać repr(), które będzie próbowało uniknąć nieskończonej rekurencji automatycznie, zastępując już reprezentowany obiekt ....

Na stronie 358 książki Python scripting for computational science autor: Hans Petter Langtangen, wyraźnie stwierdza, że

• __repr__ ma na celu kompletną reprezentację ciągu znaków obiektu;
• {[2] } jest zwrócenie ładnego ciągu do drukowania.

Więc wolę je rozumieć jako

• repr = reproduce
• str = string (representation)

Z punktu widzenia użytkownika chociaż to nieporozumienie, które popełniłem podczas nauki Pythona.

Mały, ale dobry przykład jest również podany na tej samej stronie w następujący sposób:

Przykład

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'

Szczerze mówiąc, eval(repr(obj)) nigdy nie jest używany. Jeśli znajdziesz się przy jego użyciu, powinieneś przestać, ponieważ eval jest niebezpieczne, a łańcuchy są bardzo nieefektywnym sposobem serializacji obiektów (zamiast tego użyj pickle).

Dlatego polecam ustawienie __repr__ = __str__. Powodem jest to, że str(list) wywołuje repr na elementach (uważam to za jedną z największych wad projektowych Pythona, które nie zostały rozwiązane przez Pythona 3). Rzeczywisty repr prawdopodobnie nie będzie zbyt pomocny jako wynik print [your, objects].

Aby to zakwalifikować, z mojego doświadczenia, najbardziej użytecznym przypadkiem użycia funkcji repr jest umieszczenie łańcucha wewnątrz innego łańcucha (używając formatowania łańcucha). W ten sposób nie musisz się martwić o unikanie cytatów lub czegokolwiek. Ale zauważ, że nie ma eval dzieje się tutaj.

Mówiąc prościej:

__str__ jest używany do wyświetlania reprezentacji łańcucha znaków Twojego obiektu do łatwego odczytu przez innych.

__repr__ jest używany do pokazania reprezentacji ciągu obiektu.

Załóżmy, że chcę utworzyć klasę Fraction, w której łańcuchowa reprezentacja ułamka to " (1/2)", a obiekt (Klasa ułamkowa) ma być reprezentowany jako "ułamek (1,2)"

Więc możemy utworzyć prostą klasę ułamkową:

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)

Z http://pyref.infogami.com/__str _ _ by effbot:

__str__ "oblicza" nieformalną " reprezentację łańcuchową obiektu. Różni się to od __repr__ tym, że nie musi być poprawnym wyrażeniem Pythona: zamiast tego można użyć bardziej wygodnej lub zwięzłej reprezentacji."

Jeden aspekt, którego brakuje w innych odpowiedziach. To prawda, że ogólnie wzór jest następujący:

• cel __str__: czytelny dla człowieka
• Cel __repr__: jednoznaczny, możliwy do odczytu maszynowego przez eval

Niestety, to rozróżnienie jest wadliwe, ponieważ Python REPL i IPython używają {[1] } do drukowania obiektów w konsoli REPL (zobacz powiązane pytania dla Python i IPython ). Tak więc, projekty, które są ukierunkowane na interaktywne Numpy lub Pandy) zaczęły ignorować powyższe reguły i zamiast tego dostarczać czytelną dla człowieka implementację __repr__.

str - wytworzy nowy obiekt string z podanego obiektu.

repr - zwraca kanoniczną reprezentację łańcuchową obiektu.

Różnice:

Str():

• sprawia, że obiekt jest czytelny
• generuje wyjście dla użytkownika końcowego

Repr():

• potrzebuje kodu, który odtwarza obiekt
• generuje wyjście dla programisty

Doskonałe odpowiedzi pokrywają już różnicę między __str__ i __repr__, co dla mnie sprowadza się do tego, że pierwsza jest czytelna nawet przez użytkownika końcowego, a druga jest jak najbardziej przydatna dla programistów. Biorąc to pod uwagę, uważam, że domyślna implementacja __repr__ często nie osiąga tego celu, ponieważ pomija informacje przydatne dla programistów.

Z tego powodu, jeśli mam wystarczająco proste __str__, generalnie staram się uzyskać to, co najlepsze z obu światów z czymś like:

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

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

Gdy print() jest wywołany na wyniku dziesiętnego.Decimal (23) / deci-mal.Decimal("1.05") wypisywana jest liczba surowa; wyjście to ma postać string , którą można uzyskać za pomocą __str _ _ (). Jeśli po prostu wprowadzimy wyrażenie, otrzymamy dziesiętne.Wyjście dziesiętne - to wyjście ma postać reprezentacyjną , którą można uzyskać za pomocą __repr _ _ (). Wszystkie obiekty Pythona mają dwie formy wyjściowe. Forma ciągów jest zaprojektowana tak, aby była czytelna dla człowieka. Forma reprezentacyjna jest przeznaczona do produkcji wyjście, że jeśli zostanie przekazane interpreterowi Pythona, (jeśli to możliwe) ponownie wytworzy reprezentowany obiekt

Należy pamiętać, że kontener __str__ używa zawartych obiektów ' __repr__.

>>> 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 preferuje jednoznaczność nad czytelnością , __str__ wywołanie tuple wywołuje zawarte obiekty ' __repr__, "formalną" reprezentację obiektu. Chociaż formalna reprezentacja jest trudniejsza do odczytania niż nieformalna, jest jednoznaczna i bardziej odporna na błędy.

"A basic requirement for a Python object is to provide usable 
 string   representations of itself, one used for debugging and
 logging, another for presentation to end users. That is why the  
 special methods __repr__ and __str__ exist in the data model."

Z książki: Fluent Python

W skrócie:

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'

Zrozumieć __str__ i __repr__ intuicyjnie i trwale odróżnić je w ogóle.

__str__ zwraca ciąg ukrytego ciała danego obiektu w celu odczytania oczu
__repr__ zwraca rzeczywiste ciało danego obiektu (zwraca się samo) dla jednoznaczności do identyfikacji.

Zobacz to na przykładzie

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

Jak __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.

Możemy wykonać operację arytmetyczną na wynikach __repr__ wygodnie.

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)

Jeśli zastosujemy operację na __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'

Zwraca tylko błąd.

Kolejny przykład.

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

Mam nadzieję, że to pomoże Ci zbudować konkretne podstawy, aby zbadać więcej odpowiedzi.

Tak dużo jaśniej z blog

Str jest jak toString. utworzone, aby można było wydrukować dane repr jest jak serialize, lub ogórek. Jak odtworzyć Ten obiekt, jeśli muszę to zrobić za pomocą eval ()

>>> import datetime
>>> now = datetime.datetime.now() 
>>> str(now)
'2015-04-04 20:51:31.766862'
>>> repr(now)
'datetime.datetime(2015, 4, 4, 20, 51, 31, 766862)'
>>mydate = eval(repr(now))

__repr__ jest używany wszędzie, z wyjątkiem print i str, Gdy __str__ jest zdefiniowane