29 异常处理与元类

异常处理

1. 什么是异常处理

异常是错误发生的信号,一旦程序出错就会产生一个异常,如果该异常
没有被应用程序处理,那么该异常就会抛出来,程序的执行也随之终止

异常包含三个部分:

1. traceback异常的追踪信息
2. 异常的类型
3. 异常的信息

错误分为两大类:

1. 语法上的错误:在程序运行前就应该立即修正
2. 逻辑上的错误

2. 为何要异常处理

避免程序因为异常而崩溃,所以在应用程序中应该对异常进行处理,从而增强程序的健壮性

3. 如何异常处理

 try:
     f=open(‘a.txt‘,‘w‘)
     print(‘=====1‘)
     print(‘=====2‘)
     print(‘=====3‘)
     d = {‘x‘: 1, ‘y‘: 2}
     d[‘z‘]   #KeyError
     print(‘=====4‘)
     l = [1, 2, 3]
     l[1000]   #IndexError
     print(‘=====5‘)

 except IndexError as e:
     print(‘IndexError:‘, e)
 except KeyError as e:
     print(‘KeyError:‘, e)
 except Exception as e:# 万能异常类型Exception:可以匹配任意类型的异常
     print(‘Exception:‘,e)
 else:
     print(‘else必须放到后面,else的子代码块会在被检测的代码没有异常的情况下执行‘)
 finally:
     print(‘无论被检测的代码有没有异常都会执行‘)
     f.close()

主动触发异常

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

     def tell_info(self):
         print(self.__name,self.__age)

     def set_info(self,name,age):
         if not isinstance(name,str):
             raise TypeError(‘名字必须是str类型‘)
         if not isinstance(age,int):
             raise TypeError(‘年龄必须是int类型‘)
         self.__name=name
         self.__age=age

 obj=People(‘egon‘,18)
 print(obj.__dict__)
 obj.tell_info()

 obj.set_info(‘egon‘,123)
 obj.tell_info()

自定义异常类型(了解)

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

     def __str__(self):
         return ‘<%s>‘ %self.msg

 raise MyException(‘我自定义的异常‘)

断言(了解)

print(‘上半部分,生产数据‘)
l=[1,2,3,4]

if len(l) != 5:
     raise TypeError(‘列表的长度必须为5‘)
assert len(l) == 5

print(‘下半部分,处理数据‘)

元类介绍

什么是元类:

源自一句话:在python中,一切皆对象,而对象都是由类实例化得到的

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

    def score(self):
        print(‘%s is scoring‘ %self.name)

tea1=OldboyTeacher(‘egon‘,18,‘male‘)
print(type(tea1))
print(type(OldboyTeacher))

对象tea1是调用OldboyTeacher类得到的,如果说一切皆对象,那么OldboyTeacher也是一个对象,只要是对象
都是调用一个类实例化得到的,即OldboyTeacher=元类(...),内置的元类是type

关系:

1. 调用元类---->自定义的类
2. 调用自定义的类---->自定义的对象

class关键字创建自定义类的底层的工作原理,分为四步

1. 先拿到类名:‘OldboyTeacher‘
2. 再拿到类的基类们:(object,)
3. 然后拿到类的名称空间???(执行类体代码,将产生的名字放到类的名称空间也就是一个字典里,补充exec)
4. 调用元类实例化得到自定义的类: OldboyTeacher=type(‘OldboyTeacher‘,(object,),{...})

 class OldboyTeacher: OldboyTeacher=type(...)
     school = ‘Oldboy‘
     def __init__(self,name,age,sex):
         self.name=name
         self.age=age
         self.sex=sex

     def score(self):
         print(‘%s is scoring‘ %self.name)
 print(OldboyTeacher)

自定义类的三个关键组成部分:

1. 类名
2. 类的基类们
3. 类的名称空间

不依赖class关键字创建一个自定义类

1. 拿到类名

class_name=‘OldboyTeacher‘

2. 拿到类的基类们:(object,)

class_bases=(object,)

3. 拿到类的名称空间

