人工智能之编程进阶 Python高级

第二章 面向对象

前言

Python 是一种 面向对象编程（Object-Oriented Programming, OOP） 语言，支持封装、继承、多态等核心特性。掌握面向对象编程是编写结构清晰、可维护、可复用代码的关键。

一、面向对象核心概念

二、定义类和创建对象

1. 基本语法

class ClassName:
    # 类属性（所有实例共享）
    class_variable = "共享值"
    # 构造方法（初始化）
    def __init__(self, param1, param2):
        # 实例属性（每个对象独有）
        self.instance_var1 = param1
        self.instance_var2 = param2
    # 实例方法
    def method(self):
        return f"{self.instance_var1} - {self.instance_var2}"
# 创建对象（实例化）
obj = ClassName("值1", "值2")
print(obj.method())  # 值1 - 值2

2. __init__ 方法

• 类似于构造函数，用于初始化对象
• 第一个参数必须是 self（代表当前实例）

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def greet(self):
        return f"Hello, I'm {self.name}, {self.age} years old."
p = Person("Alice", 25)
print(p.greet())  # Hello, I'm Alice, 25 years old.

三、封装与访问控制

Python 没有严格的 private/ public 关键字，但通过命名约定实现封装：

| 命名方式     | 含义       | 访问建议                                    |

| -------------- | ------------ | --------------------------------------------- |

| name   | 公有属性   | 可自由访问                                  |

| _name  | 受保护属性 | “内部使用”，但可访问                      |

| __name | 私有属性   | 名称改写（name mangling），外部不可直接访问 |

示例

class BankAccount:
    def __init__(self, owner, balance=0):
        self.owner = owner          # 公有
        self._balance = balance     # 受保护（约定）
        self.__pin = "1234"         # 私有（实际为 _BankAccount__pin）
    def deposit(self, amount):
        if amount > 0:
            self._balance += amount
    def get_balance(self, pin):
        if pin == self.__pin:
            return self._balance
        else:
            raise ValueError("Invalid PIN")
acc = BankAccount("Alice", 100)
print(acc.owner)        # ✅ 可访问
print(acc._balance)     # ⚠️ 可访问，但不推荐
# print(acc.__pin)      # ❌ AttributeError
print(acc._BankAccount__pin)  # ✅ 但强烈不推荐（破坏封装）

✅ 最佳实践：使用属性（ @property）提供安全的访问接口。

class Temperature:
    def __init__(self, celsius=0):
        self._celsius = celsius
    @property
    def celsius(self):
        return self._celsius
    @celsius.setter
    def celsius(self, value):
        if value < -273.15:
            raise ValueError("温度不能低于绝对零度")
        self._celsius = value
    @property
    def fahrenheit(self):
        return self._celsius * 9/5 + 32
temp = Temperature(25)
print(temp.celsius)     # 25
print(temp.fahrenheit)  # 77.0
temp.celsius = 30       # 自动验证
# temp.celsius = -300   # 抛出异常

四、继承（Inheritance）

子类继承父类的属性和方法，并可扩展或重写。

1. 基本继承

class Animal:
    def __init__(self, name):
        self.name = name
    def speak(self):
        raise NotImplementedError("子类必须实现 speak 方法")
class Dog(Animal):
    def speak(self):
        return f"{self.name} says Woof!"
class Cat(Animal):
    def speak(self):
        return f"{self.name} says Meow!"
dog = Dog("Buddy")
cat = Cat("Whiskers")
print(dog.speak())  # Buddy says Woof!
print(cat.speak())  # Whiskers says Meow!

2. super() 调用父类

class Employee:
    def __init__(self, name, salary):
        self.name = name
        self.salary = salary
class Manager(Employee):
    def __init__(self, name, salary, bonus):
        super().__init__(name, salary)  # 调用父类构造函数
        self.bonus = bonus
    def total_income(self):
        return self.salary + self.bonus

3. 多重继承

class Flyable:
    def fly(self):
        return "Flying..."
class Swimmable:
    def swim(self):
        return "Swimming..."
class Duck(Animal, Flyable, Swimmable):
    def speak(self):
        return "Quack!"
duck = Duck("Donald")
print(duck.fly())    # Flying...
print(duck.swim())   # Swimming...

⚠️ 注意：多重继承可能引发 方法解析顺序（MRO） 问题，可通过 ClassName.__mro__ 查看。

五、多态（Polymorphism）

同一接口，不同实现。Python 是动态类型语言，天然支持多态。

def animal_sound(animal: Animal):
    print(animal.speak())  # 不关心具体类型，只要实现 speak()
animals = [Dog("Buddy"), Cat("Whiskers"), Duck("Donald")]
for a in animals:
    animal_sound(a)

输出：

Buddy says Woof!
Whiskers says Meow!
Donald says Quack!

六、特殊方法（魔术方法 / Dunder Methods）

