day 25 方法和函数 反射

特殊成员的补充：

#    __str__
class Foo(object):
    def __init__(self):
        pass
    def func(self):
        pass
    def __str__(self):
        return "F1"       #返回的结果必须是字符串，别的都不行
obj = Foo()
print(obj,type(obj))

####      __doc__
class Foo(object):
    """
    asdfasdfasdfasdf
    """
    def __init__(self):
        pass
    def func(self):
        pass
obj = Foo()
print(obj.__doc__)    #打印注释里面的内容

##   __dict__
class Foo(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def func(self):
        pass
obj1 = Foo('刘博文',99)
obj2 = Foo('史雷',89)
print(obj1.__dict__) # {'name': '刘博文', 'age': 99}
print(obj2.__dict__) # {'name': '史雷', 'age': 89}

###     __iter__
# l1是list类的一个对象，可迭代对象
l1 = [11,22,33,44]
class Foo(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age
    def func(self):
        pass
    def __iter__(self):
        # return iter([11,22,33,44,55,66])
        yield 11
        yield 22
        yield 33
# obj1是Foo类的一个对象，可迭代对象
"""
如果想要把不可迭代对象 -> 可迭代对象
1. 在类中定义__iter__方法
2. iter内部返回一个迭代器(生成器也是一种特殊迭代器)
"""
obj1 = Foo('刘博文',99)
for item in obj1:
    print(item)

今日内容：

　　1. isinstance/issubclass/type
　　2. 方法和函数
　　3. 反射

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

issubclass
    class Base(object):
        pass

    class Foo(Base):
        pass

    class Bar(Foo):
        pass

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

View Code

2、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)
"""

View Code

3、isinstance,检查第一个参数（对象）是否是第二个参数（类及父类）的实例

 1 class Base(object):
 2     pass
 3 
 4 class Foo(Base):
 5     pass
 6 
 7 obj1 = Foo()
 8 print(isinstance(obj1,Foo))  # 检查第一个参数（对象）是否是第二个参数（类及父类）的实例。
 9 print(isinstance(obj1,Base)) # 检查第一个参数（对象）是否是第二个参数（类及父类）的实例。
10 
11 
12 obj2 = Base()
13 print(isinstance(obj2,Foo))  # 检查第一个参数（对象）是否是第二个参数（类及父类）的实例。
14 print(isinstance(obj2,Base)) # 检查第一个参数（对象）是否是第二个参数（类及父类）的实例。
15 
16 
17 
18 # #################### 练习
19 """
20 给你一个参数，判断对象是不是由某一个指定类？ type                  --> type(obj) == Foo
21 给你一个参数，判断对象是不是由某一个指定类或其父类？ isinstance    --> instance(obj,Foo)

View Code

扫描二维码关注公众号，回复： 7681779 查看本文章

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 # 根据字符串的形式，动态的删除一个成员（内存

 1 class Account(object):
 2     func_list = ['login', 'logout', 'register']
 3 
 4     def login(self):
 5         """
 6         登录
 7         :return:
 8         """
 9         print('登录111')
10 
11     def logout(self):
12         """
13         注销
14         :return:
15         """
16         print('注销111')
17 
18     def register(self):
19         """
20         注册
21         :return:
22         """
23         print('注册111')
24 
25     def run(self):
26         """
27         主代码
28         :return:
29         """
30         print("""
31             请输入要执行的功能：
32                 1. 登录
33                 2. 注销
34                 3. 注册
35         """)
36 
37         choice = int(input('请输入要执行的序号:'))
38         func_name = Account.func_list[choice-1]
39 
40         # func = getattr(Account,func_name) # Account.login
41         # func(self)
42 
43         func = getattr(self, func_name)  # self.login
44         func()
45 
46 obj1 = Account()
47 obj1.run()
48 
49 obj2 = Account()
50 obj2.run()

应用二

 1 from types import FunctionType
 2 import handler
 3 
 4 while True:
 5     print("""
 6     系统支持的函数有：
 7         1. f1
 8         2. f2
 9         3. f3
10         4. f4
11         5. f5
12     """)
13     val = input("请输入要执行的函数：") # val = "f1"
14 
15     # 错误
16     # handler.val()
17     if hasattr(handler,val):
18         func_or_val = getattr(handler,val)     # 根据字符串为参数，去模块中寻找与之同名的成员。
19         if isinstance(func_or_val,FunctionType):
20             func_or_val()
21         else:
22             print(func_or_val)
23     else:
24         print('handler中不存在输入的属性名')
25 
26 # 正确方式
27 """
28 if val == 'f1':
29     handler.f1()
30 elif val == 'f2':
31     handler.f2()
32 elif val == 'f3':
33     handler.f3()
34 elif val == 'f4':
35     handler.f4()
36 elif val == 'f5':
37     handler.f5()
38 """

应用一

问题：你见过的什么后面可以加()? 
        - 类()
        - 对象()
        - 函数()
        - 方法()
        以上所有都可以被调用。
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))