Математический модуль Python: Все, что Вам нужно знать

>>> import math


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

Число Пи
Число Тау
Число Эйлера
Бесконечность
Не число (NaN)

В этом разделе вы узнаете о константах и о том, как их использовать в вашем коде на Python.
Пи
Pi (π) - это отношение длины окружности (c) к ее диаметру (d): 

π = c/d 

Это соотношение всегда одинаково для любого круга.
Число Пи - это иррациональное число, что означает, что оно не может быть выражено простой дробью. Следовательно, число пи имеет бесконечное число знаков после запятой, но его можно приблизительно определить как 22/7, или 3,141.
 Интересный факт:  Число Пи - самая узнаваемая математическая постоянная в мире. У него есть своя собственная дата празднования, называемая  День числа Пи, которая приходится на 14 марта (3/14).
Вы можете получить доступ к pi следующим образом:

>>> math.pi
3.141592653589793


Как вы можете видеть, в Python значение pi равно пятнадцати знакам после запятой. Количество цифр зависит от используемого компилятора языка Си. По умолчанию Python выводит первые пятнадцать цифр, а math.pi всегда возвращает значение с плавающей точкой.
Итак, какими способами pi может быть вам полезен? Вы можете вычислить длину окружности, используя 2πr, где r - радиус окружности:

>>> r = 3
>>> circumference = 2 * math.pi * r
>>> f"Circumference of a Circle = 2 * {math.pi:.4} * {r} = {circumference:.4}"
'Circumference of a Circle = 2 * 3.142 * 3 = 18.85'


Вы можете использовать math.pi для вычисления длины окружности. Вы также можете рассчитать площадь окружности, используя формулу πr2 следующим образом:

>>> r = 5
>>> area = math.pi * r * r
>>> f"Area of a Circle = {math.pi:.4} * {r} * {r} = {area:.4}"
'Area of a Circle = 3.142 * 5 * 5 = 78.54'


Вы можете использовать math.pi для вычисления площади и длины окружности. Когда вы выполняете математические вычисления с помощью Python и сталкиваетесь с формулой, использующей π, рекомендуется использовать значение pi, заданное модулем math, вместо жесткого кодирования значения.
Тау
Tau (τ) - это отношение длины окружности к ее радиусу. Эта постоянная равна 2π, или примерно 6,28. Как и число пи, тау - иррациональное число, потому что это просто число пи, умноженное на два.
Во многих математических выражениях используется 2π, и использование tau вместо этого может помочь упростить ваши уравнения. Например, вместо вычисления длины окружности с помощью 2πr мы можем подставить tau и использовать более простое уравнение τr.
Однако использование тау в качестве константы окружности все еще является предметом дискуссий. При необходимости вы можете использовать либо 2π, либо τ.
Вы можете использовать tau, как показано ниже:

>>> math.tau
6.283185307179586


Например math.pi, math.tau возвращает пятнадцать цифр и является значением с плавающей запятой. Вы можете использовать tau для вычисления длины окружности с помощью τr, где r - это радиус, следующим образом:

>>> r = 3
>>> circumference = math.tau * r
>>> f"Circumference of a Circle = {math.tau:.4} * {r} = {circumference:.4}"
'Circumference of a Circle = 6.283 * 3 = 18.85'


Вы можете использовать math.tau вместо 2 * math.pi, чтобы привести в порядок уравнения, содержащие выражение 2π.
Число Эйлера
Число Эйлера (e) - это константа, лежащая в основе натурального логарифма, математической функции, которая обычно используется чтобы рассчитать темпы роста или затухания. Как и в случае с пи и тау, число Эйлера является иррациональным числом с бесконечным числом после запятой. Значение e часто приблизительно равно 2,718.
Число Эйлера является важной константой, поскольку оно имеет множество практических применений, таких как расчет прироста населения с течением времени или определение скорости радиоактивного распада. Вы можете получить доступ к числу Эйлера из модуля math следующим образом:

>>> math.e
2.718281828459045


Как и в случае с math.pi и math.tau, значение math.e указывается с точностью до пятнадцати знаков после запятой и возвращается в виде значения с плавающей точкой.
Бесконечность
Бесконечность не может быть определена числом. Скорее, это математическое понятие, представляющее нечто бесконечное или безграничное. Бесконечность может иметь любое направление, положительное или отрицательное.
Вы можете использовать infinity в алгоритмах , когда хотите сравнить заданное значение с абсолютным максимальным или минимальным значением. Значения положительной и отрицательной бесконечности в Python следующие:

>>> f"Positive Infinity = {math.inf}"
'Positive Infinity = inf'
>>> f"Negative Infinity = {-math.inf}"
'Negative Infinity = -inf'


Бесконечность не является числовым значением. Вместо этого она определяется как math.inf. В Python эта константа была введена в версии 3.5 как эквивалент float("inf"):

