Комплексные числа: тип complex и его методы
Основы работы с комплексными числами в Python
Python поддерживает комплексные числа как встроенный тип данных complex. Комплексное число состоит из действительной и мнимой частей, где мнимая единица обозначается как j или J (в отличие от математической i). Комплексные числа применяются в инженерных расчётах, физике, обработке сигналов и компьютерной графике.
Основной способ создания комплексного числа
Наиболее эффективный способ - использовать литерал в виде a+bj, где a и b - действительные числа. Например:
z = 3 + 4j
print(z) # (3+4j)
print(type(z)) # <class 'complex'>вещественные значения python (вещественные значения в python)
Также используется функция complex(real, imag):
z = complex(3, 4)
print(z) # (3+4j)вывести тип данных python (вывод типа данных в python)
Оба способа эквивалентны. В большинстве случаев литерал удобнее.
Как создать комплексное число из строки?
Функция complex() принимает строку, содержащую представление комплексного числа:
z = complex('3+4j')
print(z) # (3+4j)
z = complex('5-2j')
print(z) # (5-2j)Python двоичные данные (работа с двоичными данными в python)
Строка должна быть без пробелов и содержать символ j. Если строка некорректна, возникает исключение ValueError.
Как получить действительную и мнимую части?
Используйте атрибуты .real и .imag:
z = 5 - 2j
print(z.real) # 5.0
print(z.imag) # -2.0переменная int python какая переменная (переменная int в python - что это?)
Результат всегда число с плавающей точкой.
Как выполнить арифметические операции с комплексными числами?
Все стандартные арифметические операции (+, -, *, /, **) работают с комплексными числами:
a = 1 + 2j
b = 3 - 1j
print(a + b) # (4+1j)
print(a - b) # (-2+3j)
print(a * b) # (5+5j) (1*3 - 2*(-1) + ...)
print(a / b) # (0.1+0.7j)
print(a ** 2) # (-3+4j)комплексные числа в python (комплексные числа в python)
Операция деления на ноль вызывает ZeroDivisionError.
Как вычислить модуль и аргумент комплексного числа?
Модуль (абсолютное значение) находится функцией abs():
z = 3 + 4j
print(abs(z)) # 5.0логические значения python (логические значения в python)
Аргумент (фаза) в радианах - из модуля cmath:
import cmath
z = 1 + 1j
print(cmath.phase(z)) # 0.7853981633974483 (π/4)длина переменной python (длина числа и переменной в python)
Модуль cmath предоставляет множество математических функций для комплексных чисел.
Как использовать функции модуля cmath?
Модуль cmath содержит аналоги математических функций, работающих с комплексными числами:
import cmath
z = 2 + 3j
print(cmath.sqrt(z)) # (1.6741492280355401+0.8959774761298381j)
print(cmath.exp(z)) # (-7.315110094901103+1.042743656400904j)
print(cmath.sin(z)) # (9.15449914691143-4.168906959966565j)
print(cmath.cos(z)) # (-4.189625690968807-9.109227893755337j)определение объекта python (определение типа объекта в python)
Результаты - комплексные числа. Эти функции полезны в научных расчётах.
Как преобразовать комплексное число в вещественные типы?
Преобразование в int или float возможно только если мнимая часть равна нулю:
z = 5 + 0j
print(int(z.real)) # 5
print(float(z.real)) # 5.0определение типа данных python (определение типов данных в python)
Попытка преобразовать комплексное число с ненулевой мнимой частью:
z = 1 + 1j
# int(z) # TypeError: can't convert complex to intPython максимальное целое число (максимальное целое число в python)
Для округления комплексного числа применяется округление отдельно действительной и мнимой частей.
Как округлить комплексное число?
Поскольку прямого метода округления нет, создаётся новое комплексное число с округлёнными частями:
z = 3.14159 + 2.71828j
z_rounded = complex(round(z.real, 2), round(z.imag, 2))
print(z_rounded) # (3.14+2.72j)List values python (список значений словаря в python)
Этот подход позволяет задать точность для каждой части.
Как сравнивать комплексные числа?
Комплексные числа поддерживают только сравнение на равенство (== и !=):
a = 1 + 2j
b = 1 + 2j
print(a == b) # True
print(a != 3j) # Trueчисла с плавающей запятой python (числа с плавающей запятой в python)
Операции <, >, <=, >= приводят к TypeError, так как комплексные числа не образуют упорядоченного поля.
Как перейти от декартовых координат к полярным и обратно?
Функция cmath.polar() возвращает кортеж (модуль, фаза):
import cmath
z = 1 + 1j
print(cmath.polar(z)) # (1.4142135623730951, 0.7853981633974483)является ли числом python (проверка, является ли значение числом в python)
Обратное преобразование - cmath.rect():
r, phi = 2, 0.5
z = cmath.rect(r, phi)
print(z) # (1.7551651237807435+0.958851077208406j)Python пустые значения (пустые значения в python)
Это удобно при работе с амплитудой и фазой.
Как получить сопряжённое комплексное число?
Метод .conjugate() возвращает комплексно-сопряжённое число:
z = 3 - 4j
print(z.conjugate()) # (3+4j)Сопряжение используется для вычисления нормы: z * z.conjugate() даёт квадрат модуля (вещественное число).
Каждый вариант подходит для определённых задач: создание чисел - для ввода данных, арифметика - для расчётов, модуль cmath - для научных вычислений, полярные координаты - для анализа сигналов. Выбор зависит от контекста.
Расширенные примеры работы с комплексными числами
Решение квадратного уравнения с комплексными корнями
Квадратное уравнение ax² + bx + c = 0 может иметь комплексные корни при отрицательном дискриминанте. Программа вычисляет корни с помощью cmath.sqrt:
import cmath
a, b, c = 1, -2, 5
d = b**2 - 4*a*c # дискриминант (работает и для комплексных)
x1 = (-b + cmath.sqrt(d)) / (2*a)
x2 = (-b - cmath.sqrt(d)) / (2*a)
print(f'Корни: {x1} и {x2}')
print(f'Проверка: a*x1**2 + b*x1 + c = {a*x1**2 + b*x1 + c}')Корни: (1+2j) и (1-2j) Проверка: a*x1**2 + b*x1 + c = 0j
Здесь cmath.sqrt корректно обрабатывает отрицательный дискриминант, возвращая комплексное число. Проверка показывает, что подстановка корня даёт ноль (с машинной точностью).
Вычисление амплитуды и фазы синусоидального сигнала
В обработке сигналов комплексные числа представляют гармонические колебания. Пусть сигнал задан как комплексная амплитуда A * exp(j*phi). Амплитуда A - модуль, фаза phi - аргумент:
import cmath
import math
# Комплексная амплитуда: A=5, phi=30°
A = 5
phi_deg = 30
phi_rad = math.radians(phi_deg)
z = cmath.rect(A, phi_rad) # переводим в декартову форму
print(f'Представление сигнала: {z}')
print(f'Модуль (амплитуда): {abs(z)}')
print(f'Фаза (градусы): {math.degrees(cmath.phase(z))}')Представление сигнала: (4.330127018922193+2.5j) Модуль (амплитуда): 5.0 Фаза (градусы): 30.0
Такой подход используется при анализе цепей переменного тока и в цифровой обработке сигналов.
Вычисление корней n-й степени из комплексного числа
Корень n-й степени из комплексного числа имеет n значений. Формула: z^(1/n) = r^(1/n) * exp(j*(phi + 2πk)/n) для k=0..n-1. Пример для кубического корня из 8 (вещественное число, но демонстрация):
import cmath
import math
z = 8 + 0j # комплексная форма
n = 3
r, phi = cmath.polar(z)
root_mag = r ** (1/n)
for k in range(n):
angle = (phi + 2 * math.pi * k) / n
root = cmath.rect(root_mag, angle)
print(f'Корень {k}: {root}')Корень 0: (2+0j) Корень 1: (-1+1.7320508075688772j) Корень 2: (-1-1.7320508075688772j)
Видно, что один корень вещественный, два - комплексно-сопряжённые. Этот метод применяется в теории чисел и при решении дифференциальных уравнений.
Проверка стабильности системы с помощью корней характеристического многочлена
В теории автоматического управления для оценки устойчивости системы находят корни характеристического уравнения. Если все корни имеют отрицательную действительную часть, система устойчива. Пример с полиномом s² + 2s + 5:
import cmath
coeff = [1, 2, 5] # s^2 + 2s + 5
# Корни можно найти аналитически
d = coeff[1]**2 - 4*coeff[0]*coeff[2]
root1 = (-coeff[1] + cmath.sqrt(d)) / (2*coeff[0])
root2 = (-coeff[1] - cmath.sqrt(d)) / (2*coeff[0])
print(f'Корни: {root1}, {root2}')
print(f'Действительные части: {root1.real}, {root2.real}')
if root1.real < 0 and root2.real < 0:
print('Система устойчива')
else:
print('Система неустойчива')Корни: (-1+2j), (-1-2j) Действительные части: -1.0, -1.0 Система устойчива
Здесь действительные части отрицательны, поэтому система устойчива. При наличии положительной действительной части система была бы неустойчивой. Этот критерий широко применяется в инженерной практике.
Использование комплексных чисел в алгоритме БПФ (идея)
Быстрое преобразование Фурье (БПФ) оперирует массивами комплексных чисел. В Python встроенные функции не предоставляют БПФ, но библиотека numpy содержит numpy.fft. Пример на встроенных средствах невозможен без внешних модулей. Однако базовый принцип: каждое комплексное число представляет амплитуду и фазу гармоники. Для иллюстрации можно вычислить дискретное преобразование Фурье (ДПФ) наивным способом:
import cmath
import math
# Входной сигнал (вещественный)
signal = [1, 2, 3, 4]
N = len(signal)
# Вычисляем ДПФ
spectrum = []
for k in range(N):
s = 0+0j
for n in range(N):
angle = -2 * math.pi * k * n / N
s += signal[n] * cmath.rect(1, angle)
spectrum.append(s)
for k, val in enumerate(spectrum):
print(f'k={k}: {val:.2f}')k=0: (10+0j) k=1: (-2+2j) k=2: (-2+0j) k=3: (-2-2j)
Полученные комплексные числа - спектральные компоненты. Этот пример демонстрирует, как комплексные числа участвуют в разложении сигнала на гармоники.
Приведённые примеры охватывают типичные сценарии использования комплексных чисел в научных и инженерных расчётах. Для более сложных задач (матричные операции, БПФ, интегральные преобразования) рекомендуется подключать специализированные библиотеки, такие как numpy и scipy.