Python复数数学运算指南：加减乘除、共轭及求模

图 0：Python 复数核心概念与数学运算全景示意图

在 Python 中，复数（Complex Number）是原生内置的一等公民类型（complex），无需安装或导入任何外部第三方库即可直接进行代数运算。复数在工程计算、信号处理、量子模拟和几何变换等领域有着广泛应用。本文将系统梳理 Python 复数的核心数学运算，重点讲解复数的定义创建、加减乘除四则代数与几何运算、共轭复数（z.conjugate()）与求模长（abs(z)）的底层原理与代码实现，并指出实际编码中常见的精度与语法陷阱。

一、Python复数的定义与表示机制

数学中的复数由实部和虚部组成，记作 a + bi（其中 i² = -1）。而在工程学和 Python 中，虚数单位统一使用小写 j 或大写 J 表示，以避免与电学中的电流符号 i 混淆。

在 Python 中创建复数主要有两种方式：

• 字面量写法：直接在浮点数或整数后追加 j，例如 3 + 4j。需要特别注意：当虚部系数为 1 时，必须显式写作 1j，若单独写 j，解释器会将其视作未定义的变量名并抛出 NameError。
• 构造函数写法：使用内置的 complex(real, imag)。例如 complex(3, 4) 返回 (3+4j)；也可以解析字符串 complex("3+4j")，但加减号两侧绝对不能包含空格。

# 复数的两种创建途径示例
z1 = 3 + 4j             # 字面量创建
z2 = complex(1.5, -2.5) # 构造函数创建
z3 = complex("2+3j")    # 字符串解析创建（注意中间无空格）

print("z1:", z1, "类型:", type(z1))
print("z2:", z2)
print("z3:", z3)

# 访问实部与虚部分量
print("z1 实部:", z1.real, "类型:", type(z1.real))
print("z1 虚部:", z1.imag, "类型:", type(z1.imag))

# 示例输出：
# z1: (3+4j) 类型: <class 'complex'>
# z2: (1.5-2.5j)
# z3: (2+3j)
# z1 实部: 3.0 类型: <class 'float'>
# z1 虚部: 4.0 类型: <class 'float'>

在底层实现中，Python 的 complex 对象由 CPython 的 PyComplexObject 结构体实现，其实部 .real 与虚部 .imag 分别以 IEEE 754 双精度 64 位浮点数（C 语言 double）保存。复数在 Python 中是不可变对象（Immutable），因此属性是只读的，尝试执行 z1.real = 5 会引发 AttributeError。

图 1：Python complex 对象的创建方式与底层存储结构

二、四则基本数学运算：加、减、乘、除

Python 为 complex 类型重载了标准的算术运算符（+、-、*、/），并且支持复数与整数（int）、浮点数（float）之间的混合运算。运算过程中，实数会自动提升为虚部为 0 的复数。

1. 复数加法与减法

复数的加减法对应代数上的“分部计算”：两个复数的实部与实部相加减，虚部与虚部相加减。

代数公式：
• 加法：(a + bj) + (c + dj) = (a + c) + (b + d)j
• 减法：(a + bj) - (c + dj) = (a - c) + (b - d)j

在几何意义上，复平面的每个复数都可以视作从原点出发的二维向量。复数加法严格遵循物理学中的“平行四边形法则”或“三角形法则”。

2. 复数乘法

根据多项式展开法则，结合虚数基本定义 j × j = -1，可得乘法公式：
(a + bj)(c + dj) = ac + adj + bcj + bd(j²) = (ac - bd) + (ad + bc)j

在几何层面上，复数乘法具有非常优雅的变换性质：两个复数相乘，其结果的模长等于模长相乘，幅角等于幅角相加（旋转缩放变换）。

3. 复数除法

复数除法通过“分母有理化”实现：分子与分母同时乘以分母的共轭复数 (c - dj)，将分母转化为纯实数：
(a + bj) / (c + dj) = [(a + bj)(c - dj)] / [(c + dj)(c - dj)] = [(ac + bd) + (bc - ad)j] / (c² + d²)

若除数为 0 + 0j，Python 会严格抛出 ZeroDivisionError: complex division by zero 异常。

# 四则数学运算代码示例
z1 = 3 + 1j
z2 = 1 + 3j

# 1. 加法
add_res = z1 + z2
print("z1 + z2 =", add_res)

# 2. 减法
sub_res = z1 - z2
print("z1 - z2 =", sub_res)

# 3. 乘法
mul_res = z1 * z2
print("z1 * z2 =", mul_res)

# 4. 除法
div_res = z1 / z2
print("z1 / z2 =", div_res)

# 5. 复数与实数混合运算
mix_res = (2 + 3j) * 2 + 1.5
print("混合运算结果:", mix_res)

# 示例输出：
# z1 + z2 = (4+4j)
# z1 - z2 = (2-2j)
# z1 * z2 = 10j
# z1 / z2 = (0.6-0.8j)
# 混合运算结果: (5.5+6j)

图 2：复平面上的向量几何运算与乘除法推导图解

