a + bj （在數(shù)學(xué)中通常寫作 a + bi，Python中用 j 代替 i）

# Python中的復(fù)數(shù)
z1 = 3 + 4j       # 實(shí)部=3, 虛部=4
z2 = 1 - 2j       # 實(shí)部=1, 虛部=-2
z3 = 5j           # 純虛數(shù)，實(shí)部=0（注意：不能寫成 j5）
z4 = 2 + 0j       # 其實(shí)就是實(shí)數(shù)2（但類型是complex）

# 基本創(chuàng)建
a = 3 + 4j
b = -1 - 2j
c = 5j           # 等于 0 + 5j
d = 2 - 0j       # 等于 2 + 0j

# 注意：虛部系數(shù)必須緊挨著j
# e = 1 + j      # NameError！j被當(dāng)作變量名
e = 1 + 1j       # OK

# 從一個(gè)參數(shù)
z1 = complex(5)         # (5+0j)
z2 = complex(3.14)      # (3.14+0j)

# 從兩個(gè)參數(shù)（實(shí)部, 虛部）
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)

# 這些會(huì)報(bào)錯(cuò)
# complex('3 + 4j')     # 字符串中有空格！
# complex('3+4i')       # Python用j，不是i

z = 3 + 4j

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

# 復(fù)數(shù)的共軛（虛部取反）
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-8j2 = 3-2j+8 = 11-2j
print(a * b)     # (11-2j)

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

# 冪運(yùn)算
print(a ** 2)    # (-7+24j) — 因?yàn)?(3+4j)2 = 9+24j+16j2 = 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  # 復(fù)數(shù)的數(shù)學(xué)函數(shù)

z = 3 + 4j

# abs()：復(fù)數(shù)的模（magnitude）
# |3+4j| = sqrt(32 + 42) = sqrt(25) = 5
print(abs(z))              # 5.0

# pow()：冪運(yùn)算
print(pow(z, 2))           # (-7+24j)

# round()不能用于復(fù)數(shù)
# round(z)  # TypeError

# cmath模塊：復(fù)數(shù)的數(shù)學(xué)函數(shù)
print(cmath.sqrt(z))       # (2+1j)（因?yàn)?2+j)2 = 4+4j+j2 = 3+4j）

# 復(fù)數(shù)的極坐標(biāo)表示
print(cmath.polar(z))      # (5.0, 0.9272952180016122)
# 返回 (模, 輻角) = (5.0, arctan(4/3))

# 從極坐標(biāo)恢復(fù)復(fù)數(shù)
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)))  # 手動(dòng)計(jì)算驗(yàn)證

import cmath

z = 1 + 1j

# 指數(shù)和對(duì)數(shù)
print(cmath.exp(z))       # e^z
print(cmath.log(z))       # ln(z)
print(cmath.log10(z))     # log10(z)

# 三角函數(shù)
print(cmath.sin(z))
print(cmath.cos(z))
print(cmath.tan(z))

# 反三角函數(shù)
print(cmath.asin(z))
print(cmath.acos(z))
print(cmath.atan(z))

# 雙曲函數(shù)
print(cmath.sinh(z))
print(cmath.cosh(z))
print(cmath.tanh(z))

# 判斷函數(shù)
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）
    輸入：時(shí)域信號(hào)采樣點(diǎn)列表（實(shí)數(shù)）
    輸出：頻域復(fù)數(shù)列表
    """
    n = len(samples)
    result = []
    for k in range(n):
        # 計(jì)算第k個(gè)頻率分量
        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


# 示例：分析一個(gè)包含兩個(gè)頻率成分的信號(hào)
import math

# 生成采樣信號(hào)：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)

# 執(zhí)行DFT
frequency_spectrum = discrete_fourier_transform(samples)

# 顯示前10個(gè)頻率分量的幅度
print('頻率分析結(jié)果：')
for i in range(10):
    magnitude = abs(frequency_spectrum[i])
    frequency = i * sample_rate / n_samples
    print(f'{frequency:.0f}Hz: 幅度={magnitude:.2f}')

# 在圖像處理中，可以使用復(fù)數(shù)來(lái)表示二維坐標(biāo)系中的點(diǎn)
# 復(fù)數(shù)的實(shí)部表示x坐標(biāo)，虛部表示y坐標(biāo)

def rotate_point(x, y, angle_degrees):
    """用復(fù)數(shù)實(shí)現(xiàn)二維平面上的點(diǎn)旋轉(zhuǎn)"""
    # 創(chuàng)建表示點(diǎn)的復(fù)數(shù)
    point = complex(x, y)

    # 創(chuàng)建旋轉(zhuǎn)因子：e^(jθ) = cos(θ) + j*sin(θ)
    import math
    angle_radians = math.radians(angle_degrees)
    rotation = complex(math.cos(angle_radians), math.sin(angle_radians))

    # 旋轉(zhuǎn)：復(fù)數(shù)乘法
    rotated = point * rotation

    return rotated.real, rotated.imag


# 測(cè)試：將點(diǎn)(1, 0)旋轉(zhuǎn)90度
x, y = rotate_point(1, 0, 90)
print(f'(1, 0)旋轉(zhuǎn)90度后：({x:.2f}, {y:.2f})')  # (0.00, 1.00)

# 放大/縮小
def scale_point(x, y, factor):
    """縮放點(diǎn)"""
    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)

# 在交流電路分析中，阻抗（電阻+電抗）用復(fù)數(shù)表示
# Z = R + jX
# R：電阻（實(shí)部），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):
    """并聯(lián)阻抗"""
    return (z1 * z2) / (z1 + z2)

def series_impedance(*impedances):
    """串聯(lián)阻抗"""
    return sum(impedances)


# 示例：RLC串聯(lián)電路
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):
    """
    判斷一個(gè)復(fù)數(shù)c是否屬于曼德勃羅集
    返回迭代次數(shù)（用于著色），如果在max_iterations內(nèi)不發(fā)散則返回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藝術(shù)"""
    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):
            # 將像素坐標(biāo)映射到復(fù)數(shù)平面
            real = x_min + (x / width) * (x_max - x_min)
            imag = y_min + (y / height) * (y_max - y_min)
            c = complex(real, imag)

            # 計(jì)算這個(gè)點(diǎn)屬于曼德勃羅集的程度
            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藝術(shù)）
generate_mandelbrot(100, 40)

# 復(fù)數(shù) → 其他類型
z = 3 + 4j

# 復(fù)數(shù) → 字符串
print(str(z))        # '(3+4j)'

# 復(fù)數(shù) → 整數(shù)/浮點(diǎn)數(shù)？不行
# int(z)             # TypeError
# float(z)           # TypeError

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

# 其他類型 → 復(fù)數(shù)
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

# 對(duì)負(fù)數(shù)開方
# math.sqrt(-1)  # ValueError
result = cmath.sqrt(-1)   # 1j
print(result)

# 但cmath.sqrt返回復(fù)數(shù)
print(cmath.sqrt(4))      # (2+0j)——即使結(jié)果是實(shí)數(shù)，也返回complex類型
print(cmath.sqrt(-4))     # 2j——令人困惑的寫法，實(shí)際是0+2j

# 如果你想要實(shí)數(shù)，需要檢查
def safe_sqrt(x):
    """安全開方：正數(shù)返回float，負(fù)數(shù)返回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'>

# 這意味著實(shí)部或虛部也可以是float中的特殊值
z1 = complex(float('inf'), 0)   # (inf+0j)
z2 = complex(0, float('nan'))   # (nanj)
print(z1, z2)