python 面向对象--代码小练

一：对下面的代码的详细过程进行分析

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):
    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()
上面的这个是进行实例化的过程，在此过程中发生了什么？首先会调用该类的__new__()方法进行构造创建了对象
（实例）空间，此时还是个空的，然后在执行__init__()进行数据初始化，此时对象中的变量就是在此时定义。
而对象空间中会有指向类空间的指针，因此要区分好类变量和实例变量所在的空间。我们在操作时到底改没改
类变量就是看这个变量在实例变量中有没有，如果没有说明在__init__()中没有此变量。因此针对此题，
就可以很轻松的知道为什么会有这样的答案了。


result1 = s1.get_list_display()
print(result1) # [33]
result2 = s1.get_list_display()
print(result2) # [33, 33]

 

二：看代码写答案

class Base:

    @classmethod
    def f3(cls):
        print(cls)

    def f1(self):
        print('base.f1')
        self.f3()

class Foo(Base):

    def f2(self):
        print('foo.f2')
        self.f1()

obj = Foo()
obj.f2()

答案：
foo.f2
base.f1
<class '__main__.Foo'>

针对此题的分析：

此题的关键在于self，obj.f2()首先会调用Foo的f2所以打印foo.f2，然后调用self.f1()，self是obj，obj是Foo()，先从Foo类寻找，没有
再去找父类Base，找到f1，此时参数self依旧是obj，然后打印'base.f1，在然后self.f3()，先是去Foo寻找（因为self是Foo类的对象），
没有找到，再去父类Base里找，找到后，f3()是类方法，因此cls参数是类名，这个类名从self.f3()可以确定来源于Foo

 三：反射相关的案例：

 如果有一下handler.py文件，请在 run.py中补充代码实现：

handler.py

class Base(object):
    pass

class F1(Base):
    pass
class F2(Base):
    pass
class F3(F2):
    pass
class F4(Base):
    pass
class F5(object):
    pass
class F6(F5):
    pass

 

1: 获取handler中所有成员名称

import handler
def func():
    objs = []
    name_list = dir(handler)
    print(name_list)

if __name__ == '__main__':
    func()

答案：['Base', 'F1', 'F2', 'F3', 'F4', 'F5', 'F6', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__']注意：这里获得的是字符串

 

2：获取handler中名字叫Base的成员

import handler
def func():
    objs = []
    name_list = dir(handler)    #注意这里获得的是字符串
    for item in name_list:
        if item == 'Base':
            print(item)
            break
    else:
        print("没有")
if __name__ == '__main__':
    func()

 

3：检查其他成员是否是Base类的子类（不包含Base），如果是则创建对象并添加到objs列表中

import handler

def func():
    objs = []
    name_list = dir(handler)
    func_b = getattr(handler, 'Base')
    for item in name_list:  #注意这里的item是字符串
        if item != 'Base':
            func_a = getattr(handler, item)  #找到映射关系
            if type(func_a) == type:    #这个是判断是否是类的方法
                if issubclass(func_a,func_b):
                    objs.append(func_a())
    print(objs)
    return objs

四：看代码写结果

class Foo:
    def __init__(self):
        self.name = 'li'
        self.age = 100
obj = Foo()
setattr(Foo,'email','lilz@qq.com')
print(obj.__dict__)  #{'name': 'li', 'age': 100}#__dict__把对象封装中的数据以字典的方式输出

v1 = getattr(obj,'email')   #obj.email
v2 = getattr(Foo,'email')   #Foo.email
print(v1,v2)  #lilz@qq.com lilz@qq.com