以双下划线开头和结尾的方法，用于自定义类的行为。

| 方法              | 用途                   | 示例               |

| ------------------- | ------------------------ | -------------------- |

| __str__     | 用户友好的字符串表示   | print(obj)   |

| __repr__    | 开发者友好的字符串表示 | repr(obj)    |

| __len__     | 支持 len()        | len(obj)     |

| __getitem__ | 支持索引访问           | obj[0]       |

| __call__    | 使对象可调用           | obj()        |

| __eq__      | 定义相等比较           | obj1 == obj2 |

示例：自定义容器类

class MyList:
    def __init__(self, items=None):
        self._items = items or []
    def __len__(self):
        return len(self._items)
    def __getitem__(self, index):
        return self._items[index]
    def __str__(self):
        return f"MyList({self._items})"
    def __repr__(self):
        return f"MyList({self._items!r})"
my_list = MyList([1, 2, 3])
print(len(my_list))     # 3
print(my_list[0])       # 1
print(my_list)          # MyList([1, 2, 3])

七、类方法与静态方法

| 类型     | 装饰器              | 第一个参数 | 用途                           |

| ---------- | --------------------- | ------------ | -------------------------------- |

| 实例方法 | 无                  | self | 操作实例数据                   |

| 类方法   | @classmethod  | cls  | 操作类数据，常用于替代构造函数 |

| 静态方法 | @staticmethod | 无         | 与类相关但不依赖类或实例       |

class Person:
    species = "Homo sapiens"
    def __init__(self, name, age):
        self.name = name
        self.age = age
    @classmethod
    def get_species(cls):
        return cls.species
    @classmethod
    def from_string(cls, person_str):
        # 替代构造函数
        name, age = person_str.split('-')
        return cls(name, int(age))
    @staticmethod
    def is_adult(age):
        return age >= 18
# 使用
p1 = Person.from_string("Alice-25")
print(Person.get_species())  # Homo sapiens
print(Person.is_adult(17))   # False

八、抽象基类（ABC）

强制子类实现特定方法。

from abc import ABC, abstractmethod
class Shape(ABC):
    @abstractmethod
    def area(self):
        pass
    @abstractmethod
    def perimeter(self):
        pass
class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height
    def area(self):
        return self.width * self.height
    def perimeter(self):
        return 2 * (self.width + self.height)
# rect = Shape()  # ❌ 不能实例化抽象类
rect = Rectangle(3, 4)
print(rect.area())  # 12

九、数据类（ @dataclass，Python 3.7+）

简化只用于存储数据的类。

from dataclasses import dataclass
@dataclass
class Point:
    x: float
    y: float
    def distance_from_origin(self):
        return (self.x ** 2 + self.y ** 2) ** 0.5
p = Point(3.0, 4.0)
print(p)  # Point(x=3.0, y=4.0)
print(p.distance_from_origin())  # 5.0

自动生成 __init__, __repr__, __eq__ 等方法。

十、面向对象设计原则（SOLID 简化版）

1. 单一职责：一个类只做一件事
2. 开闭原则：对扩展开放，对修改关闭
3. 里氏替换：子类能替换父类而不破坏程序
4. 接口隔离：客户端不应依赖它不需要的接口
5. 依赖倒置：依赖抽象，而非具体实现

十一、super()

十二、总结

本文主要讲述python的面向对象具有的特性，以便于更加方便的实现业务逻辑以及高效的编程方式，便于理解业务和开发拓展功能。具体内容总结如下

✅ 最佳实践：

• 优先组合而非继承
• 使用 @property 控制属性访问
• 用 dataclass 简化数据载体类
• 抽象基类用于定义接口契约

资料关注

相关资料获取: 公众号：咚咚王

《Python编程：从入门到实践》 《利用Python进行数据分析》 《算法导论中文第三版》 《概率论与数理统计（第四版） (盛骤) 》 《程序员的数学》 《线性代数应该这样学第3版》 《微积分和数学分析引论》 《（西瓜书）周志华-机器学习》 《TensorFlow机器学习实战指南》 《Sklearn与TensorFlow机器学习实用指南》 《模式识别（第四版）》 《深度学习 deep learning》伊恩·古德费洛著 花书 《Python深度学习第二版(中文版)【纯文本】 (登封大数据 (Francois Choliet)) (Z-Library)》 《深入浅出神经网络与深度学习+(迈克尔·尼尔森（Michael+Nielsen） 》 《自然语言处理综论  第2版》 《Natural-Language-Processing-with-PyTorch》 《计算机视觉-算法与应用(中文版)》 《Learning OpenCV 4》 《AIGC：智能创作时代》杜雨+&+张孜铭 《AIGC原理与实践：零基础学大语言模型、扩散模型和多模态模型》 《从零构建大语言模型（中文版）》 《实战AI大模型》 《AI 3.0》