三、共轭复数（Conjugate）的计算与性质

如果一个复数为 z = a + bj，则其实部相同、虚部互为相反数的复数 z̄ = a - bj 称为 z 的共轭复数（Complex Conjugate）。在复平面直角坐标系中，共轭复数表现为关于实轴（横轴）的镜像对称点。

在 Python 中，获取复数的共轭使用内置方法 z.conjugate()。注意这是一个方法调用，必须带括号，而不是属性。

# 计算共轭复数示例
z = 3 + 4j
z_conj = z.conjugate()

print("原复数 z:", z)
print("共轭复数 z.conjugate():", z_conj)

# 验证核心代数恒等式：z 与其共轭的乘积必为非负实数 (a^2 + b^2)
product = z * z_conj
print("z * z_conj 结果:", product)
print("实部值:", product.real, "虚部值:", product.imag)

# 示例输出：
# 原复数 z: (3+4j)
# 共轭复数 z.conjugate(): (3-4j)
# z * z_conj 结果: (25+0j)
# 实部值: 25.0 虚部值: 0.0

四、复数求模（Modulus）与绝对值

复数的模（Modulus），又称复数的绝对值或范数，记作 |z|。在复平面上，它代表从坐标原点 (0, 0) 到点 (a, b) 的欧几里得直线距离。

数学定义基于勾股定理：
|z| = √(a² + b²)

在 Python 中，求模运算直接调用内置的 abs(z) 函数，它返回一个普通的 64 位浮点数（float）。

import math
import cmath

z = 3 + 4j

# 使用内置函数 abs(z) 求模
mod = abs(z)
print("abs(z) 模长:", mod, "类型:", type(mod))

# 手动按公式验证：sqrt(a^2 + b^2)
manual_mod = math.sqrt(z.real**2 + z.imag**2)
print("公式验证模长:", manual_mod)

# 获取极坐标下的模长与幅角 (r, theta)
r, theta = cmath.polar(z)
print(f"极坐标形式: 模长 r = {r}, 幅角 theta = {theta:.4f} 弧度")

# 示例输出：
# abs(z) 模长: 5.0 类型: <class 'float'>
# 公式验证模长: 5.0
# 极坐标形式: 模长 r = 5.0, 幅角 theta = 0.9273 弧度

值得强调的是，复数的模平方与共轭乘积具有天然的数学等价性：|z|² = z · z̄。当需要获得模的平方时，直接计算 z.real**2 + z.imag**2 通常比 abs(z)**2 具有更好的数值精度，并能避免一次不必要的开平方开销。

图 3：共轭变换与求模运算的推导步骤与几何流程图

五、核心注意事项与避坑指南

在实际使用 Python 编写复数计算代码时，有若干容易引起 Bug 或运行时异常的细节需要警惕：

1. 虚数单位写法陷阱

Python 仅将带有数字前缀的 j 识别为虚数。若输入 j 或 -j，解释器会当成变量名；正确写法必须是 1j 或 -1j。

2. 字符串解析严禁含有空格

使用 complex("1+2j") 转换字符串时，加减号之间不能留有任何空格。例如 complex("1 + 2j") 会直接抛出 ValueError: complex() arg is a malformed string。

3. 复数不能进行大小比较

在数学理论中，复数域是一个代数闭域，但并不是一个有序域。因此 Python 不支持在复数之间使用 <、<=、>、>= 运算符。

# 大小比较异常示例
try:
    result = (1 + 2j) < (2 + 3j)
except TypeError as err:
    print("捕获错误:", err)

# 示例输出：
# 捕获错误: '<' not supported between instances of 'complex' and 'complex'

如果需要对一组复数进行排序或比较，必须显式指定依据，例如按模长 sorted(nums, key=abs) 或按实部 sorted(nums, key=lambda z: z.real)。

4. 浮点精度与相等性判断

因为复数的实部与虚部在底层都是二进制浮点数，所以在经过乘除运算后可能会积累微小的舍入误差。不能简单地用 == 判断两个经过复杂计算的复数，而应使用 cmath.isclose()：

# 浮点误差与近似比较
import cmath

a = (0.1 + 0.2j) * 3
b = 0.3 + 0.6j

print("直接使用 == 比较:", a == b)
print("使用 cmath.isclose 比较:", cmath.isclose(a, b))

# 示例输出：
# 直接使用 == 比较: False
# 使用 cmath.isclose 比较: True

5. math 模块与 cmath 模块的边界

标准库的 math 模块只处理实数，当传入负数进行开方时（如 math.sqrt(-4)），会报 ValueError: math domain error。处理涉及复数的超越函数（开方、指数、对数、三角函数等）时，必须使用专门的 cmath（Complex Math）模块。

图 4：Python 复数运算速查与常见避坑清单

六、常用运算与语法自查表

下表汇总了本文涉及的全部核心运算符、内置函数与方法，方便在日常开发中随时查阅自检：

掌握了以上定义方式、算术运算规则、共轭与模长函数，以及浮点数和异常陷阱，即可在 Python 中安全、高效地进行各类复数数学运算与工程算法开发。