如何用Python编程实现复变函数的Laurent级数及对应收敛域？

Sympy确实没有直接生成Laurent级数的内置函数，但我们可以通过拆分复变函数的正则部（解析部分）和主要部（负幂次部分），结合Sympy的泰勒展开功能手动实现，同时推导收敛域。

核心原理 #

Laurent级数是泰勒级数的扩展，针对复平面上的环形区域收敛。对于函数$f(z)$，在环形域$r < |z - z_0| < R$内可展开为：
$$f(z) = \sum_{n=-\infty}^{\infty} a_n (z - z_0)^n$$
其中$a_n = \frac{1}{2\pi i} \oint_C \frac{f(\zeta)}{(\zeta - z_0)^{n+1}} d\zeta$，$C$是环形内的任意闭合曲线。

实际计算时，我们可以：

• 先找到函数的奇点，划分可能的环形收敛域
• 将函数拆分为解析部分（可做泰勒展开）和负幂次部分（通过变量替换转为泰勒展开）
• 分别计算两部分的级数，合并得到Laurent级数

分步实现与代码示例 #

1. 确定奇点与收敛域范围 #

首先用Sympy找出函数的奇点，以此划分收敛区域。比如对于$f(z) = \frac{1}{z(z-1)}$，奇点是$z=0$和$z=1$，可能的环形域为：

• $0 < |z| < 1$
• $1 < |z| < \infty$

用代码找出奇点：

import sympy as sp

z = sp.symbols('z')
f = 1/(z*(z-1))

# 获取复平面内的所有奇点
singularities = sp.singularities(f, z)
print("奇点：", singularities)

2. 拆分函数并展开（以$0 < |z| < 1$为例） #

先拆分函数：$f(z) = -\frac{1}{z} - \frac{1}{1 - z}$

• 负幂次部分：$-\frac{1}{z}$（本身就是单一项）
• 解析部分：$-\frac{1}{1 - z}$，可以用Sympy的series()做泰勒展开

代码：

# 拆分函数
f_split = -1/z - 1/(1 - z)

# 解析部分泰勒展开（0点附近，保留到z^4项）
analytic_part = sp.series(f_split.args[1], z, 0, 5).removeO()
# 合并得到Laurent级数
laurent_series = f_split.args[0] + analytic_part

print("\nLaurent级数（0 < |z| < 1）：")
sp.pretty_print(laurent_series)

输出结果：

-1/z - 1 - z - z² - z³ - z⁴

3. 处理无穷远处的收敛域（$1 < |z| < \infty$） #

此时做变量替换$w = 1/z$，将函数转为关于$w$的解析函数，在$|w| < 1$（即$|z| > 1$）内泰勒展开，再换回$z$：

代码：

w = sp.symbols('w')
# 替换变量并化简
f_w = f.subs(z, 1/w).simplify()
# 展开到w^4项，移除余项
expanded_w = sp.series(f_w, w, 0, 5).removeO()
# 换回z变量
laurent_series_inf = expanded_w.subs(w, 1/z).simplify()

print("\nLaurent级数（1 < |z| < ∞）：")
sp.pretty_print(laurent_series_inf)

输出结果：

1/z² + 1/z³ + 1/z⁴ + 1/z⁵

4. 自动计算收敛域 #

收敛域由奇点到展开中心的距离决定：

• $r$是展开中心到最近奇点的距离
• $R$是展开中心到最远奇点的距离（若没有远奇点则$R=\infty$）

代码：

z0 = 0  # 展开中心
# 计算到各有限奇点的距离
distances = [sp.Abs(s - z0) for s in singularities if s != sp.oo]
r = min(distances) if distances else 0
R = max(distances) if distances else sp.oo

print(f"\n收敛域：{r} < |z - {z0}| < {R}")

非有理函数示例（如$e^{1/z}$） #

对于本身包含负幂次的函数，直接用series()即可生成Laurent级数：

f_exp = sp.exp(1/z)
laurent_exp = sp.series(f_exp, z, 0, 5).removeO()

print("\ne^(1/z)的Laurent级数：")
sp.pretty_print(laurent_exp)
print("收敛域：0 < |z| < ∞")

输出结果：

1 + 1/z + 1/(2*z²) + 1/(6*z³) + 1/(24*z⁴)

通用封装函数 #

可以把上述逻辑封装成函数，自动处理有理函数的Laurent展开与收敛域计算：

def laurent_series(f, z, z0, n_terms=5):
    # 获取所有奇点
    singularities = sp.singularities(f, z)
    finite_singularities = [s for s in singularities if s != sp.oo]
    
    # 计算收敛域的r和R
    distances = [sp.Abs(s - z0) for s in finite_singularities]
    r = min(distances) if distances else 0
    R = max(distances) if distances else sp.oo

    # 部分分式分解拆分函数
    f_partial = sp.apart(f, z)
    laurent = 0
    for term in sp.Add.make_args(f_partial):
        # 区分负幂次项（主要部）和解析项（正则部）
        if sp.degree(term, z) < 0:
            laurent += term
        else:
            laurent += sp.series(term, z, z0, n_terms).removeO()
    return laurent, r, R

# 测试函数
laurent, r, R = laurent_series(f, z, 0, 5)
print("\n通用函数生成的Laurent级数：")
sp.pretty_print(laurent)
print(f"收敛域：{r} < |z| < {R}")

内容的提问来源于stack exchange，提问作者Александр Скворцов