>>> float("inf") == math.inf
True


И float("inf"), и math.inf представляют собой понятие бесконечности, что делает math.inf больше любого числового значения:

>>> x = 1e308
>>> math.inf > x
True


В приведенном выше коде значение math.inf больше, чем значение x, 10308 (максимальный размер числа с плавающей запятой), которое является числом двойной точности.
Аналогично, -math.inf меньше любого значения:

>>> y = -1e308
>>> y > -math.inf
True


Отрицательная бесконечность меньше значения y, которое равно -10308. Никакое число не может быть больше бесконечности или меньше отрицательной бесконечности. Вот почему математические операции с math.inf не изменяют значение бесконечности:

>>> math.inf + 1e308
inf
>>> math.inf / 1e308
inf


Как вы можете видеть, ни сложение, ни деление не изменяют значение math.inf.
Не число (NaN)
Не число, или NaN, на самом деле не является математическим понятием. Оно возникло в области компьютерных наук как ссылка на значения, которые не являются числовыми. Значение NaN может быть получено из-за неверных входных данных или может указывать на то, что переменная, которая должна быть числовой, была искажена текстовыми символами.
Всегда рекомендуется проверять, является ли значение NaN. Если это так, то это может привести к недопустимым значениям в вашей программе. В Python константа NaN появилась в версии 3.5.
Вы можете наблюдать значение math.nan ниже:

>>> math.nan
nan


NaN не является числовым значением. Вы можете видеть, что значение math.nan равно nan, то есть совпадает с float("nan").
Арифметические функции
 Теория чисел - это раздел чистой математики, который изучает натуральные числа. Теория чисел обычно имеет дело с целыми положительными числами.
Модуль Python math предоставляет функции, которые полезны в теории чисел, а также в  теории представлений, смежной области. Эти функции позволяют вычислять ряд важных значений, включая следующие: 

Факториалы числа
Наибольший общий делитель двух чисел
Сумма повторяемых значений

Поиск факториалов с помощью Python factorial()
Возможно, вы уже сталкивались с математическими выражениями, подобными 7! или 4!. Восклицательные знаки не означают, что числа возбуждены. Скорее, “!” - это символ факториала. Факториалы используются при поиске перестановок или комбинаций. Вы можете определить факториал числа, умножив все целые числа, начиная с выбранного числа, на 1.
В следующей таблице приведены значения коэффициентов для 4, 6 и 7:



Symbol
In Words
Expression
Result




4!
Four factorial
4 x 3 x 2 x 1
24


6!
Six factorial
6 x 5 x 4 x 3 x 2 x 1
720


7!
Seven factorial
7 x 6 x 5 x 4 x 3 x 2 x 1
5040



Из таблицы видно, что 4!, или четырехфакторный коэффициент, дает значение 24 путем умножения диапазона целых чисел от 4 до 1. Аналогично, 6! и 7! дают значения 720 и 5040 соответственно.
Вы можете реализовать факториальную функцию в Python, используя один из нескольких инструментов:

for циклы
Рекурсивные функции
math.factorial()

Сначала вы рассмотрите реализацию факториала с использованием for цикла. Это относительно простой подход:

def fact_loop(num):
    if num < 0:
        return 0
    if num == 0:
        return 1

    factorial = 1
    for i in range(1, num + 1):
        factorial = factorial * i
    return factorial


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

def fact_recursion(num):
    if num < 0:
        return 0
    if num == 0:
        return 1

    return num * fact_recursion(num - 1)


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

>>> fact_loop(7)
5040

>>> fact_recursion(7)
5040


Несмотря на то, что их реализации различны, возвращаемые значения одинаковы.
Однако реализация собственных функций только для получения факториала числа отнимает много времени и неэффективна. Лучшим методом является использование math.factorial(). Вот как вы можете найти факториал числа, используя math.factorial():

>>> math.factorial(7)
5040


Этот подход возвращает желаемый результат с минимальным количеством кода.
factorial() принимает только положительные целые значения. Если вы попытаетесь ввести отрицательное значение, то получите ValueError:

>>> math.factorial(-5)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: factorial() not defined for negative values


Ввод отрицательного значения приведет к показанию ValueError factorial() not defined for negative values.
factorial() также не принимает десятичные числа. Это даст вам возможность ValueError:

>>> math.factorial(4.3)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: factorial() only accepts integral values


Ввод десятичного значения приводит к показанию ValueError factorial() only accepts integral values.
Вы можете сравнить время выполнения для каждого из факторных методов, используя timeit():

>>> import timeit
>>> timeit.timeit("fact_loop(10)", globals=globals())
1.063997201999996

>>> timeit.timeit("fact_recursion(10)", globals=globals())
1.815312818999928

>>> timeit.timeit("math.factorial(10)", setup="import math")
0.10671788000001925


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



