第三十四篇 Python面向对象之 反射（自省）

时间：2023-03-08 19:22:09

什么是反射？

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

四个可以实现自省的函数，是Python的内置函数

    下列方法适用于类和对象
    • 先看这四个方法对实例（b1）的使用
# 演示代码

class BlackMedium:

    feature = 'Ugly'

    def __init__(self, name, address):

        self.name = name

        self.address = address

    def sell_house(self):

        print("[%s] 是卖房子的，sb才从它这买" %self.name)

    def rent_house(self):

        print("[%s] 是租房子的，sb才从它这租，它黑人" %self.name)

# 实例化

b1 = BlackMedium('某某置业', '回龙观')
  • hasattr(object, name)：判断object里有没有一个name字符串（'属性名'）对应的方法或属性。

　　object：表示对象； name:属性名，是字符串形式；

# 检测数据属性

print(hasattr(b1, 'name'))        # True     # b1.__dict__['name']

# 检测函数属性

print(hasattr(b1, 'sell_house'))  # True

print(hasattr(b1, 'sell_housereqre'))  # False
  • getattr(object, name, default=None): 获取属性值

　　object：表示对象； name:属性名，是字符串形式；value：属性对应的值

# 获取属性的具体值

print(getattr(b1, 'name'))   # 某某置业

print(getattr(b1, 'rent_house'))  # <bound method BlackMedium.rent_house of <__main__.BlackMedium object at 0x00B52F50>>

func = getattr(b1, 'rent_house')

func()    # [某某置业] 是租房子的，sb才从它这租，它黑人

print(getattr(b1, 'feature'))   # Ugly

# default 参数

print(getattr(b1, 'sell_house323', '没有这个属性')) # 没有这个属性

getattr()  # 等价于 b1.sell_house
  • setattr(object, name, value): 修改或者新增属性及值

　　object：表示对象； name:属性名，是字符串形式；value：属性对应的值

# setattr设置数据属性

setattr(b1, 'sb', True)

setattr(b1, 'sb1', 1234)

setattr(b1, 'name', "万神置业")

setattr(b1, 'feature', '黑中介')

print(b1.__dict__)

#  {'name': '万神置业', 'address': '回龙观', 'sb': True, 'sb1': 1234, 'feature': '黑中介'}

# setattr设置函数属性

setattr(b1, 'funct', lambda x:x+1)

setattr(b1, 'funct1', lambda self:self.name+"ss")

print(b1.__dict__)

# {'name': '万神置业', 'address': '回龙观', 'sb1': 1234, 'feature': '黑中介', 'funct': <function <lambda> at 0x02FEB618>}

# 调用新增的函数属性

print(b1.funct(10))     #

print(b1.funct1(b1))    # 万神置业ss
  • delattr(object, name)  删除属性。

　　object：表示对象； name:属性名，是字符串形式

delattr(b1, 'sb')   # 等于 del b1.sb

print(b1.__dict__)

#  {'name': '万神置业', 'address': '回龙观', 'sb1': 1234, 'feature': '黑中介'}
    • 　　再看这四个方法对类（BlackMedium）的使用
# 定义类，但没有进行实例化

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)
# hasattr()

print(hasattr(BlackMedium,'feture'))  # True

print(getattr(BlackMedium,'feture'))

print(setattr(BlackMedium, 'feture', '黑中介'))

print(getattr(BlackMedium, 'feture'))  # 黑中介

delattr(BlackMedium, 'sell_hourse')

print(BlackMedium.__dict__)

# {'__module__': '__main__', 'feture': '黑中介', '__init__': <function BlackMedium.__init__ at 0x007D1B70>, 'rent_hourse': <function BlackMedium.rent_hourse at 0x007D1AE0>, '__dict__': <attribute '__dict__' of 'BlackMedium' objects>, '__weakref__': <attribute '__weakref__' of 'BlackMedium' objects>, '__doc__': None}

#

Python一切皆对象，文件也是对象，所以文件也可反射

def say_hi():

    print('你好啊')

test.py文件

# fanshe.py 文件
import test as obj  # 导入test模块，重命名为obj

print(obj)

print(hasattr(obj,'say_hi'))  #　True

