继承1.继承,2.属性查找顺序3.子类访问父类内容4.补充,经典类与新式类 --------- # 21

继承:

1.继承

1.1继承

''''''
"""
1.什么是继承?
    继承是描述两个对象之间,什么是什么的关系
    
    案例:麦兜,佩奇,猪刚鬓  --  都是猪
    
    在程序中,继承描述的是类和类之间的关系
    
    例如:a 继承 b,a就能直接使用b已经存在的方法或属性
    此时,a称之为子类,b被称之为父类,也称为基类

2.为什么要使用继承?
    继承的一方制剂使用另一方已经有的东西
    其目的是:提高重用性(重用已有的代码)
    
3.如何使用继承?
    语法:
    class 类名称(父类的名称):
    
    ps:在Python中一个子类可以继承多个父类
    查找继承顺序使用mro()列表
    print(类名称.mro())
"""
# 继承语法
class Person:  # 父类
    decs = '基类'
    def say_hi(self):
        print('fdj;kll;;jlkkl;')
class Teacher(Person):  # 子类
    pass
p = Teacher()
# 1.继承属性
print(p.decs)  # 基类
# 2.继承方法
print(p.say_hi())
# fdj;kll;;jlkkl;
# None
p.say_hi()  # fdj;kll;;jlkkl;

1.2抽象

''''''
"""
继承与抽象
    抽象:不具体不清晰,看不懂,一种概念
    继承的正确打开方式:
    方式一:
    先抽象(形成一个具有公共属性的类),
    再继承(继承抽象形成的类).
    方式二:
    继承一个现存的类,新添加新的功能
"""
# 案例1
# 抽象
# 抽取老师和学生中相同的属性,形成的类
class Person:
    def __init__(self,name,age,gender):
        self.name = name
        self.age = age
        self.gender = gender
    def say_hi(self):
        print("name:%s,age:%s,gender:%s"%(self.name,self.age,self.gender))
class Teacher(Person):
    # def __init__(self,name,age,gender):
    #     self.name = name
    #     self.age = age
    #     self.gender = gender
    # def say_hi(self):
    #     print("name:%s,age:%s,gender:%s"%(self.name,self.age,self.gender))
    pass
class Student(Person):
    def __init__(self,name,age,gender,number):
        super().__init__(name,age,gender)
        self.number = number
    def say_hi(self):
        super().say_hi()
        print("number:%s"%(self.number))

s = Student('llx','28','198','10')
s.say_hi()
"""
name:llx,age:28,gender:198
number:10
"""
# 案例2
class Teacher1:
    def __init__(self,name,age,gender):
        self.name = name
        self.age = age
        self.gender = gender
    def say_hi(self):
        print("name:%s,age:%s,gender:%s"%(self.name,self.age,self.gender))
class Student1(Teacher1):
    def __init__(self,name,age,gender,number):
        super().__init__(name,age,gender)
        self.number = number
    def say_hi(self):
        super().say_hi()
        print("number:%s"%(self.number))

s = Student1('wyf','28','198','20')
s.say_hi()
'''
name:wyf,age:28,gender:198
number:20
'''

1.3组合

''''''
"""
组合:(把类作为属性,传给另一个类)
    也是一种关系,
    表示两个对象之间是什么有什么的关系
    
    例如:学生有手机,游戏角色有装备
    
    将一个对象作为另一个对象的属性,
    即:什么有什么
    
    组合的目的:
    降低耦合度
    为了重用现有代码
    (关联起来,使用其中的方法)


"""
# 案例
class Phone:
    def __init__(self,price,app,music):
        self.price = price
        self.app = app
        self.music = music
    def tall_phone(self):
        print('price:%s,app:%s,music:%s'%(self.price,self.app,self.music))
class Student:
    # ps:把Phone类作为属性传给Student
    def __init__(self,name,age,phone):
        self.name = name
        self.age = age
        self.phone = phone
    def study(self):
        print('name%s:,age:%s,phone:%s'%(self.name,self.age,(self.phone.price,self.phone.app,self.phone.music)))
