小白学python系列————【Day43】面向对象三大特性之继承以及类的派生方法

本文链接：https://blog.csdn.net/DiligentGG/article/details/126021362

今日内容概要

对象独有的功能
动静态方法
面向对象三大特性之继承
继承的本质
数据和方法的查找顺序
经典类与新式类
派生方法

对象独有的功能

1.针对对象独有的方法，我们无法真正实现：
（1）如果在全局则不是独有的；
（2）如果在类中则是公共的
在python中存在一个特性，相当于是对象独有的方法，就是定义在类中的函数默认都是绑定给对象的。

2.举个栗子

class Person:
   h_type = '人类'

   def __init__(self, name):  # 让对象拥有独有的数据
       self.name = name
   # 定义在类中的函数 我们称之为方法
   def eat(self):  # 是多个对象公共的方法 也算多个对象独有的方法  对象来调用就会将对象当做第一个参数传入
       print('%s正在干饭'%self.name)

   def others(self,a,b):
       print('others哈哈哈')
p1 = Person('jason')
p1.eat()  # eat(p1)     # jason正在干饭
p2 = Person('kevin')
p2.eat()  # eat(p2)     # kevin正在干饭
# 如何理解绑定二字
p3 = Person('oscar')
Person.eat(p3)          # oscar正在干饭

p1 = Person('jason')
p1.others(1, 2)       # others哈哈哈

Person.others(p1,1,2)    # others哈哈哈

动静态方法

动静态方法有三种类型，主要是专门针对在类体代码中编写的函数

1.绑定给对象的方法；
（1）直接在类体代码中编写即可；
（2）对象调用会自动将对象当做第一个参数传入；
（3）类调用则有几个形参就传几个实参。
class Student:
   school = '清华大学'
   # 绑定给对象的方法
   def run(self):  # self用于接收对象
       print('老六赶紧跑!!!', self)
stu1 = Student()

2.绑定给类的方法：
类的调用会自动将类当做第一个参数传入

class Student:
   school = '清华大学'
   # 绑定给对象的方法
   def run(self):  # self用于接收对象
       print('老六赶紧跑!!!', self)

   @classmethod  # 绑定给类的方法
   def eat(cls):  # cls用于接收类
       print('老六你可真有才', cls)
stu1 = Student()
# 调用绑定给类的方法
Student.eat()  # 类调用会自动将类当做第一个参数传入    >eat(Student)
''' 老六你可真有才 <class '__main__.Student'>'''
stu1.eat()  # 对象调用会自动将产生该对象的类当做第一个参数传入  >eat(Student)
'''老六你可真有才 <class '__main__.Student'>'''

3,静态方法(普普通通的函数)

class Student:
   school = '清华大学'
   @staticmethod  # 静态方法
   def sleep(a, b):  # 无论谁来调用都必须按照普普通通的函数传参方式
       print('老六快去睡觉吧')
stu1 = Student()
# 调用静态方法
# 类调用
Student.sleep(1,2)
# 对象调用
stu1.sleep(1, 2)

面向对象三大特性之继承

1.面向对象三大特性：
继承；封装；多态

2.继承的含义
（1）在现实生活中继承其实就是用来描述人与人之间资源的关系
eg:儿子继承父亲的财产(拥有了父亲所有的资源)
（2）在编程世界里继承其实就是用来描述类与类之间数据的关系
eg:类A继承类B(拥有了类B里面所有的数据和功能)

3.继承的目的
（1）现实生活中继承就是想占有别人的财产
eg:亲身父亲干爹干妈富婆
（2）编程世界里继承就是为了节省代码编写
eg:可以继承一个类也可以继承多个类

4.继承的操作
class 类名（父类）:
	pass
（1）定义类的时候在类名后加括号；
（2）括号内填写你需要继承的类名；
（3）括号内可以填写多个父类，逗号隔开即可
举个栗子
# 父类
class Father:
   money = 1000000000


   def run(self):
     print('豪车别墅')

# 子类
class Son(Father):
   pass
print(Son.money)   # 1000000000
Son.run(11)     # 豪车别墅

5.继承类的说明
（1）我们将被继承的类称之为: 父类或基类或超类；
（2）我们将继承类的类称之为: 子类或派生类；

6.查找父类要按括号内从左到右查找
自己里面有的话就不在去父类索取

class F1:
   name = 'from f1'

