Python复数类型complex应用场景详解

a + bj （在数学中通常写作 a + bi，Python中用 j 代替 i）

# Python中的复数
z1 = 3 + 4j       # 实部=3, 虚部=4
z2 = 1 - 2j       # 实部=1, 虚部=-2
z3 = 5j           # 纯虚数，实部=0（注意：不能写成 j5）
z4 = 2 + 0j       # 其实就是实数2（但类型是complex）

# 基本创建
a = 3 + 4j
b = -1 - 2j
c = 5j           # 等于 0 + 5j
d = 2 - 0j       # 等于 2 + 0j

# 注意：虚部系数必须紧挨着j
# e = 1 + j      # NameError！j被当作变量名
e = 1 + 1j       # OK

# 从一个参数
z1 = complex(5)         # (5+0j)
z2 = complex(3.14)      # (3.14+0j)

# 从两个参数（实部, 虚部）
z3 = complex(3, 4)      # (3+4j)
z4 = complex(-1, 2.5)   # (-1+2.5j)

# 从字符串（不能有空格！）
z5 = complex('3+4j')    # (3+4j)
z6 = complex('-1-2j')   # (-1-2j)
z7 = complex('5j')      # 5j
z8 = complex('3')       # (3+0j)

# 这些会报错
# complex('3 + 4j')     # 字符串中有空格！
# complex('3+4i')       # Python用j，不是i

z = 3 + 4j

print(z.real)    # 3.0（注意：返回float类型）
print(z.imag)    # 4.0

# 复数的共轭（虚部取反）
print(z.conjugate())  # (3-4j)

a = 3 + 4j
b = 1 - 2j

# 加法：(3+4j) + (1-2j) = 4+2j
print(a + b)     # (4+2j)

# 减法：(3+4j) - (1-2j) = 2+6j
print(a - b)     # (2+6j)

# 乘法：(3+4j)(1-2j) = 3-6j+4j-8j² = 3-2j+8 = 11-2j
print(a * b)     # (11-2j)

# 除法：(3+4j)/(1-2j)
print(a / b)     # (-1+2j)

# 幂运算
print(a ** 2)    # (-7+24j) — 因为 (3+4j)² = 9+24j+16j² = 9+24j-16 = -7+24j

a = 3 + 4j
b = 3 + 4j

# 可以比较相等
print(a == b)    # True
print(a != b)    # False

# 不能比较大小！
# print(a > b)   # TypeError: '>' not supported between complex numbers
# print(a < b)   # 同上

import math
import cmath  # 复数的数学函数

z = 3 + 4j

# abs()：复数的模（magnitude）
# |3+4j| = sqrt(3² + 4²) = sqrt(25) = 5
print(abs(z))              # 5.0

# pow()：幂运算
print(pow(z, 2))           # (-7+24j)

# round()不能用于复数
# round(z)  # TypeError

# cmath模块：复数的数学函数
print(cmath.sqrt(z))       # (2+1j)（因为(2+j)² = 4+4j+j² = 3+4j）

# 复数的极坐标表示
print(cmath.polar(z))      # (5.0, 0.9272952180016122)
# 返回 (模, 辐角) = (5.0, arctan(4/3))

# 从极坐标恢复复数
modulus, angle = 5.0, 0.9272952180016122
print(cmath.rect(modulus, angle))  # (3+4j)

# 欧拉公式：e^(jx) = cos(x) + j*sin(x)
x = 0.5
print(cmath.exp(1j * x))  # (0.87758+0.47943j)
print(complex(cmath.cos(x), cmath.sin(x)))  # 手动计算验证

import cmath

z = 1 + 1j

# 指数和对数
print(cmath.exp(z))       # e^z
print(cmath.log(z))       # ln(z)
print(cmath.log10(z))     # log10(z)

# 三角函数
print(cmath.sin(z))
print(cmath.cos(z))
print(cmath.tan(z))

# 反三角函数
print(cmath.asin(z))
print(cmath.acos(z))
print(cmath.atan(z))

# 双曲函数
print(cmath.sinh(z))
print(cmath.cosh(z))
print(cmath.tanh(z))

# 判断函数
print(cmath.isinf(complex(float('inf'), 0)))   # True
print(cmath.isnan(complex(float('nan'), 0)))   # True
print(cmath.isclose(1+2j, 1+2.0000000001j))    # True

import cmath

def discrete_fourier_transform(samples):
    """
    离散傅里叶变换（DFT）
    输入：时域信号采样点列表（实数）
    输出：频域复数列表
    """
    n = len(samples)
    result = []
    for k in range(n):
        # 计算第k个频率分量
        frequency_component = 0j
        for t in range(n):
            angle = -2 * cmath.pi * 1j * k * t / n
            frequency_component += samples[t] * cmath.exp(angle)
        result.append(frequency_component)
    return result


# 示例：分析一个包含两个频率成分的信号
import math

# 生成采样信号：50Hz + 120Hz的正弦波
sample_rate = 500  # 采样率
duration = 1.0     # 1秒
n_samples = int(sample_rate * duration)

samples = []
for i in range(n_samples):
    t = i / sample_rate
    value = math.sin(2 * math.pi * 50 * t) + 0.5 * math.sin(2 * math.pi * 120 * t)
    samples.append(value)

# 执行DFT
frequency_spectrum = discrete_fourier_transform(samples)

# 显示前10个频率分量的幅度
print('频率分析结果：')
for i in range(10):
    magnitude = abs(frequency_spectrum[i])
    frequency = i * sample_rate / n_samples
    print(f'{frequency:.0f}Hz: 幅度={magnitude:.2f}')

