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='黑桃')]
来源：https://www.cnblogs.com/hukey/p/9990081.html