python高级（反射（与属性操作相关的魔术方法））

最新推荐文章于 2024-07-17 16:24:43 发布

旅立の涯秸

最新推荐文章于 2024-07-17 16:24:43 发布

阅读量1.1k

点赞数

分类专栏： python高级（一）文章标签： python（反射（与属性操作相关的魔术方法））

本文链接：https://blog.csdn.net/jamfiy/article/details/88073626

版权

python高级（一）专栏收录该内容

22 篇文章 13 订阅

订阅专栏

1 什么是反射

反射的概念是由Smith在1982年首次提出的，主要是指程序可以访问、检测和修改它本身状态或行为的一种能力（自省）。这一概念的提出很快引发了计算机科学领域关于应用反射性的研究。它首先被程序语言的设计领域所采用,并在Lisp和面向对象方面取得了成绩。

2 python面向对象中的反射：通过字符串的形式操作对象相关的属性。python中的一切事物都是对象（都可以使用反射）

可以拦截对对象属性的所有访问企图，其用途之一是在旧式类中实现特性（在旧式类中，函数property的行为可能不符合预期）。要在属性被访问时执行一段代码，必须使用一些魔法方法。

下面与属性操作相关的四个魔术方法适用于类和对象（一切皆对象，类本身也是一个对象），提供了你需要的所有功能（在旧式类中，只需使用后面三个）。

四个可以实现自省的函数

1.__getattr__（self, name)：在属性被访问而对象没有这样的属性时自动调用。

触发时机：获取不存在的对象成员时触发参数：1接收当前对象的self，一个是获取成员名称的字符串返回值：必须有值作用:为访问不存在的属性设置值注意：getattribute无论何时都会在getattr之前触发，触发了getattribute就不会在触发getattr了

2.__setattr__（self, name, value)：试图给属性赋值时自动调用。

触发时机:设置对象成员值的时候触发参数:1个当前对象的self,一个是要设置的成员名称字符串,一个是要设置的值返回值:无过程操作作用:接管设置操作,可以在设置前之前进行判断验证等行为注意:在当前方法中无法使用成员=值的方式直接设置成员，否则会无限递归，必须借助object的设置方法来完成 object.__setattr__（参数1，参数2，参数3）

3.__deleteattr__（self, name)：试图删除属性时自动调用。

触发时机：删除对象成员时触发参数：一个当前对象的self 返回值：无作用:可以在删除成员时进行验证。

4.__getattribute__（self, name）：在属性被访问时自动调用（只适用于新式类）。

触发时机：使用对象成员时触发，无论成员是否存在参数：1个接收当前对象self，一个是获取的成员的名称字符串返回值：必须有作用：在具有封装操作（私有化时），为程序开部分访问权限使用

（补充）5.__dir__（）

触发时机：dir（对象）的时候触发参数:1个接收当前对象self 返回值：必须为序列类型（列表，元组，集合等，）作用：可以自定义成员列表的返回值

来看Rectangle示例，但这里使用的是魔法方法：
class Rectangle:
def __init__ (self):
self.width = 0
self.height = 0
def __setattr__(self, name, value):
if name == 'size':
self.width, self.height = value
else:
self. __dict__[name] = value
def __getattr__(self, name):
if name == 'size':
return self.width, self.height
else:
raise AttributeError()

如你所见，这个版本需要处理额外的管理细节。对于这个代码示例，需要注意如下两点。

即便涉及的属性不是size，也将调用方法__setattr__。因此这个方法必须考虑如下两种情形：如果涉及的属性为size，就执行与以前一样的操作；否则就使用魔法属性__dict__。__dict__属性是一个字典，其中包含所有的实例属性。之所以使用它而不是执行常规属性赋值，是因为旨在避免再次调用__setattr__，进而导致无限循环。
仅当没有找到指定的属性时，才会调用方法__getattr__。这意味着如果指定的名称不是size，这个方法将引发AttributeError异常。这在要让类能够正确地支持hasattr和getattr等内置函数时很重要。如果指定的名称为size，就使用前一个实现中的表达式。

前面说过，编写方法__setattr__时需要避开无限循环陷阱，编写__getattribute__时亦如此。由于它拦截对所有属性的访问（在新式类中），因此将拦截对__dict__的访问！
在__getattribute__中访问当前实例的属性时，唯一安全的方式是使用超类的方法__getattribute__（使用super）。

接口和自（内）省