# 在图像处理中，可以使用复数来表示二维坐标系中的点
# 复数的实部表示x坐标，虚部表示y坐标

def rotate_point(x, y, angle_degrees):
    """用复数实现二维平面上的点旋转"""
    # 创建表示点的复数
    point = complex(x, y)

    # 创建旋转因子：e^(jθ) = cos(θ) + j*sin(θ)
    import math
    angle_radians = math.radians(angle_degrees)
    rotation = complex(math.cos(angle_radians), math.sin(angle_radians))

    # 旋转：复数乘法
    rotated = point * rotation

    return rotated.real, rotated.imag


# 测试：将点(1, 0)旋转90度
x, y = rotate_point(1, 0, 90)
print(f'(1, 0)旋转90度后：({x:.2f}, {y:.2f})')  # (0.00, 1.00)

# 放大/缩小
def scale_point(x, y, factor):
    """缩放点"""
    point = complex(x, y)
    scaled = point * factor
    return scaled.real, scaled.imag

x, y = scale_point(3, 4, 2)
print(f'(3, 4)放大2倍：({x}, {y})')  # (6.0, 8.0)

# 在交流电路分析中，阻抗（电阻+电抗）用复数表示
# Z = R + jX
# R：电阻（实部），X：电抗（虚部）
# 电感：X_L = jωL，电容：X_C = 1/(jωC) = -j/(ωC)

def impedance_resistor(r):
    """纯电阻阻抗"""
    return complex(r, 0)

def impedance_inductor(inductance, frequency):
    """电感阻抗：Z_L = jωL"""
    omega = 2 * 3.14159 * frequency
    return complex(0, omega * inductance)

def impedance_capacitor(capacitance, frequency):
    """电容阻抗：Z_C = 1/(jωC)"""
    omega = 2 * 3.14159 * frequency
    return complex(0, -1 / (omega * capacitance))

def parallel_impedance(z1, z2):
    """并联阻抗"""
    return (z1 * z2) / (z1 + z2)

def series_impedance(*impedances):
    """串联阻抗"""
    return sum(impedances)


# 示例：RLC串联电路
R = 100.0            # 100欧姆电阻
L = 0.1              # 100毫亨电感
C = 10e-6            # 10微法电容
f = 1000.0           # 1000Hz频率

Z_R = impedance_resistor(R)
Z_L = impedance_inductor(L, f)
Z_C = impedance_capacitor(C, f)

Z_total = series_impedance(Z_R, Z_L, Z_C)
print(f'总阻抗：{Z_total}')
print(f'阻抗模：{abs(Z_total):.2f}欧姆')
print(f'相位角：{cmath.phase(Z_total):.2f}弧度')

def mandelbrot(c, max_iterations=100):
    """
    判断一个复数c是否属于曼德勃罗集
    返回迭代次数（用于着色），如果在max_iterations内不发散则返回max_iterations
    """
    z = 0j
    for n in range(max_iterations):
        z = z * z + c
        if abs(z) > 2:
            return n
    return max_iterations


def generate_mandelbrot(width=80, height=40, max_iter=50):
    """生成曼德勃罗集的ASCII艺术"""
    x_min, x_max = -2.0, 1.0
    y_min, y_max = -1.0, 1.0

    for y in range(height):
        line = ''
        for x in range(width):
            # 将像素坐标映射到复数平面
            real = x_min + (x / width) * (x_max - x_min)
            imag = y_min + (y / height) * (y_max - y_min)
            c = complex(real, imag)

            # 计算这个点属于曼德勃罗集的程度
            m = mandelbrot(c, max_iter)

            # 用不同字符表示不同深度
            if m == max_iter:
                line += '#'
            elif m > max_iter * 0.8:
                line += '*'
            elif m > max_iter * 0.5:
                line += '+'
            elif m > max_iter * 0.2:
                line += '.'
            else:
                line += ' '
        print(line)

# 生成曼德勃罗集（终端中的ASCII艺术）
generate_mandelbrot(100, 40)

# 复数 → 其他类型
z = 3 + 4j

# 复数 → 字符串
print(str(z))        # '(3+4j)'

# 复数 → 整数/浮点数？不行
# int(z)             # TypeError
# float(z)           # TypeError

# 但可以取模
magnitude = abs(z)   # 5.0（float类型）

# 其他类型 → 复数
print(complex(5))           # (5+0j)
print(complex(3.14))        # (3.14+0j)
print(complex(3, 4))        # (3+4j)
print(complex('1+2j'))      # (1+2j)

import cmath

# 对负数开方
# math.sqrt(-1)  # ValueError
result = cmath.sqrt(-1)   # 1j
print(result)

# 但cmath.sqrt返回复数
print(cmath.sqrt(4))      # (2+0j)——即使结果是实数，也返回complex类型
print(cmath.sqrt(-4))     # 2j——令人困惑的写法，实际是0+2j

# 如果你想要实数，需要检查
def safe_sqrt(x):
    """安全开方：正数返回float，负数返回complex"""
    if x >= 0:
        import math
        return math.sqrt(x)
    else:
        return cmath.sqrt(x)

print(safe_sqrt(4))    # 2.0
print(safe_sqrt(-4))   # 2j

z = 3 + 4j
print(type(z.real))  # <class 'float'>
print(type(z.imag))  # <class 'float'>

# 这意味着实部或虚部也可以是float中的特殊值
z1 = complex(float('inf'), 0)   # (inf+0j)
z2 = complex(0, float('nan'))   # (nanj)
print(z1, z2)