面向对象高级

1.反射

反射是所有动态语言比较重要的一个特征 , 提一嘴go , 虽然go是静态的 , 但是也支持反射 , 这是go比较优秀的一点 , python一切皆对象的设计保证了实现反射非常简单

1.1什么是反射机制

反射机制指的是在程序的运行状态中
对于任意一个类，都可以知道这个类的所有属性和方法；
对于任意一个对象，都能够调用他的任意方法和属性。
这种动态获取程序信息以及动态调用对象的功能称为反射机制。

反射 : 指的是在程序运行过程中可以"动态(不见棺材不掉泪)"获取对象的信息

补充 :

任何语言都需要指定类型 , 但你会发现 x = 10 , 没有指定类型啊
在python中当解释器执行到这一句话的时候 , 才会自动根据值 指定类型

1.2为什么要用反射

你函数接收到一个参数以后 , 你有可能要访问这个参数内部的一些属性 , 但是你不确定是否有这个属性 , 这样你就要先判断 , 如果有了 , 再访问 , 但是这样判断比较low , 所以我们使用反射来做

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('辣良菜同学')

# 实现反射机制的步骤
# 1、先通过多din:查看出某一个对象下可以.出哪些属性来
print(dir(obj))
# 2、可以通过字符串反射到真正的属性上,得到属性值
print(obj.__dict__[dir(obj)[-2]])

# 这样些确实实现了反射 , 但是不够优雅 , python给我们专门提供了四个内置函数

四个内置函数的使用 : 通过字符串来操作属性值

# hasattr() , 见名知意 , 我就不解释了
print(hasattr(obj,'name'))  # 返回bool值
print(hasattr(obj,'x'))

# getattr()
print(getattr(obj, 'name' ))  # 获取name属性值
print(getattr(obj, 'name1' ,None)) # 当获取不到属性值 , 设置返回值为None

# setattr()
setattr(obj,'name','EGON')   # obj. name="EGON"  

# delattr()
delattr(obj, 'name' ) # del obj.name
print(obj.__dict__)

# 一般hasattr()和getattr() 搭配使用

2.内置方法

即双下方法 , 在类中定义了这类方法 , 满足某种条件下会自动触发 , 不需要调用

为什么要用内置方法呢? ---> 就是为了定制化我们的类or对象

关于内置方法的学习 , 我们只需要知道 , 在什么情况下会自动触发这个方法

__str__方法

# __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)  # print(obj.__str__())   

__del__方法

# __del__:在清理对象时触发,会先执行该方法
class People:
    def __init__(self,name,age):
        self.name =  name
        self.age =  age
        self.x= open('a.txt',mode='w')
        #sef.x=占据的是操作系统资源
    def __del__(self):
        # print( 'run....')
        # 发起系统调用,告诉操作系统回收相关的系统资源
        self.x.close() 

obj = People('alex',99)

# del obj   obj.__del__()
print('===========')

其他的内置方法还有很多 , 就不一 一介绍了

详情请见 : https://www.cnblogs.com/linhaifeng/articles/6204014.html

3.元类

3.1 什么是元类

一切源自于一句话：python中一切皆为对象。让我们先定义一个类，然后逐步分析

class StanfordTeacher(object):
    school='Stanford'

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

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

所有的对象都是实例化或者说调用类而得到的（调用类的过程称为类的实例化），比如对象t1是调用类StanfordTeacher得到的

t1=StanfordTeacher('lili',18)
print(type(t1)) #查看对象t1的类是<class '__main__.StanfordTeacher'>

如果一切皆为对象，那么类StanfordTeacher本质也是一个对象，既然所有的对象都是调用类得到的，那么StanfordTeacher必然也是调用了一个类得到的，你可能会疑问我StanfordTeacher类 , 不是使用class机制得到的吗 , 实际上任何关键字机制后面 , 都对应了一系列的代码 , 这个代码做的实际上就是造一个类 , 那么类是对象 , 肯定也是通过另一个类加括号实例化的 , 这个类就是元类

元类就是用来实例化产生类的类 , 前提是我们把类当成对象去看待

