Сообщить об ошибке.

Функции теории чисел модуля math в Python.

Функции относящиеся к теории чисел.

В этом разделе представлены функции относящиеся к теории чисел.

Содержание:


math.factorial(x):

Функция math.factorial() возвращает факториал указанного числа x.
>>> import math
>>> math.factorial(5)
120
Данная функция всегда возвращает число типа int и поддерживает длинную арифметику, т.е. величина обрабатываемого числа x и возвращаемого результата ограничивается только возможностями компьютера.
Если x не является целым числом или если x является отрицательным, то будет вызвано исключение ValueError.
Изменено в Python 3.9. Не рекомендуется передавать числа с плавающей запятой с целыми значениями (например, 5.0).

math.gcd(*integers):

Функция math.gcd() возвращает наибольший общий делитель указанных целочисленных аргументов *integers.
>>> import math
>>> math.gcd(3886, 9048)
# 58

# проверяем
>>> 3886/58, 9048/58
# (67.0, 156.0)
  • Если какой-либо из аргументов не равен нулю, то возвращаемое значение является наибольшим положительным целым числом, которое является делителем всех аргументов:
  • Если все аргументы равны нулю, то возвращаемое значение равно 0.
  • функция math.gcd() вызванная без аргументов возвращает 0.
Указанные числа должны быть целыми типа int, но могут быть как положительными, так и отрицательными:
>>> import math
>>> math.gcd(-4, -8)
# 4
>>> math.gcd(-4, -8.8)
# Traceback (most recent call last):
#   File "<stdin>", line 1, in <module>
# TypeError: 'float' object cannot be interpreted as an integer
Изменено в Python 3.9: Добавлена ​​поддержка произвольного количества аргументов. Раньше поддерживалось только два аргумента.

math.frexp(x):

Функция math.frexp() возвращает кортеж из двух чисел (m, e) таких что x == m*2**e.
>>> import math
>>> math.frexp(123)
# (0.9609375, 7)
>>> 0.9609375*2**7
# 123.0
Число m принадлежит к типу float и всегда является таким, что 0.5 <= abs(m) < 1, даже для тех случаев, когда значением x является произвольная степень двойки. Число e всегда целое число int:
>>> math.frexp(0.25)
# (0.5, -1)
>>> math.frexp(64)
# (0.5, 7)
Если x равен 0, то будет возвращено (0.0, 0).
Данная функция используется тогда, когда представление чисел типа float не должно зависеть от архитектуры машины.

math.ldexp(x, i):

Функция math.ldexp() возвращает значение равное x*2**i, т.е. является обратной к функции math.frexp().
>>> import math
>>> math.ldexp(3, 4)
# 48.0
>>> math.ldexp(0.125, 8)
# 32.0

math.fabs(x):

Функция math.fabs() возвращает абсолютное значение, модуль числа x. Результат всегда тип float.
>>> import math
>>> math.fabs(-3)
3.0
Данная функция в отличии от встроенной функции abs() не обрабатывает комплексные числа.

math.fmod(x):

Функция math.fmod() возвращает остаток от деления числа x на число y, вычисленный так, как это определено в библиотеке math языка C.
>>> import math
>>> math.fmod(2.23, 0.2)
0.02999999999999986
Данная функция направлена на то, что бы результат был максимально приближен к значению x - n*y для некоторого целого числа n, что бы этот результат имел тот же знак, что и x, что бы разность x - n*y == abs(y).
Для чисел типа float данная функция является предпочтительнее чем команда x%y, которая в свою очередь является предпочтительной для чисел типа int. Так как для некоторых случаев, например при x = -1e-100 и x = 1e100, команда x%y может вообще выдать неправильный результат.

math.modf(x):

Функция math.modf() возвращает кортеж из двух чисел (f, w) где f это дробная, а w - целая часть числа x. Результат всегда имеет тип float.
>>> import math
>>> math.modf(3)
# (0.0, 3.0)
>>> math.modf(3.14)
# (0.14000000000000012, 3.0)

math.fsum(iterable):

