【Python基础】史上最全||一篇博客搞懂Python面向对象编程（封装、继承、多态）

1.面向对象概念介绍

• 1.1 过程和函数（科普）
  • 过程 是早期的一个编程概念
  • 过程 类似于函数，只能执行，但是没有返回值
  • 函数 不仅能执行，还可以返回结果
• 1.2 面相过程 和 面相对象 基本概念

1) 面相过程 —— 怎么做？

1. 把完成某一个需求的 所有步骤 从头到尾 逐步实现
2. 根据开发需求，将某些 功能独立 的代码 封装 成一个又一个 函数
3. 最后完成的代码，就是顺序地调用 不同的函数
   特点
4. 注重 步骤与过程，不注重职责分工
5. 如果需求复杂，代码会变得很复杂
6. 开发复杂项目，没有固定的套路，开发难度很大！
   

2）面向对象 谁来做

相比较函数，面向对象 是 更大 的 封装，根据 职责 在 一个对象中 封装 多个方法

1. 在完成某一个需求前，首先确定 职责 —— 要做的事情（方法）
2. 根据 职责 确定不同的 对象，在 对象 内部封装不同的 方法（多个）
3. 最后完成的代码，就是顺序地让 不同的对象 调用 不同的方法
   特点
4. 注重 对象和职责，不同的对象承担不同的职责
5. 更加适合应对复杂的需求变化，是专门应对复杂项目开发，提供的固定套路
6. 需要在面向过程基础上，再学习一些面向对象的语法

2.类和对象

1. 类和对象的概念
   类 和 对象 是 面向对象编程的 两个 核心概念

2.1类

• 类 是对一群具有 相同 特征 或者 行为 的事物的一个统称，是抽象的，不能直接使用
– 特征 被称为 属性
– 行为 被称为 方法
• 类 就相当于制造飞机时的图纸，是一个 模板，是 负责创建对象的

2.2对象

• 对象 是 由类创建出来的一个具体存在，可以直接使用
• 由 哪一个类 创建出来的 对象，就拥有在 哪一个类 中定义的：

2.3类和对象的关系

• 类是模板，对象 是根据 类 这个模板创建出来的，应该 先有类，再有对象
• 类 只有一个，而 对象 可以有很多个
– 不同的对象 之间 属性 可能会各不相同
• 类 中定义了什么 属性和方法，对象 中就有什么属性和方法，不可能多，也不可能少

2.4类的设计

在使用面相对象开发前，应该首先分析需求，确定一下，程序中需要包含哪些类！
在程序开发中，要设计一个类，通常需要满足一下三个要素：
1 类名 这类事物的名字，满足大驼峰命名法
2 属性 这类事物具有什么样的特征
3 方法 这类事物具有什么样的行为

• 驼峰命名法
  CapWords
  1 每一个单词的首字母大写
  2 单词与单词之间没有下划线

• 3.1 类名的确定
  名词提炼法 分析 整个业务流程，出现的 名词，通常就是找到的类

• 3.2 属性和方法的确定
  • 对 对象的特征描述，通常可以定义成 属性
  • 对象具有的行为（动词），通常可以定义成 方法
  提示：需求中没有涉及的属性或者方法在设计类时，不需要考虑

• 实例
  
  代码：

#!/usr/bin/python
# author X_Dragon
# E-mail:3270895551@qq.com

class Person:
    def __init__(self, name, age, height):
        self.name = name
        self.age = age
        self.height = height

    def introduce(self):
        print("我是：%s，今年%d岁，身高%.2f" % (self.name, self.age, self.height))

    def run(self):
        print("%s爱跑步，跑步锻炼身体" % self.name)

    def eat(self):
        print("%s是吃货，吃完再减肥" % self.name)

xiaoming = Person("小明", 18, 180)
xiaoming.introduce()
xiaoming.run()
xiaoming.eat()
print(xiaoming)# 打印地址 0x0000015E2D92BFD0

xiaomei=Person("小美",20,168)
xiaomei.introduce()
xiaomei.run()
xiaomei.eat()
print(xiaomei) # 0x0000015E2D92BE50
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

• 运行截图
  

2.5面向对象设计案例 士兵类设计

• 需求
  
  
• 代码

#!/usr/bin/python
# author X_Dragon
# E-mail:3270895551@qq.com

class Gun:
    def __init__(self,gun_model):
        # 枪的型号
        self.model=gun_model
        # 剩余子弹
        self.bullet_count=0# 默认0
    # 填充子弹
    def Add_bullet(self,count):
        self.bullet_count+=count
    # 射击
    def Shoot(self):
        if(self.bullet_count>0):
            self.bullet_count -= 1
            print("开始射击，剩余子弹：%d"%self.bullet_count)

        else:
            print("枪没有子弹了，请填充子弹")
