Python Language
Módulo de matemáticas
Buscar..
Redondeo: redondo, suelo, ceil, trunc
Además de la función round incorporada, el módulo math proporciona las funciones floor , ceil y 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 , el ceil , el trunc y el round siempre devuelven un float .
round(1.3) # 1.0
round siempre rompe empates lejos de cero.
round(0.5) # 1.0
round(1.5) # 2.0
floor , ceil y trunc siempre devuelven un valor Integral , mientras que round devuelve un valor Integral si se llama con un argumento.
round(1.3) # 1
round(1.33, 1) # 1.3
Rupturas round empates hacia el número par más cercano. Esto corrige el sesgo hacia números más grandes cuando se realizan una gran cantidad de cálculos.
round(0.5) # 0
round(1.5) # 2
¡Advertencia!
Al igual que con cualquier representación de punto flotante, algunas fracciones no se pueden representar exactamente . Esto puede llevar a algún comportamiento de redondeo inesperado.
round(2.675, 2) # 2.67, not 2.68!
Advertencia sobre la división de números negativos en el piso, corte y número entero
Python (y C ++ y Java) se alejan de cero para los números negativos. Considerar:
>>> math.floor(-1.7)
-2.0
>>> -5 // 2
-3
Logaritmos
math.log(x) da el logaritmo natural (base e ) de x .
math.log(math.e) # 1.0
math.log(1) # 0.0
math.log(100) # 4.605170185988092
math.log puede perder precisión con números cercanos a 1, debido a las limitaciones de los números de punto flotante. Para calcular con precisión los registros cercanos a 1, use math.log1p , que evalúa el logaritmo natural de 1 más el argumento:
math.log(1 + 1e-20) # 0.0
math.log1p(1e-20) # 1e-20
math.log10 puede usarse para logs base 10:
math.log10(10) # 1.0
Cuando se usa con dos argumentos, math.log(x, base) da el logaritmo de x en la base dada (es decir, log(x) / log(base) .
math.log(100, 10) # 2.0
math.log(27, 3) # 3.0
math.log(1, 10) # 0.0
Copiando carteles
En Python 2.6 y superior, math.copysign(x, y) devuelve x con el signo de y . El valor devuelto es siempre 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
Trigonometría
Cálculo de la longitud de la hipotenusa.
math.hypot(2, 4) # Just a shorthand for SquareRoot(2**2 + 4**2)
# Out: 4.47213595499958
Convertir grados a / desde radianes
Todas las funciones math esperan radianes, por lo que necesitas convertir grados a radianes:
math.radians(45) # Convert 45 degrees to radians
# Out: 0.7853981633974483
Todos los resultados de las funciones trigonométricas inversas devuelven el resultado en radianes, por lo que es posible que deba volver a convertirlo en grados:
math.degrees(math.asin(1)) # Convert the result of asin to degrees
# Out: 90.0
Funciones seno, coseno, tangente e inversa.
# 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"
Aparte de math.atan también hay una función math.atan2 dos argumentos, que calcula el cuadrante correcto y evita los escollos de la división por cero:
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 hiperbólico, coseno y 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
Constantes
math módulos math incluyen dos constantes matemáticas de uso común.
-
math.pi- La constante matemática pi -
math.e- La constante matemática e (base del logaritmo natural)
>>> from math import pi, e
>>> pi
3.141592653589793
>>> e
2.718281828459045
>>>
Python 3.5 y superior tienen constantes para infinito y NaN ("no es un número"). La sintaxis anterior de pasar una cadena a float() aún funciona.
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
Números imaginarios
Los números imaginarios en Python están representados por una "j" o "J" detrás del número objetivo.
1j # Equivalent to the square root of -1.
1j * 1j # = (-1+0j)
Infinito y NaN ("no es un número")
En todas las versiones de Python, podemos representar infinito y NaN ("no un número") de la siguiente manera:
pos_inf = float('inf') # positive infinity
neg_inf = float('-inf') # negative infinity
not_a_num = float('nan') # NaN ("not a number")
En Python 3.5 y superior, también podemos usar las constantes definidas math.inf y math.nan :
pos_inf = math.inf
neg_inf = -math.inf
not_a_num = math.nan
Las representaciones de cadena se muestran como inf y -inf y nan :
pos_inf, neg_inf, not_a_num
# Out: (inf, -inf, nan)
Podemos probar el infinito positivo o negativo con el método isinf :
math.isinf(pos_inf)
# Out: True
math.isinf(neg_inf)
# Out: True
Podemos probar específicamente el infinito positivo o el infinito negativo por comparación directa:
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 y superior también permite verificar la finitud:
math.isfinite(pos_inf)
# Out: False
math.isfinite(0.0)
# Out: True
Los operadores de comparación funcionan como se espera para el infinito positivo y 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
Pero si una expresión aritmética produce un valor más grande que el máximo que se puede representar como un float , se convertirá en infinito:
pos_inf == sys.float_info.max * 1.0000001
# Out: True
neg_inf == -sys.float_info.max * 1.0000001
# Out: True
Sin embargo, la división por cero no da un resultado de infinito (o infinito negativo cuando sea apropiado), sino que genera una excepción ZeroDivisionError .
try:
x = 1.0 / 0.0
print(x)
except ZeroDivisionError:
print("Division by zero")
# Out: Division by zero
Las operaciones aritméticas en el infinito solo dan resultados infinitos, o algunas veces 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 nunca es igual a nada, ni siquiera a sí mismo. Podemos probar que es con el método isnan :
not_a_num == not_a_num
# Out: False
math.isnan(not_a_num)
Out: True
NaN siempre se compara como "no igual", pero nunca menor o mayor que:
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
Las operaciones aritméticas en NaN siempre dan NaN. Esto incluye la multiplicación por -1: no hay "NaN negativo".
5.0 * not_a_num
# Out: nan
float('-nan')
# Out: nan
-math.nan
# Out: nan
Hay una diferencia sutil entre las versiones float antiguas de NaN e infinito y las constantes de la biblioteca 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 para una exponenciación más rápida
Usando el módulo timeit desde la línea de 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
El operador ** integrado a menudo es útil, pero si el rendimiento es esencial, use math.pow. Sin embargo, asegúrese de tener en cuenta que pow devuelve flotantes, incluso si los argumentos son enteros:
> from math import pow
> pow(5,5)
3125.0
Números complejos y el módulo cmath.
El módulo cmath es similar al módulo math , pero define funciones adecuadamente para el plano complejo.
En primer lugar, los números complejos son un tipo numérico que forma parte del lenguaje Python en lugar de ser proporcionado por una clase de biblioteca. Por lo tanto, no necesitamos import cmath para expresiones aritméticas ordinarias.
Tenga en cuenta que usamos j (o J ) y no i .
z = 1 + 3j
Debemos usar 1j ya que j sería el nombre de una variable en lugar de un literal numérico.
1j * 1j
Out: (-1+0j)
1j ** 1j
# Out: (0.20787957635076193+0j) # "i to the i" == math.e ** -(math.pi/2)
Tenemos la parte real y la parte imag (imaginaria), así como el complejo 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
Las funciones integradas abs y complex también son parte del lenguaje en sí y no requieren ninguna importación:
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 función complex puede tomar una cadena, pero no puede tener espacios:
complex('1+1j')
# Out: (1+1j)
complex('1 + 1j')
# Exception: ValueError: complex() arg is a malformed string
Pero para la mayoría de las funciones necesitamos el módulo, por ejemplo, sqrt :
import cmath
cmath.sqrt(-1)
# Out: 1j
Naturalmente, el comportamiento de sqrt es diferente para números complejos y números reales. En math no complejas math la raíz cuadrada de un número negativo genera una excepción:
import math
math.sqrt(-1)
# Exception: ValueError: math domain error
Se proporcionan funciones para convertir hacia y desde coordenadas polares:
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)
El campo matemático del análisis complejo está más allá del alcance de este ejemplo, pero muchas funciones en el plano complejo tienen un "corte de rama", generalmente a lo largo del eje real o el eje imaginario. La mayoría de las plataformas modernas admiten el "cero firmado" como se especifica en IEEE 754, que proporciona continuidad de esas funciones en ambos lados del corte de rama. El siguiente ejemplo es de la documentación de Python:
cmath.phase(complex(-1.0, 0.0))
# Out: 3.141592653589793
cmath.phase(complex(-1.0, -0.0))
# Out: -3.141592653589793
El módulo cmath también proporciona muchas funciones con contrapartes directas del módulo math .
Además de sqrt , existen versiones complejas de exp , log , log10 , las funciones trigonométricas y sus inverses ( sin , cos , tan , asin , acos , atan ), y las funciones hiperbólicas y sus inverses ( sinh , cosh , tanh , asinh , acosh , atanh ). Sin embargo, tenga en cuenta que no hay una contraparte compleja de math.atan2 , la forma de arctangente de dos argumentos.
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
Se proporcionan las constantes pi y e . Tenga en cuenta que estos son float y no complex .
type(cmath.pi)
# Out: <class 'float'>
El módulo cmath también proporciona versiones complejas de isinf , y (para Python 3.2+) es isfinite . Ver " Infinito y NaN ". Un número complejo se considera infinito si su parte real o su parte imaginaria es infinita.
cmath.isinf(complex(float('inf'), 0.0))
# Out: True
Asimismo, el módulo cmath proporciona una versión compleja de isnan . Ver " Infinito y NaN ". Un número complejo se considera "no un número" si su parte real o su parte imaginaria no es "un número".
cmath.isnan(0.0, float('nan'))
# Out: True
Tenga en cuenta que no hay cmath contraparte de math.nan constantes math.inf y math.nan (de Python 3.5 y superior)
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'
En Python 3.5 y superior, hay una isclose método en ambos cmath y math módulos.
z = cmath.rect(*cmath.polar(1+1j))
z
# Out: (1.0000000000000002+1.0000000000000002j)
cmath.isclose(z, 1+1j)
# True