class F2:
   name = 'from f2'

class F3:
   name = 'from f3'

class MyClass(F1,F2,F3):
   pass
print(MyClass.name)
# from f1----> from f2----> from f3

请添加图片描述

继承的本质

1.抽象和继承
抽象:将多个类共同的数据或功能抽取出来形成一个基类
继承:从上往下白嫖各个基类里面的资源

2,举个栗子：

class Person:
   def __init__(self,name,age,gender):
       self.name = name
       self.age = age
       self.gender = gender
class Teacher(Person):
   def teach_course(self):
       print('老师上课')
class Student(Teacher):
   def choice_course(self):
       print('学生选课')
stu1 = Student('jason',18,'male')
print(stu1.__dict__)
# {'name': 'jason', 'age': 18, 'gender': 'male'}

3.形成对比
对象:数据和功能的结合体
类:多个对象相同的数据和功能的结合体
父类:多个类相同的数据和功能的结合体

名字的查找顺序

敲重点！！！主要涉及到对象查找名字那么几乎都是：
对象自身类父类

1.不继承的情况下名字的查找顺序
先从对象自身查找，没有的话再去产生该对象的类中查找
对象 >>> 类

class Student:
   school = '清华大学'
   def choice_course(self):
       print('正在选课')
stu1 = Student()
print(stu1.school)  # 对象查找school 自身名称空间没有 所以查找的是类的  清华大学
stu1.school = '北京大学'  # 在自身的名称空间中产生了新的school
"""对象点名字并写了赋值符号和数据值 那么操作的肯定是自己的名称空间"""
print(stu1.school)  # 北京大学
print(Student.school)  # 清华大学

2.单继承的情况下名字的查找顺序
先从对象自身查找，然后是产生该对象的类，然后是一个个父类
对象 >>> 类 >>> 父类…
eg1:

class A:
   name = 'from A'
   pass
class B(A):
   # name = 'from B'
   pass
class C(B):
   # name = 'from C'
   pass
class MyClass(C):
   # name = 'from MyClass'
   pass
obj = MyClass()
# obj.name = '我很困!!!'
print(obj.name)

'''from A'''

请添加图片描述

只要涉及到对象查找名字几乎要回到最开始的位置依次查找
eg2:

class A1:
   def func1(self):
       print('from A1 func1')
   def func2(self):
       print('from A1 func2')
       self.func1()  # obj.func1()
class MyClass(A1):
   def func1(self):
       print('from MyClass func1')
obj = MyClass()
obj.func2()
'''
from A1 func2
from MyClass func1
'''

3.多继承的情况下名字的查找顺序
（1）非菱形继承(最后不会归总到一个我们自定义类上)
深度优先(每个分支都走到底再切换)

（2）菱形继承(最后归总到一个我们自定义类上)
广度优先(前面几个分支都不会走最后一个类最后一个分支才会走)

特别注意:可以使用类点mro()方法查看该类产生的对象名字的查找顺序

经典类与新式类

1.概念说明
（1）经典类
不继承object或其子类的类(什么都不继承)
（2）新式类
继承了object或其子类的类

2.不同解释器中说明
（1）在python3中所有的类默认都会继承object
也就意味着python3里面只有新式类
（2）在python2中有经典类和新式类
由于经典类没有核心的功能所以到了python3直接砍掉了

3.推荐用法
以后我们在定义类的时候，如果没有想要继承的父类，一般推荐以下写法：
class MyClass(object):
      pass
其目的是为了兼容python2

派生方法

子类中定义类与父类一模一样的方法并且扩展了该功能>>>:派生

1.派生的作用——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):
       super().__init__(name,age,gender)   # super专门用于子类调用父类的方法
       self.level = level     # 自己补充一些的
class Student(Person):
   pass

2.派生的实例对列表添加数据做作业一些改动。

class MyClass(list):
   def append(self, value):  # []  截胡
       if value == 'jason':
           print('jason不能添加')  # 输出
           return
       super().append(value)


obj = MyClass()  # 产生一个对象  []
obj.append('jason')
obj.append(111)
obj.append(222)
obj.append(333)
print(obj)  # [111, 222, 333]
print(MyClass.mro())  # 查看该类产生的对象名字的查找顺序

"""
jason不能添加
[111, 222, 333]
[<class '__main__.MyClass'>, <class 'list'>, <class 'object'>]
"""