Módulo Math do Python — Funções, Constantes e Exemplos

Python inclui um módulo math integrado que fornece acesso às funções matemáticas da biblioteca padrão C. Este capítulo aborda:

Operadores aritméticos básicos que o Python oferece nativamente
Todas as constantes principais (pi, e, tau, inf, nan)
Auxiliares de arredondamento, valor absoluto, potência e raiz quadrada
Funções trigonométricas e conversão entre graus e radianos
Funções logarítmicas e exponenciais
Auxiliares de teoria dos números: gcd, factorial, isqrt, comb, perm
Inspeção de ponto flutuante: isfinite, isinf, isnan, isclose

Nenhuma instalação é necessária — import math é tudo o que você precisa.

Operadores aritméticos básicos

O Python lida com a aritmética do dia a dia com operadores integrados — sem necessidade de módulo.

# 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

O operador ** é a forma idiomática em Python para elevar um número a uma potência. Use-o em vez de math.pow() para entradas inteiras — ele permanece como inteiro, enquanto math.pow() sempre retorna um float.

Importando o módulo math

Para qualquer coisa além dos operadores acima, importe math:

import math

Você também pode importar nomes específicos para evitar o prefixo math.:

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

Prefira import math em código de produção — isso torna óbvia a origem de cada função.

Constantes matemáticas

O módulo math define várias constantes:

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 é útil como valor inicial quando você precisa de um sentinela do tipo "maior valor possível":

import math

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

Arredondamento e valor absoluto

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

A diferença entre trunc e floor é relevante para números negativos:

import math

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

Raiz quadrada, potência e hipotenusa

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() (adicionado no Python 3.8) é a escolha certa quando você precisa de um resultado inteiro sem converter de float, por exemplo ao verificar quadrados perfeitos:

import math

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

math.hypot() aceita mais de dois argumentos desde o Python 3.8 e calcula a norma euclidiana em qualquer número de dimensões:

import math

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

Fatorial e auxiliares inteiros

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 lança um ValueError para entradas negativas e um TypeError para não inteiros.

Combinatória

O Python 3.8 adicionou math.comb e math.perm para substituir fórmulas manuais com fatoriais:

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) é equivalente a n! / (k! * (n-k)!), mas é mais rápido e evita valores intermediários grandes.

Funções trigonométricas

O módulo math trabalha em radianos. Use math.radians() para converter graus primeiro.

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

Valores de ângulos comuns em radianos:

Graus	Expressão em radianos	Valor em `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…`

As funções trigonométricas inversas retornam radianos:

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°)

Use math.atan2(y, x) em vez de math.atan(y/x) sempre que precisar do quadrante correto.

Funções logarítmicas

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))

Prefira math.log10 e math.log2 em vez de math.log(x, 10) e math.log(x, 2) — as funções dedicadas têm melhor precisão numérica.

math.log lança um ValueError para entradas não positivas:

import math

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

Funções exponenciais

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) calcula e**x - 1 com maior precisão quando x está próximo de zero, o que importa em cálculos financeiros e científicos.

Inspeção de ponto flutuante

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

Comparando floats com isclose

Devido à representação de ponto flutuante, verificações de igualdade direta podem falhar:

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) retorna True quando |a - b| está dentro da tolerância relativa ou absoluta. Sempre use math.isclose em vez de == ao comparar floats calculados.

Referência rápida

Função	Retorna	Exemplo
`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`

Capítulos relacionados

Python Numbers — tipos inteiro, float e complexo
Python Operators — operadores aritméticos, de comparação e lógicos
Python Variables — armazenando e nomeando valores
Python Modules — como importar e usar módulos

Prática

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

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