Python proporciona un conjunto robusto de operadores para realizar una amplia variedad de operaciones, desde cálculos matemáticos hasta evaluaciones lógicas y manipulaciones a nivel de bits. Entender su funcionamiento es crucial para escribir código eficaz y claro. Además, exploraremos cómo Python maneja la conversión entre diferentes sistemas numéricos como el binario, octal y hexadecimal.

Operadores Aritméticos

Los operadores aritméticos se utilizan para realizar operaciones matemáticas comunes.

Operador	Descripción
+	Suma
-	Resta
*	Multiplicación
/	División (siempre devuelve un flotante)
%	Módulo (residuo de la división)
**	Potenciación (eleva un número a la potencia de otro)
//	División entera (devuelve la parte entera del cociente)

val1 = 20
val2 = 7

print(f"Suma: {val1 + val2}")
print(f"Resta: {val1 - val2}")
print(f"Multiplicación: {val1 * val2}")
print(f"División: {val1 / val2}")
print(f"Módulo: {val1 % val2}")
print(f"División Entera: {val1 // val2}")
print(f"Potencia (val1^val2): {val1 ** val2}")

Para obtener el cociente y el residuo de una división simultáneamente, se puede usar la función incorporada divmod():

resultado_division = divmod(25, 4)
print(f"Cociente y Residuo: {resultado_division}") # Salida: (6, 1)

Operadores de Asignación

Los operadores de asignación se utilizan para asignar valores a variables. Pueden combinar una operación aritmética con la asignación.

Operador	Descripción
=	Asigna el valor de la derecha a la variable de la izquierda
+=	Suma y asigna
-=	Resta y asigna
*=	Multiplica y asigna
/=	Divide y asigna
%=	Calcula el módulo y asigna
**=	Eleva a la potencia y asigna
//=	Divide enteramente y asigna

total = 100
print(f"Valor inicial: {total}")

total += 20  # Equivalente a total = total + 20
print(f"Después de += 20: {total}")

total *= 2   # Equivalente a total = total * 2
print(f"Después de *= 2: {total}")

total /= 5   # Equivalente a total = total / 5
print(f"Después de /= 5: {total}")

total //= 3  # Equivalente a total = total // 3
print(f"Después de //= 3: {total}")

En Python, cada objeto en memoria tiene una dirección única. La función id() devuelve esta dirección, lo que es útil para entender cómo las variables referencian objetos.

clave_api = "mi_clave_secreta"
alias_clave = clave_api

print(f"ID de clave_api: {id(clave_api)}, Valor: {clave_api}")
print(f"ID de alias_clave: {id(alias_clave)}, Valor: {alias_clave}")
# Ambos IDs son iguales porque alias_clave referencia el mismo objeto en memoria

Operadores de Comparación

Estos operadores se utilizan para comparar dos valores y devuelven un valor booleano (True o False).

Operador	Descripción
==	Igual a
!=	Diferente de
>	Mayor que
<	Menor que
>=	Mayor o igual que
<=	Menor o igual que

num_a = 15
num_b = 8

print(f"¿num_a es igual a num_b? {num_a == num_b}")
print(f"¿num_a es diferente de num_b? {num_a != num_b}")
print(f"¿num_a es mayor que num_b? {num_a > num_b}")
print(f"¿num_a es menor o igual que num_b? {num_a <= num_b}")

is vs. ==

Aunque a menudo se usan indistintamente, is y == tienen diferencias fundamentales:

• == compara el valor de los objetos.
• is compara la identidad de los objetos; es decir, verifica si ambas variables se refieren exactamente al mismo objeto en memoria.

Python realiza optimizaciones para reutilizar objetos para números enteros pequeños (generalmente en el rango de -5 a 256). Esto puede llevar a resultados sorprendentes con is.

