2.3. Operaciones matemáticas

Python funciona como una calculadora desde el primer momento. Esta página cubre los operadores que usarás con más frecuencia: aritmética con números, comparaciones que producen valores booleanos, operadores lógicos que combinan condiciones y operadores a nivel de bits para el trabajo a nivel de hardware.

2.3.1. Aritmética

Los operadores aritméticos estándar sobre valores int y float:

  • + – suma

  • - – resta (o negación, como prefijo: -x)

  • * – multiplicación

  • / – división. Siempre devuelve un float, incluso cuando ambos operandos son enteros.

  • // – división entera. Devuelve el cociente entero redondeado hacia menos infinito.

  • % – módulo (resto).

  • ** – exponenciación (2 ** 10 es 1024).

>>> 7 / 2
3.5
>>> 7 // 2
3
>>> -7 // 2
-4
>>> 7 % 2
1
>>> 2 ** 16
65536

La aritmética con tipos mixtos promueve automáticamente los enteros a flotantes:

>>> 3 + 0.5
3.5

La asignación aumentada combina el operador con = para una actualización compacta en el sitio:

counter = 0
counter += 1                # equivalent to counter = counter + 1
counter *= 2                # works for *= /= //= %= **= too

La precedencia de operadores sigue el orden convencional: primero **, luego el - unario, después *, /, // y %, y finalmente + y -. Usa paréntesis cuando tengas dudas: no cuestan nada en tiempo de ejecución.

2.3.2. Comparación

Los operadores de comparación devuelven un bool (True o False):

  • == y != – igual / distinto.

  • <, <=, >, >= – ordenación.

>>> 3 == 3
True
>>> 3 == 3.0
True
>>> 3 < 5 <= 5
True

El último ejemplo es una comparación encadenada y equivale exactamente a 3 < 5 and 5 <= 5.

Advertencia

= asigna; == compara. La expresión if x = 5: es un error de sintaxis precisamente porque Python se niega a confundir silenciosamente ambos.

2.3.3. Lógica booleana

Tres operadores combinan booleanos:

  • and – True solo cuando ambos lados son verdaderos.

  • or – True cuando cualquiera de los lados es verdadero.

  • not – invierte un único booleano.

and y or hacen cortocircuito: dejan de evaluar en cuanto se conoce el resultado. False and slow_check() nunca llama a slow_check.

and y or también devuelven uno de sus operandos en lugar de un literal True o False, lo que te permite escribir valores predeterminados de forma compacta:

name = user_name or "anonymous"   # "" / 0 / None are falsy

2.3.4. Operadores a nivel de bits

Para el trabajo con hardware (empaquetar campos de registros, enmascarar bits, analizar cabeceras de protocolo) recurrirás a los operadores a nivel de bits. Actúan sobre la representación binaria de un int:

  • & – AND a nivel de bits

  • | – OR a nivel de bits

  • ^ – XOR a nivel de bits

  • ~ – NOT a nivel de bits (complemento a uno)

  • << – desplazamiento a la izquierda

  • >> – desplazamiento a la derecha

Las formas literales hexadecimal y binaria resultan cómodas al leer y escribir estos valores:

>>> 0b1100 & 0b1010
8                              # 0b1000
>>> 0b1100 | 0b1010
14                             # 0b1110
>>> 0xFF ^ 0x0F
240                            # 0xF0
>>> 1 << 8
256
>>> (0xABCD >> 8) & 0xFF
171                            # extract the high byte

Existen formas aumentadas para cada uno: |=, &=, ^=, <<=, >>=.

Nota

and / or operan sobre booleanos (o sobre la veracidad); & / | operan sobre bits. No los confundas. 0b1100 and 0b1010 se evalúa como 0b1010 porque ambos operandos son verdaderos, lo cual no suele ser lo que quieres al manipular bits.

2.3.5. Funciones numéricas incorporadas útiles

Un puñado de funciones incorporadas cubren operaciones numéricas comunes que los operadores por sí solos no abarcan:

  • round() – el entero más cercano, o las ndigits posiciones decimales más cercanas cuando se proporciona un segundo argumento. Devuelve un int para round(x) y un float para round(x, n). Los empates (0.5, 1.5, …) se redondean al número par más cercano, no siempre hacia arriba.

  • divmod() – devuelve (quotient, remainder) en una sola llamada. Práctico para dividir una cantidad en unidades (segundos en minutos y segundos, bytes en páginas y desplazamientos).

  • pow() – lo mismo que ** en su forma de dos argumentos. La forma de tres argumentos pow(base, exp, mod) calcula (base ** exp) % mod sin llegar a materializar nunca el gigantesco valor intermedio, que es la única forma práctica de hacer exponenciación modular con exponentes grandes.

>>> round(3.7)
4
>>> round(3.14159, 2)
3.14
>>> round(0.5)               # ties go to even, not always up
0
>>> round(1.5)
2

>>> divmod(125, 60)          # 125 seconds = 2 min, 5 sec
(2, 5)
>>> minutes, seconds = divmod(125, 60)

>>> pow(3, 4)                # same as 3 ** 4
81
>>> pow(3, 100, 7)           # (3 ** 100) mod 7, efficient
4

Las conversiones de entero a cadena entre bases (bin, oct, hex) se tratan en Métodos y formato de cadenas.

2.3.6. El módulo math

Las funciones matemáticas comunes residen en el módulo math. Impórtalo una vez y llama a sus funciones mediante un nombre con punto:

import math

print(math.sqrt(2))              # 1.4142135
print(math.sin(math.pi / 2))     # 1.0
print(math.floor(3.7))           # 3
print(math.log(100, 10))         # 2.0

El módulo math de MicroPython cubre los habituales (sqrt, exp, log, sin, cos, tan, atan2, floor, ceil, pi, e, …). Para números aleatorios, consulta el módulo random; para la manipulación de bits en coma fija, los operadores anteriores suelen ser suficientes.

2.3.7. Números complejos

Para el trabajo numérico que necesita componentes imaginarios, Python tiene un tipo complex con literales con sufijo j (1 + 2j). El módulo cmath refleja a math para entradas complejas. Ambos están presentes en la mayoría de las compilaciones de MicroPython, pero rara vez se necesitan para el trabajo con cámaras; se mencionan principalmente para que no sean una sorpresa si portas código que los utiliza.