Type
Execution Time




With loops
1.0640 s


With recursion
1.8153 s


With factorial()
0.1067 s



Как вы можете видеть из времени выполнения, factorial() работает быстрее, чем другие методы. Это связано с его базовой реализацией на языке Си. Метод, основанный на рекурсии, является самым медленным из трех. Хотя вы можете получить разные тайминги в зависимости от вашего процессора, порядок выполнения функций должен быть одинаковым.
 Это не только factorial() быстрее, чем другие методы, но и более стабильно. Когда вы реализуете свою собственную функцию, вам необходимо явно запрограммировать ее для аварийных случаев, таких как обработка отрицательных или десятичных чисел. Одна ошибка в реализации может привести к ошибкам. Но при использовании factorial() вам не нужно беспокоиться о сбоях, потому что функция обрабатывает их все. Поэтому рекомендуется использовать factorial() всякий раз, когда это возможно.
Найдите максимальное значение с помощью ceil()
math.ceil() возвращает наименьшее целое значение, которое больше или равно заданному числу. Если число является положительным или отрицательным десятичным числом, то функция вернет следующее целое значение, большее заданного значения.
Например, при вводе значения 5.43 будет возвращено значение 6, а при вводе значения -12.43 будет возвращено значение -12. math.ceil() может принимать положительные или отрицательные действительные числа в качестве входных значений и всегда будет возвращать целое значение.
Когда вы вводите целое значение в ceil(), оно возвращает то же число:

>>> math.ceil(6)
6
>>> math.ceil(-11)
-11


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

>>> math.ceil(4.23)
5
>>> math.ceil(-11.453)
-11


Если значение положительное (4.23), функция возвращает следующее целое число, большее значения (5). Если значение отрицательное (-11.453), функция аналогично возвращает следующее целое число, большее этого значения (-11).
Функция вернет значение TypeError, если вы введете значение, которое не является числом:

>>> math.ceil("x")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: must be real number, not str


В функцию необходимо ввести число. Если вы попытаетесь ввести любое другое значение, то получите TypeError.
Найдите минимальное значение с помощью floor()
floor() возвращает ближайшее целочисленное значение, меньшее или равное заданному числу. Эта функция ведет себя противоположно ceil(). Например, при вводе значения 8.72 будет возвращено значение 8, а при вводе значения -12.34 - значение -13. floor() может принимать как положительные, так и отрицательные числа в качестве входных данных и возвращает целое значение.
Если вы введете целое значение, то функция вернет то же значение:

>>> math.floor(4)
4
>>> math.floor(-17)
-17


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

>>> math.floor(5.532)
5
>>> math.floor(-6.432)
-7


Когда вы вводите положительное десятичное значение (5,532), оно возвращает ближайшее целое число, которое меньше введенного числа (5). Если вы введете отрицательное число (-6.432), то оно вернет следующее наименьшее целое значение (-7).
Если вы попытаетесь ввести значение, которое не является числом, то функция вернет значение TypeError:

>>> math.floor("x")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: must be real number, not str


Вы не можете вводить нечисловые значения в качестве входных данных для ceil(). Это приведет к TypeError.
Усекать числа с помощью trunc()
Когда вы получаете число с десятичной точкой, возможно, вам захочется сохранить только целую часть и исключить десятичную. В модуле math есть функция под названием trunc(), которая позволяет вам делать именно это.
Удаление десятичного значения является одним из видов округления. При использовании trunc() отрицательные числа всегда округляются в сторону увеличения до нуля, а положительные числа всегда округляются в сторону уменьшения до нуля.
Вот как функция trunc() округляет положительные или отрицательные числа:

>>> math.trunc(12.32)
12
>>> math.trunc(-43.24)
-43


Как вы можете видеть, 12.32 округлено в меньшую сторону до 0, что дает результат 12. Точно так же значение -43.24 округляется в сторону увеличения до 0, что дает значение -43. trunc() всегда округляется до нуля, независимо от того, положительное это число или отрицательное.
При работе с положительными числами trunc() ведет себя так же, как floor():

>>> math.trunc(12.32) == math.floor(12.32)
True


trunc() ведет себя так же, как floor() для положительных чисел. Как вы можете видеть, возвращаемое значение обеих функций одинаковое.
При работе с отрицательными числами trunc() ведет себя так же, как ceil():

>>> math.trunc(-43.24) == math.ceil(-43.24)
True


