一、反射
1 什么是反射
指的是在程序运行过程中可以‘动态’地获取对象的信息
静态语言:java,c,在定义变量时必须指定数据类型的强类型语言
动态语言:python,php,在定义数据是不需要申明变量类型的弱类型语言
反射是动态语言的特性
2 如何实现反射
在我们拿到一个对象要使用它下面的方法时,我们事先并不知道有什么方法,这时候就要用到反射。
第一步:通过dir查看对象可以使用哪些属性
第二步:通过字符串反射到真正的属性上,得到属性值
class People:
def __init__(self,name,age):
self.name=name
self.age=age
def say(self):
print('<%s:%s>' %(self.name,self.age))
obj=People('hz',18)
print(dir(obj))
# 获得的是列表里面都是字符串
>>>['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'age', 'name', 'say']
# 如果我们想使用name属性,就可以索引-2
print(obj.__dict__[dir(obj)[-2]])
>>> hz
显然,通过dir获取的是全部的属性的字符串,我们也可以通过内置函数对属性进行更精简的操作
1 . hasattr() 判断对象中是否有这个属性,返回布尔值
print( hasattr(obj,'name'))
>>> True
print( hasattr(obj,'sex'))
>>> False
2 . getattr()获取这个对象的指定属性值,没有则返回属性名后面的东西,没写会报错
print(getattr(obj,'name'))
>>> hz
print(getattr(obj,'sex','不存在这种属性!'))
>>> 不存在这种属性!
3 . setattr()修改原有的属性,新增不存在的属性
setattr(obj,'name','HZ')# obj.name = 'HZ'
setattr(obj,'sex','male')# obj.sex = 'male'
4 . delattr()删除指定属性和对象的绑定关系
delattr(obj,'name')
print(getattr(obj,'name',None))
>>> None
反射也可以运用在用户交互中
class Ftp:
def put(self):
print('正在执行上传功能')
def get(self):
print('正在执行下载功能')
def interactive(self):
method=input(">>>: ").strip() # method='put'
if hasattr(self,method):
getattr(self,method)()
else:
print('输入的指令不存在')
obj=Ftp()
obj.interactive()
二、内置方法
1 什么是内置方法
定义在类内部,以__开头和结尾的方法
特点:在达成某种情况会自动触发执行
2 为什么要用内置方法
为了定制我们的类或者对象
3 如何使用内置方法
3.1 str
在打印对象的时候会自动触发,然后把返回值(必须字符串)作为本次打印的输出结果
这种方法我们在学习数据类型的时候就有接触过
#x是int这个类实例化的结果
x = 10 # x = int (10)
# 打印x对象,本该获得x的内存地址
print(x)
# 直接获得了值是因为int类内部为我们设定了str,让我们打印对象直接得到值
>>> 10
转换成类
class Foo:
def __init__(self,name):
self.name = name
def __str__(self):
return self.name
obj = Foo('hz')
print(obj)
>>> hz
3.2 del
在清理对象时会触发,会先执行该方法
class Foo:
def __init__(self,name):
self.name = name
def __del__(self):
# 发起系统调用,告诉操作系统回收相关的系统资源
print('123213')
obj = Foo('hz')
print('----')
>>> ----
>>> 123213
在执行完最后一行代码后才执行了del,是因为在程序结束的时候,我们会把对象清除,在清除之前就会执行del功能
三、元类
引子:python中一切皆对象
1 什么是元类
元类是用来实例化产生类的类
关系:元类---实例化---->类(People)---实例化---->对象(obj)
type是内置的元类
在python中,class关键字定义的所有类,以及内置的类,都是由元类type实例化得到的
2 class关键字创造类的步骤
类有三大特征:类名,类的基类,执行类体代码得到名称空间
通过下面拆解的方法我们实现了不用class去定义一个类
# 1、类的名字
class_name="People"
# 2、类的基类
class_bases=(object,)
# 3、执行类体代码拿到类的名称空间
class_dic={}
class_body="""
def __init__(self,name,age):
self.name=name
self.age=age
def say(self):
print('%s:%s' %(self.name,self.age))
"""
exec(class_body,{},class_dic)
# exec 执行第一个参数(必须字符串)中的python代码,把其中的全局作用域的名字转换成字典放在传给第二个参数,局部作用域的名字传给第三个参数
People=type(class_name,class_bases,class_dic)
obj = People('hz',18)
obj.say()
exec补充
#exec:三个参数
#参数一:包含一系列python代码的字符串
#参数二:全局作用域(字典形式),如果不指定,默认为globals()
#参数三:局部作用域(字典形式),如果不指定,默认为locals()
#可以把exec命令的执行当成是一个函数的执行,会将执行期间产生的名字存放于局部名称空间中
g={
'x':1,
'y':2
}
l={}
exec('''
global x,z
x=100
z=200
m=300
''',g,l)
print(g) #{'x': 100, 'y': 2,'z':200,......}
print(l) #{'m': 300}
3 自定义元类控制类的产生
type是python内置的元类,所有的类都由type产生,但是当一个类继承于type时,他就成了一个自定义的元类
class Mymeta(type): # 只有继承了type类的类才是元类
# 空对象,"People",(),{...}
def __init__(self, x, y, z):
super().__init__(x,y,z)
print('run22222222222....')
# if not x.istitle():
# raise NameError('类名的首字母必须大写啊!!!')
# 当前所在的类,调用类时所传入的参数
def __new__(cls, *args, **kwargs):
# 造Mymeta的对象
print('run1111111111.....')
# print(cls,args,kwargs)
# return super().__new__(cls,*args, **kwargs)
return type.__new__(cls,*args, **kwargs)
# 用自定义的元类 实例化得到类:People
class People(metaclass=Mymeta):# metaclass指定元类
def __init__(self,name,age):
self.name=name
self.age=age
def say(self):
print('%s:%s' %(self.name,self.name))
调用我们自定义元类Mymeta会发生三件事,调用Mymeta就是调用type.__call__方法
1、通过Mymeta中的__new__方法新建一个空对象
2、调用Mymeta中的__init__方法完成对类的初始化操作
3、返回初始化好的对象
4 如何让对象可以被调用
class Foo:
def __init__(self,x,y):
self.x=x
self.y=y
# obj,1,2,3,a=4,b=5,c=6
def __call__(self,*args,**kwargs):
print('===>',args,kwargs)
return 123
obj = Foo(1,2)
print(obj)
print(obj(1,2,3,a=4,b=5,c=6)) # 调用了Foo中的__call__
>>> <__main__.Foo object at 0x000001FEAD9075C0>
>>> ===> (1, 2, 3, 4, 8, 78, 89) {}
>>> 123
应用:如果想让一个对象可以加括号调用,需要在该对象的类中添加一个方法__call__
总结:
对象()->类内的__call__
类()->自定义元类内的__call__
自定义元类()->内置元类__call__
5 自定义元类控制类的调用
# 在实例化People对象的时候会通过它的元类Mymeta中的__call__方法去调用People类
# obj=People()=》people.__call__=>干了3件事
class Mymeta(type): # 只有继承了type类的类才是元类
def __call__(self, *args, **kwargs):
# 1、Mymeta.__call__函数内会先调用People内的__new__
people_obj=self.__new__(self)
# 2、Mymeta.__call__函数内会调用People内的__init__
self.__init__(people_obj,*args, **kwargs)
# print('people对象的属性:',people_obj.__dict__)
# 附加:可以对新对象指定默认值
people_obj.__dict__['xxxxx']=11111
# 3、Mymeta.__call__函数内会返回一个初始化好的对象
return people_obj
#以此类推,自定义元类的调用也是使用type的__call__去调用自定义元类来实现实例化
# 类的产生
# People=Mymeta()=》type.__call__=>干了3件事
# 1、type.__call__函数内会先调用Mymeta内的__new__
# 2、type.__call__函数内会调用Mymeta内的__init__
# 3、type.__call__函数内会返回一个初始化好的对象
补充:属性查找
原则:对象-》类-》父类
切记:父类不是元类
class Mymeta(type):
n=444
class Bar(object):
# n=333
pass
class Foo(Bar):
# n=222
pass
class Teacher(Foo,metaclass=Mymeta):
# n=111
def __init__(self,name,age):
self.name=name
self.age=age
obj = Teacher('hz',18)
在上面的例子中
obj的属性查找顺序:
obj----》Teacher----》Foo----》Bar----》object
Teacher的属性查找顺序:
Teacher----》Foo----》Bar----》object----》Mymeta----》type