# Números enteros pequeños (dentro del rango de caché)
x = 50
y = 50
print(f"Para 50 y 50:")
print(f"x == y: {x == y}") # True (los valores son iguales)
print(f"x is y: {x is y}") # True (ambas variables referencian el mismo objeto optimizado)

# Números enteros grandes (fuera del rango de caché)
p = 1000
q = 1000
print(f"\nPara 1000 y 1000:")
print(f"p == q: {p == q}") # True (los valores son iguales)
print(f"p is q: {p is q}") # False (normalmente, Python crea dos objetos distintos en memoria)

El comportamiento de is para números grandes puede variar entre diferentes ejecuciones o entornos (script vs. consola interactiva) debido a las optimizaciones del intérprete, pero la regla general es que is verifica la identidad del objeto.

Operadores Lógicos

Los operadores lógicos se utilizan para combinar expresiones condicionales y se aplican a valores booleanos.

Operador	Descripción
and	True si ambas expresiones son True
or	True si al menos una expresión es True
not	Invierte el valor booleano de la expresión

es_adulto = True
tiene_licencia = False

print(f"¿Es adulto Y tiene licencia? {es_adulto and tiene_licencia}") # False
print(f"¿Es adulto O tiene licencia? {es_adulto or tiene_licencia}")   # True
print(f"¿NO es adulto? {not es_adulto}")                              # False

edad = 25
puntos_carnet = 8
puede_conducir = (edad >= 18) and (puntos_carnet > 0)
print(f"¿Puede conducir? {puede_conducir}") # True

Conversión entre Bases Numéricas

Python facilita la conversión entre las bases numéricas más comunes: binario (base 2), octal (base 8), decimal (base 10) y hexadecimal (base 16).

Binario (Base 2)

Los números binarios se componen de los dígitos 0 y 1. Python utiliza el prefijo 0b para indicar un literal binario.

• Decimal a Binario: Use la función bin().

numero_decimal = 13
print(f"Decimal {numero_decimal} a binario: {bin(numero_decimal)}") # Salida: 0b1101

Para convertir un número binario (como 0b1101) a decimal manualmente, sumamos las potencias de 2 donde el dígito es 1 (de derecha a izquierda):

(1 * 2^0) + (0 * 2^1) + (1 * 2^2) + (1 * 2^3) = 1 + 0 + 4 + 8 = 13

• Binario a Decimal: Use la función int() con la base 2.

print(f"Binario 0b1101 a decimal: {int('0b1101', 2)}") # Salida: 13

Para números negativos, bin() simplemente añade un signo menos al inicio:

print(f"Decimal -8 a binario: {bin(-8)}") # Salida: -0b1000

Octal (Base 8)

Los números octales usan los dígitos del 0 al 7. Python utiliza el prefijo 0o para los literales octales.

• Decimal a Octal: Use la función oct().

numero_decimal = 64
print(f"Decimal {numero_decimal} a octal: {oct(numero_decimal)}") # Salida: 0o100

Para convertir un número octal (como 0o100) a decimal, sumamos las potencias de 8:

(0 * 8^0) + (0 * 8^1) + (1 * 8^2) = 0 + 0 + 64 = 64

• Octal a Decimal: Use int() con la base 8.

print(f"Octal 0o100 a decimal: {int('0o100', 8)}") # Salida: 64

Hexadecimal (Base 16)

Los números hexadecimales utilizan los dígitos del 0 al 9 y las letras de la A a la F (donde A=10, B=11, ..., F=15). Python usa el prefijo 0x para los literales hexadecimales.

• Decimal a Hexadecimal: Use la función hex().

numero_decimal = 255
print(f"Decimal {numero_decimal} a hexadecimal: {hex(numero_decimal)}") # Salida: 0xff

Para convertir un número hexadecimal (como 0xFF) a decimal:

(15 * 16^0) + (15 * 16^1) = 15 + 240 = 255

• Hexadecimal a Decimal: Use int() con la base 16.

