Python, комплексные типы для работы с комплексными числами (абсолютные значения, склонение, полярные преобразования и т.д.)

Бизнес

В Python есть стандартный тип для работы с комплексными числами — тип COMPLEX. Если вы хотите выполнять простые вычисления, вам не нужно импортировать какие-либо модули, но если вы импортируете стандартную библиотеку cmath, вы также сможете использовать математические функции (экспоненциальные, логарифмические, тригонометрические и т.д.), соответствующие комплексным числам.

Следующее содержание объясняется здесь с помощью примера кода.

  • Генерировать комплексные переменные
  • Получение действительных и мнимых частей:real,imagатрибут
  • Получение сопряженных комплексных чисел:conjugate()метод
  • Получить абсолютное значение (величину):abs()функция (например, математика, программирование, программирование)
  • Получить склонение (фазу):math,cmathмодуль
  • Преобразование полярных координат (представление в полярной форме):math,cmathмодуль
  • Вычисление комплексных чисел (квадратура, силы, квадратные корни)

Генерировать комплексные переменные

Обозначим мнимую единицу через j и напишем следующее, заметим, что это не i.

c = 3 + 4j

print(c)
print(type(c))
# (3+4j)
# <class 'complex'>

Если мнимая часть равна 1, ее опущение приводит к ошибке NameError. Если переменная с именем j определена первой, она считается этой переменной.

1j
Это должно быть четко сформулировано таким образом.

# c = 3 + j
# NameError: name 'j' is not defined

c = 3 + 1j

print(c)
# (3+1j)

Если действительная часть равна 0, ее можно опустить.

c = 3j

print(c)
# 3j

Если вы хотите определить значение с мнимой частью 0 как сложный комплексный тип, запишите 0 явно. Как описано ниже, между комплексным типом и целочисленным типом или типом с плавающей точкой можно выполнять операции.

c = 3 + 0j

print(c)
# (3+0j)

Вещественная и мнимая части могут быть заданы в виде плавающей запятой. Также допустима экспоненциальная нотация.

c = 1.2e3 + 3j

print(c)
# (1200+3j)

Он также может быть порожден конструктором типа «complex», как в «complex(real part, imaginary part)».

c = complex(3, 4)

print(c)
print(type(c))
# (3+4j)
# <class 'complex'>

Получение действительных и мнимых частей комплексных чисел: real, imagатрибут

Действительную и мнимую части сложного комплексного типа можно получить с помощью атрибутов real и imag соответственно. Оба типа являются типами с плавающей точкой.

c = 3 + 4j

print(c.real)
print(type(c.real))
# 3.0
# <class 'float'>

print(c.imag)
print(type(c.imag))
# 4.0
# <class 'float'>

Он доступен только для чтения и не может быть изменен.

# c.real = 5.5
# AttributeError: readonly attribute

Получение сопряженных комплексных чисел: conjugate()

Чтобы получить сопряженные комплексные числа, используйте метод conjugate().

c = 3 + 4j

print(c.conjugate())
# (3-4j)

Получение абсолютного значения (величины) комплексного числа: abs()

Чтобы получить абсолютное значение (величину) комплексного числа, используйте встроенную функцию abs().

c = 3 + 4j

print(abs(c))
# 5.0

c = 1 + 1j

print(abs(c))
# 1.4142135623730951

Получение склонения (фазы) комплексного числа: math, cmathмодуль

Чтобы получить склонение (фазу) комплексного числа, используйте модуль math или cmath.

Модуль cmath — это модуль математических функций для комплексных чисел.

Его можно вычислить с помощью функции обратного тангенса math.atan2(), как определено, или использовать cmath.phase(), которая возвращает склонение (фазу).

import cmath
import math

c = 1 + 1j

print(math.atan2(c.imag, c.real))
# 0.7853981633974483

print(cmath.phase(c))
# 0.7853981633974483

print(cmath.phase(c) == math.atan2(c.imag, c.real))
# True

В обоих случаях единицей измерения угла, который можно получить, являются радианы. Для преобразования в градусы используйте math.degrees().

print(math.degrees(cmath.phase(c)))
# 45.0

Преобразование полярных координат комплексных чисел (полярное формальное представление): math, cmathмодуль

Как упоминалось выше, можно получить абсолютное значение (величину) и склонение (фазу) комплексного числа, но с помощью cmath.polar() их можно получить вместе в виде кортежа (абсолютное значение, склонение).

c = 1 + 1j

print(cmath.polar(c))
print(type(cmath.polar(c)))
# (1.4142135623730951, 0.7853981633974483)
# <class 'tuple'>

print(cmath.polar(c)[0] == abs(c))
# True

print(cmath.polar(c)[1] == cmath.phase(c))
# True

Преобразование из полярных координат в декартовы осуществляется с помощью cmath.rect(). cmath.rect(абсолютное значение, отклонение) и аналогичные аргументы можно использовать для получения значений эквивалентного комплексного комплексного типа.

print(cmath.rect(1, 1))
# (0.5403023058681398+0.8414709848078965j)

print(cmath.rect(1, 0))
# (1+0j)

print(cmath.rect(cmath.polar(c)[0], cmath.polar(c)[1]))
# (1.0000000000000002+1j)

Действительная и мнимая части эквивалентны результатам, вычисленным косинусом math.cos() и синусом math.sin() по абсолютным значениям и углам склонения.

r = 2
ph = math.pi

print(cmath.rect(r, ph).real == r * math.cos(ph))
# True

print(cmath.rect(r, ph).imag == r * math.sin(ph))
# True

Вычисление комплексных чисел (квадратура, силы, квадратные корни)

Четыре арифметические операции и вычисления мощности могут быть выполнены с помощью обычных арифметических операторов.

c1 = 3 + 4j
c2 = 2 - 1j

print(c1 + c2)
# (5+3j)

print(c1 - c2)
# (1+5j)

print(c1 * c2)
# (10+5j)

print(c1 / c2)
# (0.4+2.2j)

print(c1 ** 3)
# (-117+44j)

Квадратный корень можно вычислить с помощью **0.5, но это вносит ошибку. Для вычисления точного значения можно использовать cmath.sqrt().

print((-3 + 4j) ** 0.5)
# (1.0000000000000002+2j)

print((-1) ** 0.5)
# (6.123233995736766e-17+1j)

print(cmath.sqrt(-3 + 4j))
# (1+2j)

print(cmath.sqrt(-1))
# 1j

Он также может выполнять арифметические операции с комплексными типами, типами int и float.

print(c1 + 3)
# (6+4j)

print(c1 * 0.5)
# (1.5+2j)
Copied title and URL