Math

Числа: целые, вещественные, комплексные

Числа в 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)	x y по модулю (если модуль задан)

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

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

Над целыми числами также можно производить битовые операции

x | y	Побитовое или
x ^ y	Побитовое исключающее или
x & y	Побитовое и
x > y	Битовый сдвиг вправо

x

Инверсия битов

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

7.4. Генерация случайных значений

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

Получение простых случайных данных:

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

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

Целые и числа с плавающей точкой в Python

В программирование целые числа — это те, что лишены плавающей точкой, например, 1, 10, -1, 0 и так далее. Числа с плавающей точкой — это, например, 1.0, 6.1 и так далее.

Создание int и float чисел

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

Здесь мы присваиваем значение переменной

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

Копировать

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

Здесь также не стоит использовать кавычки.

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

Копировать

Вывод:

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

Копировать

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

Копировать

Значение выведем с помощью функции :

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

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

Сложение

В Python сложение выполняется с помощью оператора . В терминале Python выполните следующее.

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

Теперь запустим такой код.

В нем было выполнено сложение целого и числа с плавающей точкой

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

Вычитание

В Python для операции вычитания используется оператор -. Рассмотрим примеры.

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

Умножение

Для умножения в .

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

Деление

В Python деление выполняется с помощью оператора .

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

Деление без остатка

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

Результатом такой операции становится частное. Остаток же можно получить с помощью модуля, о котором речь пойдет дальше.

Остаток от деления

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

На этих примерах видно, как это работает.

Кубический корень

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

Вышеуказанное соотношение несложно доказать и для других степеней вида .

В случае с квадратным или кубическим корнем эти операции действительно эквивалентны, но, вообще говоря, в математике извлечение корня и возведение в дробную степень имеют существенные отличия при рациональных степенях вида m/n, где m != 1. Формально, в дробно-рациональную степень можно возводить только положительные вещественные числа. В противном случае возникают проблемы:

Таким образом, извлечь кубический корень в Python можно следующим образом:

Или же:

Копирование

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

• Определяет поведение для экземпляров вашего класса. возвращает глубокую копию вашего объекта — копируются и объект и его данные. это кэш предыдущих скопированных объектов, он предназначен для оптимизации копирования и предотвращения бесконечной рекурсии, когда копируются рекурсивные структуры данных. Когда вы хотите полностью скопировать какой-нибудь конкретный атрибут, вызовите на нём с первым параметром .

Специальные константы

Математическая библиотека в Python содержит две важные константы.

Pie

Первая – это Pie (π), очень популярная математическая константа. Он обозначает отношение длины окружности к диаметру круга и имеет значение 3,141592653589793. Чтобы получить к нему доступ, мы сначала импортируем математическую библиотеку следующим образом:

import math

Затем мы можем получить доступ к этой константе с помощью pi:

math.pi

Вывод:

3.141592653589793

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

import math

radius = 2
print('The area of a circle with a radius of 2 is:', math.pi * (radius ** 2))

Вывод:

The area of a circle with a radius of 2 is: 12.566370614359172

Мы увеличили значение радиуса до степени 2, а затем умножили его на круговую диаграмму в соответствии с формулой площади πr 2 .

Число Эйлера

Число Эйлера (e), являющееся основанием натурального логарифма, также определено в библиотеке Math. Мы можем получить к нему доступ следующим образом:

math.e

Вывод:

2.718281828459045

В следующем примере показано, как использовать указанную выше константу:

import math

print((math.e + 6 / 2) * 4.32)

Вывод:

24.702977498943074

Решение реальной задачи с использованием sqrt

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

Соотношение a2 + b2 = c2, где «a» и «b» – катеты, а «c» – гипотенуза – естественным образом требует извлекать корни при поиске неизвестной стороны. Python-а под рукой у древних греков и вавилонян не было, поэтому считать приходилось методом приближений. Жизнь стала проще, но расчет теоремы Пифагора никто не отменял и в XXI веке.

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

1. Ваше местоположение;
2. Центр Земли;
3. Пиковая высота вышки;

Модель готова, приступаем к написанию кода:

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

Дополнение 1: Как вызывать магические методы

Магический метод	Когда он вызывается (пример)	Объяснение
		вызывается при создании экземпляра
		вызывается при создании экземпляра
	, , etc.	Вызывается для любого сравнения
		Унарный знак плюса
		Унарный знак минуса
		Побитовая инверсия
		Преобразование, когда объект используется как индекс
	,	Булевое значение объекта
		Пытаются получить несуществующий атрибут
		Присвоение любому атрибуту
		Удаление атрибута
		Получить любой атрибут
		Получение элемента через индекс
		Присвоение элементу через индекс
		Удаление элемента через индекс
		Итерация
	,	Проверка принадлежности с помощью
		«Вызов» экземпляра
		оператор менеджеров контекста
		оператор менеджеров контекста
		Сериализация
		Сериализация

