面向对象在加深

内容补充:

把不可迭代对象变成可迭代对象:  1在类中定义__iter__方法 

　　　　　　　　　　　　　　　2在__iter__内部返回一个迭代器(生成器也是特殊的迭代器)

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类的一个对象，可迭代对象
"""
obj1 = Foo('刘博文',99)

for item in obj1:
    print(item)   #结果为 11  22  33

练习题补充:

# 第一题：

# class StarkConfig(object):
#     list_display = []
#
#     def get_list_display(self):
#         self.list_display.insert(0,33)
#         return self.list_display
#
# class RoleConfig(StarkConfig):
#     list_display = [11,22]
#
#
# s1 = StarkConfig()
#
# result1 = s1.get_list_display()
# print(result1) # 33
#
# result2 = s1.get_list_display()
# print(result2) # 33 33

 class StarkConfig(object):
#     def __init__(self):
#         self.list_display = []
#
#     def get_list_display(self):
#         self.list_display.insert(0, 33)
#         return self.list_display
#
#
# class RoleConfig(StarkConfig):
#     list_display = [11, 22]
#
#
# s1 = StarkConfig()
#
# result1 = s1.get_list_display()
# print(result1)  # 33
#
# result2 = s1.get_list_display()
# print(result2)  # 33 33

# class StarkConfig(object):
#     def __init__(self):
#         self.list_display = []
#
#     def get_list_display(self):
#         self.list_display.insert(0, 33)
#         return self.list_display
#
#
# class RoleConfig(StarkConfig):
#     list_display = [11, 22]
#
#
# s1 = StarkConfig()
# s2 = StarkConfig()
#
# result1 = s1.get_list_display()
# print(result1)  # 33
#
# result2 = s2.get_list_display()
# print(result2)  # 33

 

issubclass/isinstance/type

issubclass(a,b):检查a是否是b的子孙类

class Base(object):
    pass

class Foo(Base):
    pass

class Bar(Foo):
    pass

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

type(a):获取当前对象a由哪个类创建,,只能判断对象与类的父子关系,不包含爷孙关系

class Foo(object):
    pass

obj = Foo()

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

isinstance(a,b):检查第一个参数a是否是第二个参数(类及其父类)b的实例.

class Base(object):
    pass

class Foo(Base):
    pass

obj1 = Foo()
print(isinstance(obj1,Foo))  #True  检查第一个参数（对象）是否是第二个参数（类及父类）的实例。
print(isinstance(obj1,Base)) #True 检查第一个参数（对象）是否是第二个参数（类及父类）的实例。

用科学的方法判断方法与函数

简单称谓:定义在类内部的函数称之为方法,定义在外部的函数就是函数.  其实与定义无关,而是与调用对象有关,  类名.函数名()是函数     对象.函数名()是方法

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('不知道是什么')


def func():
    pass

class Foo(object):
    def detail(self):
        pass
    @staticmethod
    def xxx():
        pass

check(func) #arg是一个函数
obj = Foo()
check(obj.detail)# arg是一个方法
check(obj.xxx)# arg是一个函数

 

反射:

getattr # 根据字符串的形式，去对象中找成员。

模块类型:

1自定义一个模块:handler

f0 = 9

def f1():
    print('F1')

def f2():
    print('F2')

def f3():
    print('F3')

def f4():
    print('F4')

def f5():
    print('F5')

2在其他程序中调用:run 
from types import FunctionType   #引入判断函数方法
import handler  #引入handler模块

while True:
    print("""
    系统支持的函数有：
        1. f1
        2. f2
        3. f3
        4. f4
        5. f5
    """)
    val = input("请输入要执行的函数：")     # val = "f1"

        #handler.val()       # 错误方式 因为val 是字符串,不能字符串+()
#正确反射方式
    if hasattr(handler,val):   #判断handler中有val
        func_or_val = getattr(handler,val)     # 根据字符串为参数，去模块中寻找与之同名的成员。
        if isinstance(func_or_val,FunctionType):#func_or_val是函数类型
            func_or_val()    #调用函数
        else:#不是函数类型
            print(func_or_val)  #打印值
    else:
        print('handler中不存在输入的属性名')#判断handler中没有val

    # 正确if语句方式
    """
    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()
    """

    country = "中国"

    def func(self):
        pass


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

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

 

hasattr # 根据字符串的形式，去判断对象中是否有成员。
setattr # 根据字符串的形式，动态的设置一个成员（内存）:尽量少使用 程序可读性差,不方便交流.
delattr # 根据字符串的形式，动态的删除一个成员（内存）

xx模块:

x1 = 123

def f1(arg):
    print(arg,666)


另一模块:
import xx  #引入XX模块

# getattr
v1 = getattr(xx,'x1')  #去xx模块中寻找x1同名成员
v2 = getattr(xx,'f1')  #去xx模块中寻找f1同名成员
v2('杨森')  #存在f1的话 调用f1并传值杨森

# hasattr
v3 = hasattr(xx,'x1') #判断xx中有无x1成员
v4 = hasattr(xx,'f1')  #判断xx中有无f1成员
v5 = hasattr(xx,'xxxxxxx')  #判断xx中有无xxxxxxx成员
print(v3,v4,v5)  #打印结果 True  True  False
 
# setattr
setattr(xx,'x2',999)  # 在xx模块内存地址中动态添加一个变量x2=999
v6 = getattr(xx,'x2')  #去xx模块中寻找x2同名成员
print(v6)  #打印结果为 999

setattr(xx,'f2',lambda x:x+1)#动态添加一个函数
v7 = getattr(xx,'f2')#去xx模块中寻找f2同名成员
v8 = v7(1) # 调用v7
print(v8)  打印出  2

# delattr
delattr(xx,'x1') # 在xx模块内存地址中动态删除x1
v9 = getattr(xx,'x1')# 去xx模块中寻找x1同名成员
print(v9) # 打印结果为错误