math — Математические функции


Этот модуль обеспечивает доступ к математическим функциям, определенным стандартом C.

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

Этот модуль предоставляет следующие функции. За исключением случаев, когда явно указано иное, все возвращаемые значения являются плавающими.

Теоретико-числовые и репрезентативные функции

math.ceil(x)

Функция округляет число x до ближайшего целого в большую сторону. Если x не float, делегируется x.__ceil__(), который должен возвратить Integral значение.

math.comb(n, k)

Возвращает количество способов выбора k позиций из n позиций без повторения и без порядка.

Вычисляется как n! / (k! * (n - k)!) при k <= n и равно нулю при k > n.

Также называется биномиальным коэффициентом, потому что он эквивалентен коэффициенту k-го члена в полиномиальном расширении выражения (1 + x) ** n.

Поднимает TypeError, если любой из аргументов не является целыми числами. Вызывает ValueError, если любой из аргументов отрицательный.

Добавлено в версии 3.8.

math.copysign(x, y)

Возвращает модуль (абсолютное значение) float x, но с знаком y. На платформах, поддерживающих знаковые нули, copysign(1.0, -0.0) возвращает -1.0.

math.fabs(x)

Возвращает абсолютная значение x.

math.factorial(x)

Возвращает x факториал как целое число. Поднимает ValueError, если x не является целым или отрицательным.

math.floor(x)

Возвращает округление в меньшую сторону x, наибольшее целое число, меньшее или равне x. Если x не float, делегируется x.__floor__(), который должен возвращать значение Integral.

math.fmod(x, y)

Возвращает fmod(x, y), как определено библиотекой платформы C. Обратите внимание, что выражение x % y Python не может возвращает тот же результат. Намерение стандарта C состоит в том, что fmod(x, y) точно (математически; к бесконечной точности), равняются x - n*y для некоторого целочисленного n, таким образом, что у результата есть тот же знак как x и величина меньше, чем abs(y). Python’s x % y возвращает результат со знаком y вместо него и может быть не совсем вычисляемым для аргументов float. Например, fmod(-1e-100, 1e100) есть -1e-100, но результат Python’s -1e-100 % 1e100 есть 1e100-1e-100, который не может быть представлен точно как float, и округляет до удивительного 1e100. По этой причине функция fmod() обычно предпочтительна при работе с поплавками, тогда как Python’s x % y - при работе с целыми числами.

math.frexp(x)

Возвращает мантиссу и степень x как пару (m, e). m - float, а e - целое число, такое, что x == m * 2**e точно. Если x равно нулю, возвращает (0.0, 0), в противном случае 0.5 <= abs(m) < 1. Это - используемый, чтобы «выбрать обособленно» внутреннее представление float портативным способом.

math.fsum(iterable)

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

>>> sum([.1, .1, .1, .1, .1, .1, .1, .1, .1, .1])
0.9999999999999999
>>> fsum([.1, .1, .1, .1, .1, .1, .1, .1, .1, .1])
1.0

Точность алгоритма зависит от IEEE-754 арифметических гарантий и типичного случая, когда режим округления является получетным. В некоторых построениях, отличных от Windows, базовая библиотека C использует расширенное добавление точности и иногда может дублировать промежуточную сумму, что приводит к ее отключению в младшем бите.

Для дальнейшего обсуждения и двух альтернативных подходов см. Рецепты ASPN для точного суммирования с плавающей точкой.

math.gcd(a, b)

Возвращает наибольший общий делитель целых чисел a и b. Если a или b ненулевое, то значение gcd(a, b) - наибольшее положительное целое число, делящее и a, и b. gcd(0, 0) возвращает 0.

Добавлено в версии 3.5.

math.isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0)

Возвращает True если значения a и b близки друг к другу и False иначе.

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

rel_tol - относительная терпимость - это - максимальное позволенное различие между a и b относительно большего абсолютного значение a или b. Например, чтобы задать допуск 5%, следует пройти rel_tol=0.05. Допуском по умолчанию точность является 1e-09, что гарантирует, что эти два значения одинаковы в пределах около 9 десятичных цифр. rel_tol должно быть больше нуля.

abs_tol является минимальным абсолютным допуском – полезно для сравнения, близкого к нулю. abs_tol должно быть не менее нуля.

Если ошибок не возникает, результат будет следующим: abs(a-b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol).

Специальные значения IEEE 754 NaN, inf и -inf будут обрабатываться в соответствии с правилами IEEE. В частности, NaN не считается близким к каким-либо другим значение, включая NaN. inf и -inf считаются только близкими к себе.

Добавлено в версии 3.5.

См.также

PEP 485 - функция для проверки приближенного равенства

math.isfinite(x)

