1.什么是元类
一切源自于一句话：python中一切皆为对象。既然如此类是不是也是对象呢?
class Teacher(object):
school='tsinghua'
def __init__(self,name,age):
self.name=name
self.age=age
def say(self):
print('%s says welcome to the Beijing' %self.name)
t1=Teacher('egon',18)
print(type(t1)) #查看对象t1的类是<class '__main__.Teacher'>
所有的对象都是实例化或者说调用类而得到的（调用类的过程称为类的实例化），比如对象t1是调用类Teacher得到的
一切皆对象的话 类也必然是一个对象,验证一下
tcls = Teacher
li = [Teacher]
def func(cls):
print(cls)
func(Teacher)
#完全没问题把他当做对象来使用 和其他对象没有任何区别
思考,t1是通过Teacher实例化得到的,那Teacher对象是哪个类实例化的呢?
print(type(Teacher))
#<class 'type'>
可以推导出===>产生Teacher的过程一定发生了：Teacher=type(...)
用于实例化产生类的类称之为元类 就是此时的type类;**
Teacher是通过type实例化得到的,既然如此,是不是可以自己调用type来实例化一个calss呢?
2.创建类的流程分析
class关键字在帮我们创建类时，必然帮我们调用了元类Teacher=type(...)，那调用type时传入的参数是什么呢？必然是类的关键组成部分，一个类有三大组成部分，分别是
1、类名class_name='Teacher'
2、基类们class_bases=(object,)
3、类的名称空间class_dic，类的名称空间是执行类体代码而得到的
调用type时会依次传入以上三个参数
自己来实例化一个类
class_name = "Teacher"
class_code = """
def __init__(self,name,age):
self.name=name
self.age=age
def say(self):
print('%s says welcome to the Beijing' %self.name)
"""
class_dict = {}
exec(class_code,None,class_dict)
bases = (object,)
Teacher = type(class_name,bases,class_dict)
print(Teacher)
综上，class关键字帮我们创建一个类应该细分为以下四个过程
1.获取类名
2.获取基类
3.获取名称空间
4.实例化元类得到类
总结:元类即 用于产生类的类
3.自定义元类控制类的创建
思考 如果我想高度定制一个类 该如何实现 例如要求所有方法名称必须小写,类名称必须大写开头等等
创建类是有type完成的 type中必然包含了创建了的具体代码, 现在需要对这些代码进行修改,两种方式
1.修改type源代码 不可取
2.创建新的元类 使用自己的元类来创建类 从而实现定制类
一个类没有声明自己的元类，默认他的元类就是type，除了使用内置元类type，我们也可以通过继承type
来自定义元类，然后使用metaclass关键字参数为一个类指定元类
class Mymeta(type): #只有继承了type类才能称之为一个元类，否则就是一个普通的自定义类
pass
class Teacher(object,metaclass=Mymeta): # Teacher=Mymeta('Teacher',(object),{...})
school='tsinghua'
def __init__(self,name,age):
self.name=name
self.age=age
def say(self):
print('%s says welcome to the Beijing' %self.name)
需求
1.规范类名必须大写
2.类中必须包含文档注释
class MyMate(type):
def __init__(self,name,bases,dic):
print("run")
if not dic.get("__doc__"):
raise TypeError("类必须有文档注释!")
if not name.istitle():
raise TypeError("类名必须大写开头!")
super().__init__(name,bases,dic)
class Foo(object,metaclass=MyMate):
pass
项目中的应用
在优酷系统中需要根据类的信息来生成创建表的语句; 必需知道类何时被创建了,使用元类可以轻松的拦截类的创建过程,获取类相关信息来生成建表语句
class MyMetaClass(type):
def __init__(self,name,bases,dic):
table_name = name
columns = self.transfer_columns(dic)
sql = "create table if not exists %s(%s)" % (table_name,columns)
# 自动建表
try:
OBDB().conn.execute(sql)
except Exception as e:
pass
super().__init__(name,bases,dic)
s = 10 == s = int
a = type("int")
b = a
b()
c.__class__
4.自定义元类控制类的调用
__call__函数得执行时机
该方法会在调用对象是自动触发执行 (对象加括号)
class Foo:
def __call__(self, *args, **kwargs):
print("run")
f = Foo() #调用Foo得到f对象
f()#调用对象时 触发__call__的执行
通常调用一个普通对象是没有意义的,那__call__在什么时候用呢?
我们说类也是一个对象,那么Foo()是不是也执行了Foo的类中的__call__函数呢?
Foo的类是谁呢? 默认是元类type,通过mateclass来指定为自定义的元类来测试
#测试
class M(type):
def __call__(self, *args, **kwargs):
print("run mateclass __call__")
pass
pass
class A(metaclass=M):
pass
print(A())
#输出 run mateclass __call__
#输出 None
覆盖__call__函数时的注意事项
第一行输出表明了,调用类A时,的确自动执行了__call__函数,
第二行输出一个空,这是为什么呢? 将__call__注释起来,再次测试,会发打印结果变成了一个对象!
必须明确创建对象的过程: 先创建空对象,执行初始化将属性存储到对象的名称空间中!
所以在__call__函数中必须完成这两步操作,同时将初始化完成的对象返回给调用者
一旦覆盖了__call__函数,就必须自己来完成上述的几个步骤
class MyMate(type):
def __call__(self, *args, **kwargs):
# 创建空对象
# 调用init
# 返回初始化后的对象
obj = object.__new__(self)
self.__init__(obj,*args,**kwargs)
return obj
class Foo(metaclass=MyMate):
def __init__(self):
print("初始化对象")
f = Foo()
print(f)
通过元类来控制一个类实例化对象的过程
只需覆盖__call__函数我们就能完成对实例化过程的控制
#需求:
#2.要求实例化时传参必须为关键字形式，否则抛出异常TypeError: must use keyword argument
#3.key作为用户自定义类产生对象的属性，且所有属性变成大写
class Mymetaclass(type):
def __call__(self, *args, **kwargs):
if args:
raise TypeError('must use keyword argument for key function')
obj = object.__new__(self) #创建对象，self为类Chinese
for k,v in kwargs.items():
obj.__dict__[k.upper()]=v
return obj
class Chinese(metaclass=Mymetaclass):
country='China'
tag='Legend of the Dragon' #龙的传人
def walk(self):
print('%s is walking' %self.name)
p=Chinese(name='egon',age=18,sex='male')
print(p.__dict__)
补充:
产生类Teacher的过程就是在调用Mymeta，而Mymeta也是type类的一个对象，那么Mymeta之所以可以调用，一定是实现了__call__方法,但是我们就算自己写该方法,类也可以被创建,这是因为type中已经有默认的__call__的实现了
该方法中同样需要做至少三件事
#伪代码
class type:
def __call__(self, *args, **kwargs): #self=<class '__main__.Mymeta'>
obj=self.__new__(self,*args,**kwargs) # 产生Mymeta的一个对象
self.__init__(obj,*args,**kwargs)
return obj
####
5.元类实现单例
什么是单例
单例是指的是单个实例,指一个类只能有一个实例对象
为什么要用单例
当一个类的实例中的数据不会变化时使用单例,数据是不变的
例如开发一个音乐播放器程序,音乐播放器可以封装为一个对象,那你考虑一下,当你切歌的时候,是重新创建一个播放器,还是使用已有的播放器?
因为播放器中的数据和业务逻辑都是相同的没有必要创建新的,所以最好使用单例模式,以节省资源
当两个对象的数据完全相同时 则没有必要占用两份资源
#使用classmethod 实现单例
class Player():
def __init__(self):
print("创建播放器了")
__play = None
该方法无法避免使用者直接调用类来实例化,这样就不是单例了
使用元类实现单例模式
#在类定义时 自动执行init 在init中创建实例 call中直接返回已有实例
class MyMeta(type):
__instance = None
def __init__(self,name,bases,dic):
if not self.__instance:
self.__instance = object.__new__(self)
self.__init__(self.__instance)
super().__init__(name, bases, dic)
def __call__(cls):
return cls.__instance
class Player(metaclass=MyMeta):
def __init__(self):
print("创建播放器了")
Player()
Player()
# 仅执行一次创建播放器
6.元类之属性查找
当一个类既有父类又有元类时属性的查找顺序是什么样的?
回顾一下,在没有元类时属性的查找是基于MRO列表的顺序,这个点还是相同的,那我们为某个类增加元类后,元类中的属性,什么时候会被使用到呢?来看一个例子
class Mymeta(type): #只有继承了type类才能称之为一个元类，否则就是一个普通的自定义类
n=444
def __new__(cls, *args, **kwargs):
pass
class Bar(object):
n = 333
def __new__(cls, *args, **kwargs):
pass
class Foo(Bar):
n=222
def __new__(cls, *args, **kwargs):
pass
class Teacher(Foo,metaclass=Mymeta):
n=111
def __new__(cls, *args, **kwargs):
pass
school='Tsinghua'
print(Teacher.__new__)
print(Teacher.n)
测试结果表明:属性查找的顺序依然是遵循MRO列表顺序,当顶级类object中不存在时会查找元类,元类没有时查找元类的父类也就是type类,
7.令人迷惑的__new__函数与__init__函数
class M(type):
def __init__(self,clsname,bases,namespace):
print("init")
def __call__(self, *args, **kwargs):
pass
pass
class A(metaclass=M):
n = 1
pass
print(A.__name__)
print(A.__bases__)
print(A.__dict__)
"""输出
init
A
(<class 'object'>,)
{'__module__': '__main__', 'n': 1, '__dict__': <attribute '__dict__' of 'A' objects>, '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None}
"""
我们已经知道__init__可以控制类的创建过程,但是现在我们看到的是,init中没有任何代码但是类的三个基本信息已经都有了,这说明类的创建其实已经完成了
class M(type):
def __new__(cls, *args, **kwargs):
print("new")
#return type.__new__(cls,*args,**kwargs)
def __init__(self,clsname,bases,namespace):
print("init")
class A(metaclass=M):
n = 1
print(A.__name__)
print(A.__bases__)
print(A.__dict__)
"""输出
new
Traceback (most recent call last):
File "/Users/jerry/PycharmProjects/元类属性查找.py", line 43, in <module>
print(A.__name__)
AttributeError: 'NoneType' object has no attribute '__name__'"""
执行了__new__函数但是并没有执行__init__,因为__new__函数是真正用于创建类的方法,只有创建类成功了才会执行init函数,new必须要有返回值且返回值类型为__type__时才会执行__init__函数,
将__new__中被注释的代码打开 一切正常! 再一次印证了第四节中的伪代码
什么是异常
异常指不同于常规的情况
在python中是表示程序遇到了错误
一旦出现了错误,解释器会给出错误详细信息,并终止程序的执行!
这个过程我们称为抛出异常
常见异常
-
AttributeError 试图访问一个对象没有的属性，比如foo.x，但是foo没有属性x
-
IOError 输入/输出异常；无法打开文件或无法读写
-
ImportError 无法引入模块或包；基本上是路径问题或名称错误
-
SyntaxError Python语法错误异常，代码不能编译
-
IndentationError 缩进异常；代码没有正确缩进
-
IndexError 下标索引超出序列边界，比如当x只有三个元素，却试图访问x[5]
-
KeyError 试图访问字典里不存在的键
-
KeyboardInterrupt Ctrl+C被按下
-
NameError 使用一个还未被赋予对象的变量
-
TypeError 传入对象类型与要求的不符合
-
UnboundLocalError 试图访问一个还未被设置的局部变量，基本上是由于另有一个同名的全局变量，
导致你以为正在访问它 -
ValueError 传入一个调用者不期望的值，即使值的类型是正确的
异常的分类
按照异常发生的时间可以将异常分为两类
1.语法检测异常
运行代码前都会先检测语法,这个期间产生的异常就是语法检查异常,如果发生了语法检测异常则不会运行代码,通过是因为你代码不符合python语法规范,或是缩进未对齐
#语法异常
a =
2.运行时异常
当代码通过了语法检测后就开始解释执行,这执行期间出现的异常称为运行时异常
作为合格的python程序员是绝对不应该出现语法检测异常的
异常的组成
a = int("a")
""" 异常信息
Traceback (most recent call last): (追踪信息)
File "/Users/jerry/PycharmProjects/work/test.py", line 158, in <module>
a = int("a")
ValueError(异常类型): invalid literal for int() with base 10: 'a'(异常信息)
"""
异常处理
程序出现异常对于程序的使用者而言是体验是非常差的,
例如iphone手机APP的闪退其实都是因为异常导致的,并不是手机的问题,给用户的感觉就是这个软件非常垃圾或手机非常垃圾,所以我们需要尽量避免程序出现错误
但是终究不可能完全避免出现错误,所以python为我们提供了处理异常机制,来帮助我们提升程序的健壮性
处理异常的目的就是避免程序因为错误而强行终止
语法1 多分支
try:
except type1:
except type 2:
语法2 多异常合并处理
try:
except (type1,type2,…….):
语法3 万能异常
try:
except Exception as 别名:
语法4 多分支+万能异常
try:
except type1:
except type 2:
except Exception as 别名:
语法5 try + else
try:
except type:
else:
没有出现异常时
语法6 try+finally
try:
except type:
finally:
最终 用于清理操作
抛出异常
当我们的程序在执行过程中由于接收到的参数不正确或者其他情况导致,后续代码无法执行时,可以主动抛出异常
使用raise关键字,后面跟任意Exception的子类或子类实例
# 直接抛出异常
raise TypeError
# 直接抛出异常 并附加错误信息
raise TypeError("类型错误")
断言
断言是就是断定的意思,当一些代码的执行必须满足某个条件时,就需要先断定条件在继续执行,当然你可以使用if判断来处理
a = input("请输入一个数字:")
if a.isdigit():
print("后续代码.......")
print("后续代码.......")
print("后续代码.......")
print("后续代码.......")
print("后续代码.......")
print("后续代码.......")
# 上述方式如果后续代码太多则结构混乱 可以做一下修改
if not a.isdigit():
raise TypeError("必须输入一个整数!")
print("后续代码.......")
print("后续代码.......")
print("后续代码.......")
print("后续代码.......")
print("后续代码.......")
print("后续代码.......")
以上代码还可以通过断言来进一步简化
assert a.isdigit()
print("后续代码.......")
print("后续代码.......")
print("后续代码.......")
print("后续代码.......")
print("后续代码.......")
print("后续代码.......")
assert 后面跟条件即可 如果条件成立则正常执行,否则抛出AssertionError
断言可以简化代码 但是无法知道异常的详细信息
自定义异常类
通常异常的类型就应该能够表达异常大致原因,但是系统内置的异常类有限,当这些内置异常类无法表达遇到的异常时,就可以自定义异常类,通过继承Exception即可
#定义
class MyException(Exception):
pass
#使用
raise MyException("这是一个自定义异常类型!")
"""
Traceback (most recent call last):
File "/Users/jerry/PycharmProjects/work/test.py", line 167, in <module>
raise MyException("这是一个自定义异常类型!")
__main__.MyException: 这是一个自定义异常类型!
"""
异常的正确使用方式
1.在明确知道错误原因时,尽可能不使用异常处理,直接使用判断
2.避免使用万能异常,会使得你的程序即不出错,也不不正常执行,如果非要用,一定记得打印异常信息
3.常用的语法是第一种