开发者社区> 我要学编程> 正文
阿里云
为了无法计算的价值
打开APP
阿里云APP内打开

python-异常处理、元类

简介: 一、异常处理 1.异常处理介绍:   异常是错误发生的信号,一旦程序出错就会产生一个异常,如果该异常没有被应用程序处理,那么该异常就会被抛出来,程序执行随之停止 2.异常通常包含三个部分   1.
+关注继续查看

一、异常处理

1.异常处理介绍:

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

2.异常通常包含三个部分

  1.traceback异常的追踪信息

  2.异常的类型

  3.异常的信息

3.为何使用异常处理:

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

4.自定义处理异常的结构

1) try: except Exception as e:
2) try: except Exception: else:
3) try: except Exception: else: finally:
4) try: except...
5) try: finally:
else必须放到后面,else的代码块会在没有异常的情况下运行
finally:无论被检测的代码有无异常,都会运行,通常用于资源回收(列如 文件操作中途代码错误 可以在finally中定义回收代码)

自定义异常:(防止资源被无限占用,自定义规范)

"""
class MyException(BaseException):
    # 构造自定义异常类对象
    def __init__(self):
        pass
    # 格式化异常信息
    def __str__(self):
        pass
"""
自定义异常必须要继承
Exception:可以匹配任意类型的异常 被称为万能异常类型
AttributeError 试图访问一个对象没有的树形,比如foo.x,但是foo没有属性x
IOError 输入/输出异常;基本上是无法打开文件
ImportError 无法引入模块或包;基本上是路径问题或名称错误
IndentationError 语法错误(的子类) ;代码没有正确对齐
IndexError 下标索引超出序列边界,比如当x只有三个元素,却试图访问x[5]
KeyError 试图访问字典里不存在的键
KeyboardInterrupt Ctrl+C被按下
NameError 使用一个还未被赋予对象的变量
SyntaxError Python代码非法,代码不能编译(个人认为这是语法错误,写错了)
TypeError 传入对象类型与要求的不符合
UnboundLocalError 试图访问一个还未被设置的局部变量,基本上是由于另有一个同名的全局变量,
导致你以为正在访问它
ValueError 传入一个调用者不期望的值,即使值的类型是正确的
一些常用异常

主动抛出异常:raise Exception(msg)

断言(了解)

# print('上半部分,生产数据')
# l = [1,2,3,4,5]
#
# # if len(l)!=5:
# #     raise TypeError('列表的长度必须是5')
# assert len(l) ==5 #if的简化版本
# print('下半部分,处理数据')

二、元类

1.元类介绍:

  源自于一句话,在python中,一切皆对象,而对象都是由类实例化得到的。简单的说 元类就是产生类的类

定义了一个类,类里有一个构造器和方法

class OldboyTeacher:
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
    def score(self):
        print('%s'%self.name)

tea1 = OldboyTeacher('egon',18,'male')
print(type(tea1))#<class '__main__.OldboyTeacher'>
print(type(OldboyTeacher))#<class 'type'>

从上面的代码中我们可以看出,对象teal调用OldboyTeacher类得到的,一切皆对象,OldboyTeacher也是一个对象,只要是对象,都是调用一个类的实例化方法得到的,即OldboyTeacher=元类,OldboyTeacher类的类型为type,内置元类就是type

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

  1.先拿到类名:OldboyTeacher

  2.再拿到类的基类们:object

  3.然后拿到类的名称空间(执行类体代码,将产生的名字放到类的名称空间,也就是一个字典里)

  4.调用元类来实例化得到自定义的类:OldboyTeacher = type(OldboyTeacher,(object,){...})

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

  1.类名

  2.类的基类

  3.类的名称空间

不依赖class类创建一个自定义类:

#1.拿到类名
clss_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)#可以把exec命令的执行当成是一个函数的执行,会将执行期间产生的名字存放于局部名称空间中
print(class_dic)#{'school': 'Oldboy', '__init__': <function __init__ at 0x00000209D705C268>, 'score': <function score at 0x00000209D7208B70>}
# 4.调用type得到自定义的类
OldboyTeacher = type(clss_name,class_bases,class_dic)

tea1 = OldboyTeacher('egon',18,'male')
print(tea1.__dict__)#{'name': 'egon', 'age': 18, 'sex': 'male'}

补充exec:exec()

#参数一:包含一系列python代码的字符串

#参数二:全局作用域(字典形式),如果不指定,默认为globals()