class_dic={}
class_body="""
school = ‘Oldboy‘

def __init__(self,name,age,sex):
    self.name=name
    self.age=age
    self.sex=sex

def score(self):
    print(‘%s is scoring‘ %self.name)
"""
exec(class_body,{},class_dic)
print(class_dic)

4. 调用type得到自定义的类

OldboyTeacher=type(class_name,class_bases,class_dic)

print(OldboyTeacher)
print(OldboyTeacher.school)
print(OldboyTeacher.score)

tea1=OldboyTeacher(‘egon‘,18,‘male‘)
print(tea1.__dict__)

自定义元类来控制类的产生

模板

class Mymeta(type): #但凡继承了type的类才能称之为自定义的元类,否则就是只是一个普通的类
    def __init__(self,class_name,class_bases,class_dic):
        print(self)
        print(class_name)
        print(class_bases)
        print(class_dic)

classOldboyTeacher(object,metaclass=Mymeta):#OldboyTeacher=Mymeta(‘OldboyTeacher‘,(object,),{...})
    school = ‘Oldboy‘

    def __init__(self,name,age,sex):
        self.name=name
        self.age=age
        self.sex=sex

    def score(self):
        print(‘%s is scoring‘ %self.name)

控类的产生

1.类名必须用驼峰体
2.类体必须有文档注释,且文档注释不能为空

class Mymeta(type):# 但凡继承了type的类才能称之为自定义的元类,否则就是只是一个普通的类
　　def __init__(self,class_name,class_bases,class_dic):
　　　　if class_name.islower():
　　　　　　raise TypeError(‘类名必须使用驼峰体‘)

　　　　doc=class_dic.get(‘__doc__‘)
　　　　if doc is None or len(doc) == 0 or len(doc.strip(‘\n ‘)) == 0:
　　　　　　raise TypeError(‘类体中必须有文档注释,且文档注释不能为空‘)

class OldboyTeacher(object,metaclass=Mymeta): #OldboyTeacher=Mymeta(‘OldboyTeacher‘,(object,),{...})
　　school = ‘Oldboy‘

　　def __init__(self,name,age,sex):
　　　　self.name=name
　　　　self.age=age
　　　　self.sex=sex

　　def score(self):
　　　　print(‘%s is scoring‘ %self.name)

print(OldboyTeacher.__dict__)

自定义元类来控制类调用的过程

class Mymeta(type): #但凡继承了type的类才能称之为自定义的元类,否则就是只是一个普通的类
　　pass

class OldboyTeacher(object): OldboyTeacher=Mymeta(‘OldboyTeacher‘,(object,),{...})
　　school = ‘Oldboy‘

　　def __init__(self,name,age,sex):
　　　　self.name=name
　　　　self.age=age
　　　　self.sex=sex

　　def score(self):
　　　　print(‘%s is scoring‘ %self.name)

　　def __call__(self, *args, **kwargs):
　　　　print(self)
　　　　print(args)
　　　　print(kwargs)
tea1=OldboyTeacher(‘egon‘,18,‘male‘)

tea1(1,2,a=1,b=2)# __call__(tea1,(1,2).{‘a‘:1,‘b‘:2})

总结:对象之所以可以调用,是因为对象的类中有一个函数__call__
推导:如果一切皆对象,那么OldboyTeacher也是一个对象,该对象之所可以调用,肯定是这个对象的类中也定义了一个函数__call__

class Mymeta(type): #但凡继承了type的类才能称之为自定义的元类,否则就是只是一个普通的类
　　def __call__(self, *args, **kwargs): self=OldboyTeacher这个类,args=(‘egon‘,18,‘male‘),kwargs={}
　　　　#1. 先产生一个空对象
　　　　tea_obj=self.__new__(self) tea_obj是OldboyTeacher这个类的对象
　　　　#2. 执行__init__方法,完成对象的初始属性操作
　　　　self.__init__(tea_obj,*args,**kwargs)
　　　　#3. 返回初始化好的那个对象
　　　　return tea_obj

class OldboyTeacher(object,metaclass=Mymeta): OldboyTeacher=Mymeta(‘OldboyTeacher‘,(object,),{...})
　　school = ‘Oldboy‘

