如果说函数式编程像是按照食谱一步步做菜，那么面向对象编程 (Object-Oriented Programming, OOP) 就像是管理一个餐厅。你需要设计不同的角色（厨师、服务员、经理），赋予他们职责，并让他们协同工作。
在 Python 中，OOP 的三大支柱是：类、封装和继承（还有多态，本文暂不展开）。掌握它们，你就能构建出结构清晰、易于扩展的大型程序。
- 类 (Class) 与 对象 (Object)：图纸与房子
这是 OOP 的起点。
类 (Class)：是图纸或模板。它定义了一类事物应该具备的属性（数据）和行为（函数）。
对象 (Object)：是根据图纸盖出来的房子，也就是类的实例。
代码示例
我们要设计一个简单的游戏角色系统。首先定义一个“玩家”类。
class Player:
# init 是初始化方法（构造函数），创建对象时自动调用
def init(self, name, profession):
# 属性 (Attributes)：数据
self.name = name
self.profession = profession
self.hp = 100 # 初始血量
# 方法 (Methods)：行为
def attack(self, enemy_name):print(f"{self.name} ({self.profession}) 攻击了 {enemy_name}！")
创建对象 (实例化)
p1 = Player("亚瑟", "战士")
p2 = Player("安吉拉", "法师")
使用对象的属性和方法
print(f"玩家1: {p1.name}, 血量: {p1.hp}")
p1.attack("小怪兽")
核心点：
class 关键字定义类。
self 代表对象本身。当 p1 调用方法时，self 就是 p1。
- 封装 (Encapsulation)：保护你的隐私
想象一下你的银行账户。你肯定不希望任何人都能随意直接修改你的余额数字（比如 account.balance = 9999999）。你希望他们通过正规渠道（存款、取款）来改变余额，这样银行才能检查操作是否合法。
封装的目的就是：隐藏对象的内部细节，只暴露必要的接口。
在 Python 中，我们通过在属性名前加两个下划线 __ 来将其设为“私有”。
代码示例
class BankAccount:
def init(self, owner, balance):
self.owner = owner
self.__balance = balance # 私有属性，外部无法直接访问
def deposit(self, amount):if amount > 0:self.__balance += amountprint(f"存款成功，当前余额: {self.__balance}")else:print("存款金额必须大于0")def withdraw(self, amount):if 0 < amount <= self.__balance:self.__balance -= amountprint(f"取款成功，当前余额: {self.__balance}")else:print("余额不足或金额无效")# 如果非要读取余额，可以提供一个只读接口
def get_balance(self):return self.__balance
使用
my_account = BankAccount("Tom", 1000)
my_account.deposit(500)
my_account.withdraw(200)
尝试直接修改私有属性（会报错或无效，取决于访问方式）
print(my_account.__balance) # 报错！AttributeError
my_account.__balance = 1000000 # 这只是给对象动态加了个新属性，并没有修改内部真正的私有余额
print(f"查询余额: {my_account.get_balance()}")
核心点：
安全：防止外部代码随意篡改内部数据。
可控：通过方法（如 deposit）修改数据，可以在方法里加入逻辑判断（如金额不能为负）。
- 继承 (Inheritance)：不要重复造轮子
假设你要设计 Cat（猫）和 Dog（狗）两个类。
猫有：名字、年龄、吃东西、喵喵叫。
狗有：名字、年龄、吃东西、汪汪叫。
你会发现，“名字、年龄、吃东西”是重复的代码。继承允许我们创建一个通用的父类（比如 Animal），然后让 Cat 和 Dog 作为子类去继承它。子类自动拥有父类的所有功能，且可以扩展自己的功能。
代码示例
1. 定义父类
class Animal:
def init(self, name):
self.name = name
def eat(self):print(f"{self.name} 正在大口吃东西...")def speak(self):print(f"{self.name} 发出了叫声")
2. 定义子类 Dog，继承自 Animal
class Dog(Animal):
def speak(self):
# 重写 (Override) 父类的方法
print(f"{self.name} 汪汪叫！")
def guard_house(self):# 子类独有的方法print(f"{self.name} 正在看家护院")
3. 定义子类 Cat，继承自 Animal
class Cat(Animal):
def speak(self):
print(f"{self.name} 喵喵叫~")
使用
dog = Dog("旺财")
cat = Cat("咪咪")
调用继承来的方法
dog.eat() # 这里的 eat 是从 Animal 继承来的
cat.eat()
调用重写后的方法
dog.speak() # 汪汪叫
cat.speak() # 喵喵叫
调用子类独有的方法
dog.guard_house()
cat.guard_house() # 报错，猫不会看家
进阶：super() 的使用
如果在子类中，你不仅想重写父类的方法，还想保留父类原有的逻辑，就要用到 super()。
class Bird(Animal):
def init(self, name, can_fly):
# 调用父类的初始化方法，处理 name
super().init(name)
# 再处理子类独有的属性
self.can_fly = can_fly
pidgeon = Bird("鸽子", True)
print(f"{pidgeon.name} 能飞吗? {pidgeon.can_fly}")
核心点：
复用：相同的代码写在父类，子类直接用，减少代码重复。
扩展：子类可以增加新方法。
重写：子类可以修改父类的行为。
- 总结：三者如何协作？
在实际开发中，这三个概念通常是交织在一起的：
你先观察需求，抽象出类（比如“用户”、“订单”、“商品”）。
在类内部，你利用封装，把复杂的逻辑隐藏起来，只对外提供简单的接口（比如“下单”、“支付”）。
当你发现“普通用户”和“VIP用户”有很多共同点时，你利用继承，创建一个基础“用户类”，然后派生出不同等级的用户子类。
这就是 Python 面向对象编程的精髓：组织代码、保护数据、避免重复。