面向对象的反射和其他

1.issubclass/type/isinstance/

class Base(object):
    pass
class Foo(Base):
    pass
class Bar(Foo):
    pass
#   issubclass  判断是否是继承关系,
print(issubclass(Bar, Base))     #判断第一个参数是不是第二个参数的子孙类
print(issubclass(Foo, Bar))

class Foo(object):
    pass
obj = Foo()
print(obj, type(obj))   #获取当前对象是由那个类创建的
if type(obj) == Foo:
    print('obj是类Foo创建的对象')
结果:
<__main__.Foo object at 0x032ADCF0> <class '__main__.Foo'>
obj是类Foo创建的对象

class Foo(object):
    pass
class Bar(object):
    pass
def func(*args):
    foo_counter = 0
    bar_counter = 0
    for item in args:
        if type(item) == Foo:
            foo_counter += 1
        elif type(item) == Bar:
            bar_counter += 1
    return foo_counter, bar_counter
result = func(Foo(), Bar(), Foo())
print(result)
v1, v2 = func(Foo(), Bar(), Foo())
print(v1, v2)
结果:
(2, 1)
2 1

#isinstance  传两个参数,判断第一个参数(对象)是否是第二个参数(类及父类)的实例
class Base(object):
    pass
class Foo(Base):
    pass
obj1 = Foo()
print(isinstance(obj1, Foo))    #检查第一个参数(对象)是否是第二个参数(类及父类)的实例
print(isinstance(obj1, Base))   #检查第一个参数(对象)是否是第二个参数(类及父类)的实例
obj2 = Base()
print(isinstance(obj2, Foo))    #检查第一个参数(对象)是否是第二个参数(类及父类)的实例
print(isinstance(obj2, Base))   #检查第一个参数(对象)是否是第二个参数(类及父类)的实例

　　使用场景:type和isinstance

　　　　type: 判断对象是不是由某一个指定的类创建    -->type(obj) == Foo

　　　　isinstance:判断对象是不是由某一个指定的类或其父类创建  -->isinstance(obj,Foo)

2.方法和函数

　　称谓:

　　　　类  方法

　　　　外  函数

　　　判断到底是方法还是函数的方法,看怎么调用

　　　　　　对象.xxx  --> xxx就是方法

　　　　　　类.xxx      --> xxx就是函数

　　　　　　xxx　　　--> xxx就是函数

　　　打印查看

　　　　　　function　　函数

　　　　　　method　　方法

from types import MethodType,FunctionType
def check(args):
    if isinstance(args, MethodType):
        print('args是一个方法')
    elif isinstance(args, FunctionType):
        print('args是一个函数')
    else:
        print('不知道是什么东西')

def func():
    pass
class Foo(object):
    def detail(self):
        pass
    @staticmethod
    def xxx():
        pass

check(func)

obj = Foo()
check(obj.detail)
check(obj.xxx)
结果:
args是一个函数
args是一个方法
args是一个函数

class Foo(object):
    def f1(self):
        pass
    def f2(self):
        pass
    def f3(self):
        pass
obj = Foo()
print(obj.f1)
print(obj.f2)

obj = Foo()
Foo.f1(obj)     #把f1当做函数
obj = Foo()
obj.f1()        #把f1当做方法,自动传self值
结果:
<bound method Foo.f1 of <__main__.Foo object at 0x0030FDF0>>
<bound method Foo.f2 of <__main__.Foo object at 0x0030FDF0>>

3.反射

　　getatter　　#根据字符串的形式,去对象中找成员

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

　　setatter　　#根据字符串的形式,动态的设置一个成员(添加在内存中)

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

from types import FunctionType
import handler
while True:
    print('''
    系统支持的函数有:
    1. f1
    2. f2
    3. f3
    4. f4
    5. f5
    ''')
    val = input('请输入要执行的函数:')
    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中不存在输入的属性名.')

f0 = 9
def f1():
    print('f1')
def f2():
    print('f2')
def f3():
    print('f3')
def f4():
    print('f4')
def f5():
    print('f5')

class Account(object):
    func_list = ['login', 'logout', 'register'] #建立一个序号与方法的对应关系列表
    def login(self):
        '''
        登录
        :return:
        '''
        print('登录11')
    def logout(self):
        '''
        注销
        :return:
        '''
        print('注销11')
    def register(self):
        '''
        注册
        :return:
        '''
        print('注册11')
    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)        #通过类执行方法,自己传self
        func = getattr(self, func_name)             #在对象中找func_name对应的方法
        func()              #通过对象执行方法
obj1 = Account()
obj1.run()

可以被调用:

　　类()

 　   对象()

　　函数()

　　方法()

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))