# Operadores de Python: aritmética, división // y %, comparación, and/or/not y round en Python

URL: https://skillaria.top/es/guides/python/operadores-python

En Python, / siempre devuelve un float, // da la parte entera redondeando hacia abajo, % es el resto y ** es la potencia. La función round(x, n) redondea a n decimales con redondeo bancario: round(2.5) da 2 y round(3.5) da 4; para redondear hacia arriba o hacia abajo se usan math.ceil y math.floor, y el valor absoluto lo da abs.

Los operadores de Python son símbolos que combinan valores y producen un nuevo valor: `+` suma, `//` divide sin resto y `and` combina condiciones. A continuación tiene la lista completa de operadores con ejemplos, la diferencia entre `/` y `//`, la lógica de `and`, `or` y `not`, y las funciones de redondeo: round en Python, `math.ceil`, `math.floor` y `abs`. Todos los ejemplos se pueden pegar en el REPL y comprobar.

## Lista de operadores de Python

Los operadores se agrupan por su función. No hace falta memorizar la tabla completa: en el código real lo que más aparece son la aritmética, la comparación y los operadores lógicos.

| Grupo | Operadores | Ejemplo |
| --- | --- | --- |

| Aritméticos | `+ - * / // % **` | `7 // 2` → 3 |

| Comparación | `== != < > <= >=` | `3 < 5` → True |

| Lógicos | `and or not` | `not True` → False |

| Identidad | `is`, `is not` | `x is None` |

| Pertenencia | `in`, `not in` | `"f" in "café"` → True |

| Asignación | `= += -= *= /= //= %= **=` | `total += 250` |

| Morsa | `:=` | `if (n := len(s)) > 10:` |

| Bit a bit | `& | ^ ~ << >>` | `5 & 3` → 1 |

## Operadores aritméticos

La suma, la resta y la multiplicación funcionan como en la escuela. Si en una expresión interviene al menos un `float`, el resultado también será `float`: `2 + 1.0` da `3.0`. Los enteros en Python no desbordan: `2 ** 100` se calcula con exactitud, sin importar cuántas cifras tenga.

```
>>> 250 + 120
370
>>> 12.5 * 3
37.5
>>> 2 ** 10
1024
>>> 2 ** 0.5
1.4142135623730951
```

### Potencia en Python: el operador **

La potencia se escribe con dos asteriscos, no con `^`: en Python el signo `^` significa «O exclusivo» bit a bit, y `2 ^ 3` devuelve 1, no 8. Una potencia fraccionaria da una raíz: `9 ** 0.5` es `3.0`. Existe también la función `pow(x, y)`, que hace lo mismo y admite un tercer argumento para el resto: `pow(2, 10, 1000)` devuelve 24.

Ojo con la prioridad: `**` se ejecuta antes que el menos unario, así que `-2 ** 2` da `-4`. Para elevar al cuadrado un número negativo, escriba los paréntesis: `(-2) ** 2`.

## División en Python: /, // y %

En Python hay dos tipos de división, y esa es la principal fuente de sorpresas para los principiantes. La división normal `/` siempre devuelve un `float`, incluso si la división es exacta. La división entera `//` descarta la parte decimal, y `%`, el operador módulo (modulo operator en inglés), devuelve el resto.

```
>>> 7 / 2
3.5
>>> 8 / 2
4.0
>>> 7 // 2
3
>>> 7 % 2
1
```

### División entera // y resto %: en la práctica

El par `//` y `%` resuelve los problemas del tipo «cuántos enteros salen y cuánto sobra». En el curso, el registro de gastos guarda el dinero en centavos para no perder precisión y separa el importe en unidades y centavos:

```
centavos = 125050         # guardamos el dinero en centavos
pesos = centavos // 100   # 1250 — pesos enteros
cent = centavos % 100     # 50 — el resto
print(pesos, cent)        # 1250 50

print(40 // 7, "semanas y", 40 % 7, "días")   # 5 semanas y 5 días
```

