__str__ 和 __repr__ 有什么区别？

Alex 总结得很好，但令人惊讶的是，它过于简洁。

首先，让我重申 Alex’s post 中的要点：

默认实现是无用的（很难想到一个不会，但是是的）

__repr__ 目标是明确的

__str__ 目标是可读的

容器的 __str__ 使用包含对象的 __repr__

默认实现没用

这主要是一个惊喜，因为 Python 的默认值往往相当有用。但是，在这种情况下，具有 __repr__ 的默认值，其行为如下：

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

会太危险（例如，如果对象相互引用，太容易陷入无限递归）。所以 Python 出局了。请注意，有一个默认值为 true：如果定义了 __repr__ 而未定义 __str__，则对象的行为就像 __str__=__repr__。

这意味着，简单来说：您实现的几乎每个对象都应该有一个可用于理解该对象的功能 __repr__。实现 __str__ 是可选的：如果您需要“漂亮打印”功能（例如，由报告生成器使用），请执行此操作。

__repr__ 的目标是明确的

让我直接说出来——我不相信调试器。我真的不知道如何使用任何调试器，也从未认真使用过。此外，我认为调试器的最大故障在于它们的基本性质——我调试的大多数故障都发生在很久很久以前，在一个遥远的星系中。这意味着我确实怀着宗教热情相信伐木。日志记录是任何体面的即发即弃服务器系统的命脉。 Python 使记录变得容易：可能使用一些特定于项目的包装器，您所需要的只是一个

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)

但是你必须做最后一步——确保你实现的每个对象都有一个有用的 repr，这样这样的代码才能正常工作。这就是为什么会出现“评估”的原因：如果您有足够的信息 eval(repr(c))==c，这意味着您了解有关 c 的所有信息。如果这很容易，至少以一种模糊的方式，那就去做吧。如果没有，请确保您有足够的关于 c 的信息。我通常使用类似 eval 的格式："MyClass(this=%r,that=%r)" % (self.this,self.that)。这并不意味着您可以实际构造 MyClass，或者这些是正确的构造函数参数 - 但它是一种有用的形式来表达“这是您需要了解的有关此实例的所有信息”。

注意：我在上面使用了 %r，而不是 %s。您总是希望在 __repr__ 实现中使用 repr() [或 %r 格式字符，等价地]，否则您将违背 repr 的目标。您希望能够区分 MyClass(3) 和 MyClass("3")。

__str__ 的目标是可读

具体而言，它并非旨在明确 — 请注意 str(3)==str("3")。同样，如果你实现一个 IP 抽象，让它的 str 看起来像 192.168.1.1 就可以了。在实现日期/时间抽象时，str 可以是“2010/4/12 15:35:22”等。目标是以用户而不是程序员想要阅读的方式表示它。砍掉无用的数字，假装是其他类——只要它支持可读性，它就是一种改进。

容器的 __str__ 使用包含对象的 __repr__

这似乎令人惊讶，不是吗？有点，但是如果使用他们的__str__，它的可读性如何？

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

不是特别的。具体来说，容器中的字符串会很容易干扰其字符串表示。面对歧义，请记住，Python 抵制猜测的诱惑。如果您在打印列表时想要上述行为，只需

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

（您可能还可以弄清楚如何处理字典。

概括

为您实现的任何类实现 __repr__。这应该是第二天性。如果您认为有一个在可读性方面出错的字符串版本会很有用，请实施 __str__。

---

我的经验法则：__repr__ 适用于开发人员，__str__ 适用于客户。

---

除非您特别采取行动以确保其他情况，否则大多数课程对以下任何一项都没有有用的结果：

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

如您所见——没有区别，除了类和对象的 id 之外没有任何信息。如果您只覆盖两者之一......：

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

如您所见，如果您覆盖 __repr__，则它也用于 __str__，但反之则不然。

要了解的其他重要花絮：内置容器上的 __str__ 使用 __repr__ 而不是 __str__ 来表示它包含的项目。而且，尽管在典型文档中找到了有关该主题的文字，但几乎没有人会费心将对象的 __repr__ 设为 eval 可以用来构建相等对象的字符串（这太难了，而且不知道相关模块如何实际上是进口的，这实际上是不可能的）。

因此，我的建议是：专注于使 __str__ 合理地可读，并使 __repr__ 尽可能明确，即使这会干扰使 __repr__ 的返回值可以作为 { 的输入而无法实现的模糊目标4}！

---

__repr__：python 对象的表示，通常 eval 会将其转换回该对象

__str__：是您认为的任何文本形式的对象

例如

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

---

简而言之，__repr__ 的目标是明确的，而 __str__ 是可读的。

这是一个很好的例子：

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

阅读此文档以获取 repr：

