Python with，多继承

with

with 就是上下文协议，可以自动的帮你将上下文管理器资源关闭，如 用with open 打开了一个文件，后面你就不用手动的将它关闭，在with 中会自动的帮你关闭该资源

在一个类中只要实现了 __enter__()和 __exit__()方法的类就是一个上下文管理器， 当使用
with 这个实例对象的时候 会调用 __enter__()方法，这个方法打开文件，或连接数据库，如何返回该操作的对（打开文件的对象或连接数据库的对象） 当这个资源对象使用结束后，会自动调用 上下文管理器中的 __exit__(), 这时候，我们可以在这个方法里面对资源进行关闭操作，

class A:
    def __init__(self):
        self.f = None

    def __enter__(self):
        self.f = open("./aaa.txt", "r")
        return self.f
        
    def __exit__(self, exc_type, exc_val, exc_tb):
        self.f.close()

a = A()
with a as f:
    content = f.read()
print(content)   # hello world

如上代码，这里默认是打开了当前目录下的 aaa.txt 文件，可以看到，我们使用了 with 上下文协议来调用上下文管理器，它可以在合适的时候自动帮我们调用 __exit__()中的资源关闭操作

contextmanager

不仅可以使用类来调用上下文管理器，还可以使用生成器+装饰器来创建一个上下文管理器，这种方式更简单

在python中有一个 contextlib模块中提供了一个 contextmanager方法，可以使用该方法来装饰一个生成器，这个生成器就是一个上下文管理器，在yield 前面写上连接，打开资源， 在yield 后面写对这个资源的扫尾工作， 如 关闭文件，关闭连接

from contextlib import contextmanager


@contextmanager
def aaa():
    f = open("./aaa.txt", "r")
    yield f   # 将资源返回
    f.close()


with aaa() as f:
    content = f.read()
    print(content)

此时的aaa函数就是一个上下文管理器

多继承

当python类中出现了多继承时，类里面没有方法的时候而继承的多个父类中都有的时候会调用哪个父类中的方法呢？
单继承的父类之间没有共同继承类时：

class A:
    def func(self):
        print("这是A类的方法")

class B:
    def func(self):
        print("这是B类的方法")

class A1:
    def func(self):
        print("这是A1类的方法")

class A2:
    def func(self):
        print("这是A2类的方法")

class C(A1, A2):
    def func(self):
        print("这是C类的方法")

class D(B, A):
    pass
    
class F(D, C):
    def __init__(self):
        pass


f = F()
f.func()
print(F.mro())
# 这是B类的方法
# [<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.A'>, <class '__main__.C'>, <class '__main__.A1'>, <class '__main__.A2'>, <class 'object'>]

有点像二叉树中的前序遍历一样，先打印最顶端的，再打印左边的，再打印右边的，类继承的顺序就是这样，当要调用的方法没有在实例对象类中找到，那么它就到第一个继承的父类中找，继承的父类中也找不到的话，它会到父类的第一个继承的父类中找，依次类推

当继承的父类有交互时， 如，D继承了A类， C 也继承了A 类时

class A:
    def func(self):
        print("这是A类的方法")

class B:
    def func(self):
        print("这是B类的方法")

class A1:
    def func(self):
        print("这是A1类的方法")

class A2:
    def func(self):
        print("这是A2类的方法")

class C(A, A2):
    def func(self):
        print("这是C类的方法")

class D(B, A):
    pass

class F(D, C):
    def __init__(self):
        pass

f = F()
f.func()
print(F.mro())

继承顺序就发生了变化， 如果有同等级的父类也继承了同样的父类，那么，在找完左边的父类后，会将查找操作让出来，让同等级的父类执行，让右边的父类进行查询，当右边的父类找完后再回到左边跳转的位置

class A:
    def func(self):
        print("这是A类的方法")

class B:
    def func(self):
        print("这是B类的方法")

class B2:
    def func(self):
        print("这是B2类的方法")
class B1(B2):
    def func(self):
        print("这是B1类的方法")
        
class A1:
    def func(self):
        print("这是A1类的方法")

class A2:
    def func(self):
        print("这是A2类的方法")

class C(A2, A):
    def func(self):
        print("这是C类的方法")

class D(B, A, B1):
    pass

class F(D, C):
    def __init__(self):
        pass

f = F()
f.func()
print(F.mro())

# 这是B类的方法
# [<class '__main__.F'>, <class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A2'>, <class '__main__.A'>, <class '__main__.B1'>, <class '__main__.B2'>, <class 'object'>]

可以看到， 当D类中继承了三个类，其中第二个继承父类是和 C 类一样继承的父类，那么，当查找顺序找完 B 的时候，就会将查找让出来，给 C，然后C 就开始查找它的子类，当它找完它所以的继承类时，就将查找返回给D 类， 给D类中的 B1父类进行查找