Python Language
Operadores matemáticos simples

Introducción

Observaciones

Adición

a, b = 1, 2

# Using the "+" operator:
a + b                  # = 3

# Using the "in-place" "+=" operator to add and assign:
a += b                 # a = 3 (equivalent to a = a + b)

import operator        # contains 2 argument arithmetic functions for the examples

operator.add(a, b)     # = 5  since a is set to 3 right before this line

# The "+=" operator is equivalent to: 
a = operator.iadd(a, b)    # a = 5 since a is set to 3 right before this line

Posibles combinaciones (tipos incorporados):

• int e int (da un int )
• int y float (da un float )
• int y complex (da un complex ).
• float y float (da un float )
• float y complex (da un complex ).
• complex y complex (da un complex ).

Nota: el operador + también se utiliza para concatenar cadenas, listas y tuplas:

"first string " + "second string"    # = 'first string second string'

[1, 2, 3] + [4, 5, 6]                # = [1, 2, 3, 4, 5, 6]

Sustracción

a, b = 1, 2

# Using the "-" operator:
b - a                  # = 1


import operator        # contains 2 argument arithmetic functions
operator.sub(b, a)     # = 1

Posibles combinaciones (tipos incorporados):

• int e int (da un int )
• int y float (da un float )
• int y complex (da un complex ).
• float y float (da un float )
• float y complex (da un complex ).
• complex y complex (da un complex ).

Multiplicación

a, b = 2, 3

a * b                  # = 6

import operator
operator.mul(a, b)     # = 6

Posibles combinaciones (tipos incorporados):

• int e int (da un int )
• int y float (da un float )
• int y complex (da un complex ).
• float y float (da un float )
• float y complex (da un complex ).
• complex y complex (da un complex ).

Nota: el operador * también se utiliza para la concatenación repetida de cadenas, listas y tuplas:

3 * 'ab'  # = 'ababab'
3 * ('a', 'b')  # = ('a', 'b', 'a', 'b', 'a', 'b')

División

Python hace división de enteros cuando ambos operandos son enteros. El comportamiento de los operadores de división de Python ha cambiado de Python 2.xy 3.x (ver también División de enteros ).

a, b, c, d, e = 3, 2, 2.0, -3, 10

a / b                  # = 1 

a / c                  # = 1.5

d / b                  # = -2

b / a                  # = 0

d / e                  # = -1

import operator        # the operator module provides 2-argument arithmetic functions
operator.div(a, b)     # = 1
operator.__div__(a, b) # = 1

from __future__ import division # applies Python 3 style division to the entire module
a / b                  # = 1.5 
a // b                 # = 1

a / (b * 1.0)          # = 1.5
1.0 * a / b            # = 1.5
a / b * 1.0            # = 1.0    (careful with order of operations)

from operator import truediv
truediv(a, b)          # = 1.5

float(a) / b           # = 1.5
a / float(b)           # = 1.5

a // b                # = 1
a // c                # = 1.0

a / b                  # = 1.5 
e / b                  # = 5.0
a // b                 # = 1
a // c                 # = 1.0

import operator            # the operator module provides 2-argument arithmetic functions
operator.truediv(a, b)     # = 1.5
operator.floordiv(a, b)    # = 1
operator.floordiv(a, c)    # = 1.0

Posibles combinaciones (tipos incorporados):

• int e int (da un int en Python 2 y un float en Python 3)
• int y float (da un float )
• int y complex (da un complex ).
• float y float (da un float )
• float y complex (da un complex ).
• complex y complex (da un complex ).

Ver PEP 238 para más información.

Exponer

a, b = 2, 3

(a ** b)               # = 8
pow(a, b)              # = 8

import math
math.pow(a, b)         # = 8.0 (always float; does not allow complex results)

import operator
operator.pow(a, b)     # = 8

Otra diferencia entre el pow math.pow y math.pow es que el pow incorporado puede aceptar tres argumentos:

a, b, c = 2, 3, 2

pow(2, 3, 2)           # 0, calculates (2 ** 3) % 2, but as per Python docs,
                       #    does so more efficiently

Funciones especiales

La función math.sqrt(x) calcula la raíz cuadrada de x .