repr(object) 返回一个包含对象的可打印表示的字符串。这与转换（反向引号）产生的值相同。有时能够将此操作作为普通函数访问是很有用的。对于许多类型，此函数尝试返回一个字符串，该字符串在传递给 eval() 时会产生具有相同值的对象，否则表示是一个包含在尖括号中的字符串，其中包含对象类型的名称附加信息通常包括对象的名称和地址。类可以通过定义 __repr__() 方法来控制此函数为其实例返回的内容。

这是 str 的文档：

str(object='') 返回一个字符串，该字符串包含一个对象的可打印表示。对于字符串，这将返回字符串本身。与 repr(object) 的区别在于 str(object) 并不总是试图返回一个 eval() 可接受的字符串；它的目标是返回一个可打印的字符串。如果没有给出参数，则返回空字符串 ''。

---

Python 中的 __str__ 和 __repr__ 有什么区别？

__str__（读作“dunder（双下划线）字符串”）和 __repr__（读作“dunder-repper”（表示“表示”））都是基于对象状态返回字符串的特殊方法。

如果缺少 __str__，__repr__ 会提供备份行为。

因此，首先应该编写一个 __repr__，它允许您从它返回的字符串中重新实例化一个等效对象，例如使用 eval 或在 Python shell 中逐个字符地键入它。

在以后的任何时候，当人们认为有必要时，可以为实例的用户可读字符串表示形式编写 __str__。

__str__

如果您打印一个对象，或将其传递给 format、str.format 或 str，则如果定义了 __str__ 方法，则将调用该方法，否则将使用 __repr__。

__repr__

__repr__ 方法由内置函数 repr 调用，当它计算返回对象的表达式时，它会在您的 python shell 上回显。

由于它为__str__提供了备份，如果您只能写一个，请从__repr__开始

这是 repr 的内置帮助：

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

也就是说，对于大多数对象，如果您输入 repr 打印的内容，您应该能够创建一个等效的对象。 但这不是默认实现。

__repr__ 的默认实现

默认对象 __repr__ 是 (C Python source) 类似于：

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

这意味着默认情况下，您将打印对象来自的模块、类名以及其在内存中位置的十六进制表示 - 例如：

<__main__.Foo object at 0x7f80665abdd0>

这些信息不是很有用，但没有办法推导出如何准确地创建任何给定实例的规范表示，总比没有好，至少告诉我们如何在内存中唯一地识别它。

__repr__ 如何有用？

让我们看看它有多么有用，使用 Python shell 和 datetime 对象。首先我们需要导入 datetime 模块：

import datetime

如果我们在 shell 中调用 datetime.now，我们将看到重新创建等效日期时间对象所需的一切。这是由日期时间 __repr__ 创建的：

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

如果我们打印一个日期时间对象，我们会看到一种很好的人类可读（实际上是 ISO）格式。这是由 datetime 的 __str__ 实现的：

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

重新创建我们丢失的对象是一件简单的事情，因为我们没有通过从 __repr__ 输出复制和粘贴来将它分配给变量，然后打印它，我们在与另一个相同的人类可读输出中得到它目的：

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

#如何实现它们？

在开发过程中，如果可能，您将希望能够以相同的状态重现对象。例如，这就是 datetime 对象定义 __repr__ (Python source) 的方式。它相当复杂，因为复制这样一个对象所需的所有属性：

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

如果您希望您的对象具有更易读的表示，您可以接下来实现 __str__。以下是日期时间对象 (Python source) 实现 __str__ 的方式，它很容易做到，因为它已经有一个以 ISO 格式显示它的函数：

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

设置 __repr__ = __str__?

这是对此处建议设置 __repr__ = __str__ 的另一个答案的批评。

设置 __repr__ = __str__ 很愚蠢 - __repr__ 是 __str__ 的后备，而为开发人员在调试中使用而编写的 __repr__ 应该在编写 __str__ 之前编写。

仅当您需要对象的文本表示时才需要 __str__。

结论

为您编写的对象定义 __repr__，以便您和其他开发人员在开发时使用它时有一个可重现的示例。当您需要人类可读的字符串表示形式时定义 __str__。

---

在 Hans Petter Langtangen 所著的 Python scripting for Computing Science 一书的第 358 页上，它明确指出

__repr__ 针对对象的完整字符串表示；

__str__ 是返回一个漂亮的字符串进行打印。

所以，我更愿意将它们理解为

repr = 再现

str = 字符串（表示）

从用户的角度来看，虽然这是我在学习python时犯的一个误解。

同一页面上还给出了一个小而好的示例，如下所示：

例子

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'

---

除了给出的所有答案，我想补充几点：-

1) 当您在交互式 python 控制台上简单地写入对象的名称并按 Enter 键时，会调用 __repr__()。

