python基础-day20

# 如果两个选择，
# 1，BAT等大公司，工资低些，
# 2，小公司，工资高些，
# 分析：BAT等公司，可以帮你镀金，你在公司的职责更多是螺丝钉，而且你升级为核心人员比较难，也就是说你离职的可能比较大，
# 小公司，你反而比较有机会做核心业务，重要位置，

# 我打印的是__dict__信息，里面的信息是以字典的形式存在的，
# 注意看__doc__,这是说明信息，你可以理解为文档说明，
# 我主要想说明，原来这个信息，以这种信息存在与这里，帮助你理解python如何处理我们定义的函数or类的信息，

这张图主要是想说明，
在继承中，__init__()方法，
是如何继承的，
ps：补充说下，init方法的执行顺序，父类的先执行，子类的后执行，通过添加print语句可以看出；这个也符合抽象从上往下，具体从下往上？？

# 这张图是想说，我们在实例化一个子类对象，
# 在图中标识的init方法中的self，都是指alex，
# 虽然父类的方法并没有客观存在与子类中，
# 但是你可以这样理解，父类的构造方法，就在子类中，
# 不过由于python一切皆是引用，同样的方法，多次使用，只需要知道这个方法的地址就可以了，！！！底层的东西，对错也说不清，凭感觉吧？？？

# 派生属性and派生方法，
# 就是子类在继承了父类之后，
# 又为自己添加了一些其它属性or方法，

# 这里主要讲了，子类调用父类__init__()方法的不同写法，
# 最开始：Animal.__init__(self,name,hp,ad)，白话就是：父类类调用init方法，并向其中传入参数，
# 下面是两种不同的写法，第二种是最简的，
# super(Person,self).__init__(name,hp,ad)
# super().__init__(name,hp,ad)
# ps：图片中最后一种使用方式，是OK的，但是应该没人会这么用吧？

class Animal:
    def __init__(self,name,hp,ad):
        self.name = name
        self.hp = hp
        self.ad = ad
    def eat(self):
        print(self.name,'eating in Animal')
        self.hp += 20

class Person(Animal):
    def __init__(self,name,hp,ad,sex):
        super().__init__(name,hp,ad)
        self.sex = sex
        self.money = 100
    def attack(self,dog):
        print("%s攻击了%s"%(self.name,dog.name))
    def eat(self):
        super().eat()
        print('eating in Person')
        self.money -= 50

alex = Person('alex', 100, 10, 'female')

Animal.eat(alex)            # 若子类中定义了与父类同样的方法，此时你再调用，就是子类的方法，
super(Person,alex).eat()    # 但是又想调用父类的方法，可以这样写，
# alex eating in Animal
# alex eating in Animal


# ps:
# 子类中创造了父类中没有的，叫派生，
# 子类中写出了与父类中同样的方法，叫重写，

上面是单继承，

下面要开始讲多继承了，

class A:
    def func(self):
        print('A')

class B(A):
    def func(self):
        print('B')

class C(B):
    def func(self):
        print('C')

print(C.mro())
#打印结果：注意最后还有个object.
# [<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>]

# 上面这张图和下面这张，应该说的就是同一个，
# 只不过下面那个标出了，继承方向，

class A(object):
    def func(self):
        print('A')

class B(A):
    def func(self):
        print('B')

class C(A):
    def func(self):
        print('C')

class D(B,C):   #注意这里D类中继承父类书写的顺序！！！
    def func(self):
        print('D')

print(D.mro())
#打印结果：
# 如果D(C,B),打印如下：
# [<class '__main__.D'>, <class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>]
# 如果D(B,C)打印如下：
# [<class '__main__.D'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.A'>, <class 'object'>]

# 新式类 多继承 寻找名字的顺序 遵循广度优先
class A:
    def func(self):
        print('A')
class B(A):
    def func(self):
        super().func()
        print('B')
class C(A):
    def func(self):
        super().func()
        print('C')
class D(B,C):
    def func(self):
        super().func()   # B
        print('D')

d = D()
d.func()
#结果有两个可能你觉得奇怪的，
#1，A类方法先出结果，那是因为每个类都一直在向上调用父类方法，并且你是先调用，后打印，！！！这个过程有必要想清楚
#2.super在你最初的印象中，是指向父类，而在多继承这里，其实也还是指向父类，只不过对何为父类的定义变了，
#ps:在单继承类似直线的情况下，父类必定是单纯的向上；
#而在多继承中，因为其排序依据是数据结构中的图，所以这个父类就得按图的规则来办事

#打印结果：
# A
# C
# B
# D
# super():
    # 在单继承中就是单纯的寻找父类
    # 在多继承中就是根据子节点 所在图 的 mro顺序找寻下一个类
# 遇到多继承和super
    # 对象.方法
        # 找到这个对象对应的类
        # 将这个类的所有父类都找到画成一个图
        # 根据图写出广度优先的顺序
        # 再看代码，看代码的时候要根据广度优先顺序图来找对应的super

# coding:utf-8
class A(object):
    pass
    # def func(self):
    #     print('A')
class B(A):
    pass
    # def func(self):
    #     print('B')
class C(A):
    def func(self):
        print('C')
class D(B,C):
    def func(self):
        super(D,self).func()
        print('D')

print(D.mro())
# 经典类 :在python2.*版本才存在,且必须不继承object
    # 遍历的时候遵循深度优先算法
    # 没有mro方法
    # 没有super()方法
# 新式类 :在python2.X的版本中，需要继承object才是新式类
    # 遍历的时候遵循广度优先算法
    # 在新式类中，有mro方法
    # 有super方法,但是在2.X版本的解释器中，必须传参数(子类名，子类对象)
d = D()
d.func()

#下面的整理,与前面有重复的,不过多一点总比少点好,
# 在py3中，都是新式类，
# 在py2中，你得手动继承自object，才是新式类，否则就是经典类，

# 经典类，
# 没有mro帮助我们看多继承的关系，ps：能不能这样理解，因为深度优先很好找，所以没有这个mro方法？
# 没有super，
# 并且是深度优先的，
#
# 关于广度优先搜索，
# 有个大原则，找得到的不着急找，具体表现就是，类A是下面几个类都会继承的，反正最后都会找到它，所以它在最后一次才被真正找到！！！
#
# 刚还在想，若是这种方式定义多继承的类，真是晕死了，
# 其实呢，现实中是不会这样定义的，因为这样做纯粹就是给自己挖坑，
# 关于mro，面试才会遇到，