Python 面向对象 (补充) , 反射 , 内置函数

面向对象中内置函数               

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))  # 检查第一个参数是否是第二个参数的子子孙孙类

 

type: 方法

　　获取当前对象是由那个类创建     

返回:  类的类型 ,  if判断是否等于某个类  

 

1 class Foo(object):
2     pass
3 
4 obj = Foo()
5 
6 print(obj,type(obj))   # 获取当前对象有哪个类创建
7 if type(obj) == Foo:
8     print("由类Foo创建")

 

 1 def func(*args):
 2     Foo_count = 0
 3     Base_count = 0
 4     for el in args:
 5         if type(el) == Foo:
 6             Foo_count += 1
 7         elif type(el) == Base:
 8             Base_count += 1
 9     return Foo_count,Base_count
10 
11 # ret = func(Base(),Base(),Foo(),Foo(),Foo())
12 # print(ret)
13 
14 v,i = func(Base(),Base(),Foo(),Foo(),Foo())
15 print(v,i)
例子

 

isinstance : 方法

　　检查第一个参数(对象) 是否是第二个参数(类及父类)的实例.

返回值:  布尔型

class Base(object):
    pass

class Foo(Base):
    pass

obj = Foo()

print(isinstance(obj,Foo))
print(isinstance(obj,Base))

# 
True
True

 

总结 :  给一个参数,判断对象是不是由某一个指定类创建,  用   type(obj) == Foo

　　　给一个参数,判断对象是不是由某一个指定类或父类创建 , 用  isinstance(obj,Foo)

 

 

                 方法和函数            

对象.xxx      xxx就是方法

类.xxx    xxx就是函数

xxx     xxx就是函数

 

判断是函数还是方法  可以通过打印查看

打印显示的有 function   表示函数    

打印显示的有  method   表示方法

 

 1 from types import FunctionType,MethodType
 2 
 3 def check(args):
 4     """
 5     检查args是函数还是方法
 6     :param args: 
 7     :return: 
 8     """
 9     if isinstance(args,FunctionType):
10         print("是函数")
11     elif isinstance(args,MethodType):
12         print("是方法")
13     else:
14         print("是其他")
15         
16 check(参数)
代码检查

 

                反射                 

getattr  # 根据字符串的形式,去对象中找成员.   第一个参数是(模块或对象或类),  第二个参数是(用户输入或值)

hasattr  #  根据字符串的形式 , 去判断对象中是否有成员

 1 from types import FunctionType
 2             import handler
 3 
 4             while True:
 5                 print("""
 6                 系统支持的函数有：
 7                     1. f1
 8                     2. f2
 9                     3. f3
10                     4. f4
11                     5. f5
12                 """)
13                 val = input("请输入要执行的函数：") # val = "f1"
14 
15                 # 错误
16                 # handler.val()
17                 if hasattr(handler,val):
18                     func_or_val = getattr(handler,val)     # 根据字符串为参数，去模块中寻找与之同名的成员。
19                     if isinstance(func_or_val,FunctionType):
20                         func_or_val()
21                     else:
22                         print(func_or_val)
23                 else:
24                     print('handler中不存在输入的属性名')
25 
26                 # 正确方式
27                 """
28                 if val == 'f1':
29                     handler.f1()
30                 elif val == 'f2':
31                     handler.f2()
32                 elif val == 'f3':
33                     handler.f3()
34                 elif val == 'f4':
35                     handler.f4()
36                 elif val == 'f5':
37                     handler.f5()
38                 """
示例模块
 1             class Account(object):
 2                 func_list = ['login', 'logout', 'register']
 3 
 4                 def login(self):
 5                     """
 6                     登录
 7                     :return:
 8                     """
 9                     print('登录111')
10 
11                 def logout(self):
12                     """
13                     注销
14                     :return:
15                     """
16                     print('注销111')
17 
18                 def register(self):
19                     """
20                     注册
21                     :return:
22                     """
23                     print('注册111')
24 
25                 def run(self):
26                     """
27                     主代码
28                     :return:
29                     """
30                     print("""
31                         请输入要执行的功能：
32                             1. 登录
33                             2. 注销
34                             3. 注册
35                     """)
36 
37                     choice = int(input('请输入要执行的序号:'))
38                     func_name = Account.func_list[choice-1]
39 
40                     # func = getattr(Account,func_name) # Account.login
41                     # func(self)
42 
43                     func = getattr(self, func_name)  # self.login
44                     func()
45 
46             obj1 = Account()
47             obj1.run()
48 
49             obj2 = Account()
50             obj2.run()
示例类或对象

setattr  # 根据字符串的形式 , 动态的设置一个成员(在内存中)  (三个参数, 第一个参数是  要设置的变量, 第三个变量是要设置的值)

delattr  #  根据字符串的形式 , 动态的删除一个成员(在内存中)   语法 :

 1 class Foo(object):
 2 
 3     def __init__(self,a1):
 4         self.a1 = a1
 5         self.a2 = None
 6 
 7 obj = Foo(1)
 8 
 9 
10 v1 = getattr(obj,'a1')
11 print(v1)
12 
13 setattr(obj,'a2',2)
14 
15 
16 v2 = getattr(obj,'a2')
17 print(v2)
示例

 

 

callable  判断  名()   是否可以执行

返回值  :   bool类型

 只有  类 , 对象 , 函数 , 方法,  后面加  ()  可以被调用

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

 

posted @ 2018-08-30 17:33  heshun  阅读(256)  评论(0)  编辑  收藏  举报