实例化-->类( People )--实例化---对象(obj) , 那么如何查看呢?

# 查看内置的元类   我们用 class关键字定义的类以及内置的类都是由内置type帮我们实例化产生的# type是内置的元类print(type(People))  # <class 'type'>print(type(int))         # <class 'type'>

3.2class机制分析

一起分析一下 , class关键字是怎么把类给造出来的?

# class关键字创造类 People的步骤# 类有三大特征# 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)#print(class_dic)# 4.调用元类# print(type (class_name ,cLass_bases , class _dic))People=type (class_name ,cLass_bases , class _dic)

3.3如何自定元类来控制类的产生

class Mymeta(type):  # 只有继承了type类的类才是元类(目前先不考虑type类是怎么造的)    # 空对象, " People", (object,),{...}    def __init__(self, x, y, z):        # print(self)        # print(x)        # print(y)        # print(z)        if not x.capitalize():            raise NameError('类名的首字母必须大写')    def __new__(cls, *args, **kwargs):        # 造Mymeta的对象        # super().__new__(cls, *args, **kwargs) or type.__new__(cls, *args, **kwargs)        # 必须返回一个空对象        return type.__new__(cls, *args, **kwargs)# People=Mymeta("People",(object,),{...})# 调用Mymeta发生三件事 , 调用Mymeta就是type.__call__# 1、先造一个空对象=> People# 2、调用Mymeta这个类内的__init__方法,完成初始化对象的操作# 3、返回初始化好的对象class People(metaclass=Mymeta):  # 默认是type    def __init__(self, name, age):        self.name = name        self.age = age    def say(self):        print('<%s: %s>' % (self.name, self.age))        """强调只要是调用类,那么会一次调用1、类内的__new__2、类内的__init__"""

还有一个返回初始化对象没介绍 , 思考一下 , 调用Mymeta能不能说就是调用__new__ , 不能因为__init__也被调用了 , 而且还有调用顺序 , 实际上调用Mymeta , 是调用__call__方法