Ambas operaciones a la vez las devuelve la función integrada `divmod`: `divmod(125050, 100)` da la tupla `(1250, 50)`. El resto también sirve para comprobar la paridad: `n % 2 == 0` es verdadero para los números pares.

### Números negativos: // redondea hacia abajo

El operador `//` no se limita a descartar la fracción: redondea hacia abajo, hacia menos infinito. Con números positivos no hay diferencia; con negativos, sí. El signo del resto `%` en Python coincide con el signo del divisor, de modo que siempre se cumple `a == (a // b) * b + a % b`.

```
>>> -7 // 2
-4
>>> -7 % 2
1
>>> int(-7 / 2)     # descarta la fracción, no redondea hacia abajo
-3
```

### División entre cero: qué error aparece

Dividir entre cero con cualquiera de los tres operadores provoca la excepción `ZeroDivisionError`. Esto ocurre tanto con enteros como con decimales. Se puede capturar con `try/except` o comprobar el divisor de antemano.

```
>>> 10 / 0
Traceback (most recent call last):
  ...
ZeroDivisionError: division by zero
>>> contador = 0
>>> promedio = 1500 / contador if contador else 0
>>> promedio
0
```

## Operadores de comparación

Las comparaciones devuelven `True` o `False`. La igualdad se comprueba con dos signos `==`; un solo `=` es una asignación. Las cadenas se comparan carácter a carácter por sus códigos, así que `"B" < "a"` es verdadero: las mayúsculas van antes que las minúsculas.

```
>>> 250 == 250.0
True
>>> 3 != 4
True
>>> 1 < 5 > 0.1 + 0.2 == 0.3
False
```

Las cadenas de comparaciones como `0 <= x < 100` son una comodidad de Python: no hace falta escribir `and`. La última línea recuerda el error de precisión de los decimales: `0.1 + 0.2` da `0.30000000000000004`. Para comparar decimales use `math.isclose(a, b)` y guarde el dinero en centavos o en `Decimal`.

## Operadores lógicos and, or, not

Los operadores lógicos en Python se escriben con palabras, no con los símbolos `&&` y `||` de otros lenguajes. `and` es verdadero cuando lo son ambas partes, `or` cuando lo es al menos una, y `not` invierte el valor.

| a | b | a and b | a or b | not a |
| --- | --- | --- | --- | --- |

| True | True | True | True | False |

| True | False | False | True | False |

| False | True | False | True | True |

| False | False | False | False | True |

Prioridad: primero `not`, luego `and` y después `or`. La expresión `True or False and False` es `True`, porque `and` se evalúa primero. En condiciones complejas use paréntesis: el código se entiende mejor, para usted y para sus compañeros.

### Qué devuelven realmente and y or

`and` y `or` no devuelven necesariamente `True` o `False`, sino uno de los operandos. `or` devuelve el primer valor verdadero (o el último, si no hay ninguno), y `and` el primer valor falso (o el último). Son falsos `0`, `0.0`, la cadena vacía, las colecciones vacías, `None` y `False`.

```
>>> nombre = ""
>>> nombre or "Invitado"
'Invitado'
>>> 5 and 0
0
>>> not ""
True
```

La evaluación es perezosa: si el resultado ya está claro por la parte izquierda, la derecha no se calcula. Por eso `contador and total / contador` no falla con división entre cero cuando `contador == 0`. El operador `not`, a diferencia de los otros dos, siempre devuelve un `bool`.

## Operadores is e in

`==` compara valores, mientras que `is` comprueba que dos nombres apuntan al mismo objeto. Dos listas distintas con el mismo contenido son iguales, pero no son el mismo objeto. El único lugar donde `is` se necesita siempre es la comprobación de `None`: `if x is None`.

```
>>> a = [250, 120]
>>> b = [250, 120]
>>> a == b, a is b
(True, False)
>>> c = a
>>> c is a
True
```

No compare números ni cadenas con `is`: a veces «funciona» por el caché interno de objetos, pero el resultado depende de la implementación, y Python muestra `SyntaxWarning` en construcciones como `x is 5`.

