Python反射：动态编程的强大武器

反射是动态语言的一大特色，Python作为动态语言的典型代表，其反射机制既强大又灵活。在我五年的测试开发经验中，反射技术在框架设计、插件系统、以及动态配置等场景中发挥了重要作用。

相比于Go语言等静态语言中的反射（虽然功能强大但使用复杂），Python的反射机制更加直观和易用。这主要得益于Python的动态特性——一切皆对象，运行时可以动态地检查和修改对象的属性和方法。

什么是反射？

简单来说，反射就是程序在运行时能够检查自身结构的能力。通过反射，我们可以：

• 动态获取对象的属性和方法
• 动态调用函数和方法
• 动态创建类和对象
• 在运行时修改程序的行为

概念及函数说明

说一下什么是反射吧

我就用最简单的语言来说明一下，就是用一串字符来映射出脚本里面的一个方法，然后执行它，这就叫映射。

要学会python里面的映射，我们需要学会几个函数

python中的反射功能是由以下四个内置函数提供：hasattr、getattr、setattr、delattr，改四个函数分别用于对对象内部执行：检查是否含有某成员、获取成员、设置成员、删除成员。

参考文献：

https://www.cnblogs.com/cenyu/p/5713686.html

"""
python中的反射功能
python中的反射功能是由以下四个内置函数提供：hasattr、getattr、setattr、delattr，改四个函数分别用于对对象内部执行：检查是否含有某成员、获取成员、设置成员、删除成员。
"""
class Person():
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def walk(self):
        print("walking......")


def run(self):
    print(f"{self.name} is running....")


p = Person("Alex",22)
if hasattr(p,'name'):
    print("有该成员")

#获取属性
a = getattr(p,'age')
print(f'{a}被获取')
#获取方法
method = getattr(p,'walk')
print(method)
method()

#设置属性
setattr(p,'sex','Female')
print(p.sex)

#设置方法
setattr(Person,'go',run)
p.go()

#删除属性
delattr(p,'name')
print(p.name)

结果

AttributeError: 'Person' object has no attribute 'name'
有该成员
22被获取
<bound method Person.walk of <__main__.Person object at 0x0418DCD0>>
walking......
Female
Alex is running....

hasattr(object, name)
判断一个对象里面是否有name属性或者name方法，返回BOOL值，有name特性返回True， 否则返回False。
需要注意的是name要用括号括起来

 1 >>> class test():
 2 ...     name="xiaohua"
 3 ...     def run(self):
 4 ...             return "HelloWord"
 5 ...
 6 >>> t=test()
 7 >>> hasattr(t, "name") #判断对象有name属性
 8 True
 9 >>> hasattr(t, "run")  #判断对象有run方法
10 True
11 >>>

getattr(object, name[,default])
获取对象object的属性或者方法，如果存在打印出来，如果不存在，打印出默认值，默认值可选。
需要注意的是，如果是返回的对象的方法，返回的是方法的内存地址，如果需要运行这个方法，
可以在后面添加一对括号。

 1 >>> class test():
 2 ...     name="xiaohua"
 3 ...     def run(self):
 4 ...             return "HelloWord"
 5 ...
 6 >>> t=test()
 7 >>> getattr(t, "name") #获取name属性，存在就打印出来。
 8 'xiaohua'
 9 >>> getattr(t, "run")  #获取run方法，存在就打印出方法的内存地址。
10 <bound method test.run of <__main__.test instance at 0x0269C878>>
11 >>> getattr(t, "run")()  #获取run方法，后面加括号可以将这个方法运行。
12 'HelloWord'
13 >>> getattr(t, "age")  #获取一个不存在的属性。
14 Traceback (most recent call last):
15   File "<stdin>", line 1, in <module>
16 AttributeError: test instance has no attribute 'age'
17 >>> getattr(t, "age","18")  #若属性不存在，返回一个默认值。
18 '18'
19 >>>

setattr(object, name, values)
给对象的属性赋值，若属性不存在，先创建再赋值。

 1 >>> class test():
 2 ...     name="xiaohua"
 3 ...     def run(self):
 4 ...             return "HelloWord"
 5 ...
 6 >>> t=test()
 7 >>> hasattr(t, "age")   #判断属性是否存在
 8 False
 9 >>> setattr(t, "age", "18")   #为属相赋值，并没有返回值
10 >>> hasattr(t, "age")    #属性存在了
11 True
12 >>>

一种综合的用法是：判断一个对象的属性是否存在，若不存在就添加该属性。

 1 >>> class test():
 2 ...     name="xiaohua"
 3 ...     def run(self):
 4 ...             return "HelloWord"
 5 ...
 6 >>> t=test()
 7 >>> getattr(t, "age")    #age属性不存在
 8 Traceback (most recent call last):
 9   File "<stdin>", line 1, in <module>
10 AttributeError: test instance has no attribute 'age'
11 >>> getattr(t, "age", setattr(t, "age", "18")) #age属性不存在时，设置该属性
12 '18'
13 >>> getattr(t, "age")  #可检测设置成功
14 '18'
15 >>>

我自己实现反射和使用上述功能完成反射

为什么我非常强调反射，因为反射可以大大简化自己的重复代码，将重复的代码片段整合成一个通用函数的调用方法，在使用反射机制来进行调用，这个是优雅代码的必备之路吧。

应用

我的代码如下：

# 模拟反射的代码片段
def reflect_method(self,name:str,*args,**kwargs):
    '''
    使用字典来模拟反射的机制
    Args:
        name: 
        *args: 
        **kwargs: 

    Returns:

    '''
    dict_method = {
        "getpod" : self.get_pod
    }
    if name in dict_method.keys():
        res = dict_method[name](*args,**kwargs)
        return res
    else:
        logger.info("no this method")

# 反射的代码应用
def get_reflect_method(self,name:str,*args,**kwargs):
    if hasattr(self,name):
        getattr(self,name)(*args,**kwargs)
    else:
        logger.info("no this method")

def reflect_method_v2(self,method,*args,**kwargs):
    return method(*args,**kwargs)