# 创建枪的对象 AK47
ak47=Gun("ak47")
ak47.Add_bullet(50)
ak47.Shoot()



# 开发士兵类
class Soldier:
    def __init__(self,name):
        self.name=name
        self.gun=None# 默认新兵没枪
    def fire(self):
        if(self.gun is None):
            print("%s还没有枪...."%self.name)
            return
        # 到这一步 ，满足有枪的条件
        print("冲锋......我是:[%s]"%self.name)
        # 装子弹
        print("装子弹....")
        self.gun.Add_bullet(50)
        # 发射
        self.gun.Shoot()
# 创建实例
M4=Gun("M4")
XUSANDUO=Soldier("许三多")
XUSANDUO.gun=M4# 如果是新兵 就不配枪
XUSANDUO.fire()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

• 运行：
  
• 小结：
  

2.6身份运算符

• is和==区别
  

3.私有属性和私有方法

3.1. 应用场景及定义方式

应用场景
• 在实际开发中，对象 的 某些属性或方法 可能只希望 在对象的内部被使用，而不希望在外部被访问到
• 私有属性 就是 对象 不希望公开的 属性
• 私有方法 就是 对象 不希望公开的 方法定义方式
• 在 定义属性或方法时，在 属性名或者方法名前 增加 两个下划线，定义的就是私有 属性或方法

在Python中，你可以将对象的属性设为私有属性，以防止直接访问和修改它们。要将属性设置为私有属性，通常在属性名称前面添加一个下划线前缀（单个下划线），这是一种约定，表示该属性是私有的，应该在类的内部使用，而不是在外部直接访问。虽然这不会强制阻止外部访问，但它是一种约定，告诉其他开发者应该将其视为私有属性。

下面是一个示例，演示如何在Python类中使用私有属性：

class Person:
    def __init__(self, name, age):
        self._name = name  # 前面添加下划线，表示私有属性
        self._age = age

    def introduce(self):
        print(f"我是{self._name}，今年{self._age}岁。")

    def change_name(self, new_name):
        self._name = new_name  # 类的内部可以修改私有属性

# 创建对象
xiaoming = Person("小明", 20)

# 访问私有属性
print(xiaoming._name)  # 仍然可以访问，但不建议在外部直接访问

# 通过对象方法修改私有属性
xiaoming.change_name("小红")

# 再次访问私有属性
print(xiaoming._name)  # 仍然可以访问，但不建议在外部直接访问

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

在上面的示例中，我们将 name 和 age 属性设为私有属性，添加了一个下划线前缀。虽然我们仍然可以在外部访问和修改这些属性，但是约定是在类的内部使用它们，而不要在外部直接访问。此外，我们还提供了一个对象方法 change_name，允许在类的内部修改私有属性的值。这种方法提供了更好的封装和控制，以防止意外的外部访问和修改。

• 运行
  
  如图 ，哪怕是按_命名私有了，外部对象依旧可以访问私有，那么私有怎么体验呢？CHATGPD回答：
  
  

4.继承、多态

继承的概念：子类继承父类的方法和属性

• 继承语法

1. 继承的语法
   class 类名(父类名): pass
   • 子类 继承自 父类，可以直接 享受 父类中已经封装好的方法，不需要再次开发
   • 子类 中应该根据 职责，封装 子类特有的属性和方法
2. 专业术语
   • Dog 类是Animal 类的子类，Animal 类是Dog 类的父类，Dog 类从Animal 类继承
   • Dog 类是Animal 类的派生类，Animal 类是Dog 类的基类，Dog 类从Animal 类派生
3. 继承的传递性
   • C 类从B 类继承，B 类又从A 类继承
   • 那么C 类就具有B 类和A 类的所有属性和方法
   子类 拥有 父类 以及 父类的父类 中封装的所有 属性 和 方法

• 实例

#!/usr/bin/python
# author X_Dragon
# E-mail:3270895551@qq.com
class Animal:
    def eat(self):
        print("吃-------")
    def sleep(self):
        print("睡-------")

class Dog(Animal):
    # 狗叫
    def bark(self):
        print("汪汪旺-------")
        
d=Dog()
d.bark()
d.sleep()
d.eat()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

• 运行
  
  可见 dog继承了Animal的eat、sleep类

重写

• 重写 父类方法有两种情况：
  1 覆盖 父类的方法
  2 对父类方法进行 扩展

1. 覆盖父类的方法
   • 如果在开发中，父类的方法实现 和 子类的方法实现，完全不同
   • 就可以使用 覆盖 的方式，在子类中重新编写 父类的方法实现
   具体的实现方式，就相当于在 子类中 定义了一个 和父类同名的方法并且实现