　　def __init__(self,name,age,sex):#tea_obj,‘egon‘,18,‘male‘
　　　　self.name=name
　　　　self.age=age
　　　　self.sex=sex

　　def score(self):
　　　　print(‘%s is scoring‘ %self.name)

tea1=OldboyTeacher(‘egon‘,18,‘male‘) 会触发OldboyTeacher的类(即元类)中的__call__函数
print(tea1)
print(tea1.__dict__)

实例化OldboyTeacher,或者说调用OldboyTeacher会
1. 先产生一个空对象
2. 执行__init__方法,完成对象的初始属性操作
3. 返回初始化好的那个对象
推导:调用OldboyTeacher(...)就是在调用OldboyTeacher的类中的__call__,那么在该__call__中就需要做上述三件事

自定义元类来控制类的调用(即类的实例化过程)

举例：

# 自定义轿车元类CarMeta
# -- 实现元类为CarMeta的类至少有生产日期(production_date)、发动机编号(engine_number)及载客量(capacity)三个基本属性

在__init__里做限制，不用调用类

class AttributeError(BaseException):
　　def __init__(self,msg):
　　　　super().__init__()
　　　　self.msg=msg

　　def __str__(self):
　　　　return self.msg

class CarMeta(type):
　　def __init__(self,class_name,class_bases,class_dic):
　　　　dic=class_dic
　　　　if not (‘pro_date‘ in dic and ‘en_number‘ in dic and ‘capacity‘ in dic):
　　　　　　raise AttributeError(‘必须有生产日期、发动机编号及载客量‘)

class Tesla(metaclass=CarMeta):
　　name=‘123‘
　　pro_date =1
　　en_number = 2

在__call__里做限制，如果你要调用Tesla类来生成对象的话

class AttributeError(BaseException):
　　def __init__(self, msg):
　　　　super().__init__()
　　　　self.msg = msg

　　def __str__(self):
　　　　return self.msg

class CarMeta(type):
　　def __call__(self, *args, **kwargs):
　　　　obj=self.__new__(self)
　　　　self.__init__(obj,*args,**kwargs)
　　　　if not (‘pro_date‘ in obj.__dict__ and ‘en_number‘ in obj.__dict__ and ‘capacity‘ in obj.__dict__):
　　　　　　raise AttributeError(‘必须有生产日期、发动机编号及载客量‘)
　　　　return obj

class Tesla(metaclass=CarMeta):
　　def __init__(self,production_date,engine_number):
　　　　self.pro_date=production_date
　　　　self.en_number=engine_number

alex=Tesla(1,2)

属性查找

class Mymeta(type): #只有继承了type类才能称之为一个元类，否则就是一个普通的自定义类
    n=444

    def __call__(self, *args, **kwargs): #self=<class ‘__main__.OldboyTeacher‘>
        obj=self.__new__(self)
        self.__init__(obj,*args,**kwargs)
        return obj

class Bar(object):
    n=333

class Foo(Bar):
    n=222

class OldboyTeacher(Foo,metaclass=Mymeta):
    n=111

    school=‘oldboy‘

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

    def say(self):
        print(‘%s says welcome to the oldboy to learn Python‘ %self.name)

print(OldboyTeacher.n) #自下而上依次注释各个类中的n=xxx，然后重新运行程序，发现n的查找顺序为OldboyTeacher->Foo->Bar->object->Mymeta->type

查找顺序：
1、先对象层：OldoyTeacher->Foo->Bar->object
2、然后元类层：Mymeta->type

原文地址：https://www.cnblogs.com/ouyang99-/p/10415429.html

时间： 2024-07-30 07:51:57

29 异常处理与元类的相关文章

元类,异常处理

什么是元类:# 源自一句话:在python中,一切皆对象,而对象都是由类实例化得到的.# 内置的元类是type.# # 1. 调用元类---->自定义的类# 2. 调用自定义的类---->自定义的对象 自定义类:# class关键字创建自定义类的底层的工作原理,分为四步 例如:class OldboyTeacher(object,):# 1. 先拿到类名:'OldboyTeacher'# 2. 再拿到类的基类们:(object,)# 3. 然后拿到类的名称空间???(执行类体代码,将产生的名字

