1 什么是魔法函数¶

先来定义一个类：

In[1]:

class Company(object):def __init__(self, employee_list):self.employee_list = employee_list

In[4]:

company = Company([\'张三\', \'李四\', \'王五\'])print(company)

<__main__.Company object at 0x7f7c4046ebd0>

此时，直接对Company实例化的对象进行print输出时，打印出来的信息是类名称和地址信息。但如果我们想看的不是这些，而是想输出employee_list，怎么做呢？

In[7]:

class Company(object):def __init__(self, employee_list):self.employee_list = employee_listdef __str__(self):return str(self.employee_list)

In[8]:

company = Company([\'张三\', \'李四\', \'王五\'])print(company)

[\'张三\', \'李四\', \'王五\']

在这个例子中，我们添加了一个

__str__()

函数，然后再打印输出Company类实例时，输出的就是employee_list，但是，我们并没有显式地调用

__str__()

函数，这是因为，在对一个实例使用print()函数时，Python内部机制自动会调用

__str__()

函数。

类似

__str__()

这种函数在类内部还有很多，这一类函数，我们统称为魔法函数。现在，我们明确一下魔法函数的范畴：

魔法函数是指类内部以双下划线开头，并且以双下划线结尾的函数，在特定时刻，Python会自动调用这些函数。魔法函数不是通过继承等机制获得的，而是类一旦定义，Python内部机制自动会给类赋予这些特殊的函数，且用户是不能创建魔法函数的，即使函数名以双下划线开头和双下划线结尾。通过魔法函数可以实现许多个性化、便捷的操作。

2 Python中的魔法函数¶

2.1 字符串表示：

__str__

、

__repr__

¶

• __str__

• __repr__

在很多时候，人们都容易将

__str__

和

__repr__

两个方法记混，甚至认为这两的功能是一样的，但事实上还是有一些差异的。

__str__

在上文中已经说过，是用于将实例对象进行print输出时使用。如下所示：

In[17]:

class Company(object):def __init__(self, name=None):self.name = namedef __str__(self):return \'*****公司名称为：%s*****\' % self.name

In[18]:

c = Company(name=\'腾讯\')print(c)

*****公司名称为：腾讯*****

对实例化对象是用print()函数输出时，Python内部机制会想调用str()方法，在str()方法内部继续调用

__str__

方法实现输出：

In[23]:

str(c)

Out[23]:

\'*****公司名称为：腾讯*****\'

但是如果我们不是用print()函数而直接输出c，那么，输出结果依然是原来默认的：

In[19]:

c

Out[19]:

<__main__.Company at 0x7f7c4049d050>

这是因为直接输出类实例化对象时，调用的是

__repr__

方法：

In[20]:

class Company(object):def __init__(self, name=None):self.name = namedef __str__(self):return \'*****公司名称为：%s*****\' % self.namedef __repr__(self):return \'#####公司名称为：%s#####\' % self.name

In[22]:

c = Company(name=\'腾讯\')c

Out[22]:

#####公司名称为：腾讯#####

综上所述，

__str__

和

__repr__

的区别在于，

__str__

方法在对实例化对象是用print()函数输出时调用，其实时Python内部机制调用str()方法，然后str()方法内部继续调用

__str__

方法获取输出字符串。而

__repr__

是在开发模式下直接输出实例化对象时被调用。

2.2 集合、序列相关：

__len__

、

__getitem__

、

__setitem__

、

__delitem__

、

__contains__

¶

• __len__

Python内置函数中有一个len()函数，这个函数适用于获取序列类型数据的长度，在对一个实例使用len()方法时，真实输出的其实是

__len__

的返回值。所以，只要一个类内部实现了

__len__

方法，就可以对其实例使用

__len__

方法。

In[24]:

class Company(object):def __init__(self, name=None, employee_lst=None):self.name = nameself.employee_lst = employee_lstdef __len__(self):return len(self.employee_lst)

In[26]:

c = Company(name=\'腾讯\', employee_lst=[\'张三\', \'李四\', \'王五\'])len(c)

Out[26]:

3

• __getitem__

  、

  __setitem__

  、

  __delitem__

我们知道，在Python的dict类型数据中，可以通过方括号的方式来赋值、取值和删除值，例如通过t_dict[\’attr1\’] = 1的方式进行赋值，通过t_dict[\’attr1\’]可以取得值，通过del t_dict[\’attr1\’]可以删除一个值。那么在自定义的一个类里面，通过

__getitem__

、

__setitem__

、

__delitem__

这三个，我们也可以让我们自定义类的实例化对象拥有这样的操作。

In[48]:

class Company(object):def __init__(self):self.company_info = {}def __setitem__(self,key,value):  # 令类实例化对象可以通过c[key] = value的方式赋值self.company_info[key] = valuedef __getitem__(self,key):          # 令类实例化对象可以通过c[key]的方式取值return self.company_info[key]def __delitem__(self, key):          # 令类实例化对象可以通过del c[key]的方式删除值del self.company_info[key]

In[51]:

c = Company()c[\'name\'] = \'腾讯\'c[\'type\'] = \'IT\'print(c[\'name\'])del c[\'name\']print(c.company_info)

腾讯{\'type\': \'IT\'}

有些时候，配合Python的反射机制类使用这三个魔法函数会有更加魔幻的效果，可以直接对实例属性进行操作：

In[59]:

class Company(object):def __setitem__(self,key,value):setattr(self, key, value)def __getitem__(self,key):return getattr(self, key)def __delitem__(self, key):delattr(self, key)

In[60]:

c = Company()c[\'name\'] = \'腾讯\'c[\'type\'] = \'IT\'

In[61]:

c[\'type\']

Out[61]:

\'IT\'

In[62]:

del c[\'type\']

In[63]:

c[\'type\']

---------------------------------------------------------------------------AttributeError                            Traceback (most recent call last)<ipython-input-63-56601054285d> in <module>----> 1c[\'type\']<ipython-input-59-b82d5d10cbb4> in __getitem__(self, key)56     def __getitem__(self,key):----> 7return getattr(self, key)89     def __delitem__(self, key):AttributeError: \'Company\' object has no attribute \'type\'

• __contains__

对于Python中dict类型的数据结构，可以使用

in

关键字判断序列内部是否包含某个key，在我们自定义的类中，如果定义了

__contains__

方法，那么也能使用

in

关键字判断是否包含某个属性。

In[67]:

class Company(object):def __init__(self):self.company_info = {}def __contains__(self, key):return key in self.company_info

In[69]:

c = Company()c.company_info[\'name\'] = \'腾讯\'print(\'name\' in c)print(\'type\' in c)

TrueFalse

结合反射机制使用：

In[70]:

class Company(object):def __setitem__(self,key,value):setattr(self, key, value)def __contains__(self, key):return hasattr(self, key)

In[75]:

c = Company()c[\'name\'] = \'腾讯\'print(\'name\' in c)print(\'type\' in c)

TrueFalse

2.3 迭代相关：

__iter__

、

__next__

¶

• __iter__

  、

  __next__

我之前写过一篇博客《为什么for循环可以遍历list：Python中迭代器与生成器》，很详细得介绍了Python中关于迭代器与生成器的原理。关于迭代器和生成器，其核心就在于

__iter__

和

__next__

两个方法。

iter是Iterable的简写，表示“可迭代的”，所以，任何内部定义了

__iter__

的对象，我们都可以称之为可迭代对象，在Python中，有一个类专门与之对应：Iterable，我们可以通过判断对象是否是Iterable类的实例来判断是否是可迭代对象。进一步的，如果一个类内部定义了

__iter__

方法的同时，也定了

__next__

方法，那么，它的实例化对象就是迭代器，也有一个类与迭代器对应，那就是Iterator。

In[99]:

from collections.abc import Iterablefrom collections.abc import Iterator

In[81]:

isinstance(123, Iterable)  # 整型不是可迭代对象

Out[81]:

False

In[101]:

isinstance(\'abc\', Iterator)  # 字符串不是迭代器

Out[101]:

False

In[102]:

isinstance(\'abc\', Iterable)  # 字符串是可迭代对象

Out[102]:

True

In[103]:

class Company():def __iter__(self):  # 自定义一个类，只要实现了__iter__方法，就是可迭代对象passprint(\'Company()是可迭代对象吗：\',isinstance(Company(),Iterable))print(\'Company()是迭代器吗：\',isinstance(Company(),Iterator))

Company()是可迭代对象吗： TrueCompany()是迭代器吗： False

In[104]:

class Company():def __iter__(self):passdef __next__(self):  # 自定义一个类，同时实现了__iter__方法和__next__方法，就是迭代器passprint(\'Company()是可迭代对象吗：\',isinstance(Company(),Iterable))print(\'Company()是迭代器吗：\',isinstance(Company(),Iterator))

Company()是可迭代对象吗： TrueCompany()是迭代器吗： True

知道怎么区分可迭代对象和迭代器之后，就可以解释

__iter__

和

__next__

的作用了。那就是定义了这两个方法，就可以对实例化对象进行遍历。以for循环为例，通过for循环对一个可迭代对象进行迭代时，for循环内部机制会自动通过调用iter()方法执行可迭代对象内部定义的

__iter__

方法来获取一个迭代器，然后一次又一次得迭代过程中通过调用next()方法执行迭代器内部定义的

__next__

方法获取下一个元素，当没有下一个元素时，for循环自动捕获并处理StopIteration异常。

In[94]:

class B():def __init__(self, lst):self.lst = lstself.index = 0def __iter__(self):print(\'B.__iter__()方法被调用\')return selfdef __next__(self):try:print(\'B.__next__()方法被调用\')value = self.lst[self.index]self.index += 1return valueexcept IndexError:raise StopIteration()

In[98]:

b = B([1, 2, 3])for i in b:print(i)

B.__iter__()方法被调用B.__next__()方法被调用1B.__next__()方法被调用2B.__next__()方法被调用3B.__next__()方法被调用

2.4 可调用：

__call__

¶

• __call__

假如有一个对象A，如果A是一个类，我们使用A()进行调用，那么就是创建一个A类的实例化对象，如果A是一个函数，我们使用A()就是调用函数A。那么，如果A是一个某个类的实例化对象时，A()是进行什么操作呢？答案就是调用该类的

__call__

方法，我们可以理解为，

__call__

就是“()”运算符。

In[88]:

class Company(object):def __init__(self):passdef __call__(self, name):self.name = nameprint(\'__call__方法被调用，name:%s\' % self.name)

In[89]:

c = Company()c(\'腾讯\')

__call__方法被调用，name:腾讯

现在，我们证实了

__call__

就是“()”运算法，那么，是不是类、函数这些可使用“()”运算符的对象内部都定义有

__call__

函数呢？答案是肯定的。

In[90]:

class Company(object):def __init__(self):passdef A():pass

In[91]:

print(\'类Company是否有__call_方法：\', hasattr(Company, \'__call__\'))print(\'函数A是否有__call_方法：\', hasattr(A, \'__call__\'))

类Company是否有__call_方法： True函数A是否有__call_方法： True

借助这一特性，我们可以弥补hasattr()函数的不足。我们知道，通过hasattr()函数可以判断一个类内部是否有某个属性，但是没法判断到底是变量还是方法，但进一步借助方法内部肯定定义有

__call__

这个特性，就可以进一步判断。

In[92]:

class Company(object):def __init__(self):self.name = Nonedef func(self):pass

In[93]:

c = Company()print(\'c中是否存在属性name:\', hasattr(c, \'name\'))print(\'c中是否存在属性func:\', hasattr(c, \'func\'))print(\'name是函数吗:\', hasattr(c.name, \'__call__\'))print(\'func是函数吗:\', hasattr(c.func, \'__call__\'))

c中是否存在属性name: Truec中是否存在属性func: Truename是函数吗: Falsefunc是函数吗: True

2.5 with上下文管理器：

__enter__

、

__exit__

¶

只要你熟悉Python开发，那么对with上下文管理就一定不会陌生，例如操作文本时，我们通常习惯

with open

来对打开文件，获得句柄。使用with来打开文件的好处就是在打开文件后进行操作的过程中，无论是否出现异常，Python都会对关闭句柄，也就是一定会进行收尾工作，避免占用内存资源。

这种上下文管理机制是怎么实现的呢？这就涉及到我们现在要说的两个两个魔法函数

__enter__

和

__exit__

。

__enter__

：with语句开始执行时候调用

__exit__

：with语句结束时候调用，注意，无论with语句中的代码是否正常结束，都会执行

__exit__

方法

除了读写文件之外，我们使用Python来操作数据库时，也需要做收尾处理，也就是关闭数据库连接，那么，这个时候我们也可以用with来进行。

In[3]:

import pymysqlclass Dao(object):def __init__(self, cursor_type=None):self.conn = pymysql.connect( # 创建数据库连接host=\'192.168.31.201\', # 要连接的数据库所在主机ipdatabase=\'test\',user=\'root\', # 数据库登录用户名password=\'admin123456\', # 登录用户密码charset=\'utf8\' # 编码，注意不能写成utf-8)self.cursor = Noneif cursor_type:self.cursor = self.conn.cursor(pymysql.cursors.DictCursor)else:self.cursor = self.conn.cursor()def __enter__(self):return self.cursor  # 返回类实例本身def __exit__(self, exc_type, exc_value, exc_trace):self.conn.commit()  # 提交事务self.cursor.close()  # 关闭游标self.conn.close()  # 关闭数据库连接

In[6]:

with Dao() as cursor:cursor.execute(\"select * from employee;\")e = cursor.fetchall()print(e)

((1, \'张三\'), (2, \'李四\'))

2.6 属性相关：

__getattr__

、

__setattr__

、

__getattribute__

¶

• __getattr__

  、

  __setattr__

__getattr__

函数的作用： 在一个类实例中查找一个属性时，通过

__dict__

失败， 那么会调用到类的

__getattr__

函数，如果没有定义这个函数，那么抛出AttributeError异常。也就是说

__getattr__

是属性查找的最后一步。

In[13]:

class Company(object):def __init__(self, name):self.company_name = namedef fun(self):print(\'fun方法被调用……\')def __getattr__(self, name):print(\'__getattr__方法被调用\')raise AttributeError(\'哥们，你查找的属性\"%s\"不存在\' % name)

In[14]:

c = Company(\'腾讯\')

如果提前找到了某个属性，那么将不会继续调用

__getattr__

：

In[15]:

print(c.company_name)print(c.fun)

腾讯<bound method Company.fun of <__main__.Company object at 0x7fa0a8077100>>

当属性不存在是，将会调用

__getattr__

，所以，我们可以通过

__getattr__

函数来定义当找不到属性时候的提醒方式，甚至是返回一个其他的默认值。

In[16]:

c.abc

__getattr__方法被调用

---------------------------------------------------------------------------AttributeError                            Traceback (most recent call last)<ipython-input-16-a2bb1cff9d71> in <module>----> 1c.abc<ipython-input-13-810c2a9c4f3c> in __getattr__(self, name)8     def __getattr__(self, name):9         print(\'__getattr__方法被调用\')---> 10raise AttributeError(\'哥们，你查找的属性\"%s\"不存在\' % name)AttributeError: 哥们，你查找的属性\"abc\"不存在

通过

__getattr__

方法，我们可以对Python的字典进行改造，另外开始通过

dict_name.key

的方式来访问。

In[21]:

class Dict(dict):def __init__(self, *args, **kwargs):super(Dict, self).__init__(*args, **kwargs)def __getattr__(self, key):try:return self[key]except KeyError:raise AttributeError(r\"\'Dict\' object has no attribute \'%s\'\" % key)

In[22]:

d = Dict({\'name\': \'张三\', \'age\': \'李四\'})d.name

Out[22]:

\'张三\'

__getattr__

是用来获取属性，那么

__setattr__

就是用来给属性赋值，当我们使用

实例.key=value

的方式进行赋值的时候就一定会调用

__setattr__

方法。

In[27]:

class Company(object):def __init__(self, name):self.company_name = namedef __setattr__(self, name, value):print(\"__setattr__方法被调用\")#         self.name = value   # 第一种写法#         object.__setattr__(self, name, value)   # 第二种写法self.__dict__[name] = value         # 第三种写法

In[29]:

c = Company(\'腾讯\')c.company_name = \'阿里\'print(c.company_name)

__setattr__方法被调用__setattr__方法被调用阿里

为什么

__setattr__

被调用了两次呢？因为在

__init__

中也使用了一次

实例.key=value

的方式赋值。

所以，在定义

__setattr__

的时候一定要注意，一定不能使用上述代码中被注释掉的第一种写法，因为使用

self.name = value

进行赋值时，本身又会再次调用

__setattr__

方法，这就造成了无线递归，造成bug。所以使用第二和第三种写法才是正确的。

继续用

__setattr__

方法改造字典：

In[30]:

class Dict(dict):def __init__(self, *args, **kwargs):super(Dict, self).__init__(*args, **kwargs)def __getattr__(self, key):try:return self[key]except KeyError:raise AttributeError(r\"\'Dict\' object has no attribute \'%s\'\" % key)def __setattr__(self, key, name):self[key] = name

In[31]:

d = Dict()d.name = \'张三\'print(d.name)

张三

• __getattribute__

__getattribute__

与上面的

__getattr__

很相似，区别在于

__getattr__

是在类中未找到属性时调用，而

__getattribute__

是不管类中有无查找的属性存在，都优先调用。不过在使用

__getattribute__

方法市，必须注意陷入无限递归，当在

__getattribute__

代码块中，再次执行属性的获取操作时，会再次触发

__getattribute__

方法的调用，代码将会陷入无限递归，直到Python递归深度限制，所以，在

__getattribute__

中获取属性时，需要通过父类的

__getattribute__

方法获取对应的属性。

In[32]:

class Company(object):def __init__(self, name):self.company_name = namedef __getattribute__(self, name):print(\'__getattribute__方法被调用\')return object.__getattribute__(self, name)#         raise AttributeError(\'哥们，你查找的属性\"%s\"不存在\' % name)

In[33]:

c = Company(\'腾讯\')c.company_name

__getattribute__方法被调用

Out[33]:

\'腾讯\'

In[34]:

c.abc

__getattribute__方法被调用

---------------------------------------------------------------------------AttributeError                            Traceback (most recent call last)<ipython-input-34-a2bb1cff9d71> in <module>----> 1c.abc<ipython-input-32-e6bee225b017> in __getattribute__(self, name)5     def __getattribute__(self, name):6         print(\'__getattribute__方法被调用\')----> 7return object.__getattribute__(self, name)8 #         raise AttributeError(\'哥们，你查找的属性\"%s\"不存在\' % name)AttributeError: \'Company\' object has no attribute \'abc\'

• __dict__

  、

  dir()

  、

  __dir__

上文中提到过

__dict__

，

__dict__

是对象的一个属性，并不是函数，它的作用是返回对象的所有属性名为key，属性值为value的一个字典，注意，这里所说的所有属性是指数据对象本身的属性，例如类的

__dict__

只包含类本身的属性和函数，而类实例也只包含类实例的属性。这一点与

dir()

函数不同，

dir()

将会返回一个列表，列表中包含对象所有有关的属性名。也就是说，

__dict__

是

dir()

的子集。而

dir()

实际上调用的是

__dir__

方法。

In[37]:

class Company(object):def __init__(self, name):self.company_name = namedef fun(self):print(\'fun方法被调用……\')

In[38]:

c = Company(\'腾讯\')

In[40]:

c.__dict__

Out[40]:

{\'company_name\': \'腾讯\'}

In[41]:

Company.__dict__

Out[41]:

mappingproxy({\'__module__\': \'__main__\',\'__init__\': <function __main__.Company.__init__(self, name)>,\'fun\': <function __main__.Company.fun(self)>,\'__dict__\': <attribute \'__dict__\' of \'Company\' objects>,\'__weakref__\': <attribute \'__weakref__\' of \'Company\' objects>,\'__doc__\': None})

In[44]:

dir(c)

Out[44]:

[\'__class__\',\'__delattr__\',\'__dict__\',\'__dir__\',\'__doc__\',\'__eq__\',\'__format__\',\'__ge__\',\'__getattribute__\',\'__gt__\',\'__hash__\',\'__init__\',\'__init_subclass__\',\'__le__\',\'__lt__\',\'__module__\',\'__ne__\',\'__new__\',\'__reduce__\',\'__reduce_ex__\',\'__repr__\',\'__setattr__\',\'__sizeof__\',\'__str__\',\'__subclasshook__\',\'__weakref__\',\'company_name\',\'fun\']

In[45]:

c.__dir__()

Out[45]:

[\'company_name\',\'__module__\',\'__init__\',\'fun\',\'__dict__\',\'__weakref__\',\'__doc__\',\'__repr__\',\'__hash__\',\'__str__\',\'__getattribute__\',\'__setattr__\',\'__delattr__\',\'__lt__\',\'__le__\',\'__eq__\',\'__ne__\',\'__gt__\',\'__ge__\',\'__new__\',\'__reduce_ex__\',\'__reduce__\',\'__subclasshook__\',\'__init_subclass__\',\'__format__\',\'__sizeof__\',\'__dir__\',\'__class__\']