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

面向对象中内置函数

issubclass方法:

　　检查第一个参数是否是第二个参数的子子孙孙类    

返回  :   是一个布尔值

 class Base(object):
     pass

 class Foo(Base):
     pass

 class Bar(Foo):
     pass

 print(issubclass(Bar,Base))  # 检查第一个参数是否是第二个参数的子子孙孙类

type: 方法

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

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

 class Foo(object):
     pass

 obj = Foo()

 print(obj,type(obj))   # 获取当前对象有哪个类创建
 if type(obj) == Foo:
     print("由类Foo创建")

 def func(*args):
     Foo_count = 0
     Base_count = 0
     for el in args:
         if type(el) == Foo:
             Foo_count += 1
         elif type(el) == Base:
             Base_count += 1
     return Foo_count,Base_count

 # ret = func(Base(),Base(),Foo(),Foo(),Foo())
 # print(ret)

 v,i = func(Base(),Base(),Foo(),Foo(),Foo())
 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   表示方法

 from types import FunctionType,MethodType

 def check(args):
     """
     检查args是函数还是方法
     :param args:
     :return:
     """
     if isinstance(args,FunctionType):
         print("是函数")
     elif isinstance(args,MethodType):
         print("是方法")
     else:
         print("是其他")

 check(参数)

代码检查

反射

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

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

 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):
                     func_or_val = getattr(handler,val)     # 根据字符串为参数，去模块中寻找与之同名的成员。
                     if isinstance(func_or_val,FunctionType):
                         func_or_val()
                     else:
                         print(func_or_val)
                 else:
                     print('handler中不存在输入的属性名')

                 # 正确方式
                 """
                 if val == 'f1':
                     handler.f1()
                 elif val == 'f2':
                     handler.f2()
                 elif val == 'f3':
                     handler.f3()
                 elif val == 'f4':
                     handler.f4()
                 elif val == 'f5':
                     handler.f5()
                 """

示例模块

             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
                     # func(self)

                     func = getattr(self, func_name)  # self.login
                     func()

             obj1 = Account()
             obj1.run()

             obj2 = Account()
             obj2.run()

示例类或对象

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

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

 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)

 v2 = getattr(obj,'a2')
 print(v2)

示例

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

返回值  :   bool类型

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

 def func():
     pass

 class Foo(object):

     def __call__(self, *args, **kwargs):
         pass

     def fun(self):
         pass

 obj = Foo()

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

示例