随笔- 93 文章- 8 评论- 1 阅读- 26294

issubclass,isinstance,type，判断函数和方法，反射

#1
#类变量与实例变量的区别
class foo:
    country='中国'
    def __new__(cls, *args, **kwargs):
        print('这是构造方法')
        return object.__new__(cls) #返回开辟的内存空间地址
    def __init__(self,name):
        self.name=name
        print('这个初始化方法')
#country 是类变量  name是实例变量
# country可以通过类名.变量的方式调用,也可以通过对象.变量的方式调用(对象中无此变量)
#name只能通过对象.变量的方式调用
obj=foo('alex')
print('类名调用类变量',foo.country)
print('对象调用类变量',obj.country)
print('对象调用实例变量',obj.name)
 
#2
#super().func()是找到func方法本类没有去父类找,继承多个父类,从左往右找
class f1:
    pass
class f2:
    def func1(self):
        return 'func被调用'
class f3(f1,f2):
    def func2(self):
        print(super().func1())
obj1=f3()
obj1.func2()
#3
#isinstance和type的区别
class Animal:
    pass
class Cat(Animal):
    pass
class BlueCat(Cat):
    pass
a=Animal()
cat=Cat()
blueCat=BlueCat()
print(isinstance(blueCat,Cat))
print(isinstance(blueCat,Animal))
print(type(blueCat))

""" if val == 'f1':
　　　　 handler.f1() 
    elif val == 'f2': 
　　　　 handler.f2() 
    elif val == 'f3': 
 　　　　handler.f3() 
　　 elif val == 'f4': 
　　　　 handler.f4() 

#4. issubclass/type/isinstance/
    
       # issubclass
            class Base(object):
                pass

            class Foo(Base):
                pass

            class Bar(Foo):
                pass

            print(issubclass(Bar,Base)) # 检查第一个参数是否是第二个参数的 子子孙孙类
            
        type:获取当前对象是由那个类创建。
                """
                class Foo(object):
                    pass

                obj = Foo()

                print(obj,type(obj)) # 获取当前对象是由那个类创建。
                if type(obj) == Foo:
                    print('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)
                """
            
        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                  --> type(obj) == Foo
            给你一个参数，判断对象是不是由某一个指定类或其父类？ isinstance    --> instance(obj,Foo)
            """
        
        
    2. 方法和函数
        称谓：
            类，方法
            外，函数
        到底方法函数？
            对象.xxx  --> xxx就是方法
            类.xxx    --> xxx就是函数
            xxx       --> xxx就是函数
        打印查看：
            function 
            method 
            
        代码检查：
            from types import MethodType,FunctionType
            def check(arg):
                """
                检查arg是方法还是函数？
                :param arg:
                :return:
                """
                if isinstance(arg,MethodType):
                    print('arg是一个方法')
                elif isinstance(arg,FunctionType):
                    print('arg是一个函数')
                else:
                    print('不知道是什么')
        
    
    3. 反射

        总结：
            v = getattr(obj,"func")  # 根据字符串为参数（第二个参数），去对象（第一个参数）中寻找与之同名的成员。
            getattr # 根据字符串的形式，去对象中找成员。
            hasattr # 根据字符串的形式，去判断对象中是否有成员。
            setattr # 根据字符串的形式，动态的设置一个成员（内存）
            delattr # 根据字符串的形式，动态的删除一个成员（内存）
        应用一：
            # by luffycity.com
            from types import FunctionType
            import handler

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

                """
        
        应用二：
            
            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(obj1,func_name) # obj1.login
              


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

            obj1 = Account()
            obj1.run()

            obj2 = Account()
            obj2.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))