Комплексные числа python: Числа: целые, вещественные, комплексные | Python 3 для начинающих и чайников

Содержание

Числа: целые, вещественные, комплексные | Python 3 для начинающих и чайников

Числа в Python 3: целые, вещественные, комплексные. Работа с числами и операции над ними.

Целые числа (int)

Числа в Python 3 ничем не отличаются от обычных чисел. Они поддерживают набор самых обычных математических операций:

x + y Сложение
x — y Вычитание
x * y Умножение
x / y Деление
x // y Получение целой части от деления
x % y Остаток от деления
-x Смена знака числа
abs(x) Модуль числа
divmod(x, y) Пара (x // y, x % y)
x ** y Возведение в степень
pow(x, y[, z]) xy по модулю (если модуль задан)

Также нужно отметить, что целые числа в python 3, в отличие от многих других языков, поддерживают длинную арифметику (однако, это требует больше памяти). y Побитовое исключающее или x & y Побитовое и x << n Битовый сдвиг влево x >> y Битовый сдвиг вправо ~x Инверсия битов

Дополнительные методы

int.bit_length() — количество бит, необходимых для представления числа в двоичном виде, без учёта знака и лидирующих нулей.

>>> n = -37
>>> bin(n)
'-0b100101'
>>> n.bit_length()
6

int.to_bytes(length, byteorder, *, signed=False) — возвращает строку байтов, представляющих это число.

>>> (1024).to_bytes(2, byteorder='big')
b'\x04\x00'
>>> (1024).to_bytes(10, byteorder='big')
b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'
>>> (-1024).to_bytes(10, byteorder='big', signed=True)
b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'
>>> x = 1000
>>> x.to_bytes((x.bit_length() // 8) + 1, byteorder='little')
b'\xe8\x03'

classmethod int.from_bytes(bytes, byteorder, *, signed=False) — возвращает число из данной строки байтов.

>>> int.from_bytes(b'\x00\x10', byteorder='big')
16
>>> int.from_bytes(b'\x00\x10', byteorder='little')
4096
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680

Системы счисления

Те, у кого в школе была информатика, знают, что числа могут быть представлены не только в десятичной системе счисления. К примеру, в компьютере используется двоичный код, и, к примеру, число 19 в двоичной системе счисления будет выглядеть как 10011. Также иногда нужно переводить числа из одной системы счисления в другую. Python для этого предоставляет несколько функций:

  • int([object], [основание системы счисления]) — преобразование к целому числу в десятичной системе счисления. По умолчанию система счисления десятичная, но можно задать любое основание от 2 до 36 включительно.
  • bin(x) — преобразование целого числа в двоичную строку.
  • hex(х) — преобразование целого числа в шестнадцатеричную строку.
  • oct(х) — преобразование целого числа в восьмеричную строку.

Примеры:

>>> a = int('19') # Переводим строку в число
>>> b = int('19.5')  # Строка не является целым числом
Traceback (most recent call last):
  File "", line 1, in
ValueError: invalid literal for int() with base 10: '19.5'
>>> c = int(19.5)  # Применённая к числу с плавающей точкой, отсекает дробную часть
>>> print(a, c)
19 19
>>> bin(19)
'0b10011'
>>> oct(19)
'0o23'
>>> hex(19)
'0x13'
>>> 0b10011  # Так тоже можно записывать числовые константы
19
>>> int('10011', 2)
19
>>> int('0b10011', 2)
19

Вещественные числа (float)

Вещественные числа поддерживают те же операции, что и целые. Однако (из-за представления чисел в компьютере) вещественные числа неточны, и это может привести к ошибкам:

>>> 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1
0.9999999999999999

Для высокой точности используют другие объекты (например Decimal и Fraction)).

Также вещественные числа не поддерживают длинную арифметику:

>>> a = 3 ** 1000
>>> a + 0.1
Traceback (most recent call last):
  File "", line 1, in
OverflowError: int too large to convert to float

Простенькие примеры работы с числами:

>>> c = 150
>>> d = 12.9
>>> c + d
162.9
>>> p = abs(d - c)  # Модуль числа
>>> print(p)
137.1
>>> round(p)  # Округление
137

Дополнительные методы

float.as_integer_ratio() — пара целых чисел, чьё отношение равно этому числу.

float.is_integer() — является ли значение целым числом.

float.hex() — переводит float в hex (шестнадцатеричную систему счисления).

classmethod float.fromhex(s) — float из шестнадцатеричной строки.

>>> (10.5).hex()
'0x1.5000000000000p+3'
>>> float.fromhex('0x1.5000000000000p+3')
10.5

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

Модуль math предоставляет более сложные математические функции.

>>> import math
>>> math.pi
3.141592653589793
>>> math.sqrt(85)
9.219544457292887

Модуль random реализует генератор случайных чисел и функции случайного выбора.

>>> import random
>>> random.random()
0.15651968855132303

Комплексные числа (complex)

В Python встроены также и комплексные числа:

>>> x = complex(1, 2)
>>> print(x)
(1+2j)
>>> y = complex(3, 4)
>>> print(y)
(3+4j)
>>> z = x + y
>>> print(x)
(1+2j)
>>> print(z)
(4+6j)
>>> z = x * y
>>> print(z)
(-5+10j)
>>> z = x / y
>>> print(z)
(0.44+0.08j)
>>> print(x.conjugate())  # Сопряжённое число
(1-2j)
>>> print(x.imag)  # Мнимая часть
2.0
>>> print(x.real)  # Действительная часть
1.0
>>> print(x > y)  # Комплексные числа нельзя сравнить
Traceback (most recent call last):
  File "", line 1, in
TypeError: unorderable types: complex() > complex()
>>> print(x == y)  # Но можно проверить на равенство
False
>>> abs(3 + 4j)  # Модуль комплексного числа
5.0
>>> pow(3 + 4j, 2)  # Возведение в степень
(-7+24j)

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

complex комплексные числа | Python

Если вы еще ничего не прочитали о комплексных числах на википедии, то обязательно прочитайте. А если прочитали, но не совсем поняли, хотя, даже если и поняли, мы все равно подробно рассмотрим как устроены и как работают комплексные числа в Python.


Создание комплексных чисел

Мы знаем, что любое комплексное число \(z\) задается его действительной частью \(a\), мнимой частью \(b\) и в нем всегда присутствует символ \(i\), обозначающий мнимую единицу. В Python все практически точно так же, только мнимую единицу обозначают символом j (реже J), а числа \(a\) и \(b\) могут быть любыми числами типа int или float. Например, комплексные числа в Python могут выглядеть следующим образом:

3 + 7j
100.0 + 0.001j
100. + .00j
2e-10 - 2e10j

Кстати, символ мнимой единицы j не может существовать сам по себе, к нему обязательно должно быть присоединено какое-то число, т.е. мнимая единица в Python выглядит как 1j, а любое число у которого действительная часть равна \(0\) можно указывать без нее, например, все вышеуказанные числа без действительной части, для интерпретатора Python считаются приемлемыми:

7j
0.001j
.00j
2e10j

Интуитивно понятно, что если в числе \(a+bi\) мнимая часть \(b=0\), то оно автоматически становится обычным вещественным числом, потому что \(z=a+0i=a\). Но в то же время все вещественные числа, являются подмножеством комплексных, значит число \(a\) это комплексное число у которого мнимая часть равна \(0\). В математике это так, но в Python нет, т.е. автоматического преобразования чисел типа complex в числа типа int или float не происходит, даже если их мнимая часть равна \(0\):

>>> 10 + 0j    #  это число могло бы стать числом типа int
(10+0j)
>>> 
>>> 3.14 - 0j    #  а это могло бы стать float
(3.14+0j)

Наверное, если бы такое преобразование имело место, то это привело бы к противоречиям некоторых математических операций. Здесь следует еще раз напомнить о преобразовании типов и о том что это преобразование работает только в одну сторону:

>>> -1/2    #  результат может быть только типа float
-0.5
>>> 
>>> (-0.5)**0.5    #  результат может быть только типа complex
(4.329780281177467e-17+0.7071067811865476j)

Именно поэтому, комплексное 3.14 - 0j не станет вещественным 3.14. Более того, даже если такие комплексные числа передать встроенным функциям int() или float(), то это приведет к ошибке:

>>> int(2 + 0j)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can't convert complex to int

Для нас очевидно, что раз мнимая часть равна \(0\) то к типу int нужно приводить его действительную часть. Но то что очевидно для нас, не всегда очевидно для интерпретатора. Однако, мы можем работать с отдельными частями комплексного числа с помощью атрибутов real и imag. Так что наше преобразование можно записать так:

>>> int((2 + 0j).real)
2

Особо бдительные, могут заметить, что можно вообще обойтись без функции int() потому что действительная часть числа и так типа int, однако, атрибуты real и imag всегда возвращают вещественный результат (тип float).


Встроенная функция complex()

Встроенная функция complex(real[, imag]) позволяет создать комплексное число на основе значений его действительной и мнимой частей:

>>> complex(1)    #  аргумент imag не обязателен
(1+0j)
>>> 
>>> complex(1, 2e-2)
(1+0.02j)

Приятным сюрпризом данной функции, является то что она может создавать комплексное число из строки. Но с небольшой оговоркой, эта строка должна быть допустимым литералом комплексного числа:

>>> complex('1+2j')
(1+2j)
>>> complex('0.1+2.0j')
(0.1+2j)
>>> complex('.1+2.j')
(0.1+2j)
>>> complex('1e3+2e-3j')
(1000+0.002j)

Учитывая, что на месте действительной и мнимой части могут находиться только целые и вещественные числа, то как видите, способов ввода строк комплексных чисел становится довольно много. Однако, следует помнить, что пробельные символы являются недопустимыми:

>>> complex('1e3 + 2e-3j')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: complex() arg is a malformed string

Представление на комплексной плоскости

Целые и вещественные числа в геометрическом представлении являются точками на числовом луче:

Геометрическим представлением комплексных чисел являются точки на плоскости. Данная плоскость называется комплексной и абсолютно аналогична прямоугольной системе координат, только по оси абцис (x) откладывается величина действительной части (real), а по оси ординат (y) ооткладывается величина мнимой части (imag). Например, точка \(A(3, 4)\) и комплексное число \(z = 3 + 4i\) будут выглядеть вот так:

Как видите, изображение комплексных чисел на плоскости довольно простой процесс, по сути это те же самые декартовы координаты, которые получаются по правилу: \(x=\mathrm {Re} \,z; \quad y=\mathrm {Im} \,z\). А в Python получение тех же координат будет выглядеть аналогично:

>>> z = 3 + 4j
>>> 
>>> z.real, z.imag
(3.0, 4.0)

Изображение комплексных чисел еще и весьма удобно, так как позволяет наглядно изображать арифметические операции над ними.


Арифметические операции

Сложение двух комплексных чисел \(A=a+bi\) и \(B=c+di\) выполняется по простой формуле:

$$A+B = \left(a+bi\right)+\left(c+di\right)=\left(a+c\right)+\left(b+d\right)i$$

Python выполняет все промежуточные действия за нас, сразу выдавая результат:

>>> a = -5 + 3j
>>> b = 4 + 2j
>>> 
>>> a + b
(-1+5j)

На предыдущем рисунке мы видели, что комплексное число это точка на комплексной плоскости. Но если заметить что значения действительной и мнимой части отсчитываются от начала координат, то уместно задать вопрос: «А нельзя ли изображать эти числа в виде векторов?» Ответ: «Можно.» Данные числа действительно можно рассматривать как радиус-векторы:

Разность комплексных чисел задается похожим образом:

$$A-B = \left(a+bi\right)-\left(c+di\right)=\left(a-c\right)+\left(b-d\right)i$$

Умножение комплексного числа на вещественное число выполняется очень просто: \(kA = k\left(a+bi\right)=ka + kbi\) и по сути просто меняет лишь длину радиус вектора комплексного числа, вдоль его направления:

>>> a = 2 + 2j
>>> 
>>> a*2
(4+4j)
>>> 
>>> a*(-1.5)
(-3-3j)

А вот умножение комплексных чисел друг на друга немного сложнее:

$$(a+bi)\cdot (c+di)=(ac-bd)+(bc+ad)i$$

Как всегда в Python мы сразу видим результат:

>>> a = 1 + 1j
>>> b = 1 + 4j
>>> 
>>> a*b
(-3+5j)

Который на комплексной плоскости выглядит вот так:

Можно было бы предположить, что это что-то вроде векторного или скалярного умножения векторов, но нет, умножение комплексных чисел, отличается от этих двух операций.{2}}}\right)i$$

Давайте посмотрим как это выглядит в Python и на комплексной плоскости:

>>> a = -5 - 1j
>>> b = -1 + 1j
>>> 
>>> a/b
(2+3j)


Математические операции

Комплексные числа поддерживают не все математические операции и не все операции сравнения, а побитовые операции не поддерживаются вообще. Дело в том, что комплексные числа являются «двумерными», что на первый взгляд вовсе не кажется помехой для таких операций как целочисленное деление или остаток от деления. На на самом деле введение таких операций приводит к неопределенностям, которые невозможно преодолеть. К тому же, такие операции как < и > так же не могут быть выполнены просто потому, что мы не знаем какая из двух точек на плоскости будет больше другой, а какая меньше.

Неподдерживаемые комплексными числами математические операции выделены красным цветом и оставлены в таблице, потому что они формально могут присутствовать в математических выражениях содержащих числа типа int и float. Все операции отсортированы по убыванию приоритета:

Операция Результат Замечание
1 x ** y возводит x в степень y (I)
2 pow(x, y[, z]) возводит x в степень y по модулю z, где z – необязательный аргумент. Если указан параметр z, то это приведет к ошибке ValueError (I)
3 divmod(x, y) возвращает кортеж с парой чисел (x // y, x % y) (II)
4 x.conjugate() возвращает \(\bar{x}\) — число, которое комплексно сопряжено с \(x\)
5 complex(re, im) преобразует re в комплексное число (по умолчанию im = 0) (V)(VI)
6 float(x) преобразует x в вещественное число (число с плавающей точкой). Если x комплексное, то будет вызвано исключение TypeError (VI)
7 int(x) переобразует x в целое число, представленное в десятичной системе счисления. Если x комплексное, то будет вызвано исключение TypeError (VI)
8 abs(x) абсолютное значение (модуль) числа x (III)
9 +x делает число x положительным
10 -x делает число x отрицательным
11 x % y остаток от деления x на y (II)
12 x // y результат целочисленного деления x на y (II)
13 x / y результат «истинного» деления x на y (IV)
14 x * y произведение x и y
15 x - y разность x и y
16 x + y сумма x и y

Важно: приоритет математических операций выше операций сравнения.

Замечания:

I. возведение \(0+0i\) в степень \(0+0i\) возвращает \(1+0i\):

>>> c = 0 + 0j
>>> c
0j
>>> 
>>> c**c
(1+0j)

II. функция divmod() и операция %, // не работают для комплексных чисел. Для вас это может быть и очевидно, но не пользователя для которого вы пишите программу.

III. Функция abs() всегда возвращает результат типа float.

IV. деление на \(0+0i\) приведет к ошибке и вызовет исключение ZeroDivisionError.

V. встроенная функция complex() пропускает числа (объекты) типа complex «как есть», не выполняя над ними, абсолютно никаких действий.

VI. строго говоря эти функции не являются математическими, но они могут учавствовать в математических выражениях Python и поэтому должны обладать приоритетом.


Операции сравнения

Для сравнения чисел имеется \(8\) операций, но для комплексных чисел доступно только \(4\) причем все они имеют одинаковый приоритет:

Операция Результат Замечание
1 x < y True если x меньше y, иначе False (I)
2 x <= y True если x меньше или равно y, иначе False (I)
3 x > n True если x больше y, иначе False (I)
4 x >= n True если x больше или равно y, иначе False (I)
5 x == y True если x равно y, иначе False
6 x != y True если x не равно y, иначе False
7 x is y True если x и y это один и тот же объект, иначе False
8 x is not y True если x и y это не один и тот же объект, иначе False

Важно: приоритет операций сравнения ниже математических.

I. эти операции могут присутствовать в математических выражениях, но если операндами являются комплексные числа или одним из них является комплексным числом, то это приведет к ошибке и вызовет исключение TypeError:

>>> a = 3+4j
>>> 
>>> abs(a) < 6
True
>>> 
>>> a < 6
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unorderable types: complex() < int()

cmath | Python

Модуль cmath предоставляет доступ к функциям, которые могут выполнять математические действия над комплексными числами. Помимо комплексных чисел, аргументами данных функций могут быть как целые так и вещественные (с плавающей точкой) числа, а так же любые объекты языка Python с методами __complex__() или __float__(), необходимые для преобразования комплексных чисел в вещественные и наоборот.

Некоторые функции комплексного переменного являются многозначными, поэтому для них необходимо определить ту область в которой их значение будет однозначным, а сама функция непрерывна. Такие области называются листами, а их края разрезами.

Наличие модуля cmath наряду с модулем math необходимо лишь потому что зачастую, комплексные числа вовсе не нужны. Например, кого-то сбивает с толку выражение:

>>> (-1)**0.5
(6.123233995736766e-17+1j)

Потому что некоторая часть программистов, вообще никак не связана с математикой и для них такое поведение не то что бы является странным — оно вообще является нежелательным. Поэтому они и пользуются библиотекой math, которая в этом случае просто выдаст ошибку:

>>> import math
>>> 
>>> math.sqrt(-1)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: math domain error

Модуль cmath в свою очередь, всегда возвращает комплексные числа, даже если для вывода достаточно целого или вещественного типа данных, просто множитель перед мнимой единицей будет равен нулю:

>>> cmath.sin(0)
0j
>>> cmath.sin(-0.0)
(-0+0j)

Степенные и логарифмические функции

cmath.exp(x)¶
вычисляет экспоненту комплексного числа.

Для комплексного числа \(x = a+ib\) экспонента определяется как \(e^{x}=e^{a}e^{ib}\), где \(e^{a}\) – это экспонента вещественного числа, а \(e^{ib}\) – это \(\cos b + i\sin b\).

>>> import cmath
>>> 
>>> cmath.exp(0+0j)
(1+0j)
>>> 
>>> 
>>> x = 0 + (cmath.pi/2)*1j
>>> cmath.exp(x)
(6.123233995736766e-17+1j)
>>> 
>>> cmath.e**x
(6.123233995736766e-17+1j)
cmath.log(x[, base])¶
вычисляет логарифм комплексного числа с указанным основанием, если основание не указано, то возвращается значение натурального логарифма.

Для данной функции определен единственный, непрерывный сверху разрез главной ветви вдоль отрицательной действительной оси от \(0\) до \(-\infty\).

Как правило, на практике используется именно натуральный логарифм (обозначается \(\mathrm {Ln} \,z\) ), который так же как и логарифм для других оснований, определяется как функция обратная к показательной.{\omega}=x\).

