[ python ] 类中的一些特殊方法

item系列

__getitem__(self, item)            对象通过 object[key] 触发
__setitem__(self, key, value)    对象通过 object[key] = value 触发
__delitem__(self, key)            对象通过 del object[key] 触发

class Func:
    def __getitem__(self, item):
        # object[item] 触发
        return self.__dict__[item]

    def __setitem__(self, key, value):
        # object[key] = value 触发
        self.__dict__[key] = value

    def __delitem__(self, key):
        # del object[key] 触发
        print('delitem: 删除key')
        del self.__dict__[key]

    def __delattr__(self, item):
        # del object.item 触发
        print('delattr: 删除key')
        del self.__dict__[item]


f = Func()
f['name'] = 'hkey'  # __setitem__
f['age'] = 20   # __setitem__
print(f.name)   # 对象属性原本的调用方式
print(f['name'])    # __getitem__
del f['name']   # __delitem__
print('------')
del f.age   # __delattr__

要注意反射的 __delattr__ 和 __delitem__ 使用不同的方式触发不同的特殊方法。

class Fib:
    def __getitem__(self, item):
        if isinstance(item, int):
            a, b = 1, 1
            for x in range(item):
                a, b = b, a+b
            return a
        if isinstance(item, slice):
            start = item.start
            stop = item.stop
            if start is None:
                start = 0
            a, b = 1, 1
            L = []
            for x in range(stop):
                if x >= start:
                    L.append(a)
                a, b = b, a+b
            return L

f = Fib()
print(f[9])
print(f[:10])

