抛出异常 和 元类

1. 主动抛出异常

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

主动抛出异常：我们自己有时候也需要抛出一些异常信息，来阻止代码的执行
举例：
    抽象类：在父类中限制子类必须有某个方法
import abc
class Animal(metaclass=abc.ABCMeta):
    @abc.abstractmethod # 这么设置之后，以后所有继承Animal类的子类中都必须有speak函数
    def speak(self):pass
    
class People(Animal):
    def speak(self):
        pass
       
    """不推荐使用这种方式"""

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


class People(Animal):
    pass

obj=People()
obj.speak()


# 断言
# assert 条件  # 条件必须是成立的
# l = ['kevin', 'jason', 'tank1']
# assert 'tank' in l
# print(123)


自定义异常
class MyException(BaseException):
    def __init__(self, msg):
        self.msg = msg
    def __str__(self):
        return self.msg

    def reponse(self):
        pass


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

2. 元类

产生类的两种方法

1. class 类名():
        pass
    
2. 由于所有的类都是有元类创建的，所以，我们可以通过type这个类造出来一个新的类
    # type(object_or_name, bases, dict)
    # type('类名', '父类', '类的名称空间')
    C1=type('C1', (), {'school':'SH'})
    obj=C1()
    print(C1.__dict__)
    print(obj.__dict__)
3. 为什么要学元类? 有什么用?
    
    # 我们学习元类，可以高度的对类做定制化
    比如：让你定义一个类，但是，类的名字首字母必须大写.
    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__方法

对象() 的时候会调用产生对象的类中得__call__方法

推导：类名()? 会执行产生类的类中得__call__方法，其实就是元类type中得__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类里的__init__方法和MyClass里的__call__方法的执行顺序?"""
"""得出结论：在执行类的__init__方法之前，其实已经执行了元类的__call__方法了,既然这样，我们就可以在实例化对象的时候，对类做一些定制化"""
# C1('kevin', 20) # 现在是位置传参，我限制让你限制不允许位置传参，只能够通过关键字传参/
C1(name='kevin', age=20) # 现在是位置传参，我限制让你限制不允许位置传参，只能够通过关键字传参/