>>> import cmath
>>> 
>>> cmath.log(1 + 0j)
0j
>>> 
>>> cmath.log(0 + 1j)
1.5707963267948966j
>>> 
>>> 
>>> cmath.log(1 + 1j, 2)
(0.5+1.1330900354567985j)
cmath.log10(x)¶
вычисляет десятичный логарифм комплексного числа.

Имеет тот же разрез главной ветви, что и log().

>>> import cmath
>>> 
>>> x = 10**(2 + 0.5j)
>>> x
(40.73073101539468+91.32911666577952j)
>>> 
>>> cmath.log10(x)
(2+0.5j)
cmath.sqrt(x)¶
вычисляет квадратный корень комплексного числа.

Имеет тот же разрез главной ветви, что и log().

Для одного комплексного числа всегда существуют два значения его квадратного корня, например:

>>> (2 - 1j)**2, (-2 + 1j)**2
((3-4j), (3-4j))

Но с учетом разреза главной ветви, будет возвращено только одно из них, имеющее положительную действительную часть:

>>> import cmath
>>> 
>>> cmath.sqrt(3 - 4j)
(2-1j)

Полярные координаты

Комплексное число в языке Python представляется в виде координаты точки на плоскости с прямоугольной системой координат и хранится в виде:

z == z.real + z.imag*1j

где z.real – это действительная часть (соответствует оси \(x\)), z.imag – мнимая часть (соответствует оси \(y\)), 1j – мнимая единица в языке Python.

Однако, помимо представления комплексных чисел в прямоугольной системе координат, существует еще один альтернативный способ — представление в полярной системе координат. В полярных координатах комплексное число определяется его модулем – длиной радиус-вектора \(\bar{r}\), соединяющим начало координат и точку \(z\), и, его аргументом – углом \( \varphi \) между радиус вектором и положительной частью оси \(x\), откладываемым против часовой стрелки, который еще называют фазовым углом или фазой.

Представленные ниже функции позволяют переводить комплексные числа из одной системы координат в другую.

cmath.phase(x)¶
Возвращает фазу (так же известную как фазовый угол или аргумент) комплексного числа.

Данная функция эквивалентна команде math.atan2 (x.imag, x.real), т.е. это арктангенс, который возвращает значения из интервала \([-\pi;\pi]\) (в радианах) причем, возвращаемое значение фазы будет находиться в правильном квадранте, так как знаки x.imag и x.real известны.

Для данной функции определен единственный, непрерывный сверху разрез главной ветви вдоль отрицательной действительной оси от \(0\) до \(-\infty\). В системах с поддержкой нулей со знаком (в которых \(-0\) и \(0\) это разные числа) т.е. в большинстве систем, знак результата совпадает с x.imag, даже если x.imag = 0, например:

>>> import cmath
>>> 
>>> cmath.phase(complex(-5.0, 0.0))
3.141592653589793
>>> 
>>> cmath.phase(complex(-5.0, -0.0))
-3.141592653589793

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

>>> import cmath, math
>>> 
>>> phi = cmath.phase(3 + 3j)
>>> phi
0.7853981633974483
>>> 
>>> math.degrees(phi)
45.0

В модуле cmath нет функции для вычисления модуля комплексного числа, если вам необходимо вычислить его воспользуйтей функцией abs() модуля math.

cmath.polar(x)¶
Возвращает полярные координаты комплексного числа.

Возвращает кортеж вида (r, phi), где \(r\) – это модуль комплексного числа, a phi – это его фазовый угол \(\varphi\). Данная функция эквивалентна команде (math.abs(x), cmath.phase(x)).

>>> import cmath
>>> 
>>> x = cmath.polar(3 - 3j)
>>> x
(4.242640687119285, -0.7853981633974483)
>>> 
>>> r, phi = x
>>> 
>>> cmath.rect(r, phi)
(3-2.9999999999999996j)
cmath.rect(r, phi)¶
вычисляет действительную и мнимую части комплексного числа по его полярным координатам и возвращает полученное число.

Данная функция эквивалентна команде r*(math.cos(phi) + math.sin(phi)*1j).

>>> import cmath
>>> 
>>> cmath.rect(7, 0.7)
(5.35389531099142+4.509523810663837j)
>>> 
>>> cmath.polar(cmath.rect(7, 0.7))
(7.000000000000001, 0.6999999999999998)

Тригонометрические функции

cmath.sin(x)¶
возвращает синус комплексного числа.
>>> import cmath
>>> 
>>> cmath.sin(0)
0j
>>> cmath.sin(1)
(0.8414709848078965+0j)
>>> 
>>> cmath.sin(1 + 1j)
(1.2984575814159773+0.6349639147847361j)
>>> 
>>> cmath.asin(cmath.sin(1 + 1j))
(1+1j)
cmath.cos(x)¶
возвращает косинус комплексного числа.
>>> import cmath
>>> 
>>> cmath.cos(0)
(1-0j)
>>> 
>>> cmath.cos(1)
(0.5403023058681398-0j)
>>> 
>>> cmath.cos(1 + 1j)
(0.8337300251311491-0.9888977057628651j)
>>> 
>>> cmath.acos(cmath.cos(1 + 1j))
(0.9999999999999999+1j)
cmath.tan(x)¶
возвращает тангенс комплексного числа.
>>> import cmath
>>> 
>>> cmath.tan(0)
0j
>>> 
>>> cmath.tan(1)
(1.5574077246549023+0j)
>>> 
>>> cmath.tan(1 + 1j)
(0.27175258531951174+1.0839233273386946j)
>>> 
>>> cmath.atan(cmath.tan(1 + 1j))
(1+1j)
cmath.asin(x)¶
возвращает арксинус комплексного числа.

Для данной функции заданы два разреза главной ветви, оба вдоль действительной оси: первый \((-\infty , -1]\) непрерывный сверху, второй \([1 , +\infty)\) непрерывный снизу.

>>> import cmath
>>> 
>>> x = cmath.sin(1 + 1j)
>>> x
(1.2984575814159773+0.6349639147847361j)
>>> 
>>> cmath.asin(x)
(1+1j)
cmath.acos(x)¶
возвращает арккосинус комплексного числа.

Для данной функциидва заданы два разреза главной ветви, оба вдоль действительной оси: первый \((-\infty , -1]\) непрерывный сверху, второй \([1 , +\infty)\) непрерывный снизу.

>>> import cmath
>>> 
>>> x = cmath.cos(1 + 1j)
>>> x
(0.8337300251311491-0.9888977057628651j)
>>> 
>>> cmath.acos(x)
(0.9999999999999999+1j)
cmath.atan(x)¶
возвращает арктангенс комплексного числа.

Для данной функциидва заданы два разреза главной ветви, оба вдоль мнимой оси: первый \((-\infty i , -1i]\) непрерывный слева, второй \([1i , +\infty i)\) непрерывный справа.

>>> import cmath
>>> 
>>> x = cmath.tan(1 + 1j)
>>> x
(0.27175258531951174+1.0839233273386946j)
>>> 
>>> cmath.atan(x)
(1+1j)

Гиперболические функции

cmath.sinh(x)¶
возвращает гиперболический синус комплексного числа.
>>> import cmath
>>> 
>>> cmath.sinh(3)
(10.017874927409903+0j)
>>> 
>>> cmath.sinh(1 + 1j)
(0.6349639147847361+1.2984575814159773j)
cmath.cosh(x)¶
возвращает гиперболический косинус комплексного числа.
>>> import cmath
>>> 
>>> cmath.cosh(0)
(1+0j)
>>> 
>>> cmath.cosh(3)
(10.067661995777765+0j)
>>> 
>>> cmath.cosh(1 + 1j)
(0.8337300251311491+0.9888977057628651j)
cmath.tanh(x)¶
возвращает гиперболический тангенс комплексного числа.
>>> import cmath
>>> 
>>> cmath.tanh(0)
0j
>>> 
>>> cmath.tanh(3)
(0.9950547536867305+0j)
>>> 
>>> cmath.tanh(1 + 1j)
(1.0839233273386946+0.27175258531951174j)
cmath.asinh(x)¶
возвращает гиперболический арксинус комплексного числа.

Для данной функциидва заданы два разреза главной ветви, оба вдоль мнимой оси: первый \((-\infty i , -1i]\) непрерывный слева, второй \([1i , +\infty i)\) непрерывный справа.

>>> import cmath
>>> 
>>> x = cmath.sinh(1 + 1j)
>>> x
(0.6349639147847361+1.2984575814159773j)
>>> 
>>> cmath.asinh(x)
(1+1j)
cmath.acosh(x)¶
возвращает гиперболический арккосинус комплексного числа.

Для данной функции задан один разрез главной ветви вдоль вещественной оси \((- \infty, 1]\) непрерывный сверху.

>>> import cmath
>>> 
>>> x = cmath.cosh(1 + 1j)
>>> x
(0.8337300251311491+0.9888977057628651j)
>>> 
>>> cmath.acosh(x)
(1+0.9999999999999999j)
cmath.atanh(x)¶
возвращает гиперболический арктангенс комплексного числа.

Для данной функциидва заданы два разреза главной ветви, оба вдоль действительной оси: первый \((-\infty , -1]\) непрерывный сверху, второй \([1 , +\infty)\) непрерывный снизу.

>>> import cmath
>>> 
>>> x = cmath.tanh(1 + 1j)
>>> x
(1.0839233273386946+0.27175258531951174j)
>>> 
>>> cmath.atanh(x)
(1+1j)

Классифицирующие функции

cmath.isfinite(x)¶
возвращает True если вещественная и (или) мнимая части не равны inf, -inf или nan.
>>> import cmath, math
>>> 
>>> x = complex(math.inf, 3)
>>> y = complex(3, -math.inf)
>>> z = complex(3, math.nan)
>>> 
>>> x, y, z
((inf+3j), (3-infj), (3+nanj))
>>> 
>>> cmath.isfinite(x)
False
>>> cmath.isfinite(y)
False
>>> cmath.isfinite(z)
False
>>> 
>>> 
>>> cmath.isfinite(1000 + 0.001j)
True

Доступно в Python c версии 3.2.

cmath.isinf(x)¶
возвращает True только если вещественная и (или) мнимая части равны inf, -inf.
>>> import cmath, math
>>> 
>>> x = complex(math.inf, 3)
>>> y = complex(3, -math.inf)
>>> z = complex(3, math.nan)
>>> 
>>> x, y, z
((inf+3j), (3-infj), (3+nanj))
>>> 
>>> cmath.isinf(x)
True
>>> cmath.isinf(y)
True
>>> cmath.isinf(z)
False
cmath.isnan(x)¶
возвращает True только если вещественная и (или) мнимая части равны nan.
>>> import cmath, math
>>> 
>>> x = complex(math.nan, math.nan)
>>> y = complex(3, math.nan)
>>> z = complex(300, 300)
>>> 
>>> x, y, z
((nan+nanj), (3+nanj), (300+300j))
>>> 
>>> cmath.isnan(x)
True
>>> cmath.isnan(y)
True
>>> cmath.isnan(z)
False
cmath.isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0)¶
возвращает True если в пределах указанной точности, числа a и b близки настолько, что их можно считать равными.

Допустим у нас есть два числа и мы знаем, что по сути это одно и то же число, а все мизерные различия связаны с ошибками округления и двоичной арифметикой. Мы то понимаем что это как бы одно и то же число, а вот компьютер считает иначе:

>>> import cmath
>>> 
>>> x = 1 + 1j
>>> 
>>> y = cmath.acos(cmath.cos(x))
>>> y
(0.9999999999999999+1j)
>>> 
>>> 
>>> x == y
False

Для таких ситуаций, в которых мы готовы считаться с некоторой погрешностью и подходит функция isclose():

>>> cmath.isclose(x, y)
True

Считать числа близкими или нет, определяют два параметра rel_tol и abs_tol().

rel_tol (relative tolerances) – это относительный допуск, определяемый как максимально допустимая разница между числами a и b относительно большего из них по модулю. По умолчанию, rel_tol = 1e-09, это гарантирует, что числа a и b будут одинаковы, в пределах 9 десятичных цифр. Что бы числа считались равными, если они, допустим, отличаются меньше чем на 0.1%, то достаточно установить rel_tol = 0.001, но в любом случае данный параметр, должен быть больше нуля:

>>> y
(0.9999999999999999+1j)
>>> 
>>> z = 0.999 + 1j
>>> 
>>> cmath.isclose(y, z)
False
>>> 
>>> cmath.isclose(y, z, rel_tol = 0.001)
True

Параметр abs_tol (absolute tolerances) – это минимальный абсолютный допуск, который определяет как сравнивать значения близкие к нулю. Данный параметр должен быть не меньше нуля:

>>> x = 2**(-1000) + 3**(-100)*1j
>>> x
(9.332636185032189e-302+1.9403252174826328e-48j)
>>> 
>>> y = 0.000000000001 + 0.000000000001j
>>> y
(1e-12+1e-12j)
>>> 
>>> cmath.isclose(x, y)
False
>>> cmath.isclose(x, y, abs_tol = 10.0e-13)
False
>>> cmath.isclose(x, y, abs_tol = 10.0e-12)
True

Данная функция эквивалентна команде abs(a - b) <= max(rel_tol*max(abs(a), abs(b)), abs_tol). Значения inf, -inf считаются близкими только сами к себе, а NaN не является близким ни к одному значению, включая само NaN.


Математические константы

cmath.pi¶
математическая константа \( \pi\) в виде числа типа float.
>>> import cmath
>>> 
>>> cmath.pi
3.141592653589793
cmath.e¶
математическая константа \( e\) в виде числа типа float.
>>> import cmath
>>> 
>>> cmath.e
2.718281828459045

Комплексное число в python — CodeRoad

Как написать комплексное число в python? Действительно у меня есть:

import math
a=3
b=4
function=a*j*x+b*y

Я не хочу писать непосредственно 3j в своей функции, так как я абсолютно хочу использовать a, так как же преобразовать a в комплексное число? Причина в matlab он работает при печати :

a=3
b=a*i

Результат даст: 0 + 3.0000i

Спасибо за ваши ответы.

python

matlab

