Python---面向对象编程思想迁移

一、核心认知：面向过程 vs 面向对象

先明确两种编程思想的本质差异，才能理解 “迁移” 的核心逻辑：

维度	面向过程（Procedure-Oriented）	面向对象（Object-Oriented）
核心单元	函数 / 步骤（按 “做什么” 拆分）	对象（按 “谁来做” 拆分）
组织方式	线性的步骤序列（先做 A→再做 B→再做 C）	对象间的交互（对象 A 调用方法→通知对象 B 执行动作）
数据与逻辑的关系	数据和函数分离（函数操作外部数据）	数据和逻辑封装在对象内（对象自己管理数据）
适用场景	简单、一次性、无复用的小程序	复杂、需复用、易拓展的大型程序
典型例子	写一个脚本计算单个商品的折扣价	开发电商系统（商品、用户、订单等对象交互）

二、思维迁移的核心步骤

从面向过程迁移到面向对象，本质是从 “关注步骤” 转向 “关注事物（对象）”，可遵循以下 4 个步骤：

步骤 1：识别场景中的 “对象”（抽象事物）

先从业务场景中提取核心 “事物”，每个事物就是一个潜在的类：

比如 “电商下单” 场景：核心事物有「用户」「商品」「订单」；
比如 “学生成绩管理” 场景：核心事物有「学生」「课程」「成绩」。

步骤 2：定义对象的 “属性”（特征）和 “方法”（行为）

属性：描述对象的静态特征（如用户的姓名 / 手机号，商品的名称 / 价格）；
方法：描述对象的动态行为（如用户下单、商品计算折扣、订单生成）。

步骤 3：封装对象的逻辑（数据 + 方法绑定）

将对象的属性和方法封装到类中，隐藏内部细节，仅通过公开方法交互。

步骤 4：设计对象间的交互（替代线性步骤）

用对象的方法调用，替代面向过程的 “步骤序列”，实现业务逻辑。

三、实战迁移示例：从面向过程改造成面向对象

以 “商品折扣计算 + 订单生成” 为例，对比两种写法，理解迁移过程。

1. 面向过程写法（关注步骤）

python

# 面向过程：按步骤拆分，数据和函数分离 def calculate_discount(price, discount_rate): """步骤1：计算商品折扣价""" if discount_rate < 0 or discount_rate > 1: raise ValueError("折扣率必须在0-1之间") return price * discount_rate def generate_order(user_name, goods_name, original_price, discount_rate): """步骤2：生成订单""" discount_price = calculate_discount(original_price, discount_rate) order_info = { "user": user_name, "goods": goods_name, "original_price": original_price, "discount_price": discount_price, "order_time": "2026-01-08" } print(f"订单生成成功：{order_info}") return order_info # 执行步骤（线性调用） if __name__ == "__main__": # 数据是零散的，函数操作外部数据 user_name = "张三" goods_name = "Python编程书" price = 89.9 discount = 0.8 generate_order(user_name, goods_name, price, discount)

2. 面向对象改造（关注对象）

按照 “识别对象→定义属性 / 方法→封装→交互” 的步骤改造：

python

# 步骤1+2：识别对象，定义属性和方法 class Goods: """商品对象：封装商品的属性和折扣计算逻辑""" def __init__(self, name, original_price): # 封装属性：商品名称、原价 self.name = name self.original_price = original_price # 封装方法：商品自己计算折扣价（逻辑内聚） def get_discount_price(self, discount_rate): if discount_rate < 0 or discount_rate > 1: raise ValueError("折扣率必须在0-1之间") return self.original_price * discount_rate class User: """用户对象：封装用户属性""" def __init__(self, name): self.name = name class Order: """订单对象：封装订单生成逻辑""" def __init__(self, user, goods): # 封装属性：关联用户和商品对象（对象间交互） self.user = user self.goods = goods self.order_time = "2026-01-08" # 封装方法：生成订单（调用商品对象的方法） def generate(self, discount_rate): discount_price = self.goods.get_discount_price(discount_rate) order_info = { "user": self.user.name, "goods": self.goods.name, "original_price": self.goods.original_price, "discount_price": discount_price, "order_time": self.order_time } print(f"订单生成成功：{order_info}") return order_info # 步骤4：对象间交互（替代线性步骤） if __name__ == "__main__": # 创建对象（实例化） user = User("张三") goods = Goods("Python编程书", 89.9) order = Order(user, goods) # 调用对象方法完成业务（对象交互） order.generate(0.8)

3. 迁移对比分析

改造点	面向过程	面向对象
数据管理	零散的变量（user_name、price 等）	封装在对象中（user.name、goods.original_price）
逻辑归属	函数独立于数据（calculate_discount 操作外部 price）	逻辑内聚于对象（goods 自己计算折扣）
拓展性	新增 “会员折扣” 需修改 generate_order	新增 “会员折扣” 只需给 User 加属性 / 方法，Order 调用即可
复用性	函数复用需传多个参数	对象可直接复用（如多个订单用同一个商品对象）

四、迁移过程中的关键思维转变

1. 从 “写步骤” 到 “定义事物”

面向过程：先想 “第一步做什么，第二步做什么”；
面向对象：先想 “这个场景有哪些核心事物，每个事物有什么特征和行为”。

2. 从 “数据和逻辑分离” 到 “封装”

面向过程：函数接收外部数据，修改外部数据；
面向对象：对象自己管理数据，逻辑（方法）只操作自己的属性，外部仅通过方法交互。

3. 从 “硬编码依赖” 到 “对象交互”

面向过程：函数直接依赖具体的参数（如 generate_order 依赖 user_name 字符串）；
面向对象：对象依赖抽象的 “类”（Order 依赖 User 类和 Goods 类），拓展时只需新增类 / 方法，无需修改原有逻辑。

4. 从 “重复代码” 到 “继承 / 多态”（进阶）

当多个对象有相似特征 / 行为时，用继承复用代码；用多态实现 “同一行为不同表现”：

python

# 进阶：继承实现代码复用 class MemberUser(User): """会员用户（继承普通用户）""" def __init__(self, name, member_level): super().__init__(name) self.member_level = member_level # 多态：不同会员等级有不同折扣 def get_member_discount(self): if self.member_level == 1: return 0.9 elif self.member_level == 2: return 0.8 else: return 0.7 # 新增会员逻辑，原有Order类无需修改 if __name__ == "__main__": member = MemberUser("李四", 2) goods = Goods("Python编程书", 89.9) order = Order(member, goods) order.generate(member.get_member_discount()) # 直接复用原有生成逻辑