что такое комплексные числа в python
Комплексные числа — complex
Если вы еще ничего не прочитали о комплексных числах на википедии, то обязательно прочитайте. А если прочитали, но не совсем поняли, хотя, даже если и поняли, мы все равно подробно рассмотрим как устроены и как работают комплексные числа в Python.
Создание комплексных чисел
Мы знаем, что любое комплексное число \(z\) задается его действительной частью \(a\), мнимой частью \(b\) и в нем всегда присутствует символ \(i\), обозначающий мнимую единицу. В Python все практически точно так же, только мнимую единицу обозначают символом j (реже J ), а числа \(a\) и \(b\) могут быть любыми числами типа int или float. Например, комплексные числа в Python могут выглядеть следующим образом:
Интуитивно понятно, что если в числе \(a+bi\) мнимая часть \(b=0\), то оно автоматически становится обычным вещественным числом, потому что \(z=a+0i=a\). Но в то же время все вещественные числа, являются подмножеством комплексных, значит число \(a\) это комплексное число у которого мнимая часть равна \(0\). В математике это так, но в Python нет, т.е. автоматического преобразования чисел типа complex в числа типа int или float не происходит, даже если их мнимая часть равна \(0\):
Наверное, если бы такое преобразование имело место, то это привело бы к противоречиям некоторых математических операций. Здесь следует еще раз напомнить о преобразовании типов и о том что это преобразование работает только в одну сторону:
Встроенная функция complex()
Встроенная функция complex(real[, imag]) позволяет создать комплексное число на основе значений его действительной и мнимой частей:
Приятным сюрпризом данной функции, является то что она может создавать комплексное число из строки. Но с небольшой оговоркой, эта строка должна быть допустимым литералом комплексного числа:
Учитывая, что на месте действительной и мнимой части могут находиться только целые и вещественные числа, то как видите, способов ввода строк комплексных чисел становится довольно много. Однако, следует помнить, что пробельные символы являются недопустимыми:
Представление на комплексной плоскости
Целые и вещественные числа в геометрическом представлении являются точками на числовом луче:
Геометрическим представлением комплексных чисел являются точки на плоскости. Данная плоскость называется комплексной и абсолютно аналогична прямоугольной системе координат, только по оси абцис (x) откладывается величина действительной части ( real ), а по оси ординат (y) ооткладывается величина мнимой части ( imag ). Например, точка \(A(3, 4)\) и комплексное число \(z = 3 + 4i\) будут выглядеть вот так:
Как видите, изображение комплексных чисел на плоскости довольно простой процесс, по сути это те же самые декартовы координаты, которые получаются по правилу: \(x=\mathrm
Изображение комплексных чисел еще и весьма удобно, так как позволяет наглядно изображать арифметические операции над ними.
Арифметические операции
Сложение двух комплексных чисел \(A=a+bi\) и \(B=c+di\) выполняется по простой формуле:
Python выполняет все промежуточные действия за нас, сразу выдавая результат:
На предыдущем рисунке мы видели, что комплексное число это точка на комплексной плоскости. Но если заметить что значения действительной и мнимой части отсчитываются от начала координат, то уместно задать вопрос: «А нельзя ли изображать эти числа в виде векторов?» Ответ: «Можно.» Данные числа действительно можно рассматривать как радиус-векторы:
Разность комплексных чисел задается похожим образом:
Умножение комплексного числа на вещественное число выполняется очень просто: \(kA = k\left(a+bi\right)=ka + kbi\) и по сути просто меняет лишь длину радиус вектора комплексного числа, вдоль его направления:
А вот умножение комплексных чисел друг на друга немного сложнее:
Как всегда в Python мы сразу видим результат:
Который на комплексной плоскости выглядит вот так:
Можно было бы предположить, что это что-то вроде векторного или скалярного умножения векторов, но нет, умножение комплексных чисел, отличается от этих двух операций.
Деление комплексного числа на вещественное число, так же как и умножение на вещественное число кроме длины радиус-вектора вдоль его направления ничего не меняет:
Деление комплексных чисел друг на друга вычисляется по формуле:
Давайте посмотрим как это выглядит в Python и на комплексной плоскости:
Математические операции
Комплексные числа поддерживают не все математические операции и не все операции сравнения, а побитовые операции не поддерживаются вообще. Дело в том, что комплексные числа являются «двумерными», что на первый взгляд вовсе не кажется помехой для таких операций как целочисленное деление или остаток от деления. На на самом деле введение таких операций приводит к неопределенностям, которые невозможно преодолеть. К тому же, такие операции как и > так же не могут быть выполнены просто потому, что мы не знаем какая из двух точек на плоскости будет больше другой, а какая меньше.
Неподдерживаемые комплексными числами математические операции выделены красным цветом и оставлены в таблице, потому что они формально могут присутствовать в математических выражениях содержащих числа типа int и float. Все операции отсортированы по убыванию приоритета:
Важно: приоритет математических операций выше операций сравнения.
I. возведение \(0+0i\) в степень \(0+0i\) возвращает \(1+0i\):
III. Функция abs() всегда возвращает результат типа float.
IV. деление на \(0+0i\) приведет к ошибке и вызовет исключение ZeroDivisionError.
V. встроенная функция complex() пропускает числа (объекты) типа complex «как есть», не выполняя над ними, абсолютно никаких действий.
VI. строго говоря эти функции не являются математическими, но они могут учавствовать в математических выражениях Python и поэтому должны обладать приоритетом.
Операции сравнения
Для сравнения чисел имеется \(8\) операций, но для комплексных чисел доступно только \(4\) причем все они имеют одинаковый приоритет:
Важно: приоритет операций сравнения ниже математических.
I. эти операции могут присутствовать в математических выражениях, но если операндами являются комплексные числа или одним из них является комплексным числом, то это приведет к ошибке и вызовет исключение TypeError:
BestProg
Содержание
Поиск на других ресурсах:
Модуль всегда доступен из программы.
Функции модуля cmath оперируют аргументами
Способ 1. Задавание непосредственно вещественной и мнимой части комплексного числа
При этом функция complex() может получать разное количество аргументов:
Каждый из аргументов может быть числового типа, или даже комплексным числом.
Способ 2. Указание комплексного числа в виде строки
При этом способе функция complex() получает только один аргумент — строку. Два аргумента передавать запрещено.
3. Как получить вещественную и мнимую части комплексного числа? Пример
После создания комплексного числа функцией complex() (см. предыдущий пункт) можно получить доступ к его составляющим с помощью следующего обращения:
Пример.
Результат выполнения программы
4. Пример, демонстрирующий создание комплексного числа различными способами
Результат выполнения программы
В модуле cmath функции для работы с комплексными числами сгруппированы следующим образом:
5.1. Функции преобразования в полярные координаты и наоборот
К этой категории функций относятся следующие:
5.2. Степенные и логарифмические функции
В модуле cmath реализованы следующие степенные и логарифмические функции, оперирующие комплексными числами:
5.3. Тригонометрические функции
Модуль cmath содержит 6 тригонометрических функций, которые обрабатывают комплексные числа:
5.4. Гиперболические функции
Модуль cmath содержит реализацию следующих гиперболических функций, которые оперируют комплексными числами:
5.5. Функции классификаций
К числу функций классификаций модуля cmath относятся следующие:
Модуль cmath содержит ряд широко применяемых констант:
Числа
Числа в языке Python представлены тремя встроенными типами: целые ( int ), вещественные ( float ) и комплексные ( comlex ), а так же двумя типами чисел, которые предоставляет его стандартная библиотека: десятичные дроби неограниченной точности ( Decimal ) и обыкновенные дроби ( Float ).
Числовой тип данных устроен очень просто и интуитивно понятно. Однако, если чисел в вашей работе очень много, то узнать о них будет, по крайней мере, не лишним.
Помимо этого, числа встроенных типов (int, float и complex) относятся к немутирующим (неизменяемым) объектам, т.е. объектам чья структура не может быть изменена напрямую. Нельзя изменить какую-нибудь цифру существующего числа, нельзя расставить его цифры в обратном порядке. То что кажется изменением числа, на самом деле таковым не является. Например:
Вроде бы мы создали объект-число со значением \(1\), а затем изменили его значение на \(0\). Но если это так, то id объекта (его адрес в памяти) не должен меняться, а он меняется:
Как видим, изменения объекта не произошло, старый объект исчез и появился новый. Эту информацию трудно назвать «очень полезной», но она нужна для понимания «внутренней кухни» языка. Например того, что все в этом языке, включая числа, является объектом. Или того, что числа, действительно хранятся в памяти компьютера, и живут в этой памяти по каким-то своим правилам. Но вся эта внутренняя кухня является заботой самого Python. В основном, мы пишем код, даже не задумываясь о ее существовании, лишь иногда, очень редко вмешиваясь в ее работу.
Ну и последнее, что я могу сказать о встроенных числовых типах, так это то, что результат всегда преобразуется к более общему типу если это необходимо. Например, если частное двух целых чисел (int) не является целым числом, то оно будет преобразовано к вещественному типу (float):
А если результат не может быть выражен типами int и float, то он будет преобразован к типу complex. Так что если вдруг будете вычислять корни четной степени из отрицательных чисел, не ждите ошибки:
Еще мы могли бы рассмотреть как устроено хеширование чисел, или как устроены их классы. Но такие тонкости настолько редко требуются на практике, что я о них ни разу не слышал (что и не мудрено, я ведь сельский учитель 😇). А к тому моменту, когда вам вдруг это потребуется вы и сами без труда сможете со всем разобраться. Давайте рассмотрим каждый тип чисел в отдельности.
Целые числа (int)
Все дело в том, что данная функция для трех аргументов реализована, как алгоритм быстрого возведения в степень по модулю, что на порядки быстрее чем эквивалентная команда:
Поддержка длинной арифметики может показаться излишней, но на самом деле, есть целая куча подразделов математики (например, комбинаторика, теория графов, теория чисел, криптография и т.д.) где ее наличие «под рукой» может сильно облегчить вычисления и даже способствовать вашему самообразованию. Чем, по вашему, изучение отличается от заучивания? Верно, тем что вы сами все проверяете и подвергаете критике.
Вещественные числа (float)
Наверное, было бы правильнее называть эти числа числами с плавающей точкой нежели вещественными, но в принципе, с определенной натяжкой, можно сказать, что это, как бы одно и тоже. Давайте разберемся почему.
В качестве примера возьмем число \(\sqrt<2>\), которое является вещественным потому что мы никогда не сможем выразить его с помощью обыкновенной дроби. А если мы все-таки извлечем корень из двойки, то обнаружим, что это бесконечная десятичная дробь. Но вычислив этот корень на Python:
мы увидим, что никакой бесконечной дробью и не пахнет. Python вернул только начало этой дроби, а все остальное отброс ил, т.е. он вернул число с плавающей точкой, которое как бы и соответствует вещественному числу, но с определенной погрешностью.
На самом деле, работая с числами с плавающей точкой, мы очень часто подразумеваем числа вещественные, например вот такое число \(\sqrt[77]<7>\), его мы увидим в виде конечной десятичной дроби:
А число \(7^<-77>\) в виде мантисы \(8.461569363277291\) (опять же конечной десятичной дроби) и порядка \(-66\):
Кстати, можно было бы подумать, что 8.461569363277291*10**(-66) вернет результат идентичный предыдущему, но:
Отличие настолько незначительное, что для нас оно становится абсолютно неважным. Возможно, поэтому числа типа float в Python все чаще называют вещественными, а не числами с плавающей точкой. Возможно, потому что так короче, хотя и не так как кажется:
А может, потому что в нашей стране все меньше инженеров и прочих физиков-ядерщиков, для которых «какие-то» погрешности принципиально важны. Незнаю.
В общем важно то, что тип float это тип чисел с погрешностью, чисел с ограниченной точностью. И этой точности нам более чем достаточно. Но существуют исключения из правил – ситуации, в которых и пятый и даже миллионный знак после запятой может оказаться очень важен. А бывают даже такие ситуации, когда мы вообще не можем пользоваться десятичными дробями (вещественными числами).
Комплексные числа (complex)
Единственная область где могут пригодиться комплексные числа – это наука, как теоретическая, так и прикладная. Причем, если понаблюдать за теоретиками, то можно заметить, что они, вполне себе, обходятся бумагой и ручкой, а вот прикладники часто, очень часто что-то считают на компьютерах. Причем, комплексные числа нет-нет да появятся, то тут то там. В принципе, раз это надо только ученым, то пусть сами и выкручиваются – они же умные. «Хм. ну так-то я и есть ученый и как бы даже математик» подумал (наверное) создатель языка Гвидо Ван Россум и добавил в Python комплексные числа.
Раз поддерживаются комплексные числа, следовательно, поддерживаются и математические операции над комплексными числами, так что если вам вдруг понадобится вычислить, значение какой нибудь комлексной функции, например такой:
при \(z=1+1j\), то знайте – в этом нет ничего сложного:
Десятичные дроби (Decimal)
Числа данного типа позволяют производить вычисления над десятичными дробями с заданной точностью. Возможно, вы сразу задались вопросом: «А разве типом float мы обойтись не можем? Ведь это как бы и десятичные дроби, а погрешности при вычислениях с ними, настолько ничтожны, что мы можем вообще не обращать на них внимания.» Чтож, вполне обоснованное замечание, но давайте посмотрим вот на такой пример:
Должно получиться ровно \(0.4\) а получилось \(0.39999999999999997\). Конечно, как вы сказали: на такую погрешность можно вообще не обращать внимания, но как минимум, такой результат сложения кажется странным сам по себе. Ну в самом деле, разве это так трудно правильно сложить? Дело в том, что компьютер использует двоичную арифметику, над числами в двоичном представлении, а конечная десятичная дробь, в двоичном представлении может оказаться бесконечной, бесконечный «хвост» которой и отбрасывается при вычислениях, что в свою очередь и приводит к таким «ничтожным» погрешностям.
Но, как говорится «Дьявол кроется в мелочах» Очень неприятным последствием таких «ничтожно-маленьких» погрешностей является то, что вы не можете точно проверить истинность равенства:
Потому что с точки зрения компьютера:
А в финансовой и бухгалтерской среде подобные логические проверки выполняются постоянно.
Вторым неприятным последствием становится то, что погрешности имеют свойство накопления. Расмотрим простой пример:
Потребность в повышенной точности, возникает очень редко, но возникает неспроста. Именно эту потребность и призваны удовлетворить числа типа Decimal. Этот тип не является встроенным, а предоставляется модулем Decimal из стандартной библиотеки Python:
Причем точность может быть настолько большой, насколько позволяет мощность компьютера. Допустим, мы хотим видеть результат с точностью \(80\) знаков после запятой (хотя можем увидеть и \(1000\)), вот они:
Хотелось бы думать, что такая точность доступна абсолютно для всех математических операций и функций, например таких как всякие синусы, косинусы или даже Γ, Β, G, K функции и прочая экзотика. Но нет, слишком хорошо – тоже не хорошо. К тому же все эти и другие функции могут быть получены с помощью базовых математических операций, которые модулем Decimal прекрасно поддерживаются, например:
Обыкновенные дроби (Fraction)
Честно говоря без чисел типа Fraction можно легко обойтись, но из примера видно, что данный модуль выполнил сокращение числителя и знаменателя автоматически, что довольно любопытно и наводит на вопрос «А где бы мне это могло пригодиться?». Самый очевидный ответ – числовые ряды и пределы. Для примера рассмотрим ряд Лейбница, который сходится к \(\pi/4\) (правда медленно. ооочень медленно сходится):
Или посмотреть на поведение вот такого предела:
который тоже можно выразить с помощью чисел типа fractions:
Мы можем проделать тоже самое, полагаясь только на встроенные типы чисел, но результат будет не так приятен глазу:
Числа в Python (FAQ)
Ч исла в Python (как и в других языках программирования) чрезвычайно простое понятие. В Python все переменные представляют собой объекты и размещаются в динамической памяти.
Базовый набор Python содержит следующие типы чисел:
Целые числа (int)
Любое целое число состоит из массива цифр переменной длины, поэтому в Python 3 в переменную типа int может быть записано число неограниченной длины. Единственное ограничение длины — это размер оперативной памяти.
>>> 134523345234252523523478777 ** 2 18096530413013891133013347014216107772438771969415729
Целые числа могут записываться не только как десятичные, но и как двоичные, восьмеричные или шестнадцатеричные. Для этого перед числом нужно написать символы:
Вещественные числа (float)
Числа типа float — неточны (из-за представления чисел с плавающей запятой в компьютере).
>>> 0.3 + 0.3 + 0.3 + 0.1 0.9999999999999999
Информацию о точности и внутреннем представлении float для вашей системы можно получить из sys.float_info
>>> import sys >>> sys.float_info sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)
Если нужна высокая точность обычно используют модули Decimal и Fraction.
Комплексные числа (complex)
Отдельные части комплексного числа доступны через атрибуты real и imag
>>> num = 1.1+2j >>> num.real, num.imag (1.1, 2.0)
Операции с числами
Является ли переменная числом
Любую переменную можно проверить на тип (int, float или complex):
n = 10 >>> if type(n) == int: print(«This is int») This is int
Если вы хотите проверить, находится ли в строке число, воспользуйтесь методом isdigit()
>>> string = «404» >>> string.isdigit() True
Однако стоит помнить, что метод isdigit() не работает для отрицательных чисел и чисел с плавающей точкой.
Также для проверки на число, можно написать собственную функцию:
>>> def isInt(value): try: int(value) return True except ValueError: return False >>> isInt(123) True >>> isInt(«qwerty») False >>> isInt(«123») True >>> isInt(«-123») True >>> isInt(«123.2») False
Арифметические операции
Сравнение чисел
Преобразования
Ввод чисел
Если нужен список чисел, введите несколько чисел через пробел и выполните:
my_list = [int(x) for x in input().split()] print(my_list) > [1, 2, 3]
Вывод чисел
Для вывода числа используйте print() :
На практике возникают ситуации, когда нужно вывести число вместе со строкой (например пояснить, что означает число). Существует несколько вариантов сделать это:
>>> print(«int variable = » + str(1)) int variable = 1 >>> print(«int variable = <>«.format(1)) int variable = 1 >>> print(f’int variable = <1>‘) # f-строки работаюв в Python 3.6+ int variable = 1
Числа в Python и методы работы с ними
В Python, как и во всех популярных языках программирования, имеются целые числа (int) и числа с плавающей точкой (float). Но у Python есть и отличительная особенность – комплексные числа (complex).
Стоит также уточнить, что при присваивании переменной любого типа числа, не нужно использовать кавычки, так как они определяют строку, а не число. Пример:
Целые числа (int) в Python
В Python, как и в привычной нам математике, целыми числами являются все числа, которые лишены дробной части, то есть не имеют плавающей точки. Рассмотрим на примере:
Для упрощения создания больших чисел в Python используется нижнее подчеркивание, а не запятая. Пример:
Числа с плавающей точкой (float)
Для отделения целой части числа в Python используется точка. Рассмотрим создание float-числа на примере:
Комплексные числа (complex)
Как я писал выше, Python поддерживает комплексные числа без установки дополнительных модулей. Рассмотрим создание таких чисел на примере:
Проверка типа данных переменной
Для проверки типа данных переменной в Python используется встроенная функция type(). Рассмотрим на примере:
Арифметические действия в Python
Сложение делается с помощью оператора “+”. Пример:
С помощью сложения можно преобразовать целое число в число с плавающей точкой. Рассмотрим на примере:
Вычитание выполняется с помощью оператора “—”. Пример:
Умножение делается с помощью оператора “*”:
Возведение в степень выполняется с помощью оператора “**”. Пример:
Также возведение в степень можно производить с помощью функции pow():
Деление выполняется с помощью оператора “/”. Пример:
Для получения остатка от деления используется оператор “%”. Пример:
Целочисленное деление выполняется с помощью оператора “//”. Пример:
Округление чисел с плавающей точкой
Для округления float-чисел до ближайшего целого числа используется функция round(). Рассмотрим на примере:
Получение модуля числа
Для получения модуля любого числа мы можем использовать функцию abs(). Рассмотрим на примере:
Вывод
Мы разобрали функции для работы с числами в Python и научились ими пользоваться. Надеюсь, эта статья оказалась для вас полезной. Удачи в ваших начинаниях!