p = Phone('1998','qq音乐','风灯')
s = Student('llx','24',p)
print(s.phone.price)  # 1998
s.phone.tall_phone()  # price:1998,app:qq音乐,music:风灯
s.study()  # namellx:,age:24,phone:('1998', 'qq音乐', '风灯')

ps:继承与组合对比

''''''
"""
1.什么时候使用继承:分析两个类的关系,到底是不是:什么是什么的关系 


2.什么时候使用组合:如果两个类之间 没有太大的关系,完全不属于同类  

另外组合相比继承,耦合度更低了 
"""

1.4菱形继承--了解

''''''
"""
菱形继承--了解
    Python支持多继承
    定义:
    当一个了有多个父类,多个父类有共同基类,称为菱形继承
"""
class E:
    a = 'm'
    b = 'n'
    c = 'o'
    d = 'p'
    e = 'e'
class B(E):
    a = 'g'
    b = 'b'
class C(E):
    a = 'h'
    b = 'i'
    c = 'c'
class D(E):
    a = 'j'
    b = 'k'
    c = 'l'
    d = 'd'

class A(B,C,D):
    a = 'a'
q = A()
# 先深度,进入父类,多个父类,按广度找,最后在按深度
print(q.e) # e
print(q.d) # d
print(q.c) # c
print(q.b) # b
print(q.a) # a

# 多继承查找顺序mro()列表 -- 先深度,遇到共同父类,在广度
# ps :当出现了菱形继承时,新式类,先深度,当遇到了共同父类时就广度
# 新式类,就是深度优先
A.mro()
print(A.mro())  # [<class '__main__.A'>, <class '__main__.B'>, <class '__main__.C'>, <class '__main__.D'>, <class '__main__.E'>, <class 'object'>]

2.属性的内容

2.1属性的查找顺序
ps:mro()列表查找访问顺序
语法:print(类名称.mro())

''''''
"""
1.属性的查找顺序
    先找对象自己 --- > 自己的类 --- > 父类 --- > 父类的父类 --- > 基类(object)  
2.方法
mro()列表,查询属性的查找顺序
"""
# 案例
class A:
    text = '嘿嘿'
    txt = '数据库'
    py = '运行员'
    xml = '前端'
class B(A):
    text = '哈哈'
    txt = '文件夹'
    py = '运行'
class C(B):
    text = '娃哈哈'
    txt = '文件'
# 对象
p = C()
p.text = '嘻嘻嘻嘻'
# 1.先找对象自己
print(p.text)  # 嘻嘻嘻嘻
# 2.再找自己类
print(p.txt)  # 文件
# 3.再找父类
print(p.py)  # 运行
# 4.自找父类的父类
print(p.xml)  # 前端
# 5.自找基类
p.__init__()
print(p.__init__() )  # None

# 使用方法
print(C.mro())  # [<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>]

2.2派生

''''''
"""
派生:
    属性在子类中存在
    父类中完全没有的属性,称为派生
    
    通常子类都会新增一些功能属性,不可能和父类完全一样,都可以称为派生,
    即派生指的就是子类
"""
# 案例
class A:
    text = '嘿嘿'
    txt = '数据库'
    py = '运行员'
    xml = '前端'
    def g(self):
        print('哈哈')
class B(A):
    text = '哈哈'
    txt = '文件夹'
    py = '运行'
    def h(self):
        print('heihei')
class C(B):
    text = '娃哈哈'
    txt = '文件'
    css = 'jq'
    def f(self):
        print('嘿嘿')
# 对象
p = C()
# 1.类覆盖
p.text = '嘻嘻嘻嘻'
# 1.覆盖
print(p.text)  # 嘻嘻嘻嘻
# 2.覆盖
print(p.txt)  # 文件
# 3.覆盖
print(p.py)  # 运行
# 类派生
# 1.派生
print(p.xml)  # 前端 # 与基类做对比
# 2.派生
print(p.css)  # jq

