异常，元类，Mixins机制

异常

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

异常的分类

逻辑错误：逻辑的错误是允许出现的，但是我们在变形程序的时候应该尽量避免逻辑错误的发生

语法错误：语法错误是不允许出现的

异常的组成：

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('不管被监测的代码有么有异常都会走')
"""以上结构不是必须全部都要有的，需要哪些就写哪些"""

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

例子：

抽象类：在父类中限制子类必须有某个方法

    import abc
    class Animal(metaclass=abc.ABCMeta):
        @abc.abstractmethod # 这么设置之后，以后所有继承Animal类的子类中都必须有speak函数
        def speak(self):pass
    
    class People(Animal):
        def speak(self):
            pass

我们常用raise关键字来主动抛出异常

raise的语法结构：raise 异常的类型

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


class People(Animal):
    pass

obj=People()
obj.speak()

断言

Python还提供了一个断言语句assert expression，断定表达式expression成立，否则触发异常AssertionError，与raise-if-not的语义相同，如下

age='18'

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

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

自定义异常

class MyException(BaseException):
    def __init__(self, msg):
        self.msg = msg
    def __str__(self):
        return self.msg

    def reponse(self):
        pass


raise MyException('用户名必须填写')

python Mixins机制

class Vehicle:  # 交通工具 主类：就是具备主要的功能
    '''这里面应该有其他交通工具都具备的功能'''


# 辅类：写一些辅助的功能，辅类中得函数一般很少
class FlyMixin(): # 专门写能够支持飞的功能
    def fly(self):
        '''
        飞行功能相应的代码
        '''
        print("I am flying")

# class FlyMixin(): # 专门写能够支持飞的功能
# class Flyable(): # 专门写能够支持飞的功能
class Flyible(): # 专门写能够支持飞的功能
    def fly(self):
        '''
        飞行功能相应的代码
        '''
        print("I am flying")

# 继承的类书写顺序也有讲究
# 辅类一般写在类的左边，主类写在类的右边，主类只有一个，而辅类可以有多个

# 辅类的类名也有讲解，辅类的类名一般都是以，python 对于mixin类的命名方式一般以 Mixin, able, ible 为后缀
class CivilAircraft(FlyMixin, Flyible, Vehicle):  # 民航飞机
    pass


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


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

元类

什么是元类

元类就是用来实例化产生类的类

关系：元类----->实例化------->类（People）-------->实例化------>对象（obj）

t1=StanfordTeacher('lili',18)
print(type(t1)) #查看对象t1的类是<class '__main__.StanfordTeacher'>

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

于是我们可以推导出===>产生StanfordTeacher的过程一定发生了：StanfordTeacher=元类(...)

print(type(StanfordTeacher)) # 结果为<class 'type'>，证明是调用了type这个元类而产生的StanfordTeacher，即默认的元类为type

查看内置的元类

1.type是内置的元类

2.我们用class关键字定义的类以及内置的类都是由元类type实例化产生

class People:
    def __init__(self,name,age):
        self.name=name
        self.age=age

    def say(self):
        print('%s:%s' %(self.name,self.name))

print(type(People)) # <class 'type'>
print(type(int)) # <class '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)
        print(cls_bases)
        print(cls_dict)
        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__方法

对象+（）的时候会调用产生对象的类中的__call__ 方法

推导：类名+（）会执行产生类的类中的__call__方法，其实就是元类type中的__type__方法

举例：

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


C1('kevin', 20)

上述代码中参数的传递是位置传参，接下来我们给它限制只能通过关键字传参，不允许位置传参

class MyClass(type):
    def __call__(self, *args, **kwargs):
        print(args)
        print(kwargs)
        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(name='star',age=18)