精通 Python 面向对象编程：类、继承、封装与多态

Python 面向对象编程

本指南通过实战示例讲解 Python 面向对象编程（OOP）核心概念，助你构建健壮、可复用代码。

视频：Python 面向对象编程

面向对象编程

Python 是支持多种编程风格的多范式语言。最强大的方法之一是用对象建模问题——即面向对象编程（OOP）。

对象具备两个基本特征：

属性（数据）
行为（方法）

例如，鹦鹉是一个对象，拥有 name、age、color 等属性，以及 sing()、dance() 等行为。

Python OOP 促进代码复用，遵循 DRY（Don't Repeat Yourself）原则。

类

class 是定义对象结构和行为的蓝图。可视为鹦鹉的详细草图：规定鹦鹉可拥有的属性和动作。

class Parrot:
    pass

此处 Parrot 为空类。稍后创建实例。

对象

对象（或实例）是类的具体实现。定义类时不分配内存，仅存在模板。实例化类创建对象。

obj = Parrot()

下例构建功能性 Parrot 类并创建两个实例 blu 和 woo：

class Parrot:
    # 类属性
    species = "bird"
    # 实例属性
    def __init__(self, name, age):
        self.name = name
        self.age = age
# 实例化类
blu = Parrot("Blu", 10)
woo = Parrot("Woo", 15)
# 访问类属性
print("Blu is a {}".format(blu.__class__.species))
print("Woo is also a {}".format(woo.__class__.species))
# 访问实例属性
print("{} is {} years old".format(blu.name, blu.age))
print("{} is {} years old".format(woo.name, woo.age))

输出

Blu is a bird Woo is also a bird Blu is 10 years old Woo is 15 years old

此例中 species 为所有鹦鹉共享的类属性，而 name 和 age 为各对象独有的实例属性。

方法

方法是类中定义的函数，描述对象行为。在类实例上调用。

class Parrot:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def sing(self, song):
        return f"{self.name} sings {song}"
    def dance(self):
        return f"{self.name} is now dancing"
# 实例化并使用方法
blu = Parrot("Blu", 10)
print(blu.sing("'Happy'"))
print(blu.dance())

输出

Blu sings 'Happy' Blu is now dancing

继承

继承让新类继承现有类的属性和方法，促进代码复用和逻辑层级。

# 基类
class Bird:
    def __init__(self):
        print("Bird is ready")
    def whoisThis(self):
        print("Bird")
    def swim(self):
        print("Swim faster")
# 派生类
class Penguin(Bird):
    def __init__(self):
        super().__init__()
        print("Penguin is ready")
    def whoisThis(self):
        print("Penguin")
    def run(self):
        print("Run faster")
peggy = Penguin()
peggy.whoisThis()
peggy.swim()
peggy.run()

输出

Bird is ready Penguin is ready Penguin Swim faster Run faster

封装

封装限制对对象内部状态的直接访问，保护数据完整性。Python 中以下划线（单或双）前缀表示私有属性。

class Computer:
    def __init__(self):
        self.__maxprice = 900
    def sell(self):
        print(f"Selling Price: {self.__maxprice}")
    def setMaxPrice(self, price):
        self.__maxprice = price
c = Computer()
c.sell()
# 尝试直接修改
c.__maxprice = 1000
c.sell()
# 使用 setter 方法
c.setMaxPrice(1000)
c.sell()

输出

Selling Price: 900 Selling Price: 900 Selling Price: 1000

多态

多态允许不同类的对象通过共享接口处理，使代码能灵活操作各种对象类型。

class Parrot:
    def fly(self):
        print("Parrot can fly")
    def swim(self):
        print("Parrot can't swim")
class Penguin:
    def fly(self):
        print("Penguin can't fly")
    def swim(self):
        print("Penguin can swim")
# 通用接口
def flying_test(bird):
    bird.fly()
blu = Parrot()
peggy = Penguin()
flying_test(blu)
flying_test(peggy)

输出

Parrot can fly Penguin can't fly

关键要点

OOP 为代码清晰度和可维护性提供结构。
类通过继承实现代码复用。
封装保护内部数据。
多态提供跨对象类型的灵活接口。

精通 Python 自定义异常：实战指南精通 Python 对象与类：实战指南

Python