python 类空间和对象空间的查询顺序,以及组合

一. 类空间,对象空间,查询顺序 
    查询顺序:
        对象.属性: 先从对象空间找,如果找不到,再从类空间找,再找不到,再从父类找...
        类名.属性: 先从本类空间找,如果找不到,再从父类找...

        对象与对象之间是互相独立的
        通过类名可以更改我的类中的静态变量值
        但是通过对象,不能改变,只能引用类中的静态变量

二. 组合
    组合: 给一个类的对象封装一个属性,这个属性是另一个类的对象

1. 查询顺序:

class Film2:  # 父类
    count = 2  # 类中的静态变量(类空间),...p1.count, 如果没有就继续找,没有就报错

    # Film.count, 找到这里,如果没有,在找继承的父类,找不到就报错
    def __init__(self, war_wolf, climber, kungfu_online):
        self.war_wolf = war_wolf
        self.climber = climber
        self.kungfu_online = kungfu_online

    def Movie_name(self):
        print('%s挺好看的Film2**' % self.war_wolf)


f1 = Film2('战狼**', '攀登者**', '功夫**')


class Film(Film2):  # 有继承的概念
    count = 1  # p1.count, 第二次找这里(类空间),没有就找父类的类空间

    # Film.count, 先从本空间找,没有到父类空间找
    def __init__(self, war_wolf, climber, kungfu_online, count):
        self.war_wolf = war_wolf
        self.climber = climber
        self.kungfu_online = kungfu_online
        self.count = count  # 10,  p1.count 第一次找这里(对象空间),没有就找(第二次)类空间

    def Movie_name(self):
        print("%s挺好看的Film" % self.war_wolf)

    def frind(self):
        print("你好")


p1 = Film('战狼', '攀登者', '功夫', 10)
p1.Movie_name()

print(p1.count) # 先从对象空间找,如果找不到,再从类空间找,再找不到,再从父类找...
print(Film.count)   # 类名.属性: 先从本类空间找,如果找不到,再从父类找...

Film.__dict__["frind"](123) # 可以执行
# 分析: Film.__dict__:指类中的所有内容包括函数名,
# Film.__dict__["frind"]: 在本类中的所有内容中指定了frind()函数名,
# Film.__dict__["frind"] + (),就是执行此函数,
# Film.__dict__["frind"] + (123) 因为是类名(Film)调用的函数名,所以要传参数,不传参数,会报错

# p1.__dict__['frind']()    # 不能调用函数,p1.__dict__没有frind的函数名
# 只能查看到,__init__方法中封装的属性

 

2. 组合

class Film2:
    pass
    def __init__(self, war_wolf, climber, kungfu_online):
        self.war_wolf = war_wolf
        self.climber = climber
        self.kungfu_online = kungfu_online

    def func(self,wea): # 把其他类的对象封装在这个函数里面,可以用本类的对象调用其他类的对象
        self.wea = wea

class Food:
    def __init__(self,apple, banana):
        self.apple = apple
        self.banana = banana
    def fight(self,ff):
        # print('边看电影,边吃%s' % self.apple)
        print('边看%s,边吃%s' % (ff.war_wolf,self.apple))



f1 = Film2('战狼**', '攀登者**', '功夫**')        # p1.wea = wea (axe)
f2 = Film2('战狼', '攀登者', '功夫')
F1 = Food('苹果**','香蕉**')
F2 = Food('苹果','香蕉')


f1.func(F1) # 把F1对象封装在f1的函数里面
# f1.wea.fight()    # 组合, 调用f1里面函数封装的F1对象,在调用fight函数
f1.wea.fight(f1)  # 传f1的对象 f1.wea() == F1对象
# 由F2对象调用fight函数,并且转参数f1对象
f1.wea.fight(f2)    # 传f2的对象 f1.wea() == F1对象
# 由F2对象调用fight函数,并且转参数f2对象