• 重写之后，在运行时，只会调用 子类中重写的方法，而不再会调用 父类封装的方法
• 2. 对父类方法进行扩展
     • 如果在开发中，子类的方法实现 中 包含父类的方法实现
     – 父类原本封装的方法实现 是 子类方法的一部分
     • 就可以使用 扩展 的方式
     a) 在子类中重写 父类的方法
     b) 在需要的位置使用super().父类方法来调用父类方法的执行
     c) 代码其他的位置针对子类的需求，编写 子类特有的代码实现
• 关于super
  • 在Python 中super 是一个 特殊的类
  • super() 就是使用super 类创建出来的对象
  • 最常 使用的场景就是在 重写父类方法时，调用 在父类中封装的方法实现
• 实例

#!/usr/bin/python
# author X_Dragon
# E-mail:3270895551@qq.com
class Animal:
    def eat(self):
        print("吃-------")
    def sleep(self):
        print("睡-------")

class Dog(Animal):
    # 狗叫
    def bark(self):
        print("汪汪旺-------")

class xiaotianquan(Dog):
    def fly(self):
        print("我会飞........")
    # 重写 bark
    def bark(self):
        print("哮天犬在咆哮........")

xtq=xiaotianquan()
xtq.bark()
xtq.fly()
xtq.sleep()
xtq.eat()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

上面实例 哮天犬就把dog类的bark重写了

父类的私有属性和私有方法

1 子类对象不能 在自己的方法内部，直接 访问父类的 私有属性 或 私有方法
2 子类对象 可以通过 父类 的 公有方法间接 访问到 私有属性 或 私有方法（父类在自己的公有方法中调用私有方法）
• 私有属性、方法 是对象的隐私，不对外公开，外界 以及 子类 都不能直接访问
• 私有属性、方法 通常用于做一些内部的事情
示例

B的对象不能直接访问 num2 属性
• B 的对象不能在demo 方法内访问 num2 属性
• B 的对象可以在demo 方法内，调用父类的test 方法
• 父类的test 方法内部，能够访问 num2 属性和 test 方法
测试代码：

class A:
    def __int__(self):
        self.num1=100
        self._num2=200
    def _test(self):
        print("这是一个内部方法")
class B(A):
    def demo(self):
        pass
b=B()
print(b)
print(b._test())
print(b._num2)


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

继承规则：

运行结果：

多进程

• Python 中的MRO —— 方法搜索顺序（知道）
  • Python 中针对 类 提供了一个 内置属性 mro 可以查看 方法 搜索顺序
  • MRO 是method resolution order，主要用于 在多继承时判断方法、属性的调用路径
  print(C. mro )输出结果
  (, , , )

• 在搜索方法时，是按照 mro 的输出结果 从左至右 的顺序查找的
• 如果在当前类中 找到方法，就直接执行，不再搜索
• 如果 没有找到，就查找下一个类 中是否有对应的方法，如果找到，就直接执行，不再搜索
• 如果找到最后一个类，还没有找到方法，程序报错

• 2.2 新式类与旧式（经典）类
  object 是Python 为所有对象提供的 基类，提供有一些内置的属性和方法，可以使用dir 函数查看
  • 新式类：以object 为基类的类，推荐使用
  • 经典类：不以object 为基类的类，不推荐使用
  • 在Python 3.x 中定义类时，如果没有指定父类，会 默认使用 object 作为该类的 基类 —— Python 3.x 中定义的类都是 新式类
  • 在Python 2.x 中定义类时，如果没有指定父类，则不会以object 作为 基类
  新式类 和 经典类 在多继承时—— 会影响到方法的搜索顺序
  为了保证编写的代码能够同时在Python 2.x 和Python 3.x 运行！ 今后在定义类时，如果没有父类，建议统一继承自object

class 类名(object): pass

Python 至少有三种不同的 MRO：

而这个 MRO 列表的构造是通过一个 C3 线性化算法来实现的。我们不去深究这个算法的数学原理,它实际上就是合并所有父类的 MRO 列表并遵循如下三条准则:

1. 子类会先于父类被检查
2. 多个父类会根据它们在列表中的顺序被检查
3. 如果对下一个类存在两个合法的选择,选择第一个父类

• 多态

面向对象三大特性
1 封装 根据 职责 将 属性 和 方法封装 到一个抽象的 类 中
– 定义类的准则
2 继承实现代码的重用，相同的代码不需要重复的编写
– 设计类的技巧
– 子类针对自己特有的需求，编写特定的代码
3 多态 不同的 子类对象 调用相同的 父类方法，产生不同的执行结果
– 多态 可以 增加代码的灵活度
– 以 继承 和 重写父类方法 为前提
– 是调用方法的技巧，不会影响到类的内部设计单一职责，开放 封闭—对扩展开放，对修改封闭

