Python 面向对象（一）：从概念到实践-CSDN博客

本文链接：https://blog.csdn.net/weixin_65516460/article/details/149332684

Python 面向对象（一）：从概念到实践

作为编程领域的重要范式，面向对象编程（Object-Oriented Programming，简称 OOP）彻底改变了我们编写和组织代码的方式。对于 Python 开发者来说，掌握面向对象思想不仅能提升代码质量，更能让程序设计变得更贴近现实世界的逻辑。今天这篇文章，我们就从基础概念出发，一步步揭开 Python 面向对象编程的神秘面纱。

一、什么是面向对象编程？

在面向对象的世界里，我们将现实中的事物抽象为 “对象”，每个对象都包含两部分：

属性：事物的特征（比如人的年龄、姓名，汽车的颜色、型号）

方法：事物的行为（比如人会走路、说话，汽车会行驶、鸣笛）

这种思想的核心是 “以对象为中心”，通过对象之间的交互来完成业务逻辑，就像现实世界中不同事物协同工作一样。

举个简单的例子：如果我们要开发一个学生管理系统，用面向对象的思路会先定义 “学生” 这个对象，包含 “学号、姓名、成绩” 等属性，以及 “上课、考试、交作业” 等方法，而不是像面向过程那样单纯用函数和变量堆砌逻辑。

二、面向对象的四大核心优势

1. 封装：数据安全的 “保护罩”

封装指的是将数据（属性）和操作数据的方法捆绑在一起，对外隐藏内部实现细节，只暴露必要的接口。这样可以防止外部代码随意修改对象内部数据，保证数据的安全性和一致性。

class BookStore:

def __init__(self, store_name, initial_cash=0):

self.store_name = store_name # 公开属性：书店名称

self.__cash = initial_cash # 私有属性：营业额（双下划线开头）

# 公开方法：记录销售额

def record_sale(self, amount):

if amount > 0:

self.__cash += amount

print(f"{self.store_name}销售额增加{amount}元，当前总营业额：{self.__cash}元")

else:

print("销售额不能为负数")

# 公开方法：查询营业额（带权限验证）

def check_cash(self, password):

if password == "admin123":

return f"当前营业额：{self.__cash}元"

else:

return "密码错误，无权查询"

# 使用示例

my_store = BookStore("知阅书店", 1000)

my_store.record_sale(350) # 知阅书店销售额增加350元，当前总营业额：1350元

my_store.record_sale(-50) # 销售额不能为负数

print(my_store.check_cash("admin123")) # 当前营业额：1350元

print(my_store.__cash) # 报错！无法直接访问私有属性

在这个例子中，书店营业额__cash被设为私有属性，外部无法直接修改，只能通过record_sale方法记录销售额，且查询营业额需要密码验证，充分体现了封装对数据安全的保护。

2. 继承：站在巨人肩膀上的编程

继承允许我们创建新类（子类）时，直接复用已有类（父类）的属性和方法，同时可以添加新功能或修改原有功能。这大大减少了代码重复，提高了开发效率。

# 父类：交通工具

class Vehicle:

def __init__(self, brand, color):

self.brand = brand # 品牌

self.color = color # 颜色

def move(self):

print(f"{self.color}的{self.brand}正在移动")

# 子类：自行车（继承自交通工具）

class Bicycle(Vehicle):

# 重写父类方法

def move(self):

print(f"{self.color}的{self.brand}自行车，蹬着脚踏板前进")

# 子类特有方法

def ring_bell(self):

print(f"{self.brand}自行车铃铃铃响")

# 子类：电动车（继承自交通工具）

class ElectricCar(Vehicle):

def __init__(self, brand, color, battery_capacity):

# 调用父类构造方法

super().__init__(brand, color)

self.battery_capacity = battery_capacity # 电池容量（新增属性）

def move(self):

print(f"{self.color}的{self.brand}电动车，安静地行驶")