Возвращает True если x не является ни бесконечностью, ни NaN, и False иначе. (Обратите внимание, что 0.0 будет считается конечным.

Добавлено в версии 3.2.

math.isinf(x)

Возвращает True если x - положительная или отрицательная бесконечность, и False иначе.

math.isnan(x)

Возвращает True если x - NaN (не число), и False иначе.

math.isqrt(n)

Возвращает целое число квадратного корня неотрицательного целого числа n. Это пол точного квадратного корня n, или эквивалентно наибольшему целому a, такому как a² ≤ n.

Для некоторых заявлений может быть более удобно иметь наименее целочисленный a, таким образом что n ≤ a² или другими словами потолок точного квадратного корня n. Для положительных n это можно вычислить с помощью a = 1 + isqrt(n - 1).

Добавлено в версии 3.8.

math.ldexp(x, i)

Возвращает x * (2**i). Это, по существу, обратная функция frexp().

math.modf(x)

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

math.perm(n, k=None)

Возвращает количество способов выбора k позиций из n позиций без повторения и с заказом.

Вычисляется как n! / (n - k)! при k <= n и равно нулю при k > n.

Если k не определен или является None, то дефолты k к n и возвращает n! функции.

Поднимает TypeError, если любой из аргументов не является целыми числами. Вызывает ValueError, если любой из аргументов отрицательный.

Добавлено в версии 3.8.

math.prod(iterable, *, start=1)

Вычислите произведение всех элементов в iterable ввода. start значение по умолчанию для продукта - 1.

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

Добавлено в версии 3.8.

math.remainder(x, y)

Возвращает остаток x в стиле IEEE 754 относительно y. Для конечных x и конечных ненулевых y это разность x - n*y, где n - ближайшее целое число к точному значение частного x / y. Если x / y точно промежуточный между двумя последовательными целыми числами, ближайшее целое число even - используемый для n. Остаток r = remainder(x, y) таким образом всегда удовлетворяет abs(r) <= 0.5 * abs(y).

Особые случаи следуют за IEEE 754: в частности, remainder(x, math.inf) является x для любого конечного x, а remainder(x, 0) и remainder(math.inf, x) поднять ValueError для любого не-NaN x. Если результат операции остатка равен нулю, этот ноль будет иметь тот же знак, что и x.

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

Добавлено в версии 3.7.

math.trunc(x)

Возвращает Real значение x, усеченный к Integral (обычно целое число). Делегаты на x.__trunc__().

Обратите внимание, что frexp() и modf() имеют другой шаблон call/возвращает, чем их C эквиваленты: они принимают один аргумент и возвращает пару значения, а не возвращают свой второй возвращает значение через «выходной параметр» (в Python такого нет).

Для ceil() floor() и функции modf(), отмечают, что числа с плавающей запятой all достаточно большой величины - точные целые числа. Python поплавки обычно несут не более 53 бит точности (такой же, как у платформы C двойного типа), и в этом случае любой float x с abs(x) >= 2**52 обязательно не имеет дробных битов.

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

math.exp(x)

Возвращает e поднят на мощность x, где e = 2,718281… является основой натуральных логарифмов. Обычно это более точно, чем math.e ** x или pow(math.e, x).

math.expm1(x)

Возвращает e повышен до мощности x, минус 1. Здесь e - основание натуральных логарифмов. Для небольших поплавков x вычитание в exp(x) - 1 может привести к значительной потере точности; функция expm1() предоставляет способ вычисления этой величины до полной точности:

>>> from math import exp, expm1
>>> exp(1e-5) - 1  # дает результат с точностью до 11 мест
1.0000050000069649e-05
>>> expm1(1e-5)    # результат с точностью до полной точности
1.0000050000166668e-05

Добавлено в версии 3.2.

math.log(x[, base])

С одним аргументом, возвращает натуральный логарифм x (для основания e).

С двумя аргументами, возвращает логарифм x к данному base, вычисленный как log(x)/log(base).

math.log1p(x)

Вернуть натуральный логарифм 1 + x (основание e). результат рассчитывается так, чтобы он был точным для x около нуля.

math.log2(x)

Возвращает логарифм пооснованию-2 x. Обычно это более точно, чем log(x, 2).

Добавлено в версии 3.3.

См.также

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

math.log10(x)

Возвращает логарифм основания-10 x. Обычно это более точно, чем log(x, 10).

math.pow(x, y)

Возвращает x поднят на силовой y. В исключительных случаях, насколько это возможно, следует приложению F стандарта C99. В частности, pow(1.0, x) и pow(x, 0.0) всегда возвращает 1.0, даже когда x является нулем или NaN. Если и x, и y конечны, x является отрицательным, а y не является целым числом, то pow(x, y) является неопределенным и повышает ValueError.

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

math.sqrt(x)

Возвращает квадратный корень x.

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

math.acos(x)

Возвращает дуговой косинус x, в радианах.

math.asin(x)

Возвращает дуговой синус x, в радианах.

math.atan(x)

Возвращает касательная дуги x, в радианах.

math.atan2(y, x)

Возвращает atan(y / x), в радианах. Результат между -pi и pi. Вектор в плоскости от начала до точки (x, y) делает этот угол положительным по оси X. Точка atan2() в том, что знаки обоих входов ему известны, так что он может вычислить правильный квадрант для угла. Например, atan(1) и atan2(1, 1) оба являются pi/4, но atan2(-1, -1) является -3*pi/4.

math.cos(x)

Возвращает косинус x радиан.

math.dist(p, q)

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

Примерно эквивалентный:

sqrt(sum((px - qx) ** 2.0 for px, qx in zip(p, q)))

Добавлено в версии 3.8.

math.hypot(*coordinates)

Возвращает евклидова норма, sqrt(sum(x**2 for x in coordinates)). Это длина вектора от начала координат до точки, заданной координатами.

Для двумерной точки (x, y) это эквивалентно вычислению гипотенузы прямоугольного треугольника с помощью теоремы пифагора, sqrt(x*x + y*y).

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

math.sin(x)

Возвращает синус x радиан.

math.tan(x)

Возвращает тангенс радианов x.

Угловое преобразование

math.degrees(x)

Преобразование угла x из радианов в градусы.

math.radians(x)

Преобразуйте угол x из градусов в радианы.

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

Гиперболические функции - аналоги тригонометрических функций, которые основаны на гиперболах вместо кругов.

math.acosh(x)

Возвращает обратный гиперболический косинус x.

math.asinh(x)

Возвращает обратный гиперболический синус x.

math.atanh(x)

Возвращает обратный гиперболический тангенс x.

math.cosh(x)

Возвращает гиперболический косинус x.

math.sinh(x)

Возвращает гиперболический синус x.

math.tanh(x)

Возвращает гиперболический тангенс x.

Специальные функции

math.erf(x)

Возвращает функцию ошибки для x.

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

def phi(x):
    'Накопительная функция распределения для стандартного нормального распределения'
    return (1.0 + erf(x / sqrt(2.0))) / 2.0

Добавлено в версии 3.2.

math.erfc(x)

Возвращает дополнительную функцию ошибки в точке x. Дополнительная функция ошибки определяется как 1.0 - erf(x). Это - используемый для большого значения x, где вычитание от можно было бы вызвать потеря значимости.

Добавлено в версии 3.2.

math.gamma(x)

Возвращает Гамма функцию для x.

Добавлено в версии 3.2.

math.lgamma(x)

Возвращает натуральный логарифм абсолютного значение гамма-функции при x.

Добавлено в версии 3.2.

Константы

math.pi

Математическая константа π = 3,141592…, к доступной точности.

math.e

Математическая константа e = 2,718281…, к доступной точности.

math.tau

Математическая константа τ = 6.283185…, доступная точность. Тау - постоянная окружности, равная 2*π*, отношение окружности окружности к её радиусу. Чтобы узнать больше о тау, ознакомьтесь с видео Vi Hart Пи (все еще) ошибается, и начать праздновать День тау, съев вдвое больше пирога!

Добавлено в версии 3.6.

math.inf

Положительная бесконечность с плавающей запятой. (Для отрицательной бесконечности используйте -math.inf.) Эквивалентно выходу float('inf').

Добавлено в версии 3.5.

math.nan

Плавающая точка «не числовое» (NaN) значение. Эквивалентно выходу float('nan').

Добавлено в версии 3.5.

Детали реализации CPython: Модуль math состоит в основном из тонких оболочек вокруг функций математической библиотеки платформы C. Поведение в исключительных случаях в соответствующих случаях следует приложению F стандарта C99. Текущая реализация поднимет ValueError для недопустимых операций, таких как sqrt(-1.0) или log(0.0) (где C99 Приложение F рекомендует сигнализировать о недопустимости операции или деления на ноль), и OverflowError для результатов, которые переполняют (например, exp(1000.0)). NaN не будет возвращенный из любой из функций, указанных выше, если один или несколько входных аргументов не были NaN; в этом случае большинство функций будет возвращает NaN, но (снова после Приложения F C99) есть некоторые исключения к этому правилу, например, pow(float('nan'), 0.0) или hypot(float('nan'), float('inf')).

Следует отметить, что Python не предпринимает никаких усилий для отличия сигнализации NaN от тихих NaN, и поведение сигнализации NaN остается неопределенным. Типичное поведение - относиться ко всем NaN как к тихим.

См.также

Модуль cmath
Комплексные числа версии многих из этих функций.