El operador `in` comprueba la pertenencia: una subcadena dentro de una cadena, un elemento de una lista, una clave de un diccionario. `not in` es la comprobación contraria.

```
>>> "café" in "café con leche"
True
>>> "comida" in {"comida": 450, "taxi": 300}
True
>>> 5 not in [1, 2, 3]
True
```

## Operadores de asignación y el operador morsa :=

Los operadores compuestos `+=`, `-=`, `*=`, `//=` y otros son una abreviatura: `total += 250` equivale a `total = total + 250`. En Python no existen los operadores `++` y `--`: escribir `x++` provoca un error de sintaxis.

El operador morsa `:=` (llamado así por su parecido con los ojos y los colmillos de la morsa) asigna un valor dentro de una expresión. Resulta útil cuando el valor hace falta a la vez para comprobar y para usar después:

```
gastos = ["café", "taxi", "comida", "cine"]
if (n := len(gastos)) > 3:
    print(f"Demasiados gastos: {n}")

while (linea := input("Importe: ")) != "":
    print(int(linea) * 2)
```

Sin la morsa habría que llamar a `len` dos veces o sacar la asignación a una línea aparte. Abusar de ella no conviene: si la línea se vuelve ilegible, es mejor una asignación normal.

## Redondeo en Python: round, ceil, floor

Para redondear en Python existe la función integrada `round` y las funciones del módulo `math`. Resuelven tareas distintas, y confundirlas es un error frecuente.

| Función | Qué hace | 2.5 | -2.5 | 2.7 |
| --- | --- | --- | --- | --- |

| `round(x)` | al entero más cercano; la mitad, al par | 2 | -2 | 3 |

| `math.floor(x)` | hacia abajo, hacia menos infinito | 2 | -3 | 2 |

| `math.ceil(x)` | hacia arriba, hacia más infinito | 3 | -2 | 3 |

| `math.trunc(x)`, `int(x)` | descartar la fracción, hacia cero | 2 | -2 | 2 |

### La función round en Python y el redondeo bancario

La función `round(x, n)` redondea a `n` decimales; sin segundo argumento devuelve un `int`. La trampa principal: round en Python redondea el «medio» al par más cercano, al estilo bancario. Por eso `round(2.5)` da 2 y `round(3.5)` da 4. Así los errores de redondeo no se acumulan en una sola dirección en cálculos grandes.

```
>>> round(2.5), round(3.5)
(2, 4)
>>> round(3.14159, 2)
3.14
>>> round(1250, -2)     # a las centenas
1200
>>> round(2.675, 2)     # no 2.68: en binario es 2.67499...
2.67
```

Si necesita el redondeo escolar «la mitad hacia arriba», por ejemplo en un recibo, use `Decimal` con el modo `ROUND_HALF_UP`. Pase el número como cadena para no heredar el error del `float`:

```
>>> from decimal import Decimal, ROUND_HALF_UP
>>> Decimal("2.5").quantize(Decimal("1"), ROUND_HALF_UP)
Decimal('3')
>>> Decimal("2.675").quantize(Decimal("0.01"), ROUND_HALF_UP)
Decimal('2.68')
```

Y otra regla del curso: redondee solo al mostrar. Para imprimir bonito no hace falta `round`: basta una f-string, `f"{importe:.2f}"` muestra dos decimales y el número en sí sigue siendo exacto.

### math.ceil y math.floor: redondeo hacia arriba y hacia abajo

`math.ceil` sirve cuando «faltar» no es aceptable: cuántos autobuses contratar, cuántas páginas hacen falta en los resultados. `math.floor` sirve cuando solo cuentan las unidades completas. Ambas funciones devuelven un `int`.

```
import math

invitados = 47
asientos = 20
print(math.ceil(invitados / asientos))   # 3 autobuses
print(math.floor(9.99))                  # 9
print(-(-invitados // asientos))         # 3 — ceil sin math, con //
```

