day29 元类及异常处理

元类及异常处理

元类

什么是元类

在python中，一切皆对象，对象是由类产生的，那么类是不是对象呢？

举例：

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

从上例中可以看出，在python中，类也是对象，是由某个兑现实例化来的，而且这个类的名字叫做type，那么这个类又是什么呢？这个类就是元类

元类就是产生类的的类

实例化类对象

普通的类是由元类实例化产生的，那么我们如何按照普通类的方式去生成类对象呢？

由于定义类时会使用class关键字，实际上class关键字就帮我们做了实例化的过程

p = type()  # 通过元类实例化一个普通的类对象
# TypeError: type() takes 1 or 3 arguments

经过上方的代码测试，发现会报错，错误信息为缺少一个或者三个参数，我们来看一下源代码

class type():
    def __init__(cls, what, bases=None, dict=None): # known special case of type.__init__
        """
            type(object_or_name, bases, dict)
            type(object) -> the object's type
            type(name, bases, dict) -> a new type
            # (copied from class doc)
            """
        pass

在python中的源代码信息如上，通过上述信息可以发现，在我们使用type元类想要创建一个类对象时需要传入一个或者三个参数：

传入一个参数时：返回实例化这个对象的类

传入三个参数时分别是：

• name ：创建的类对象的名称，字符串类型

• bases：创建的这个类对象的父类们，tuple类型

• dict：这个类对象的名称空间，dict类型

那么我们传入这三个参数进行试验：

p = type("Aclass",(object,),{"a":10})
print(type(p)) # <class 'type'>

通过上方的测试代码我们创建了一个类对象，并且将这个对象的地址赋值给了p

总结

• 在python中，一切皆对象，类也是对象，普通类是由元类实例化产生的类对象

• 元类是用来产生类的类，英文为metaclass

• 我们可以通过type(class_name，bases,dict)自己实例化元类的类对象

元类可以做什么？

元类的主要作用

• 自定义类对象时使用

• 限制类对象的实例化过程时使用

如何使用元类？

1、定义类对象的使用过程__init__方法（重点）

# 需求：在定义类时类名必须大写，类中的属性及方法必须小写
class MyMetaClass(type):
    def __init__(self,class_name,bases,dict):
        if not class_name.istitle():
            raise Exception("类名必须为大驼峰命名法")
        for k in self.__dict__:
            if not k.islower():
                raise Exception("属性及方法名必须小写")
        super().__init__(class_name,bases,dict)
​
​
class person(metaclass=MyMetaClass): # 将person的元类指定为 MyMetaClass
     pass
​
#     raise Exception("类名必须为大驼峰命名法")
# Exception: 类名必须为大驼峰命名法
​
​
class Person(metaclass=MyMetaClass):
    def My(self):
        pass

#     raise Exception("属性及方法名必须小写")
# Exception: 属性及方法名必须小写

通过上述的方法，我们可以高度定义类对象的实例化，从而限制类的定义

与普通的实例化相同，在进行对象的实例化时会调用__init__方法，并执行，此时只要在实例化过程中进行限制就可以定制化类对象的实例化

2、类中的__new__方法（用的比较少）

在以前说过，类的实例化会进行两步：

• 产生一个空的对象

• 对产生的空对象进行初始化

元类的实例化产生类对象与普通的类进行实例化相似，也会经过这两个步骤

使用__init__方法可以进行初始化过程，那么如何产生空的对象呢？

使用__new__方法可以创建空的对象

# __new__的源代码解释
@staticmethod # known case of __new__
    def __new__(*args, **kwargs): # real signature unknown
        """ Create and return a new object.  See help(type) for accurate signature. """
        pass

上述的源代码显示

• __new__方法为静态方法（非绑定方法）

• __new__方法是用来创建一个空对象并将其返回

那么其中的*args、**kwargs是什么呢？

class MyMetaClass(type):
    def __new__(cls, *args, **kwargs):
        print(cls)  # <class '__main__.MyMetaClass'>
        print(args)  # ('A', (), {'__module__': '__main__', '__qualname__': 'A',"a":10})
        print(kwargs)  # {}
​
class A(metaclass=MyMetaClass):
    a = 10