# 子类特有方法

def charge(self):

print(f"{self.brand}电动车正在充电，当前电池容量{self.battery_capacity}Ah")

# 使用示例

bike = Bicycle("永久", "蓝色")

bike.move() # 蓝色的永久自行车，蹬着脚踏板前进

bike.ring_bell() # 永久自行车铃铃铃响

ecar = ElectricCar("小牛", "白色", 20)

ecar.move() # 白色的小牛电动车，安静地行驶

ecar.charge() # 小牛电动车正在充电，当前电池容量20Ah

这里Bicycle和ElectricCar都继承了Vehicle类的brand、color属性和move方法，但又根据自身特点重写了move方法并添加了新方法，体现了 “继承复用，差异重写” 的核心思想。

3. 多态：同一种行为的不同表现

多态指的是同一方法在不同对象上会表现出不同的行为。当子类重写父类方法后，调用相同的方法名，会根据对象类型执行不同的实现。

# 基于上面的Vehicle、Bicycle、ElectricCar类

def start_move(vehicle):

# 接收Vehicle类型的参数，调用其移动方法

vehicle.move()

# 多态体现：同样调用start_move，传入不同对象表现不同

bike = Bicycle("凤凰", "红色")

ecar = ElectricCar("雅迪", "黑色", 15)

start_move(bike) # 红色的凤凰自行车，蹬着脚踏板前进

start_move(ecar) # 黑色的雅迪电动车，安静地行驶

多态让代码更加灵活，我们可以编写通用的start_move函数来处理所有交通工具，无需关心具体是哪种车型。如果后续需要添加 “摩托车” 类，只需让它继承Vehicle并重写move方法，start_move函数无需任何修改就能正常工作。

4. 可维护性与可扩展性：代码的 “长寿秘诀”

封装、继承、多态共同作用，使得面向对象的代码具有极强的可维护性和可扩展性。当需求变更时，我们只需要修改相关类的内部实现，或者新增子类，而不需要大面积重构代码。

例如，要给交通工具系统添加 “共享单车” 类型，只需新增SharedBike类继承Bicycle，添加特有功能即可，原有代码无需修改：

class SharedBike(Bicycle):

def __init__(self, brand, color, bike_id):

super().__init__(brand, color)

self.bike_id = bike_id # 单车编号

self.is_locked = True # 是否上锁

# 新增扫码解锁方法

def scan_to_unlock(self):

self.is_locked = False

print(f"共享单车{self.bike_id}已解锁，可骑行")

# 使用新类

shared_bike = SharedBike("哈啰", "黄色", "8675309")

shared_bike.scan_to_unlock() # 共享单车8675309已解锁，可骑行

shared_bike.move() # 黄色的哈啰自行车，蹬着脚踏板前进

这种 “开 - 闭原则”（对扩展开放，对修改关闭）是面向对象设计的重要准则，能让代码在长期维护中保持稳定。

三、类与实例：面向对象的基本单元

类的定义与实例创建

类（Class）：是对象的模板，定义了对象的属性和方法（可以理解为 “图纸”）

实例（Instance）：是类创建的具体对象（可以理解为 “用图纸造出的实物”）

语法格式：

# 定义类

class 类名:

# 属性和方法定义

# 创建实例

实例名 = 类名(参数)

示例：

class Fruit:

# 类体（后续会添加属性和方法）

pass

# 创建两个水果实例

apple = Fruit()

banana = Fruit()

print(type(apple)) # 输出：<class '__main__.Fruit'>，说明是Fruit类的实例

实例属性与实例方法

实例属性：每个实例独有的属性，通过self.属性名定义在类的方法中。

实例方法：定义在类中，第一个参数必须是self的函数，用于操作实例属性。self代表调用该方法的实例本身。

class Fruit:

# 实例方法：设置水果信息

def set_details(self, name, weight, is_ripe):

self.name = name # 水果名称

