__getattribute__()方法、__next__()和__iter__()实现迭代器协议、item()方法等类的各种双下划线方法

_ getattribute_()

是__getattr__()的升级版，当两个方法都存在的时候，会先调用__getattribute__()方法
不论实例的属性字典中是否存在该属性，都会执行__getattribute__()

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

    def __getattr__(self, item):
        print("执行的是getattr")

    def __getattribute__(self, item):
        print("执行的是getattribute")


f1 = Foo(10)
f1.y
f1.xxx

当__getattribute__()方法中存在升起异常时，就会调用__getattr__()，AttributeError相当于两个方法之间的口令

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

    def __getattr__(self, item):
        print("执行的是getattr")

    def __getattribute__(self, item):
        print("执行的是getattribute")
        raise AttributeError("抛出异常")


f1 = Foo(10)
f1.y
f1.xxx

_getattribute__方法在python中的实现是先判断属性是否存在，存在则返回，不存在则抛出异常进入__getattr _()

class Foo(object):
    def __init__(self, y):
        self.y = y

    def __getattr__(self, item):
        print("执行的是getattr")

    def __getattribute__(self, item):
        if object.__getattribute__(self, item):
            return object.__getattribute__(self, item)
        else:
            raise AttributeError


f1 = Foo(10)
print(f1.y)
f1.xxx

---

_ iter_()、_ next_()实现迭代器协议

_ iter_()、_ next_()是类的两个内置函数，可以通过定义他们两个实现迭代器协议，产生的实例就可以变成一个迭代器

未定义__iter__()方法会导致无法执行iter()函数

class Foo:

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


f1 = Foo(10)
for i in f1:
    print(i)
#for函数的本质是调用iter(f1)或者f1.__iter__()方法，将f1变为一个迭代器，但是此处的类未定义__iter__()方法，所以会报
#'Foo' object is not iterable的错

_ iter_()方法的返回值需要实现可迭代

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

    def __iter__(self):
        pass


f1 = Foo(10)
for i in f1:
    print(i)
#此处的类的__iter__()方法没有定义返回值，所以会报iter() returned non-iterator of type 'NoneType'的错

两个方法实现迭代器协议

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

    def __iter__(self):
        return self

    def __next__(self):
        self.n += 1
        return self.n


f1 = Foo(10)
print(f1.__next__())
for i in f1:
    print(i)
#每一次的f1.__next__()的结果传给i，f1调用f1.__iter__()变为一个可迭代对象

但是现在没有定义for循环的终止
通过升起StopIteration的异常来终止循环

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

    def __iter__(self):
        return self

    def __next__(self):
        if self.n < 13:
            self.n += 1
            return self.n
        else:
            raise StopIteration


f1 = Foo(10)
for i in f1:
    print(i)
#for函数会帮忙捕捉异常并终止循环不会报错。如果采用f1.__next__()方法获得下一个值则在最后一个值位置会报错

一个例子：
通过迭代器协议实现的斐波那切数列

class Fib:
    def __init__(self, start1, start2):
        self.start1 = start1
        self.start2 = start2

    def __iter__(self):
        return self

    def __next__(self):
        self.start1, self.start2 = self.start2, self.start1 + self.start2
        return self.start2


f1 = Fib(1, 2)
print(f1.__next__())
print(f1.__next__())
print(f1.__next__())
print(f1.__next__())
print(f1.__next__())

---

_ setitem_()、_ getitem_()、_ delitem_()

item类方法可以实现像操作字典一样操作实例的属性

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

    def __setitem__(self, key, value):
        print("执行setitem")
        self.__dict__[key] = value

    def __delitem__(self, key):
        print("执行delitem")
        self.__dict__.pop(key)

    def __getitem__(self, item):
        print("执行getitem")
        if self.__dict__[item]:
            return self.__dict__[item]
        else:
            print("属性不存在")


f1 = Foo("Cjj")
print(f1["name"])
f1["name"] = "MB"
print(f1["name"])
del f1["name"]

---

_ slots_

_ _slots__是一个类变量，变量值可以是列表 、元组或者可迭代对象，也可以是一个字符串

_ slots__的使用原因： 每创建一个实例就会创建一个独立的属性字典，而字典会占用大量内存，如果有一个属性很少的类但是这个类产生了很多事例，为了节省内存，可以使用__slots__变量来取代__dict_

__slots__的原理：当定义__slots__后，__slots__就会为实力使用一种更加紧凑的内部表示，实例通过一个很小的固定大小的数组来构建，而不是为每个实例定义一个字典

class Foo:
    __slots__ = ["name", "age"]


f1 = Foo()  # f1已经没有f1.__dict__，打印__dict__会报错
f1.name = "MB"
f1.age = 18
print(f1.name)
print(f1.age)
print(f1.__slots__)  # 相当于调用类的__slots__(print(Foo.__slots__))

这种方法限制了实例创建新的属性，只能定义已经写入__slots__的属性
定义__slots__的副作用较大，会影响所有操作__dict__的方法

---

---

_ str_()、_ repr_()

通过两个函数可以改变实例的字符串显示

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

    def __str__(self):
        return "自定义的str"

    
f1 = Foo("Cjj")
print(f1)

repr是用在解释器当中的改变实例字符串显示的方法

>>> class Foo:
...     def __repr__(self):
...             return "爱你"
...
>>> f1 = Foo()
>>> print(f1)

当两个方法在python中共存时调用__str__()方法

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

    def __str__(self):
        return "自定义的str"
    
    def __repr__(self):
        return "自定义的repr"


f1 = Foo("Cjj")
print(f1)

当__str__()方法不存在时，调用__repr__()方法

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

    def __repr__(self):
        return "自定义的repr"


f1 = Foo("Cjj")
print(f1)

注意：_ str_()、_ repr_()的return值必须都是字符串

---

_ format_()

自定义format方法

class Foo:
    def __init__(self, year, mon, day):
        self.year = year
        self.mon = mon
        self.day = day

    def __format__(self, format_spec):
        if not format_spec or format_spec not in format_dic:
            format_spec = "ymd"
        return format_dic[format_spec].format(self)


f1 = Foo(2018, 11, 12)
print(f1.__format__("y-m-d"))
print(format(f1, "ymd"))#本质是调用__fomat__()方法

---

_ doc_

调用类的文本
文本的东西无法继承给子类

class Foo:
    "Foo的描述信息"
    pass


class Bar(Foo):
    pass


f1 = Foo()
b1 = Bar()
print(f1.__doc__)
print(b1.__doc__)

---

_ mocule_、_ class_

_ module_ 表示当前操作的对象在哪个模块
_ class_ 表示当前操作的对象的类是什么

#module文件夹下module.py中
class C:
    def __init__(self):
        self.name = "SB"


#和module文件夹同级的文件中
from module.module import C
c1 = C()
print(c1.name)
print(c1.__module__)
print(c1.__class__)

---

_ del_()

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

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

    def __del__(self):
        print("我执行啦")


f1 = Foo("MB")
del f1

注意如果不以删除对象的方式释放内存，在程序执行完毕后也会自动释放对象的内存

---

_ call_()
对象后面加括号触发执行的方法

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

    def __call__(self, *args, **kwargs):
        print("call执行啦")


f1 = Foo("MB")
f1()
Foo("MB")()

注意，在类实例化的时候，类名()的方式其实也是调用产生该类的那个类的__call__()方法