Квадратный корень

Положительное число

Именно на работу с неотрицательными числами «заточена» функция

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

А можете – из вещественных:

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

Отрицательное число

Функция не принимает отрицательных аргументов. Только положительные целые числа, вещественные числа и ноль.

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

Поэтому, если передадите отрицательное число в , то получите ошибку:

Математические функции и числовые методы

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

• , для округления чисел до определённого количества десятичных знаков
• , для получения абсолютного значения числа
• , для возведения числа в степень

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

Круглые числа с round()

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

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

Число 3,14159 округляется до трех десятичных знаков, чтобы получить 3,142, а число 2,71828 округляется до двух десятичных знаков, чтобы получить 2,72.

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

Иногда не дает правильного ответа:

2.675 – это ничья, потому что она находится ровно посередине между числами 2.67 и 2.68. Поскольку Python округляет до ближайшего четного числа, вы ожидаете, что round (2,675, 2) вернет 2,68, но вместо этого он вернет 2,67. Эта ошибка является результатом ошибки представления с плавающей запятой, а не ошибки в .

Работа с числами с плавающей запятой может вызывать разочарование, но это разочарование не характерно для Python. Все языки, реализующие стандарт IEEE с плавающей запятой, имеют одинаковые проблемы, включая C / C ++, Java и JavaScript.

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

Найдите абсолютное значение с помощью abs()

Абсолютное значение числа равно , если положительно, и , если отрицательно. Например, абсолютное значение 3 равно 3, а абсолютное значение -5 равно 5.

Чтобы получить абсолютное значение числа в Python, вы используйте :

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

Возвести в степень с помощью pow()

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

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

Например, в следующем примере функция возводит 2 в степень 3:

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

Итак, в чем разница между и ?

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

Вот пример, в котором x = 2, y = 3 и z = 2:

Сначала 2 возводится в степень 3, чтобы получить 8. Затем вычисляется 8 % 2, что равно 0, потому что 2 делит 8 без остатка.

Проверка, является ли float целым числом

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

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

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

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

Заставьте Python лгать вам

Как вы думаете, что такое ? Ответ – , правда? Посмотрим, что скажет об этом Python. Попробуйте это в интерактивном окне:

Хорошо, это . . . почти правильно. Что, черт возьми, здесь происходит? Это ошибка в Python?

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

Число 0,1 можно представить как дробь 1/10. И число 0,1, и его дробная часть 1/10 являются десятичными представлениями или представлениями base-10. Однако компьютеры хранят числа с плавающей запятой в представлении base-2, которое чаще называется двоичным представлением.

При представлении в двоичном формате с десятичным числом 0,1 происходит что-то знакомое, но, возможно, неожиданное. Дробь 1/3 не имеет конечного десятичного представления. То есть 1/3 = 0,3333 … с бесконечным числом 3 после десятичной точки. То же самое происходит с дробью 1/10 в двоичной системе.

Двоичное представление 1/10 – это следующая бесконечно повторяющаяся дробь:

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

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

Python не просто обрезает цифры в двоичном представлении 0,1. То, что происходит на самом деле, немного более тонкое.

Поскольку приближение 0,1 в двоичном формате – это всего лишь приблизительно, вполне возможно, что более одного десятичного числа имеют одинаковое двоичное приближенное значение.

Например, и 0,1, и 0,10000000000000001 имеют одинаковое двоичное приближенное значение. Python выводит самое короткое десятичное число, которое разделяет приближенное значение.

Это объясняет, почему в первом примере этого раздела 0,1 + 0,2 не равно 0,3. Python складывает двоичные приближенные значения для 0,1 и 0,2, что дает число, которое не является двоичным приближенным значением для 0,3.

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

3 ответа

Лучший ответ

Вы специально избегаете библиотек?

Если нет, вы могли бы использовать для своей власти (понял? Сила ..

не важно):. EDIT1: или альтернативно используйте:

EDIT1: или альтернативно используйте:

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

EDIT2: Но лучшим подходом будет использование битовых манипуляций:

Объяснение: каждая степень 2 имеет ровно 1 бит, установленный в 1 (бит в индексе base-2 журнала этого числа — 8 равен 1000 при 2 ^ 3 = 8, поэтому бит в индексе 3 установлен). Таким образом, вычитая из него 1, этот бит переходит на 0, а все предыдущие биты переворачиваются на 1. Это делает эти 2 числа обратными друг другу, поэтому при И-их мы получим 0 в качестве результата. Итак, в заключение, всякий раз, когда мы вычитаем единицу из числа и И с результатом, и это становится 0, это число является степенью 2.