#参数三:局部作用域(字典形式),如果不指定,默认为locals()

#可以把exec命令的执行当成是一个函数的执行,会将执行期间产生的名字存放于局部名称空间中

 将class_body中产生的名称空间都存放在class_dic的列表中

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

注:只有继承了type类的类才能称之为自定义的元类,否则就是一个普通的类

以一个例子来说明使用方法:

#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,),{...})
    '''

    '''
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
    def score(self):
        print('%s'%self.name)

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

对象之所以可以调用,是因为对象的类中有一个函数__call__,那么OldboyTeacher也是对象的话,肯定也是定义了一个__call__方法

我们来看看__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):
        self.name = name
        self.age = age
        self.sex = sex
    def score(self):
        print('%s'%self.name)

tea1 = OldboyTeacher('egon',18,'male')#会触发OldboyTeacher的类,即元类中的__call__

回顾一下类的实例化步骤:

  1.先产生一个空对象

  2.执行__init__方法,完成对象的初始化属性操作

  3.返回初始化好的那个对象

4.属性查找

class Mymeta(type): 
    # n=444
    def __call__(self, *args, **kwargs): #self=OldboyTeacher这个类
        # 1. 先产生一个空对象
        tea_obj = self.__new__(self)  # tea_obj是OldboyTeacher这个类的对象
        # print(self.__new__ is object.__new__)
        # tea_obj=object.__new__(self)

        # 2. 执行__init__方法,完成对象的初始属性操作
        self.__init__(tea_obj, *args, **kwargs)
        # 3. 返回初始化好的那个对象
        return tea_obj


class Bar:
    # n = 33
    pass

class Foo(Bar):
    # n = 222
    pass

class OldboyTeacher(Foo, metaclass=Mymeta):  # OldboyTeacher=Mymeta('OldboyTeacher',(object,),{...})
    # n = 111
    school = 'Oldboy'

    def __init__(self, name, age, sex):
        self.name = name #None.name='egon'
        self.age = age
        self.sex = sex

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

    def __new__(cls, *args, **kwargs):
        # print('=====>')
        return super().__new__(cls)

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

# print(OldboyTeacher.n)

# print(object.__new__)
View Code
#查找顺序:
#1、先对象层:OldoyTeacher->Foo->Bar->object
#2、然后元类层:Mymeta->type
总结,Mymeta下的__call__里的self.__new__在OldboyTeacher、Foo、Bar里都没有找到__new__的情况下,会去找object里的__new__,而object下默认就有一个__new__,所以即便是之前的类均未实现__new__,也一定会在object中找到一个,
根本不会、也根本没必要再去找元类Mymeta->type中查找__new__但我们还是推荐在__call__中使用self.__new__(self)去创造空对象,因为这种方式会检索三个类OldboyTeacher->Foo->Bar,而object.__new__则是直接跨过了他们三个



焚膏油以继晷,恒兀兀以穷年。

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

相关文章
python 范儿编程--解析式 中|学习笔记
快速学习 python 范儿编程--解析式 中
19 0
python 范儿编程--花样传参 下|学习笔记
快速学习 python 范儿编程--花样传参 下
18 0
Python 编程 | 连载 01 - Python 的标识符
Python 编程 | 连载 01 - Python 的标识符
13 0
第二章 Python编程基础综合题目
第二章 Python编程基础综合题目
16 0
Python编程:tornado实现WebSocket通讯
以下实例有点像广播通讯,支持多个客户端连接 代码参考别人的,稍微做了一点点修改 服务器端 websocket_demo.py
16 0
Python编程:将驼峰命名转为小写下划线命名
Python编程:将驼峰命名转为小写下划线命名
8 0
Python编程:pickleDB库Redis的简易替代
pickleDB 是一个轻量简单的 key-value 存储器,操作和redis 很类似 可以作为一个不错的工具
14 0
Python编程:lambda替代品-operator模块
代码中不是很推荐使用 lambda表达式 取而代之的是 operator模块,提供了很多简单函数实现
9 0
Python编程:aiohttp和requests网络io性能比较
使用4 种方式 对网络发起10次请求,进行10次耗时测试
19 0
+关注
我要学编程
热爱学习,愿意接收新事物,有志称为一个互联网大佬
文章
问答
文章排行榜
最热
最新
相关电子书
更多
Python系列直播第一讲——Python中的一切皆对象
立即下载
Python第五讲——关于爬虫如何做js逆向的思路
立即下载
Python 脚本速查手册
立即下载