异常教程

Python 实现一个类，表示复数，并提供加法、减法等操作（一文讲透）

更新时间:

💡一则或许对你有用的小广告

欢迎加入小哈的星球 ，你将获得：专属的项目实战 / 1v1 提问 / Java 学习路线 / 学习打卡 / 每月赠书 / 社群讨论

截止目前， 星球 内专栏累计输出 90w+ 字，讲解图 3441+ 张，还在持续爆肝中.. 后续还会上新更多项目，目标是将 Java 领域典型的项目都整一波，如秒杀系统, 在线商城, IM 即时通讯，权限管理，Spring Cloud Alibaba 微服务等等，已有 3100+ 小伙伴加入学习 ，欢迎点击围观

在数学领域，复数是一个重要的概念，它由实部和虚部构成，广泛应用于工程、物理等领域。Python 的内置类型 complex 已经提供了复数的运算支持，但手动实现一个复数类能够帮助开发者深入理解类的设计逻辑、运算符重载机制，以及面向对象编程的核心思想。本文将通过 Python 实现一个类，表示复数，并提供加法、减法等操作，以通俗易懂的方式讲解相关知识点，并通过代码示例和案例分析，帮助读者掌握这一技能。

复数的数学基础与 Python 的内置实现

复数的基本定义

复数由实部（real part）和虚部（imaginary part）组成，通常写作 a + bj，其中 a 和 b 是实数，j 是虚数单位（满足 j² = -1）。例如，复数 3 + 4j 的实部是 3，虚部是 4。

Python 的 complex 类型原生支持复数的创建和运算：

c = complex(3, 4)          # 创建复数 3 + 4j  
print(c + complex(1, 2))   # 输出 (4+6j)

为什么需要自定义复数类？

尽管 Python 提供了内置的复数类型，但手动实现复数类有以下意义：

  1. 学习目的：通过实践理解类的构造、运算符重载等概念。
  2. 扩展性：例如，添加自定义方法（如模长计算、复数的极坐标表示）。
  3. 教学场景：帮助编程初学者直观理解面向对象编程的实现过程。

类的设计与核心逻辑

类的结构设计

一个复数类需要满足以下需求：

  1. 存储实部和虚部：通过类的属性（如 self.real 和 self.imag）。
  2. 支持加法、减法等运算：通过重载运算符（如 __add__、__sub__）。
  3. 可读性：提供 __str__ 方法，方便输出复数的字符串表示。

示例代码：基础类结构

class ComplexNumber:  
    def __init__(self, real, imag):  
        self.real = real  
        self.imag = imag  

    def __str__(self):  
        return f"{self.real} + {self.imag}j"

关键点解析

  • __init__ 方法：初始化复数的实部和虚部。
  • __str__ 方法：返回复数的字符串形式，便于调试和输出。

运算符重载：实现加法与减法

运算符重载的概念

Python 允许通过特殊方法（以双下划线包裹的方法，如 __add__）重载运算符。例如，表达式 a + b 会调用 a.__add__(b)。

实现加法运算

复数的加法遵循 实部相加、虚部相加 的规则：

def __add__(self, other):  
    new_real = self.real + other.real  
    new_imag = self.imag + other.imag  
    return ComplexNumber(new_real, new_imag)

实现减法运算

减法的逻辑类似，只需将对应部分相减：

def __sub__(self, other):  
    new_real = self.real - other.real  
    new_imag = self.imag - other.imag  
    return ComplexNumber(new_real, new_imag)

使用示例

a = ComplexNumber(3, 4)  
b = ComplexNumber(1, 2)  
print(a + b)   # 输出 "4 + 6j"  
print(a - b)   # 输出 "2 + 2j"

扩展功能：乘法、除法与比较运算

复数的乘法运算

复数的乘法规则为：
[ (a + bj) \times (c + dj) = (ac - bd) + (ad + bc)j ]
对应的代码实现如下：

def __mul__(self, other):  
    new_real = self.real * other.real - self.imag * other.imag  
    new_imag = self.real * other.imag + self.imag * other.real  
    return ComplexNumber(new_real, new_imag)

复数的除法运算

除法的实现较为复杂，需要通过 有理化 的方法：
[ \frac{a + bj}{c + dj} = \frac{(a + bj)(c - dj)}{c^2 + d^2} ]
代码示例：

def __truediv__(self, other):  
    denominator = other.real**2 + other.imag**2  
    new_real = (self.real * other.real + self.imag * other.imag) / denominator  
    new_imag = (self.imag * other.real - self.real * other.imag) / denominator  
    return ComplexNumber(new_real, new_imag)

比较运算：等于与不等于

通过 __eq__ 和 __ne__ 方法实现复数的相等性判断：

def __eq__(self, other):  
    return (self.real == other.real) and (self.imag == other.imag)  

def __ne__(self, other):  
    return not self.__eq__(other)

完整代码与案例分析

完整的复数类代码

class ComplexNumber:  
    def __init__(self, real, imag):  
        self.real = real  
        self.imag = imag  

    def __str__(self):  
        return f"{self.real} + {self.imag}j"  

    def __add__(self, other):  
        new_real = self.real + other.real  
        new_imag = self.imag + other.imag  
        return ComplexNumber(new_real, new_imag)  

    def __sub__(self, other):  
        new_real = self.real - other.real  
        new_imag = self.imag - other.imag  
        return ComplexNumber(new_real, new_imag)  

    def __mul__(self, other):  
        new_real = self.real * other.real - self.imag * other.imag  
        new_imag = self.real * other.imag + self.imag * other.real  
        return ComplexNumber(new_real, new_imag)  

    def __truediv__(self, other):  
        denominator = other.real**2 + other.imag**2  
        new_real = (self.real * other.real + self.imag * other.imag) / denominator  
        new_imag = (self.imag * other.real - self.real * other.imag) / denominator  
        return ComplexNumber(new_real, new_imag)  

    def __eq__(self, other):  
        return (self.real == other.real) and (self.imag == other.imag)  

    def __ne__(self, other):  
        return not self.__eq__(other)

案例：计算复数的模长

虽然模长不是运算符，但可以作为类的扩展方法：

def modulus(self):  
    return (self.real**2 + self.imag**2)**0.5  

a = ComplexNumber(3, 4)  
print(a.modulus())  # 输出 5.0

常见问题与进阶思考

问题 1：如何处理类型不匹配的运算？

当前代码假设 other 是 ComplexNumber 类型。若操作数类型不匹配，会引发错误。可以通过类型检查增强健壮性：

def __add__(self, other):  
    if not isinstance(other, ComplexNumber):  
        raise TypeError("Operands must be instances of ComplexNumber")  
    # 原逻辑...

进阶方向：支持链式运算与向量化操作

当前代码支持两个复数的运算，但无法直接处理多个复数的链式计算（如 a + b + c）。由于 Python 的运算符重载特性，链式运算会自动按顺序执行，因此无需额外修改。

总结与展望

通过本文，我们实现了 Python 实现一个类，表示复数，并提供加法、减法等操作 的目标。这一过程不仅复习了复数的数学知识，还深入理解了以下关键点：

  1. 类的设计与属性管理。
  2. 运算符重载的语法与逻辑。
  3. 面向对象编程的扩展性与可维护性。

未来可以进一步扩展此类的功能，例如：

  • 添加极坐标形式的支持（模长和幅角）。
  • 实现复数的指数、对数运算。
  • 将复数类与 NumPy 等科学计算库结合，提升性能。

掌握这一技能后，开发者能够更灵活地应对数学建模、工程计算等场景，并为深入理解 Python 的底层机制打下坚实基础。

最新发布

查看更多文章