Модуль math в Python — функции, константы и примеры

Python поставляется со встроенным модулем math, который открывает доступ к математическим функциям стандартной библиотеки C. В этой главе рассматриваются:

Базовые арифметические операторы, встроенные в Python
Все ключевые константы (pi, e, tau, inf, nan)
Вспомогательные функции округления, абсолютного значения, возведения в степень и квадратного корня
Тригонометрические функции и преобразование градусов в радианы
Логарифмические и экспоненциальные функции
Вспомогательные функции теории чисел: gcd, factorial, isqrt, comb, perm
Инспекция чисел с плавающей точкой: isfinite, isinf, isnan, isclose

Установка не требуется — достаточно написать import math.

Базовые арифметические операторы

Python выполняет повседневные арифметические операции с помощью встроенных операторов — никакой модуль для этого не нужен.

# Integer and float arithmetic
print(2 + 3)    # 5    — addition
print(5 - 2)    # 3    — subtraction
print(3 * 4)    # 12   — multiplication
print(10 / 2)   # 5.0  — true division (always returns float)
print(10 // 3)  # 3    — floor division (rounds toward negative infinity)
print(10 % 3)   # 1    — modulo (remainder)
print(2 ** 8)   # 256  — exponentiation

Оператор ** — идиоматический способ возведения числа в степень в Python. Используйте его вместо math.pow() для целочисленных значений: результат остаётся целым числом, тогда как math.pow() всегда возвращает float.

Импорт модуля math

Для всего, что выходит за пределы приведённых операторов, импортируйте math:

import math

Можно также импортировать конкретные имена, чтобы избежать префикса math.:

from math import sqrt, pi, factorial
print(sqrt(25))     # 5.0
print(pi)           # 3.141592653589793
print(factorial(5)) # 120

В производственном коде предпочтительнее import math — так сразу видно, откуда берётся каждая функция.

Математические константы

Модуль math определяет несколько констант:

import math

print(math.pi)   # 3.141592653589793  — ratio of circumference to diameter
print(math.e)    # 2.718281828459045  — base of the natural logarithm
print(math.tau)  # 6.283185307179586  — 2 * pi (full circle in radians)
print(math.inf)  # inf                — positive infinity
print(math.nan)  # nan                — "not a number" sentinel

math.inf удобно использовать в качестве начального значения, когда нужен «максимально возможный» ограничитель:

import math

best = math.inf
for value in [5, 3, 8, 1]:
    if value < best:
        best = value
print(best)  # 1

Округление и абсолютное значение

import math

print(math.floor(3.7))   # 3    — round toward negative infinity
print(math.ceil(3.2))    # 4    — round toward positive infinity
print(math.trunc(3.9))   # 3    — strip the decimal (toward zero)
print(math.trunc(-3.9))  # -3   — note: trunc(-3.9) != floor(-3.9)
print(math.fabs(-5.3))   # 5.3  — absolute value, always returns float
print(abs(-5))           # 5    — built-in abs() works for int and float

Разница между trunc и floor важна для отрицательных чисел:

import math

print(math.floor(-3.2))   # -4  — floor always rounds down
print(math.trunc(-3.2))   # -3  — trunc always rounds toward zero

Квадратный корень, степень и гипотенуза

import math

print(math.sqrt(25))      # 5.0  — square root (returns float)
print(math.isqrt(17))     # 4    — integer square root (floor, returns int)
print(math.pow(2, 10))    # 1024.0  — power, always returns float
print(2 ** 10)            # 1024    — integer exponentiation, stays int
print(math.hypot(3, 4))   # 5.0  — Euclidean distance sqrt(3²+4²)

math.isqrt() (добавлено в Python 3.8) — правильный выбор, когда нужен целочисленный результат без преобразования из float, например при проверке точного квадрата:

import math

n = 144
if math.isqrt(n) ** 2 == n:
    print(f"{n} is a perfect square")  # 144 is a perfect square

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

import math

# 3-D distance from origin to (1, 2, 2)
print(math.hypot(1, 2, 2))  # 3.0

Факториал и вспомогательные функции для целых чисел

import math

print(math.factorial(5))   # 120  — 5! = 5*4*3*2*1
print(math.factorial(0))   # 1    — 0! is defined as 1
print(math.gcd(48, 18))    # 6    — greatest common divisor
print(math.lcm(4, 6))      # 12   — least common multiple (Python 3.9+)

math.factorial выбрасывает ValueError для отрицательных аргументов и TypeError для нецелых значений.

Комбинаторика

В Python 3.8 появились math.comb и math.perm на замену ручным формулам с факториалами:

import math

# Number of ways to choose 2 items from 5 (order does not matter)
print(math.comb(5, 2))   # 10

# Number of ways to arrange 2 items from 5 (order matters)
print(math.perm(5, 2))   # 20

# All permutations of 5 items
print(math.perm(5))      # 120  — same as factorial(5)

comb(n, k) эквивалентно n! / (k! * (n-k)!), но работает быстрее и избегает больших промежуточных значений.

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

Модуль math работает в радианах. Используйте math.radians() для предварительного перевода градусов.

import math

angle_deg = 30
angle_rad = math.radians(angle_deg)  # 0.5235987755982988

print(math.sin(angle_rad))           # 0.49999999999999994  (~0.5)
print(math.cos(angle_rad))           # 0.8660254037844387   (~√3/2)
print(math.tan(angle_rad))           # 0.5773502691896256   (~1/√3)

# Convert radians back to degrees
print(math.degrees(math.pi))         # 180.0

Часто используемые углы в радианах:

Градусы	Выражение в радианах	Значение `math`
0°	`0`	`0`
30°	`math.pi / 6`	`0.5236…`
45°	`math.pi / 4`	`0.7854…`
90°	`math.pi / 2`	`1.5708…`
180°	`math.pi`	`3.1416…`

Обратные тригонометрические функции возвращают радианы:

import math

print(math.asin(0.5))                # 0.5235987755982988  (= pi/6 = 30°)
print(math.acos(0.5))                # 1.0471975511965976  (= pi/3 = 60°)
print(math.atan(1.0))                # 0.7853981633974483  (= pi/4 = 45°)

# atan2(y, x) handles all quadrants correctly
print(math.atan2(1, -1))             # 2.356…  (135° — second quadrant)
print(math.atan2(-1, -1))            # -2.356… (225° / -135°)

Используйте math.atan2(y, x) вместо math.atan(y/x), когда нужно правильно определить квадрант.

Логарифмические функции

import math

print(math.log(math.e))    # 1.0    — natural log (base e)
print(math.log(100, 10))   # 2.0    — log with explicit base
print(math.log10(1000))    # 3.0    — base-10 log (more accurate than log(x, 10))
print(math.log2(8))        # 3.0    — base-2 log (more accurate than log(x, 2))

Предпочтительнее использовать math.log10 и math.log2 вместо math.log(x, 10) и math.log(x, 2) — специализированные функции обеспечивают лучшую числовую точность.

math.log выбрасывает ValueError для неположительных аргументов:

import math

try:
    math.log(0)
except ValueError as e:
    print(e)   # math domain error

Экспоненциальные функции

import math

print(math.exp(1))    # 2.718281828459045  — e¹
print(math.exp(0))    # 1.0                — e⁰
print(math.exp(2))    # 7.38905609893065   — e²

# For small x, expm1(x) is more accurate than exp(x) - 1
print(math.expm1(1e-10))  # 1.00000000005e-10  (accurate)
print(math.exp(1e-10) - 1)  # 1.000000082740371e-10   (slightly less precise)

math.expm1(x) вычисляет e**x - 1 с повышенной точностью при x, близком к нулю, что важно в финансовых и научных вычислениях.

Инспекция чисел с плавающей точкой

import math

print(math.isfinite(1.0))      # True
print(math.isfinite(math.inf)) # False
print(math.isfinite(math.nan)) # False

print(math.isinf(math.inf))    # True
print(math.isinf(-math.inf))   # True
print(math.isinf(1e308))       # False  — large but finite

print(math.isnan(math.nan))    # True
print(math.isnan(float('nan')))# True
print(math.isnan(0.0))         # False

Сравнение чисел с плавающей точкой через isclose

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

print(0.1 + 0.2 == 0.3)           # False  — floating-point rounding

import math
print(math.isclose(0.1 + 0.2, 0.3))  # True  — within default tolerance

math.isclose(a, b, rel_tol=1e-09, abs_tol=0.0) возвращает True, если |a - b| находится в пределах относительного или абсолютного допуска. Всегда используйте math.isclose вместо == при сравнении вычисленных чисел с плавающей точкой.

Краткий справочник

Функция	Возвращает	Пример
`math.sqrt(x)`	float	`sqrt(9)` → `3.0`
`math.isqrt(x)`	int	`isqrt(10)` → `3`
`math.pow(x, y)`	float	`pow(2, 8)` → `256.0`
`math.floor(x)`	int	`floor(3.9)` → `3`
`math.ceil(x)`	int	`ceil(3.1)` → `4`
`math.trunc(x)`	int	`trunc(-3.9)` → `-3`
`math.fabs(x)`	float	`fabs(-4)` → `4.0`
`math.factorial(n)`	int	`factorial(5)` → `120`
`math.gcd(a, b)`	int	`gcd(12, 8)` → `4`
`math.comb(n, k)`	int	`comb(5, 2)` → `10`
`math.perm(n, k)`	int	`perm(5, 2)` → `20`
`math.log(x)`	float	`log(e)` → `1.0`
`math.log10(x)`	float	`log10(100)` → `2.0`
`math.log2(x)`	float	`log2(8)` → `3.0`
`math.exp(x)`	float	`exp(1)` → `2.718…`
`math.sin(x)`	float	`sin(pi/2)` → `1.0`
`math.cos(x)`	float	`cos(0)` → `1.0`
`math.tan(x)`	float	`tan(pi/4)` → `1.0`
`math.degrees(x)`	float	`degrees(pi)` → `180.0`
`math.radians(x)`	float	`radians(180)` → `3.14…`
`math.hypot(*coords)`	float	`hypot(3, 4)` → `5.0`
`math.isclose(a, b)`	bool	`isclose(0.1+0.2, 0.3)` → `True`
`math.isfinite(x)`	bool	`isfinite(inf)` → `False`
`math.isinf(x)`	bool	`isinf(inf)` → `True`
`math.isnan(x)`	bool	`isnan(nan)` → `True`

Связанные главы

Python Numbers — целые числа, числа с плавающей точкой и комплексные числа
Python Operators — арифметические, сравнительные и логические операторы
Python Variables — хранение и именование значений
Python Modules — как импортировать и использовать модули

Практика

Which math module function returns the largest integer less than or equal to a given number?

math.ceil()math.floor()math.trunc()math.round()