面向对象之继承

• 动静态方法
  • 面向对象之继承理论
  • 继承基本操作
  • 对象查找名字的顺序（非常重要）
  • 继承本质
  • 基于继承的派生方法（重要）

动静态方法

1.绑定给对象的方法

# 类中定义的函数有多种特性
class Student:
    school_name = '清华大学'
    # 1.类中直接定义函数，默认绑定给对象，类调用有几个参数传几个，对象调用第一个参数就是对象自身
    def func1(self):
        print('看看谁的学校最好')
obj = Student()  # 类加括号生成一个对象赋值给obj
obj.func1()  # obj直接调用产生自己类中的函数，直接把自己地方第一个参数传入
Student.func1(123)  # 类调用自己内部函数，需要传进一个参数

2.绑定给类的方法

class Student:
    school_name = '摆烂大学'
    """
    被classmethod装饰的函数，默认绑定给类，类调用第一个参数就是类本身，类产生的对象也可以调用
    并且自动会将产生该对象的类当做第一个参数传入
    """
    @classmethod
    def func2(cls):
        print('猜猜这是谁',cls)

obj = Student()  # 产生一个对象
Student.func2()  # 类用点的方式调用内部函数，被classmethod装饰不需要传参
obj.func2()  # 类产生的对象也直接点调用，会把产生对象的类，自动传入

3.静态方法

class Student:
    school_name = '摆烂大学'

    """
    被staticmethod修饰的就是普通的函数，无论是类还是对象调用，都必须自己手动传参
    """
    @staticmethod
    def func3(a):
        print('猜猜这又是谁',a)
obj = Student()
obj.func3(1)  # 猜猜这又是谁 1
Student.func3(2)  # 猜猜这又是谁 2

面向对象之继承的概念

"""
面向对象三大特性
	分装、继承、多态
1.三者中继承最为核心（实操最多，体验感最强）
2.封装和多胎略微抽象
"""
1.继承的含义
	在现实生活中继承表示人与人之间资源的从属关系
     eg：儿子继承父亲
    在编程世界中继承表示类与类之间资源的从属关系
   		eg：类A继承类B
2.继承的目的
	在编程世界中类A继承类B就拥有了类B中所有的数据和方法使用权限
3.继承的实操
	class Son(Father):
        pass
   	1.在定义类的时候类名后面可以加括号填写其他类名，以为着继承其他类
  	 2.在python支持多继承，括号内填写多个类名彼此逗号隔开即可
     class Son(F1,F2,F3):pass
 """
 1.继承其他类的类  son
 	我们称之为子类、派生类
 2.被继承的类  Father，F1,F2,F3
 	我们称之为父类，基类，超类
 ps：我们最常用的就是父类和子类
 """

继承的本质

"""
对象：数据与功能的结合体
类（子类）：多个对象相同数据和功能的结合体
父类：多个类（子类）相同数据和功能结合体
ps：类与父类本质都是为了节省代码
"""
继承本质应该分为两部分
	抽象：将多个类相同的东西抽出去行程一个新的类
  	继承：将多个类继承刚刚取出来的新的类

名字的查找顺序

1.不继承情况下名字的查找顺序

class C1:
    name = 'jason'
    def func(self):
        print('from func')
obj = C1()  # 生成一个对象
print(obj.name)  # 在对象obj查找name的名字，自己局部没有去类中找jason
obj.name = 'kevin'  # 在obj的名称空间创建独有的名字
print(obj.name)  # 对象先在自己局部空间去找kevin
print(C1.name)  # 类C1在自己局部名称空间找name jason
"""
对象查找名字的顺序：
	1.先从自己的名称空间中查找
	2.自己没有再去产生对象的类中查找
	3.如果类中也没有，那么直接报错
对象自身>>>>	产生对象的类
"""

2.单继承情况下名字的查找顺序

class F1:
    name = 'jason'

class S1(F1):
    name = ' kevin'