complex-numbers

Поделиться

Источник


user3263704    

05 февраля 2014 в 09:14

3 ответа


  • Почему мое целое число рассматривается python как комплексное число?

    Я только что начал курс в Python и попробовал этот код: import math c = int(input(‘Enter number: ‘)) a = 1 counter = 0 while counter != 2: a = a + 1 b = round((c-(a**3))**(1/3.0)) if a < b and a**3 + b**3 == c: counter = counter + 1 print(a,b) Моя проблема заключается в том, что python не может…

  • комплексное число в полярную форму в python

    Я новичок в python, так что, пожалуйста, потерпите меня. Проблема: Напишите функцию polar (z), чтобы преобразовать комплексное число в его полярную форму (r, тета). Вы можете использовать функции math.atan2 и math.hypot, но не библиотеку cmath. Я даже не знаю, с чего начать, но пока у меня есть:…



3

j сам по себе является переменной, вы можете получить комплексное число, набрав 1j

>>> type(j)
NameError: name 'j' is not defined
>>> type(1j)
<type 'complex'>

Таким образом, ваш код может быть написан как функция, как

def function(x, y):
    a = 3
    b = 4
    return a*1j*x+b*y

Поделиться


Rems    

05 февраля 2014 в 09:35



2

Вы можете использовать функцию complex для создания комплексного числа из переменных:

>>> a = 3
>>> b = 4
>>> complex(a, b)
(3+4j)

Поделиться


Ashwini Chaudhary    

05 февраля 2014 в 09:15



0

Вы можете просто использовать встроенную функцию Python complex()

>>> first_number = 10
>>> second_number = 15
>>> complex(first_number, second_number)
(10+15j)

Поделиться


Maninder Singh    

05 февраля 2014 в 09:22


Похожие вопросы:

Считайте комплексное число Fortran в Python

Я пытаюсь прочитать файл (сгенерированный с помощью Fortran) с комплексными числами в Python. Скажем, после использования a = f1.readline().split( ) я получаю следующее значение для a : a =…

random комплексное число

мне нужен алгоритм для генерации random комплексного числа, пожалуйста, помогите, я знаю, как генерировать random число, но random комплексное число сбивает меня с толку

как изменить комплексное число python

После создания Python комплексных чисел доступны только для чтения. >>> x = complex(1,1) >>> x (1+1j) >>> x.real=2 Traceback (most recent call last): File <stdin>,…

Почему мое целое число рассматривается python как комплексное число?

Я только что начал курс в Python и попробовал этот код: import math c = int(input(‘Enter number: ‘)) a = 1 counter = 0 while counter != 2: a = a + 1 b = round((c-(a**3))**(1/3.0)) if a < b and…

комплексное число в полярную форму в python

Я новичок в python, так что, пожалуйста, потерпите меня. Проблема: Напишите функцию polar (z), чтобы преобразовать комплексное число в его полярную форму (r, тета). Вы можете использовать функции…

Вывести комплексное число

Используя embarcadero XE7 и System.VarCmplx-нужно представить комплексное число в виде строки. Простой пример, когда создается комплексное число и цель состоит в том, чтобы показать его в заголовке…

Комплексное число в R

Я знаю, что вы можете легко определить комплексное число z, например, сделав : z <- 3 + 2i . Но когда я хочу определить функцию, которая создает комплексное число: f <- function(x,y){ x + yi }…

yaml комплексное число дампа

Я загрузил комплексное число в свою структуру yaml, и при сбросе его вывод получается не совсем то, что я хотел бы иметь : obj={‘val’: -0.3+0.1j} yaml.dump(obj, default_flow_style=False) val:…

Есть ли способ преобразовать комплексное число в простое число?

