反射

反射

一：isinstance, type, issubclass

1. issubclass(),这个内置函数可以判断xxx类是否是yyy类的型的子类。
例：
    class Base:
        pass
    class Foo(Base):
        pass
    class Bar(Foo):
        pass
        
    print(issubclass(Bar,Foo))  # True
    print(issubclass(Foo,Bar))  # False
    print(issubclass(Bar,Base)) # True
    
    
     
    

2. 前面学习过type(),查看obj是由哪个类创建的。
例：
    class Foo:
        pass

    obj = Foo()
    print(obj,type(obj))  # 查看obj的类
     # <__main__.Foo object at 0x00000000024B8160> <class '__main__.Foo'>
    

2.1 现在type()可以判断xxx是否是xxx数据类型的。
例:
    class Boy:
        pass
    class Girl:
        pass

    # 统计传进来的男生和女生分别有多少
    def func(*args):
        b = 0
        g = 0
        for obj in args:
            if type(obj) == Boy:
                b += 1
            elif type(obj) == Girl:
                g += 1
        return b, g
    ret = func(Boy(),Girl(),Boy(),Girl(),Boy(),Girl(),Boy(),Girl())
    print(ret)
     # (4,4)

2.2 也可以先判断好数据类型必须是int或者float，进行有意义的计算。
例：
    def add(a,b):
    if (type(a) == int or type(a) == float) and (type(b) == int or type(b) == float):
        return a + b
    else:
        print('报错')    
    

3. isinstance 也可以判断xxx是否是yyy类型的数据，但是isinstance没有typename精准。
例：
    class Base:
        pass
    class Foo(Base):
        pass
    class Bar(Foo):
        pass

    print(isinstance(Foo(),Foo))   # True
    print(isinstance(Foo(),Base))  # True
    print(isinstance(Foo(),Bar))   # False
     
注：isinstance可以判断该对象是否是xxx家族体系的（只能往上判断，不能往下判断）

二：区分函数和方法

如何区分函数和方法
例：
    def func():
        pass
        print(func)   # <function func at 0x0000000002071E18>
            
    
    class Foo:
        def chi(self):
            print('1')
    
    f = Foo()
    print(f.chi)   # <bound method Foo.chi of <__main__.Foo object at 0x00000000024E83C8>>
    
函数下打印的时候，显示的是function；方法在打印的时候现实的method.
但其实不一定是这样的。
例：
    class Foo:
        def chi(self):
            print('我是吃')

    @staticmethod
    def ststic_method():
        pass

    @classmethod
    def class_method(cls):
        pass

    f = Foo()
    print(f.chi)   # <bound method Foo.chi of <__main__.Foo object at 0x00000000024C83C8>>
    print(f.ststic_method)    # <function Foo.ststic_method at 0x00000000022F7950>
    print(f.class_method)     # <bound method Foo.class_method of <class '__main__.Foo'>>
    
    print(Foo.chi) # <function Foo.chi at 0x00000000024F78C8>
    print(Foo.ststic_method)  # <function Foo.ststic_method at 0x00000000024B7950>
    print(Foo.class_method)   # <bound method Foo.class_method of <class '__main__.Foo'>>
    
     注: function 表示是函数
         method 表示是方法

结论：
    1.类方法，不论任何情况都是方法。
    2.静态方法，不论任何情况都是函数。
    3.实例方法，如果是实例（对象）访问就是方法，类名访问就
    
    是函数。
    
    
如何用程序分辨方法和函数，借助于types模块。
例：
    # 所有的方法都是MethodType的实例
    #所有的函数都是FunctionType的实例

    from types import MethodType ,FunctionType        
    def func():
        pass

    # print(isinstance(func,FunctionType))   # True
    # print(isinstance(func,MethodType))     # False


    class Foo:
        def chi(self):
            print('我是吃')

    @staticmethod
    def static_method():
        pass

    @classmethod
    def class_method(cls):
        pass

    obj = Foo()
    print(type(obj.chi))   # <class 'method'>
    print(type(Foo.chi))   # <class 'function'>
    print(isinstance(obj.chi,MethodType))   # True
    print(isinstance(Foo.chi,FunctionType)) # True
    
    print(isinstance(Foo.static_method,FunctionType))   # False
    print(isinstance(Foo.static_method,MethodType))     # True
    
    print(isinstance(Foo.class_method,MethodType))   # True
    print(isinstance(Foo.class_method,FunctionType)) #  False
        
