Python之异常 猿类

异常

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

异常的分类：逻辑错误     # 是允许出现的，尽量避免

                     语法错误     # 不允许出现的

异常的组成：
    1. Traceback:追溯信息,可以定位到错误发生的位置
    2. 错误类型: XXXError(TypeError、KeyError、IndexError等)
    3. 错误的原因：重要

解决异常的完整语法：

try:
    被监测的代码(这块儿一般写可能会发生异常的代码)
except 错误类型1 as e:
    print(e) # 查看到错误的原因
except 错误类型2 as e:
    print(e) # 查看到错误的原因
except Exception as e:     # 万能的异常
    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 异常的类型

class Animal():           # 父类
    def speak(self):
        raise Exception("请先实现speak功能")  # 这个方式是最常用，因为简单
class People(Animal):     # 子类
    pass
obj=People()
obj.speak()      # 在子类中没有，去父类有，主动报错

断言：assert 条件     # 条件必须是成立的

# 作用: 单元测试(断言) 我自己写代码去测试我的写代码的bug UnitTest

l = ['kevin', 'jason', 'tank1']    
assert 'tank' in l     # 如果不在就直接回报错
print(123)     # tank在l中就会执行assert后的代码

自定义异常

class MyException(BaseException):
    def __init__(self, msg):
        self.msg = msg
    def __str__(self):
        return self.msg
raise MyException('用户名必须填写')    # 异常抛出
Python Mixins机制

# 辅类一般写在类的左边，主类写在类的右边，主类只有一个，而辅类可以有多个

# 辅类的类名一般都是以，python 对于mixin类的命名方式一般以 Mixin, able, ible 为后缀

class ThreadingUDPServer(ThreadingMixIn, UDPServer): pass

只是个规范

class Vehicle:  # 交通工具 主类：就是具备主要的功能
    '''这里面应该有其他交通工具都具备的功能'''
class FlyMixin(): # 专门写能够支持飞的功能
    def fly(self):
        '''
        飞行功能相应的代码
        '''
        print("I am flying")
class CivilAircraft(FlyMixin, Vehicle):  # 民航飞机
    pass
class Helicopter(FlyMixin, Vehicle):  # 直升飞机
    pass
class Car(Vehicle):  # 汽车并不会飞，但按照上述继承关系，汽车也能飞了
    pass

元类简介

# 元类即产生类的类

class Student():
    pass
Student()
print(type(Student))   # <class 'type'>
print(type(123))   # <class 'int'>
# 严格来说，type是查看一个对象是哪个类产生的

   # Student类就是type类产生的

class C1():
    pass
print(type(C1))   # <class 'type'>

# type是所有类的类，也就是说它是所有类的元类

产生类的两种方式

1. class 类名():
        pass

2、由于所有的类都是有元类创建的，所以，我们可以通过type这个类造出来一个新的类

      #   type(type(object_or_name, bases, dict)

      #   type('类名', '父类', '类的名称空间')

C1=type('C1', (), {'school':'SH'})
obj=C1()
print(C1.__dict__)    # C1的名称空间
class C1:
    school = 'SH'     # 没有class方便
print(C1.__dict__)

元类可以高度的对类做定制化

class Student():   # 首字母必须大写
   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)

元类的进阶用法

# 元类的__call__方法

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

推导：类名()：会执行元类type中得__call__方法

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('kevin', 20)      # ('kevin', 20)  {}
C1(name='kevin', age=20)   # ()  {'name': 'kevin', 'age': 20} 

在执行类的__init__方法之前，其实已经执行了元类的__call__

我们就可以在实例化对象的时候，对类做一些定制化