python 魔术方法

前言

在做python开发的过程中,我们大家都会遇到在class(类)中使用双下划线的方法,这些都是我们经常所说的"魔法"方法.这些方法可以对类添加特殊的功能,使用恰当可以很大的提升我们在开发过程中的便捷性,方便的进行扩展.

概览

目前我们常见的魔法方法大致可分为以下几类：

构造与初始化
类的表示
访问控制
比较操作
容器类操作
可调用对象
Pickling序列化

我们这次主要介绍这几类常用魔法方法:

1.构造与初始化

__init__
构造方法是我们使用频率最高的魔法方法了，几乎在我们定义类的时候，都会去定义构造方法，它的主要作用就是在初始化一个对象时，定义这个对象的初始值。

class Person(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age


p1 = Person('Jack', 25)
p2 = Person('shuke', 20)

__new__

事实上，当我们理解了new方法后，我们还可以利用它来做一些其他有趣的事情，比如实现设计模式中的单例模式(singleton)
依照Python官方文档的说法，new方法主要是当你继承一些不可变的class时(比如int, str, tuple)，提供给你一个自定义这些类的实例化过程的途径。还有就是实现自定义的metaclass
这个方法我们一般很少定义，不过我们在一些开源框架中偶尔会遇到定义这个方法的类。实际上，这才是"真正的构造方法"，它会在对象实例化时第一个被调用，然后再调用init，它们的区别主要如下：

new的第一个参数是cls，而init的第一个参数是self
new返回值是一个实例，而init没有任何返回值，只做初始化操作
new由于是返回一个实例对象，所以它可以给所有实例进行统一的初始化操作

由于new优先于init调用，且返回一个实例，所以我们可以利用这种特性，每次返回同一个实例来实现一个单例类：

__new__的作用:

class PositiveInteger(int):

  def __init__(self, value):

    super(PositiveInteger, self).__init__(self, abs(value))

i = PositiveInteger(-3)

print(i)

但运行后会发现，结果根本不是我们想的那样，我们仍然得到了-3。这是因为对于int这种不可变的对象，我们只有重载它的new方法才能起到自定义的作用。
修改后的代码如下:

class PositiveInteger(int):

  def __new__(cls, value):

    return super(PositiveInteger, cls).__new__(cls, abs(value))

i = PositiveInteger(-3)

print(i)

通过重载new方法，我们实现了需要的功能.

class g(float):
    """千克转克"""

    def __new__(cls, kg):
        return float.__new__(cls, kg * 2)


# 50千克转为克
a = g(50)
print(a)  # 100.0
print(a + 100)  # 200.0 由于继承了float，所以可以直接运算，非常方便！

用new来实现单例
因为类每一次实例化后产生的过程都是通过new来控制的，所以通过重载new方法，我们可以很简单的实现单例模式。

# 写法一
class Singleton(object):
    def __new__(cls):
        # 关键在于这，每一次实例化的时候，我们都只会返回这同一个instance对象

        if not hasattr(cls, 'instance'):
            cls.instance = super(Singleton, cls).__new__(cls)

        return cls.instance

obj1 = Singleton()
obj2 = Singleton()
obj1.attr1 = 'value1'
print(obj1.attr1, obj2.attr1)
print(obj1 is obj2)

"""
>>>
value1 value1
True
"""
可以看到obj1和obj2是同一个实例。

# 写法二
class Singleton(object):
    """单例"""
    _instance = None

    def __new__(cls, *args, **kwargs):
        if not cls._instance:
            cls._instance = super(Singleton, cls).__new__(cls, *args, **kwargs)
        return cls._instance


class MySingleton(Singleton):
    pass


a = MySingleton()
b = MySingleton()
print(a is b)
"""
>>> 
True
"""

2. del析构方法

这个方法代表析构方法，也就是在对象被垃圾回收时被调用。但是请注意，执行del x不一定会执行此方法。

由于Python是通过引用计数来进行垃圾回收的，也就是说，如果这个实例还是有被引用到，即使执行del销毁这个对象，但其引用计数还是大于0，所以不会触发执行del。
例子:
此时我们没有对实例进行任何操作时，del在程序退出后被调用。

class Person(object):
    def __del__(self):
        print('__del__')

a = Person()
print('exit')

"""
exit
__del__
"""

由于此实例没有被其他对象所引用，当我们手动销毁这个实例时，del被调用后程序正常退出。

class Person(object):
    def __del__(self):
        print('__del__')


a = Person()
b = a  # b引用a
del a  # 手动销毁,不触发__del__
print('exit')

"""
exit
__del__
"""

此时实例有被其他对象引用，尽管我们手动销毁这个实例，但依然不会触发del方法，而是在程序正常退出后被调用执行。
为了保险起见，当我们在对文件、socket进行操作时，要想安全地关闭和销毁这些对象，最好是在try异常块后的finally中进行关闭和释放操作！

3. 类的表示

str/repr
这两个魔法方法一般会放到一起进行讲解，它们的主要差别为：

str强调可读性，而repr强调准确性/标准性
str的目标人群是用户，而repr的目标人群是机器，它的结果是可以被执行的
%s调用str方法，而%r调用repr方法
来看几个例子，了解内置类实现这2个方法的效果：

>>> a = 'hello'
>>> str(a)
'hello'
>>> '%s' % a   # 调用__str__
'hello'
>>>
>>> repr(a)     # 对象a的标准表示，也就是a是如何创建的
"'hello'"
>>> '%r' % a    # 调用__repr__ 
"'hello'"
>>>
>>>
>>> import datetime
>>> b = datetime.datetime.now()
>>> str(b)
'2018-05-03 19:08:45.921879'
>>> print(b)     # 等同于print str(b)
2018-05-03 19:08:45.921879
>>>
>>>
>>> repr(b)     # 展示对象b的标准创建方式(如何创建的 
'datetime.datetime(2018, 5, 3, 19, 8, 45, 921879)'
>>> b
datetime.datetime(2018, 5, 3, 19, 8, 45, 921879)
>>>
>>> c = eval(repr(b))
>>> c
datetime.datetime(2018, 5, 3, 19, 8, 45, 921879)

从上面的例子可以看出这两个方法的主要区别，在实际中我们定义类时，一般这样定义即可：

class Person(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __str__(self):
        # 格式化，友好对用户展示
        return 'name: %s, age: %s' % (self.name, self.age)

    def __repr__(self):
        # 标准化展示
        return "Person('%s', %s)" % (self.name, self.age)


person = Person('zhangsan', 20)
print(str(person))      # name: zhangsan, age: 20
print('%s' % person)    # name: zhangsan, age: 20
print(repr(person))     # Person('zhangsan', 20)
print('%r' % person)    # Person('zhangsan', 20)

"""
name: zhangsan, age: 20
name: zhangsan, age: 20
Person('zhangsan', 20)
Person('zhangsan', 20)
"""

这里值得注意的是，如果只定义了str或repr其中一个，那会是什么结果？

如果只定义了str_，那么repr(person)输出<main.Person object at 0x10783b400>
如果只定义了repr，那么str(person)与repr(person)结果是相同的
也就是说，repr在表示类时，是一级的，如果只定义它，那么str = repr。
而str展示类时是次级的，用户可自定义类的展示格式，如果没有定义repr，那么repr(person)将会展示缺省的定义。

4. 对象判断

hash/eq
hash方法返回一个整数，用来表示该对象的唯一标识，配合eq方法判断两个对象是否相等(==)：

class Person(object):
    def __init__(self, uid):
        self.uid = uid

    def __repr__(self):
        return 'Person(%s)' % self.uid

    def __hash__(self):
        return self.uid

    def __eq__(self, other):
        return self.uid == other.uid


p1 = Person(1)
p2 = Person(1)
print(p1 == p2)
p3 = Person(2)
print(set([p1, p2, p3]))  # 根据唯一标识去重输出 set([Person(1), Person(2)])

"""
True
{Person(1), Person(2)}
"""

如果我们需要判断两个对象是否相等，只要我们重写hash和eq方法就可以完成此功能。此外使用set存放这些对象时，会根据这两个方法进行去重操作。

5. 对象布尔判断

bool
当调用bool(obj)时，会调用bool方法，返回True/False。

class Person(object):
    def __init__(self, uid):
        self.uid = uid

    def __bool__(self):
        return self.uid > 10

p1 = Person(1)
p2 = Person(15)
print(bool(p1))  # False
print(bool(p2))  # True

"""
False
True
"""

⚠️: 在Python3中，nonzero被重命名bool

6. 访问控制

访问控制相关的魔法方法，主要涉及以下几个：

setattr：通过.设置属性或setattr(key, value)
getattr：访问不存在的属性
delattr：删除某个属性
getattribute：访问任意属性或方法
来看一个完整的例子：


class Person(object):
    def __setattr__(self, key, value):
        """属性赋值"""
        if key not in ('name', 'age'):
            return
        if key == 'age' and value < 0:
            raise ValueError()
        super(Person, self).__setattr__(key, value)

    def __getattr__(self, key):
        """访问某个不存在的属性"""
        return 'unknown'

    def __delattr__(self, key):
        """删除某个属性"""
        if key == 'name':
            raise AttributeError()
        super(Person, self).__delattr__(key)

    def __getattribute__(self, key):
        """所有属性/方法调用都经过这里"""
        if key == 'money':
            return 100
        if key == 'hello':
            return self.say
        return super(Person, self).__getattribute__(key)

    def say(self):
        return 'hello'

p1 = Person()
p1.name = 'zhangsan'  # 调用__setattr__
p1.age = 20  # 调用__setattr__
print(p1.name)  # zhangsan
print(p1.age)  # 20
setattr(p1, 'name', 'lisi')  # 调用__setattr__
setattr(p1, 'age', 30)  # 调用__setattr__
print(p1.name)  # lisi
print(p1.age)  # 30

p1.gender = 'male'  # __setattr__中忽略对gender赋值
print(p1.gender)  # gender不存在,调用__getattr__返回：unknown
print(p1.money)  # money不存在,在__getattribute__中返回100
print(p1.say())  # hello
print(p1.hello())  # hello,调用__getattribute__，间接调用say方法

del p1.name  # __delattr__中引发AttributeError
p2 = Person()
p2.age = -1  # __setattr__中引发ValueError

setattr
通过此方法，对象可在在对属性进行赋值时进行控制，所有的属性赋值都会经过它。
一般常用于对某些属性赋值的检查校验逻辑，例如age不能小于0，否则认为是非法数据等等。
getattr
很多同学以为此方法是和setattr完全对立的，其实不然！
这个方法只有在访问某个不存在的属性时才会被调用，看上面的例子，由于gender属性在赋值时，忽略了此字段的赋值操作，所以此属性是没有被成功赋值给对象的。当访问这个属性时，getattr被调用，返回unknown。
del
删除对象的某个属性时，此方法被调用。一般常用于某个属性必须存在，否则无法进行后续的逻辑操作，会重写此方法，对删除属性逻辑进行检查和校验。
getattribute
这个方法我们很少用到，它与getattr很容易混淆。它与前者的区别在于：
getattr访问某个不存在的属性被调用，getattribute访问任意属性被调用
getattr只针对属性访问，getattribute不仅针对所有属性访问，还包括方法调用

7. Python的类下面的item系列

xxxitem:使用 [''] 的方式操作属性时被调用
setitem:每当属性被赋值的时候都会调用该方法，因此不能再该方法内赋值 self.name = value 会死循环
getitem:当访问不存在的属性时会调用该方法
delitem:当删除属性时调用该方法

#! /usr/bin/env python
# -*- coding: utf-8 -*-
# __author__ = "shuke"
# Date: 2018/5/2

class A(object):
    def __init__(self):
        self['B'] = "BB"
        self['D'] = "DD"
        del self['B']

    def __setitem__(self, name, value):
        '''''
        @summary: 每当属性被赋值的时候都会调用该方法，因此不能再该方法内赋值 self.name = value 会死循环
        '''
        print("__setitem__:Set %s Value %s" % (name, value))
        self.__dict__[name] = value

    def __getitem__(self, name):
        '''''
        @summary: 当访问不存在的属性时会调用该方法
        '''
        print("__getitem__:No attribute named '%s'" % name)
        return 123

    def __delitem__(self, name):
        '''''
        @summary: 当删除属性时调用该方法
        '''
        print("__delitem__:Delect attribute '%s'" % name)
        del self.__dict__[name]
        print(self.__dict__)


if __name__ == "__main__":
    X = A()
    X['bb'] = "BB"
    print(X.__dict__)

"""
>>> 
__setitem__:Set B Value BB
__setitem__:Set D Value DD
__delitem__:Delect attribute 'B'
{'D': 'DD'}
__setitem__:Set bb Value BB
{'D': 'DD', 'bb': 'BB'}
"""

越是强大的魔法方法，责任越大，如果你不能正确使用它，最好还是不用为好，否则在出现问题时很难排查!

参考原文
魔术方法二
延伸

python 魔术方法