``call`方法

class Foo:    def __init__(self, x, y):        self.x = x        self.y = y    def __call__(self,*args,**kwargs):        print('===2>1')obj = Foo(111, 222)print(obj)  # print(obj.__str__())res = obj()  # res = obj.__call__()print(res)# 应用 : 如果想让一个对象可以加括号调用,需要在该对象的类中添加一个方法__call__

class Mymeta(type):  # 只有继承了type类的类才是元类(目前先不考虑type类是怎么造的)    # 空对象, " People", (object,),{...}    def __init__(self, x, y, z):        # print(self)        # print(x)        # print(y)        # print(z)        if not x.capitalize():            raise NameError('类名的首字母必须大写')    def __new__(cls, *args, **kwargs):        # 造Mymeta的对象        # super().__new__(cls, *args, **kwargs) or type.__new__(cls, *args, **kwargs)        # 必须返回一个空对象        return type.__new__(cls, *args, **kwargs)# People=Mymeta("People",(object,),{...})# 调用Mymeta发生三件事 , 调用Mymeta就是type.__call__# 1、先造一个空对象=> People# 2、调用Mymeta这个类内的__init__方法,完成初始化对象的操作# 3、返回初始化好的对象class People(metaclass=Mymeta):  # 默认是type    def __init__(self, name, age):        self.name = name        self.age = age    def say(self):        print('<%s: %s>' % (self.name, self.age))"""对象()->类内的caLL类()->自定义元类内的__call__自定义元类()->内置元类__call__"""

模板 :

class Mymeta(type): #只有继承了type类才能称之为一个元类，否则就是一个普通的自定义类    def __call__(self, *args, **kwargs): #self=<class '__main__.StanfordTeacher'>        #1、调用__new__产生一个空对象obj        obj=self.__new__(self) # 此处的self是类OldoyTeacher，必须传参，代表创建一个StanfordTeacher的对象obj        #2、调用__init__初始化空对象obj        self.__init__(obj,*args,**kwargs)        #3、返回初始化好的对象obj        return objclass StanfordTeacher(object,metaclass=Mymeta):    school='Stanford'    def __init__(self,name,age):        self.name=name        self.age=age    def say(self):        print('%s says welcome to the Stanford to learn Python' %self.name)t1=StanfordTeacher('lili',18)print(t1.__dict__) #{'name': 'lili', 'age': 18}

上例的__call__相当于一个模板，我们可以在该基础上改写__call__的逻辑从而控制调用StanfordTeacher的过程，比如将StanfordTeacher的对象的所有属性都变成私有的

class Mymeta(type): #只有继承了type类才能称之为一个元类，否则就是一个普通的自定义类    def __call__(self, *args, **kwargs): #self=<class '__main__.StanfordTeacher'>        #1、调用__new__产生一个空对象obj        obj=self.__new__(self) # 此处的self是类StanfordTeacher，必须传参，代表创建一个StanfordTeacher的对象obj        #2、调用__init__初始化空对象obj        self.__init__(obj,*args,**kwargs)        # 在初始化之后，obj.__dict__里就有值了        obj.__dict__={'_%s__%s' %(self.__name__,k):v for k,v in obj.__dict__.items()}        #3、返回初始化好的对象obj        return objclass StanfordTeacher(object,metaclass=Mymeta):    school='Stanford'    def __init__(self,name,age):        self.name=name        self.age=age    def say(self):        print('%s says welcome to the Stanford to learn Python' %self.name)t1=StanfordTeacher('lili',18)print(t1.__dict__) #{'_StanfordTeacher__name': 'lili', '_StanfordTeacher__age': 18}

3.4属性查找

元类不是父类

class Mymeta(type):     n=444    def __call__(self, *args, **kwargs): #self=<class '__main__.StanfordTeacher'>        obj=self.__new__(self)        print(self.__new__ is object.__new__) #Trueclass Bar(object):    n=333    # def __new__(cls, *args, **kwargs):    #     print('Bar.__new__')class Foo(Bar):    n=222    # def __new__(cls, *args, **kwargs):    #     print('Foo.__new__')class StanfordTeacher(Foo,metaclass=Mymeta):    n=111    school='Stanford'    def __init__(self,name,age):        self.name=name        self.age=age    def say(self):        print('%s says welcome to the Stanford to learn Python' %self.name)    # def __new__(cls, *args, **kwargs):    #     print('StanfordTeacher.__new__')StanfordTeacher('lili',18) #触发StanfordTeacher的类中的__call__方法的执行，进而执行self.__new__开始查找

总结，Mymeta下的__call__里的self.__new__在StanfordTeacher、Foo、Bar里都没有找到__new__的情况下，会去找object里的__new__，而object下默认就有一个__new__，所以即便是之前的类均未实现__new__,也一定会在object中找到一个，根本不会、也根本没必要再去找元类Mymeta->type中查找__new__

我们在元类的__call__中也可以用object.__new__(self)去造对象

但我们还是推荐在__call__中使用self.__new__(self)去创造空对象，因为这种方式会检索三个类StanfordTeacher->Foo->Bar,而object.__new__则是直接跨过了他们三个

最后说明一点

class Mymeta(type): #只有继承了type类才能称之为一个元类，否则就是一个普通的自定义类    n=444    def __new__(cls, *args, **kwargs):        obj=type.__new__(cls,*args,**kwargs) # 必须按照这种传值方式	print(obj.__dict__)        # return obj # 只有在返回值是type的对象时，才会触发下面的__init__        return 123    def __init__(self,class_name,class_bases,class_dic):        print('run。。。')class StanfordTeacher(object,metaclass=Mymeta): #StanfordTeacher=Mymeta('StanfordTeacher',(object),{...})    n=111    school='Stanford'    def __init__(self,name,age):        self.name=name        self.age=age    def say(self):        print('%s says welcome to the Stanford to learn Python' %self.name)print(type(Mymeta)) #<class 'type'># 产生类StanfordTeacher的过程就是在调用Mymeta，而Mymeta也是type类的一个对象，那么Mymeta之所以可以调用，一定是在元类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