一般而言，你无需过于深入地研究对象，而只依赖于多态来调用所需的方法。然而，如果要确定对象包含哪些方法或属性，有一些函数可供你用来完成这种工作。

接口这一概念与多态相关。处理多态对象时，你只关心其接口（协议）——对外暴露的方法和属性。在Python中，不显式地指定对象必须包含哪些方法才能用作参数。例如，你不会像在Java中那样显式编写接口，而是假定对象能够完成你要求它完成的任务。如果不能完成，程序将失败。
通常，你要求对象遵循特定的接口（即实现特定的方法），但如果需要，也可非常灵活地提出要求：不是直接调用方法并期待一切顺利，而是检查所需的方法是否存在；如果不存在，就改弦易辙。
>>> hasattr(tc, 'talk')
True
>>> hasattr(tc, 'fnord')
False
在上述代码中，你发现tc包含属性talk（指向一个方法），但没有属性fnord。如果你愿意，还可以检查属性talk是否是可调用的。
>>> callable(getattr(tc, 'talk', None))
True
>>> callable(getattr(tc, 'fnord', None))
False
请注意，这里没有在if语句中使用hasattr并直接访问属性，而是使用了getattr（它让我能够指定属性不存在时使用的默认值，这里为None），然后对返回的对象调用callable。

案例：

class BlackMedium:
feture='Ugly'
def __init__(self,name,addr):
self.name=name
self.addr=addr

def sell_hourse(self):
print('【%s】正在卖房子，傻逼才买呢' %self.name)

def rent_hourse(self):
print('【%s】正在租房子，傻逼才租呢' % self.name)

print(hasattr(BlackMedium,'feture'))
getattr()

b1=BlackMedium('万成置地','天露园')
#b1.name--->b1.__dic__['name']
print(b1.__dict__)

# b1.name
# b1.sell_hourse
print(hasattr(b1,'name'))
print(hasattr(b1,'sell_hourse'))
print(hasattr(b1,'selasdfasdfsadfasdfasdfasdfasdl_hourse'))

print(getattr(b1,'name'))
print(getattr(b1,'rent_hourse'))
func=getattr(b1,'rent_hourse')
func()
# print(getattr(b1,'rent_hourseasdfsa')) #没有则报错
print(getattr(b1,'rent_hourseasdfsa','没有这个属性')) #没有则报错

# b1.sb=True
setattr(b1,'sb',True)
setattr(b1,'sb1',123)
setattr(b1,'name','SB')
setattr(b1,'func',lambda x:x+1)
setattr(b1,'func1',lambda self:self.name+'sb')
print(b1.__dict__)
print(b1.func)
print(b1.func(10))
print(b1.func1(b1))
del b1.sb
del b1.sb1
delattr(b1,'sb')
print(b1.__dict__)

反射当前模块成员

import sys

def s1():
    print 's1'


def s2():
    print 's2'


this_module = sys.modules[__name__]

hasattr(this_module, 's1')
getattr(this_module, 's2')

3 为什么用反射之反射的好处

好处一：实现可插拔机制

有俩程序员，一个lili，一个是egon，lili在写程序的时候需要用到egon所写的类，但是egon去跟女朋友度蜜月去了，还没有完成他写的类，lili想到了反射，使用了反射机制lili可以继续完成自己的代码，等egon度蜜月回来后再继续完成类的定义并且去实现lili想要的功能。

总之反射的好处就是，可以事先定义好接口，接口只有在被完成后才会真正执行，这实现了即插即用，这其实是一种‘后期绑定’，什么意思？即你可以事先把主要的逻辑写好（只定义接口），然后后期再去实现接口的功能

egon还没有实现全部功能

class FtpClient:
    'ftp客户端,但是还么有实现具体的功能'
    def __init__(self,addr):
        print('正在连接服务器[%s]' %addr)
        self.addr=addr

不影响lili的代码编写

#from module import FtpClient
f1=FtpClient('192.168.1.1')
if hasattr(f1,'get'):
    func_get=getattr(f1,'get')
    func_get()
else:
    print('---->不存在此方法')
    print('处理其他的逻辑')

好处二：动态导入模块（基于反射当前模块成员）

第一种方法：
module_t=__import__('m1.t')
print(module_t)

module_t.t.test1()
# from m1.t import *
# from m1.t import test1,_test2
#
# test1()
# _test2()

第二种方法：
import  importlib
m=importlib.import_module('m1.t')
print(m)
m.test1()
m._test2()