# 对象派生
p.f()  # 嘿嘿
p.h()  # heihei
p.g()  # 哈哈

2.3覆盖

''''''
"""
覆盖:也称之为重写overrides(覆盖)
    当子类中出现与父类中完全一致的属性或方法,
    由于属性的查找顺序,
    所以父类的同名属性被覆盖
"""
class A:
    text = '嘿嘿'
    txt = '数据库'
    py = '运行员'
    xml = '前端'
    def f(self):
        print(111111)
class B(A):
    text = '哈哈'
    txt = '文件夹'
    py = '运行'
    def f(self):
        print(2222)
class C(B):
    text = '娃哈哈'
    txt = '文件'
    def f(self):
        print(3333)
# 对象
p = C()
p.text = '嘻嘻嘻嘻'
# 类属性
# 1.覆盖
print(p.text)  # 嘻嘻嘻嘻
# 2.覆盖
print(p.txt)  # 文件
# 3.覆盖
print(p.py)  # 运行
# 4.派生
print(p.xml)  # 前端

# 对象属性
p.f()  # 3333

3.子类访问父类的内容

3.1子类访问父类,三种方法

''''''
"""
子类访问父类的方法:三种方法
    1.方法一(python2)
    语法:
    super(当前类名称,self).名字(你要调的父类属性或方法)
    2.方法二(python3)
    语法:
    super().名字(你要调的父类属性或方法)
    3.方法三(直接指定类名称(你要调的父类属性或方法(self)),调用)
    指名道姓调用
    ps:指名道姓调用和继承无关

"""

3.2自定义list--MyList

''''''
# 案例
'''
结论:
    当你继承一个你现有的类,
    并且覆盖了父类的__init__(初始化,创建对象的时候触发)方法时,
    
    必须在初始化方法的'第一行'调用父类的初始化方法,并传入父类所需参数
'''
'''
继承内置list,定义我自己的mylist
'''
class MyList(list):
    def __init__(self,element_type):
        # 调用父类的初始化方法,来完成基本的初始化
        super().__init__()
        self.element_type = element_type
    def append(self, object):
        """

        :param object: 是要存储的元素
        :return:没有/None
        """
        if type(object) == self.element_type:
            # 我们需要在这里访问父类的append函数来完成真正的存储操作
            super(MyList,self).append(object)
        else:
            print("sorry sir ,your element type not is %s"%self.element_type)

# 创建指定要存储的元素类型
# m = MyList(int)
# # 当你有需求时,需要在创建对象时,干点什么事,我就该想到初始化方法
# m.append(1)
# print(m[0])  # 1
# print(m.__dict__)
# print(m) # [1]
m1 = MyList(str)
m1.append('dgggdg')
print(m1)  # ['dgggdg']
m2 = MyList(dict)
m2.append({1:'d'})
print(m2) # [{1: 'd'}]

3.3坑点 ___init__

''''''
"""
坑点:
结论:
当你继承一个现有的类,并且你要覆盖父类__init__的方法,必须,先调用下父类的__init__,赋予初始值

"""
class Person:
    def __init__(self,name,gender,age):
        self.name = name
        self.gender = gender
        self.age = age
    def say_hi(self):
        print("name:%s,gender:%s,age:%s"%(self.name,self.gender,self.age))

class Student(Person):
    def __init__(self,name,gender,age,number):
        super().__init__(name,gender,age)
        self.number = number
    def say_hi(self):
        super().say_hi()
        print("number:%s"%(self.number))
s = Student('llx','98','24','10')
print(s.__dict__)  # {'name': 'llx', 'gender': '98', 'age': '24', 'number': '10'}
s.say_hi()
# name:llx,gender:98,age:24
# number:10

4.新式类与经典类 -- 补充

4.1新式类

''''''
"""
新式类:Python3中都是新式类
新式类:任何显式或隐式中继承自object,都是新式类
"""

4.2经典类

''''''
"""
经典类:即,不是object子类,仅在Python2中出现
"""