Когда число отрицательное, floor() ведет себя так же, как ceil(). Возвращаемые значения обеих функций одинаковы.
Найдите близость чисел с помощью Python isclose()
В определенных ситуациях, особенно в области обработки данных, вам может потребоваться определить, близки ли два числа друг к другу. Но для этого вам сначала нужно ответить на важный вопрос: насколько близко равно близко? Другими словами, каково определение "близко"? 
Ну, Merriam-Webster скажет вам, что “близкий” означает "близкий во времени, пространстве, эффекте или степени". Не очень-то полезно, не так ли?
Например, возьмем следующий набор чисел: 2,32, 2,33 и 2,331. Если вы измеряете близость с помощью двух десятичных знаков, то значения 2,32 и 2,33 будут близкими. Но на самом деле 2.33 и 2.331 ближе. Таким образом, близость - понятие относительное. Вы не можете определить близость без определенного порога.
К счастью, модуль math предоставляет функцию, называемую isclose(), которая позволяет вам установить свой собственный порог, или  допуск, для близости. Он возвращает True, если два числа находятся в пределах установленного вами допустимого значения близости, и в противном случае возвращает False.
Давайте посмотрим, как сравнить два числа, используя допуски по умолчанию:

 Относительный допуск, или rel_tol, является максимальной разницей для того, чтобы считаться “близким” по отношению к величине входных значений. Это процент допуска. Значение по умолчанию - 1e-09 или 0,000000001.
 Абсолютный допуск, или abs_tol, является максимальной разницей для того, чтобы считаться “близким” независимо от величины входных значений. Значение по умолчанию равно 0,0.

isclose() вернет True, когда будет выполнено следующее условие:

abs(a-b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol).

isclose использует приведенное выше выражение для определения близости двух чисел. Вы можете подставить свои собственные значения и посмотреть, близки ли какие-либо два числа.
В следующем случае 6 и 7 не являются близкими:

>>> math.isclose(6, 7)
False


Числа 6 и 7 не считаются близкими, поскольку относительный допуск установлен для девяти знаков после запятой. Но если вы введете значения 6.999999999 и 7 с одинаковым допуском, то они  будут считаться близкими:

>>> math.isclose(6.999999999, 7)
True


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

>>> math.isclose(6, 7, rel_tol=0.2)
True


Вы можете заметить, что цифры 6 и 7 теперь близки. Это потому, что они находятся на расстоянии 20% друг от друга.
Как и в случае с rel_tol, вы можете настроить значение abs_tol в соответствии со своими потребностями. Для того, чтобы разница между входными значениями считалась близкой, она должна быть меньше или равна абсолютному значению допуска. Вы можете задать значение abs_tol следующим образом:

>>> math.isclose(6, 7, abs_tol=1.0)
True
>>> math.isclose(6, 7, abs_tol=0.2)
False


Когда вы устанавливаете абсолютный допуск равным 1, числа 6 и 7 оказываются близкими, поскольку разница между ними равна абсолютному допуску. Однако во втором случае разница между 6 и 7 не меньше или равна установленному абсолютному допуску, равному 0,2.
Вы можете использовать abs_tol для очень малых значений:

>>> math.isclose(1, 1.0000001, abs_tol=1e-08)
False
>>> math.isclose(1, 1.00000001, abs_tol=1e-08)
True


Как вы можете видеть, вы можете определить близость очень маленьких чисел с помощью isclose. Несколько особых случаев, касающихся близости, можно проиллюстрировать, используя значения nan и inf:

>>> math.isclose(math.nan, 1e308)
False
>>> math.isclose(math.nan, math.nan)
False

>>> math.isclose(math.inf, 1e308)
False
>>> math.isclose(math.inf, math.inf)
True


Из приведенных выше примеров вы можете видеть, что nan не близок ни к какому значению, даже к самому себе. С другой стороны, inf не близок ни к каким числовым значениям, даже к очень большим, но  близок к самому себе.
Силовые функции
Функция степени принимает любое число x в качестве входных данных, возводит x в некоторую степень n, и возвращает xn в качестве выходных данных. Модуль Python math предоставляет несколько функций, связанных со степенями. В этом разделе вы узнаете о степенных функциях, экспоненциальных функциях и функциях с квадратным корнем.
Вычислить степень числа с помощью pow()
Степенные функции имеют следующую формулу, где переменная x является базовой, переменная n - это степень, и a может быть любой константой:

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

>>> math.pow(2, 5)
32.0
>>> math.pow(5, 2.4)
47.59134846789696


Первый аргумент - это базовое значение, а второй аргумент - значение степени. Вы можете ввести целое или десятичное значение в качестве входных данных, и функция всегда вернет значение с плавающей точкой. Существуют некоторые особые случаи, определенные в math.pow().
Когда основание 1 возводится в степень любого числа n, это дает результат 1.0:

>>> math.pow(1.0, 3)
1.0


Когда вы возводите базовое значение 1 в любую степень, вы всегда получаете результат 1,0. Аналогично, любое базовое число, возведенное в степень 0, дает результат 1,0:

>>> math.pow(4, 0.0)
1.0
>>> math.pow(-4, 0.0)
1.0