通过上述方法可以看见：

• 其中cls为MyMetaClass类

• args中的值为使用元类进行创建对象时传入的三个参数

• kwargs为创建对象时传入的关键字参数

通过类的实例化过程我们可以知道，会首先执行__new__方法，然后再执行__init__方法

在__new__中也会将对象的名称空间进行传入，那么是否可以在__new__方法中进行定制化呢？

class MyMetaClass(type):
    def __new__(cls, *args, **kwargs):
        if not args[0].istitle():
            raise Exception("类名必须为大驼峰命名法")
        for k in args[2].values():
            if not k.islower():
                raise Exception("属性及方法名必须小写")
        return type.__new__(cls,*args,**kwargs)
​
class A(metaclass=MyMetaClass):
    B = 10
​
# Traceback (most recent call last):
#   File "H:/py8-study/practice/day29/元类的引出.py", line 69, in <module>
#     class A(metaclass=MyMetaClass):
#   File "H:/py8-study/practice/day29/元类的引出.py", line 66, in __new__
#     raise Exception("属性及方法名必须小写")
# Exception: 属性及方法名必须小写
​

通过上述__new__与__init__的学习，产生了以下几个疑问：

1、__init__与__new__有什么区别呢？

• __init__方法是在创建了类对象后初识化时执行的

• __new__方法是在创建对象时执行

2、在__new__中也可以进行类的定制化，那么在实现定制化时应该使用__init__方法还是__new__方法呢？

• 在进行定制化时两者都可以使用，按照合理的思维可以是对类对象的名字进行限制或定制化时，应该使用__new__方法，在不符合条件时，就不让类进行实例化，

• 如果对类对象的属性及方法进行限制或定制化时使用__init__方法，只有符合条件时才能进行初始化

• 但是推荐的是使用__init__方法，因为__init__方法的使用较为简单

• 在使用__new__创建对象时必须讲对象进行返回，而创建对象的方法在type类中，所以每次必须调用type.__new__(cls,*args,**kwargs)，并将其返回

3、有了__new__为什么还要使用__init__方法呢？

• 虽然在元类创建类对象时看着两者的方法作用没什么区别，但是在创建普通的对象时区别很大，__new__就是用来产生空对象的，__init__就是用来产生初始化对象的，两者的功能交叉很小，因为在实例化普通对象时没有名称空间的字典。

• 在元类实例化类对象时虽然看着两者功能很相似，但是不同的方法有不同的职责，在进行创建对象时就使用__new__方法，进行对象初始化时就使用__init__方法

3、__call__方法

我们在进行程序编写时经常会出现 以下错误：

class A:
    b = 10
    def func(self):
        pass

a = A()
a.func()
a.b()

# Traceback (most recent call last):
#   File "H:/py8-study/practice/day29/元类的引出.py", line 82, in <module>
#     a.b()
# TypeError: 'int' object is not callable

我们执行上述程序时，调用func函数时就不会报错，但是调用b()时就会报错，这是为什么的？

这时因为在对象类时有一个__call__方法进行控制，在进行调用时会执行类的__call__方法

在上述例子中，由于func是function类实例化的对象，而b是int类实例化的对象，而在func中会将函数的执行结果进行返回，而在int中会抛出异常

那么__call__在什么时候会被调用呢？

在用类进行实例化对象时会被调用

如何使用__call__进行控制实例化对象的过程

class MyMeta(type):
    def __call__(self, *args, **kwargs):
        print(self)
        print(args)
        print(kwargs)

class A(metaclass=MyMeta):
    def __init__(self,name,age):
        self.age = age
        self.name = name

# 在此处执行时，不添加下方代码不会打印

a = A("lee",18)
# <class '__main__.A'>
# ('lee', 18)
# {}

从上述代码中可以看出，只有在实例化过程中才会调用__call__方法

并且调用者时A，其参数就是实例化时输入的参数

因为在A类对象中没有__call__方法，所以继续寻找他的类MyMeta,并使用其中的__call__方法

那么我们就可以使用这个特性将元类中的__call__方法进行继承并自定义，增加我们的限制等

