Operadores en Python
Introducción
Los operadores en Python son símbolos especiales que realizan operaciones específicas en uno o más valores (operandos). Son esenciales para realizar cálculos, comparaciones y manipulaciones de datos en los programas.
Operadores Aritméticos
+: Suma # x = 5 + 3 Resultado: x = 8
-: Resta # x = 5 - 3 Resultado: x = 2
*: Multiplicación # x = 5 * 3 Resultado: 15
/: División (siempre retorna un float) # x = 5 / 2 Resultado: 2.5
//: División entera (retorna un int) # x = 5 // 2 Resultado: 2
%: Módulo (resto de la división) # x = 5 % 2 Resultado: 1
**: Exponenciación # x = 2 ** 3 Resultado: 8
Operadores de Comparación
Comparan dos valores y devuelven un valor booleano (True
o False).
==: Igual a # 5 == 5 # Resultado: True
!=: No igual a # 5 != 3 Resultado: True
>: Mayor que # 5 > 3 Resultado: True
<: Menor que # 3 < 5 Resultado: True
>=: Mayor o igual que # 5 >= 5 Resultado: True
<=: Menor o igual que # 3 <= 5 Resultado: True
Operadores Lógicos
and: Y lógico # (5 > 3) and (2 < 4) Resultado: True
or: O lógico # (5 > 3) or (2 > 4) Resultado: True
not: Negación lógica # not(5 > 3) Resultado: False
Operadores de Asignación
=: Asignación simple # x = 5 Equivalente a x = 5
+=: Asignación con suma # x += 3 Equivalente a x = x + 3
-=: Asignación con resta # x -= 2 Equivalente a x = x - 2
*=: Asignación con multiplicación # x *= 4 Equivalente a x = x * 4
/=: Asignación con división # x /= 2 Equivalente a x = x / 2
//=: Asignación con división entera # x //= 2 Equivalente a x = x // 2
%=: Asignación con resto de la división # x %= 3 Equivalente a x = x % 3
**=: Asignación con Exponenciación # x **= 2 Equivalente a x = x ** 2
Operadores de Identidad
Comprueban si dos variables hacen referencia al mismo objeto en memoria.
is: Comprueba si dos objetos son el mismo objeto
x = [1, 2, 3]
y = x
x is y # Resultado: True
is not: Comprueba si dos objetos no son el mismo objeto
x = [1, 2, 3]
y = [1, 2, 3]
x is not y # Resultado: True
Operadores de Pertenencia
Comprueban si un valor está presente en una secuencia, como una lista, tupla, cadena o conjunto.
in: Comprueba si un valor está en una secuencia
3 in [1, 2, 3] # Resultado: True
not in: Comprueba si un valor no está en una secuencia
4 not in [1, 2, 3] # Resultado: True
Operadores Bit a Bit (Para tipos enteros)
5 | 3 # Resultado: 7 (0101 | 0011 = 0111)
^ (XOR a nivel de bits): Realiza una operación XOR bit a bit.
5 ^ 3 # Resultado: 6 (0101 ^ 0011 = 0110)
~ (NOT a nivel de bits): Invierte los bits.
~5 # Resultado: -6 (invertir los bits de 5)
<< (Desplazamiento a la izquierda): Desplaza los bits hacia la izquierda, añadiendo ceros.
5 << 1 # Resultado: 10 (0101 << 0001 = 1010)
>> (Desplazamiento a la derecha): Desplaza los bits hacia la derecha.
5 >> 1 # Resultado: 2 (0101 >> 1 = 0010)
Prioridad de los Operadores
En Python, los operadores tienen una prioridad o precedencia que determina el orden en que se evalúan cuando hay múltiples operadores en una expresión. Los operadores de mayor precedencia se evalúan antes que los de menor precedencia. Si varios operadores tienen la misma precedencia, la evaluación se realiza de izquierda a derecha (asociatividad de izquierda), salvo algunas excepciones, como la potencia.
A continuación se presenta una lista de los operadores de Python ordenados de mayor a menor precedencia, junto con ejemplos para ilustrar cómo afecta la prioridad:
Operadores de Paréntesis ()
Los paréntesis tienen la mayor precedencia y se utilizan para forzar un orden específico de evaluación en las expresiones.
(3 + 2) * 4 # Resultado: 20
# Se evalúa primero lo que está dentro de los paréntesis.
Exponenciación **
Este operador eleva un número a la potencia de otro. Tiene asociatividad de derecha a izquierda, lo que significa que se evalúa de derecha a izquierda.
2 ** 3 ** 2 # Resultado: 512
# Se evalúa primero 3 ** 2 (9) y luego 2 ** 9.
Operadores Unarios +, -, ~
Estos son operadores que se aplican a un solo operando: + para el valor positivo, - para el negativo, y ~ para la negación bit a bit.
-5 + 3 # Resultado: -2
Multiplicación *, División /, División Entera //, Módulo %
Todos estos operadores tienen la misma precedencia y se evalúan de izquierda a derecha.
5 * 2 // 3 # Resultado: 3
# Se evalúa primero 5 * 2, luego el resultado se divide por 3.
Suma + y Resta -
La suma y la resta también tienen la misma precedencia y se evalúan de izquierda a derecha.
5 - 3 + 2 # Resultado: 4
# Se evalúa primero 5 - 3, luego se le suma 2.
Operadores de Desplazamiento <<, >>
Estos operadores realizan desplazamientos de bits hacia la izquierda o derecha, respectivamente.
# Números positivos
a = 5 # binario: 0b0101
print(a << 1) # desplazar a la izquierda 1 → 0b1010 = 10
print(a << 2) # desplazar a la izquierda 2 → 0b10100 = 20
print(a >> 1) # desplazar a la derecha 1 → 0b10 = 2
print(a >> 2) # desplazar a la derecha 2 → 0b1 = 1
# Ejemplo 2: con números negativos
b = -10 # en binario en complemento a dos (ilustrativo)
print(b << 1) # ≈ -20, porque desplazar hacia la izquierda multiplica por 2
print(b << 2) # ≈ -40
print(b >> 1) # ≈ -5, división por 2 manteniendo signo
print(b >> 2) # ≈ -3, redondeando hacia abajo (más negativo)
Operadores de Comparación <, <=, >, >=
Comparan dos valores y devuelven un valor booleano. Tienen la misma precedencia y se evalúan de izquierda a derecha.
a = 5
b = 7
c = 5
print(a == b) # False, porque 5 no es igual a 7
print(a == c) # True, 5 es igual a 5
print(a != b) # True, porque 5 es distinto de 7
print(a < b) # True, 5 es menor que 7
print(a > b) # False, 5 no es mayor que 7
print(a <= c) # True, 5 es menor o igual que 5
print(b >= a) # True, 7 es mayor o igual que 5
Operadores de Igualdad ==, !=
Comprueban si dos valores son iguales o distintos. Tienen menor precedencia que los operadores de comparación.
a = 5
b = 7
c = 5
print(a == b) # False, porque 5 no es igual a 7
print(a == c) # True, 5 es igual a 5
print(a != b) # True, porque 5 es distinto de 7
Operadores a Nivel de Bits & (AND bit a bit)
Este operador realiza una operación AND a nivel de bits.
# Ejemplo 1: números simples
a = 0b111100
b = 0b001101
print(a & b) # c = 0b001100
Operadores a Nivel de Bits ^ (XOR) y | (OR bit a bit)
Estos operadores realizan operaciones XOR (OR exclusivo) y OR a nivel de bits.
a = 00001100
b = 00001010
print(a | b) # Esperado: 0001110
print(a ^ b) # Esperado: 0000110
Operadores Lógicos not, and, or
Estos operadores se usan para combinar condiciones lógicas. not tiene mayor precedencia que and y or.
# Valores binarios, comprobaciones lógicas simples
a = 20
b = 40
# Se quiere comprobar si ambos son “verdaderos” (> 10) usando and
print((a > 10) and (b > 10)) # True, porque a>10 y b>10
# Se Usa or para ver si al menos uno es mayor que 10
print((a > 30 ) or (b > 30)) # True, porque solo b>30
edad = 17
print(not (edad >= 18)) # Resultado: True, porque edad >= 18 es False, y not lo invierte
Operadores de Asignación =, +=, -=, *=, /=, etc.
Estos operadores asignan un valor a una variable. Tienen baja precedencia, por lo que las operaciones del lado derecho de una asignación se evalúan primero.
# Operador de asignación simple (=)
x = 10
print(x) # Imprime: 10
# Operador += (suma y asignación)
x += 5 # equivalente a: x = x + 5
print(x) # Imprime: 15
# Operador -= (resta y asignación)
x -= 3 # equivalente a: x = x - 3
print(x) # Imprime: 12
# Operador *= (multiplicación y asignación)
x *= 2 # equivalente a: x = x * 2
print(x) # Imprime: 24
# Operador /= (división flotante y asignación)
x /= 4 # equivalente a: x = x / 4
print(x) # Imprime: 6.0
# Operador %= (módulo y asignación)
x %= 4 # equivalente a: x = x % 4
print(x) # Imprime: 2.0
# Operador **= (potencia y asignación)
x **= 3 # equivalente a: x = x ** 3
print(x) # Imprime: 8.0
# Operador //= (división entera / floor y asignación)
x //= 3 # equivalente a: x = x // 3
print(x) # Imprime: 2.0 (porque 8.0 // 3 da 2.0)
Operadores de Identidad is, is not
Verifican si dos variables se refieren al mismo objeto.
# Ejemplo muy simple de is / is not
a = [1, 2, 3]
b = a # b apunta al mismo objeto que a
c = [1, 2, 3] # c es una lista diferente, aunque con los mismos elementos
print(a is b) # True, porque b y a son el mismo objeto
print(a is c) # False, porque c aunque igual en contenido, es otro objeto distinto
print(a is not c) # True, porque no son el mismo objeto
print(a is not b) # False, porque sí son el mismo objeto
Operadores de Pertenencia in, not in
Comprueban si un elemento está presente en una secuencia.
in: Comprueba si un valor está en una secuencia
3 in [1, 2, 3] # Resultado: True
not in: Comprueba si un valor no está en una secuencia
4 not in [1, 2, 3] # Resultado: True