反射

1.内置函数
issubclass(子类,父类) ##判断第一个参数是否是第二个参数的子类(子子孙孙)
例子:
class Base(object):
pass
class Foo(Base):
pass
class Wal(Foo):

         print(issubclass(Foo,Base))    #True
         print(issubclass(Wal,Base))    #True


type()        ##获取对象是由哪个类创建的. "这个类只是当前类.不包括父类"

isinstance(obj,class)   ##判断'当前对象'(第一个参数)是否有'当前类,以及当前类的父类'(第二个参数)创建

##########给一个参数,判断对象是否由一个指点类? type
##########给一个参数,判断对象是否由一个指点类及其父类? isinstance

2.函数与方法区分
称谓:
类中 -->方法
类外 -->函数

科学判断:
    对象.函数名 -->方法
    类.函数名  --> 函数
    函数名     -->函数

代码检测:
    from types import MethodType,FunctionType
    def check(args):
        '''
        检测args是方法还是函数
        :param args:
        :return:
        '''
        if isinstance(args,MethodType):
            print('arges是方法')
        elif isinstance(args, FunctionType):
            print('arges是函数')
        else:
            print ('不知道是啥')
    def fun():
        pass

    class Foo:
        def method(self):
            pass
    obj = Foo()

    check(fun)
    check(obj.method)

3.反射

getattr(对象,字符串内容)  #####根据字符串的内容, 去对象中去寻找相应名字的板块
hasattr(对象,字符串内容)  #####根据字符串的内容, 判断对象中是哦夫存在相应名字的板块
setattr(对象,字符串内容)  #####根据字符串的内容, 在对象中动态传入相应名字的板块(内存)
delattr(对象,字符串内容)  #####根据字符串的内容, 在对象中动态删除应名字的板块(内存)

模块应用一:     输入函数名,在xx模块中找到,并调用
    ##模块
        XX:
        a = 0
        def func1():
            pass
        def func2():
            pass
        def func3():
            pass
    ##执行
        from types import FunctionType
        print("""
        xx模块内置函数有:
            0.a
            1.func1
            2.func2
            3.func3
            """)
        val = input('请输入数字:')

        ##错误; XX.val()    因为val是字符串,func1是函数,所以val无法充当函数名.

        ##if - else方法     ------->缺点,写太多
        """
        if val == 'func1':
            func1()
        elif val == 'func2':
            func2()
        elif val == 'func3':
            func3()
        """

        ##反射方法
        if hasattr(xx,val):        ##判断xx中是否有与val名字相同地板块
            f = getattr(xx, val)  ##通过val,在模块xx寻找出相应名字的板块(获取函数名)
            if isinstance(val,FunctionType)       ##判断与val相同名字的把板块是否是函数
                f()                               ##调用函数
            else:
                print(val)                        ##打印值

面向对象应用一:
        class Foo:

            alld = '丹麦'

            def func(self):
                pass

        obj = Foo()

        ***********
        v = getattr(Foo,'alld') ###-----> Foo.alld
        s = getattr(Foo,'func') ###-----> Foo.func ----->此时是一个函数

        *********
        s = getattr(obj,'func') ###-----> obj.func ----->此时是一个方法

        *************总结***********
        getattr(对象,字符串)作用其实就是:在当前"对象"中获取与"字符串"相同"成员"(变量名,方法名,函数名).


     应用二: 输入函数名,在类中找到,并调用
        from types import  FunctionType
        class Base(object):
            a = 1
            func_list = ['login', 'logout', 'register']

            def login(self):
                print('successful login')

            def logout(self):
                print('successful logout')

            def register(self):
                print('successful register')

            def run(self):

                while True:
                    val = int(input('请输入数字:'))
                    func_or_val= Base.func_list[val-1]

                    if hasattr(Base, func_or_val):
                        new_func = getattr(Base, func_or_val) 
                        if isinstance(new_func,FunctionType) or isinstance(new_func, MethodType):
                            new_func(self)
                        else:
                            print(new_func)

        obj = Base()
        obj.run()