面向对象之继承

面向对象之继承

• 动态方法与静态方法
• 面向对象的三大特质之一：继承
• 属性查找
• 多继承问题

动态方法与静态方法

1.动态方法
	1.1 绑定给对象的方法
        class Student:
          def func(self):
              print('哈哈哈')
        # 类调用对象的绑定方法:有几个参数就需要传几个参数
        Student.func(123)         # 哈哈哈
        obj1 = Student()
        # 对象调用对象的绑定方法:会自动将对象当做第一个参数传入
        obj1.func()               # 哈哈哈
	
    1.2 绑定给类的方法
    	class Student:
            @classmethod
            def func(cls):
                print(cls)
        # 类调用绑定给类的方法:会自动将类当做第一个参数传入     
        print(Student)  # <class '__main__.Student'>
        Student.func()  # <class '__main__.Student'>
        # 对象调用绑定给类的方法:也不需要传参 会讲产生该对象的类自动当做第一个参数传入
        obj1 = Student()
        obj1.func()  # <class '__main__.Student'>

2.静态方法
    class Student:
      @staticmethod
      def func(a):
          print(a)
    2.1 普普通通的函数:无论谁来调 都必须传固定的参数个数
    # 类调用静态方法:要自己传值
    Student.func(123)
    # 对象调用静态方法:要自己传值
    obj1 = Student()
    obj1.func(666)

面向对象的三大特征之一：继承

面对对象有三大特征 其中最重要的就是继承
继承、封装、多态

继承的含义

​ 现实生活中继承是用来描述人与人之间的从属关系
​ eg:儿子继承父亲 那么就可以拥有父亲的一切(别墅、豪车...)
​ 面向对象中继承则是用来描述类与类之间数据的从属关系
​ eg:类A继承了类B 那么类A就可以使用类B中所有的数据(数据、功能...)

继承的目的

​ 面向对象中通过继承可以减少代码冗余 提升开发效率 同样也支持多继承
​ eg:类A可以继承多个类同时拥有多个类里面的代码使用权
继承的基本使用

继承的基本使用

class parent_calss:  # 父类
    pass
class parent2_class:  # 子类
    pass
class child1_class(parent_calss):  # 单继承
    pass
class child_class(parent_calss, parent2_class):  # 多继承
    pass
print(child_class.__bases__)  # 通过类的内置属性__bases__可以查看类继承的所有父类

继承的本质

抽象: 由下往上抽取相同特征

继承: 由上往下直接白嫖资源

在面向对象的编程中 其实类和父类的主要功能都是用来减少代码冗余的

对象: 数据与功能的结合体

类: 多个对象相同数据和功能的结合体

父类: 多个类相同数据和功能的结合体

class Person:
    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender
class Teacher(Person):
    def teach(self):
        print(f'{self.name}老师正在讲课')
class Student(Person):
    def study(self):
        print(f'{self.name}学生正在学习')
stu1 = Student('jason', 18, 'male')
print(stu1.name,stu1.age,stu1.gender)
stu1.study()

名字的查找顺序

1.不继承的情况下

​ 名字的查找顺序是

​ 先从对象自己的名称空间中查找，没有则去类里面的名称空间查找

​ 对象 >>>>>> 类

​ 注意设置值的情况下是在自身的名称空间中添加或者修改数据

2.单继承的情况下

​ 名字的查找顺序是

​ 先从对象自己的名称空间中查找，没有 则去产生对象的类中去查找

​ 如果还没有并且类有父类则去父类中查找 以此往复下去

​ 对象 >>>>> 类 >>>>>> 父类

​ 经典案例

class A:
  def f1(self):
      print('from A.f1')
  def f2(self):
      print('from A.f2')
      self.f1()
      '''以后看到self点东西 一定要问自己self是谁'''
class MyClass(A):
   def f1(self):
        print('from MyClass.f1')
obj = MyClass()
obj.f2()

3.多继承的情况下

在python2中存在经典类与新式类
在python3中只有新式类
区分的关键在于是否继承了一个默认的object类
新式类:直接或者间接继承了object或者其子类的类
经典类:不继承任何的类

class A:
    pass
print A.__bases__  # 空的
print(A.__bases__)  # (<class 'object'>,)

有时候我们在定义类的时候会习惯的写

class MyClass(object):
    pass

目的是为了兼容python2和python3

4.菱形继承与非菱形继承

非菱形继承的情况下

​ 父类中的名字的查找顺序就是按照继承时从左往右依次查找

​ 如果多个父类还有分类那么遵循深度优先

菱形继承的情况下

​ 父类中名字的查找顺序就是按照继承时从左往右依次查找

​ 如果多个父类还有分类，那么遵循广度优先

名字的查找顺序永远都是: 先从当前对象自身开始查找

派生类

如果自己写的子类需要使用父类的方法，并且还需要基于该方法做扩展

那么这样的子类我们称之为派生类(本质还是子类)

​ 那么可以使用super关键字来实现

class Person:
    def __init__(self,name,age,gender):
        self.name = name
        self.age = age
        self.gender = gender
class Teacher(Person):
    def __init__(self,name,age,gender,level,salary):
        # 用了Person类里面的__init__方法之后
        # super(Teacher,self).__init__(name,age,gender)  # 子类调用父类的方法 完整语法
        super().__init__(name,age,gender)  # 子类调用父类的方法 精简语法
        # 自己还要添加一个额外的东西
        self.level = level
        self.salary = salary
class Student(Person):
    def __init__(self,name,age,gender,stu_id,class_id):
        # 用了Person类里面的__init__方法之后
        super().__init__(name, age, gender)
        # 自己还要添加一个额外的东西
        self.stu_id = stu_id
        self.class_id = class_id
t1 = Teacher('tony',28,'male','高级',10000)
s1 = Student('kevin',11,'female',1302010201,2)
print(t1.__dict__.values())
print(s1.__dict__.values())

派生功能前瞻

class MyClass(list):
    def append(self,args):
        if args == 123:
            print('数字123不能追加')
            return
        super(MyClass, self).append(args)
obj1 = MyClass()
obj1.append(333)
obj1.append(222)
obj1.append(123)
print(obj1)