【Python】面向对象-反射

反射

根据字符串为参数（第二个参数），去对象或模块（第一个参数）中寻找与之同名的成员。

getattr # 根据字符串的形式，去对象中找成员。
v = getattr(obj,"func")
hasattr # 根据字符串的形式，去判断对象中是否有成员。
setattr # 根据字符串的形式，动态的设置一个成员（内存）
delattr # 根据字符串的形式，动态的删除一个成员（内存）

应用一：在模块中寻找

from types import FunctionType
import handler #导入一个模块

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

# 错误
# handler.val()
if hasattr(handler,val): #判断handler模块中是否有输入的字符串
func_or_val = getattr(handler,val) # 根据字符串为参数，去模块中寻找与之同名的成员。
if isinstance(func_or_val,FunctionType):
func_or_val() #如果是函数，调用加括号
else:
print(func_or_val) #如果是变量，调用直接写就行
else:
print('handler中不存在输入的属性名')

handle模块定义

def f1():
print('F1')

def f2():
print('F2')

def f3():
print('F3')

def f4():
print('F4')

def f5():
print('F5')

应用二：在类，对象中寻找

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)

应用2.2

class Account(object):
func_list = ['login', 'logout', 'register']

def login(self):
"""
登录
:return:
"""
print('登录111')

def logout(self):
"""
注销
:return:
"""
print('注销111')

def register(self):
"""
注册
:return:
"""
print('注册111')

def run(self):
"""
主代码
:return:
"""
print("""
请输入要执行的功能：
1. 登录
2. 注销
3. 注册
""")

choice = int(input('请输入要执行的序号:'))
func_name = Account.func_list[choice-1]

# func = getattr(Account,func_name) # Account.login #在account类中寻找
# func(self)

func = getattr(self, func_name) # self.login #在对象中寻找
func()

obj1 = Account()
obj1.run()

obj2 = Account()
obj2.run()

getattr/hasattr/setattr/delattr

"""
getattr # 根据字符串的形式，去对象中找成员。
hasattr # 根据字符串的形式，去判断对象中是否有成员。
setattr # 根据字符串的形式，去判断对象动态的设置一个成员（内存）
delattr # 根据字符串的形式，去判断对象动态的设置一个成员（内存）
"""

import xx

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

# hasattr
v3 = hasattr(xx,'x1')
v4 = hasattr(xx,'f1')
v4 = hasattr(xx,'f1')
v5 = hasattr(xx,'xxxxxxx')
print(v3,v4,v5)

# setattr
setattr(xx,'x2',999) #动态设置在模块中，x2变量999
v6 = getattr(xx,'x2')
print(v6)

setattr(xx,'f2',lambda x:x+1) #在模块中，动态设置函数f2
v7 = getattr(xx,'f2')
v8 = v7(1)
print(v8)

# delattr
delattr(xx,'x1') #在模块中，删除设置的成员
v9 = getattr(xx,'x1')
print(v9)

检测是否可以被调用

def func():
pass


class Foo(object):
def __call__(self, *args, **kwargs):
pass
def func(self):
pass
obj = Foo()


print(callable(func))
print(callable(Foo))
print(callable(obj))
print(callable(obj.func))