2) __str__() 在您使用带有 print 语句的对象时被调用。

3) 如果缺少 __str__，则 print 和任何使用 str() 的函数调用对象的 __repr__()。

4) __str__() 的容器，调用时将执行其包含的元素的 __repr__() 方法。

5) 在 __str__() 中调用的 str() 可能会在没有基本情况的情况下进行递归，并且最大递归深度会出错。

6) __repr__() 可以调用 repr()，它将尝试自动避免无限递归，用 ... 替换已经表示的对象。

---

（2020 项）

问：__str__() 和 __repr__() 有什么区别？

https://i.stack.imgur.com/cpqeK.png

长

这个问题已经存在了很长时间，并且有各种各样的答案，其中大多数是正确的（更不用说来自几个 Python 社区的传说[！]）。然而，当涉及到细节时，这个问题类似于询问 str() 和 repr() 内置函数之间的区别。我将用我自己的话来描述这些差异（这意味着我可能从 Core Python Programming 大量“借用”了，所以请原谅我）。

str() 和 repr() 都有相同的基本工作：它们的目标是返回 Python 对象的字符串表示形式。字符串表示的种类是它们的区别。

str() & __str__() 返回一个对象的可打印字符串表示......人类可读/供人类消费的东西

repr() 和 __repr__() 返回一个对象的字符串表示，它是一个有效的 Python 表达式，一个可以传递给 eval() 或键入 Python shell 而不会出错的对象。

例如，让我们将一个字符串分配给 x，将一个 int 分配给 y，并简单地显示每个字符串的人类可读的字符串版本：

>>> x, y = 'foo', 123
>>> str(x), str(y)
('foo', '123')

我们可以把这两种情况下的引号内的内容逐字输入到 Python 解释器中吗？试一试吧：

>>> 123
123
>>> foo
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'foo' is not defined

显然，您可以使用 int，但不一定适用于 str。同样，虽然我可以将 '123' 传递给 eval()，但它不适用于 'foo'：

>>> eval('123')
123
>>> eval('foo')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<string>", line 1, in <module>
NameError: name 'foo' is not defined

因此，这告诉您 Python shell eval()就是您给它的。知道了？现在，让我们repr() 两个表达式，看看我们得到了什么。更具体地说，取出它的输出并将 那些 转储到解释器中（有一点我们将在之后解决）：

>>> repr(x), repr(y)
("'foo'", '123')
>>> 123
123
>>> 'foo'
'foo'

哇，他们都工作？这是因为 'foo' 虽然是该字符串的可打印字符串表示，但它不可 可评估，但 "'foo'" 可以。 123 是由 str() 或 repr() 调用的有效 Python int。当我们用这些调用 eval() 时会发生什么？

>>> eval('123')
123
>>> eval("'foo'")
'foo'

它之所以有效，是因为 123 和 'foo' 是有效的 Python 对象。另一个关键要点是，虽然有时两者都返回相同的东西（相同的字符串表示），但情况并非总是如此。 （是的，是的，我可以在 eval() 起作用的地方创建一个变量 foo，但这不是重点。）

关于这两对的更多事实

有时，str() 和 repr() 被隐式调用，这意味着它们是代表用户调用的：当用户执行 print (Py1/Py2) 或调用 print() (Py3+) 时，即使用户不调用 str( ) 明确地，在显示对象之前代表他们进行此类调用。在 Python shell（交互式解释器）中，如果在 >>> 提示符下输入变量并按 RETURN，解释器会显示对该对象隐式调用的 repr() 的结果。要将 str() 和 repr() 连接到 __str__() 和 __repr__()，请意识到调用内置函数，即 str(x) 或 repr(y) 会导致调用其对象的相应特殊方法：x。 __str__() 或 y.__repr()__ 通过为 Python 类实现 __str__() 和 __repr__()，可以重载内置函数（str() 和 repr()），从而允许传入类的实例到 str() 和 repr()。当进行此类调用时，它们会转身并调用类的 __str__() 和 __repr__()（根据 #3）。

---

简而言之：

__str__ 用于显示您的对象的字符串表示便于他人阅读。

__repr__ 用于显示 对象的字符串表示形式。

假设我想创建一个 Fraction 类，其中分数的字符串表示形式为“(1/2)”，而对象（分数类）表示为“分数 (1,2)”

所以我们可以创建一个简单的 Fraction 类：

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)

---

来自 effbot 的 an (An Unofficial) Python Reference Wiki (archive copy)：

__str__ "计算对象的“非正式”字符串表示。这与 __repr__ 的不同之处在于它不必是有效的 Python 表达式：可以使用更方便或更简洁的表示。"

---

__repr__ 绝不需要返回有效的 Python 表达式。