РЕДАКТИРОВАТЬ1: время

Согласно комментарию @FilipHaglund, я вернулся к , чтобы попытаться собрать информацию об эффективности. Я обнаружил, что метод с заданной базой фактически вычисляет , что, очевидно, медленнее.

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

В конце я хотел посмотреть, как они соотносятся с бинарным подходом. Итак, результаты:

Код, который я использовал для этих мер, приведен ниже. Что я в основном сделал, так это проверил все числа от 1 до 1М, являются ли они степенью 2 в каждом методе, 10 раз и взял среднее значение. Конечно, это не научно, но дает представление …

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

Надеюсь, вы найдете мое небольшое исследование полезным 🙂

9

Tomerikoo
30 Ноя 2019 в 09:25

Используйте * 2 вместо битовых сдвигов. Битовые сдвиги ограничены размером int, но умножение — нет. Умножение или сложение гораздо более читабельно.

1

Filip Haglund
14 Июл 2019 в 08:47

Обратитесь к превосходному и подробному ответу на вопрос «Как проверить, является ли число степенью 2» — для C #. Эквивалентная реализация Python, также использующая «побитовый оператор» , это:

Python имеет целые числа произвольной точности, это работает для любого целого числа , если оно помещается в память.

Кратко резюмируя приведенный выше ответ: первый член перед логическим оператором просто проверяет, равен ли 0, и, следовательно, не имеет степень 2. Второе слагаемое проверяет, является ли оно степенью 2, проверяя, чтобы все биты после этой побитовой операции были равны 0. Битовая операция предназначена только для для степеней из 2 — с одним исключением: if (и, следовательно, все его биты) были 0 для начала.

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

3

anon
15 Июл 2019 в 07:52

Функция преобразования углов

У внимательного читателя мог на предыдущем этапе появиться вопрос: а что, если я не знаю, сколько радиан в угле? Я знаю только количество градусов. Ничего страшного, ведь библиотека math поддерживает возможность конвертации радиан в градусы и наоборот. 

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

Для того, чтобы получить количество радиан, зная количество градусов, следует воспользоваться функцией radians(), которая принимает величину угла в качестве аргумента.

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

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

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

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

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

Почему нельзя свалить все данные в одну общую кучу и не заморачиваться с каждым типом по отдельности? Допустим, мы присвоили переменной a цифру 5: a = 5. А теперь представьте, что никакого разделения по типу данных нет. Так что находится в переменной: число или строка? Если 10 — это число, то с ним можно произвести математические действия. А если это строка, то мы имеем дело с текстом и тогда Python задействует совсем другие методы.

# объединение строк (конкатенация) d = ’10’ f = ‘негритят’ d + ‘ ‘ + f ’10 негритят’

Ключевой момент: У каждого типа данных свои методы.

Цифра 100 написанная без кавычек, относится к числовому типу данных. А цифра ‘100’ в кавычках — к строковому типу. С помощью синтаксиса, мы сообщаем Python, какой у нас тип данных. Числа в Python делятся на два вида: целое число и вещественное.

Арифметические функции

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

• ceil(): возвращает максимальное значение указанного числа.
• fabs(): возвращает абсолютное значение указанного числа.
• floor(): возвращает минимальное значение указанного числа.
• gcd (a, b): возвращает наибольший общий делитель a и b.
• fsum (iterable): возвращает сумму всех элементов в повторяемом объекте.
• expm1(): возвращает (e ^ x) -1.
• exp (x) -1: когда значение x мало, вычисление exp (x) -1 может привести к значительной потере точности. Expm1 (x) может возвращать результат с полной точностью.

Следующий пример демонстрирует использование вышеуказанных функций:

import math

num = -4.28
a = 14
b = 8
num_list = 
x = 1e-4 # A small value of x

print('The number is:', num)
print('The floor value is:', math.floor(num))
print('The ceiling value is:', math.ceil(num))
print('The absolute value is:', math.fabs(num))
print('The GCD of a and b is: ' + str(math.gcd(a, b)))
print('Sum of the list elements is: ' + str(math.fsum(num_list)))
print('e^x (using function exp()) is:', math.exp(x)-1)
print('e^x (using function expml()) is:', math.expm1(x))

Вывод:

The number is: -4.28
The floor value is: -5
The ceiling value is: -4
The absolute value is: 4.28
The GCD of a and b is: 2
Sum of the list elements is: 16.029999999999998
e^x (using function exp()) is: 0.0001000050001667141
e^x (using function expml()) is: 0.00010000500016667084

К другим математическим функциям относятся следующие:

• pow(): принимает два аргумента с плавающей запятой, переводит первый аргумент во второй и возвращает результат. Например, pow (2,2) эквивалентно 2 ** 2.
• sqrt(): возвращает квадратный корень указанного числа.

Эти методы можно использовать, как показано ниже:

math.pow(3, 4)

Вывод:

81.0

Квадратный корень:

math.sqrt(81)

Вывод:

9.0

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

Для создания комплексного числа можно использовать функцию complex(a, b), в которую, в качестве первого аргумента, передается действительная часть, в качестве второго – мнимая. Либо записать число в виде  a + bj.

Рассмотрим несколько примеров.

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

>>> z = 1 + 2j
>>> print(z)
(1+2j)
>>> x = complex(3, 2)
>>> print(x)
(3+2j)

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

>>> x + z
(4+4j)
>>> x - z
(2+0j)
>>> x * z
(-1+8j)
>>> x  z
(1.4-0.8j)
>>> x ** z
(-1.1122722036363393-0.012635185355335208j)
>>> x ** 3
(-9+46j)

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

>>> x = 3 + 2j
>>> x.real
3.
>>> x.imag
2.

Для получения комплексносопряженного число необходимо использовать метод conjugate().

>>> x.conjugate()
(3-2j)

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

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

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

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

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

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

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

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

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

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

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

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

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

Число Пи из библиотеки math

Первой важной математической константой является число Пи (π). Оно обозначает отношение длины окружности к диаметру, его значение 3,141592653589793

Чтобы получить к нему доступ, сначала импортируем библиотеку math следующим образом:

Python

import math

1	importmath

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

Python

math.pi

1

math.pi

Вывод

Shell

3.141592653589793

1	3.141592653589793

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

Python

import math

radius = 2
print(‘Площадь окружности с радиусом 2 равна:’, math.pi * (radius ** 2))

1 2 3 4

importmath radius=2 print(‘Площадь окружности с радиусом 2 равна:’,math.pi*(radius**2))

Вывод

Shell

Площадь окружности с радиусом 2 равна: 12.566370614359172

1	Площадьокружностисрадиусом2равна12.566370614359172

Мы возвели радиус во вторую степень и умножили значение на число Пи, как и следовало сделать в соответствии с формулой πr2.

Целые числа (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)	x y по модулю (если модуль задан)

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

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

Над целыми числами также можно производить битовые операции

x | y	Побитовое или
x ^ y	Побитовое исключающее или
x & y	Побитовое и
x > y	Битовый сдвиг вправо

x

Инверсия битов

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

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

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

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

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

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

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

Дополнение 1: Как вызывать магические методы

Магический метод	Когда он вызывается (пример)	Объяснение
		вызывается при создании экземпляра
		вызывается при создании экземпляра
	, , etc.	Вызывается для любого сравнения
		Унарный знак плюса
		Унарный знак минуса
		Побитовая инверсия
		Преобразование, когда объект используется как индекс
	,	Булевое значение объекта
		Пытаются получить несуществующий атрибут
		Присвоение любому атрибуту
		Удаление атрибута
		Получить любой атрибут
		Получение элемента через индекс
		Присвоение элементу через индекс
		Удаление элемента через индекс
		Итерация
	,	Проверка принадлежности с помощью
		«Вызов» экземпляра
		оператор менеджеров контекста
		оператор менеджеров контекста
		Сериализация
		Сериализация

Комплексные числа в Python (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)

Кроме того, для работы с complex может применяться модуль cmath.

На этом пока что всё. Следите за новостями и не забывайте оставлять свои комментарии!

Квадратный корень: math.sqrt () и cmath.sqrt

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

функция вызывает , если результат будет :

ValueError: ошибка математического домена

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

Что с ? является эквивалентом квадратного корня из -1. Все числа можно записать в виде a + bi или в этом случае a + bj. реальная часть числа , как 2 в . Так как она не имеет мнимую часть, равно 0. представляет собой часть мнимой части числа , как 2 — в . Поскольку нет никакой реальной части в этом, также можно записать в виде .

Дополнительные методы и операции в Python

В эти операции входят:
• int.bit_length() — количество бит, которое необходимо, чтобы представить число в двоичном виде без учёта лидирующих нулей и знака;
• int.to_bytes(length, byteorder, *, signed=False) — метод возвращает строку байтов, которые представляют это число;
• 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(, byteorder='big')
16711680

Вывод

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

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

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