执行结果：
55
[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

__str__ 和 __repr__

当直接打印一个对象的时候，显示的是一段内存地址。

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

In [2]: p = Person('hkey')

In [3]: p
Out[3]: <__main__.Person at 0x2be9f5c9128>

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

为了便于更好的理解，我们定义一个__str__方法

In [1]: class Person:
   ...:     def __init__(self, name):
   ...:         self.name = name
   ...:     def __str__(self):
   ...:         return "hello %s." % self.name

In [2]: p = Person('hkey')

In [3]: p
Out[3]: <__main__.Person at 0x2858bd468d0>

In [4]: print(p)
hello hkey.

定义了__str__方法，直接输出对象还是打印的内存地址，并没有走__str__方法中定义的格式，用print输出信息却调用了__str__方法定义的内容

In [1]: class Person:
   ...:     def __init__(self, name):
   ...:         self.name = name
   ...:     def __repr__(self):
   ...:         return "hello %s." % self.name

In [2]: p = Person('hkey')

In [3]: p
Out[3]: hello hkey.

In [4]: print(p)
hello hkey.

定义了__repr__方法，不管是直接打印对象还是通过print打印对象，都是走的__repr__中定义的格式。

总结：

    __repr__ 和 __str__ 这两个方法都是用于显示的，__str__是面向用户的，而__repr__是面向程序员
    
    使用print打印操作会首先尝试__str__和str内置函数，它通常应该返回一个友好的提示
    当__str__不存在的时候，会去找__repr__是否定义，定义则打印__repr__中定义的内容
    
    当我们想在所有环境下都统一显示的话，可以添加__repr__方法。
    当我们想在不同的环境下支持不同的显示，就可以定义__repr__方法和__str__方法，终端交互使用__repr__，用户使用__str__方法

__new__

__new__ 是在新式类中出现的方法，它作用在构造函数之前，可以这么理解，在python中存在于类里面的构造方法__init__()负责将类实例化，而在__init__() 启动之前，__new__()决定是否要使用该__init__()方法，因为__new__()可以调用其他类的构造方法或者直接返回别的对象作为本类的实例。

具体参考：https://www.cnblogs.com/ifantastic/p/3175735.html

要记住的是：在实例化时，__new__() 先与 __init__() 方法执行.

通常来讲，新式类开始实例化时，__new__()方法会返回cls（cls代指当前类）的实例，然后该类的__init__()方法作为构造方法会接收这个实例(self)作为自己的一个参数，然后依次传入__new__()方法中接收的位置参数和命名参数。

In [1]: class Foo:
   ...:     def __init__(self, *args, **kwargs):
   ...:         print('in init function.')    
   ...:     def __new__(cls, *args, **kwargs):    # 实例化时，首先执行__new__方法
   ...:         print('in new function.')
   ...:         return object.__new__(cls, *args, **kwargs)

In [2]: f = Foo()
in new function.
in init function.

对于__new__ 和 __init__ 的个人理解如下：

首先，我们把一个类比一个生物，使用__new__方法是创建这个生物的本体（实例），当本体（实例）创建好，才能使用__init__来创建这个本体的属性

一个单例模式来印证上面的描述：

In [1]: class Foo:
   ...:     def __init__(self, *args, **kwargs):
   ...:         pass
   ...:     def __new__(cls, *args, **kwargs):
   ...:         if not hasattr(cls, '_instance'):
   ...:             cls._instance = object.__new__(cls, *args, **kwargs)
   ...:         return cls._instance

In [2]: one = Foo()

In [3]: two = Foo()

In [4]: id(one)
Out[4]: 2173030026152

In [5]: id(two)
Out[5]: 2173030026152

In [6]: print(one == two)
True

In [7]: print(one is two)
True

通过__new__方法，首先创建实例的本体，当第二次实例化时，通过if判断，这个本体已经存在，就直接返回，然后在调用__init__()方法附加属性值

python3 正常的使用格式：

class Foo(object):

    def __new__(cls, *args, **kwargs):
        return object.__new__(cls)

    def __init__(self, name):
        self.name = name


f = Foo('hkey')
print(f.name)

__del__

析构方法，当对象在内存中被释放时，自动触发执行。

注：此方法一般无需定义，因为python是一门高级语言，程序员在使用时无需关心内存和释放，因为此工作都是交给python解释器来执行的，所有，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。

在 pycharm中当程序执行完，自动触发 __del__ 方法

class Foo:
    def __init__(self, name):
        self.name = name

    def __del__(self):
        print('执行__del__.')


f = Foo('hkey')

# 执行结果：
执行__del__.

__del__ 在类中适合做一些关闭文件句柄等操作。

__call__

当对象+()时候[object()] 触发

class Foo:
    def __init__(self, name):
        self.name = name

    def __call__(self, *args, **kwargs):
        print('执行__call__.')

f = Foo('hkey')
f()

# 执行结果：
执行__call__.

__len__

使用 len(object) 触发

class Foo:
    def __init__(self, name):
        self.name = name

    def __len__(self):
        return 10    # 注意返回结果必须是 int 类型


f = Foo('hkey')
print(len(f))


# 执行结果：
10

__hash__

调用 hash(object) 触发

class Foo:
    def __init__(self):
        self.a = 1
        self.b = 5

    def __hash__(self):
        return hash(str(self.a) + str(self.b))


f = Foo()
print(hash(f))


# 执行结果：
2068706206124340336

__eq__

当两个对象进行比较时，触发

class Foo:
    def __init__(self):
        self.a = 1
        self.b = 5

    def __eq__(self, other):
        if self.a == other.a and self.b == other.b:
            return True
        return False

a = Foo()
b = Foo()
print(a == b)   # 执行这个比较的时候，就调用了 __eq__ 方法

# 执行结果：
True

实例练习：纸牌

from collections import namedtuple

Card = namedtuple('Card', ['rank', 'suit'])


class FranchDeck:
    ranks = [x for x in range(2, 11)] + list('JQKA')
    suits = ['红桃', '黑桃', '方块', '梅花']

    def __init__(self):
        '''创建一副牌'''
        self._card = [Card(rank, suit) for rank in FranchDeck.ranks for suit in FranchDeck.suits]

    def __len__(self):
        '''统计牌数'''
        return len(self._card)

    def __getitem__(self, item):
        '''通过object[index]取牌'''
        return self._card[item]

    def __setitem__(self, key, value):
        '''调用 shuffle 的时候需要有__setitem__方法'''
        self._card[key] = value


f = FranchDeck()
print(f[:4])    # 按照顺序取牌
from random import shuffle
shuffle(f)  # 随机排列
print(f[:4])    # 切片随机取4张

# 执行结果：
[Card(rank=2, suit='红桃'), Card(rank=2, suit='黑桃'), Card(rank=2, suit='方块'), Card(rank=2, suit='梅花')]
[Card(rank=7, suit='红桃'), Card(rank=3, suit='方块'), Card(rank='J', suit='红桃'), Card(rank=5, suit='黑桃')]