import math
import cmath
c = 4
math.sqrt(c)           # = 2.0 (always float; does not allow complex results)
cmath.sqrt(c)          # = (2+0j) (always complex)

Para calcular otras raíces, como una raíz cúbica, aumente el número al recíproco del grado de la raíz. Esto se podría hacer con cualquiera de las funciones exponenciales u operador.

 import math
 x = 8
 math.pow(x, 1/3) # evaluates to 2.0
 x**(1/3) # evaluates to 2.0

La función math.exp(x) calcula e ** x .

math.exp(0)  # 1.0
math.exp(1)  # 2.718281828459045 (e)

La función math.expm1(x) calcula e ** x - 1 . Cuando x es pequeño, esto proporciona una precisión significativamente mejor que math.exp(x) - 1 .

math.expm1(0)       # 0.0

math.exp(1e-6) - 1  # 1.0000004999621837e-06
math.expm1(1e-6)    # 1.0000005000001665e-06
# exact result      # 1.000000500000166666708333341666...

Logaritmos

De forma predeterminada, la función math.log calcula el logaritmo de un número, base e. Opcionalmente puede especificar una base como segundo argumento.

import math
import cmath

math.log(5)         # = 1.6094379124341003
# optional base argument. Default is math.e
math.log(5, math.e) # = 1.6094379124341003
cmath.log(5)        # = (1.6094379124341003+0j)
math.log(1000, 10)   # 3.0 (always returns float)
cmath.log(1000, 10)  # (3+0j)

Existen variaciones especiales de la función math.log para diferentes bases.

# Logarithm base e - 1 (higher precision for low values)
math.log1p(5)       # = 1.791759469228055

# Logarithm base 2
math.log2(8)        # = 3.0

# Logarithm base 10
math.log10(100)     # = 2.0
cmath.log10(100)    # = (2+0j)

Operaciones in situ

Es común que dentro de las aplicaciones se necesite tener un código como este:

a = a + 1

o

a = a * 2

Existe un atajo efectivo para estas operaciones in situ:

a += 1
# and
a *= 2

Se puede usar cualquier operador matemático antes del carácter '=' para realizar una operación in situ:

• -= disminuir la variable en su lugar
• += incrementar la variable en su lugar
• *= multiplica la variable en su lugar
• /= dividir la variable en su lugar
• //= piso divide la variable en su lugar # Python 3
• %= devolver el módulo de la variable en su lugar
• **= elevar a una potencia en su lugar

Existen otros operadores in situ para los operadores bitwise ( ^ , | etc)

Funciones trigonométricas

a, b = 1, 2

import math

math.sin(a)  # returns the sine of 'a' in radians
# Out: 0.8414709848078965

math.cosh(b)  # returns the inverse hyperbolic cosine of 'b' in radians
# Out: 3.7621956910836314

math.atan(math.pi)  # returns the arc tangent of 'pi' in radians
# Out: 1.2626272556789115

math.hypot(a, b) # returns the Euclidean norm, same as math.sqrt(a*a + b*b)
# Out: 2.23606797749979

Tenga en cuenta que math.hypot(x, y) también es la longitud del vector (o distancia euclidiana) desde el origen (0, 0) hasta el punto (x, y) .

Para calcular la distancia euclidiana entre dos puntos (x1, y1) y (x2, y2) puede usar math.hypot siguiente manera

math.hypot(x2-x1, y2-y1)

Para convertir de radianes -> grados y grados -> radianes respectivamente use math.degrees y math.radians

math.degrees(a)
# Out: 57.29577951308232

math.radians(57.29577951308232)
# Out: 1.0

Módulo

Como en muchos otros idiomas, Python usa el operador % para calcular el módulo.

3 % 4     # 3
10 % 2    # 0
6 % 4     # 2

O utilizando el módulo operator :

import operator

operator.mod(3 , 4)     # 3
operator.mod(10 , 2)    # 0
operator.mod(6 , 4)     # 2

También puedes usar números negativos.

-9 % 7     # 5
9 % -7     # -5
-9 % -7    # -2

Si necesita encontrar el resultado de la división y el módulo de enteros, puede usar la función divmod como acceso directo:

quotient, remainder = divmod(9, 4)
# quotient = 2, remainder = 1 as 4 * 2 + 1 == 9