一、反射
1.1 反射三连问
1.1.1 什么是反射？
反射指的是在程序的运行过程中，可以'动态'获取对象的信息（数据属性或函数属性）；
'动态'获取指的是直到运行语句时才知道数据类型。
1.1.2 为什么要有反射？
能够通过字符串访问或者操作属性值。
当我们需要从一个不知道有什么属性的对象那里获取对象属性时，无法通过 ’obj. ‘ 的方式获取，但是可以通过反射机制获取
1.1.3 如何实现反射？
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('辣白菜同学',18)
实现反射机制的步骤
1）先通过多dir：查看出某一个对象下可以.出哪些属性来
print(dir(obj))
2）可以通过字符串反射到真正的属性上，得到属性值
print(obj.__dict__[dir(obj)[-2]])
1.2 四个内置函数实现反射
虽然1.3可以实现反射，但是不要那样去实现反射，python提供了专业的方法：4个内置函数；
使用4个内置函数，通过字符串来操作属性值。
1）hasattr()
print(hasattr(obj,'name'))
print(hasattr(obj,'x'))
2）getattr()
print(getattr(obj,'name'))
3）setattr()
setattr(obj,'name','EGON') # obj.name='EGON'
print(obj.name)
4）delattr()
delattr(obj,'name') # del obj.name
print(obj.__dict__)
res1=getattr(obj,'say') # obj.say
res2=getattr(People,'say') # People.say
print(res1)
print(res2)
obj=10
if hasattr(obj,'x'):
print(getattr(10,'x'))
else:
pass
print(getattr(obj,'x',None))
if hasattr(obj,'x'):
setattr(obj,'x',111111111) # 10.x=11111
else:
pass
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()
二、内置方法
2.1 什么是内置方法？
定义在类内部，以 __ 开头并以 __ 结尾的方法；
特点：会在某种情况下自发触动执行
2.2 为何要用内置方法？
为了定制化我们的类or对象
2.3 如何使用内置方法
1）__ str __ :在打印对象时会自动触发，然后将返回值（必须是字符串类型）当做本次打印的结果输出
class People:
def __init__(self, name, age):
self.name = name
self.age = age
def __str__(self):
# print('运行了...')
return "<%s:%s>" %(self.name,self.age)
obj = People('辣白菜同学', 18)
# print(obj.__str__())
print(obj) # <'辣白菜同学':18>
# obj1=int(10)
# print(obj1)
2）__ del __ ：在清理对象时触发，会先执行该方法
class People:
def __init__(self, name, age):
self.name = name
self.age = age
self.x = open('a.txt',mode='w')
# self.x = 占据的是操作系统资源
def __del__(self):
# print('run...')
# 发起系统调用，告诉操作系统回收相关的系统资源
self.x.close()
obj = People('辣白菜同学', 18)
# del obj # obj.__del__()
print('============>')
三、元类
3.1 元类的引入
一切都源自于一句话：一切皆为对象
3.2 什么是元类？
元类就是用来实例化产生类的类
关系：元类---实例化---->类（People）---实例化---->对象（obj）
class People:
def __init__(self,name,age):
self.name=name
self.age=age
def say(self):
print('%s:%s' %(self.name,self.name))
print(People.__dict__)
如何得到对象
obj=调用类()
obj=People('egon',18)
print(type(obj))
如果说类也是对象
People=调用类(。。。)
查看内置的元类：
1、type是内置的元类
2、我们用class关键字定义的所有的类以及内置的类都是由元类type实例化产生
print(type(People))
print(type(int))
3.3 class关键字创造类People的步骤
分为四个步骤，其中前3个步骤涉及类的三大特征：
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.name))
"""
exec(class_body,{},class_dic)
# print(class_dic)
4）调用元类
People=type(class_name,class_bases,class_dic)
3.4 如何自定义元类来控制类的产生
class Mymeta(type): # 只有继承了type类的类才是元类
# 空对象,"People",(),{...}
def __init__(self,x,y,z):
print('run22222222222....')
print(self)
# print(x)
# print(y)
# print(z)
# print(y)
# 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=Mymeta("People",(object,),{...})
调用Mymeta发生三件事，调用Mymeta就是type.call
1）先造一个空对象=>People,调用Mymeta类内的__new__方法
2）调用Mymeta这个类内的__init__方法，完成初始化对象的操作
3）返回初始化好的对象
class People(metaclass=Mymeta):
def __init__(self,name,age):
self.name=name
self.age=age
def say(self):
print('%s:%s' %(self.name,self.name))
强调：
只要是调用类，那么会一次调用
1）类内的 __ new __
2）类内的__ init __
3.5 __ call __
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(111,222)
# print(obj) # obj.__str__
res=obj(1,2,3,a=4,b=5,c=6) # res=obj.__call__()
print(res)
应用：如果想让一个对象可以加括号调用，需要在该对象的类中添加一个方法call
总结：
对象()->类内的call
类()->自定义元类内的call
自定义元类()->内置元类call
3.6 自定义元类控制类的调用=》类的对象的产生
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
类的产生
People=Mymeta()=》type.call=>干了3件事
1、type.call__函数内会先调用Mymeta内的__new
2、type.call__函数内会调用Mymeta内的__init
3、type.__call__函数内会返回一个初始化好的对象
class People(metaclass=Mymeta):
def __init__(self,name,age):
self.name=name
self.age=age
def say(self):
print('%s:%s' %(self.name,self.name))
def __new__(cls, *args, **kwargs):
# 产生真正的对象
return object.__new__(cls)
类的调用
obj=People('egon',18) =》Mymeta.__call__=》干了3件事
1、Mymeta.__call__函数内会先调用People内的__new__
2、Mymeta.__call__函数内会调用People内的__init__
3、Mymeta.__call__函数内会返回一个初始化好的对象
obj1=People('egon',18)
obj2=People('egon',18)
# print(obj)
print(obj1.__dict__)
print(obj2.__dict__)
四、属性查找
属性查找的原则：对象-》类-》父类
切记：父类 不是 元类
class Mymeta(type):
n=444
def __call__(self, *args, **kwargs): #self=<class '__main__.StanfordTeacher'>
obj=self.__new__(self) # StanfordTeacher.__new__
# obj=object.__new__(self)
print(self.__new__ is object.__new__) #True
self.__init__(obj,*args,**kwargs)
return obj
class Bar(object):
# n=333
# def __new__(cls, *args, **kwargs):
# print('Bar.__new__')
pass
class Foo(Bar):
# n=222
# def __new__(cls, *args, **kwargs):
# print('Foo.__new__')
pass
class StanfordTeacher(Foo,metaclass=Mymeta):
# n=111
def __init__(self,name,age):
self.name=name
self.age=age
obj=StanfordTeacher('lili',18)
print(obj.__dict__)
# print(obj.n)
# print(StanfordTeacher.n)