面向对象（三）

python的Mixins机制

一个子类可以继承多个父类，一个父类也可以有多个子类。我们还是拿交通工具举例子

class Vehicle:  # 交通工具
    def fly(self):
        '''
        飞行功能相应的代码        
        '''
        print("I am flying")


class CivilAircraft(Vehicle):  # 民航飞机
    pass


class Helicopter(Vehicle):  # 直升飞机
    pass


class Car(Vehicle):  # 汽车并不会飞，但按照上述继承关系，汽车也能飞了
    pass

比如，民航飞机、直升飞机、汽车都是交通工具，但民航飞机和直升飞机有飞的功能，汽车并不会飞。它们又都同时继承了交通工具的类。如果民航飞机和直升飞机各自写各自飞行的类，又违背了代码间接性的原则，为了不让代码冗余，Python提供了Mixins机制。

简单来说Mixins机制指的是子类混合(mixin)不同类的功能，而这些类采用统一的命名规范（例如Mixin后缀），以此标识这些类只是用来混合功能的，并不是用来标识子类的从属"is-a"关系的，所以Mixins机制本质仍是多继承，但同样遵守”is-a”关系，如下

class Vehicle:  # 交通工具
    pass


class FlyableMixin:
    def fly(self):
        '''
        飞行功能相应的代码        
        '''
        print("I am flying")


class CivilAircraft(FlyableMixin, Vehicle):  # 民航飞机
    pass


class Helicopter(FlyableMixin, Vehicle):  # 直升飞机
    pass


class Car(Vehicle):  # 汽车
    pass

# ps: 采用某种规范（如命名规范）来解决具体的问题是python惯用的套路

 继承的类书写顺序也有讲究，辅类一般写在类的左边，主类写在类的右边，主类只有一个，而辅类可以有多个。辅类的类名也有讲解，辅类的类名一般都是以，python 对于mixin类的命名方式一般以 Mixin, able, ible 为后缀

 

异常（补充）

异常就是错误发生的信号，我们需要对该信号做处理，如果不处理，往后的代码就不能执行了

异常的组成：
    1. Traceback:追溯信息,可以定位到错误发生的位置
    2. 错误类型: XXXError(TypeError、KeyError、IndexError等)
    3. 错误的原因：通过这部分我们可以很精准的找到错误的具体原因，这块对我们解决问题是最重要的

#解决异常的完整语法：
	try:
        被监测的代码(这块儿一般写可能会发生异常的代码)
    except 错误类型1 as e:
        print(e) # 查看到错误的原因
    except 错误类型2 as e:
        print(e) # 查看到错误的原因
   except 错误类型3 as e:
        print(e) # 查看到错误的原因
   except 错误类型4 as e:
        print(e) # 查看到错误的原因
   except Exception as e: '''万能的异常，以上所有的类型都没有被找到，就交给Exception处理'''
        print(e) # 查看到错误的原因
   else:
    	print('被监测的代码没有异常的时候会走这个分支')
    finally:
        print('不管被监测的代码有么有异常都会走')

 主动抛出异常：我们自己有时候也需要抛出一些异常信息，来阻止代码的执行

在不符合Python解释器的语法或逻辑规则时，是由Python解释器主动触发的各种类型的异常，而对于违反程序员自定制的各类规则，则需要由程序员自己来明确地触发异常，这就用到了raise语句，raise后必须是一个异常的类或者是异常的实例

class Animal():
    def speak(self):
        raise Exception("请先实现speak功能")  # 这个方式是最常用

class People(Animal):
    pass

obj=People()
obj.speak()

Python还提供了一个断言语句assert expression，断定表达式expression成立，否则触发异常AssertionError

age='18'

# 若表达式isinstance(age,int)返回值为False则触发异常AssertionError
assert isinstance(age,int)

# 等同于
if not isinstance(age,int):
	raise AssertionError

 元类

什么是元类呢？就是产生类的类

class Student():
    pass

Student()
#通常定义类是这样

一切皆为对象，那么类Student本身也是一个对象，既然所有的对象都是调用类得到的，那么Student必然也是调用了一个类得到的，这个类称为元类

于是

print(type(Student)) # <class 'type'>

Student类就是type类产生的，type是所有类的类，也就是说它是所有类的元类

产生类的两种方式

第一种，class 类名():pass
第二种，由于所有的类都是有元类创建的，所以，我们可以通过type这个类造出来一个新的类

    # type(object_or_name, bases, dict)
    # type('类名', '父类', '类的名称空间')
	C1=type('C1', (), {'school':'SH'})
    obj=C1()
    print(C1.__dict__)
    print(obj.__dict__)

自定义元类的使用

    比如：让你定义一个类，但是，类的名字首字母必须大写.
    class Student():
        pass
    class a():
        pass

思考：我们的定制化代码应该写在哪里?
    
         对象是如何产生的? 调用类然后执行类里面的__init__方法了
         类是如何产生的? 推导应该是，造出类的类里面的__init__方法，而这个类恰好是type元类
         得出结论：如果想定制化类的代码，应该写在元类的__init__方法

但是，我们不能直接在源码里修改元类，所以可以写一个子类，来继承type类，然后在子类里面的__init__方法中书写定制化代码，所以，还需要在子类里面执行父类的__init__方法 

class MyTypeClass(type):
    def __init__(self, cls_name, cls_bases, cls_dict):
        print(cls_name)  # 类名C1
        print(cls_bases)  # ()父类
        print(cls_dict)  # {'__module__': '__main__', '__qualname__': 'C1'}
        if not cls_name.istitle():
            raise Exception("类名必须大写!!!")
        super().__init__(cls_name, cls_bases, cls_dict)


"""元类不能够直接被继承，需要指定metaclass=MyTypeClass"""


class C1(metaclass=MyTypeClass):
    def __init__(self):
        print('C1.__INIT__')

C1()

 

元类的进阶用法

对象() 的时候会调用产生对象的类中得__call__方法，其实也就是调用type中的__call__方法 

搞明白C1类里的__init__方法和MyClass里的__call__方法的执行顺序
在执行类的__init__方法之前，其实已经执行了元类的__call__方法了,既然这样，我们就可以在实例化对象的时候，对类做一些定制化

class MyClass(type):
    def __call__(self, *args, **kwargs):
        print(args) # ()  ('kevin', 20)
        print(kwargs) # {'name': 'kevin', 'age': 20} {}
        if args:
            raise Exception("必须使用关键字传参")
        print('MyClass.__call__')
        super(MyClass, self).__call__(*args, **kwargs)

class C1(metaclass=MyClass):
    def __init__(self,name, age):
        self.name = name
        self.age = age
        print('C1.__init__')

# C1('kevin', 20) 
# 现在是位置传参，我限制让你限制不允许位置传参，只能够通过关键字传参