object.__getattribute__(self, name)
无条件被调用，通过实例访问属性。如果class中定义了__getattr__()，则__getattr__()不会被调用（除非显示调用或引发AttributeError异常）
class Foo:
def __init__(self,x):
self.x = x
def __getattr__(self, item):
print("执行__getattr__")
def __getattribute__(self, item):
print("执行__getattribute__")
# raise AttributeError("不存在的异常")
f = Foo("nick")
print(f.x)
print(f.xxxx)#这里本来调用后应该在__getattribute__中产生AttributeError，然后调用__getattr__，但在#这里__getattribute__被重写了，没有产生AttributeError，所以就没调用__getattr__
输出结果
执行__getattribute__ None 执行__getattribute__ None
object.__getattr__(self, name)
当一般位置找不到attribute的时候，会调用getattr，返回一个值或AttributeError异常。
class Foo:
def __init__(self,x):
self.x = x
def __getattr__(self, item):
print("执行__getattr__")
# def __getattribute__(self, item):
# print("执行__getattribute__")
# raise AttributeError("不存在的异常")
f = Foo("nick")
print(f.x)
print(f.xxxx) #这里是执行了新定义的__getattr__方法，并没有直接报错
输出结果
nick 执行__getattr__ None
每次通过实例访问属性，都会经过__getattribute__函数。
而当属性不存在时，仍然需要访问__getattribute__，不过接着要访问__getattr__。这就好像是一个异常处理函数。 需要注意的是，当使用类访问不存在的变量是，不会经过__getattr__函数。
当属性存在时，经过__getattribute__函数，返回属性的值。
二、__setitem__,__getitem,__delitem__
在类中，对象以object["key"]形式访问属性或方法时调用item系列内置方法，对象以object.属性（以点的形式）调用属性或方法时调用attr系列内置方法。
class Foo:
def __init__(self,name):
self.name = name
def __getitem__(self, item):
print("执行__getitem__")
return self.__dict__[item]
def __setitem__(self, key, value):
print("执行__setitem__")
self.__dict__[key] = value
def __delitem__(self, key):
print("执行__delitem__")
self.__dict__.pop(key)
f = Foo("nick")
print(f["name"]) #获取属性， 执行__getitem__方法
f["age"] = 18 #设置属性，执行__setitem__方法
print(f.__dict__)
del f["name"] #删除属性，执行__delitem__方法
print(f.__dict__)
输出结果
执行__getitem__
nick
执行__setitem__
{'name': 'nick', 'age': 18}
执行__delitem__
{'age': 18}
三、__str__,__repr__,__format__
__str__是控制改变对象的字符串显示
在print(obj)/'%s'%obj/str(obj)时，实际上是内部调用了obj.__str__方法，如果str方法有，那么他返回的必定是一个字符串，如果没有__str__方法，会先找本类中的__repr__方法，再没有再找父类（object）中的__str__。
例子1
class Foo:
def __str__(self):
return "控制打印对象时的显示形式"
f = Foo()
print(f) #输出结果： 控制打印对象时的显示形式
分析：这里打印对象直接调用了被重新定义的__str__方法
例子2
class Foo:
def __str__(self):
return "控制打印对象时的显示形式"
f = Foo()
a = str(f)
print(a) #输出结果： 控制打印对象时的显示形式
分析：这里的str(object)也是调用了__str__方法
例子3
class Foo:
def __str__(self):
return "控制打印对象时的显示形式"
f = Foo()
print("%s"%f) #输出结果： 控制打印对象时的显示形式
分析：这里的“%s”%f也是调用了__str__方法
__repr__也是显示对象的名字方式，用repr(object)或者“%r”%object会调用__repr__方法
repr 是str的备胎，但str不能做repr的备胎
例子4
class Foo:
def __str__(self):
return "控制打印对象时的显示形式"
def __repr__(self):
print("在执行repr")
return "repr Foo"
pass
f = Foo()
print("%r"%f)
print(f)
输出结果
在执行repr repr Foo 控制打印对象时的显示形式
分析：这里print("%r"%f) 调用重新定义的__repr__方法，print(f)调用__str__方法
例子5
class Foo:
def __str__(self):
return "控制打印对象时的显示形式"
def __repr__(self):
print("在执行repr")
return "repr Foo"
pass
f = Foo()
print(repr(f))
输出结果
在执行repr repr Foo
例子6
class Foo:
# def __str__(self):
# return "控制打印对象时的显示形式"
def __repr__(self):
print("在执行repr")
return "repr Foo"
pass
f = Foo()
print(f)
输出结果
在执行repr repr Foo
分析：如果要调用__str__方法，首先在本类中查找有没有__str__方法,如果没有就找本类有没有__repr__方法，如果有就执行__repr__方法，不再借用父类的__str__方法。所以repr 是str的备胎，但str不能做repr的备胎。
例子7
class Foo:
def __str__(self):
return "控制打印对象时的显示形式"
# def __repr__(self):
# print("在执行repr")
# return "repr Foo"
pass
f = Foo()
print(repr(f)) #输出结果 <__main__.Foo object at 0x002EB550>
分析：要调用__repr__方法，本类没有，直接借用父类的__repr__方法，而不执行__str__方法。所以repr 是str的备胎，但str不能做repr的备胎。
__format__
自定制格式化字符串__format__,
format_dic = {
"ymd":"{0.year}{0.month}{0.day}",
"dmy":"{0.day}:{0.month}:{0.year}",
"mdy":"{0.month}-{0.day}-{0.year}"
}
class Foo:
def __init__(self,year,month,day):
self.year = year
self.month = month
self.day = day
def __format__(self, format_spec):
if not format_spec or format_spec not in format_dic:
format_spec = "ymd"
fmt = format_dic[format_spec]
return fmt.format(self)
f = Foo(2018,8,20)
print(format(f))
print(format(f,"dmy"))
print(format(f,"mdy"))
print("{:mdy}".format(f))
输出结果
2018820 20:8:2018 8-20-2018 8-20-2018
分析：调用format方法自定制字符串格式化，这里调用__format__方法
四、__slots__
__slots__:其实就是将类中的名称锁定,实例化对象,只可以赋值和调用,不可以删除属性和增加新的属性
1、__slots__是什么:是一个类变量,变量值可以是列表,元祖,或者可迭代对象,也可以是一个字符串(也就是意味着所有实例只有一个数据属性)
2、使用点来访问属性本质就是在访问类或者对象的__dict__属性字典(类的字典是共享的,而每个实例的是独立的)
3、字典会占用大量内存,如果你有一个属性很少的类,但是有很多实例,为了节省内存可以使用__slots__取代实例的__dict__当你定义__slots__后,__slots__就会为实例使用一种更加紧凑的内部表示。实例通过一个很小的固定大小的数组来构建,而不是为每个实例定义一个字典,这跟元组或列表很类似。在__slots__中列出的属性名在内部被映射到这个数组的指定小标上。使用__slots__一个不好的地方就是我们不能再给实例添加新的属性了,只能使用在__slots__中定义的那些属性名。
4、应用场景：当实例化几万个对象的时候，每个对象都会生成一个名称空间__dict__，而每一个名称空间都会各自占用一个内存，造成内存的浪费，用 __slots__，不用再产生每个对象的 dict 了，省内存，对象的 dict 都统一用类的 dict，属性都是用 slots 给定义的
class Foo:
__slots__ = ["name","age"] #在类中定义属性"name"、"age"
f1 = Foo()
f1.name = "nick" #首先要进行赋值，不赋值调用会出错
print(f1.name)
# f1.gender = "female" # 新增__slots__之外的属性会报错
# del f1.age #删除属性也会报错
五、__doc__
__doc__显示文档注释信息，文档注释信息无法继承给子类。
例子
class Foo:
"""
我是文档注释
"""
pass
f = Foo()
print(f.__doc__) #输出结果 ： 我是文档注释
例子2
class Foo:
"""
我是文档注释
"""
pass
class Son(Foo):
pass
s = Son()
print(s.__doc__) #输出结果：None
六、__module__和__class__
__module__ 表示当前操作的对象在那个模块
__class__ 表示当前操作的对象的类是什么
例子1
class Foo:
def __init__(self,name):
self.name = name
f = Foo("nick")
print(f.__module__) #当执行文件为当前文件时，__module__ = __main__
#输出结果：__main__
print(f.__class__) #输出当前操作的类名是什么
#输出结果：<class '__main__.Foo'>
例子2
文件结构
├── index.py #执行文件
│ ├── test
│ │ ├── a.py
a.py内容：
class Bar:
def __init__(self):
self.name = "nicholas"
index.py内容：
from test.a import Bar
class Foo:
def __init__(self,name):
self.name = name
b = Bar()
print(b.name) #输出结果 nicholas
print(b.__module__) #输出结果 test.a ，表示当前操作的类在test.a下
print(b.__class__) #表示当前操作的类名是<class 'test.a.Bar'>
七、 __del__析构方法
析构方法，当对象在内存中被释放时，自动触发执行。即清除释放内存的方法。
这个是在回收实例化对象时触发执行的方法，删除对象的属性不会触发__del__方法
注：此方法一般无须定义，因为Python是一门高级语言，程序员在使用时无需关心内存的分配和释放，因为此工作都是交给Python解释器来执行，所以，析构函数的调用是由解释器在进行垃圾回收时自动触发执行的。
例子1
class Foo:
def __init__(self,name):
self.name = name
def __del__(self):
print("我执行啦！")
f = Foo("nick")
print("-----1")
del f.name
print("-----2") #这里是先执行print("-----1")然后执行print("-----2") ，
# 执行del f.name只是删除对象字典的"name"属性，并不会触发__del__方法
输出结果
-----1 -----2 我执行啦！
例子2
class Foo:
def __init__(self,name):
self.name = name
def __del__(self):
print("我执行啦！")
f = Foo("nick")
print("-----1")
del f #删除对象才能调用__del__，这里既执行了__del__方法，又删除了对象
print("-----2")
输出结果
-----1 我执行啦！ -----2
例子3
class Foo:
def __init__(self,name):
self.name = name
def __del__(self):
print("我执行啦！")
f = Foo("nick")
import time
time.sleep(2)
输出结果
我执行啦！
分析：这里在程序结束时，python解释器自动回收内存，执行了__del__方法
典型的应用场景：
创建数据库类，用该类实例化出数据库链接对象，对象本身是存放于用户空间内存中，而链接则是由操作系统管理的，存放于内核空间内存中
当程序结束时，python只会回收自己的内存空间，即用户态内存，而操作系统的资源则没有被回收，这就需要我们定制__del__，在对象被删除前向操作系统发起关闭数据库链接的系统调用，回收资源。
例子
class Foo:
def __del__(self):
print("我执行了")
f = Foo()
f.file = open("test.txt") #打开文件,在操作系统中打开了一个文件,
# 拿到了文件操作符存在了内存中
del f.file #删除了内存中的文件操作符,但是并未关闭操作系统中的文件，
# 这时需要在__del__中加入定制f.file.close(),关闭操作系统的文件
print("-----1")
#最后程序结束python解释器自动执行内存回收，执行了__del__方法
输出结果
-----1 我执行了