python018

核能来袭-类与类之间的关系 本节主要内容: 
1.依赖关系 
2.关联关系,组合关系,聚合关系 
3.继承关系,self到底是什么? 
4.类中的特殊成员 大千世界,万物之间皆有规则和规律.我们的类和对象是对大千世界中的所有事物进行归类.那事物之间存在着相对应的关系类与类之间也同样如此.面向对象 的世界中.类与类中存在以下的关系. 
1.依赖关系
2.关联关系 
3.组合关系 
4.聚合关系 
5.继承关系

一.类与类之间的依赖关系

class Elephant:
    def __init__(self,name):
        self.name=name
    def open(self,ref):
        print("大象要开门了.默念三声.关!")
        ref.open_door()
    def close(self,close):
        print("大象要关门了.默念三声.关!")
    def take(self):
        print("钻进去")
class Refrigerator:
    def open_door(self):
        print("冰箱门被打开了")
    def close_door(self):
        print("冰箱门被关上了")
r=Refrigerator()
el=Elephant("神奇的大象")
el.open(r)
el.take()
el.close(r)
此时,我们说,大象和冰箱之间就是依赖关系.我用着你.但是你不属于我.这种关系是最弱的

二.类与类之间的关联关系

二.类与类之间的关联关系
class Boy:
    def __init__(self, name, xingge, girlFriend=None):
        self.name = name
        self.xingge = xingge
        self.girlFriend = girlFriend
    def yujian(self, girl):
        self.girlFriend = girl
    def chi(self):
        if self.girlFriend:
            print("随便吃! %s 和 %s" % (self.name, self.girlFriend.name))
        else:
            print("单身狗， 吃什么吃？")
class Girl:
    def __init__(self, name ):
        self.name = name
        def chi(self):
            print("%s在吃饭" % self.name)
girl = Girl("白骨精")
alex = Boy("金王", "娘")
alex.chi()
alex.yujian(girl)
alex.chi()
#找到alex的女朋友
alex.girlFriend.name
alex.girlFriend.chi()

一个对多个.

class School:
    def __init__(self, name, address, phone):
        self.name = name
        self.address = address
        self.phone = phone
        self.__teach_list = []
    def zhaopin(self, t):
        self.__teach_list.append(t)
    def display(self):
        for el in self.__teach_list:
            print(el.name, el.hobby)
class Teacher:
    def __init__(self, name, gender, salary, hobby, school):
        self.name = name
        self.gender = gender
        self.salary = salary
        self.hobby = hobby
        self.school = school
oldboy_bj = School("北京老男孩", "美丽富饶的沙河", "10086")
oldboy_sh = School("北京老男孩， 上海分校", "上海浦东", "10010")
oldboy_sz = School("北京老男孩， 深圳分校（骑士计划)", "南山区", "10000")
t1 = Teacher("配齐", "男", 200000, "上课", oldboy_bj)
t2 = Teacher("太白", "男", 150000, "开车", oldboy_bj)
t3 = Teacher("Eggon", "男", 123456, "钻研技术", oldboy_sh)
t4 = Teacher("高鑫", "女", 45678, "相夫教子", oldboy_sz)
t5 = Teacher("日天", "男", 666, "看天", oldboy_sz)
# print(t3.school.address) # 找到老师所在的学校的地址
oldboy_bj.zhaopin(t1)
oldboy_bj.zhaopin(t2)
oldboy_bj.display()
oldboy_sh.zhaopin(t3)
oldboy_sz.zhaopin(t4)
oldboy_sz.zhaopin(t5)
oldboy_sz.display()

至于组合关系和聚合关系其实代码上差别不大.都是把另一个类的对象作为这个类的属性来传递和保存.只是在含义上会有些不同而已.

5.继承关系

    def __init__(self):
        pass
    def method(self):
        pass
        __hash__ = None
print(hash(Foo))
 print(hash(Foo()))
既然可以hash.那就是说字典的key可以是对象或者类
dic = {}
dic[Foo] = 123
dic[Foo()] = 456
print(dic)        {<class '__main__.Foo'>: 123, <__main__.Foo object at 0x000002576BA282B0>: 456}
class Base:
    def __init__(self, num):
     self.num = num
    def func1(self):
        print(self.num)
        self.func2()
    def func2(self):
        print("Base.func2")
class Foo(Base):
    def func2(self):
        print("Foo.func2")
obj = Foo(123)
obj.func1()  #123 Foo.func2
总结:self在访问方法的顺序: 永远先找自己的,自己的找不到再找父类的.

四. 类中的特殊成员 什么是特殊成员呢? __init_()就是⼀个特殊的成员.说白了.带双下划线的那一坨.这些方法在特殊的场景的时候会被自动的执行. 
比如, 1. 类名() 会自动执行__init__() 
2. 对象() 会自动执行__call__() 
3. 对象[key] 会自动执行__getitem__()
 4. 对象[key] = value 会自动执行__setitem__() 
5. del对象[key] 会自动执行 __delitem__()
 6. 对象+对象 会自动执行 __add__() 
7. with 对象 as 变量 会自动执行__enter__ 和__exit__ 
8. 打印对象的时候 会自动执行 __str__ 
9. 干掉可哈希 __hash__ == None 对象就不可哈希了. 
创建对象的真正步骤:  首先,在执行类名()的时候. 系统会自动先执行__new__()来开辟内存.此时新开辟出来的内 存区域是空的. 紧随其后, 系统动调用__init__()来完成对象的初始化工作.按照时间轴来算. 
1. 加载类
 2. 开辟内存(__new__) 
3. 初始化(__init__) 
4. 使用对象干xxxxxxxxx 类似的操作还有很多很多. 我们不需要完全刻意的去把所有的特殊成员全都记住.实战中也用不到那么多.用到查就是了.