__str__和__repr__
改变对象的字符串显示__str__,__repr__
我们先定义一个Student类，打印一个实例：
class Student(object):
def __init__(self,name):
self.name = name print(Student('libai'))
打印出一堆<__main__.Student object at 0x000002311102EE10>，不好看。
怎么才能打印得好看呢？只需要定义好__str__()方法，返回一个好看的字符串就可以了：
class Student(object):
def __init__(self,name):
self.name = name
def __str__(self):
return 'Student object(name:%s)'%self.name print(Student('libai'))
这样打印出来的实例，不但好看，而且容易看出实例内部重要的数据。
但是细心的朋友会发现直接敲变量不用print（在交互式解释器下），打印出来的实例还是不好看：
这是因为直接显示变量调用的不是__str__()，而是__repr__()，两者的区别是__str__()返回用户看到的字符串，而__repr__()返回程序开发者看到的字符串，也就是说，__repr__()是为调试服务的。
解决办法是再定义一个__repr__()。但是通常__str__()和__repr__()代码都是一样的，所以，有个偷懒的写法：
class Student(object):
def __init__(self,name):
self.name = name
def __str__(self):
return 'Student object(name:%s)'%self.name
__repr__ = __str__ print(Student('libai'))
'''
str函数或者print函数--->obj.__str__()
repr或者交互式解释器--->obj.__repr__()
如果__str__没有被定义,那么就会使用__repr__来代替输出
注意:这俩方法的返回值必须是字符串,否则抛出异常
'''
__call__
一个对象实例可以有自己的属性和方法，当我们调用实例方法时，我们用instance.method()来调用。能不能直接在实例本身上调用呢？在Python中，答案是肯定的。
任何类，只需要定义一个__call__()方法，就可以直接对实例进行调用。请看示例：
class Student(object):
def __init__(self,name):
self.name = name def __call__(self):
print('My name is %s'%self.name) s = Student('libai')
s()
__call__()还可以定义参数。对实例进行直接调用就好比对一个函数进行调用一样，所以你完全可以把对象看成函数，把函数看成对象，因为这两者之间本来就没啥根本的区别。
如果你把对象看成函数，那么函数本身其实也可以在运行期动态创建出来，因为类的实例都是运行期创建出来的，这么一来，我们就模糊了对象和函数的界限。
那么，怎么判断一个变量是对象还是函数呢？其实，更多的时候，我们需要判断一个对象是否能被调用，能被调用的对象就是一个Callable对象，比如函数和我们上面定义的带有__call__()的类实例：
print(callable(Student))
print(callable(len))
print(callable(''))
通过callable()函数，我们就可以判断一个对象是否是“可调用”对象。
__len__
class A:
def __init__(self):
self.a = 1
self.b = 2 def __len__(self):
return len(self.__dict__)
#不定义这个方法，异常是：object of type 'A' has no len()
a = A()
print(len(a))
__del__
仅了解。
析构方法，当对象在内存中被释放时，自动触发执行。
注：此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给Python解释器来执行，所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。
class Foo:
def __del__(self):
print('执行我啦')
f1=Foo()
del f1
print('------->')
#输出结果
执行我啦
------->
__getitem__\__setitem__\__delitem__
__getitem__(self,key):返回键对应的值。
__setitem__(self,key,value)：设置给定键的值
__delitem__(self,key):删除给定键对应的元素。
class Foo(object):
def __init__(self,name):
self.name = name
def __getitem__(self, item):
print('call function __getitem__')
return self.__dict__[item]
def __setitem__(self, key, value):
print('call function __setitem__')
self.__dict__[key] = value
def __delitem__(self, key):
print('call function __delitem__')
del self.__dict__[key] f = Foo('libai')
print(f['name'])
f['gender'] = 'male'#新增一个Key
print(f['gender'])
f['gender'] = 'female'#重新赋值
print(f['gender'])
del f['gender']#删除了key
print(f['gender'])#引发异常
源码：item_1.py
这些魔术方法的原理就是：当我们对类的属性item进行下标的操作时，首先会被__getitem__()、__setitem__()、__delitem__()拦截，从而进行我们在方法中设定的操作，如赋值，修改内容，删除内容等等。
item一例
class A(object):
def __init__(self,start=0,step=1):
print('call function __init__')
self.start = start
self.step = step
self.mydata = {}
#定义获取值的方法
def __getitem__(self, item):
print('call function __getitem__')
try:
return self.mydata[item]
except KeyError:
return 'no such key'
#定义赋值方法
def __setitem__(self, key, value):
print('call function __setitem__')
self.mydata[key] = value
#定义删除元素的方法
def __delitem__(self, key):
print('call function __delitem__')
del self.mydata[key] a = A(1,2)
print(a[3])# 这里应该执行 'no such key'，因为没有3这个key
a[3] = 'value3'# 进行赋值
print(a[3])# 前面进行了赋值，那么直接输出赋的值 value3
del a[3]# 删除3这个key
print(a[3])
源码：item_2.py