反射

             反射      **********             

       gerattr(a,b)    根据字符串为参数 (第二个参数) , 去 对象(第一个参数) 中寻找与之同名的成员.

  例一 : 面对函数的反射

    现在有2个py文件(在同一个文件下面的平等文件),现在想从run.py 中调用 handler.py 中的东西.

 

#handler.py

f0 = 9

def f1():
    print('F1')

def f2():
    print('F2')

def f3():
    print('F3')

def f4():
    print('F4')

def f5():
    print('F5')

 

#run.py
#我们可以使用if ...elif....的方法执行
import handler

while True:
    print("""
    系统支持的函数有:
    1 f0
    2 f1
    3 f2
    4 f3
    5 f4
    6 f5
    """)
    num = input("请输入您要执行的函数:")
    if num == "f0":
        print(9)
    elif num == 'f1':
        handler.f1()
    elif num == 'f2':
        handler.f2()
    elif num == 'f3':
        handler.f3()
    elif num == 'f4':
        handler.f4()
    elif num == 'f5':
        handler.f5()

#用 if...elif...方法,如果在handler.py文件的函数特别多,就会使代码繁杂.

while True:
    print("""
    系统支持的函数有：
        1. f1
        2. f2
        3. f3
        4. f4
        5. f5
    """)
    val = input("请输入要执行的函数：") # val = "f1"

    if hasattr(handler,val):
        func_or_val = getattr(handler,val)     # 根据字符串为参数，去模块中寻找与之同名的成员。
        if isinstance(func_or_val,FunctionType):  #判断是否是函数
            func_or_val()
        else:
            print(func_or_val)
    else:
        print('handler中不存在输入的属性名')

 

    所有,我们 比较 方法一 和方法二,发现方法二比方法一简介而且定位准

  例二 : 面对 面向对象的反射

class Foo(object):

    country = "中国"

    def func(self):
        pass


v = getattr(Foo,'func') # Foo.func # 根据字符串为参数，去类中寻找与之同名的成员。
print(v)

obj = Foo()
v = getattr(obj,"func") # obj.func # 根据字符串为参数，去对象中寻找与之同名的成员。
print(v)

结果:
<function Foo.func at 0x00000000025FCEA0>
<bound method Foo.func of <__main__.Foo object at 0x00000000025FB2E8>>

 

#反射----类
class Foo(object):

    def __init__(self,a1):
        self.a1 = a1
        self.a2 = None

obj = Foo(1)


v1 = getattr(obj,'a1')
print(v1)

setattr(obj,'a2',2)

 

x1 = 123


def f1(arg):
    print(arg,666)

 

import xx

# getattr                          #查找
v1 = getattr(xx,'x1')
v2 = getattr(xx,'f1')
v2('杨森')                      # 杨森 666                   

# hasattr                        #判断是否由成员
v3 = hasattr(xx,'x1')
v4 = hasattr(xx,'f1')
v4 = hasattr(xx,'f1')
v5 = hasattr(xx,'xxxxxxx')
print(v3,v4,v5)                   #True True False

# setattr                         #在内存中添加 x2= 999
setattr(xx,'x2',999)
v6 = getattr(xx,'x2')
print(v6)                          # 999

setattr(xx,'f2',lambda x:x+1)   #添加一个函数
v7 = getattr(xx,'f2')
v8 = v7(1)
print(v8)                        # 2 因为 添加函数 x+1  参数为1

# delattr                        #删除 x1
delattr(xx,'x1')
v9 = getattr(xx,'x1')
print(v9)

结果:

     

      总结:

           getattr(a,b)  : 根据字符串为参数(第二个参数b),去对象中(第一个参数a)寻找与之同名的成员

           hasattr(a,b) : 根据字符串形式(第二个参数b) ,去判断对象(第一个参数a)中是否有该成员

           setattr (a,b,c): 参数分别是新建对象所属类的类名，新建对象的对象名，对象的值 (在内存中体现,在文件中是看不到的)

           delattr(a,b) : 根据字符串为参数 (b),动态的删除对象中(第一个a)一个成员(在内存中体现)