self.weight = weight # 重量（克）

self.is_ripe = is_ripe # 是否成熟

# 实例方法：展示水果状态

def show_status(self):

ripe_status = "已成熟" if self.is_ripe else "未成熟"

print(f"{self.name}，重量{self.weight}克，{ripe_status}")

# 使用示例

apple = Fruit()

apple.set_details("红富士苹果", 250, True)

apple.show_status() # 红富士苹果，重量250克，已成熟

banana = Fruit()

banana.set_details("香蕉", 150, False)

banana.show_status() # 香蕉，重量150克，未成熟

注意：调用实例方法时，不需要手动传递self参数，Python 会自动将实例本身作为self传入。比如apple.set_details(...)中，self就代表apple这个实例。

构造方法init：实例的 “出生证明”

__init__方法是一种特殊的实例方法，用于在创建实例时自动初始化属性，相当于对象的 “构造函数”。

class Fruit:

# 构造方法：创建实例时自动调用

def __init__(self, name, weight, is_ripe):

self.name = name

self.weight = weight

self.is_ripe = is_ripe

def show_status(self):

ripe_status = "已成熟" if self.is_ripe else "未成熟"

print(f"{self.name}，重量{self.weight}克，{ripe_status}")

# 创建实例时必须传入__init__方法要求的参数（除self外）

orange = Fruit("橙子", 200, True)

orange.show_status() # 橙子，重量200克，已成熟

关于__init__的重要说明：

第一个参数永远是self，代表当前创建的实例

创建实例时，参数会自动传递给__init__方法

实例属性必须通过self绑定，否则只是局部变量

如果不定义__init__，Python 会提供一个默认的无参构造方法

四、类对象、类属性与类方法

在 Python 中 “一切皆对象”，类本身也是一种对象（称为类对象）。类对象拥有自己的属性和方法：

类属性：所有实例共享的属性

类属性定义在类体中，不在任何方法内，所有实例都可以访问，修改类属性会影响所有实例。

class Library:

# 类属性：所有图书馆实例共享的属性

category = "公共文化设施" # 设施类别

def __init__(self, name, location):

self.name = name # 实例属性：图书馆名称

self.location = location # 实例属性：位置

# 创建实例

lib1 = Library("市图书馆", " downtown")

lib2 = Library("区图书馆", "西城区")

# 访问类属性

print(lib1.category) # 输出：公共文化设施（通过实例访问）

print(Library.category) # 输出：公共文化设施（通过类访问，推荐）

# 修改类属性

Library.category = "公益文化场馆"

print(lib2.category) # 输出：公益文化场馆（所有实例都受影响）

类方法：操作类属性的方法

类方法用@classmethod装饰，第一个参数是cls（代表类对象本身），用于操作类属性。

class Library:

category = "公共文化设施"

def __init__(self, name, location):

self.name = name

self.location = location

# 类方法：修改设施类别

@classmethod

def update_category(cls, new_category):

cls.category = new_category

print(f"设施类别已更新为：{cls.category}")

# 使用类方法

Library.update_category("文化服务场馆") # 设施类别已更新为：文化服务场馆

print(Library.category) # 输出：文化服务场馆

静态方法：类中的 “工具函数”

静态方法用@staticmethod装饰，不需要self或cls参数，更像是类里的普通函数，通常用于实现与类相关但不依赖类属性或实例属性的功能。

class WeatherUtil:

# 静态方法：根据温度判断是否适合户外活动

@staticmethod

def is_suitable(temperature):

if 15 <= temperature <= 25:

return "温度适宜，适合户外活动"

elif temperature < 15:

return "温度较低，建议保暖"

else:

return "温度较高，注意防暑"

# 调用静态方法（无需创建实例）

print(WeatherUtil.is_suitable(22)) # 温度适宜，适合户外活动

print(WeatherUtil.is_suitable(30)) # 温度较高，注意防暑