print(hasattr(obj,'say_hisssssssssssssssssssssssssssssssssssssssssss'))  # False

if hasattr(obj,'say_hi'):

    func=getattr(obj,'say_hi')

    func()

else:

    print('其他的逻辑')

x=111

y=222

# 执行结果

# 你好阿
# 需求：检测一下fanshe.py这个当前文件有没有某些属性

import test as obj  # 导入test模块，重命名为obj

print(obj)

print(hasattr(obj,'say_hi'))  #　True

print(hasattr(obj,'say_hisssssssssssssssssssssssssssssssssssssssssss'))  # False

if hasattr(obj,'say_hi'):

    func=getattr(obj,'say_hi')

    func()

else:

    print('其他的逻辑')

x=111

y=222

# 关键问题是，上面拿到别人的导入就行了，那怎么拿到自己的呢？

# import fanshe as obj1   # 在当前文件里是不可以再导入自己的

# 需要用sys模块来操作

import sys

obj1=sys.modules[__name__]

print('===>',hasattr(obj1,'x'))

二. 为什么用反射？

好处一：实现可插拔机制

是项目中，一个项目有多个程序员写，如果A写程序的时候要用到B所写的类，但是B休假了，还没有完成他写的类，A想到了反射，使用了反射机制A可以继续完成自己的代码，等B休假回来后再继续完成类的定义并且实现Ａ想要的功能。

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

演示：

class FtpClient:

    'ftp客户端，还没具体实现功能'

    def __init__(self,addr):

        print("正在连接服务器[{}]".format(addr))

        self.addr = addr

f1 = FtpClient('192.168.123.123')

# f1.put()   # 因为B还没定义put()方法，所以会报错，不能这么干，所以需要用下面的判断做

if hasattr(f1,'put'):   # 判断f1里是否有put 方法

    func_get =  getattr(f1, 'put')   # 如果有，就可以get到这个方法

    func_get()   # 然后运行这个方法

else:

    print("执行其他逻辑")     # 如果没有put这个方法，就执行其他逻辑

#  结果

正在连接服务器[192.168.123.123]

执行其他逻辑

B只定义了接口，还没实现功能

class FtpClient:

    'ftp客户端，还没具体实现功能'

    def __init__(self,addr):

        print("正在连接服务器[{}]".format(addr))

        self.addr = addr

    # B休假回来了，实现了put方法

    def put(self):

        print("文件开始上传了")

# from try import FtpClient

f1 = FtpClient('192.168.123.123')

# f1.put()

if hasattr(f1,'put'):   # 判断f1里是否有put 方法

    func_get =  getattr(f1, 'put')   # 如果有，就可以get到这个方法

    func_get()   # 然后运行这个方法

else:

    print("执行其他逻辑")     # 如果没有put这个方法，就执行其他逻辑

#结果

正在连接服务器[192.168.123.123]

文件开始上传了

B休假回来，实现了A想要的方法

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

模块的动态导入

所谓动态导入模块，就是模块名是字符串形式的，根据字符串使用importLib模块导入。

如果要导入的模块给你的是一个字符串，那怎么导入呢？目录结构如下：

需求是：要将m1下的t.py导入到01.动态导入模块.py文件里

第三十四篇 Python面向对象之 反射（自省）

# 1. 正常的导入及调用执行

from m1 import t

t.test1()
# 2. 现在有个新问题，要求你不能按照上面的方式到导入，给的是个字符串  'm1.t'

# 通过字符串方式导入模块

module_t = __import__('m1.t')

print(module_t)

# <module 'm1' (namespace)>

# 为什么导入的模块是m1，而不是t呢？而我们要导入的就是t模块啊？

'''

这种导入方式，不管你下面套多少层，返回的都是最顶层的模块

'''

# 调用:都需要通过最顶层的模块以.的方式，一层一层的往下找，直到调用你需要引用的模块

module_t.t.test1()
# 3. 利用importlib模块导入字符串形式的模块

import importlib

m = importlib.import_module("m1.t")

print(m)

# <module 'm1.t' from 'F:\\workspace\\Try2\\m1\\t.py'>

# 以这种方式导入，直接就定位到你想要调用的t模块了

# 调用

m.test1()

相关文章