下方的单例模式就是这个的应用方式之一

单例设计模式

当我们设计的类只希望产生一个对象时就要用到单例设计模式

class SingleMetaClass(type):
    def __init__(self,name,bases,dic):
        self.obj = None
​
    def __call__(self, *args, **kwargs):
        if self.obj:
            return self.obj
        obj = type.__call__(self,*args,**kwargs)
        self.obj = obj
        return self.obj
​
​
class Student(metaclass=SingleMetaClass):
    def __init__(self,name,age):
        self.name = name
        self.age = age
​
    def say(self):
        print("my name is %s"%self.name)
​
​
s1 = Student("lee",18)
print(s1)
​
s2 = Student("lee",18)
print(s2)
​
class Teacher(metaclass=SingleMetaClass):
    def __init__(self,name,age):
        self.name = name
        self.age = age
​
    def say(self):
        print("my name is %s"%self.name)
​
t = Teacher("lee",18)
print(t)
​
​
# <__main__.Student object at 0x000001F8D96AD320>
# <__main__.Student object at 0x000001F8D96AD320>
# <__main__.Teacher object at 0x000001F8D96AD3C8>

异常

什么是异常

异常是程序运行过程中发生的非正常情况,是一个错误发生时的信号

异常如果没有被正确处理的话,将导致程序被终止,这对于用户体验是非常差的,可能导致严重的后果

处理异常的目的就是提高程序的健壮性

异常的分类

python解释器在执行代码前会先检查语法,语法检查通过才会开始执行代码

1.语法检测异常 作为一个合格的程序员 是不应该出现这种低级错误

2.运行时异常

已经通过语法检测,开始执行代码,执行过程中发生异常 称之为运行时异常

异常:

TypeError: 'int' object is not subscriptable     对象不能被切片
TypeError: 'list' object is not callable        对象不能被调用
IndexError: list index out of range             索引超出范围
TypeError: 'builtin_function_or_method' object is not iterable     对象不能被迭代
KeyError: 'xxx'      不存在这个key
FileNotFoundError: [Errno 2] No such file or directory: 'xxxxx'  文件找不到

异常的组成:

Traceback (most recent call last):
  File "F:/python8期/课堂内容/day29/11.常见异常.py", line 22, in <module>
    with open("xxxxx") as f:
FileNotFoundError: [Errno 2] No such file or directory: 'xxxxx    

Traceback    是异常追踪信息   用于展示错误发生的具体位置 以及调用的过程
其中 包括了 错误发生的模块  文件路径   行号  函数名称  具体的代码

最后一行  前面是错误的类型
		 后面 错误的详细信息   在查找错误时 主要参考的就是详细信息

异常处理

异常发生后 如果不正确处理将导致程序终止,我们必须应该尽量的避免这种情况发生

重点:

必须掌握的语法

语法:

try:

可能会出现异常的代码 放到try里面

except 具体异常类型 as e:

如果真的发生异常就执行except

如何正确处理异常

1. 当发生异常 不是立马加try 要先找出错误原因并解决它

2. try 仅在 即使你知道为什么发生错误 ,但是你却无法避免 例如 你明确告诉用户 需要一个正确文件路径 然而用户依然传入了错误的路径

   如 socket 双方都要使用管道 ,但是如果一方有由于某些原因强行关闭了 ,即使你知道原因也无法避免出错 那就只能try 保证程序正常结束

   总结一句话:能不加try 就不加try

自定义异常类

当系统提供异常类不能准确描述错误原因时 就可以自定义异常类

继承自Exception即可

class  MyException(Exception):
    pass
 

主动抛出异常:

什么时候需要主动抛出异常

当我们做功能的提供者,给外界提供一个功能接口

但是使用者不按照相应的方式来使用,或者参数类型不正确等原因,导致功能无法正常执行时,就应该主动抛出异常

主动抛出异常使用raise 关键字

后面可以跟任何Exception的子类 或是 对象

raise MyException
raise MyException("错误具体原因!")

断言assert

断言 其实可以理解为断定的意思

即非常肯定某个条件是成立的

条件是否成立其实可以使用if来判断

其存在的目的就是 为了简化if 判断而生的