Как вы можете видеть, любое число, возведенное в степень 0, даст в качестве результата 1,0. Вы можете увидеть этот результат, даже если основание равно nan:

>>> math.pow(math.nan, 0.0)
1.0


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

>>> math.pow(0.0, 2)
0.0
>>> math.pow(0.0, 2.3)
0.0


Но если вы попытаетесь возвести 0.0 в отрицательную степень, то результатом будет ValueError:

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


Значение ValueError возникает только в том случае, если основание равно 0. Если основанием является любое другое число, кроме 0, то функция вернет допустимое значение степени.
Помимо math.pow(), в Python есть два встроенных способа определения степени числа:

x ** y
pow()

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

>>> 3 ** 2
9
>>> 2 ** 3.3
9.849155306759329


Когда вы используете целые числа, вы получаете целочисленное значение. Когда вы используете десятичные значения, возвращаемый тип изменяется на десятичное значение.
 Второй вариант - это универсальная встроенная функция. Для ее использования вам не нужно использовать какой-либо импорт. Встроенный метод pow() имеет три параметра:

Базовый номер
Степень число
Число  модуля

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

>>> pow(3, 2)
9
>>> pow(2, 3.3)
9.849155306759329


Встроенный pow() имеет два обязательных аргумента, которые работают так же, как base и power в синтаксисе x ** y. pow() также имеет третий параметр, который является необязательным: модуль упругости. Этот параметр часто используется в криптографии. Встроенный pow() с дополнительным параметром модуля эквивалентен уравнению (x ** y) % z. Синтаксис Python выглядит следующим образом:

>>> pow(32, 6, 5)
4
>>> (32 ** 6) % 5 == pow(32, 6, 5)
True


pow() возводит основание (32) в степень (6), а затем полученное значение делится по модулю  на число по модулю (5). В этом случае результат равен 4. Вы можете подставить свои собственные значения и увидеть, что и pow(), и приведенное уравнение дают одинаковые результаты.
Несмотря на то, что все три метода расчета мощности работают одинаково, между ними существуют некоторые различия в реализации. Время выполнения для каждого метода следующее:

>>> timeit.timeit("10 ** 308")
1.0078728999942541

>>> timeit.timeit("pow(10, 308)")
1.047615700008464

>>> timeit.timeit("math.pow(10, 308)", setup="import math")
0.1837239999877056


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



Type
Execution Time




x ** y
1.0079 s


pow(x, y)
1.0476 s


math.pow(x, y)
0.1837 s



Из таблицы видно, что math.pow() работает быстрее, чем другие методы, а встроенный pow() - самый медленный.
Причина эффективности math.pow() заключается в том, как она реализована. Она основана на базовом языке Си. С другой стороны, pow() и x ** y используют собственную реализацию оператора ** объекта ввода. Однако math.pow() не может обрабатывать комплексные числа (что будет объяснено в следующем разделе), в то время как pow() и ** могут.
Найдите натуральный показатель степени с помощью exp()
Вы узнали о степенных функциях в предыдущем разделе. С экспоненциальными функциями дело обстоит немного иначе. Вместо основания переменной становится степень. Это выглядит примерно так:

Общая экспоненциальная функция
Здесь a может быть любой константой, а x, которое является значением степени, становится переменной.
Итак, что же такого особенного в экспоненциальных функциях? Значение функции быстро растет по мере увеличения значения x. Если основание больше 1, то значение функции непрерывно увеличивается по мере увеличения x. Особым свойством экспоненциальных функций является то, что наклон функции также непрерывно увеличивается по мере увеличения x.
Вы узнали о числе Эйлера из предыдущего раздела . Оно является основанием натурального логарифма. Оно также играет важную роль в показательной функции. Когда число Эйлера включается в экспоненциальную функцию, оно становится естественной экспоненциальной функцией:

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

>>> math.exp(21)
1318815734.4832146
>>> math.exp(-1.2)
0.30119421191220214


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

>>> math.exp("x")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: must be real number, not str


Как вы можете видеть, если входные данные представляют собой строковое значение, то функция возвращает значение TypeError must be real number, not str.
Вы также можете вычислить показатель степени, используя выражение math.e ** x или используя pow(math.e, x). Время выполнения этих трех методов следующее:

>>> timeit.timeit("math.e ** 308", setup="import math")
0.17853009998701513

>>> timeit.timeit("pow(math.e, 308)", setup="import math")
0.21040189999621361

>>> timeit.timeit("math.exp(308)", setup="import math")
0.125878200007719


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



Type
Execution Time




e ** x
0.1785 s


pow(e, x)
0.2104 s


math.exp(x)
0.1259 s



