第十三章 反射操作相关函数
1. 【检测对象是否可被调用】callable()函数
语法参考
callable函数的语法格式如下：
callable(object)
参数说明：
-
object：对象；
-
返回值：如果对象可调用返回 True，否则返回 False。
说明：对于函数、方法、lambda 函式、类以及实现了__call__方法的类实例, 它都返回 True。
锦囊01 判断常用数据类型和内置函数是否可以被调用
使用callable()函数判断字符串、元组、列表和字典是否可以被调用，以及它们的内置函数是否可以被调用。代码如下：
str_val = 'mrsoft'
tuple_val = (1,2,3,4,5)
list_val = [1,2,3,4,5]
dict_val = {'name':'Andy'}
print(callable(str_val)) # 结果为False
print(callable(tuple_val)) # 结果为False
print(callable(list_val)) # 结果为False
print(callable(dict_val)) # 结果为False
print(callable(str_val.capitalize)) # 结果为True
print(callable(tuple_val.count)) # 结果为True
print(callable(list_val.reverse)) # 结果为True
print(callable(dict_val.values)) # 结果为True
锦囊02 判断函数、lambda 表达式和方法是否可以被调用
使用callable()函数判断函数、lambda表达式和类的方法是否可以被调用，以及类属性是否可以被调用。代码如下：
def add(x):
return x+1
l = lambda x : x +1
class A:
name = 'Andy'
def test(self):
return 'test'
print(callable(add)) # 结果为True
print(callable(l)) # 结果为True
print(callable(A.test)) # 结果为True
print(callable(A.name)) # 结果为False
锦囊03 判断类和实例是否可以被调用
使用callable()函数判断类和实例是否可以被调用，代码如下：
class A:
def test(self):
return 'test'
a = A() # 实例化类A
print(callable(A)) # 判断类是否可以被调用
print(callable(a)) # 判断实例是否可以被调用
锦囊04 设置__call__()方法使实例可以被调用
虽然实例对象不能被直接调用，但是可以设置__call__()方法，使其可以被调用。代码如下：
class A:
def test(self):
return 'test'
class B:
def __call__(self):
return '函数被调用'
def test(self):
return 'test'
a = A() # 实例化类A
b = B() # 实例化类B
print(callable(a)) # 判断实例对象是否可以被调用
print(callable(b)) # 判断实例对象是否可以被调用
print(b()) # 调用实例对象
2. 【删除对象的属性】delattr()函数
语法参考
delattr函数的语法格式如下：
delattr(object, name)
参数说明：
-
object：对象；
-
name：字符串，对象属性。
-
返回值：无。
说明：delattr(x, ‘foobar’) 相等于 del x.foobar。
锦囊01 删除类对象属性
使用delattr()函数删除类对象的属性。代码如下：
class Student:
name = 'Andy'
age = 18
print(getattr(Student,'age'))
delattr(Student,'age')
try:
print(getattr(Student,'age'))
except AttributeError:
print('该类属性不存在')
锦囊02 删除实例对象属性
使用delattr()函数删除实例对象的属性。代码如下：
class Student:
def __init__(self,name,age):
self.name = name
self.age = age
s = Student('Andy',18)
print(getattr(s,'name'))
print(getattr(s,'age'))
delattr(s,'age')
try:
print(getattr(s,'age'))
except AttributeError:
print('该实例属性不存在')
3. 【获取对象的属性值】getattr()函数
语法参考
getattr函数的语法格式如下：
getattr(object, name[, default])
参数说明：
-
object：对象；
-
name：字符串，对象属性。
-
default: 默认返回值，如果不提供该参数，在没有对应属性时，将触发 AttributeError。
-
返回值：返回对象属性。
锦囊01 获取属性值
使用getattr()函数获取实例对象属性值，代码如下：
class Student:
name = 'Andy'
age = 18
def hello(self):
return 'hello'
s = Student()
f = getattr(s,'hello')
print(getattr(s,'name'))
print(getattr(s,'age'))
print(getattr(s,'gender','男'))
print(f())
锦囊02 捕获属性异常值
使用try-except 语句捕获getattr()函数获取属性失败时的异常，代码如下：
class Student:
name = 'Andy'
age = 18
s = Student() # 实例化Student类
# 捕获属性异常
try:
print(getattr(s,'gender'))
except AttributeError:
print('没有该属性')
print(getattr(s,'gender'))
4. 【检查对象是否含有属性】hasattr()函数
语法参考
hasattr函数的语法格式如下：
hasattr(object, name)
参数说明：
-
object：对象；
-
name：字符串，属性名。
-
返回值：如果对象有该属性返回 True，否则返回 False。
锦囊01 判断属性是否为原生类型属性
使用hasattr()函数判断是否属性为原生类型属性。代码如下：
str_val = 'mrsoft'
print(hasattr(str_val,'__len__')) # 输出为True
print(hasattr(str_val,'__lt__')) # 输出为True
print(hasattr(str_val,'format')) # 输出为True
print(hasattr(str_val,'lower')) # 输出为True
list_val = [1,2,3]
print(hasattr(list_val,'__len__')) # 输出为True
print(hasattr(list_val,'__delitem__')) # 输出为True
print(hasattr(list_val,'pop')) # 输出为True
dict_val = {'name':'Andy'}
print(hasattr(dict_val,'__len__')) # 输出为True
print(hasattr(dict_val,'keys')) # 输出为True
print(hasattr(dict_val,'values')) # 输出为True
说明：可以使用dir()函数查看对象的全部属性。
锦囊02 判断属性是否为类属性
使用hasattr()函数判断属性是否为类属性。代码如下：
class Student:
name = 'Andy'
age = 18
def hello(self):
print('hello')
print(hasattr(Student,'name'))
print(hasattr(Student,'age'))
print(hasattr(Student,'hello'))
print(hasattr(Student,'hi'))
锦囊03 判断属性是否为实例属性
使用hasattr()函数判断是否为实例属性。代码如下：
class Student:
name = 'Andy'
age = 18
def hello(self):
print('hello')
s = Student()
# 判断是否属于实例的属性
print(hasattr(s,'name'))
print(hasattr(s,'age'))
print(hasattr(s,'hello'))
print(hasattr(s,'hi'))
锦囊04 判断属性是否继承父类属性
使用hasattr()函数判断属性是否继承父类属性。代码如下：
class A:
a_name = 'A'
def a_test(self):
pass
class B(A):
b_name = 'B'
def b_test(self):
pass
print(hasattr(B, 'a_name'))
print(hasattr(B, 'a_test'))
说明：使用dir(B)查看B对象的属性，其中包含’a_name’, ‘a_test’, ‘b_name’, 'b_test’4个属性。
5. 【动态加载类和函数】__import__()函数
语法参考
__import__()函数的语法格式如下：
__import__(name[, globals[, locals[, fromlist[, level]]]])
参数说明：
-
name：模块名称；
-
globals：包含全局变量的字典，该选项很少使用，采用默认值 global()；
-
locals：包含局部变量的字典，内部标准实现未用到该变量，采用默认值 local()；
-
fromlist：由name指定的模块导入对象或子模块名称;
-
level：指定是使用绝对还是相对导入。 0 (默认值) 意味着仅执行绝对导入。 level 为正数值表示相对于模块调用 __import__() 的目录，将要搜索的父目录层数。
-
返回值：返回元组列表。
锦囊01 导入模块
使用__import__()函数实现模块导入功能。步骤如下：
创建a.py文件，代码如下：
# a.py 文件
name = 'Andy'
def hello():
return 'hello'
创建test.py文件，从test.py文件中导入a.py 模块。代码如下：
# test.py文件
a = __import__('a') # 导入 a.py 模块
print(a.name)
print(a.hello())
锦囊02 设置fromlist参数导入子模块
使用fromlist参数导入子模块。现有如图所示目录结构。
utils目录下的a.py文件代码如下：
# a.py文件
name = 'Andy'
def hello():
return 'hello'
utils目录下的b.py 代码如下：
# b.py 文件
name = 'Jack'
def hi():
return 'hi'
test.py 代码如下：
# test.py 文件
module = __import__('utils',fromlist=['a','b']) # 导入 a.py 模块
print(module.a.name)
print(module.b.name)
print(module.a.hello())
print(module.b.hi())
锦囊03 使用package.module导入子模块
当模块名为package.module时，而且fromlist参数为空时，函数返回顶层的模块，也就是package模块。如果设置fromlist=[module]，则返回module。
修改快用锦囊02中的test.py文件，修改后代码如下：
# test.py 文件
module_a = __import__('utils.a',fromlist=[]) # 导入 a.py 模块
module_b = __import__('utils.b',fromlist=[]) # 导入 b.py 模块
print(module_a.a.name)
print(module_a.b.name)
print(module_b.a.hello())
print(module_b.b.hi())
修改test.py文件，设置fromlist参数不为空，代码如下：
# test.py 文件
module_a = __import__('utils.a',fromlist=['name','hello']) # 导入 a.py 模块
module_b = __import__('utils.b',fromlist=['name','hi'])
print(module_a.name)
print(module_b.name)
print(module_a.hello())
print(module_b.hi())
锦囊04 动态导入模块
在快用锦囊03的基础上，创建一个run.py文件，代码如下：
# run.py 文件
package = 'utils'
module = 'a'
def func2():
p = __import__("%s.%s"%(package,module)) # 动态导入包和模块
m = getattr(p, 'a') # 获取a模块
f = getattr(m, 'hello') # 获取hello方法
print(f()) # 调用hello方法
func2()
6. 【判断对象是否是类或者类型元组中任意类元素的实例】isinstance()函数
语法参考
isinstance函数的语法格式如下：
isinstance(object, classinfo)
参数说明：
-
class：实例对象；
-
classinfo：类名可以是直接或间接类名、基本类型或者由它们组成的元组。
-
返回值：如果对象的类型与参数二的类型（classinfo）相同则返回 True，否则返回 False。
锦囊01 判断实例是否属于某个类
使用isinstance()函数判断一个实例对象是否属于某个类。代码如下：
class Foo:
a = [1,2,3,4,5]
fooInstance = Foo()
print(isinstance(fooInstance, Foo))
print(isinstance(fooInstance, (list, tuple)))
print(isinstance(fooInstance, (list, tuple, Foo)))
锦囊02 判断对象是否属于原生类型
使用isinstance()函数判断某个对象是否属于原生类型，代码如下：
numbers = [1, 2, 3,4]
result = isinstance(numbers, list)
print(numbers,'instance of list?', result)
result = isinstance(numbers, dict)
print(numbers,'instance of dict?', result)
result = isinstance(numbers, (dict, list))
print(numbers,'instance of dict or list?', result)
number = 5
result = isinstance(number, list)
print(number,'instance of list?', result)
result = isinstance(number, int)
print(number,'instance of int?', result)
锦囊03 判断多个继承中实例和父类的关系
有3个类对象A、B和C。它们的继承关系是C继承B,B继承A。使用isinstance()函数判断C的实例对象是否属于A。代码如下：
class A:
pass
class B(A):
pass
class C(B):
pass
someInstance = C()
if isinstance(someInstance,A):
print('someInstance属于A的实例')
else:
print('someInstance不属于A的实例')
7. 【判断类是否是另外一个类或者类型元组中任意类元素的子类】issubclass()函数
语法参考
issubclass函数的语法格式如下：
issubclass(class, classinfo)
参数说明：
-
class：类名；
-
classinfo：类名。
-
返回值：如果 class 是 classinfo 的子类返回 True，否则返回 False。
锦囊01 判断类的继承关系
创建A和B两个类，并令B继承A。使用issubclass()函数判断B是否为A的子类。代码如下：
class A:
pass
class B(A):
pass
if issubclass(B,A):
print('B是A的子类')
else:
print('B不是A的子类')
锦囊02 判断布尔型和整型之间的关系
布尔型数据只有两个值，它们通常被表示为True和False。然而，True和False只是整型1和0的别名。下面使用issubclass()函数来验证布尔型和整型之间的关系，代码如下：
print(int(False))
print(int(True))
print(True+True)
print(issubclass(bool,int))
锦囊03 判断是否属于多个父类的子类
issubclass(class,classinfo)函数的第二个参数classinfo也可以使用元组的形式包含多个父类。如果class的父类是元组中某一个，则同样返回True,否则返回False，代码如下：
class A:
pass
class B(A):
pass
class C():
pass
if issubclass(B,C):
print('B是C的子类')
else:
print('B不是C的子类')
print(issubclass(B,(C,A)))
锦囊04 判断多个继承中父类和子类的关系
有A,B,C3个类，如果C继承B,B又继承A.那么C同样是A的子类。使用issubclass()函数判断C和A之间的关系。代码如下：
class A:
pass
class B(A):
pass
class C(B):
pass
if issubclass(C,A):
print('C是A的子类')
else:
print('C不是A的子类')
8. 【设置对象的属性值】setattr()函数
语法参考
setattr函数的语法格式如下：
setattr(object, name, value)
参数说明：
-
object：对象；
-
name：字符串，对象属性。
-
value：属性值。
-
返回值：无。
锦囊01 替换已经存在的属性
使用setattr()函数替换实例中已经存在的属性。代码如下：
class Student:
name = 'Andy'
age = 18
s = Student()
print(getattr(s,'name'))
setattr(s,'name','Jack')
print(getattr(s,'name'))
锦囊02 创建新属性
使用setattr()函数为实例对象创建新的属性，代码如下：
class Student:
name = 'Andy'
age = 18
s = Student()
if getattr(s, 'gender', None) is None:
setattr(s, 'gender', '男')
gender = getattr(s, 'gender')
print(gender)
锦囊03 批量创建属性
结合字典的键值对，使用setattr()函数为实例对象批量创建属性。代码如下：
class Student(object):
def __init__(slef,**dic):
for attr,values in dic.items():
setattr(slef,attr,values)
dict_val = {'name':'Andy','age':18,'gender':'男'}
s = Student(**dict_val)
print(s.name)
print(s.age)
print(s.gender)