print(f"Hexadecimal 0xFF a decimal: {int('0xFF', 16)}") # Salida: 255

Decimal (Base 10)

Como se mostró anteriormente, para convertir un string de otra base a decimal, se utiliza la función int() especificendo la base:

print(f"Binario '1010' a decimal: {int('1010', 2)}")   # Salida: 10
print(f"Octal '12' a decimal: {int('12', 8)}")       # Salida: 10
print(f"Hexadecimal 'A' a decimal: {int('A', 16)}")   # Salida: 10

Operadores a Nivel de Bits (Bitwise)

Estos operadores actúan directamente sobre los bits individuales de los números enteros. Antes de la operación, los números se representan internamente en binario.

Operador	Descripción
&	AND a nivel de bits: Cada bit del resultado es 1 si los bits correspondientes en ambos operandos son 1.
|	OR a nivel de bits: Cada bit del resultado es 1 si al menos uno de los bits correspondientes en los operandos es 1.
~	NOT a nivel de bits (complemento a uno): Invierte todos los bits (0 se convierte en 1 y viceversa).
^	XOR a nivel de bits (OR exclusivo): Cada bit del resultado es 1 si los bits correspondientes son diferentes.
<<	Desplazamiento a la izquierda: Desplaza los bits del operando izquierdo a la izquierda por el número de posiciones especificadas por el operando derecho. Rellena con ceros a la derecha.
>>	Desplazamiento a la derecha: Desplaza los bits del operando izquierdo a la derecha por el número de posiciones especificadas por el operando derecho. Rellena con ceros a la izquierda (para positivos).

# Ejemplo: num1 = 5 (0101 en binario), num2 = 3 (0011 en binario)

# AND a nivel de bits (&)
#   0101 (5)
# & 0011 (3)
# = 0001 (1)
print(f"5 & 3 = {5 & 3}")

# OR a nivel de bits (|)
#   0101 (5)
# | 0011 (3)
# = 0111 (7)
print(f"5 | 3 = {5 | 3}")

# XOR a nivel de bits (^)
#   0101 (5)
# ^ 0011 (3)
# = 0110 (6)
print(f"5 ^ 3 = {5 ^ 3}")

# NOT a nivel de bits (~)
# El complemento a uno de 'x' es equivalente a '-(x+1)' para números positivos.
# ~5 es -(5+1) = -6
print(f"~5 = {~5}")

# Desplazamiento a la izquierda (<<)
# Un desplazamiento de 'n' posiciones a la izquierda es equivalente a multiplicar por 2^n.
# 5 << 2 = 5 * (2^2) = 5 * 4 = 20
# 0101 << 2  -> 010100 (20)
print(f"5 << 2 = {5 << 2}")

# Desplazamiento a la derecha (>>)
# Un desplazamiento de 'n' posiciones a la derecha es equivalente a una división entera por 2^n.
# 20 >> 2 = 20 // (2^2) = 20 // 4 = 5
# 010100 >> 2 -> 0101 (5)
print(f"20 >> 2 = {20 >> 2}")

Operador Ternario (Expresión Condicional)

Python ofrece un operador ternario conciso para asignar un valor a una variable basado en una condición. Su formato es:

valor_si_verdadero if condicion else valor_si_falso

temperatura = 28
estado_clima = "Cálido" if temperatura > 25 else "Fresco"
print(f"El clima es: {estado_clima}") # Salida: Cálido

puntuacion = 75
mensaje_resultado = "Aprobado" if puntuacion >= 70 else "Reprobado"
print(f"El estudiante está: {mensaje_resultado}") # Salida: Aprobado

Precedencia de Operadores

Al igual que en matemáticas, los operadores en Python tienen un orden de precedencia. Por ejemplo, la multiplicación se realiza antes que la suma. Es buena práctica usar paréntesis () para controlar explícitamente el orden de las operaciones y mejorar la legibilidad del código, evitando ambigüedades.