• 演示
  需求
  1 在Dog 类中封装方法game
  – 普通狗只是简单的玩耍
  2 定义XiaoTianDog 继承自Dog，并且重写game 方法
  – 哮天犬需要在天上玩耍
  3 定义Person 类，并且封装一个 和狗玩 的方法
  – 在方法内部，直接让 狗对象 调用game 方法

#!/usr/bin/python
# author X_Dragon
# E-mail:3270895551@qq.com
class Dog:
    def __init__(self,name):
        self.name=name
    def game(self):
        print("普通狗 普通玩耍 在地面哇哇哇....")
class XIAOTIANQUAN(Dog):
    def game(self):
        print("我是哮天犬，我在天上玩耍，芜湖.....")
class Person:
    def __init__(self,name):
        self.name=name
    def game(self,dog):
        print("和%s快乐玩耍"%dog.name)

wangcai=Dog("旺财")
XTQ=XIAOTIANQUAN("哮天犬")

xiaoming=Person("小明")

xiaoming.game(XTQ)


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

运行：

5.类属性和类方法

5.1 术语—— 实例

1 使用面向对象开发，第 1 步 是设计 类
2 使用 类名() 创建对象，创建对象 的动作有两步：
– 1) 在内存中为对象 分配空间
– 2) 调用初始化方法 init 为 对象初始化
3 对象创建后，内存 中就有了一个对象的 实实在在 的存在—— 实例

因此，通常也会把：
1 创建出来的 对象 叫做 类 的 实例
2 创建对象的 动作 叫做 实例化
3 对象的属性 叫做 实例属性
4 对象调用的方法 叫做 实例方法
在程序执行时：
1 对象各自拥有自己的 实例属性
2 调用对象方法，可以通过self.
– 访问自己的属性
– 调用自己的方法

• 结论
  每一个对象 都有自己 独立的内存空间，保存各自不同的属性
  • 多个对象的方法，在内存中只有一份，在调用方法时，需要把对象的引用 传递到方法内部（知道为啥要搞 self 了吧

5.21.2 类是一个特殊的对象

Python 中 一切皆对象：
• class AAA: 定义的类属于 类对象
• obj1 = AAA() 属于 实例对象
• 在程序运行时，类 同样 会被加载到内存
• 在Python 中，类 是一个特殊的对象—— 类对象
• 在程序运行时，类对象 在内存中 只有一份，使用 一个类 可以创建出 很多个对象实例
• 除了封装 实例 的 属性 和 方法外，类对象 还可以拥有自己的 属性 和 方法
d) 类属性
e) 类方法
• 通过 类名. 的方式可以 访问类的属性 或者 调用类的方法

5.3. 类属性和实例属性

• 概念和使用
  • 类属性 就是给 类对象 中定义的 属性
  • 通常用来记录 与这个类相关 的特征

• 类属性不会用于记录 具体对象的特征

5.4. 类方法和静态方法

• 类方法
  类属性 就是针对 类对象 定义的属性
  – 使用 赋值语句 在class 关键字下方可以定义 类属性
  – 类属性 用于记录 与这个类相关 的特征
  • 类方法 就是针对 类对象 定义的方法
  – 在 类方法 内部可以直接访问 类属性 或者调用其他的 类方法语法如下
  @classmethod
  def 类方法名(cls): pass

• 类方法需要用 修饰器 @classmethod 来标识，告诉解释器这是一个类方法
• 类方法的 第一个参数 应该是cls
– 由 哪一个类 调用的方法，方法内的cls 就是 哪一个类的引用
– 这个参数和 实例方法 的第一个参数是self 类似
– 提示 使用其他名称也可以，不过习惯使用cls
• 通过 类名. 调用 类方法，调用方法时，不需要传递cls 参数
• 在方法内部
– 可以通过cls. 访问类的属性
– 也可以通过cls. 调用其他的类方法示例需求

5.5静态方法

• 在开发时，如果需要在 类 中封装一个方法，这个方法：
– 既 不需要 访问 实例属性 或者调用 实例方法
– 也 不需要 访问 类属性 或者调用 类方法
• 这个时候，可以把这个方法封装成一个 静态方法，例如打印一些帮助语法如下

@staticmethod
def 静态方法名(): pass

• 静态方法 需要用 修饰器 @staticmethod 来标识，告诉解释器这是一个静态方法
• 通过 类名. 调用 静态方法

创作不易 点赞发财~~~~