En el módulo `math` hay más funciones útiles: `math.sqrt` (raíz), `math.isclose` (comparación de decimales), `math.pi`, `math.gcd`. En Python 3.15 apareció el submódulo `math.integer` (PEP 791) para matemática entera: en él están `comb`, `factorial`, `gcd`, `isqrt`, `lcm`, `perm`, y las funciones antiguas como `math.gcd` siguen funcionando.

## Función abs: valor absoluto

`abs(x)` devuelve el módulo, es decir, la distancia a cero sin signo. No requiere importar nada, la función es integrada. Funciona con enteros, decimales e incluso complejos: para `3+4j` devuelve la longitud del vector, `5.0`.

```
>>> abs(-250)
250
>>> abs(-12.5)
12.5
>>> presupuesto, gastado = 5000, 5320
>>> abs(presupuesto - gastado)    # cuánto nos desviamos
320
```

El uso típico es la diferencia sin tener en cuenta el sentido, y la comparación con una tolerancia: `abs(a - b) < 0.001`. Para decimales es más fiable `math.isclose`, porque tiene en cuenta la escala de los números.

## Prioridad de los operadores

Cuando una expresión tiene varios operadores, Python los ejecuta por prioridad, de mayor a menor:

1. `**`
2. unarios `-x`, `+x`, `~x`
3. `* / // %`
4. `+ -`
5. desplazamientos y operaciones bit a bit
6. comparaciones, `in`, `is`
7. `not`
8. `and`
9. `or`
10. `:=`

Así, `2 + 3 * 4` es 14, y `(2 + 3) * 4` es 20. Si tiene dudas, ponga paréntesis: los paréntesis de más no cuestan nada, mientras que un error de prioridad tarda mucho en encontrarse.

## Errores frecuentes con los operadores

| Error | Qué pasa | Cómo es correcto |
| --- | --- | --- |

| `if x = 5:` | SyntaxError: es una asignación | `if x == 5:` |

| `2 ^ 3` en lugar de potencia | XOR bit a bit, resultado 1 | `2 ** 3` |

| esperar un entero de `8 / 2` | se obtiene `4.0` | `8 // 2` |

| `x == 1 or 2` | siempre es verdadero: `or 2` | `x in (1, 2)` |

| esperar 3 de `round(2.5)` | el redondeo bancario da 2 | `Decimal` con `ROUND_HALF_UP` |

| `"5" + 5` | TypeError | `int("5") + 5` |

## Conclusión

Lo más importante: `/` siempre da float, `//` redondea hacia abajo, `%` devuelve el resto con el signo del divisor, y la potencia es `**`. Los operadores lógicos `and`, `or` y `not` se escriben con palabras y se evalúan de forma perezosa, y `is` sirve para comprobar `None`. La función round en Python redondea al par; para redondear hacia arriba y hacia abajo están `math.ceil` y `math.floor`, y el valor absoluto lo da `abs`. En el curso estos operadores se practican en un caso real, el registro de gastos, donde el dinero se guarda en centavos.

## FAQ

**¿Cómo redondear un número a dos decimales en Python?**

Use round(x, 2); si solo necesita mostrar el número bonito, use la f-string f"{x:.2f}", que no cambia el valor en sí.

**¿Por qué round(0.5) en Python devuelve 0?**

Porque round redondea la mitad al entero par más cercano, y 0 es par; de la misma forma round(1.5) y round(2.5) dan 2.

**¿Cómo obtener la parte entera de una división en Python?**

Con el operador //: 17 // 5 devuelve 3. Con números negativos redondea hacia abajo, así que -17 // 5 da -4; si quiere descartar la fracción hacia cero, use int(-17 / 5).

**¿Python tiene operador ternario?**

Sí, es la expresión condicional: valor_si_verdadero if condición else valor_si_falso, por ejemplo "par" if n % 2 == 0 else "impar".

**¿Cuál es la diferencia entre & y and en Python?**

and es un operador lógico con evaluación perezosa, y & es el AND bit a bit para números y la intersección para conjuntos; en los if use and.


---
Source: Skillaria.Top (https://skillaria.top)