obj = S1()  # 调用类S1产生一个对象
print(obj.name)
"""
对查找名字的顺序:
对象自身>>>		产生对象的类>>>>		父类
"""
class F3:
    name = 'jerry'
    pass


class F2(F3):
    name = 'tony'
    pass


class F1(F2):
    name = 'jason'
    pass


class S1(F1):
    name = 'kevin'
    pass


obj1 = S1()
obj1.name = '嘿嘿嘿'
print(obj1.name)


    class A1:
        def func1(self):
            print('from A1 func1')

        def func2(self):
            print('from A1 func2')
            self.func1()  # 这里seif指代的B1生成的对象obj，obj.func1（）
            		    #  首先在自身，再找产生他的B1类里面，所以调用的是 								B1的func1()

    class B1(A1):
        def func1(self):
            print('from B1 func1')

    obj = B1()
    obj.func2()
"""
强调：对象名字，永远从对象自身开始一步步查找
以后在看到self.名字的时候，一定要搞清楚self指代的是哪个对象

"""

3.多继承情况下名字的查找顺序

菱形继承
广度悠闲，最后再会找到闭环的定点

    class G:
        name = 'from G'
        pass
    class A(G):
        # name = 'from A'
        pass
    class B(G):
        # name = 'from B'
        pass
    class C(G):
        # name = 'from C'
        pass
    class D(A):
        # name = 'from D'
        pass
    class E(B):
        # name = 'from E'
        pass
    class F(C):
        # name = 'from F'
        pass
    class S1(D, E, F):
        pass
    obj = S1()
    print(obj.name)
"""
名字查找顺序：
	对象自身  >>>  产生对象的类  >>>  父类（从左到右，最终到闭环的起点）

"""

2.非菱形继承

​ 深度优先（从左往右每条道从完为止）

class F1:
    name = 'jason'
    pass


class F2:
    name = 'oscar'
    pass


class F3:
    name = 'jerry'
    pass


class S1(F1, F2, F3):
    name = '嘿嘿嘿'
    pass


obj = S1()
print(obj.name)
"""
名字查找顺序
对象自身	>>>		产生对象的类	>>>	父类（从左往右）
"""

mro()方法可以直接获取名字的查找顺序

经典类与新式类

"""
经典类：不继承object或者其子类的类
新式类：继承object或者其他子类的类
	在python2中有经典类和新式类
	在python3中只有新式类（所有默认都继承object）
"""
class Student(object):pass
这句话表示在定义类的时候，没有其他明确的父类，习惯写上object可以兼容python2

派生方法

子类基于父类某个方法做了扩展

class Person:
    def __init__(self, name, age, gender):
        self.name = name  # 表示在类生成的对象中添加对象独有的数据
        self.age = age
        self.gender = gender


class Student(Person):  # 子类Student，父类Person
    # 想要在子类中给父类的方法添加数据
    def __init__(self, name, age, gender, sid):
        super().__init__(name, age, gender)  # 这里表示继承父类的功能，关键字super
        self.sid = sid  # 表示在子类里面添加自己独有的方法


class Tercher(Person):
    def __init__(self, name, age, gender, lever):
        super().__init__(name, age, gender)
        self.level = lever


sth1 = Student('jason', 18, 'male', 666)
print(sth1.__dict__)  # {'name': 'jason', 'age': 18, 'gender': 'male', 'sid': 666}
tea1 = Tercher('tony', 28, 'female', 99)
print(tea1.__dict__)  # {'name': 'tony', 'age': 28, 'gender': 'female', 'level': 99}

派生方法的实战

class My_list(list):  # 父类是列表
    def append(self, values):  # 在子类里面定义一个append方法
        if values == 'jason':
            print('jason不能尾部追加')
            return
        super().append(values)  # 继承父类中append方法


obj = My_list()
print(obj, type(obj))  # 继承了父类列表，子类生成的对象也是列表
obj.append(111)
obj.append(222)
print(obj)  # [111, 222]
obj.append('jason')  
print(obj)  # # jason不能尾部追加