Python之异常的补充、元类

1 异常处理
        在Python中，异常处理是指程序在执行过程中遇到错误时，能够通过一定的机制来捕获和处理这些错误，从而保证程序的正常运行。

在Python中，异常（Exception）是一种标准的错误信息，当程序发生异常时，Python会抛出一个异常对象，我们可以通过捕获这个异常对象并处理它来控制程序的执行。

下面是一个简单的例子，演示如何使用Python的异常处理：

try:
    x = int(input('请输入一个整数：'))
    y = 10 / x
    print('结果是：', y)
except ValueError:
    print('输入的不是一个整数！')
except ZeroDivisionError:
    print('除数不能为零！')
except Exception as e:
    print('发生了一个异常：', e)
finally:
    print('程序结束')
 
 
在上面的例子中，我们使用了try-except语句来处理可能发生的异常。
 
try语句块中包含可能发生异常的代码。如果try语句块中的代码发生异常，Python会抛出一个异常对象。
 
except语句块用来捕获和处理这个异常对象。如果发生多个异常，我们可以使用多个except语句来分别处理不同的异常类型。
 
最后，无论是否发生异常，finally语句块中的代码都会执行。

1.1 异常的分类 
        逻辑错误  # 是允许出现的，但是呢，编程的时候尽量避免逻辑错误的发生
        语法错误  # 不允许出现的

1.2  异常的组成

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

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

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

举例：
    抽象类：在父类中限制子类必须有某个方法
    
    import abc
    class Animal(metaclass=abc.ABCMeta):
        @abc.abstractmethod # 这么设置之后，以后所有继承Animal类的子类中都必须有speak函数
        def speak(self):pass
    
    class People(Animal):
        def speak(self):
            pass
        
    """不推荐使用这种方式"""
1.4.1 异常关键字raise
class Animal():
    def speak(self):
        raise Exception("请先实现speak功能")  # 这个方式是最常用，因为简单
 
 
class People(Animal):
    pass
 
obj=People()
obj.speak()
"""主动抛出异常的关键字是：raise"""
"""语法结构：raise 异常的类型"""
# raise IndexError('索引错误')
# raise KeyError('字典错误')
# raise Exception('字典错误')
# print(123)

 1.5 assert 断言
#断言
 
 
assert 条件  # 条件必须是成立的
 
l = ['kevin', 'jason', 'tank1']
 
assert 'tank' in l
 
print(123)
 
# 有什么用：单元测试(断言) 我自己写代码去测试我的写代码的bug UnitTest
"""后续的代码中必须要用tank这个元素"""
自定义异常
class MyException(BaseException):
    def __init__(self, msg):
        self.msg = msg
    def __str__(self):
        return self.msg
 
    def reponse(self):
        pass
 
 
raise MyException('用户名必须填写')
 2 Python Mixins 机制
        Python mixins机制是一种实现代码重用的方法，它允许将一个类的功能添加到另一个类中，而无需继承或修改原有类的代码。Mixin类是一种特殊的类，通常只包含一些方法，并且这些方法可以被其他类作为扩展使用。Mixin类本身并不会被实例化，而是被其他类继承并与它们的方法混合在一起使用。Mixin类可以被多个类继承，从而实现代码的复用。

        Mixin类通常以Mixin结尾，例如，一个包含日志功能的Mixin类可以命名为LoggerMixin。Mixin类的方法要设计好接口，以便其他类可以正确地调用它们。Mixin类通常是比较小的类，因此可以在多个类中使用，从而避免了代码重复的问题。在Python中，使用Mixin可以实现类似于多重继承的功能。

        例如，假设有一个基础类Animal，它有一些简单的属性和方法，现在需要给Animal类添加一些行为，比如能够飞、能够游泳等。这时可以创建一些Mixin类，比如FlyMixin和SwimMixin，这些Mixin类只包含相应的方法，然后将它们混合到Animal类中，就可以得到新的Animal类，它具有飞行、游泳等功能。

下面是一个示例代码，演示了如何使用Mixin机制将多个类的功能合并到一个类中：

class FlyMixin:
    def fly(self):
        print("I'm flying!")
 
class SwimMixin:
    def swim(self):
        print("I'm swimming!")
 
class Animal:
    def __init__(self, name):
        self.name = name
 
class Bird(Animal, FlyMixin):
    def __init__(self, name):
        Animal.__init__(self, name)
 
class Fish(Animal, SwimMixin):
    def __init__(self, name):
        Animal.__init__(self, name)
 
class Duck(Animal, FlyMixin, SwimMixin):
    def __init__(self, name):
        Animal.__init__(self, name)
 
duck = Duck('Donald')
duck.fly()   # I'm flying!
duck.swim()  # I'm swimming!

在上面的示例中，FlyMixin类和SwimMixin类分别定义了飞和游泳的方法，Animal类是一个基础类，它只有一个名字属性。Bird类和Fish类都继承了Animal类，并且分别使用了FlyMixin和SwimMixin混合类。Duck类同样继承自Animal类，并且混合了FlyMixin和SwimMixin类，所以它同时具有飞行和游泳的能力。这样，就可以通过Mixin类的方式来实现类的多重继承，同时避免了多重继承所带来的复杂性。

3 元类
          什么是元类？即产生类的类

  3.1 type是所有类的类，也就是说它是所有类的元类
          type是查看一个对象是哪个类产生的

class Student():
    pass
 
Student()
# int # class int(object):
# str # class str(object):
# list # class list(object):
# res=int(123) # 123
# str('hello')
# list([1,2,3,4])
"""严格来说，type是查看一个对象是哪个类产生的"""
         type是所有类的类，也就是说它是所有类的元类

class Student():
    pass
 
print(type(Student)) # <class 'type'>
 
"""Student类就是type类产生的"""
 
class C1():
    pass
print(type(C1)) # <class 'type'>
 
 
class A():
    pass
 
print(type(A)) # <class 'type'>
"""type是所有类的类，也就是说它是所有类的元类"""

3.2 产生类的两种方式
        3.2.1 所有的类都是有元类创建的，所以，我们可以通过type这个类造出来一个新的类
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.2.2 使用元类 定制化代码
        3.2.2.1高度的对类做定制化
比如：让你定义一个类，但是，类的名字首字母必须大写.
    class Student():
        pass
    class a():
        pass
    
    """
    思考：我们的定制化代码应该写在哪里?
    
         对象是如何产生的? 调用类然后执行类里面的__init__方法了
         类是如何产生的? 推导应该是，造出类的类里面的__init__方法，而这个类恰好是type元类
         得出结论：如果想定制化类的代码，应该写在元类的__init__方法
        3.2.2.2 定制化的元类的__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()

4 元类的进阶用法
4.1  元类的__call__方法
对象() 的时候会调用产生对象的类中得__call__方法

元类的__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) # 现在是位置传参，我限制让你限制不允许位置传参，只能够通过关键字传参/