Вы можете видеть, что math.exp() работает быстрее, чем другие методы, а pow(e, x) - самый медленный. Это ожидаемое поведение из-за базовой реализации C модуля math.
Также стоит отметить, что e ** x и pow(e, x) возвращают одинаковые значения, но exp() возвращает немного другое значение. Это связано с различиями в реализации. В документации Python отмечается, что exp() является более точным, чем два других метода.
Практический пример с exp()
 Радиоактивный распад происходит, когда нестабильный атом теряет энергию, испуская ионизирующее излучение. Скорость радиоактивного распада измеряется с помощью периода полураспада, который представляет собой время, необходимое для распада половины количества исходного ядра. Вы можете рассчитать процесс распада по следующей формуле:

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

 N(0) - начальное количество вещества.
 N(t) - это количество, которое все еще остается и еще не распалось по истечении некоторого времени (t).
 T - период полураспада распадающегося вещества.
 e это число Эйлера.

Научные исследования выявили периоды полураспада всех радиоактивных элементов. Вы можете подставить значения в уравнение, чтобы рассчитать оставшееся количество любого радиоактивного вещества. Давайте попробуем это сейчас.
Период полураспада радиоизотопа стронция-90 составляет 38,1 года. Образец содержит 100 мг стронция-90. Вы можете рассчитать количество оставшихся миллиграммов Sr-90 через 100 лет:

>>> half_life = 38.1
>>> initial = 100
>>> time = 100
>>> remaining = initial * math.exp(-0.693 * time / half_life)
>>> f"Remaining quantity of Sr-90: {remaining}"
'Remaining quantity of Sr-90: 16.22044604811303'


Как вы можете видеть, период полураспада установлен равным 38,1, а продолжительность - 100 годам. Вы можете использовать math.exp для упрощения уравнения. Подставив значения в уравнение, вы можете найти, что через 100 лет  остается 16,22 мг Sr-90.
Логарифмические функции
 Логарифмические функции можно считать обратными показательным функциям. Они обозначаются в следующем виде:

Общая логарифмическая функция
Здесь a - основание логарифма, которое может быть любым числом. Вы узнали об экспоненциальных функциях из предыдущего раздела. Экспоненциальные функции могут быть выражены в виде логарифмических функций и наоборот.
Естественный журнал Python С log()
 натуральный логарифм числа - это его логарифм по основанию математической константы e, или числа Эйлера:

Натуральная логарифмическая функция
Как и в случае с экспоненциальной функцией, в natural log используется константа e. Обычно это изображается как f(x) = ln(x), где e неявно.
Натуральный логарифм можно использовать так же, как и экспоненциальную функцию. Он используется для расчета таких значений, как скорость роста населения или скорость радиоактивного распада элементов.
log() имеет два аргумента. Первый из них является обязательным, а второй - необязательным. С помощью одного аргумента вы можете получить логарифмическое значение (до основания e) входного числа:

>>> math.log(4)
1.3862943611198906
>>> math.log(3.4)
1.2237754316221157


Однако функция возвращает значение ValueError, если вы вводите неположительное число:

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


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

>>> math.log(math.pi, 2)
1.651496129472319
>>> math.log(math.pi, 5)
0.711260668712669


Вы можете увидеть, как изменяется значение при изменении базы журнала.
Понимать log2() и log10()
Модуль Python math также предоставляет две отдельные функции, которые позволяют вычислять логарифмические значения с основанием 2 и 10:

log2() используется для вычисления логарифмического значения с основанием 2.
log10() используется для вычисления логарифмического значения с основанием 10.

С помощью log2() вы можете получить логарифмическое значение с основанием 2:

>>> math.log2(math.pi)
1.6514961294723187
>>> math.log(math.pi, 2)
1.651496129472319


Обе функции преследуют одну и ту же цель, но в  документации по Python отмечается, что log2() более точно, чем при использовании log(x, 2).
Вы можете вычислить логарифмическое значение числа с основанием 10 с помощью log10():

>>> math.log10(math.pi)
0.4971498726941338
>>> math.log(math.pi, 10)
0.4971498726941338


В  документации по Python также упоминается, что log10() является более точным, чем log(x, 10), хотя обе функции преследуют одну и ту же цель.
Практический пример с Натуральным Логарифмом
В предыдущем разделе вы видели, как использовать math.exp() для расчета остаточного количества радиоактивного элемента по истечении определенного периода времени. С помощью math.log() вы можете определить период полураспада неизвестного радиоактивного элемента, измерив его массу с определенным интервалом. Для расчета периода полураспада радиоактивного элемента можно использовать следующее уравнение:

Уравнение радиоактивного распада
Изменив формулу радиоактивного распада, вы можете включить в формулу период полураспада (T). Переменные данной формулы следующие:

 T - период полураспада распадающегося вещества.
 N(0) - начальное количество вещества.
 N(t) - это количество, которое остается и еще не распалось по истечении определенного периода времени (t).
 ln - это натуральный логарифм.

