issubclass/type/isinstance、方法和函数、反射

一、issubclass/type/isinstance

1、issubclass：检查第一个参数是否是第二个参数的子子孙孙类（类的确定）

 1 class Base(object):
 2     pass
 3 
 4 class Foo(Base):
 5     pass
 6 
 7 class Bar(Foo):
 8     pass
 9 
10 print(issubclass(Bar,Base))  #检查第一个参数是否是第二个参数的 子子孙孙类

2、type：判断当前对象是由哪个类创建的

1 class Base:
2     pass
3 
4 obj=Base()
5 if type(obj)==Base:
6     print("当前对象是Base类创建的")

3、isinstance：检查第一个参数（对象）是否是第二个参数（类及父类）的实例。（确定实例和类的关系）

 1 class Base(object):
 2     pass
 3 
 4 class Foo(Base):
 5     pass
 6 
 7 obj1 = Foo()
 8 print(isinstance(obj1,Foo))  # 检查第一个参数（对象）是否是第二个参数（类及父类）的实例。
 9 print(isinstance(obj1,Base)) # 检查第一个参数（对象）是否是第二个参数（类及父类）的实例。
10 
11 
12 obj2 = Base()
13 print(isinstance(obj2,Foo))  # 检查第一个参数（对象）是否是第二个参数（类及父类）的实例。
14 print(isinstance(obj2,Base)) # 检查第一个参数（对象）是否是第二个参数（类及父类）的实例。

二、方法和函数
1、判断是方法还是函数

 1 from type import MethodType FunctionType
 2 def check(arg):
 3     if isinstance(MethodType,arg):
 4         print("这是方法")
 5     if isinstance(FunctionType,arg):
 6         print("这是函数")
 7     else:
 8         print("什么也不是")
 9 
10 def func()
11     pass
12 
13 class Foo:
14     def tital(self):
15         pass
16     @staticmethod
17     def hand()
18         pass
19 
20 check(func) #判断func是函数还是方法
21 
22 obj=Foo()
23 check(obj.tital) # 如果是Foo.tital，则结果是一个函数
24 check(obj.hand)    # 如果是Foo.hand，则结果是一个函数

简单一句话：如果是格式是：类.xxx 则xxx是函数，如果格式是：对象.xxx,则xxx是方法
2、特点

 1 class Foo(object):
 2 
 3     def f1(self):
 4         pass
 5 
 6     def f2(self):
 7         pass
 8 
 9     def f3(self):
10         pass
11 
12 
13 obj = Foo()
14 Foo.f1(obj) # 把f1当做函数 需要手动传self值
15 
16 obj = Foo()
17 obj.f1()    # 把f1当做方法，自动传self值

3、练习题

 1 class Foo(object):
 2 
 3     def f1(self):
 4         pass
 5 
 6     def f2(self):
 7         pass
 8 
 9     def f3(self):
10         pass
11 
12     list_display = [f1,f2]
13 
14 obj = Foo()
15 Foo.list_display.append(obj.f3)
16 
17 for item in Foo.list_display:
18     print(item)
19 
20 #结果：
21 #function Foo.f1 at 0x0000020AA92BCB70>
22 #<function Foo.f2 at 0x0000020AA92BCD08>
23 #<bound method Foo.f3 of <__main__.Foo object at 0x0000020AA90F55F8>>

三、判断是否可以被调用
类()、函数()、方法()、对象()，都可以可以被调用

callable()

 1 def func()
 2     pass
 3 
 4 class Foo:
 5     def titer(self):
 6         pass
 7 
 8     def __call__(self, *args, **kwargs):
 9         pass
10 
11 obj=Foo()
12 
13 print(callable(Foo))
14 print(callable(func))
15 print(callable(obj))
16 print(callable(obj.titer))

四、反射

1、反射示例——模块

 1 ###handre###
 2 f0 = 9
 3 
 4 def f1():
 5     print('F1')
 6 
 7 def f2():
 8     print('F2')
 9 
10 def f3():
11     print('F3')
12 
13 def f4():
14     print('F4')
15 
16 def f5():
17     print('F5')

 1 from types import FunctionType
 2 import handre
 3 while True:
 4     print(
 5         """系统支持的函数有：
 6         1,f1
 7         2,f2
 8         3,f3
 9         4,f4
10         5,f5      
11         """
12     )
13     val=input("请选择要运行的函数")
14 
15     if hasattr(handre,val):
16         get_atter=getattr(handre,val)
17         if isinstance(get_atter,FunctionType):
18             get_atter()
19         else:
20             print(get_atter)
21 
22     else:
23         print("请输入正确的格式")

2、反射示例——面向对象

 1 class Foo:
 2     f0 = 9
 3     num_list = ["f1", "f2", "f3", "f4", "f5"]
 4     def f1(self):
 5         print('F1')
 6 
 7     def f2(self):
 8         print('F2')
 9 
10     def f3(self):
11         print('F3')
12 
13     def f4(self):
14         print('F4')
15 
16     def f5(self):
17         print('F5')
18     def run(self):
19 
20         while True:
21             print("""系统支持的函数有：
22             1,f1
23             2,f2
24             3,f3
25             4,f4
26             5,f5
27             """)
28             num=int(input("请输入序号"))
29             name=Foo.num_list[num-1]
30             method_name=getattr(Foo,name)  # 根据字符串到指定的类去找
31             method_name(self)    # 类 调用需要手动传参
32 
33             #method_name=getattr(self,name)  # 根据字符串到指定的对象去找
34             #method_name()    # 自动传参
35 
36 obj=Foo()
37 obj.run()