443 lines
14 KiB
Markdown
443 lines
14 KiB
Markdown
# 面向过程
|
||
|
||
面向过程编程（Procedural Programming）是一种以**步骤和过程**为核心的编程范式，其核心思想是将复杂问题分解为一系列可顺序执行的函数或过程，通过逐步调用来实现整体功能
|
||
|
||
## 核心思想
|
||
|
||
- **步骤分解**：将问题拆解为多个子任务，每个子任务由独立的**函数/过程**实现。例如，处理学生早上的活动可分解为“起床→穿衣→洗漱→去学校”等步骤，每个步骤对应一个函数。
|
||
- **顺序执行**：程序按代码的书写顺序从上到下执行，通过**条件语句**（如if）和**循环结构**（如for）控制流程
|
||
- **数据与操作分离**：数据存储在全局或局部变量中，函数通过参数接收数据并处理，结果通过返回值或修改变量传递。
|
||
|
||
## 典型特征
|
||
|
||
- **模块化函数**：功能封装为函数，例如计算两数之和的函数 `add()`，通过调用实现代码复用。
|
||
- **线性流程**：程序逻辑清晰，易于调试。例如读取文件数据→处理数据→输出结果的流程。
|
||
- **高效性**：适用于简单任务或对性能要求高的场景，因无需对象创建开销。
|
||
|
||
# 面向对象
|
||
|
||
面向对象编程（Object-Oriented Programming，OOP）是一种以**对象**为核心的编程范式，通过模拟现实世界中事物的交互逻辑来构建程序。其核心思想是将数据与操作数据的方法封装成独立的对象，通过对象之间的协作实现复杂功能
|
||
|
||
## 核心概念
|
||
|
||
1. **类（Class）**：定义对象的模板，描述一类事物的**共性特征**（如属性）和**行为**（如方法）。例如，"汽车"类包含属性"颜色"和方法"加速"。
|
||
2. **对象（Object）**：类的具体实例，拥有独立的**状态**（属性值）和**行为**。例如，一辆红色汽车是"汽车"类的对象
|
||
3. **封装（Encapsulation）**：将数据和方法捆绑在对象内部，仅通过暴露的接口与外界交互，保护数据安全并简化使用。例如，银行账户的余额只能通过特定方法修改。
|
||
4. **继承（Inheritance）**：子类可复用父类的属性和方法，并扩展新功能，实现代码复用和逻辑分层。例如，"电动车"类继承自"汽车"类，新增"充电"方法。
|
||
5. **多态（Polymorphism）**：同一方法在不同对象中呈现不同行为，增强代码灵活性。例如，"动物"类的"发声"方法在"狗"和"猫"对象中分别输出"汪汪"和"喵喵"。
|
||
6. **抽象（Abstraction）**：提取共性特征形成接口或抽象类，隐藏复杂实现细节，例如定义"图形"类的抽象方法"计算面积"。
|
||
|
||
## 核心优势
|
||
|
||
- **可维护性**：对象间低耦合，修改某部分代码不影响整体系统。
|
||
- **可扩展性**：通过继承和多态灵活扩展功能，无需重写现有代码。
|
||
- **复用性**：封装后的类可跨项目重复使用，减少冗余代码。
|
||
- **逻辑直观**：以现实世界模型组织代码，更符合人类认知。
|
||
|
||
# 两者对比
|
||
|
||
## 面向过程—怎么做
|
||
|
||
1. 把完成某一个需求的 `所有步骤` `从头到尾` 逐步实现
|
||
2. 根据开发需求，将某些功能独立的代码封装成一个又一个函数
|
||
3. 最后完成的代码，就是顺序地调用不同的函数
|
||
|
||
注重步骤与过程，不注重职责和分工，如果需求比较复杂，虽然有函数封装，但是还是会导致代码比较臃肿。开发起来比较复杂。
|
||
|
||
<img src="初识面向对象/面向过程.png" alt="img-面向过程" style="zoom: 50%;" />
|
||
|
||
## 面向对象—谁来做
|
||
|
||
相比较函数，面向对象是更大的封装，根据职责在一个对象中封装多个方法
|
||
|
||
1. 在完成某一个需求前，首先确定职责 —— 要做的事情（方法）
|
||
2. 根据职责确定不同的对象，在对象内部封装不同的方法（多个）
|
||
3. 最后完成的代码，就是顺序地让不同的对象调用不同的方法
|
||
|
||
**特点**
|
||
|
||
1. 注重对象和职责，不同的对象承担不同的职责。
|
||
2. 更加适合应对复杂的需求变化，是专门应对复杂项目开发，提供的固定套路。
|
||
3. 需要在面向过程基础上，再学习一些面向对象的语法。
|
||
|
||
<img src="初识面向对象/植物大战僵尸.png" alt="img-植物大战僵尸" style="zoom:80%;" />
|
||
|
||
<img src="初识面向对象/植物大战僵尸类.png" alt="img-植物大战僵尸类" style="zoom:80%;" />
|
||
|
||
# 类与对象
|
||
|
||
在面向对象中，类与对象是两个核心的概念
|
||
|
||
## 类
|
||
|
||
- 类是对一群具有相同特征或者行为的事物的一个统称，是抽象的，不能直接使用
|
||
- **特征** 被称为 **属性**
|
||
- **行为** 被称为 **方法**
|
||
- 类就相当于制造飞机时的图纸，是一个模板，是负责创建对象的。
|
||
|
||
<img src="初识面向对象/飞机设计图纸.png" alt="img-飞机设计图纸" style="zoom:80%;" />
|
||
|
||
## 对象
|
||
|
||
- 对象是由类创建出来的一个具体存在，可以直接使用。
|
||
- 由哪一个类创建出来的对象，就拥有在哪一个类中定义的：属性 & 方法。
|
||
- 对象就相当于用图纸制造的飞机。
|
||
|
||
<img src="初识面向对象/飞机对象.png" alt="img-飞机对象" style="zoom: 80%;" />
|
||
|
||
## 类与对象的关系
|
||
|
||
- 类是模板，对象是根据类这个模板创建出来的，应该先有类，再有对象。
|
||
- 类只有一个，而对象可以有很多个：不同的对象之间属性可能会各不相同。
|
||
- 类中定义了什么属性和方法，对象中就有什么属性和方法，不可能多，也不可能少。
|
||
|
||
## 类的设计
|
||
|
||
在使用面相对象开发前，应该首先分析需求，确定一下，程序中需要包含哪些类
|
||
|
||
<img src="初识面向对象/植物大战僵尸类.png" alt="img-植物大战僵尸类" style="zoom:80%;" />
|
||
|
||
在程序开发中，要设计一个类，通常需要满足一下三个要素：
|
||
|
||
1. **类名** 这类事物的名字，**满足大驼峰命名法**
|
||
2. **属性** 这类事物具有什么样的特征
|
||
3. **方法** 这类事物具有什么样的行为
|
||
|
||
**大驼峰命名法**
|
||
|
||
```python
|
||
CapWords
|
||
```
|
||
|
||
**类名的确定**
|
||
|
||
通常类名的选择，我们应该根据整个业务流程来提取，或者从大的角度来选择
|
||
|
||
**属性和方法的确定**
|
||
|
||
- 对对象的特征描述，通常可以定义成属性
|
||
- 对象具有的行为，通常可以定义成方法
|
||
|
||
## 类的定义
|
||
|
||
类的基本定于语法如下：
|
||
|
||
```python
|
||
class Human:
|
||
'''
|
||
这里可以写上对于这个类的说明
|
||
'''
|
||
变量 = xxxx # 这里是类的静态属性，也可以理解为该类共有的特性
|
||
dic = {}
|
||
l1 = []
|
||
def __init__(self,xxx,xxx): # 初始化方法
|
||
pass
|
||
|
||
def func(self): # 方法，动态属性
|
||
pass
|
||
```
|
||
|
||
**示例**：
|
||
|
||
定义一个人"类"，人类有思想，并且具备姓名，年龄，身高。人类还会吃饭，还会跑步等
|
||
|
||
<img src="初识面向对象/人类.png" alt="img-人类" style="zoom:80%;" />
|
||
|
||
```python
|
||
class Human(object): # 默认继承自 object
|
||
"""
|
||
此类用来构造人类
|
||
"""
|
||
mind = "思考问题.."
|
||
def __init__(self,name,age,height):、
|
||
# 在__init__中，通过self给对象封装属性
|
||
self.name = name
|
||
self.age = age
|
||
self.height = height
|
||
|
||
def run(self):
|
||
print('高高兴兴的跑步')
|
||
|
||
def eat(self):
|
||
print('大口大口的吃饭')
|
||
```
|
||
|
||
这里的 object 和 self 的解释如下：
|
||
|
||
`object` 是 Python 中所有类的基类。它是所有用户自定义类和内置类的顶层父类。可以理解为所有的类都继承自 object 类，所以才能具备类的初始化等许多基础特性。
|
||
|
||
`self` 是一个约定俗成的参数名，用于引用类的实例。它代表当前对象的实例，使我们能够访问实例的属性和方法。
|
||
|
||
在实例方法中，第一个参数通常命名为 `self`，但你可以使用其他名称（虽然不推荐）。
|
||
|
||
## 实例化对象
|
||
|
||
通过类生成具体的对象的过程，我们称之为实例化。
|
||
|
||
```python
|
||
class Human(object): # 默认继承自 object
|
||
"""
|
||
此类用来构造人类
|
||
"""
|
||
mind = "思考问题.."
|
||
def __init__(self,name,age,height):
|
||
self.name = name
|
||
self.age = age
|
||
self.height = height
|
||
|
||
def run(self):
|
||
print('高高兴兴的跑步')
|
||
|
||
def eat(self):
|
||
print('大口大口的吃饭')
|
||
|
||
# 实例化对象
|
||
xiaoming = Human('小明',18, 173.5)
|
||
xiaohong = Human('小红',20, 165)
|
||
```
|
||
|
||
这里的小明和小红就是我们通过 Human 这个类实例化出来的具体的对象
|
||
|
||
其实实例化一个对象总共发生了三件事：
|
||
|
||
1. 在内存中开辟了一个对象空间。
|
||
2. 自动执行类中的 `__init__` 方法，并将这个对象空间（内存地址）传给了 `__init__` 方法的第一个位置参数 self。
|
||
3. 在 `__init__` 方法中通过 self 给对象空间添加属性。
|
||
|
||
|
||
**对象访问类中的属性和方法**
|
||
|
||
```python
|
||
# 访问静态属性
|
||
print(xiaoming.mind)
|
||
print(xiaohong.name)
|
||
print(xiaohong.age)
|
||
|
||
# 访问动态方法
|
||
xiaohong.run()
|
||
xiaoming.eat()
|
||
|
||
```
|
||
|
||
**查看对象的所有属性**
|
||
|
||
我们可以通过 object 基类中提供的 `__dict__` 方法来查看某个对象的属性。
|
||
|
||
```python
|
||
# 通过对象查看类中所有的属性
|
||
print(xiaoming.__dict__)
|
||
```
|
||
|
||
# 从类名的角度研究类
|
||
|
||
## 类名操作静态属性
|
||
|
||
查看类中所有的内容，用 `类名.__dict__`
|
||
|
||
```python
|
||
class Human(object): # 默认继承自 object
|
||
"""
|
||
此类用来构造人类
|
||
"""
|
||
mind = "思考问题.."
|
||
# 在__init__中，通过self给对象封装属性
|
||
def __init__(self,name,age,height):
|
||
|
||
self.name = name
|
||
self.age = age
|
||
self.height = height
|
||
|
||
def run(self):
|
||
print('高高兴兴的跑步')
|
||
|
||
def eat(self):
|
||
print('大口大口的吃饭')
|
||
|
||
print(Human.__dict__)
|
||
print(Human.__dict__['mind'])
|
||
Human.__dict__['mind'] = '高智慧'
|
||
# 通过这种方式只能查询，不能增删改
|
||
print(Human.__dict__)
|
||
|
||
```
|
||
|
||
**万能的点 `.`**
|
||
|
||
在面向对象中，我们更多的是使用 `.` 来获取类或者对象的属性或方法
|
||
|
||
```python
|
||
class Human(object): # 默认继承自 object
|
||
"""
|
||
此类用来构造人类
|
||
"""
|
||
mind = "思考问题.."
|
||
|
||
def __init__(self, name, age, height):
|
||
# 在__init__中，通过self给对象封装属性
|
||
self.name = name
|
||
self.age = age
|
||
self.height = height
|
||
|
||
def run(self):
|
||
print('高高兴兴的跑步')
|
||
|
||
def eat(self):
|
||
print('大口大口的吃饭')
|
||
|
||
|
||
print(Human.mind)
|
||
Human.mind = '高智慧'
|
||
print(Human.mind)
|
||
|
||
del Human.mind
|
||
Human.run = '慢慢悠悠的走路'
|
||
print(Human.run)
|
||
# 通过万能的点 可以增删改查类中的单个属性
|
||
print('大口大口的吃饭')
|
||
```
|
||
|
||
总结：如果想要查看类的内容，我们可以使用`__dict__`方法，如果想要操作类中的某个属性，可以使用`.`
|
||
|
||
## 类名操作动态方法
|
||
|
||
```python
|
||
class Human(object): # 默认继承自 object
|
||
"""
|
||
此类用来构造人类
|
||
"""
|
||
mind = "思考问题.."
|
||
# 在__init__中，通过self给对象封装属性
|
||
def __init__(self, name, age, height):
|
||
self.name = name
|
||
self.age = age
|
||
self.height = height
|
||
|
||
def run(self):
|
||
print(self,'高高兴兴的跑步')
|
||
|
||
def eat(self):
|
||
print(self,'大口大口的吃饭')
|
||
|
||
# 可以直接通过human调用动态方法，也可以通过dict为类内部方法传递实参
|
||
Human.eat('小明')
|
||
Human.__dict__['run']('小红')
|
||
|
||
```
|
||
|
||
# 从对象的角度研究类
|
||
|
||
## 对象操作对象属性
|
||
|
||
对象也可以通过 `__dict__` 查看对象的所有属性
|
||
|
||
|
||
```python
|
||
class Human(object): # 默认继承自 object
|
||
"""
|
||
此类用来构造人类
|
||
"""
|
||
mind = "思考问题.."
|
||
|
||
def __init__(self, name, age, height):
|
||
self.name = name
|
||
self.age = age
|
||
self.height = height
|
||
|
||
def run(self):
|
||
print('高高兴兴的跑步')
|
||
|
||
def eat(self):
|
||
print('大口大口的吃饭')
|
||
|
||
|
||
# 实例化出一个具体的对象
|
||
xiaoming = Human('小明', 18, 173.5)
|
||
xiaohong = Human('小红', 20, 165)
|
||
|
||
print(xiaoming.__dict__)
|
||
```
|
||
|
||
同样也可以使用万能的点操作对象属性
|
||
|
||
```python
|
||
class Human(object): # 默认继承自 object
|
||
"""
|
||
此类用来构造人类
|
||
"""
|
||
mind = "思考问题.."
|
||
|
||
def __init__(self, name, age, height):
|
||
self.name = name
|
||
self.age = age
|
||
self.height = height
|
||
|
||
def run(self):
|
||
print('高高兴兴的跑步')
|
||
|
||
def eat(self):
|
||
print('大口大口的吃饭')
|
||
|
||
|
||
# 实例化出一个具体的对象
|
||
xiaoming = Human('小明', 18, 173.5)
|
||
xiaohong = Human('小红', 20, 165)
|
||
|
||
# 修改属性
|
||
xiaoming.name = "小小明"
|
||
|
||
# 增加属性
|
||
xiaoming.sex = "男"
|
||
print(xiaoming.sex)
|
||
|
||
# 删除属性
|
||
del xiaoming.height
|
||
|
||
# 查看属性
|
||
print(xiaoming.__dict__)
|
||
```
|
||
|
||
## 对象查看类的属性
|
||
|
||
```python
|
||
class Human(object): # 默认继承自 object
|
||
"""
|
||
此类用来构造人类
|
||
"""
|
||
mind = "思考问题.."
|
||
|
||
def __init__(self, name, age, height):
|
||
self.name = name
|
||
self.age = age
|
||
self.height = height
|
||
|
||
def run(self):
|
||
print('高高兴兴的跑步')
|
||
|
||
def eat(self):
|
||
print('大口大口的吃饭')
|
||
|
||
|
||
# 实例化出一个具体的对象
|
||
xiaoming = Human('小明', 18, 173.5)
|
||
xiaohong = Human('小红', 20, 165)
|
||
|
||
print(xiaoming.mind)
|
||
```
|
||
|
||
# 类的内置方法
|
||
|
||
| 方法名 | 作用 |
|
||
|:-------- | :------------------------------------------- |
|
||
| `__new__` | 创建对象时，会被自动调用 |
|
||
| `__init__`| 对象被初始化时，会被自动调用 |
|
||
| `__del__` | 对象被从内存中销毁前，会被自动调用 |
|
||
| `__str__` | 返回对象的描述信息，`print` 函数输出使用 |
|
||
|`__dir__` | 查看对象内所有属性以及方法 |
|
||
|
||
# 总结
|
||
|
||
1. 现有类才有对象，类是模版，对象是通过类实例化出来的。
|
||
2. 一个类可以实例化很多个对象。
|
||
3. 类中包含静态属性和动态方法，包括内置方法，自定义方法。
|
||
4. 实例化对象的时候，会自动调用 `__init__` 来初始化，我们可以在 `__init__` 中定义对象初始化的属性
|
||
5. 实例化好的对象可以调用类中的方法或者是静态属性 |