Итак, у меня есть это длинное число (т. е. 1081546747036327937), и когда я очистил свои данные в pandas dataframe, я не понял, что Python преобразовал его в комплексное число (т. е….

истекшее время выполнения программы в python возвращает комплексное число

я хочу вычислить прошедшее время в строке моей программы python. start = time.time() #do something here end = time.time() elapsed = end — start print(elapsed) я получаю комплексное число вместо…

Python Numpy-комплексные числа — существует ли функция для преобразования полярных чисел в прямоугольные?

Существует ли встроенная функция Numpy для преобразования комплексного числа в полярной форме, величины и угла (градусов) в единицу в действительной и мнимой компонентах?

Ясно, что я мог бы написать свой собственный, но это похоже на то, для чего существует оптимизированная версия, включенная в какой-то модуль?

Более конкретно, у меня есть массив величин и массив углов:

>>> a
array([1, 1, 1, 1, 1])
>>> b
array([120, 121, 120, 120, 121])

И вот чего бы мне хотелось:

>>> c
[(-0.5+0.8660254038j),(-0.515038074+0.8571673007j),(-0.5+0.8660254038j),(-0.5+0.8660254038j),(-0.515038074+0.8571673007j)]

python

numpy

complex-numbers

Поделиться

Источник


atomh43ls    

08 мая 2013 в 15:36

5 ответов




18

Нет функции, которая делала бы именно то, что вы хотите, но есть угол , который делает самую трудную часть. Так, например, можно определить две функции:

def P2R(radii, angles):
    return radii * exp(1j*angles)

def R2P(x):
    return abs(x), angle(x)

Эти функции используют радианы для ввода и вывода, а для градусов нужно было бы выполнить преобразование в радианы в обеих функциях.

В справочнике numpy есть раздел, посвященный обработке комплексных чисел, и именно здесь будет указана функция, которую вы ищете (так что, поскольку их там нет, я не думаю, что они существуют в пределах numpy).

Поделиться


tom10    

08 мая 2013 в 15:51



4

В предыдущем ответе есть ошибка, которая использует numpy.vectorize — cmath.rect не является модулем, который можно импортировать. Numpy также предоставляет функцию deg2rad, которая обеспечивает более чистый фрагмент кода для преобразования угла. Другая версия этого кода может быть:

import numpy as np
from cmath import rect

nprect = np.vectorize(rect)

c = nprect(a, np.deg2rad(b))

Код использует функцию векторизации numpy для возврата версии numpy стиля функции cmath.rect стандартной библиотеки, которая может быть применена по элементам к массивам numpy.

Поделиться


dyqik    

05 января 2015 в 21:34



1

Я использовал cmath с itertools :

from cmath import rect,pi
from itertools import imap
b = b*pi/180                   # convert from deg to rad
c = [x for x in imap(rect,a,b)]

Поделиться


atomh43ls    

08 мая 2013 в 16:11



0

import numpy as np
import cmath.rect

nprect = np.vectorize(rect)

c = nprect(a,b*np.pi/180)

Поделиться


Kees    

01 января 2015 в 15:57



0

ответ tom10 работает нормально… вы также можете расширить формулу Эйлера до:

def P2R(A, phi):
    return A * ( np.cos(phi) + np.sin(phi)*1j )

Поделиться


Thomio    

27 июня 2018 в 02:27


Похожие вопросы:

Numpy массивы, причудливая индексация, комплексные числа

Следующий код умножает часть массива на число def mul_by_num(a,b): a[0:2] *= b import numpy as np a = np.ones(5,dtype=np.float64) mul_by_num(a,1.0) mul_by_num(a,1j) #Generates a warning (and casts…

Существует ли функция numpy max min?

Существует ли функция numpy, которая дает для данного массива numpy его максимальное-минимальное значение, т. е. numpy.max(a) — numpy.min(a)? напр. numpy.xxx([4,3,2, 6] = 4 since max = 6, min = 2, 6…

Существует ли какая-либо функция php для преобразования текстовых чисел в числа? Например: преобразование(«nine») выходов 9

Возможный Дубликат : Преобразование слов в числа в PHP Мне нужна функция для преобразования текстовых чисел в числа. Например: преобразование(nine) выходов 9 Я знаю, что мог бы написать функцию,…

Как читать комплексные числа из файла с помощью python

Я хочу прочитать из файла набор комплексных чисел в массив, используя Python. Я знаю, как это сделать только для целых чисел. Я попробовал это сделать ,но когда я запускаю его, он говорит: complex()…

Существует ли функция numpy для преобразования из log (e) в log(10)?

Есть один numpy функцию преобразования входа(е) номера журнала(10) чисел? Если да, то будет ли одна функция быстрее, чем этот код? y = np.array([1, 2, 3, 4]) np.log10(np.500). Я хотел…

Python оператор экспоненты и комплексные числа

Почему python возвращает print(type(-1**0.5)) float вместо complex ? Получение квадратного корня из отрицательного целого числа float всегда математически рассматривают как комплексные числа. Как…

Существует ли быстрая функция Python для превращения чисел в разные основания?

Я пишу код, чтобы проверить, сколько раз число является палиндромом в основаниях 2-10. Существует ли функция python для преобразования чисел в различные базы? Я уже пробовал вручную создать функцию,…

Переменные, включающие комплексные числа в Fortran

Существует ли программа, разработанная в Fortran, позволяющая интерполяцию (или экстраполяционное исчисление) переменных, включающих комплексные числа (z = x + i y) … На самом деле у меня есть…

Играемся с комплексными числами / Хабр

Привет!

Очередной очерк. На этот раз поиграемся с комплексными числами, с формулами и их визуализацией.

Идея

Комплексное число — это некоторое расширение вещественного числа, по сути вектор, для которого определено целое множество аксиом. Любое комплексное (а значит и вещественное) число можно записать в виде

, где a — вещественная часть, b — мнимая, i — корень уравнения

. Для него определено много операций, которые определены для вещественного числа, к примеру,

. Интересно, что если проделывать различные операции с ними, возводить в степень, умножать и т. д. а затем брать

(вещественную часть) для оси Ox, а

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

Кстати все следующие формулы я сам придумал.

Функция визуализации

Рутина. Функция, которая по данной итеративной функции рисует все на поле:

import random
import numpy as np
def vis(A, f, step=1.0, c=None):
    x = []
    y = []
    for B in np.arange(0, A, step):
        v = f(A, B)
        x.append(v.real)
        y.append(v.imag)
    plt.figure(figsize=[8, 8])
    mxabs = max([i[0] ** 2 + i[1] ** 2 for i in zip(x, y)]) ** 0.5
    x = np.array(x) / mxabs
    y = np.array(y) / mxabs
    if c is None:
        plt.scatter(x, y)
    else:
        plt.scatter(x, y, color=[c(x[i], y[i]) for i in range(len(x))])
    plt.show()

Все наши функции зависят от двух параметров A и B. Причем по B мы итерируемся внутри vis(), а A — глобальный параметр функции.

Функция «Завитушки»

Ее объявление в python:

def func_1(A, B):
    return math.sin(B) * B * math.e ** (1j * (B * math.cos(A)))

И запустим

A = 121.5
vis(A, func_1, step=0.1)

И результат для A=121.5:

И для A=221.5:

Заметьте, эти числа вовсе не следуют из расчета какого-нибудь определенного интеграла на гладком многообразии и других умных бессмысленных в этом контексте слов. Это действительно рандомные числа, и существует еще ровно бесконечность разных A, в результате которых получается красота.

Надо покрасить

Объявим функцию цвета (такую функцию, которая по координатам возвращает tuple из трех чисел):

def sigm(x):  # Эта функция позволяет нормализировать все что угодно от 0 до 1
    return (1 / (1 + 1.2 ** (-x*50)) - 0.5) * 2

color_1 = lambda x, y: (0.2, sigm(x ** 2 + y ** 2) / 1.4, 1 - sigm(x ** 2 + y ** 2))
color_2 = lambda x, y: (sigm(x ** 2 + y ** 2), 0.5, 0.5)

Выберем рандомный параметр A, пусть будет 149:

vis(149, func_1, step=0.1, c=color_1)

Функция «Гуси»

Гуси описываются так:

Объявление на python:

def func_2(A, B):
    return math.cos(B) * math.sin(B) * B * math.e ** (1j * (B * math.cos(A)))

Ее результат для A=106:

Функция «Фокачча»

def func_3(A, B):
    return math.cos((A + 1) * B) * math.e ** (1j * (B * math.cos(A)))
vis(246, func_3, step=0.1, c=color_2)

vis(246, func_3, step=0.1, c=color_2)

Функция «Без названия»

color_3 = lambda x, y: (0.5, 0.5, sigm(x ** 2 + y ** 2))
vis(162, func_4, step=0.1, c=color_3)

vis(179, func_4, step=0.1, c=color_3)

Формула красоты

def func_5(A, B):
    return math.cos((A + 1) * B) ** 1.5 * math.e ** (1j * (B * math.cos(A)))
color_4 = lambda x, y: (sigm(x ** 2 + y ** 2) / 2, 0.5, 1 - sigm(x ** 2 + y ** 2))
vis(345, func_5, step=0.1, c=color_4)

vis(350, func_5, step=0.1, c=color_4)

Пока все.

Весь код


import numpy as np
import random
import matplotlib.pyplot as plt
import math

def vis(A, f, step=1.0, c=None):
    x = []
    y = []
    for B in np.arange(0, A, step):
        v = f(A, B)
        x.append(v.real)
        y.append(v.imag)
    plt.figure(figsize=[7, 7])
    mxabs = max([i[0] ** 2 + i[1] ** 2 for i in zip(x, y)]) ** 0.5
    x = np.array(x) / mxabs
    y = np.array(y) / mxabs
    if c is None:
        plt.scatter(x, y)
    else:
        plt.scatter(x, y, color=[c(x[i], y[i]) for i in range(len(x))])
    plt.show()

def func_1(A, B):
    return math.sin(B) * B * math.e ** (1j * (B * math.cos(A)))

def func_2(A, B):
    return math.cos(B) * math.sin(B) * B * math.e ** (1j * (B * math.cos(A)))

def func_3(A, B):
    return math.cos((A + 1) * B) * math.e ** (1j * (B * math.cos(A)))

def func_4(A, B):
    return math.sin(A + B) * B * math.e ** (1j * B * math.sin(A))

def func_5(A, B):
    return math.cos((A + 1) * B) ** 1.5 * math.e ** (1j * (B * math.cos(A)))

def sigm(x):
    return (1 / (1 + 1.2 ** (-x*50)) - 0.5) * 2

color_1 = lambda x, y: (0.2, sigm(x ** 2 + y ** 2) / 1.4, 1 - sigm(x ** 2 + y ** 2))
color_2 = lambda x, y: (sigm(x ** 2 + y ** 2), 0.5, 0.5)
color_3 = lambda x, y: (0.5, 0.5, sigm(x ** 2 + y ** 2))
color_4 = lambda x, y: (sigm(x ** 2 + y ** 2) / 2, 0.5, 1 - sigm(x ** 2 + y ** 2))
colors = [color_1, color_2, color_3, color_4]
funcs = [func_1, func_2, func_3, func_4, func_5]
while True:
    col = random.choice(colors)
    func = random.choice(funcs)
    vis(random.random() * 200 + 100, func, step=0.1, c=col)
    if input() == "exit":
        break

Еще скриншоты

Числа в Python. — it-black.ru

Сегодня я расскажу о числах в python, а также о их операциях. В Python существует 3 вида чисел:

  • Целые числа (int)
  • Вещественные числа (float)
  • Комплексные числа (complex)
Целые числа (int)

Целые числа в Python ничем не отличаются от обычных чисел. Они поддерживают набор самых обычных математических операций:

x + y Сложение
x – y Вычитание
x * y Умножение
x / y Деление
x // y Получение целой части от деления
x % y Остаток от деления
-x Смена знака числа
abs(x) Модуль числа
divmod(x, y) Пара (x // y, x % y)
x ** y Возведение в степень
pow(x, y[, z]) xy по модулю (если модуль задан)

Битовые операции

Над целыми числами также можно производить битовые операции. y Побитовое исключающее или x & y Побитовое и x << n Битовый сдвиг влево x >> y Битовый сдвиг вправо ~x Инверсия битов

Методы

int.bit_length() – количество бит, необходимых для представления числа в двоичном виде, без учёта знака и лидирующих нулей. Пример:


n = -37
bin(n)
# Выведет: '-0b100101'

n.bit_length()
# Выведет: 6

int.to_bytes(length, byteorder, *, signed=False) – возвращает строку байтов, представляющих это число. Пример:


(1024).to_bytes(2, byteorder='big')
# Выведет: b'\x04\x00'

(1024).to_bytes(10, byteorder='big')
# Выведет: b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00'

(-1024).to_bytes(10, byteorder='big', signed=True)
# Выведет: b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00'

x = 1000
x.to_bytes((x.bit_length() // 8) + 1, byteorder='little')
# Выведет: b'\xe8\x03'

classmethod int.from_bytes(bytes, byteorder, *, signed=False) – возвращает число из данной строки байтов. Пример:


int.from_bytes(b'\x00\x10', byteorder='big')
# Выведет: 16

int.from_bytes(b'\x00\x10', byteorder='little')
# Выведет: 4096

int.from_bytes(b'\xfc\x00', byteorder='big', signed=True)
# Выведет: -1024

int.from_bytes(b'\xfc\x00', byteorder='big', signed=False)
# Выведет: 64512

int.from_bytes([255, 0, 0], byteorder='big')
# Выведет: 16711680
Вещественные числа (float)

Вещественные числа поддерживают те же операции, что и целые. Но вещественные числа неточны, и это может привести к ошибкам:


0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1
# Выведет: 0.9999999999999999

Вещественные числа не поддерживают длинную арифметику:


a = 3 ** 1000
a + 0.1
# Выведет: Traceback (most recent call last):
  File "", line 1, in
OverflowError: int too large to convert to float
Методы

  • float.as_integer_ratio() – пара целых чисел, их отношение равно этому числу.
  • float.is_integer() – является ли значение целым числом.
  • float.hex() – переводит float в hex (шестнадцатеричную систему счисления).
  • classmethod float.fromhex(s) – float из шестнадцатеричной строки.

Также для работы с числами в Python есть несколько полезных модулей.

Модуль math предоставляет более сложные математические функции. Например:


import math
math.pi
# Выведет: 3.141592653589793

math.sqrt(85)
# Выведет: 9.219544457292887

Модуль random реализует генератор случайных чисел и функции случайного выбора. Например:


import random
random.random()
# Выведет: 0.15651968855132303
Комплексные числа (complex)

Примеры работы комплексных чисел в Python:


x = complex(1, 2)
print(x)
# Выведет: (1+2j)

y = complex(3, 4)
print(y)
# Выведет: (3+4j)

z = x + y
print(x)
# Выведет: (1+2j)

print(z)
# Выведет: (4+6j)

z = x * y
print(z)
# Выведет: (-5+10j)

z = x / y
print(z)
# Выведет: (0.44+0.08j)

print(x.conjugate())  # Сопряжённое число
# Выведет: (1-2j)

print(x.imag)  # Мнимая часть
# Выведет: 2.0

print(x.real)  # Действительная часть
# Выведет: 1.0

print(x > y)  # Комплексные числа нельзя сравнить
# Выведет: Traceback (most recent call last):
  File "", line 1, in
TypeError: unorderable types: complex() > complex()

print(x == y)  # Но можно проверить на равенство
# Выведет: False

abs(3 + 4j)  # Модуль комплексного числа
# Выведет: 5.0

pow(3 + 4j, 2)  # Возведение в степень
# Выведет: (-7+24j)

Также в Python существует интересный модуль под назанием cmath. Данный модуль предоставляет функции для работы с комплексными числами:

  • cmath.phase(x) – возвращает фазу комплексного числа
  • cmath.polar(x) – преобразование к полярным координатам. Возвращает пару (r, phi).
  • cmath.rect(r, phi) – преобразование из полярных координат.
  • cmath.exp(x) – ex.
  • cmath.log(x[, base]) – логарифм x по основанию base. Если base не указан, возвращается натуральный логарифм.
  • cmath.log10(x) – десятичный логарифм.
  • cmath.sqrt(x) – квадратный корень из x.
  • cmath.acos(x) – арккосинус x.
  • cmath.asin(x) – арксинус x.
  • cmath.atan(x) – арктангенс x.
  • cmath.cos(x) – косинус x.
  • cmath.sin(x) – синус x.
  • cmath.tan(x) – тангенс x.
  • cmath.acosh(x) – гиперболический арккосинус x.
  • cmath.asinh(x) – гиперболический арксинус x.
  • cmath.atanh(x) – гиперболический арктангенс x.
  • cmath.cosh(x) – гиперболический косинус x.
  • cmath.sinh(x) – гиперболический синус x.
  • cmath.tanh(x) – гиперболический тангенс x.
  • cmath.isfinite(x) – True, если действительная и мнимая части конечны.
  • cmath.isinf(x) – True, если либо действительная, либо мнимая часть бесконечна.
  • cmath.isnan(x) – True, если либо действительная, либо мнимая часть NaN.
  • cmath.pi – π.
  • cmath.e – e.

Упростите сложные числа с помощью Python — Real Python

Большинство языков программирования общего назначения не поддерживает или ограниченно поддерживает комплексных чисел . Типичные варианты — изучить какой-нибудь специализированный инструмент, такой как MATLAB, или найти стороннюю библиотеку. Python — редкое исключение, потому что он имеет встроенные комплексные числа.

Несмотря на название, комплексные числа не сложны! Они удобны для решения практических задач, с которыми вы познакомитесь в этом руководстве.Вы изучите векторной графики и анализ частоты звука , но комплексные числа также могут помочь в рисовании фракталов , например.

Из этого руководства вы узнаете, как:

  • Определите комплексные числа с литералами в Python
  • Представляют комплексные числа в прямоугольных и полярных координатах
  • Использовать комплексные числа в арифметических выражениях
  • Воспользуйтесь преимуществами встроенного модуля cmath
  • Перевести математических формул напрямую в код Python

Если вам нужно быстро освежить память или мягко познакомиться с теорией комплексных чисел, вы можете посмотреть серию видеосюжетов Khan Academy.Чтобы загрузить образец кода, использованный в этом руководстве, щелкните ссылку ниже:

Создание комплексных чисел в Python

Создание комплексных чисел и управление ими в Python не сильно отличается от других встроенных типов данных, особенно числовых. Это возможно, потому что язык рассматривает их как первоклассных граждан. Это означает, что вы можете выражать математические формулы, содержащие комплексные числа, с небольшими накладными расходами.

Python позволяет использовать комплексные числа в арифметических выражениях и вызывать для них функции так же, как и с другими числами в Python.Это приводит к элегантному синтаксису, который читается почти как учебник математики.

Буквенное число с комплексным числом

Самый быстрый способ определить комплексное число в Python — ввести его литерал непосредственно в исходный код:

Хотя это выглядит как алгебраическая формула, выражение справа от знака равенства уже является фиксированным значением, которое не нуждается в дальнейшей оценке. Проверив его тип, вы убедитесь, что это действительно комплексное число:

.
>>>

  >>> тип (z)
<класс 'сложный'>
  

Чем это отличается от , складывающего два числа с помощью оператора «плюс»? Ярким признаком является приклеенная ко второму числу буква j , что полностью меняет смысл выражения.Если вы удалите букву, вместо этого вы получите знакомый целочисленный результат:

.
>>>

  >>> z = 3 + 2

>>> тип (z)
<класс 'int'>
  

Кстати, вы можете использовать числа с плавающей запятой и для создания комплексных чисел:

>>>

  >>> z = 3,14 + 2,71j
>>> тип (z)
<класс 'сложный'>
  

Литералы комплексных чисел в Python имитируют математическую нотацию, которая также известна как стандартная форма , алгебраическая форма или иногда каноническая форма комплексного числа.В Python вы можете использовать в этих литералах либо строчные j , либо прописные J .

Если вы изучали комплексные числа на уроке математики, возможно, вы видели, как они выражаются с помощью i вместо j . Если вам интересно, почему Python использует j вместо i , вы можете развернуть свертываемый раздел ниже, чтобы узнать больше.

В традиционном обозначении комплексных чисел используется буква i вместо j , поскольку она обозначает мнимую единицу .Если у вас есть математическое образование, вы можете почувствовать легкий дискомфорт, используя условные обозначения Python. Однако есть несколько причин, которые могут оправдать неоднозначный выбор Python:

  • Это соглашение, уже принятое инженерами, чтобы избежать столкновения имен с электрическим током, который обозначается буквой i .
  • В вычислениях буква i часто используется для индексации переменной в циклах.
  • Букву i легко спутать с l или 1 в исходном коде.

Это было поднято в системе отслеживания ошибок Python более десяти лет назад, и создатель Python, сам Гвидо ван Россум, закрыл проблему следующим комментарием:

Это не будет исправлено. Во-первых, буква «i» или заглавная буква «I» слишком похожи на цифры. Способ анализа чисел либо языковым синтаксическим анализатором (в исходном коде), либо встроенными функциями (int, float, complex) не должен быть локализуемым или настраиваемым каким-либо образом; это приводит к огромным разочарованиям в будущем.Если вы хотите анализировать комплексные числа, используя «i» вместо «j», у вас уже есть множество доступных решений. (Источник)

Итак, вот оно. Если вы не хотите начать использовать MATLAB, вам придется жить с использованием j для обозначения ваших комплексных чисел.

Алгебраическая форма комплексного числа соответствует стандартным правилам алгебры, что удобно при выполнении арифметики. Например, сложение имеет коммутативное свойство, которое позволяет менять порядок двух частей литерала комплексного числа без изменения его значения:

>>>

  >>> 3 + 2j == 2j + 3
Правда
  

Точно так же вы можете заменить вычитание сложением в литерале комплексного числа, потому что знак минус — это просто сокращенное обозначение эквивалентной формы:

>>>

  >>> 3 - 2j == 3 + (-2j)
Правда
  

Всегда ли литерал комплексного числа в Python должен состоять из двух чисел? Может быть больше? Они заказаны? Чтобы ответить на эти вопросы, давайте проведем несколько экспериментов.Неудивительно, что если вы укажете только одно число без буквы j , то получите обычное целое число или число с плавающей запятой:

>>>

  >>> z = 3,14
>>> тип (z)
<класс 'float'>
  

С другой стороны, добавление буквы j к числовому литералу немедленно превратит его в комплексное число:

>>>

  >>> z = 3,14j
>>> тип (z)
<класс 'сложный'>
  

Строго говоря, с математической точки зрения, вы только что создали чистое мнимое число , но Python не может представить его как отдельный тип данных.Следовательно, без другой части это просто комплексное число.

А как насчет обратного? Чтобы создать комплексное число без мнимой части , вы можете воспользоваться нулем и добавить или вычесть его следующим образом:

>>>

  >>> z = 3,14 + 0j
>>> тип (z)
<класс 'сложный'>
  

На самом деле обе части комплексного числа присутствуют всегда. Если вы не видите единицы, это означает, что она имеет нулевое значение. Давайте посмотрим, что произойдет, если вы попытаетесь ввести в сумму больше терминов, чем раньше:

>>>

  >>> 2 + 3j + 4 + 5j
(6 + 8j)
  

На этот раз ваше выражение больше не является буквальным, потому что Python вычислил его в комплексное число, состоящее только из двух частей.Помните, что основные правила алгебры переносятся на комплексные числа, поэтому, если вы сгруппируете похожие термины и примените покомпонентное сложение, вы получите 6 + 8j .

Обратите внимание, как Python по умолчанию отображает комплексные числа. Их текстовое представление содержит пару круглых скобок, строчную букву j и без пробелов. Кроме того, на втором месте стоит мнимая часть.

Комплексные числа, которые также являются чисто мнимыми числами, отображаются без скобок и показывают только их мнимую часть:

>>>

  >>> 3 + 0j
(3 + 0j)
>>> 0 + 3j
3j
  

Это помогает отличать мнимые числа от наиболее сложных чисел, состоящих из действительных и мнимых частей.

комплекс () Заводская функция

Python имеет встроенную функцию complex () , которую можно использовать в качестве альтернативы литералу комплексного числа:

В этой форме он напоминает кортеж или упорядоченную пару обычных чисел. Аналогия не так уж надумана. Комплексные числа имеют геометрическую интерпретацию в декартовой системе координат , которую вы немного изучите. Вы можете думать о комплексных числах как о двумерных.

Интересный факт: В математике комплексные числа традиционно обозначаются буквой z , поскольку это следующая буква в алфавите после x и y , которые обычно представляют координаты.

Заводская функция комплексных чисел принимает два числовых параметра. Первая представляет собой действительную часть , а вторая представляет собой мнимую часть , обозначенную буквой j в буквальном значении, которое вы видели ранее:

>>>

  >>> комплекс (3, 2) == 3 + 2j
Правда
  

Оба параметра являются необязательными, со значениями по умолчанию, равными нулю, что упрощает определение комплексных чисел без мнимой части или как действительной, так и мнимой частей:

>>>

  >>> комплекс (3) == 3 + 0j
Правда
>>> комплекс () == 0 + 0j
Правда
  

Версия с одним аргументом может быть полезна при приведении типов .Например, вы можете передать нечисловое значение, такое как строковый литерал, чтобы получить соответствующий комплексный объект . Обратите внимание, что строка не может содержать пробелов:

>>>

  >>> комплекс ("3 + 2j")
(3 + 2j)

>>> комплекс ("3 + 2j")
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
ValueError: complex () arg - неверно сформированная строка
  

Позже вы узнаете, как сделать ваши классы совместимыми с этим механизмом приведения типов.Интересно, что если вы передадите комплексное число в complex () , вы получите тот же экземпляр:

.
>>>

  >>> z = комплекс (3, 2)
>>> z комплексный (z)
Правда
  

Это согласуется с тем, как работают другие типы чисел в Python, потому что все они неизменяемые . Чтобы создать отдельную копию комплексного числа, необходимо снова вызвать функцию с обоими аргументами или объявить другую переменную с литералом комплексного числа:

>>>

  >>> z = комплекс (3, 2)
>>> z комплексный (3, 2)
Ложь
  

Когда вы предоставляете функции два аргумента, они всегда должны быть числами, например int , float или сложным .В противном случае вы получите ошибку во время выполнения. С технической точки зрения, bool является подклассом int , поэтому он тоже будет работать:

>>>

  >>> complex (False, True) # Логические значения, такие же, как complex (0, 1)
1j

>>> complex (3, 2) # Целые числа
(3 + 2j)

>>> complex (3.14, 2.71) # Числа с плавающей запятой
(3,14 + 2,71j)

>>> complex ("3", "2") # Строки
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
TypeError: complex () не может принимать второй аргумент, если первый является строкой
  

Все становится еще более причудливым, когда вы предоставляете фабричную функцию complex () с комплексными числами в качестве аргументов.Однако если вы предоставите только первый аргумент, он будет вести себя как прокси, как и раньше:

>>>

  >>> комплекс (комплекс (3, 2))
(3 + 2j)
  

Однако, когда присутствуют два аргумента и хотя бы один из них является комплексным числом, вы получите результаты, которые на первый взгляд может быть трудно объяснить:

>>>

  >>> комплекс (1, комплекс (3, 2))
(-1 + 3j)

>>> комплекс (комплекс (3, 2), 1)
(3 + 3j)

>>> комплекс (комплекс (3, 2), комплекс (3, 2))
(1 + 5j)
  

Чтобы получить ответы, давайте взглянем на строку документации фабричной функции или онлайн-документацию, в которой объясняется, что происходит под капотом, когда вы вызываете complex (real, imag) :

Возвращает комплексное число со значением вещественное + воображаемое * 1j или преобразует строку или число в комплексное число.(Источник)

В этом объяснении real и imag являются именами аргументов функции. Второй аргумент умножается на мнимую единицу j , и результат добавляется к первому аргументу. Не волнуйтесь, если это все еще не имеет смысла. Вы можете вернуться к этой части, когда прочитали об арифметике комплексных чисел. Правила, о которых вы узнаете, упростят это.

Когда вы хотите использовать фабричную функцию complex () вместо литерала? Это зависит от обстоятельств, но вызов функции может быть более удобным, например, при работе с динамически генерируемыми данными.

Знакомство с комплексными числами Python

В математике комплексные числа — это надмножество действительных чисел, что означает, что каждое действительное число также является комплексным числом, мнимая часть которого равна нулю. Python моделирует эту взаимосвязь с помощью концепции, называемой числовой башней , описанной в PEP 3141:

.
>>>

  >>> импортные номера
>>> issubclass (числа.Реальные, числа.комплексные)
Правда
  

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

>>>

  >>> isinstance (3.14, числа.комплекс)
Правда
>>> isinstance (3.14, numbers.Integral)
Ложь
  

Значение с плавающей запятой 3,14 — это действительное число, которое также может быть комплексным числом, но не целым. Обратите внимание, что вы не можете использовать встроенные типы непосредственно в таком тесте:

>>>

  >>> isinstance (3.14, комплекс)
Ложь
  

Разница между комплексными числами и . Сложный состоит в том, что они принадлежат отдельным ветвям в дереве иерархии числовых типов, а последний является абстрактным базовым классом без какой-либо реализации:

Иерархия типов для чисел в Python

Абстрактные базовые классы, которые обозначены красным на диаграмме выше, могут обходить обычный механизм проверки наследования, регистрируя несвязанные классы в качестве своих виртуальных подклассов. Вот почему значение с плавающей запятой в этом примере представляется экземпляром чисел.Комплекс , но не комплекс .

Доступ к реальным и мнимым частям

Чтобы получить действительную и мнимую части комплексного числа в Python, вы можете использовать соответствующие атрибуты .real и .imag :

>>>

  >>> z = 3 + 2j
>>> z.real
3.0
>>> z.imag
2.0
  

Оба свойства доступны только для чтения , потому что комплексные числа неизменяемы, поэтому попытка присвоить новое значение любому из них не удастся:

>>>

  >>> z.реальный = 3,14
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
AttributeError: атрибут только для чтения
  

Поскольку каждое число в Python является более конкретным типом комплексного числа, атрибуты и методы определены в числах . Комплексный также доступен во всех числовых типах, включая int и float :

>>>

  >>> х = 42
>>> x.real
42
>>> x.imag
0
  

Мнимая часть таких чисел всегда равна нулю.

Вычисление конъюгата комплексного числа

Комплексные числа Python имеют только три открытых члена. Помимо свойств .real и .imag , они предоставляют метод .conjugate () , который меняет знак мнимой части:

>>>

  >>> z = 3 + 2j
>>> z.conjugate ()
(3-2j)
  

Для чисел, мнимая часть которых равна нулю, не действует:

>>>

  >>> х = 3.14
>>> x.conjugate ()
3,14
  

Эта операция обратна сама себе, поэтому, дважды вызвав ее, вы получите исходный номер, с которого вы начали:

>>>

  >>> z.conjugate (). Contugate () == z
Правда
  

Хотя это может показаться малопригодным, комплексное сопряжение имеет несколько полезных арифметических свойств, которые, среди прочего, могут помочь вычислить деление двух комплексных чисел ручкой и бумагой.

Арифметика комплексных чисел

Поскольку сложный является собственным типом данных в Python, вы можете вставить комплексные числа в арифметических выражений и вызывать на них многие встроенные функции.Более сложные функции для комплексных чисел определены в модуле cmath , который является частью стандартной библиотеки. Вы познакомитесь с ним в более поздней части этого руководства.

На данный момент запоминание единственного правила позволит вам применить свои знания арифметики в начальной школе для вычисления основных операций с комплексными числами. Правило, которое следует запомнить, — это определение мнимой единицы , которая удовлетворяет следующему уравнению:

Когда вы думаете о j как о действительном числе, это выглядит неправильно, но не паникуйте.Если вы на мгновение проигнорируете его и замените каждое вхождение j 2 на -1 , как если бы это была константа, тогда вы будете установлены. Посмотрим, как это работает.

Дополнение

Сумма двух или более комплексных чисел эквивалентна покомпонентному сложению их действительной и мнимой частей:

>>>

  >>> z1 = 2 + 3j
>>> z2 = 4 + 5j
>>> z1 + z2
(6 + 8j)
  

Ранее вы узнали, что алгебраические выражения, состоящие из действительных и мнимых чисел, подчиняются стандартным правилам алгебры.Когда вы запишете это алгебраически, вы сможете применить свойство распределения и упростить формулу, вычленив и сгруппировав общие термины:

Python автоматически продвигает операнды к сложному типу данных , когда вы добавляете значения смешанных числовых типов:

>>>

  >>> z = 2 + 3j
>>> z + 7 # Добавить комплекс к целому числу
(9 + 3j)
  

Это похоже на неявное преобразование из int в float , с которым вы, возможно, более знакомы.

Вычитание

Вычитание комплексных чисел аналогично их сложению, что означает, что вы также можете применять его поэлементно:

>>>

  >>> z1 = 2 + 3j
>>> z2 = 4 + 5j
>>> z1 - z2
(-2-2j)
  

Однако, в отличие от суммы, порядок операндов имеет значение и дает разные результаты, как и с действительными числами:

>>>

  >>> z1 + z2 == z2 + z1
Правда
>>> z1 - z2 == z2 - z1
Ложь
  

Вы также можете использовать унарный минус-оператор (-) , чтобы преобразовать комплексное число в минус:

>>>

  >>> z = 3 + 2j
>>> -z
(-3-2j)
  

Инвертирует действительную и мнимую части комплексного числа.

Умножение

Произведение двух или более комплексных чисел становится более интересным:

>>>

  >>> z1 = 2 + 3j
>>> z2 = 4 + 5j
>>> z1 * z2
(-7 + 22j)
  

Каким образом вы на Земле получили отрицательное число из числа только положительных? Чтобы ответить на этот вопрос, вы должны вспомнить определение мнимой единицы и переписать выражение в терминах действительной и мнимой частей:

Ключевое наблюдение: j умножить на j дает j 2 , которое можно заменить на -1 .Это меняет знак одного из слагаемых, в то время как остальные правила остаются такими же, как и раньше.

Дивизион

На первый взгляд деление комплексных чисел может показаться устрашающим:

>>>

  >>> z1 = 2 + 3j
>>> z2 = 4 + 5j
>>> z1 / z2
(0,5609756097560976 + 0,0487804878048781j)
  

Вы не поверите, но вы можете получить тот же результат, используя всего лишь ручку и бумагу! (Хорошо, калькулятор может избавить вас от головной боли.) Когда оба числа выражены в их стандартных формах, хитрость состоит в том, чтобы умножить числитель и знаменатель на конъюгат последнего:

Знаменатель превращается в квадрат модуля делителя. Позже вы узнаете больше о модуле комплексных чисел. Продолжив вывод формулы, вы получите:

Обратите внимание, что комплексные числа не поддерживают деление этажей, также известное как целочисленное деление:

>>>

  >>> z1 // z2
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
TypeError: невозможно принять комплексное число.>>> z1 // 3.14
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
TypeError: невозможно принять комплексное число.
  

Раньше это работало в Python 2.x, но позже было удалено, чтобы избежать двусмысленности.

Возведение в степень

Вы можете возвести комплексные числа в степень, используя двоичный оператор возведения в степень ( ** ) или встроенный pow () , но не тот, который определен в модуле math , который поддерживает только числа с плавающей запятой. значения:

>>>

  >>> z = 3 + 2j

>>> z ** 2
(5 + 12j)

>>> pow (z, 2)
(5 + 12j)

>>> импорт математики
>>> математика.pow (z, 2)
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
TypeError: невозможно преобразовать сложное в плавающее
  

И основание , и показатель степени могут быть любых числовых типов, включая целые числа, числа с плавающей запятой, мнимые или комплексные:

>>>

  >>> 2 ** z
(1.4676557979464138 + 7.864221995j)

>>> z ** 2
(5 + 12j)

>>> z ** 0,5
(1,8173540210239707 + 0,5502505227003375j)

>>> z ** 3j
(-0.1304148

67086-0.11115341486478239j)

>>> z ** z
(-5.409738793

9-13.410442370412747j)

Возведение в степень комплексных чисел вручную становится очень трудным, если они выражены в стандартной форме. Намного удобнее переписать число в тригонометрической форме и вычислить степень, используя базовую тригонометрию. Если вас интересует математика, ознакомьтесь с формулой Де Муавра, которая позволяет вам это сделать.

Использование комплексных чисел Python как двумерных векторов

Вы можете визуализировать комплексные числа как точек или векторов на евклидовой плоскости в декартовой или прямоугольной системе координат :

Ось X на комплексной плоскости, также известная как плоскость Гаусса или диаграмма Аргана , представляет действительную часть комплексного числа, а ось Y представляет его мнимую часть.

Этот факт приводит к одной из самых крутых особенностей сложного типа данных в Python, который бесплатно воплощает элементарную реализацию двумерного вектора. Хотя не все операции в них работают одинаково, векторы и комплексные числа имеют много общего.

Получение координат

Бермудский треугольник — легендарный регион, известный своими паранормальными явлениями, который простирается через южную оконечность Флориды, Пуэрто-Рико и крошечный остров Бермуды.Его вершины примерно обозначены тремя крупными городами, географические координаты которых следующие:

  1. Майами: 25 ° 45 ’42.054” северной широты, 80 ° 11 ’30.438” западной долготы
  2. Сан-Хуан: 18 ° 27 ’58,8” северной широты, 66 ° 6 ’20,598” западной долготы
  3. Гамильтон: 32 ° 17 ’41,64” северной широты, 64 ° 46 ’58.908” западной долготы

После преобразования этих координат в десятичные градусы вы получите два числа с плавающей запятой для каждого города. Вы можете использовать комплексный тип данных для хранения упорядоченных пар чисел.Поскольку широта является вертикальной координатой, а долгота — горизонтальной, было бы удобнее переключать их, следуя традиционному порядку декартовых координат:

  miami_fl = комплекс (-80.1, 25.761681)
san_juan = комплекс (-66.105721, 18.466333)
Гамильтон = комплекс (-64,78303, 32,2949)
  

Отрицательные значения долготы представляют западное полушарие, а положительные значения широты — северное полушарие.

Имейте в виду, что это сферических координаты . Чтобы правильно спроецировать их на плоскую плоскость, вам нужно учитывать кривизну Земли. Одной из первых картографических проекций, использованных в картографии, была проекция Меркатора, которая помогала морякам ориентироваться на своих кораблях. Но давайте проигнорируем все это и предположим, что значения уже выражены в прямоугольной системе координат.

Если вы нанесете числа на комплексную плоскость, вы получите приблизительное изображение Бермудского треугольника:

В сопутствующих материалах вы найдете интерактивный блокнот Jupyter Notebook, который отображает Бермудский треугольник с помощью библиотеки Matplotlib.Чтобы загрузить исходный код и материалы для этого руководства, щелкните ссылку ниже:

Если вам не нравится вызывать фабричную функцию complex () , вы можете создать псевдоним типа с более подходящим именем или использовать буквальную форму комплексного числа, чтобы сэкономить несколько нажатий клавиш:

  Координаты города = комплекс
miami_fl = CityCoordinates (-80.1, 25.761681)
miami_fl = -80.1 + 25.761681j
  

Если вам нужно упаковать больше атрибутов в городе, вы можете использовать именованный кортеж или класс данных или создать собственный класс.

Расчет звездной величины

звездная величина , также известная как модуль или радиус комплексного числа, представляет собой длину вектора, который изображает его на комплексной плоскости:

Вы можете вычислить это по теореме Пифагора, взяв квадратный корень из суммы квадрата действительной части и квадрата мнимой части:

Вы могли подумать, что Python позволит вам вычислить длину такого вектора с помощью встроенной функции len () , но это не так.Чтобы получить величину комплексного числа, вы должны вызвать другую глобальную функцию с именем abs () , которая обычно используется для вычисления абсолютного значения числа:

>>>

  >>> len (3 + 2j)
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
TypeError: объект типа "сложный" не имеет len ()

>>> абс (3 + 2j)
3,605551275463989
  

Эта функция удаляет знак из целых чисел, которые вы передаете, но для комплексных чисел она возвращает величину или длину вектора:

>>>

  >>> абс (-42)
42

>>> z = 3 + 2j

>>> абс (г)
3.605551275463989

>>> из математического импорта sqrt
>>> sqrt (z.real ** 2 + z.imag ** 2)
3,605551275463989
  

Возможно, вы помните из предыдущего раздела, что комплексное число, умноженное на его сопряжение, дает его величину в квадрате.

Определение расстояния между двумя точками

Давайте найдем геометрический центр Бермудского треугольника и расстояния до него от трех городов, образующих его границы. Сначала вам нужно просуммировать все координаты и разделить результат на их количество, чтобы получить среднее значение:

  геометрический_центр = сумма ([miami_fl, san_juan, hamilton]) / 3
  

Это даст вам точку, расположенную в Атлантическом океане, где-то внутри треугольника:

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

  v1 = геометрический_центр - miami_fl
v2 = геометрический_центр - san_juan
v3 = геометрический_центр - Гамильтон
  

Поскольку вы вычитаете комплексные числа, каждый вектор также является комплексным числом, состоящим из двух частей. Чтобы получить расстояние, вычислите величину каждого вектора:

>>>

  >>> абс (v1)
9,83488994681275

>>> абс (v2)
8,226809506084367

>>> абс (v3)
8.784732429678444
  

Эти длины векторов не отражают значимых расстояний, но являются хорошим приближением для такого игрушечного примера, как этот. Чтобы представить точные результаты в материальных единицах, вам нужно сначала преобразовать координаты из сферических в прямоугольные или вместо этого рассчитать расстояние, используя метод большого круга.

Перенос, переворачивание, масштабирование и поворот

Вас может беспокоить появление треугольника во втором квадранте декартовой системы координат.Переместим его так, чтобы его геометрический центр совпал с началом координат. Все три вершины будут пересчитаны на на длину вектора, указанного геометрическим центром, но в противоположном направлении:

  треугольник = miami_fl, san_juan, гамильтон
offset = -geometric_center
center_triangle = [вершина + смещение вершины в треугольнике]
  

Обратите внимание, что вы складываете два комплексных числа вместе, при этом выполняется их поэлементное сложение. Это аффинное преобразование, поскольку оно не меняет форму треугольника или относительное расположение его вершин:

Зеркальное отражение треугольника вокруг действительной или мнимой оси требует инвертирования соответствующего компонента в его вершинах.Например, чтобы перевернуть по горизонтали, вам нужно использовать отрицательную часть реальной части, которая соответствует горизонтальному направлению. Чтобы перевернуть его по вертикали, возьмем минус мнимой части:

  flipped_horizontally = [сложный (-v.real, v.imag) для v в центральном_треугольнике]
flipped_vertically = [сложный (v.real, -v.imag) для v в центральном_треугольнике]
  

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

  flipped_vertically = [v.conjugate () для v в центральном_треугольнике]
  

Естественно, ничто не мешает вам применять симметрию в любом направлении или в обоих направлениях одновременно. В таком случае вы можете использовать унарный оператор минус перед комплексным числом, чтобы перевернуть его действительную и мнимую части:

  flipped_in_both_directions = [-v для v в центральном_треугольнике]
  

Продолжайте экспериментировать с различными комбинациями переворотов, используя интерактивный блокнот Jupyter, доступный в загружаемых материалах.Вот как будет выглядеть треугольник, если перевернуть его по обеим осям:

Масштабирование похоже на преобразование, но вместо добавления смещения вы собираетесь умножить каждую вершину на постоянный коэффициент, который должен быть действительным числом :

  scaled_triangle = [1,5 * вершина для вершины в centered_triangle]
  

В результате оба компонента каждого комплексного числа умножаются на одинаковую величину. Он должен растянуть ваш Бермудский треугольник, чтобы он выглядел больше на участке:

Умножение вершин треугольника на другое комплексное число , с другой стороны, дает эффект вращения вокруг начала системы координат.Это сильно отличается от того, как вы обычно умножаете векторы друг на друга. Например, скалярное произведение двух векторов приведет к скаляру, а их перекрестное произведение вернет новый вектор в трехмерном пространстве, перпендикулярном поверхности, которую они определяют.

Примечание: Произведение двух комплексных чисел не является векторным умножением. Вместо этого он определяется как умножение матриц в двумерном векторном пространстве с 1 и j в качестве стандартного базиса.Умножение ( x 1 + y 1 j ) на ( x 2 + y 2 j ) соответствует следующему умножению матрицы:

Это матрица вращения . слева, поэтому математика работает нормально.

Когда вы умножаете вершины на мнимую единицу, треугольник поворачивается на 90 ° против часовой стрелки. Если вы будете продолжать это повторять, то в конечном итоге придете туда, откуда начали:

.

Как найти конкретное комплексное число, которое повернет другое комплексное число на любой желаемый угол при умножении обоих? Во-первых, взгляните на следующую таблицу, в которой суммированы последовательные повороты на 90 °:

Поворот на 90 ° Общий угол Формула Показатель Значение
0 0 ° z j 0 1
1 90 ° z × j j 1 j
2 180 ° z × j × j j 2 -1
3 270 ° z × j × j × j j 3 Дж
4 360 ° z × j × j × j × j j 4 1
5 450 ° z × j × j × j × j × j j 5 j
6 540 ° z × j × j × j × j × j × j j 6 -1
7 630 ° z × j × j × j × j × j × j × j j 7 Дж
8 720 ° z × j × j × j × j × j × j × j × j j 8 1

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

Например, показатель степени на полпути первого поворота равен 0,5 и представляет угол 45 °:

Итак, если вы знаете, что степень единицы представляет собой прямой угол, а все, что находится между ними, пропорционально масштабируется, то вы можете вывести эту общую формулу для произвольных вращений:

  def rotate (z: комплекс, градусы: с плавающей запятой) -> комплекс:
    return z * 1j ** (градусы / 90)
  

Обратите внимание, что вращение становится более естественным, когда вы выражаете комплексные числа в полярных координатах, которые уже описывают угол.Затем вы можете воспользоваться экспоненциальной формой , чтобы упростить вычисления:

Есть два способа повернуть число в полярных координатах:

  импорт математики, cmath

def rotate1 (z: комплекс, градусы: с плавающей запятой) -> комплекс:
    радиус, угол = cmath.polar (z)
    вернуть cmath.rect (радиус, угол + математические радианы (градусы))

def rotate2 (z: комплекс, градусы: с плавающей запятой) -> комплекс:
    вернуть z * cmath.rect (1, math.radians (градусы))
  

Вы можете суммировать углы или умножить комплексное число на единичный вектор.

Вы узнаете о них больше в следующем разделе.

Изучение математического модуля для комплексных чисел:

cmath

Вы уже видели, что некоторые встроенные функции, такие как abs () и pow () , принимают комплексные числа, а другие — нет. Например, вы не можете round () комплексное число, потому что такая операция не имеет смысла:

>>>

  >>> круглый (3 + 2j)
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
TypeError: сложный тип не определяет метод __round__
  

Многие сложные математические функции, такие как тригонометрические , гиперболические или логарифмические функции, доступны в стандартной библиотеке.К сожалению, даже если вы знаете все о модуле Python math , он не поможет, потому что ни одна из его функций не поддерживает комплексные числа. Вам нужно будет объединить его с модулем cmath , который определяет соответствующие функции для комплексных чисел.

Модуль cmath переопределяет все константы с плавающей запятой из math , чтобы они были у вас под рукой без необходимости импорта обоих модулей:

>>>

  >>> import math, cmath
>>> для имени в "е", "пи", "тау", "нан", "инф":
... print (имя, getattr (математика, имя) == getattr (cmath, имя))
...
e Верно
пи Истинно
тау Истина
nan False
inf Истина
  

Обратите внимание, что nan — это особое значение, которое никогда не может быть равным чему-либо другому, в том числе самому себе! Вот почему в приведенных выше выходных данных вы видите одиночный False . В дополнение к этому, cmath предоставляет два сложных аналога для NaN (не числа) и бесконечности, причем оба имеют нулевые действительные части:

>>>

  >>> from cmath import nanj, infj
>>> нанж.реальный, nanj.imag
(0,0, нан)
>>> infj.real, infj.imag
(0,0, инф)
  

В модуле cmath примерно вдвое меньше функций, чем в стандартном модуле math . Большинство из них имитируют исходное поведение, но некоторые уникальны для комплексных чисел. Они позволят вам выполнить преобразование между двумя системами координат, которые вы изучите в этом разделе.

Преобразование между прямоугольными и полярными координатами

Геометрически комплексное число можно рассматривать двояко.С одной стороны, это точка, горизонтальное и вертикальное расстояния которой от начала координат однозначно определяют ее местоположение. Они известны как прямоугольные координаты , состоящие из действительной и мнимой частей.

С другой стороны, вы можете описать ту же точку в полярных координатах , что также позволит вам однозначно найти ее с двумя расстояниями:

  1. Радиальное расстояние — это длина радиуса, измеренная от начала координат.
  2. Угловое расстояние — это угол, измеряемый между горизонтальной осью и радиусом.

Радиус , также известный как модуль , соответствует величине комплексного числа или длине вектора. Угол обычно называют фазой или аргументом комплексного числа. При работе с тригонометрическими функциями полезно выражать угол в радианах, а не в градусах.

Вот изображение комплексного числа в обеих системах координат:

Следовательно, точка (3, 2) в декартовой системе координат имеет радиус приблизительно 3.6 и угол около 33,7 °, или примерно π более 5,4 радиана.

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

.
>>>

  >>> импорт cmath
>>> cmath.polar (3 + 2j)
(3.605551275463989, 0.5880026035475675)
  

Он вернет кортеж, где первый элемент — это радиус, а второй — угол в радианах.Обратите внимание, что радиус имеет то же значение, что и величина, которую вы можете вычислить, вызвав abs () для вашего комплексного числа. И наоборот, если вас интересует только угол комплексного числа, вы можете вызвать cmath.phase () :

.
>>>

  >>> z = 3 + 2j

>>> abs (z) # Величина также является радиальным расстоянием
3,605551275463989

>>> импортировать cmath
>>> cmath.phase (3 + 2j)
0,5880026035475675

>>> cmath.полярный (z) == (abs (z), cmath.phase (z))
Правда
  

Угол может быть получен с помощью базовой тригонометрии, поскольку действительная часть, мнимая часть и величина вместе образуют прямоугольный треугольник:

Вы можете использовать обратные тригонометрические функции, такие как arcsine , либо из math , либо из cmath , но последние будут давать комплексные значения с мнимой частью, равной нулю:

>>>

  >>> z = 3 + 2j

>>> импорт математики
>>> математика.acos (z.real / abs (z))
0,5880026035475675
>>> math.asin (z.imag / abs (z))
0,5880026035475676
>>> math.atan (z.imag / z.real) # Предпочитать math.atan2 (z.imag, z.real)
0,5880026035475675

>>> импортировать cmath
>>> cmath.acos (z.real / abs (z))
(0,5880026035475675-0j)
  

Однако при использовании функции arctangent следует соблюдать одну небольшую деталь, которая побудила многие языки программирования разработать альтернативную реализацию под названием atan2 () .Вычисление отношения между мнимой и действительной частями может иногда приводить к сингулярности, например, из-за деления на ноль. Более того, отдельные знаки двух значений теряются в процессе, что делает невозможным точное определение угла:

>>>

  >>> импорт математики

>>> math.atan (1/0)
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
ZeroDivisionError: деление на ноль

>>> math.atan2 (1, 0)
1.5707963267948966

>>> math.atan (1/1) == math.atan (-1 / -1)
Правда

>>> math.atan2 (1, 1) == math.atan2 (-1, -1)
Ложь
  

Обратите внимание, как atan () не может распознать две разные точки, расположенные в противоположных квадрантах системы координат. С другой стороны, atan2 () ожидает, что два аргумента вместо одного сохранят отдельные знаки перед разделением один на другой, а также избегают других проблем.

Чтобы получить градусы вместо радианов, вы можете снова выполнить необходимое преобразование, используя модуль math :

>>>

  >>> импорт математики
>>> математика.градусы (0.5880026035475675) # Радианы в градусы
33.6

525979785 >>> math.radians (180) # Градусы в радианы 3,141592653589793

Обратный процесс, то есть преобразование полярных координат в прямоугольные, зависит от другой функции. Однако вы не можете просто передать тот же кортеж, который вы получили от cmath.polar () , поскольку cmath.rect () ожидает два отдельных аргумента:

>>>

  >>> cmath.rect (cmath.polar (3 + 2j))
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
TypeError: прямоугольные ожидаемые 2 аргумента, получили 1
  

При выполнении задания рекомендуется сначала распаковать кортеж и дать этим элементам более описательные имена.Теперь вы можете правильно вызвать cmath.rect () :

>>>

  >>> радиус, угол = cmath.polar (3 + 2j)
>>> cmath.rect (радиус, угол)
(3 + 1.9999999999999996j)
  

Вы можете столкнуться с ошибками округления по пути, пока Python выполняет вычисления. За кулисами он вызывает тригонометрические функции для получения реальной и мнимой частей:

>>>

  >>> импорт математики
>>> радиус * (math.cos (угол) + math.sin (угол) * 1j)
(3 + 1.9999999999999996j)

>>> импортировать cmath
>>> радиус * (cmath.cos (угол) + cmath.sin (угол) * 1j)
(3 + 1.9999999999999996j)
  

Опять же, не имеет значения, используете ли вы math или cmath в этом случае, поскольку результаты будут идентичными.

Различные представления комплексных чисел

Независимо от системы координат одно и то же комплексное число можно выразить в нескольких математически эквивалентных формах:

  • Алгебраическая (стандартная)
  • Геометрический
  • Тригонометрический
  • Экспоненциальная

Этот список не является исчерпывающим, так как есть больше представлений, таких как матричное представление комплексных чисел.

Имея возможность выбора, вы можете выбрать наиболее удобный для решения данной проблемы. Например, вам понадобится экспоненциальная форма для вычисления дискретного преобразования Фурье в следующем разделе. Эта форма также подходит для умножения и деления комплексных чисел.

Вот краткое изложение индивидуальных форм комплексных чисел и их координат:

Форма прямоугольный Полярный
Алгебраический z = x + y j
Геометрический z = ( x , y ) z = ( r , φ)
Тригонометрический z = | z | (cos ( x / | z |) + j sin ( y / | z |)) z = r (cos (φ) + j sin (φ))
Экспоненциальная z = | z | e atan2 (y / x) j z = r (e j φ )

Алгебраическая форма является родной для Python, когда вы указываете комплексные числа, используя их литералы.Вы также можете рассматривать их как точки на евклидовой плоскости в декартовой или полярной системе координат. Хотя в Python нет отдельных представлений для тригонометрической или экспоненциальной формы, вы можете проверить, верны ли математические принципы.

Например, вставка формулы Эйлера в тригонометрическую форму превратит ее в экспоненциальную. Вы можете вызвать функцию exp () модуля cmath или возвести константу e в степень, чтобы получить тот же результат:

>>>

  >>> импорт cmath

>>> алгебраический = 3 + 2j
>>> геометрический = комплекс (3, 2)
>>> радиус, угол = см.полярный (алгебраический)
>>> тригонометрический = радиус * (cmath.cos (угол) + 1j * cmath.sin (угол))
>>> экспонента = радиус * cmath.exp (1j * угол)

>>> для числа в алгебраическом, геометрическом, тригонометрическом, экспоненциальном:
... печать (формат (число, "г"))
...
3 + 2j
3 + 2j
3 + 2j
3 + 2j
  

Действительно, все формы представляют собой разные способы кодирования одного и того же числа. Однако вы не можете сравнивать их напрямую из-за ошибок округления, которые могут возникнуть в это время. Используйте cmath.isclose () для безопасного сравнения или format () для чисел в виде строк соответственно.Вы узнаете, как отформатировать такие строки в следующем разделе.

Объяснение того, почему разные формы комплексного числа эквивалентны, требует исчисления и выходит далеко за рамки этого руководства. Однако, если вас интересует математика, вы обнаружите, что связи между различными областями математики, которые выражаются комплексными числами, будут увлекательными.

Вскрытие комплексного числа в Python

Вы уже много узнали о комплексных числах Python и видели предварительные примеры.Однако, прежде чем двигаться дальше, стоит затронуть некоторые последние темы. В этом разделе вы собираетесь изучить сравнение комплексных чисел, форматирование строк, которые их содержат, и многое другое.

Проверка равенства комплексных чисел

Математически два комплексных числа равны, если они имеют одинаковые значения, независимо от принятой системы координат. Однако преобразование между полярными и прямоугольными координатами обычно приводит к ошибкам округления в Python, поэтому вам нужно следить за мельчайшими различиями при их сравнении.

Например, если вы рассматриваете точку на единичной окружности, радиус которой равен единице и наклонен под углом 60 °, то тригонометрия прекрасно работает, упрощая преобразование с помощью ручки и бумаги:

>>>

  >>> import math, cmath

>>> z1 = cmath.rect (1, math.radians (60))
>>> z2 = комплекс (0,5, math.sqrt (3) / 2)

>>> z1 == z2
Ложь

>>> z1.real, z2.real
(0,5000000000000001, 0,5)
>>> z1.imag, z2.imag
(0.8660254037844386, 0.8660254037844386)
  

Даже если вы знаете, что z1 и z2 — это одна и та же точка, Python не может определить это из-за ошибок округления. К счастью, в документе PEP 485 определены функции для приблизительного равенства, которые доступны в модулях math и cmath :

>>>

  >>> math.isclose (z1.real, z2.real)
Правда

>>> cmath.isclose (z1, z2)
Правда
  

Не забывайте всегда использовать их при сравнении комплексных чисел! Если допуск по умолчанию недостаточно хорош для ваших расчетов, вы можете изменить его, указав дополнительные аргументы.

Комплексные номера для заказа

Если вы знакомы с кортежами, то знаете, что Python может их сортировать:

>>>

  >>> planets = [
... (6, «сатурн»),
... (4, "марс"),
... (1, «ртуть»),
... (5, "юпитер"),
... (8, «нептун»),
... (3, "земля"),
... (7, "уран"),
... (2, "венера"),
...]
>>> из pprint import pprint
>>> pprint (отсортировано (по планетам))
[(1, 'ртуть'),
 (2, 'венера'),
 (3, 'земля'),
 (4, 'марс'),
 (5, 'юпитер'),
 (6, 'сатурн'),
 (7, 'уран'),
 (8, «нептун»)]
  

По умолчанию отдельные кортежи сравниваются слева направо:

>>>

  >>> (6, "сатурн") <(4, "марс")
Ложь
>>> (3, «земля») <(3, «луна»)
Правда
  

В первом случае число 6 больше, чем 4 , поэтому названия планет вообще не учитываются.Однако они могут помочь разрешить ничью. Однако это не относится к комплексным числам, поскольку они не определяют отношение естественного порядка. Например, вы получите сообщение об ошибке, если попытаетесь сравнить два комплексных числа:

>>>

  >>> (3 + 2j) <(2 + 3j)
Отслеживание (последний вызов последний):
  Файл "", строка 1, в 
TypeError: '<' не поддерживается между экземплярами 'сложный' и 'сложный'
  

Должно ли воображаемое измерение иметь больший вес, чем реальное? Стоит ли сравнивать их величины? Выбор за вами, и ответы будут разными.Поскольку вы не можете напрямую сравнивать комплексные числа, вам необходимо указать Python, как их сортировать, указав специальную ключевую функцию , например abs () :

>>>

  >>> cities = {
... комплекс (-64.78303, 32.2949): "Гамильтон",
... комплекс (-66.105721, 18.466333): "Сан-Хуан",
... комплекс (-80.1, 25.761681): "Майами"
...}

>>> для города в отсортированном виде (города, ключ = abs, обратный = True):
... печать (абс (город), города [город])
...
84.22818453809096 Майами
72.386473473 Гамильтон
68.63651945864338 Сан-Хуан
  

Это позволит отсортировать комплексные числа по их величине в порядке убывания.

Форматирование комплексных чисел как строк

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

Примечание. Форматирование строки позволяет игнорировать ошибку представления с плавающей запятой и делать вид, что ее не существует:

>>>

  >>> импорт cmath
>>> z = abs (3 + 2j) * cmath.exp (1j * cmath.phase (3 + 2j))

>>> str (z)
'(3 + 1.9999999999999996j)'

>>> format (z, "g")
'3 + 2j'
  

Буква "g" в описателе формата обозначает общий формат , который округляет ваше число до требуемой точности.По умолчанию точность составляет шесть значащих цифр.

Давайте возьмем следующее комплексное число в качестве примера и отформатируем его с двумя десятичными знаками в обеих частях:

>>>

  >>> z = pow (3 + 2j, 0,5)
>>> print (z)
(1,8173540210239707 + 0,5502505227003375j)
  

Быстрый способ сделать это - вызвать format () с указателем числового формата или создать f-строку в соответствующем формате:

>>>

  >>> формат (z, ".2f ")
'1,82 + 0,55j'

>>> f "{z: .2f}"
'1,82 + 0,55j'
  

Если вам нужен больший контроль, например, для добавления дополнительных отступов вокруг оператора плюса, то лучшим выбором будет строка f:

>>>

  >>> f "{z.real: .2f} + {z.imag: .2f} j"
'1,82 + 0,55j'
  

Вы также можете вызвать .format () для строкового объекта и передать ему позиционных или аргументов ключевого слова :

>>>

  >>> "{0 :.2f} + {0: .2f} j ".format (z.real, z.imag)
'1.82 + 1.82j'

>>> "{re: .2f} + {im: .2f} j" .format (re = z.real, im = z.imag)
'1,82 + 0,55j'
  

Позиционные аргументы обеспечивают последовательность значений, а аргументы ключевого слова позволяют ссылаться на них по имени. Точно так же вы можете использовать строковый оператор по модулю (% ) с кортежем или словарем:

>>>

  >>> "% .2f +% .2fj"% (z.real, z.imag)
'1,82 + 0,55j'

>>> "% (re) .2f +% (im).2fj "% {" re ": z.real," im ": z.imag}
'1,82 + 0,55j'
  

Однако здесь используется другой синтаксис заполнителя и он немного устарел.

Создание собственного сложного типа данных

Модель данных Python определяет набор специальных методов, которые вы можете реализовать, чтобы сделать ваши классы совместимыми с определенными встроенными типами. Допустим, вы работали с точками и векторами и хотели получить угол между двумя связанными векторами . Вы можете вычислить их скалярное произведение и выполнить тригонометрию.Как вариант, вы можете использовать комплексные числа.

Давайте сначала определим ваши классы:

  от ввода import NamedTuple

класс Point (NamedTuple):
    x: float
    y: плавать

класс Vector (NamedTuple):
    Начальная точка
    конец: точка
  

Точка Point имеет координаты x и y , а вектор Vector соединяет две точки. Возможно, вы помните cmath.phase () , который вычисляет угловое расстояние комплексного числа.Теперь, если вы относились к своим векторам как к комплексным числам и знали их фазы, вы могли бы вычесть их, чтобы получить желаемый угол.

Чтобы Python распознавал экземпляры векторов как комплексные числа, вы должны указать .__ complex __ () в теле класса:

  вектор класса (NamedTuple):
    Начальная точка
    конец: точка

    def __complex __ (сам):
        real = self.end.x - self.start.x
        imag = self.end.y - self.start.y
        возвратный комплекс (реальный, воображаемый)
  

Код внутри должен всегда возвращать экземпляр сложного типа данных , поэтому он обычно создает новое комплексное число из вашего объекта.Здесь вы вычитаете начальную и конечную точки, чтобы получить горизонтальные и вертикальные смещения, которые служат реальной и мнимой частями. Метод будет выполняться через делегирование , когда вы вызываете глобальный комплекс () в экземпляре вектора:

>>>

  >>> vector = Vector (Point (-2, -1), Point (1, 1))
>>> сложный (вектор)
(3 + 2j)
  

В некоторых случаях вам не нужно выполнять такое приведение типов самостоятельно. Рассмотрим пример на практике:

>>>

  >>> v1 = Вектор (Точка (-2, -1), Точка (1, 1))
>>> v2 = Вектор (Точка (10, -4), Точка (8, -1))

>>> импортировать математику, cmath
>>> математика.градусы (cmath.phase (v2) - cmath.phase (v1))
90,0
  

У вас есть два вектора, обозначенных четырьмя разными точками. Затем вы передаете их непосредственно в cmath.phase () , который выполняет преобразование в комплексное число за вас и возвращает фазу. Разность фаз - это угол между двумя векторами.

Разве не так красиво? Вы избавили себя от ввода большого количества кода, подверженного ошибкам, благодаря использованию комплексных чисел и немного магии Python.

Вычисление дискретного преобразования Фурье с комплексными числами

Хотя вы можете использовать действительные числа для вычисления коэффициентов синуса и косинуса частот периодической функции с помощью преобразования Фурье, обычно удобнее иметь дело только с одним комплексным коэффициентом на частоту.Дискретное преобразование Фурье в комплексной области задается следующей формулой:

Для каждого частотного бина k он измеряет корреляцию сигнала и конкретной синусоидальной волны, выраженной как комплексное число в экспоненциальной форме. (Спасибо, Леонард Эйлер!) Угловую частоту волны можно вычислить, умножив округленный угол, равный 2π радиан, на k по количеству дискретных отсчетов:

Кодирование этого на Python выглядит довольно аккуратно, если вы воспользуетесь преимуществом сложного типа данных :

  из cmath import pi, exp

def discte_fourier_transform (x, k):
    омега = 2 * пи * к / (N: = len (x))
    вернуть сумму (x [n] * exp (-1j * omega * n) для n в диапазоне (N))
  

Эта функция является буквальной транскрипцией приведенных выше формул.Теперь вы можете выполнить частотный анализ звука, который вы загружаете из аудиофайла с помощью модуля Python wave или синтезируете с нуля. Один из блокнотов Jupyter, прилагаемый к этому руководству, позволяет вам играть с синтезом и анализом звука в интерактивном режиме.

Чтобы построить частотный спектр с помощью Matplotlib, вы должны знать частоту дискретизации, которая определяет разрешение частотного бина , а также предел Найквиста:

  импорт matplotlib.pyplot как plt

def plot_frequency_spectrum (
    образцы,
    samples_per_second,
    min_frequency = 0,
    max_frequency = Нет,
):
    num_bins = len (образцы) // 2
    nyquist_frequency = samples_per_second // 2

    величины = []
    для k в диапазоне (num_bins):
        magnitude.append (abs (дискретное_фурье-преобразование (образцы, k)))

    # Нормализовать величины
    звездные величины = [м / макс (звездные величины) для m в звездных величинах]

    # Вычислить интервалы частоты
    bin_resolution = samples_per_second / len (образцы)
    frequency_bins = [k * bin_resolution для k в диапазоне (num_bins)]

    plt.xlim (min_frequency, max_frequency или nyquist_frequency)
    plt.bar (frequency_bins, magnitude, width = bin_resolution)
  

Число элементов разрешения по частоте в спектре равно половине выборки, в то время как частота Найквиста ограничивает самую высокую частоту, которую вы можете измерить. Преобразование возвращает комплексное число, величина которого соответствует амплитуде синусоидальной волны на данной частоте, а его угол равен фазе .

Примечание: Чтобы получить правильные значения амплитуды, вы должны удвоить число и разделить полученную величину на количество отсчетов.С другой стороны, если вас интересует только частотная гистограмма, вы можете нормализовать величины по их сумме или максимальной частоте.

Вот примерный график частоты звуковой волны, состоящей из трех тонов - 440 Гц, 1,5 кГц и 5 кГц - с равными амплитудами:

График частотного спектра

Обратите внимание, что это был чисто академический пример, поскольку вычисление дискретного преобразования Фурье с вложенными итерациями имеет временную сложность O ( n 2 ), что делает его неприменимым на практике.Для реальных приложений вы хотите использовать алгоритм быстрого преобразования Фурье (БПФ) , лучше всего реализованный в библиотеке C, такой как БПФ в SciPy.

Заключение

Простота использования комплексных чисел в Python делает их на удивление забавным и практичным инструментом. Вы увидели двумерных векторов , реализованных практически бесплатно, и благодаря им смогли проанализировать звуковых частот . Комплексные числа позволяют элегантно выразить математических формул в коде без особого шаблонного синтаксиса, который мешает.

В этом руководстве вы узнали, как:

  • Определите комплексные числа с литералами в Python
  • Представляют комплексные числа в прямоугольных и полярных координатах
  • Использовать комплексные числа в арифметических выражениях
  • Воспользуйтесь преимуществами встроенного модуля cmath
  • Перевести математических формул напрямую в код Python

Какой у вас был опыт работы с комплексными числами Python? Вас когда-нибудь пугали они? Как вы думаете, какие еще интересные проблемы они позволят вам решить?

Вы можете щелкнуть ссылку ниже, чтобы получить полный исходный код этого руководства:

мнимых чисел в Python | Delft Stack

  1. Инициализация комплексного числа в Python
  2. Использование атрибутов и функций комплексных чисел в Python
  3. Использование регулярных математических операций над комплексным числом в Python
  4. Использование функций модуля cmath для комплексных чисел
  5. Использование numpy.array () Функция для хранения мнимых чисел в массивах в Python

Python - очень универсальный язык для работы с числовыми данными. Он также поддерживает работу как с действительными, так и с мнимыми числами. В этом руководстве вы узнаете больше о мнимых числах и о том, как работать с ними в Python.

Инициализация комплексного числа в Python

Комплексные числа состоят из действительной и мнимой частей. В Python мнимую часть можно выразить, просто добавив после числа j или J .

Комплексное число может быть создано легко: путем прямого присвоения действительной и мнимой части переменной. В приведенном ниже примере кода показано, как создать комплексное число в Python:

  a = 8 + 5j.
печать (тип (а))
  

Вывод:

  <класс 'сложный'>
  

Мы также можем использовать встроенную функцию complex () для преобразования двух заданных действительных чисел в комплексное число.

  а = 8
б = 5
с = комплекс (8,5)
печать (тип (c))
  

Вывод:

  <класс 'сложный'>
  

Теперь вторая половина статьи будет больше посвящена работе с мнимыми числами в Python.

Использование атрибутов и функций комплексных чисел в Python

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

Например, чтобы получить доступ к действительной части комплексного числа, мы можем использовать встроенную функцию real () и аналогичным образом использовать функцию imag () для доступа к мнимой части. Кроме того, мы также можем найти сопряжение комплексного числа с помощью функции conugate () .

  а = 8 + 5j
print ('Реальная часть =', a.настоящий)
print ('Воображаемая часть =', a.imag)
print ('Сопряжение =', a.conjugate ())
  

Вывод:

  Реальная часть = 8,0
Мнимая часть = 5.0
Сопряжение = (8-5j)
  

Использование регулярных математических операций над комплексным числом в Python

Вы можете выполнять базовые математические операции, такие как сложение и умножение комплексных чисел в Python. Следующий код реализует простые математические процедуры с двумя заданными комплексными числами.

  а = 8 + 5j
б = 10 + 2j

# Сложение мнимой части обоих чисел
c = (а.image + b.imag)
печать (с)

# Простое умножение обоих комплексных чисел
print ('после умножения =', a * b)
  

Выход:

  7,0
после умножения = (70 + 66j)
  

Использование модуля

cmath Функции модуля для комплексных чисел

Модуль cmath - это специальный модуль, который обеспечивает доступ к нескольким функциям, предназначенным для использования с комплексными числами. Этот модуль состоит из множества функций. Некоторые из них - фаза комплексного числа, степенные и логарифмические функции, тригонометрические функции и гиперболические функции.a - это: (845.5850573783163-2858.5129755252788j)
синусоидальное значение номера комплекса:
(73.42022455449552-10.796569647775932j)
Гиперболический синус:
(422.7924811101271-1429.2566486042679j)

Используйте функцию

numpy.array () для хранения мнимых чисел в массивах в Python

Термин NumPy является аббревиатурой для числового Python. Это библиотека, предоставляемая Python, которая работает с массивами и предоставляет функции для работы с этими массивами. Как следует из названия, numpy.Функция array () используется при создании массива. Программа ниже демонстрирует, как вы можете создать массив комплексных чисел в Python:

  import numpy as np
arr = np.array ([8 + 5j, 10 + 2j, 4 + 3j])
печать (обр)
  

Выход:

  [8. + 5.j 10. + 2.j 4. + 3.j]
  

Комплексные числа - это один из трех способов, которыми Python позволяет хранить и реализовывать числовые данные. Это также считается важной частью программирования на Python.Вы можете выполнять широкий спектр операций с комплексными числами с помощью языка программирования Python.

Внесите вклад

DelftStack - это коллективный проект, созданный такими компьютерными фанатами, как вы. Если вам понравилась статья и вы хотите внести свой вклад в DelftStack, написав платные статьи, вы можете проверить страницу напишите для нас.

  • Последовательность Фибоначчи в Python
  • Подгонка экспоненциальной и логарифмической кривой в Python
  • Комплексные числа Python - cmath

    Комплексное число создается из двух действительных чисел.Комплексное число Python можно создать с помощью функции complex (), а также с помощью оператора прямого присваивания.

    Комплексные числа в основном используются там, где мы определяем что-либо, используя два действительных числа. Например, элемент схемы, который определяется напряжением (В) и током (I). Они в основном используются в геометрии, математическом и научном расчетах.

    Python Комплексные числа

    Давайте сначала узнаем, как создавать комплексные числа в Python.

     
    с = 1 + 2j
    печать (тип (c))
    печать (с)
    
    c1 = комплекс (2, 4)
    печать (введите (c1))
    печать (c1)
      

    Выход:

     
    <класс 'сложный'>
    (1 + 2j)
    <класс 'сложный'>
    (2 + 4j)
      

    Комплексные числа Python имеют тип комплексные .Каждое комплексное число содержит одну действительную и одну мнимую части.

    Python Атрибуты и функции комплексных чисел

    Давайте рассмотрим некоторые атрибуты и функции экземпляров комплексных чисел.

     
    с = 1 + 2j
    print ('Реальная часть =', c.real)
    print ('Воображаемая часть =', c.imag)
    print ('Комплексное сопряжение =', c.conjugate ())
      

    Выход:

     
    Реальная часть = 1.0
    Мнимая часть = 2,0
    Комплексное сопряжение = (1-2j)
      

    Комплексные числа Математические вычисления

    Комплексные числа поддерживают математические вычисления, такие как сложение, вычитание, умножение и деление.

     
    с = 1 + 2j
    c1 = 2 + 4j
    print ('Сложение =', c + c1)
    print ('Вычитание =', c - c1)
    print ('Умножение =', c * c1)
    print ('Разделение =', c1 / c)
      

    Выход:

     
    Сложение = (3 + 6j)
    Вычитание = (-1-2j)
    Умножение = (-6 + 8j)
    Деление = (2 + 0j)
      

    Комплексные числа не поддерживают операторы сравнения. Если мы попытаемся выполнить c , то сообщение об ошибке будет выдано как TypeError: «<» не поддерживается между экземплярами «сложный» и «сложный» .

    Модуль cmath Python

    Модуль cmath Python обеспечивает доступ к математическим функциям для комплексных чисел. Давайте рассмотрим некоторые важные особенности комплексных чисел и то, как мы можем использовать функцию модуля cmath для их вычисления.

    Фаза комплексного числа

    Фаза комплексного числа - это угол между действительной осью и вектором, представляющим мнимую часть. Изображение ниже иллюстрирует фазу комплексного числа и то, как получить это значение с помощью модулей cmath и math.

    Обратите внимание, что фаза, возвращаемая модулями math и cmath, выражается в радианах, мы можем использовать функцию numpy.degrees () , чтобы преобразовать ее в градусы. Диапазон фаз составляет от -π до + π (от -pi до + pi) в радианах, что эквивалентно от -180 до +180 градусов.

     
    импортировать cmath, math, numpy
    
    с = 2 + 2j
    
    # фаза
    фаза = cmath.phase (c)
    print ('2 + 2j Phase =', фаза)
    print ('Фаза в градусах =', numpy.degrees (фаза))
    print ('- 2 - 2j Phase =', cmath.phase (-2 - 2j), 'радианы.Градусы = ', numpy.degrees (cmath.phase (-2 - 2j)))
    
    # мы также можем получить фазу с помощью функции math.atan2 ()
    print ('Фаза комплексных чисел с использованием math.atan2 () =', math.atan2 (2, 1))
      

    Выход:

     
    2 + 2j Фаза = 0,7853981633974483
    Фаза в градусах = 45,0
    -2 - 2j Фаза = -2,3561944
    345 радиан. Градусы = -135,0
    Фаза комплексных чисел с использованием math.atan2 () = 1.1071487177940904
      

    Полярные и прямоугольные координаты

    Мы можем записать комплексное число в полярных координатах, которое представляет собой набор модуля и фазы комплексного числа.

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

     
    с = 1 + 2j
    
    модуль = абс (с)
    фаза = cmath.phase (c)
    полярный = cmath.polar (c)
    
    print ('Модуль =', модуль)
    print ('Фаза =', фаза)
    print ('Полярные координаты =', полярные)
    
    print ('Прямоугольные координаты =', cmath.rect (модуль, фаза))
      

    Выход:

     
    Модуль = 2,23606797749979
    Фаза = 1,1071487177940904
    Полярные координаты = (2.23606797749979, 1.1071487177940904)
    Прямоугольные координаты = (1.0000000000000002 + 2j)
      

    Константы модуля cmath

    В модуле cmath есть множество констант, которые используются в вычислениях комплексных чисел.

     
    печать ('π =', cmath.pi)
    печать ('e =', cmath.e)
    печать ('тау =', cmath.tau)
    print ('Положительная бесконечность =', cmath.inf)
    print ('Положительная комплексная бесконечность =', cmath.infj)
    print ('NaN =', cmath.nan)
    print ('Комплекс NaN =', cmath.nanj)
      

    Выход:

     
    π = 3.с = (-3.074932320639359 + 6.71884969742825j)
    log2 (c) = (1.5000000000000002 + 1.13304567985j)
    log10 (c) = (0,4515449934959718 + 0,3410940884604603j)
    sqrt (c) = (1,5537739740300374 + 0,643594252
    26j)
      

    Тригонометрические функции

     
    с = 2 + 2j
    print ('арксинус =', cmath.asin (c))
    print ('арккосинус =', cmath.acos (c))
    print ('арктангенс =', cmath.atan (c))
    
    print ('синус =', cmath.sin (c))
    print ('косинус =', cmath.cos (c))
    print ('касательная =', cmath.tan (c))
      

    Выход:

     
    арксинус = (0.75424980459 + 1.7343245214879666j)
    арккосинус = (0,8165471820968505-1,7343245214879666j)
    арктангенс = (1,311223269671635 + 0,2388778612568591j)
    синус = (3,4209548611170133-1,5093064853236156j)
    косинус = (-1,5656258353157435-3,2978948363112366j)
    тангенс = (-0.028392952868232294 + 1.0238355945704727j)
      

    Гиперболические функции

     
    с = 2 + 2j
    print ('обратный гиперболический синус =', cmath.asinh (c))
    print ('обратный гиперболический косинус =', cmath.acosh (c))
    print ('обратный гиперболический тангенс =', cmath.атан (с))
    
    print ('гиперболический синус =', cmath.sinh (c))
    print ('гиперболический косинус =', cmath.cosh (c))
    print ('гиперболический тангенс =', cmath.tanh (c))
      

    Выход:

     
    обратный гиперболический синус = (1,7343245214879666 + 0,75424980459j)
    обратный гиперболический косинус = (1,7343245214879666 + 0,8165471820968505j)
    обратный гиперболический тангенс = (0,2388778612568591 + 1,311223269671635j)
    гиперболический синус = (-1,5093064853236156 + 3,4209548611170133j)
    гиперболический косинус = (-1,5656258353157435 + 3,2978948363112366j)
    гиперболический тангенс = (1.0238355945704727-0.028392952868232294j)
      

    Классификационные функции

    Есть несколько разных функций для проверки, является ли комплексное число конечным, бесконечным или нан. Также есть функция проверки близости двух комплексных чисел.

     
    print (cmath.isfinite (2 + 2j)) # Истина
    print (cmath.isfinite (cmath.inf + 2j)) # Ложь
    
    print (cmath.isinf (2 + 2j)) # Ложь
    print (cmath.isinf (cmath.inf + 2j)) # Верно
    print (cmath.isinf (cmath.nan + 2j)) # Ложь
    
    
    печать (cmath.isnan (2 + 2j)) # Ложь
    print (cmath.isnan (cmath.inf + 2j)) # Ложь
    print (cmath.isnan (cmath.nan + 2j)) # Верно
    
    print (cmath.isclose (2 + 2j, 2.01 + 1.9j, rel_tol = 0.05)) # Истина
    print (cmath.isclose (2 + 2j, 2.01 + 1.9j, abs_tol = 0.005)) # Ложь
      

    Вывод каждого оператора представлен в комментариях.

    Вы можете получить полный скрипт Python и другие примеры Python в нашем репозитории GitHub.

    Ссылка: API Doc

    Комплексные числа Python - AskPython

    Комплексное число - это любое число в форме a + bj , где a и b - действительные числа, а j * j = -1. .

    В Python есть несколько способов создать такое комплексное число.


    Создание комплексного числа в Python

    • Мы можем напрямую использовать синтаксис a + bj для создания комплексного числа.
     >>> а = 4 + 3j
    >>> print (а)
    (4 + 3j)
    >>> print (введите (a))
    <класс 'сложный'>
     
    • Мы также можем использовать комплекс Класс для создания комплексного числа
     >>> a = complex (4, 3)
    >>> print (введите (a))
    <класс 'сложный'>
    >>> print (а)
    (4 + 3j)
     

    Реальные и мнимые части в комплексном числе

    Каждое комплексное число ( a + bj ) имеет действительную часть ( a ) и мнимую часть ( b ).

    Чтобы получить действительную часть, используйте number.real , а для получения мнимой части используйте number.imag .

     >>> а
    (4 + 3j)
    >>> а.реально
    4.0
    >>> a.imag
    3.0
     

    Сопряжение комплексного числа

    Сопряжение комплексного числа a + bj определяется как a - bj . Мы также можем использовать метод number.conjugate () для получения конъюгата.

     >>> а
    (4 + 3j)
    >>> a.conjugate ()
    (4-3j)
     

    Арифметические операции над комплексными числами

    Подобно действительным числам, комплексные числа также можно складывать, вычитать, умножать и делить.Давайте посмотрим, как это сделать в Python.

     а = 1 + 2j
    б = 2 + 4j
    print ('Сложение =', a + b)
    print ('Вычитание =', a - b)
    print ('Умножение =', a * b)
    print ('Разделение =', a / b)
     

    Выход :

     Сложение = (3 + 6j)
    Вычитание = (-1-2j)
    Умножение = (-6 + 8j)
    Деление = (2 + 0j)
     

    ПРИМЕЧАНИЕ : В отличие от действительных чисел, мы не можем сравнивать два комплексных числа. Мы можем только сравнивать их действительную и мнимую части по отдельности, поскольку они являются действительными числами.Приведенный ниже фрагмент доказывает это.

     >>> а
    (4 + 3j)
    >>> б
    (4 + 6j)
    >>> а <б
    Отслеживание (последний вызов последний):
      Файл "", строка 1, в 
    TypeError: '<' не поддерживается между экземплярами 'сложный' и 'сложный'
     

    Фаза (аргумент) комплексного числа

    Мы можем представить комплексное число как вектор, состоящий из двух компонентов на плоскости, состоящей из осей действительных и мнимых . Следовательно, два компонента вектора - это действительная часть и мнимая часть.

    Вектор комплексных чисел

    Угол между вектором и действительной осью определяется как аргумент или фаза комплексного числа.

    Формально это определяется как:

    фаза (число) = арктангенс (мнимая_часть / действительная_часть)

    где функция арктангенса - это математическая функция, обратная тангенту.

    В Python мы можем получить фазу комплексного числа, используя модуль cmath для комплексных чисел.Мы также можем использовать функцию math.arctan и получить фазу из ее математического определения.

     импорт cmath
    импортная математика
    
    число = 4 + 3j
    
    # Использование модуля cmath
    p = cmath.phase (число)
    print ('Модуль cmath:', p)
    
    # Использование математического модуля
    p = math.atan (num.imag / num.real)
    print ('Математический модуль:', p)
     

    Выход :

     cmath Модуль: 0,6435011087932844
    Математический модуль: 0,6435011087932844
     

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

     импорт cmath
    импортировать numpy как np
    
    число = 4 + 3j
    
    # Использование модуля cmath
    p = cmath.phase (число)
    print ('Модуль cmath в радианах:', p)
    print ('Фаза в градусах:', np.degrees (p))
     

    Выход :

     cmath Модуль в радианах: 0,6435011087932844
    Фаза в градусах: 36.86989764584402
     

    Прямоугольные и полярные координаты

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

     >>> импорт cmath
    >>> а = 3 + 4j
    >>> полярные_координаты = cmath.polar (a)
    >>> print (полярные_координаты)
    (5,0, 0,9272952180016122)
    
    >>> модуль = абс (а)
    >>> phase = cmath.phase (а)
    >>> rect_coordinates = cmath.rect (модуль, фаза)
    >>> print (rect_coordinates)
    (3.0000000000000004 + 3.9999999999999996j)
     

    Константы в модуле cmath

    В модуле cmath есть специальные константы.Некоторые из них перечислены ниже.

     печать ('π =', cmath.pi)
    печать ('e =', cmath.e)
    печать ('тау =', cmath.tau)
    print ('Положительная бесконечность =', cmath.inf)
    print ('Положительная комплексная бесконечность =', cmath.infj)
    print ('NaN =', cmath.nan)
    print ('Комплекс NaN =', cmath.nanj)
     

    Выход :

     π = 3,141592653589793
    е = 2,718281828459045
    тау = 6,283185307179586
    Положительная бесконечность = бесконечность
    Положительная комплексная бесконечность = infj
    NaN = нан
    NaN Комплекс = nanj
     

    Тригонометрические функции

    Тригонометрические функции для комплексного числа также доступны в модуле cmath .

     импорт cmath
    
    а = 3 + 4j
    
    print ('Синус:', cmath.sin (a))
    print ('Косинус:', cmath.cos (a))
    print ('Касательная:', cmath.tan (a))
    
    print ('ArcSin:', cmath.asin (а))
    print ('ArcCosine:', cmath.acos (а))
    print ('ArcTan:', cmath.atan (а))
     

    Выход :

     Синус: (3.8537380377-27.016813258003936j)
    Косинус: (-27.034945603074224-3.8511533348117775j)
    Касательная: (-0,0001873462046294784 + 0,999355987381473j)
    ArcSin: (0,63398386563

    + 2,3055043477j) ArcCosine: (0.9368124611557198-2.3055043477j) ArcTan: (1.4483069952314644 + 0.158997199918j)

    Гиперболические функции

    Подобно тригонометрическим функциям, гиперболические функции для комплексного числа также доступны в модуле cmath .

     импорт cmath
    
    а = 3 + 4j
    
    print ('Гиперболический синус:', cmath.sinh (a))
    print ('Гиперболический косинус:', cmath.cosh (a))
    print ('Гиперболический касательный:', cmath.tanh (a))
    
    print ('Обратный гиперболический синус:', cmath.asinh (a))
    print ('Обратный гиперболический косинус:', cmath.acosh (а))
    print ('Обратный гиперболический тангенс:', cmath.atanh (a))
     

    Выход :

     Гиперболический синус: (-6,54812004025-7,612032141j)
    Гиперболический косинус: (-6.580663040551157-7. c =', cmath.с = (-13.128783081462158-15.200784463067954j)
    log2 (c) = (2.321928094887362 + 1.3378042124509761j)
    log10 (c) = (0,6989700043360187 + 0,40271733731j)
    sqrt (c) = (2 + 1j)
     

    Разные функции

    Есть несколько дополнительных функций для проверки, является ли комплексное число конечным, бесконечным или нан . Также есть функция проверки близости двух комплексных чисел.

     >>> печать (cmath.isfinite (2 + 2j))
    Правда
    
    >>> print (cmath.isfinite (cmath.inf + 2j))
    Ложь
    
    >>> печать (cmath.isinf (2 + 2j))
    Ложь
    
    >>> печать (cmath.isinf (cmath.inf + 2j))
    Правда
    
    >>> печать (cmath.isinf (cmath.nan + 2j))
    Ложь
    
    >>> печать (cmath.isnan (2 + 2j))
    Ложь
    
    >>> печать (cmath.isnan (cmath.inf + 2j))
    Ложь
    
    >>> печать (cmath.isnan (cmath.nan + 2j))
    Правда
    
    >>> print (cmath.isclose (2 + 2j, 2.01 + 1.9j, rel_tol = 0.05))
    Правда
    
    >>> print (cmath.isclose (2 + 2j, 2.01 + 1.9j, abs_tol = 0.005))
    Ложь
     

    Заключение

    Мы узнали о модуле комплексных чисел и различных функциях, связанных с модулем cmath .

    Ссылки


    MoonBooks: массивные открытые онлайн-ноутбуки

    Как заменить или удалить слово в строке в Python?


    Дайдалос
    /

    CC BY-SA 4.0

    /

    28 сентября 2021 г.


    Как проверить, является ли символ из строки буквой, числом, специальным символом или пробелом в Python?


    Дайдалос
    /

    CC BY-SA 4.0

    /

    27 сентября 2021 г.


    Как сдвинуть значения в столбце фрейма данных с помощью панд?


    Дайдалос
    /

    CC BY-SA 4.0

    /

    27 сентября 2021 г.


    Комментарий obtenir les valeurs uniques d'une liste en python?


    Bazinga
    /

    CC BY-SA 4.0

    /

    26 сентября 2021 г.


    Комментировать инвертор словесности chaîne de caractères en python?


    Bazinga
    /

    CC BY-SA 4.0

    /

    26 сентября 2021 г.


    Комментировать дополнительные элементы и дебют в цепочке символов "строка" с питоном?


    Bazinga
    /

    CC BY-SA 4.0

    /

    26 сентября 2021 г.


    Все заметки

    Как создать список чисел на Python?


    Дайдалос
    /

    CC BY-SA 4.0

    /

    09 марта 2018


    Как преобразовать массив с плавающей запятой в целочисленный массив в Python?


    Дайдалос
    /

    CC BY-SA 4.0

    /

    22 марта 2019


    Комментарий Supprimer Element d'une Liste Avec Python?


    Дайдалос
    /

    CC BY-SA 4.0

    /

    21 авг.2014 г.


    Как создать диаграмму рассеяния с несколькими цветами в matplotlib?


    Дайдалос
    /

    CC BY-SA 4.0

    /

    05 апреля 2019


    Комментарий arrondir un nombre décimal en python?


    Дайдалос
    /

    CC BY-SA 4.0

    /

    03 июн 2014


    Как преобразовать изображение в оттенки серого с помощью Python?


    Дайдалос
    /

    CC BY-SA 4.0

    /

    19 феврье 2019


    Как найти наибольшее значение в списке и его индекс с помощью Python?


    Дайдалос
    /

    CC BY-SA 4.0

    /

    27 марта 2019


    MoonBooks: массивные открытые онлайн-блокноты

    Как заменить или удалить слово в строке в Python?


    Дайдалос
    /

    CC BY-SA 4.0

    /

    28 сентября 2021 г.


    Как проверить, является ли символ из строки буквой, числом, специальным символом или пробелом в Python?


    Дайдалос
    /

    CC BY-SA 4.0

    /

    27 сентября 2021 г.


    Как сдвинуть значения в столбце фрейма данных с помощью панд?


    Дайдалос
    /

    CC BY-SA 4.0

    /

    27 сентября 2021 г.


    Комментарий obtenir les valeurs uniques d'une liste en python?


    Bazinga
    /

    CC BY-SA 4.0

    /

    26 сентября 2021 г.


    Комментировать инвертор словесности chaîne de caractères en python?


    Bazinga
    /

    CC BY-SA 4.0

    /

    26 сентября 2021 г.


    Комментировать дополнительные элементы и дебют в цепочке символов "строка" с питоном?


    Bazinga
    /

    CC BY-SA 4.0

    /

    26 сентября 2021 г.


    Все заметки

    Как создать список чисел на Python?


    Дайдалос
    /

    CC BY-SA 4.0

    /

    09 марта 2018


    Как преобразовать массив с плавающей запятой в целочисленный массив в Python?


    Дайдалос
    /

    CC BY-SA 4.0

    /

    22 марта 2019


    Комментарий Supprimer Element d'une Liste Avec Python?


    Дайдалос
    /

    CC BY-SA 4.0

    /

    21 авг.2014 г.


    Как создать диаграмму рассеяния с несколькими цветами в matplotlib?


    Дайдалос
    /

    CC BY-SA 4.0

    /

    05 апреля 2019


    Комментарий arrondir un nombre décimal en python?


    Дайдалос
    /

    CC BY-SA 4.0

    /

    03 июн 2014


    Как преобразовать изображение в оттенки серого с помощью Python?


    Дайдалос
    /

    CC BY-SA 4.0

    /

    19 феврье 2019


    Как найти наибольшее значение в списке и его индекс с помощью Python?


    Дайдалос
    /

    CC BY-SA 4.0

    /

    27 марта 2019


    Python - Комплексные числа

    Комбинированный плагин - Связано с компонентом: ничего не найдено.

      >>> 1j
    1j
    >>> тип (1j)
    <класс 'комплекс'> 
     
      >>> (3 + 1j) + (2 + 2j)
    (5 + 3j)
    >>> х = 1 + 3j
    >>> х + 1
    (2 + 3j) 
     

    Действительную и мнимую части комплексного числа можно интерпретировать как координаты x и y на комплексной плоскости, образующей точку.

      >>> х = 1 + 3j
    >>> x.real # вещественные координаты
    1.0
    >>> x.imag # координаты мнимого числа
    3,0 
     
      импортировать matplotlib.pyplot как plt
    L = [- 2 + 2j, -1 + 2j, 0 + 2j, 1 + 2j, 2 + 2j, -1 + 4j, 0 + 4j, 1 + 4j]
    X = [x.real для x в L]
    Y = [x.imag для x в L]
    plt.

    Добавить комментарий

    Ваш адрес email не будет опубликован.