Функция math.fsum() возвращает точную сумму значений в итерируемой последовательности iterable. Возвращаемый результат всегда типа float.
>>> import math
>>> sum([.1, .1, .1, .1, .1, .1, .1, .1, .1, .1])
# 0.9999999999999999
>>> math.fsum([.1, .1, .1, .1, .1, .1, .1, .1, .1, .1])
# 1.0
Может показаться, что эта сумма будет точной всегда, но на самом деле это не так:
>>> math.fsum([0.3, 0.3, 0.3])
0.8999999999999999
Многое зависит от сборки компилятора языка C, который используется на данной платформе. Если вам нужны точные арифметические операции с десятичными дробями, то воспользуйтесь модулем decimal.

math.copysign(x, y):

Функция math.copysign() возвращает число c абсолютным значением x, но со знаком числа y. Возвращаемый результат всегда типа float
>>> import math
>>> math.copysign(14, -12)
# -14.0
>>> math.copysign(-14, 12)
# 14.0
На платформах, которые поддерживают нули со знаком функция math.copysign(1.0, -0.0) возвращает -1.0.

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

Функция math.isclose() возвращает True если в пределах указанной точности, числа a и b близки настолько, что их можно считать равными.
>>> import math
>>> x = 7
>>> y = 7.000000000000001
>>> x==y
# False
>>> math.isclose(x, y)
# True
Считать числа близкими или нет, определяют два аргумента rel_tol и abs_tol.
Аргумент rel_tol это относительный допуск, определяемый как максимально допустимая разница между числами a и b относительно большего из них по модулю. По умолчанию rel_tol=1e-09, что гарантирует, что числа a и b будут одинаковы, в пределах 9 десятичных цифр. Чтобы числа считались равными, если они, допустим, отличаются меньше чем на 0.1%, то достаточно установить rel_tol=0.001, но в любом случае данный параметр, должен быть больше нуля:
>>> y = 7.000001
>>> math.isclose(y, 6.999, rel_tol=0.001)
# True
Аргумент abs_tol это минимальный абсолютный допуск. полезен для сравнений, близких к нулю. Значение abs_tol должно быть не меньше нуля.
Данная функция эквивалентна команде abs(a-b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol). Значения inf, -inf считаются близкими только сами к себе, а NaN не является близким ни к одному значению, включая само NaN.

math.lcm(*integers):

Функция math.lcm() возвращает наименьшее общее кратное указанных целочисленных аргументов *integers.
  • Если все аргументы отличны от нуля, то возвращаемое значение является наименьшим положительным целым числом, кратным всем аргументам.
  • Если какой-либо из аргументов равен нулю, то возвращается значение 0.
  • Функция math.lcm(), вызванная без аргументов возвращает 1.
Новое в Python 3.9.

math.nextafter(x, y):

Функция math.nextafter() возвращает следующее значение float после x по направлению к y.
Если x равно y, то функция возвращает y.
Примеры:
  • math.nextafter(x, math.inf) идет вверх: в сторону положительной бесконечности.
  • math.nextafter(x, -math.inf) идет вниз: в сторону минус бесконечности.
  • math.nextafter(x, 0.0) стремится к нулю.
  • math.nextafter(x, math.copysign(math.inf, x)) уходит от нуля.
Новое в Python 3.9.

math.ulp(x):

Функция math.isclose() возвращает значение наименьшего значащего бита числа float x.
  • Если x - NaN (не число), то вернет x.
  • Если x отрицательный, то вернет ulp(-x).
  • Если x - положительная бесконечность, то вернет x.
  • Если x равен нулю, то вернет наименьшее положительное денормализованное представимое число float (меньше минимального положительного нормализованного числа float, sys.float_info.min).
  • Если x равен наибольшему положительному представимому числу float, то вернет значение младшего значащего бита x, так что первое число float меньше x будет x - ulp(x).
  • В противном случае (x - положительное конечное число) вернет значение младшего значащего бита x, так что первое число float больше x равно x + ulp(x).
ULP означает "Единица на последнем месте".
Новое в Python 3.9.