注：用types中的FunctionType和MethofType可以区分当前内容是方法还是函数。

三：反射

例：
    我们需要用别人写的代码，但是我们并不清楚代码中的功能，这时就需要我们自己去测试，来拿到自己想用的功能。
    
    首先拿到 代码：某人.py
    def chi():
        print('某人能吃一头牛')
    def he():
        print('某人能喝一条河')
    def chui():
        print('某人能八天吹破')
    def shui():
        print('某人能睡一年')

    # 现在需要自己一个一个的调用，在调用之前已经知道代码中的功能。

    import moster

    while 1:
        print('''代码中功能有
            chi
            he
            chui
            shui
        大概其就这么多   
        ''')
        gn = input('请输入你想测试的功能：')
        if gn == 'chi':
            master.chi()
        elif gn == 'he':
            master.he()
        elif gn == 'chui':
            master.chui()
        elif gn == 'shui':
            master.shui()
        else:
            print('一共四个功能')


现在某人.py文件里有100个功能，我们需要进行100次测试，工程有点浩大。但是我们可以使用反射来简单的完成这个好大的工程，
如果能通过字符串动态来访问模块中的功能，就能解决这个问题。
根据上面的操作来进行逆向操作，我们先输入自己想要的功能，然后去代码模块里找，这就叫：反射
例：
    import moster
    while 1:
        print('''代码中功能有
            chi
            he
            chui
            shui
        大概其就这么多   
        ''')
        gn = input('请输入你想测试的功能：')
        func = getattr(moster,gn)
        func()
    
    
getattr(对象.字符串): 从对象里获取到xxx功能，此时xxx是一个字符串，get表示找，attr表示属性(功能)。
但是如果在代码里找不到我想要的内容，就会报错，所以在获取attr之前先判断一下，代码里有没有attr。
例:
   import master
    from types import FunctionType

    while 1:
        print('''代码中功能有
            chi
            he
            chui
            shui
        大概其就这么多   
        ''')
        gn = input('请输入你想测试的功能：')
        if hasattr(master,gn):  # 如果master里有你功能，获取这个功能并执行。
            attr = getattr(master,gn)   # 判断是否是函数，只有函数才可以被调用
            if isinstance(attr,FunctionType):
                attr()
            else:
                print(attr)
 
 
这里讲到两个函数，一个是getattr(),一个是hasattr()。getattr()用来获取信息，hasattr()用来判断xxx中否包含了xxx功能。
例:
     class Preson:
        country = '大清'
        def chi(self):
            pass
            
    # 类中的内容可以这样动态地进行获取
    print(getattr(Preson,'country'))
    print(getattr(Preson,'chi'))   # 相当于 类名.'静态属性'  函数


    # 对象一样可以
    obj = Preson()
    print(getattr(obj,'country'))
    print(getattr(obj,'chi'))     # 相当于 对象.'方法名'  方法       

总结：
    getattr可以从模块中获取内容，也可以从类中获取内容，也可以从对象中获取内容。
    在python中一切皆为对象，那就可以认为getattr从对象中动态的获取成员。


补充：
反射一共有4个函数:
    1：getattr(obj.str) 从obj中获取str成员
    2: hasattr(obj.str) 判断obj中是否包含str成员
    3: setattr(obj,str,value) 把obj中的成员设置成value，注：这里的value可以是值，也可以是函数或者方法。
    4：delattr(obj,str) 把obj中的str成员删除

注：以上操作都是在内存中进行，不会影响源代码。

class Foo:
    pass

f = Foo()
print(hasattr(f,'chi'))  #  False

setattr(f,'chi','123')
print(f.chi)     # 添加了一个属性信息

setattr(f,'chi',lambda x : x + 1)
print(f.chi(3))   # 4
print(f.chi)  # 此时chi既不是静态方法，也不是实例方法，也不是类方法，而是相当于在类中写了一个self.chi = lambda
print(f.__dict__)  # {'chi': <function <lambda> at 0x0000000002081E18>}

delattr(f,'chi')   #  删除 chi
print(hasattr(f,'chi'))  #  判断f中是否还包含'chi'   结果：False