人工智能之编程进阶 Python高级：第二章 面向对象

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

第二章 面向对象

---

@

目录

• 人工智能之编程进阶 Python高级
• 前言
• 一、面向对象核心概念
• 二、定义类和创建对象
  • 1. 基本语法
  • 2. __init__ 方法
• 三、封装与访问控制
  • 示例
• 四、继承（Inheritance）
  • 1. 基本继承
  • 2. super() 调用父类
  • 3. 多重继承
• 五、多态（Polymorphism）
• 六、特殊方法（魔术方法 / Dunder Methods）
  • • 示例：自定义容器类
• 七、类方法与静态方法
• 八、抽象基类（ABC）
• 九、数据类（@dataclass，Python 3.7+）
• 十、面向对象设计原则（SOLID 简化版）
• 十一、super()
• 十二、总结
• 资料关注

---

前言

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

---

一、面向对象核心概念

概念	说明
类（Class）	对象的蓝图或模板，定义属性和方法
对象（Object）	类的实例，具有具体的状态和行为
封装（Encapsulation）	将数据和操作数据的方法绑定在一起，隐藏内部实现
继承（Inheritance）	子类继承父类的属性和方法，实现代码复用
多态（Polymorphism）	同一接口，不同实现（如方法重写）
抽象（Abstraction）	隐藏复杂细节，只暴露必要接口

---

二、定义类和创建对象

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的面向对象具有的特性，以便于更加方便的实现业务逻辑以及高效的编程方式，便于理解业务和开发拓展功能。具体内容总结如下

特性	Python 实现方式
封装	属性命名约定 +@property
继承	class Child(Parent):+super()
多态	鸭子类型 + 方法重写
抽象	abc.ABC+@abstractmethod
便捷数据类	@dataclass

✅ ​最佳实践​：

• 优先组合而非继承
• 使用 @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》