Tutorial Python: Operadores

Operadores aritméticos

Los operadores aritméticos en Python nos permiten realizar cálculos matemáticos básicos con valores numéricos. Estos operadores funcionan de manera similar a las operaciones matemáticas que realizamos en nuestra vida diaria, como sumar los productos en la lista de la compra o calcular el cambio que debemos recibir.

Operadores aritméticos básicos

Python incluye los siguientes operadores aritméticos fundamentales:

• Suma (+): Une dos valores numéricos.
• Resta (-): Encuentra la diferencia entre dos valores.
• Multiplicación (*): Multiplica dos valores.
• División (/): Divide el primer valor por el segundo, devolviendo siempre un número flotante.
• División entera (//): Divide y redondea hacia abajo al entero más cercano.
• Módulo (%): Devuelve el resto de la división.
• Exponente ()**: Eleva el primer valor a la potencia del segundo.

Veamos estos operadores en acción con ejemplos cotidianos:

# Suma: Calculando el total de una compra
precio_manzanas = 3
precio_naranjas = 4
total_frutas = precio_manzanas + precio_naranjas
print(f"Total de la compra: {total_frutas} euros")  # Total de la compra: 7 euros

# Resta: Calculando el cambio a recibir
dinero_entregado = 20
precio_producto = 13
cambio = dinero_entregado - precio_producto
print(f"Su cambio es: {cambio} euros")  # Su cambio es: 7 euros

# Multiplicación: Calculando el precio total de varios artículos iguales
precio_unitario = 5
cantidad = 3
precio_total = precio_unitario * cantidad
print(f"Precio por {cantidad} unidades: {precio_total} euros")  # Precio por 3 unidades: 15 euros

División y sus variantes

La división en Python tiene algunas particularidades importantes:

# División normal: Siempre devuelve un float
pizza = 8 / 2
print(f"8 / 2 = {pizza}")  # 8 / 2 = 4.0

# División entre personas: Repartiendo una cuenta
cuenta_total = 85
personas = 4
pago_por_persona = cuenta_total / personas
print(f"Cada persona debe pagar: {pago_por_persona} euros")  # Cada persona debe pagar: 21.25 euros

# División entera: Útil cuando necesitamos solo la parte entera
horas_totales = 90
horas_por_dia = 24
dias_completos = horas_totales // horas_por_dia
print(f"Días completos: {dias_completos}")  # Días completos: 3

# Módulo: Encontrando las horas restantes
horas_restantes = horas_totales % horas_por_dia
print(f"Horas restantes: {horas_restantes}")  # Horas restantes: 18

Exponenciación y raíces

El operador de exponenciación es muy útil para cálculos que involucran potencias:

# Exponenciación: Calculando el área de un cuadrado
lado = 4
area = lado ** 2
print(f"El área del cuadrado es: {area} unidades cuadradas")  # El área del cuadrado es: 16 unidades cuadradas

# Calculando el volumen de un cubo
volumen = lado ** 3
print(f"El volumen del cubo es: {volumen} unidades cúbicas")  # El volumen del cubo es: 64 unidades cúbicas

# Calculando raíces usando exponentes fraccionarios
numero = 25
raiz_cuadrada = numero ** 0.5
print(f"La raíz cuadrada de {numero} es: {raiz_cuadrada}")  # La raíz cuadrada de 25 es: 5.0

# Raíz cúbica
numero = 27
raiz_cubica = numero ** (1/3)
print(f"La raíz cúbica de {numero} es: {raiz_cubica}")  # La raíz cúbica de 27 es: 3.0

Precedencia de operadores

Al igual que en matemáticas, Python sigue un orden de precedencia para evaluar expresiones con múltiples operadores:

1. Paréntesis ()
2. Exponenciación **
3. Multiplicación *, división /, división entera //, módulo %
4. Suma +, resta -

# Ejemplo de precedencia
resultado = 10 + 5 * 2
print(f"10 + 5 * 2 = {resultado}")  # 10 + 5 * 2 = 20 (la multiplicación se realiza primero)

# Usando paréntesis para modificar la precedencia
resultado_con_parentesis = (10 + 5) * 2
print(f"(10 + 5) * 2 = {resultado_con_parentesis}")  # (10 + 5) * 2 = 30

# Ejemplo práctico: Calculando el precio final con descuento e impuestos
precio_base = 100
descuento = 20
tasa_impuesto = 0.16

# Sin paréntesis (incorrecto): primero aplica el impuesto y luego resta el descuento
precio_final_incorrecto = precio_base * tasa_impuesto + precio_base - descuento
print(f"Precio final (cálculo incorrecto): {precio_final_incorrecto}")  # 116.0

# Con paréntesis (correcto): primero resta el descuento y luego aplica el impuesto
precio_final_correcto = (precio_base - descuento) * (1 + tasa_impuesto)
print(f"Precio final (cálculo correcto): {precio_final_correcto}")  # 92.8

Operaciones con diferentes tipos de datos

Python maneja automáticamente las operaciones entre diferentes tipos numéricos:

# Entero + Entero = Entero
suma_enteros = 5 + 3
print(f"5 + 3 = {suma_enteros}, tipo: {type(suma_enteros)}")  # 5 + 3 = 8, tipo: <class 'int'>

# Entero + Float = Float
suma_mixta = 5 + 3.5
print(f"5 + 3.5 = {suma_mixta}, tipo: {type(suma_mixta)}")  # 5 + 3.5 = 8.5, tipo: <class 'float'>

# División siempre produce float, incluso con números enteros
division = 10 / 2
print(f"10 / 2 = {division}, tipo: {type(division)}")  # 10 / 2 = 5.0, tipo: <class 'float'>

Redondeo y precisión

Al trabajar con operaciones que involucran números decimales, es importante entender cómo manejar la precisión:

# Problemas de precisión con números flotantes
resultado = 0.1 + 0.2
print(f"0.1 + 0.2 = {resultado}")  # 0.1 + 0.2 = 0.30000000000000004

# Solución: usar la función round() para redondear
resultado_redondeado = round(resultado, 2)
print(f"Redondeado a 2 decimales: {resultado_redondeado}")  # Redondeado a 2 decimales: 0.3

# Ejemplo práctico: Calculando el precio final con impuestos
precio_producto = 19.99
tasa_impuesto = 0.16
precio_con_impuesto = precio_producto * (1 + tasa_impuesto)
print(f"Precio con impuesto (sin redondear): {precio_con_impuesto}")  # 23.1884
print(f"Precio con impuesto (redondeado): {round(precio_con_impuesto, 2)}")  # 23.19

Operaciones aritméticas en contextos reales

Veamos algunos ejemplos más complejos que combinan varios operadores en situaciones cotidianas:

# Calculando el tiempo total de un viaje
distancia = 150  # km
velocidad_promedio = 60  # km/h
tiempo_horas = distancia / velocidad_promedio
tiempo_horas_enteras = distancia // velocidad_promedio
tiempo_minutos_adicionales = (tiempo_horas - tiempo_horas_enteras) * 60

print(f"Tiempo total: {tiempo_horas_enteras} horas y {round(tiempo_minutos_adicionales)} minutos")
# Tiempo total: 2 horas y 30 minutos

# Calculando el consumo de combustible
litros_combustible = 35
kilometros_recorridos = 420
consumo = kilometros_recorridos / litros_combustible

print(f"Consumo: {round(consumo, 2)} km/l")  # Consumo: 12.0 km/l

# Calculando el interés compuesto
capital_inicial = 1000  # euros
tasa_interes_anual = 0.05  # 5%
años = 3
capital_final = capital_inicial * (1 + tasa_interes_anual) ** años

print(f"Capital después de {años} años: {round(capital_final, 2)} euros")
# Capital después de 3 años: 1157.63 euros

Visualización de operaciones aritméticas

Para entender mejor cómo funcionan los operadores aritméticos, podemos visualizarlos con ejemplos sencillos:

• Suma (+): Combinar cantidades

• 3 manzanas + 2 manzanas = 5 manzanas

• Resta (-): Quitar una cantidad de otra

• 5 caramelos - 2 caramelos = 3 caramelos

• Multiplicación (*): Repetir una cantidad varias veces

• 3 bolsas × 4 caramelos por bolsa = 12 caramelos

• División (/): Repartir una cantidad en partes iguales

• 12 galletas ÷ 3 personas = 4 galletas por persona

• Módulo (%): Lo que sobra al repartir

• 10 caramelos % 3 niños = 1 caramelo sobrante (después de dar 3 a cada niño)

• Exponenciación ()**: Multiplicar un número por sí mismo varias veces

• Un cuadrado de lado 3: 3² = 9 unidades de área

Operadores de comparación

Los operadores de comparación en Python nos permiten evaluar la relación entre dos valores y determinar si una condición es verdadera o falsa. Estos operadores son fundamentales para tomar decisiones en nuestros programas, similar a cómo comparamos precios al hacer compras o evaluamos si tenemos suficiente tiempo para realizar una actividad.

Tipos de operadores de comparación

Python incluye seis operadores de comparación básicos:

• Igual que (==): Comprueba si dos valores son iguales.
• Distinto que (!=): Comprueba si dos valores son diferentes.
• Mayor que (>): Evalúa si el valor izquierdo es mayor que el derecho.
• Menor que (<): Evalúa si el valor izquierdo es menor que el derecho.
• Mayor o igual que (>=): Evalúa si el valor izquierdo es mayor o igual que el derecho.
• Menor o igual que (<=): Evalúa si el valor izquierdo es menor o igual que el derecho.

Todos estos operadores devuelven un valor booleano (True o False), lo que los hace perfectos para estructuras de control como condicionales.

Comparaciones numéricas

Las comparaciones entre números funcionan de manera intuitiva, similar a las comparaciones matemáticas:

# Comparando precios de productos
precio_producto_a = 15
precio_producto_b = 10

es_mas_barato = precio_producto_b < precio_producto_a
print(f"¿El producto B es más barato que el A? {es_mas_barato}")  # True

# Verificando si tenemos suficiente dinero para una compra
dinero_disponible = 50
costo_total = 45

podemos_comprar = dinero_disponible >= costo_total
print(f"¿Tenemos suficiente dinero? {podemos_comprar}")  # True

# Comparando calificaciones
calificacion = 75
aprobado = calificacion >= 70
print(f"¿El estudiante aprobó? {aprobado}")  # True

Comparaciones de igualdad

Las comparaciones de igualdad son especialmente útiles para verificar condiciones específicas:

# Verificando si un número es par
numero = 10
es_par = numero % 2 == 0
print(f"¿{numero} es un número par? {es_par}")  # True

# Comprobando si la respuesta es correcta
respuesta_usuario = "París"
respuesta_correcta = "París"
es_correcta = respuesta_usuario == respuesta_correcta
print(f"¿La respuesta es correcta? {es_correcta}")  # True

# Verificando si un usuario tiene acceso
nivel_acceso = 2
nivel_requerido = 3
tiene_acceso = nivel_acceso >= nivel_requerido
print(f"¿El usuario tiene acceso? {tiene_acceso}")  # False

Es importante notar que el operador de igualdad == (doble igual) es diferente del operador de asignación = (igual simple). El primero compara valores, mientras que el segundo asigna un valor a una variable.

Comparaciones con diferentes tipos de datos

Python puede comparar diferentes tipos de datos, pero debemos tener cuidado con las reglas que aplica:

# Comparando enteros y flotantes
print(f"5 == 5.0: {5 == 5.0}")  # True (Python compara el valor, no el tipo)

# Comparando cadenas (comparación lexicográfica)
print(f"'apple' < 'banana': {'apple' < 'banana'}")  # True (comparación alfabética)
print(f"'apple' < 'Apple': {'apple' < 'Apple'}")  # False (las mayúsculas tienen menor valor ASCII)
print(f"'123' == 123: {'123' == 123}")  # False (diferentes tipos)

# Comparando booleanos con números
print(f"True == 1: {True == 1}")  # True
print(f"False == 0: {False == 0}")  # True
print(f"True > False: {True > False}")  # True (True es 1, False es 0)

Comparaciones encadenadas

Python permite encadenar operadores de comparación de manera elegante, similar a como lo haríamos en matemáticas:

# Verificando si un número está en un rango
edad = 25
es_adulto_joven = 18 <= edad < 30
print(f"¿Es un adulto joven? {es_adulto_joven}")  # True

# Equivalente a:
# es_adulto_joven = (18 <= edad) and (edad < 30)

# Verificando si una temperatura está en un rango confortable
temperatura = 22
es_temperatura_confortable = 20 <= temperatura <= 25
print(f"¿La temperatura es confortable? {es_temperatura_confortable}")  # True

# Verificando calificaciones
calificacion = 85
es_notable = 70 < calificacion <= 90
print(f"¿La calificación es notable? {es_notable}")  # True

Esta característica hace que el código sea más legible y cercano al lenguaje natural.

Comparación de objetos

Cuando comparamos objetos más complejos, es importante entender la diferencia entre igualdad de valor e igualdad de identidad:

# Comparando listas
lista1 = [1, 2, 3]
lista2 = [1, 2, 3]
lista3 = lista1

# Igualdad de valor (==): ¿Tienen el mismo contenido?
print(f"lista1 == lista2: {lista1 == lista2}")  # True (mismo contenido)

# Igualdad de identidad (is): ¿Son el mismo objeto en memoria?
print(f"lista1 is lista2: {lista1 is lista2}")  # False (diferentes objetos)
print(f"lista1 is lista3: {lista1 is lista3}")  # True (mismo objeto)

# El operador 'is' compara identidad, no valor
a = 1000
b = 1000
print(f"a == b: {a == b}")  # True (mismo valor)
print(f"a is b: {a is b}")  # False (diferentes objetos)

# Nota: Para pequeños enteros (-5 a 256), Python puede reutilizar objetos
c = 5
d = 5
print(f"c is d: {c is d}")  # True (Python reutiliza pequeños enteros)

Comparaciones en contextos reales

Veamos algunos ejemplos prácticos de cómo se utilizan los operadores de comparación en situaciones cotidianas:

# Sistema de descuentos
total_compra = 120
descuento_aplicado = total_compra > 100
print(f"¿Se aplica descuento? {descuento_aplicado}")  # True

# Verificación de edad para diferentes categorías
edad = 16
es_niño = edad < 13
es_adolescente = 13 <= edad < 18
es_adulto = edad >= 18

print(f"¿Es niño? {es_niño}")  # False
print(f"¿Es adolescente? {es_adolescente}")  # True
print(f"¿Es adulto? {es_adulto}")  # False

# Comprobación de contraseña
contraseña_ingresada = "secreto123"
contraseña_correcta = "secreto123"
acceso_permitido = contraseña_ingresada == contraseña_correcta
print(f"¿Acceso permitido? {acceso_permitido}")  # True

Visualización de operadores de comparación

Para entender mejor cómo funcionan los operadores de comparación, podemos visualizarlos en una recta numérica:

• Igual (==): Los valores están en el mismo punto.

• 5 == 5 ✓

• 5 == 7 ✗

• Distinto (!=): Los valores están en puntos diferentes.

• 5 != 7 ✓

• 5 != 5 ✗

• Mayor que (>): El primer valor está a la derecha del segundo en la recta numérica.

• 7 > 5 ✓

• 5 > 7 ✗

• Menor que (<): El primer valor está a la izquierda del segundo en la recta numérica.

• 5 < 7 ✓

• 7 < 5 ✗

• Mayor o igual (>=): El primer valor está a la derecha o en el mismo punto que el segundo.

• 7 >= 5 ✓

• 5 >= 5 ✓

• 5 >= 7 ✗

• Menor o igual (<=): El primer valor está a la izquierda o en el mismo punto que el segundo.

• 5 <= 7 ✓

• 5 <= 5 ✓

• 7 <= 5 ✗

Casos especiales de comparación

Existen algunos casos especiales que vale la pena mencionar:

# Comparación con None
variable = None
print(f"variable == None: {variable == None}")  # True
print(f"variable is None: {variable is None}")  # True (preferido)

# Comparación de cadenas vacías y cero
print(f"'' == 0: {'' == 0}")  # False (diferentes tipos)
print(f"'' == False: {'' == False}")  # False (diferentes tipos)
print(f"bool(''): {bool('')}")  # False (cadena vacía evalúa a False)
print(f"bool(0): {bool(0)}")  # False (cero evalúa a False)

# Comparación de NaN (Not a Number)
from math import nan
print(f"nan == nan: {nan == nan}")  # False (NaN nunca es igual a nada, ni a sí mismo)
print(f"nan != nan: {nan != nan}")  # True

Uso de comparaciones en estructuras de control

Las comparaciones son especialmente útiles en estructuras de control como condicionales:

# Ejemplo de uso en una estructura if-elif-else
temperatura = 28

if temperatura < 10:
    print("Hace mucho frío")
elif temperatura < 20:
    print("Está fresco")
elif temperatura < 30:
    print("Temperatura agradable")  # Esta se ejecutará
else:
    print("Hace calor")

# Ejemplo con múltiples condiciones
hora = 14
dia_laboral = True

if (8 <= hora < 18) and dia_laboral:
    print("Estamos en horario de trabajo")  # Esta se ejecutará
else:
    print("Estamos fuera del horario de trabajo")

Los operadores de comparación son herramientas fundamentales que nos permiten tomar decisiones en nuestros programas, haciendo que nuestro código pueda responder de manera diferente según las condiciones que se cumplan.

Operadores lógicos

Los operadores lógicos en Python nos permiten combinar condiciones y evaluar expresiones booleanas. Funcionan como conectores que nos ayudan a tomar decisiones basadas en múltiples criterios, similar a cómo razonamos en la vida diaria cuando evaluamos varias condiciones para tomar una decisión.

Los tres operadores lógicos principales

Python tiene tres operadores lógicos fundamentales:

• and: Devuelve True si ambas condiciones son verdaderas.
• or: Devuelve True si al menos una de las condiciones es verdadera.
• not: Invierte el valor booleano (cambia True a False y viceversa).

Estos operadores trabajan con valores booleanos (True y False) y siguen las reglas de la lógica booleana.

Operador and

El operador and funciona como un "Y" lógico. Para que una expresión con and sea verdadera, todas las condiciones deben ser verdaderas.

# Ejemplo: Requisitos para obtener un préstamo
ingresos_suficientes = True
buen_historial_crediticio = True

aprobacion_prestamo = ingresos_suficientes and buen_historial_crediticio
print(f"¿Préstamo aprobado? {aprobacion_prestamo}")  # True, ambas condiciones son verdaderas

Pensemos en el operador and como una cadena: si cualquier eslabón se rompe (es False), toda la cadena falla.

# Ejemplo: Verificando si un número está en un rango
numero = 15
en_rango = numero > 10 and numero < 20
print(f"¿El número {numero} está entre 10 y 20? {en_rango}")  # True

# Ejemplo: Verificando requisitos para una oferta de trabajo
años_experiencia = 3
conoce_python = True
conoce_sql = False

cumple_requisitos = años_experiencia >= 2 and conoce_python and conoce_sql
print(f"¿Cumple todos los requisitos? {cumple_requisitos}")  # False (no conoce SQL)

Operador or

El operador or funciona como un "O" lógico. Para que una expresión con or sea verdadera, al menos una de las condiciones debe ser verdadera.

# Ejemplo: Acceso a un evento
es_socio = False
tiene_invitacion = True

puede_entrar = es_socio or tiene_invitacion
print(f"¿Puede entrar al evento? {puede_entrar}")  # True, tiene invitación

Podemos pensar en el operador or como múltiples caminos para llegar a un destino: si al menos uno está disponible, podemos llegar.

# Ejemplo: Descuento en una tienda
es_cliente_frecuente = False
es_primera_compra = False
gasto_superior_100 = True

aplica_descuento = es_cliente_frecuente or es_primera_compra or gasto_superior_100
print(f"¿Aplica para descuento? {aplica_descuento}")  # True, por gasto superior a 100

Operador not

El operador not invierte el valor de una expresión booleana, convirtiendo True en False y viceversa.

# Ejemplo: Verificando si un producto no está disponible
disponible = False
no_disponible = not disponible
print(f"¿El producto no está disponible? {no_disponible}")  # True

# Ejemplo: Verificando si un número es impar
numero = 7
es_par = numero % 2 == 0
es_impar = not es_par
print(f"¿El número {numero} es impar? {es_impar}")  # True

El operador not es útil para invertir condiciones y hacer el código más legible en ciertos contextos.

Tablas de verdad

Para entender mejor cómo funcionan estos operadores, podemos visualizarlos mediante tablas de verdad:

Tabla de verdad para and:

Tabla de verdad para or:

Tabla de verdad para not:

Combinando operadores lógicos

Podemos combinar varios operadores lógicos para crear condiciones más complejas:

# Ejemplo: Sistema de acceso a una aplicación
usuario_registrado = True
contraseña_correcta = True
cuenta_bloqueada = False

puede_acceder = usuario_registrado and contraseña_correcta and not cuenta_bloqueada
print(f"¿Puede acceder al sistema? {puede_acceder}")  # True

# Ejemplo: Elegibilidad para un programa
edad = 25
es_estudiante = False
ingresos_bajos = True

es_elegible = (edad < 30 and es_estudiante) or ingresos_bajos
print(f"¿Es elegible para el programa? {es_elegible}")  # True, por ingresos bajos

Precedencia de operadores lógicos

Al igual que con los operadores aritméticos, los operadores lógicos siguen un orden de precedencia:

1. not (mayor precedencia)
2. and
3. or (menor precedencia)

Cuando tenemos dudas sobre el orden de evaluación, es recomendable usar paréntesis para hacer el código más claro:

# Sin paréntesis (puede ser confuso)
resultado = True or False and False
print(f"Resultado sin paréntesis: {resultado}")  # True

# Con paréntesis (más claro)
resultado1 = True or (False and False)  # and se evalúa primero
print(f"Resultado con paréntesis (1): {resultado1}")  # True

resultado2 = (True or False) and False
print(f"Resultado con paréntesis (2): {resultado2}")  # False

Cortocircuito en operadores lógicos

Python implementa la evaluación de cortocircuito para los operadores lógicos, lo que significa que no evalúa todas las expresiones si ya puede determinar el resultado:

• Para and: Si la primera expresión es False, Python no evalúa la segunda (ya sabe que el resultado será False).
• Para or: Si la primera expresión es True, Python no evalúa la segunda (ya sabe que el resultado será True).

# Ejemplo de cortocircuito con and
x = 5
# La segunda parte no se evalúa porque la primera es False
if x > 10 and x/0 > 1:  # No da error de división por cero
    print("Esto no se imprimirá")

# Ejemplo de cortocircuito con or
y = 20
# La segunda parte no se evalúa porque la primera es True
if y > 10 or y/0 > 1:  # No da error de división por cero
    print("Esto se imprimirá")

Este comportamiento es muy útil para evitar errores y optimizar el rendimiento.

Operadores lógicos con valores no booleanos

En Python, los operadores lógicos pueden trabajar con valores no booleanos. En estos casos:

• and devuelve el primer valor falso o el último valor si todos son verdaderos.
• or devuelve el primer valor verdadero o el último valor si todos son falsos.

Python considera los siguientes valores como False:

• False
• None
• 0 (cero)
• "" (cadena vacía)
• [] (lista vacía)
• () (tupla vacía)
• {} (diccionario vacío)
• set() (conjunto vacío)

Cualquier otro valor se considera True.

# Ejemplos con valores no booleanos
print(f"0 and 5: {0 and 5}")  # 0 (primer valor falso)
print(f"5 and 0: {5 and 0}")  # 0 (primer valor falso)
print(f"2 and 5: {2 and 5}")  # 5 (último valor, todos son verdaderos)

print(f"0 or 5: {0 or 5}")  # 5 (primer valor verdadero)
print(f"5 or 0: {5 or 0}")  # 5 (primer valor verdadero)
print(f"0 or '': {0 or ''}")  # '' (último valor, todos son falsos)

Aplicaciones prácticas

Los operadores lógicos son fundamentales en la programación para tomar decisiones basadas en múltiples condiciones:

# Ejemplo: Sistema de recomendación de películas
le_gustan_accion = True
le_gustan_comedia = False
le_gustan_drama = True

pelicula_accion = "John Wick"
pelicula_comedia = "Superbad"
pelicula_drama = "El Padrino"
pelicula_accion_drama = "Gladiador"

# Recomendación basada en preferencias
if le_gustan_accion and le_gustan_drama:
    recomendacion = pelicula_accion_drama
elif le_gustan_accion:
    recomendacion = pelicula_accion
elif le_gustan_comedia:
    recomendacion = pelicula_comedia
elif le_gustan_drama:
    recomendacion = pelicula_drama
else:
    recomendacion = "No tenemos recomendaciones para ti"

print(f"Te recomendamos ver: {recomendacion}")  # Te recomendamos ver: Gladiador

Visualización de operadores lógicos

Para entender mejor cómo funcionan los operadores lógicos, podemos visualizarlos con diagramas de Venn:

• and: Representa la intersección de dos conjuntos (área donde ambos conjuntos se superponen).
• or: Representa la unión de dos conjuntos (área total cubierta por ambos conjuntos).
• not: Representa el complemento de un conjunto (todo lo que no está en el conjunto).

Pensemos en un ejemplo con frutas:

• Conjunto A: Frutas rojas (manzana, fresa, cereza)
• Conjunto B: Frutas dulces (plátano, manzana, uva)

• A and B: Frutas que son rojas y dulces (manzana)
• A or B: Frutas que son rojas o dulces (manzana, fresa, cereza, plátano, uva)
• not A: Frutas que no son rojas (plátano, uva, naranja, etc.)

Uso en estructuras de control

Los operadores lógicos son especialmente útiles en estructuras de control como condicionales y bucles:

# Ejemplo: Sistema de calificaciones
calificacion = 85
asistencia = 90

# Evaluación basada en múltiples criterios
if calificacion >= 90 and asistencia >= 85:
    resultado = "Excelente"
elif calificacion >= 80 and asistencia >= 75:
    resultado = "Muy bien"
elif calificacion >= 70 or asistencia >= 90:
    resultado = "Bien"
else:
    resultado = "Necesita mejorar"

print(f"Evaluación final: {resultado}")  # Evaluación final: Muy bien

# Ejemplo: Validación de entrada de usuario
edad_str = "25"
if edad_str.isdigit() and 0 <= int(edad_str) <= 120:
    print(f"Edad válida: {edad_str} años")
else:
    print("Por favor, introduce una edad válida (0-120)")

Los operadores lógicos son herramientas poderosas que nos permiten expresar condiciones complejas de manera clara y concisa, haciendo que nuestro código sea más legible y eficiente.

Operadores de asignación compuesta

Los operadores de asignación compuesta en Python combinan una operación aritmética con una asignación en un solo paso. Estos operadores nos permiten actualizar el valor de una variable de forma más concisa, similar a cuando ajustamos un presupuesto o actualizamos un contador en la vida cotidiana.

Sintaxis básica

En lugar de escribir variable = variable operador valor, podemos usar la forma abreviada variable operador= valor. Esta sintaxis no solo hace que el código sea más compacto, sino también más legible y menos propenso a errores.

Python ofrece los siguientes operadores de asignación compuesta:

• +=: Suma y asigna
• -=: Resta y asigna
• ***=**: Multiplica y asigna
• /=: Divide y asigna
• //=: Divide (división entera) y asigna
• %=: Calcula el módulo y asigna
• ****=**: Eleva a potencia y asigna

Operador de suma y asignación (+=)

El operador += suma un valor a la variable y guarda el resultado en la misma variable:

# Incrementando un contador de pasos
pasos = 0
print(f"Pasos iniciales: {pasos}")

# Añadimos 2000 pasos tras caminar por la mañana
pasos += 2000
print(f"Pasos después de caminar por la mañana: {pasos}")  # 2000

# Añadimos 3500 pasos más por la tarde
pasos += 3500
print(f"Total de pasos al final del día: {pasos}")  # 5500

Este operador es especialmente útil para acumuladores o cuando necesitamos ir sumando valores progresivamente.

Operador de resta y asignación (-=)

El operador -= resta un valor de la variable y almacena el resultado:

# Control de inventario
inventario_manzanas = 100
print(f"Inventario inicial: {inventario_manzanas} manzanas")

# Vendemos 15 manzanas
inventario_manzanas -= 15
print(f"Inventario tras primera venta: {inventario_manzanas} manzanas")  # 85

# Vendemos 25 manzanas más
inventario_manzanas -= 25
print(f"Inventario actual: {inventario_manzanas} manzanas")  # 60

Este operador es ideal para decrementar valores o llevar un control de recursos que se van consumiendo.

Operador de multiplicación y asignación (*=)

El operador *= multiplica la variable por un valor y guarda el resultado:

# Cálculo de interés compuesto simplificado
capital = 1000
tasa_interes = 1.05  # 5% de interés

# Después de 1 año
capital *= tasa_interes
print(f"Capital después de 1 año: {round(capital, 2)} euros")  # 1050.0

# Después de otro año
capital *= tasa_interes
print(f"Capital después de 2 años: {round(capital, 2)} euros")  # 1102.5

Este operador es útil para factores de crecimiento o cuando necesitamos aplicar un multiplicador varias veces.

Operador de división y asignación (/=)

El operador /= divide la variable por un valor y asigna el resultado:

# Dividiendo una pizza
pizza_completa = 8  # 8 porciones
print(f"Porciones iniciales: {pizza_completa}")

# Compartimos la mitad con amigos
pizza_completa /= 2
print(f"Porciones restantes: {pizza_completa}")  # 4.0

# Compartimos la mitad de lo que queda con familia
pizza_completa /= 2
print(f"Porciones finales: {pizza_completa}")  # 2.0

Nota que este operador siempre devuelve un número flotante, incluso si el resultado es un número entero.

Operador de división entera y asignación (//=)

El operador //= realiza una división entera y asigna el resultado:

# Distribución de recursos en grupos completos
recursos = 47
tamaño_grupo = 5

# Asignamos recursos a grupos completos
grupos_completos = recursos
grupos_completos //= tamaño_grupo
print(f"Podemos formar {grupos_completos} grupos completos")  # 9

# Recursos sobrantes
recursos_sobrantes = recursos % tamaño_grupo
print(f"Sobran {recursos_sobrantes} recursos")  # 2

Este operador es útil cuando necesitamos trabajar con cantidades enteras y descartar fracciones.

Operador de módulo y asignación (%=)

El operador %= calcula el resto de la división y asigna ese valor:

# Simulando un reloj de 12 horas
hora_actual = 10
print(f"Hora actual: {hora_actual}")

# Avanzamos 5 horas
hora_actual += 5
hora_actual %= 12  # Si pasa de 12, vuelve a empezar
print(f"Hora después de 5 horas: {hora_actual}")  # 3

# Avanzamos 10 horas más
hora_actual += 10
hora_actual %= 12
print(f"Hora después de otras 10 horas: {hora_actual}")  # 1

Este operador es perfecto para ciclos o cuando necesitamos mantener un valor dentro de un rango específico.

Operador de exponenciación y asignación (**=)

El operador **= eleva la variable a una potencia y asigna el resultado:

# Crecimiento exponencial
bacteria = 1  # Comenzamos con 1 bacteria
print(f"Población inicial: {bacteria} bacteria")

# Cada bacteria se divide en 2 cada hora
# Después de 1 hora
bacteria **= 2
print(f"Población después de 1 hora: {bacteria} bacterias")  # 2

# Después de otra hora
bacteria **= 2
print(f"Población después de 2 horas: {bacteria} bacterias")  # 4

# Después de otra hora más
bacteria **= 2
print(f"Población después de 3 horas: {bacteria} bacterias")  # 16

Este operador es útil para modelar crecimientos exponenciales o calcular potencias sucesivas.

Uso con diferentes tipos de datos

Los operadores de asignación compuesta también funcionan con otros tipos de datos, no solo con números:

# Concatenación de cadenas con +=
mensaje = "Hola"
mensaje += " mundo"
mensaje += "!"
print(mensaje)  # "Hola mundo!"

# Multiplicación de cadenas con *=
patron = "-"
patron *= 10
print(patron)  # "----------"

# Listas con +=
carrito_compra = ["manzanas", "leche"]
print(f"Carrito inicial: {carrito_compra}")

carrito_compra += ["pan", "huevos"]
print(f"Carrito actualizado: {carrito_compra}")  # ['manzanas', 'leche', 'pan', 'huevos']

Aplicaciones prácticas

Los operadores de asignación compuesta son especialmente útiles en bucles y cuando necesitamos actualizar valores repetidamente:

# Calculando el factorial de un número
numero = 5
factorial = 1

for i in range(1, numero + 1):
    factorial *= i

print(f"El factorial de {numero} es {factorial}")  # 120

# Generando una secuencia Fibonacci
a, b = 0, 1
secuencia = [a, b]

for _ in range(8):  # Generamos 8 números más
    a, b = b, a + b
    secuencia.append(b)

print(f"Secuencia Fibonacci: {secuencia}")  # [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

Visualización de operadores de asignación compuesta

Para entender mejor cómo funcionan estos operadores, podemos visualizarlos como acciones cotidianas:

• +=: Como añadir más agua a un vaso medio lleno
• -=: Como sacar dinero de una cuenta bancaria
• ***=**: Como duplicar una receta para más personas
• /=: Como repartir un pastel entre varias personas
• //=: Como formar equipos completos con un grupo de personas
• %=: Como el ciclo de las manecillas de un reloj
• ****=**: Como el efecto dominó donde cada ficha derriba más que la anterior

Comparación con la forma extendida

Para apreciar la ventaja de los operadores de asignación compuesta, comparemos con la forma extendida:

# Forma extendida
contador = 0
contador = contador + 1
contador = contador + 2
contador = contador + 3
print(f"Contador (forma extendida): {contador}")  # 6

# Forma compacta con operadores de asignación compuesta
contador = 0
contador += 1
contador += 2
contador += 3
print(f"Contador (forma compacta): {contador}")  # 6

La forma compacta no solo es más corta, sino que también reduce la posibilidad de errores al no tener que repetir el nombre de la variable.

Ejemplo integrado: Simulación de cuenta bancaria

Veamos un ejemplo que integra varios operadores de asignación compuesta:

# Simulación simple de una cuenta bancaria
saldo = 1000
print(f"Saldo inicial: {saldo} euros")

# Ingreso de nómina
saldo += 1200
print(f"Saldo tras ingreso de nómina: {saldo} euros")  # 2200

# Pago de alquiler
saldo -= 650
print(f"Saldo tras pago de alquiler: {saldo} euros")  # 1550

# Interés mensual (0.2%)
saldo *= 1.002
print(f"Saldo tras aplicar interés: {round(saldo, 2)} euros")  # 1553.1

# Dividimos el saldo para diferentes gastos
presupuesto_semanal = saldo
presupuesto_semanal /= 4  # Dividimos para 4 semanas
print(f"Presupuesto semanal: {round(presupuesto_semanal, 2)} euros")  # 388.28

Este ejemplo muestra cómo los operadores de asignación compuesta pueden hacer que el código sea más legible y natural, especialmente cuando estamos modelando situaciones del mundo real donde los valores se actualizan constantemente.