面向对象中关于元类的介绍与异常处理

一.异常处理 1. 什么是异常处理     异常是错误发生的信号,一旦程序出错就会产生一个异常,如果该异常     没有被应用程序处理,那么该异常就会抛出来,程序的执行也随之终止 异常包含三个部分:         1. traceback异常的追踪信息         2. 异常的类型         3. 异常的信息 错误分为两大类:         1. 语法上的错误:在程序运行前就应该立即修正         2. 逻辑上的错误 2. 为何要异常处理 避免程序因为异常而崩溃,所以在应用程

29 内置方法 eval | exec 元类 单例

eval与exec内置方法 将字符串作为执行目标,得到响应结果 eval常用作类型转换:该函数执行完有返回值 exec拥有执行更复杂的字符串:可以形成名称空间 eval内置函数的使用场景:   1.执行字符串会得到相应的执行结果   2.一般用于类型转化,得到dict.list.tuple等 dic_str = "{'a': 1, 'b': 2, 'c': 3}" print(eval(dic_str)) list_str = "[1, 2, 3, 4, 5]" p

javascript设计模式-掺元类

有一种重用代码的方法不需要用到严格的继承.如果想把一个函数用到多个类中,可以通过扩充的方式让这些类共享该函数.其实际做法大大体为:先创建一个包含各种通用方法的类,然后再用它扩充其他的类.这种方式就叫做掺元类. 1 function augment(receivingClass,givingClass){ 2 if(arguments.length > 2){ 3 for(var i= 2, len = arguments.length;i<len;i++){ 4 receivingClass.

第六周 【项目5-友元类】

[项目5-友元类] 定义下面两个类的成员函数(为体验友元类,实际上本例并不一定是一个好的设计, 将两个类的合并为一个DateTime,日期.时间都处理更好) /* *Copyright (c)2014,烟台大学计算机与控制工程学院 *All rights reserved. *dood luck *文件名称:d.cpp *作 者:张旺华 *完成日期:2015年4月15日 *版 本 号:v1.0 * */ //项目5-友元类] //定义下面两个类的成员函数(为体验友元类,实际上本例并不一定是一个好

面向对象——元类

1.exec 1 exec(source, globals=None, locals=None, /) 2 Execute the given source in the context of globals and locals. 3 4 The source may be a string representing one or more Python statements 5 or a code object as returned by compile(). 6 The globals

Python----面向对象---元类介绍

一.储备知识exec 参数1:字符串形式的命令 参数2:全局作用域(字典形式),如果不指定默认就使用globals() 参数3:局部作用域(字典形式),如果不指定默认使用locals() 示例代码如下: 1 g = { 2 'x': 1, 3 'y': 2 4 } 5 6 l = {} 7 8 exec(''' 9 global x, m 10 x = 10 11 m = 100 12 13 z = 3 14 ''', g, l) 15 16 print(g) 17 print(l) 18 19

【python进阶】详解元类及其应用2

前言 在上一篇文章[python进阶]详解元类及其应用1中,我们提到了关于元类的一些前置知识,介绍了类对象,动态创建类,使用type创建类,这一节我们将继续接着上文来讲~~~ 5.使?type创建带有?法的类 最终你会希望为你的类增加?法.只需要定义?个有着恰当签名的函数并将 其作为属性赋值就可以了.添加实例?法 In [14]: def echo_bar(self):#定义了一个普通的函数 ...: print(self.bar) ...: In [15]: FooChild = type('

1.元类介绍/2.自定义元类控制类的行为/3.控制类的实例化行为/4.控制类的实例化行为的应用

1.元类介绍 1.储备知识exec()参数1;字符串形式得命令参数2.全局作用域(字典形式),如果不指定默认就使用globals()参数3.局部作用域(字典形式),如果不指定默认就使用locals() 2.python 一切皆对象 ,对象可以怎么用? 2.1. 都可以被引用 x=obj 2.2. 都可以当作函数得参数传入 2.3. 都可以当作函数得返回值 2.4. 都可以当作容器类得元素 li=[func,time] # 类也是对象,Foo=type() 类是属于type() 类 3.什么叫元类