Вы можете подставить известные значения в уравнение для расчета периода полураспада радиоактивного вещества.
Например, представьте, что вы изучаете образец неопознанного радиоактивного элемента. Когда он был обнаружен 100 лет назад, объем образца составлял 100 мг. После 100 лет распада осталось всего 16,22 мг. Используя приведенную выше формулу, вы можете рассчитать период полураспада этого неизвестного элемента:

>>> initial = 100
>>> remaining = 16.22
>>> time = 100
>>> half_life = (-0.693 * time) / math.log(remaining / initial)
>>> f"Half-life of the unknown element: {half_life}"
'Half-life of the unknown element: 38.09942398335152'


Вы можете видеть, что период полураспада неизвестного элемента составляет примерно 38,1 года. Основываясь на этой информации, вы можете идентифицировать неизвестный элемент как стронций-90.
Другие важные math Функции модуля
Модуль Python math имеет множество полезных функций для математических вычислений, и в этой статье подробно рассмотрены лишь некоторые из них. В этом разделе вы кратко познакомитесь с некоторыми другими важными функциями, доступными в модуле math.
Вычислить наибольший общий делитель
Наибольший общий делитель (НОД) двух положительных чисел - это наибольшее натуральное число, которое делит оба числа без остатка.
Например, число, равное 15 и 25, равно 5. Вы можете разделить и 15, и 25 на 5 без остатка. Нет большего числа, которое приводило бы к тому же результату. Если вы возьмете 15 и 30, то НОД будет равен 15, потому что и 15, и 30 можно разделить на 15 без остатка.
Вам не нужно реализовывать свои собственные функции для вычисления GCD. Модуль Python math предоставляет функцию под названием math.gcd(), которая позволяет вам вычислять GCD из двух чисел. Вы можете ввести положительные или отрицательные числа в качестве входных данных, и программа вернет соответствующее значение GCD. Однако вы не можете ввести десятичное число.
Вычислить сумму повторяющихся значений
Если вы когда-нибудь захотите найти сумму значений итерационной переменной без использования цикла, то math.fsum() вероятно, это самый простой способ сделать это. Вы можете использовать повторяющиеся элементы, такие как массивы, кортежи или списки в качестве входных данных, и функция вернет сумму значений. Встроенная функция под названием sum() также позволяет вычислять сумму повторяющихся значений, но fsum() более точна, чем sum(). Вы можете прочитать больше об этом в документации .
Вычислить квадратный корень
Квадратный корень  из числа - это величина, которая при умножении сама на себя дает число. Вы можете использовать math.sqrt() для нахождения квадратного корня из любого действительного положительного числа (целого или десятичного). Возвращаемое значение всегда является значением с плавающей точкой. Функция выдаст ValueError, если вы попытаетесь ввести отрицательное число.
Преобразование значений углов
Как в реальной жизни, так и в математике вы часто сталкиваетесь с ситуациями, когда для выполнения вычислений приходится измерять углы. Углы могут измеряться как в градусах, так и в радианах. Иногда вам приходится переводить градусы в радианы и наоборот. Модуль math предоставляет функции, которые позволяют вам это сделать.
Если вы хотите преобразовать градусы в радианы, то вы можете использовать math.radians(). Это возвращает значение в радианах для ввода градуса. Аналогично, если вы хотите преобразовать радианы в градусы, то вы можете использовать math.degrees().
Вычисление тригонометрических значений
Тригонометрия - это наука о треугольниках. Она изучает взаимосвязь между углами и сторонами треугольника. Тригонометрия в основном интересуется прямоугольными треугольниками (у которых один внутренний угол равен 90 градусам), но ее можно применять и к другим типам треугольников. Модуль Python math предоставляет очень полезные функции, которые позволяют выполнять тригонометрические вычисления.
Вы можете вычислить значение синуса угла с помощью math.sin(),, значение косинуса - с помощью math.cos(), а значение тангенса - с помощью math.tan(). Модуль math также предоставляет функции для вычисления синуса дуги с помощью math.asin(), косинуса дуги с помощью math.acos() и тангенса дуги с помощью math.atan(). Наконец, вы можете вычислить гипотенузу треугольника, используя math.hypot().
Новые дополнения к модулю math в Python 3.8
С выходом  версии Python 3.8 В модуль math было внесено несколько новых дополнений и изменений. Новые дополнения и изменения заключаются в следующем:


comb(n, k) возвращает количество способов выбора k элементов из n элементов без повторений и без определенного порядка..


perm(n, k) возвращает количество способов выбора k элементов из n элементов без повторений и с соблюдением порядка..


isqrt() возвращает квадратный корень из неотрицательного целого числа.


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


dist() возвращает Евклидово расстояние между двумя точками p и q, каждая из которых задана в виде последовательности (или повторяющихся) координат. Эти две точки должны иметь одинаковое измерение.


hypot() теперь он поддерживает более двух измерений. Ранее он поддерживал максимум два измерения.


