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
Python 2.x 2.7

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
Python 3.x 3.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
Python 2.x 2.3.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 .

Python 2.x 2.6
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
Python 3.x 3.5
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.

Python 3.x 3.5
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 :

Python 3.x 3.5
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:

Python 3.x 3.2
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
Python 3.x 3.5
-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+:

Python 3.x 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)

Python 3.x 3.5
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.

Python 3.x 3.5
z = cmath.rect(*cmath.polar(1+1j))

z
# Out: (1.0000000000000002+1.0000000000000002j)

cmath.isclose(z, 1+1j)
# True


Modified text is an extract of the original Stack Overflow Documentation
Licenciado bajo CC BY-SA 3.0
No afiliado a Stack Overflow