python中魔法方法__str__与__repr__的区别

提出问题

当我们自定义一个类时，打印这个类对象或者在交互模式下直接输入这个类对象按回车，默认显示出来的信息好像用处不大。如下所示

In [1]: class People: 
   ...:     def __init__(self, name, sex): 
   ...:         self.name = name 
   ...:         self.sex = sex 
   ...:                                                                         

In [2]: p = People('xiaoming', 'male')                                          

In [3]: p                                                                       
Out[3]: <__main__.People at 0x7fd0df745400>

In [4]: print(p)                                                                
<__main__.People object at 0x7fd0df745400>

可以发现，两种方式显示出来的信息都是对象所属类的名称以及对象所在的地址，而很多时候这不是我们想要的信息，此时我们可以通过重写__str__和__repr__方法来定制我们想要的信息。

str与repr简单介绍

__str__ 和 __repr__ 方法，是自定义类的字符串描述，当我们打印或查看某个对象时，最终看到的结果是这两个方法的返回值。这两个方法返回的都是字符串，但是什么时候调用__str__？什么时候调用__repr__？我们看下面的例子

类中只重写了str方法

In [1]: class A: 
   ...:     def __str__(self): 
   ...:         return '__str__' 
   ...:                                                                         

In [2]: a = A()                                                                 

In [3]: a                                                                       
Out[3]: <__main__.A at 0x7ffb3f2ba048>

In [4]: print(a)                                                                
__str__

在交互模式下，直接输入对象再回车，返回的结果与原来一样；但是打印对象时，触发了__str__方法。

类中只重写了repr方法

In [1]: class B: 
   ...:     def __repr__(self): 
   ...:         return '__repr__' 
   ...:                                                                         

In [2]: b = B()                                                                 

In [3]: b                                                                       
Out[3]: __repr__

In [4]: print(b)                                                                
__repr__

在交互模式下，直接输入对象再回车以及打印对象都触发了__repr__方法。

类中重写了str与repr方法

In [1]: class C: 
   ...:     def __str__(self): 
   ...:         return '__str__' 
   ...:     def __repr__(self): 
   ...:         return '__repr__' 
   ...:                                                                         

In [2]: c = C()                                                                 

In [3]: c                                                                       
Out[3]: __repr__

In [4]: print(c)                                                                
__str__

在交互模式下，直接输入对象再回车，触发了__repr__方法；打印对象触发__str__方法。

总结一下，当我们直接查看对象（输入对象再回车）时，无论怎样触发的都是__repr__方法；如果自定义类中没有重写这个方法，我们知道Python3中都是新式类，即默认都继承了object类，那么此时就会调用object中的__repr__方法。当我们打印对象时，大多数情况触发的都是__str__方法，但当自定义类中只重写了__repr__方法时，会触发__repr__方法。

str()和repr()函数

str()默认触发__str__方法，repr()默认触发__repr__方法，触发的机制与上述一样；另外，列表、字典等容器总是会触发__repr__方法，代码示例如下：

# 类中只重写了__str__方法
In [5]: str(a)                                                                  
Out[5]: '__str__'

In [6]: repr(a)                                                                 
Out[6]: '<__main__.A object at 0x7ffb3f2ba048>'

# 类中只重写了__repr__方法 
In [5]: str(b)                                                                  
Out[5]: '__repr__'

In [6]: repr(b)                                                                 
Out[6]: '__repr__'

# 类中重写了__str__与__repr__方法 
In [5]: str(c)                                                                 
Out[5]: '__str__'

In [6]: repr(c)                                                                
Out[6]: '__repr__'

# 列表、字典等容器总是会触发__repr__方法  
In [53]: print([a])                                                             
[<__main__.A object at 0x7ffb3f2ba048>]                                                         
                                                              
In [7]: str([c])                                                               
Out[7]: '[__repr__]'

In [8]: repr([c])                                                              
Out[8]: '[__repr__]'

In [9]: [c]                                                                    
Out[9]: [__repr__]

In [10]: print([c])                                                             
[__repr__]

str与repr的本质区别

那__str__与__repr__的本质区别到底是什么呢？先看官方描述

__str__: Called by str(object) and the built-in functions format() and print() to compute the “informal” or nicely printable string representation of an object.
__repr__: Called by the repr() built-in function to compute the “official” string representation of an object. This is typically used for debugging, so it is important that the representation is information-rich and unambiguous.

总结一下，__str__是一个对象的非正式的、易于阅读的字符串描述，当类str实例化（ str(object) ）时会被调用，以及会被内置函数format()和print()调用；__repr__是一个对象的官方的字符串描述，会被内置函数repr()方法调用，它的描述必须是信息丰富的和明确的。也就是说__str__返回的结果可读性强，__repr__返回的结果更加准确。再看一个例子

In [1]: import datetime                                                         

In [2]: d = datetime.datetime.now()                                             

In [3]: str(d)                                                                  
Out[3]: '2019-08-24 08:12:17.942242'    # 可读性强

In [4]: repr(d)                                                                 
Out[4]: 'datetime.datetime(2019, 8, 24, 8, 12, 17, 942242)'    # 信息更加丰富和准确

总结

在自定义类中，可以通过重写__str__和__repr__方法来定制类对象到字符串的转化。
一般情况下，推荐至少添加一个 __repr__ 方法来定制对象到字符串的自定义转化，__str__ 是可选的。因为默认情况下，在需要却找不到 __str__ 方法的时候，会自动调用 __repr__ 方法。
__str__方法的目标在于可读性，__repr__方法的目标在于准确性。