Modulo Math di Python — Funzioni, Costanti ed Esempi

Python include un modulo math integrato che fornisce accesso alle funzioni matematiche della libreria standard C. Questo capitolo tratta:

Operatori aritmetici di base forniti nativamente da Python
Tutte le costanti principali (pi, e, tau, inf, nan)
Funzioni di ausilio per arrotondamento, valore assoluto, potenza e radice quadrata
Funzioni trigonometriche e conversione gradi/radianti
Funzioni logaritmiche ed esponenziali
Funzioni per la teoria dei numeri: gcd, factorial, isqrt, comb, perm
Ispezione dei numeri in virgola mobile: isfinite, isinf, isnan, isclose

Non è necessaria alcuna installazione — basta import math.

Operatori aritmetici di base

Python gestisce l'aritmetica quotidiana con operatori integrati — nessun modulo richiesto.

# 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

L'operatore ** è il modo idiomatico in Python per elevare un numero a una potenza. Usalo al posto di math.pow() per input interi — rimane un intero, mentre math.pow() restituisce sempre un float.

Importare il modulo math

Per qualsiasi operazione che va oltre gli operatori sopra descritti, importa math:

import math

Puoi anche importare nomi specifici per evitare il prefisso math.:

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

Preferisci import math nel codice di produzione — rende evidente la provenienza di ogni funzione.

Costanti matematiche

Il modulo math definisce diverse costanti:

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 è utile come valore iniziale quando hai bisogno di un segnaposto per il "valore più grande possibile":

import math

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

Arrotondamento e valore assoluto

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

La differenza tra trunc e floor è rilevante per i numeri negativi:

import math

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

Radice quadrata, potenza e ipotenusa

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() (aggiunto in Python 3.8) è la scelta giusta quando hai bisogno di un risultato intero senza convertire da float, ad esempio per verificare quadrati perfetti:

import math

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

math.hypot() accetta più di due argomenti a partire da Python 3.8 e calcola la norma euclidea in qualsiasi numero di dimensioni:

import math

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

Fattoriale e funzioni su interi

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 genera un ValueError per input negativi e un TypeError per valori non interi.

Combinatoria

Python 3.8 ha aggiunto math.comb e math.perm per sostituire le formule manuali con il fattoriale:

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)!) ma è più veloce ed evita valori intermedi di grandi dimensioni.

Funzioni trigonometriche

Il modulo math lavora in radianti. Usa math.radians() per convertire prima i gradi.

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

Valori angolari comuni in radianti:

Gradi	Espressione in radianti	Valore `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…`

Le funzioni trigonometriche inverse restituiscono radianti:

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

Usa math.atan2(y, x) al posto di math.atan(y/x) ogni volta che hai bisogno del quadrante corretto.

Funzioni logaritmiche

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

Preferisci math.log10 e math.log2 rispetto a math.log(x, 10) e math.log(x, 2) — le funzioni dedicate offrono una migliore precisione numerica.

math.log genera un ValueError per input non positivi:

import math

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

Funzioni esponenziali

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) calcola e**x - 1 con maggiore precisione quando x è vicino a zero, il che è importante nei calcoli finanziari e scientifici.

Ispezione dei numeri in virgola mobile

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

Confronto di float con isclose

A causa della rappresentazione in virgola mobile, i confronti di uguaglianza diretta possono fallire:

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) restituisce True quando |a - b| rientra nella tolleranza relativa o assoluta. Usa sempre math.isclose invece di == quando confronti float calcolati.

Riferimento rapido

Funzione	Restituisce	Esempio
`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`

Capitoli correlati

Python Numbers — tipi interi, float e complessi
Python Operators — operatori aritmetici, di confronto e logici
Python Variables — memorizzare e denominare i valori
Python Modules — come importare e utilizzare i moduli

Esercitazione

Pratica

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

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