cmath против math
Комплексное число  представляет собой комбинацию действительного и мнимого чисел. Он имеет формулу a + bi, где a - действительное число, а bi - это мнимое число. Действительные и мнимые числа можно объяснить следующим образом:

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

Действительным числом может быть любое число. Например, 12, 4.3, -19.0 - все это действительные числа. Мнимые числа отображаются как i. На следующем рисунке показан пример комплексного числа:

Комплексное число
В приведенном выше примере, 7 - действительное число, а 3i - мнимое число. Комплексные числа в основном используются в геометрии, математическом анализе, научных расчетах и особенно в электронике.
Функции модуля Python math не предназначены для обработки комплексных чисел. Однако в Python есть другой модуль, который может работать с комплексными числами, а именно модуль cmath. Модуль Python math дополняется модулем cmath, который реализует многие из тех же функций, но для комплексных чисел.
Вы можете импортировать модуль cmath следующим образом:

>>> import cmath


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

>>> c = 2 + 3j
>>> c
(2+3j)

>>> type(c)
<class 'complex'>


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

>>> c = complex(2, 3)
>>> c
(2+3j)

>>> type(c)
<class 'complex'>


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

>>> cmath.sqrt(c)
(1.8581072140693775+0.6727275964137814j)

>>> cmath.log(c)
(1.3622897515267103+0.6947382761967031j)

>>> cmath.exp(c)
(-16.091399670844+12.02063434789931j)


В этом примере показано, как вычислить квадратный корень, логарифмическое значение и экспоненциальное значение комплексного числа. Вы можете ознакомиться с документацией, если хотите узнать больше о модуле cmath.
NumPy против math
Для математических вычислений можно использовать несколько известных библиотек Python. Одной из наиболее известных библиотек является Numerical Python, или NumPy. В основном она используется в научных вычислениях и в областях науки о данных. В отличие от модуля math, который является частью стандартной версии Python, вам необходимо установить NumPy, чтобы работать с ним.
Сердцем NumPy является высокопроизводительная N-мерная (многомерная) структура данных массива. Этот массив позволяет выполнять математические операции со всем массивом без перебора элементов. Все функции в библиотеке оптимизированы для работы с N-мерными массивами объектов.
Для математических вычислений можно использовать как модуль math, так и библиотеку NumPy. NumPy имеет несколько общих черт с модулем math. В NumPy есть подмножество функций, аналогичных math функциям модуля, которые выполняют математические вычисления. Как NumPy, так и math предоставляют функции, которые обрабатывают тригонометрические, экспоненциальные, логарифмические,  гиперболические и арифметические вычисления.
Также существует несколько фундаментальных различий между math и NumPy. Модуль Python math больше ориентирован на работу со скалярными значениями, в то время как NumPy лучше подходит для работы с массивами, векторами и даже матрицами.
При работе со скалярными значениями math функции модуля могут работать быстрее, чем их аналоги из NumPy. Это связано с тем, что функции NumPy преобразуют значения в массивы, чтобы выполнять вычисления над ними. NumPy работает намного быстрее при работе с N-мерными массивами из-за оптимизаций для них. За исключением fsum() и prod(), функции модуля math не могут обрабатывать массивы.
Заключение
Из этой статьи вы узнали о модуле Python math. Модуль предоставляет полезные функции для выполнения математических вычислений, которые имеют множество практических применений.
 Из этой статьи вы узнали:

Что такое модуль Python math
Как пользоваться math функциями с практическими примерами
Каковы константы модуля math, включая pi, tau и число Эйлера, 
В чем разница между встроенными функциями и math функциями
В чем разница между math, cmath, и NumPy

Понимание того, как использовать функции math, является первым шагом. Теперь пришло время начать применять полученные знания в реальных ситуациях. Если у вас есть какие-либо вопросы или комментарии, пожалуйста, оставьте их в разделе комментариев ниже.
<статус завершения article-slug="python-math-module" class="btn-group mb-0" data-api-article-bookmark-url="/api/v1/articles/python-math-module/bookmark/" data-api-article-завершение-статус-url="/api/версия 1/статьи/python-математический модуль/завершение_статуса/">



<кнопка поделиться bluesky-text="Интересная статья на #Python от @realpython.com :" email-body="Ознакомьтесь с этой статьей о Python:%0A%0 Математический модуль Python: все, что вам нужно знать" email-subject="Статья о Python для вас" twitter-text="Интересная #Статья о Python от @realpython:" url="https://realpython.com/python-math-module /" url-title="Математический модуль Python: все, что вам нужно знать">

 Смотрите сейчас, к этому уроку прилагается соответствующий видеокурс, созданный командой Real Python. Посмотрите его вместе с письменным руководством, чтобы углубить свое понимание:  Изучение математического модуля Python

                







                 Back to Top