特殊成员的补充：
# __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)) # 检查第一个参数是否是第二个参数的 子子孙孙类
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)
"""
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)
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))