day25

1. isinstance/issubclass/type

(1)issubclass: 检查第一个参数是否是第二个参数的 子子孙孙类
  示例:
    class Base(object):
        pass

    class Foo(Base):
        pass

    class Bar(Foo):
        pass

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

(2)type: 获取对象是由那个类?创建的
  示例1:
    class Foo:
        pass

    obj = Foo()

    print(obj, type(obj))  # 获取对象是由那个类创建的
    if type(obj) == Foo:
        print('obj是Foo类型')

  示例2:
    class Foo:
        pass

    class Bar:
        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)

(3)isinstance: 检查第一个参数(对象)是否是第二个参数(类以及父类)的实例
  示例:
    class Base(object):
        pass

    class Foo(Base):
        pass

    obj1 = Foo()
    print(isinstance(obj1, Foo))  # T 检查obj1是否是Foo类或者Foo父类的实例
    print(isinstance(obj1, Base))  # T

    obj2 = Base()
    print(isinstance(obj2, Foo))  # F
    print(isinstance(obj2, Base))  # T

"""
给你一个参数,判断对象是不是某一个指定的类?        type    --> type(obj) == Foo
给你一个参数,判断对象是不是某一个指定的类或其父类? isinstance  --> isinstance(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. 反射

简单示例:
    class Foo(object):

        country = "中国"

        def func(self):
            pass


    v = getattr(Foo, 'func') # Foo.func # 根据字符串为参数, 去类中寻找与之同名的成员
    print(v)

    obj = Foo()
    v = getattr(obj, 'func') # obj.func # 根据字符串为参数, 去对象中寻找与之同名的成员
    print(v)

　　总结: v = getattr(obj, 'func') # obj.func # 根据字符串为参数(第二个参数), 去对象(第一个参数)中寻找与之同名的成员

应用一:(模块级别)
    # 模块handler中有 f1-f5,调用之后分别打印 F1-F5.
    from types import FunctionType
    import handler
    while 1:
        print("""
        系统支持的函数有:
            1. F1
            2. F2
            3. F3
            4. F4
            5. F5
        """)
        val = input("请输入要执行的函数:")  # val = 'f1'

        # 错误
        # handler.val()
        if hasattr(handler, val):  # hasattr 判断一个对象里面是否有name属性或者方法,返回bool值
            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()

"""
getattr()  # 根据字符串的形式, 去对象中找该成员
hasattr()  # 根据字符串的形式, 去判断对象中是否有该成员
setattr()  # 根据字符串的形式, 去对象中动态的设置一个成员(内存)
delattr()  # 根据字符串的形式, 去对象中动态的删除一个成员(内存)
"""
# 反射补充
    xx文件
    ------------------
    x1 = 123

    def f1(arg):
        print(arg, 666)
    --------------------
    import xx
    
    # getattr: 根据字符串的形式, 去对象中找该成员
    v1 = getattr(xx, 'x1')
    v2 = getattr(xx, 'f1')  # 找到xx模块中的f1函数,并把函数名赋值给v1
    v2('杨森')  # 传参调用
    
    # hasattr: 根据字符串的形式, 去判断对象中是否有该成员,返回bool值
    v3 = hasattr(xx, 'x1')
    v4 = hasattr(xx, 'f1')
    v5 = hasattr(xx, 'xxxxxxx')
    print(v3, v4, v5)  # T T F
    
    # setattr: 根据字符串的形式, 去对象中动态的设置一个成员(内存)
    setattr(xx, 'x2', 999)  # 在内存设置了一个值 x2 = 999
    v6 = getattr(xx, 'x2')
    print(v6)  # 999
    
    setattr(xx, 'f2', lambda x: x+1)  # 在内存中设置了一个f2函数
    v7 = getattr(xx, 'f2')
    v8 = v7(1)
    print(v8)  # 2

    # delattr
    delattr(xx, 'x1')  # 在内存中删除了
    v9 = getattr(xx, 'x1')  # 报错: 模块'xx'中没有成员'x1'

# 反射补充-类
  示例:
        class Foo(object):
    
        def __init__(self, a1):
            self.a1 = a1
    
    obj = Foo(1)
    
    v1 = getattr(obj, 'a1')
    print(v1)  # 1
    
    setattr(obj, 'a2', 2)  # 在内存中为类设置一个类变量 a2 = 2
    v2 = getattr(obj, 'a2')
    print(v2)  # 2
    
    print(hasattr(obj, 'a1'))  # T 对象中是否存在成员a1
    
    delattr(obj, 'a1')  # 从内存中删除了a1
    v3 = getattr(obj, 'a1')  # 报错: 'Foo'对象没有'a1'

4. 补充一个小东西

# 问题：你见过的什么后面可以加()?
    - 类()
    - 对象()  执行__call__方法
    - 函数()
    - 方法()
    以上所有都可以被调用。

示例:
    def func():
        pass


    class Foo(object):
        def __call__(self, *args, **kwargs):
            pass
        def func(self):
            pass

    obj = Foo()
    
    # callable 判断是否可以被调用,返回bool值
    print(callable(func))  # 函数
    print(callable(Foo))  # 类 
    print(callable(obj))  # 对象
    print(callable(obj.func))  # 方法