Python Language
Modulo matematico
Ricerca…
Arrotondamento: rotondo, pavimento, ceil, trunc
Oltre alla funzione round incorporata, il modulo math fornisce le funzioni floor , ceil e trunc .
x = 1.55
y = -1.55
# round to the nearest integer
round(x) # 2
round(y) # -2
# the second argument gives how many decimal places to round to (defaults to 0)
round(x, 1) # 1.6
round(y, 1) # -1.6
# math is a module so import it first, then use it.
import math
# get the largest integer less than x
math.floor(x) # 1
math.floor(y) # -2
# get the smallest integer greater than x
math.ceil(x) # 2
math.ceil(y) # -1
# drop fractional part of x
math.trunc(x) # 1, equivalent to math.floor for positive numbers
math.trunc(y) # -1, equivalent to math.ceil for negative numbers
floor , ceil , trunc e round restituiscono sempre un float .
round(1.3) # 1.0
round rompe sempre i legami dallo zero.
round(0.5) # 1.0
round(1.5) # 2.0
floor , ceil e trunc restituiscono sempre un valore Integral , mentre round restituisce un valore Integral se chiamato con un argomento.
round(1.3) # 1
round(1.33, 1) # 1.3
round rompe i legami verso il numero pari più vicino. Questo corregge la tendenza verso numeri più grandi quando si esegue un numero elevato di calcoli.
round(0.5) # 0
round(1.5) # 2
Avvertimento!
Come con qualsiasi rappresentazione a virgola mobile, alcune frazioni non possono essere rappresentate esattamente . Ciò può comportare un comportamento di arrotondamento imprevisto.
round(2.675, 2) # 2.67, not 2.68!
Avviso sul piano, trunc e divisione intera dei numeri negativi
Python (e C ++ e Java) arrotondati da zero per i numeri negativi. Tenere conto:
>>> math.floor(-1.7)
-2.0
>>> -5 // 2
-3
logaritmi
math.log(x) fornisce il logaritmo naturale (base e ) di x .
math.log(math.e) # 1.0
math.log(1) # 0.0
math.log(100) # 4.605170185988092
math.log può perdere precisione con numeri vicini a 1, a causa delle limitazioni dei numeri in virgola mobile. Per calcolare con precisione i registri vicini a 1, utilizzare math.log1p , che valuta il logaritmo naturale di 1 più l'argomento:
math.log(1 + 1e-20) # 0.0
math.log1p(1e-20) # 1e-20
math.log10 può essere utilizzato per i registri di base 10:
math.log10(10) # 1.0
Quando viene utilizzato con due argomenti, math.log(x, base) fornisce il logaritmo di x nella base fornita (ad esempio, log(x) / log(base) .
math.log(100, 10) # 2.0
math.log(27, 3) # 3.0
math.log(1, 10) # 0.0
Copia di segni
In Python 2.6 e versioni successive, math.copysign(x, y) restituisce x con il segno di y . Il valore restituito è sempre un float .
math.copysign(-2, 3) # 2.0
math.copysign(3, -3) # -3.0
math.copysign(4, 14.2) # 4.0
math.copysign(1, -0.0) # -1.0, on a platform which supports signed zero
Trigonometria
Calcolo della lunghezza dell'ipotenusa
math.hypot(2, 4) # Just a shorthand for SquareRoot(2**2 + 4**2)
# Out: 4.47213595499958
Conversione dei gradi in / da radianti
Tutte le funzioni math prevedono i radianti quindi è necessario convertire i gradi in radianti:
math.radians(45) # Convert 45 degrees to radians
# Out: 0.7853981633974483
Tutti i risultati delle funzioni trigonometriche inverse restituiscono il risultato in radianti, quindi potrebbe essere necessario convertirlo in gradi:
math.degrees(math.asin(1)) # Convert the result of asin to degrees
# Out: 90.0
Funzioni seno, coseno, tangente e inverso
# Sine and arc sine
math.sin(math.pi / 2)
# Out: 1.0
math.sin(math.radians(90)) # Sine of 90 degrees
# Out: 1.0
math.asin(1)
# Out: 1.5707963267948966 # "= pi / 2"
math.asin(1) / math.pi
# Out: 0.5
# Cosine and arc cosine:
math.cos(math.pi / 2)
# Out: 6.123233995736766e-17
# Almost zero but not exactly because "pi" is a float with limited precision!
math.acos(1)
# Out: 0.0
# Tangent and arc tangent:
math.tan(math.pi/2)
# Out: 1.633123935319537e+16
# Very large but not exactly "Inf" because "pi" is a float with limited precision
math.atan(math.inf)
# Out: 1.5707963267948966 # This is just "pi / 2"
math.atan(float('inf'))
# Out: 1.5707963267948966 # This is just "pi / 2"
Oltre a math.atan esiste anche una funzione math.atan2 due argomenti, che calcola il quadrante corretto ed evita le insidie della divisione per zero:
math.atan2(1, 2) # Equivalent to "math.atan(1/2)"
# Out: 0.4636476090008061 # ≈ 26.57 degrees, 1st quadrant
math.atan2(-1, -2) # Not equal to "math.atan(-1/-2)" == "math.atan(1/2)"
# Out: -2.677945044588987 # ≈ -153.43 degrees (or 206.57 degrees), 3rd quadrant
math.atan2(1, 0) # math.atan(1/0) would raise ZeroDivisionError
# Out: 1.5707963267948966 # This is just "pi / 2"
Seno iperbolico, coseno e tangente
# Hyperbolic sine function
math.sinh(math.pi) # = 11.548739357257746
math.asinh(1) # = 0.8813735870195429
# Hyperbolic cosine function
math.cosh(math.pi) # = 11.591953275521519
math.acosh(1) # = 0.0
# Hyperbolic tangent function
math.tanh(math.pi) # = 0.99627207622075
math.atanh(0.5) # = 0.5493061443340549
costanti
math moduli math includono due costanti matematiche comunemente usate.
-
math.pi- La costante matematica pi -
math.e- La costante matematica e (base del logaritmo naturale)
>>> from math import pi, e
>>> pi
3.141592653589793
>>> e
2.718281828459045
>>>
Python 3.5 e successive hanno costanti per infinito e NaN ("non un numero"). La più vecchia sintassi del passaggio di una stringa a float() funziona ancora.
math.inf == float('inf')
# Out: True
-math.inf == float('-inf')
# Out: True
# NaN never compares equal to anything, even itself
math.nan == float('nan')
# Out: False
Numeri immaginari
I numeri immaginari in Python sono rappresentati da una "j" o "J" che trascina il numero di destinazione.
1j # Equivalent to the square root of -1.
1j * 1j # = (-1+0j)
Infinity e NaN ("non un numero")
In tutte le versioni di Python, possiamo rappresentare infinito e NaN ("non un numero") come segue:
pos_inf = float('inf') # positive infinity
neg_inf = float('-inf') # negative infinity
not_a_num = float('nan') # NaN ("not a number")
In Python 3.5 e versioni successive, possiamo anche usare le costanti definite math.inf e math.nan :
pos_inf = math.inf
neg_inf = -math.inf
not_a_num = math.nan
Le rappresentazioni di stringa vengono visualizzate come inf e -inf e nan :
pos_inf, neg_inf, not_a_num
# Out: (inf, -inf, nan)
Possiamo testare l'infinito positivo o negativo con il metodo isinf :
math.isinf(pos_inf)
# Out: True
math.isinf(neg_inf)
# Out: True
Possiamo testare specificamente per infinito positivo o infinito negativo per confronto diretto:
pos_inf == float('inf') # or == math.inf in Python 3.5+
# Out: True
neg_inf == float('-inf') # or == -math.inf in Python 3.5+
# Out: True
neg_inf == pos_inf
# Out: False
Python 3.2 e versioni successive consentono anche di controllare la finezza:
math.isfinite(pos_inf)
# Out: False
math.isfinite(0.0)
# Out: True
Gli operatori di confronto funzionano come previsto per l'infinito positivo e negativo:
import sys
sys.float_info.max
# Out: 1.7976931348623157e+308 (this is system-dependent)
pos_inf > sys.float_info.max
# Out: True
neg_inf < -sys.float_info.max
# Out: True
Ma se un'espressione aritmetica produce un valore maggiore del massimo che può essere rappresentato come un float , diventerà infinito:
pos_inf == sys.float_info.max * 1.0000001
# Out: True
neg_inf == -sys.float_info.max * 1.0000001
# Out: True
Comunque la divisione per zero non dà un risultato di infinito (o infinito negativo se appropriato), piuttosto solleva un'eccezione ZeroDivisionError .
try:
x = 1.0 / 0.0
print(x)
except ZeroDivisionError:
print("Division by zero")
# Out: Division by zero
Le operazioni aritmetiche sull'infinito danno solo risultati infiniti o talvolta NaN:
-5.0 * pos_inf == neg_inf
# Out: True
-5.0 * neg_inf == pos_inf
# Out: True
pos_inf * neg_inf == neg_inf
# Out: True
0.0 * pos_inf
# Out: nan
0.0 * neg_inf
# Out: nan
pos_inf / pos_inf
# Out: nan
NaN non è mai uguale a niente, nemmeno a se stesso. Possiamo testare perché è con il metodo isnan :
not_a_num == not_a_num
# Out: False
math.isnan(not_a_num)
Out: True
NaN si confronta sempre come "non uguale", ma mai inferiore o superiore a:
not_a_num != 5.0 # or any random value
# Out: True
not_a_num > 5.0 or not_a_num < 5.0 or not_a_num == 5.0
# Out: False
Le operazioni aritmetiche su NaN danno sempre NaN. Ciò include la moltiplicazione per -1: non c'è "NaN negativo".
5.0 * not_a_num
# Out: nan
float('-nan')
# Out: nan
-math.nan
# Out: nan
C'è una sottile differenza tra le vecchie versioni float di NaN e infinity e le costanti della libreria math Python 3.5+:
math.inf is math.inf, math.nan is math.nan
# Out: (True, True)
float('inf') is float('inf'), float('nan') is float('nan')
# Out: (False, False)
Pow per un'esponenziazione più rapida
Utilizzando il modulo timeit dalla riga di comando:
> python -m timeit 'for x in xrange(50000): b = x**3'
10 loops, best of 3: 51.2 msec per loop
> python -m timeit 'from math import pow' 'for x in xrange(50000): b = pow(x,3)'
100 loops, best of 3: 9.15 msec per loop
L'operatore integrato ** spesso è utile, ma se le prestazioni sono essenziali, usa math.pow. Assicurati di notare, tuttavia, che pow restituisce float, anche se gli argomenti sono interi:
> from math import pow
> pow(5,5)
3125.0
Numeri complessi e il modulo cmath
Il modulo cmath è simile al modulo math , ma definisce le funzioni in modo appropriato per il piano complesso.
Prima di tutto, i numeri complessi sono un tipo numerico che fa parte del linguaggio Python stesso anziché essere fornito da una classe di libreria. Pertanto non è necessario import cmath per le normali espressioni aritmetiche.
Nota che usiamo j (o J ) e non i .
z = 1 + 3j
Dobbiamo usare 1j poiché j sarebbe il nome di una variabile piuttosto che un valore letterale numerico.
1j * 1j
Out: (-1+0j)
1j ** 1j
# Out: (0.20787957635076193+0j) # "i to the i" == math.e ** -(math.pi/2)
Abbiamo la parte real e la parte imag (immaginaria), così come il complesso conjugate :
# real part and imaginary part are both float type
z.real, z.imag
# Out: (1.0, 3.0)
z.conjugate()
# Out: (1-3j) # z.conjugate() == z.real - z.imag * 1j
Le funzioni integrate abs e complex sono anche parte del linguaggio stesso e non richiedono alcuna importazione:
abs(1 + 1j)
# Out: 1.4142135623730951 # square root of 2
complex(1)
# Out: (1+0j)
complex(imag=1)
# Out: (1j)
complex(1, 1)
# Out: (1+1j)
La funzione complex può prendere una stringa, ma non può avere spazi:
complex('1+1j')
# Out: (1+1j)
complex('1 + 1j')
# Exception: ValueError: complex() arg is a malformed string
Ma per la maggior parte delle funzioni abbiamo bisogno del modulo, ad esempio sqrt :
import cmath
cmath.sqrt(-1)
# Out: 1j
Naturalmente il comportamento di sqrt è diverso per numeri complessi e numeri reali. Nella math non complessa la radice quadrata di un numero negativo solleva un'eccezione:
import math
math.sqrt(-1)
# Exception: ValueError: math domain error
Le funzioni sono fornite per convertire da e verso le coordinate polari:
cmath.polar(1 + 1j)
# Out: (1.4142135623730951, 0.7853981633974483) # == (sqrt(1 + 1), atan2(1, 1))
abs(1 + 1j), cmath.phase(1 + 1j)
# Out: (1.4142135623730951, 0.7853981633974483) # same as previous calculation
cmath.rect(math.sqrt(2), math.atan(1))
# Out: (1.0000000000000002+1.0000000000000002j)
Il campo matematico dell'analisi complessa va oltre lo scopo di questo esempio, ma molte funzioni nel piano complesso hanno un "taglio di ramo", solitamente lungo l'asse reale o l'asse immaginario. La maggior parte delle piattaforme moderne supporta lo "zero firmato" come specificato in IEEE 754, che fornisce la continuità di tali funzioni su entrambi i lati del taglio del ramo. Il seguente esempio è tratto dalla documentazione di Python:
cmath.phase(complex(-1.0, 0.0))
# Out: 3.141592653589793
cmath.phase(complex(-1.0, -0.0))
# Out: -3.141592653589793
Il modulo cmath fornisce anche molte funzioni con controparti dirette dal modulo math .
Oltre a sqrt , esistono versioni complesse di exp , log , log10 , le funzioni trigonometriche e le loro inverse ( sin , cos , tan , asin , acos , atan ) e le funzioni iperboliche e le loro inverse ( sinh , cosh , tanh , asinh , acosh , atanh ). Si noti tuttavia che non esiste una controparte complessa di math.atan2 , la forma a due argomenti di arcotangente.
cmath.log(1+1j)
# Out: (0.34657359027997264+0.7853981633974483j)
cmath.exp(1j * cmath.pi)
# Out: (-1+1.2246467991473532e-16j) # e to the i pi == -1, within rounding error
Le costanti pi ed e sono fornite. Nota che questi sono float e non complex .
type(cmath.pi)
# Out: <class 'float'>
Il modulo cmath fornisce anche versioni complesse di isinf , e (per Python 3.2+) isfinite . Vedi " Infinito e NaN ". Un numero complesso è considerato infinito se la sua parte reale o la sua parte immaginaria è infinita.
cmath.isinf(complex(float('inf'), 0.0))
# Out: True
Allo stesso modo, il modulo cmath fornisce una versione complessa di isnan . Vedi " Infinito e NaN ". Un numero complesso è considerato "non un numero" se la sua parte reale o la sua parte immaginaria è "non un numero".
cmath.isnan(0.0, float('nan'))
# Out: True
Nota: non esiste una controparte di cmath delle costanti math.inf e math.nan (da Python 3.5 e versioni successive)
cmath.isinf(complex(0.0, math.inf))
# Out: True
cmath.isnan(complex(math.nan, 0.0))
# Out: True
cmath.inf
# Exception: AttributeError: module 'cmath' has no attribute 'inf'
In Python 3.5 e superiore, v'è un isclose metodo sia cmath e math moduli.
z = cmath.rect(*cmath.polar(1+1j))
z
# Out: (1.0000000000000002+1.0000000000000002j)
cmath.isclose(z, 1+1j)
# True