➕ Parte 1 – Operadores Aritméticos en Python

Los operadores aritméticos son los cimientos de cualquier lenguaje de programación.
En Python, te permiten realizar operaciones matemáticas básicas como suma, resta, multiplicación o división,
pero también cálculos más avanzados como exponenciación o división entera.

A diferencia de otros lenguajes como C o Java, en Python no necesitas declarar tipos:
el intérprete detecta automáticamente si estás trabajando con enteros (int), decimales (float)
o números complejos (complex).

🧮 Operadores aritméticos básicos

💻 Ejemplo práctico

# Operaciones básicas
a = 10
b = 3

print("Suma:", a + b)
print("Resta:", a - b)
print("Multiplicación:", a * b)
print("División:", a / b)
print("División entera:", a // b)
print("Resto:", a % b)
print("Potencia:", a ** b)

Salida:

Suma: 13
Resta: 7
Multiplicación: 30
División: 3.3333333333333335
División entera: 3
Resto: 1
Potencia: 1000

💡 Consejo: en Python 3, el operador / siempre devuelve un número decimal (float), incluso si el resultado es exacto.

⚙️ División y sus variantes

Python te permite manejar divisiones de diferentes maneras según lo que necesites:

• / → Devuelve un número decimal (float).
• // → Devuelve un número entero (redondea hacia abajo).
• % → Devuelve el resto o residuo.

x = 17
y = 5

print(x / y)   # 3.4
print(x // y)  # 3
print(x % y)   # 2

Esto es muy útil, por ejemplo, para calcular horas y minutos:

# Calcular horas y minutos a partir de segundos
segundos = 3670
horas = segundos // 3600
minutos = (segundos % 3600) // 60
resto = segundos % 60

print(f"{horas}h {minutos}m {resto}s")

Resultado:

1h 1m 10s

📈 Exponenciación y raíces

El operador ** eleva un número a una potencia.
Si lo combinas con números decimales, puedes calcular raíces fácilmente.

# Potencia
print(2 ** 4)  # 16

# Raíz cuadrada (potencia fraccionaria)
print(9 ** 0.5)  # 3.0

# Raíz cúbica
print(27 ** (1/3))  # 3.0

También puedes usar el módulo math para obtener más precisión:

import math

print(math.pow(2, 4))  # 16.0
print(math.sqrt(81))   # 9.0

⚖️ Precedencia de operadores

Python evalúa las operaciones siguiendo un orden de prioridad, conocido como precedencia de operadores.
Los paréntesis siempre tienen la mayor prioridad.

resultado = 10 + 2 * 5 ** 2
print(resultado)  # 60

Desglose: primero se eleva 5² → 25, luego 2×25 → 50, finalmente 10+50 → 60.

🧮 Redondeo y precisión de decimales

Python usa aritmética de coma flotante (float), por lo que a veces aparecen resultados con pequeñas imprecisiones.

print(0.1 + 0.2)  # 0.30000000000000004

Para controlar esto puedes usar:

# Redondear con round()
print(round(0.1 + 0.2, 2))  # 0.3

# Usar Decimal para precisión exacta
from decimal import Decimal
resultado = Decimal('0.1') + Decimal('0.2')
print(resultado)  # 0.3

🧩 Mini práctica guiada

Ejercicio para tus alumnos 👇

# Calculadora básica
a = float(input("Introduce el primer número: "))
b = float(input("Introduce el segundo número: "))

print("Suma:", a + b)
print("Resta:", a - b)
print("Producto:", a * b)
print("División:", a / b)
print("División entera:", a // b)
print("Resto:", a % b)
print("Potencia:", a ** b)

💬 Reto adicional: crea un script que convierta segundos a horas, minutos y segundos, usando // y %.

⚖️ Parte 2 – Operadores de Comparación

Los operadores de comparación permiten comparar valores y determinar relaciones entre ellos.
El resultado de cualquier comparación en Python es un valor booleano: True (verdadero) o False (falso).
Son fundamentales en las estructuras de control (if, while, etc.), ya que deciden qué camino tomará el programa.

📘 Tipos de operadores de comparación

🔢 Comparaciones numéricas

Puedes comparar cualquier tipo numérico: enteros, flotantes o complejos (aunque estos últimos solo admiten igualdad o desigualdad).

a = 10
b = 5
c = 10.0

print(a == b)   # False
print(a == c)   # True → Python compara por valor, no por tipo exacto
print(a > b)    # True
print(a <= c)   # True

💡 Tip: Python considera 10 y 10.0 como iguales en valor, aunque tengan distinto tipo (int vs float).

🧮 Comparaciones de igualdad y cadenas

También puedes comparar cadenas de texto. Python compara alfabéticamente según el código Unicode de cada carácter.

print("hola" == "hola")    # True
print("Hola" == "hola")    # False (mayúsculas ≠ minúsculas)
print("a" < "b")           # True (alfabéticamente antes)
print("abc" < "abd")       # True

Si deseas comparar sin importar mayúsculas o minúsculas, puedes usar .lower() o .casefold():

nombre1 = "Python"
nombre2 = "python"

print(nombre1.lower() == nombre2.lower())   # True

🔗 Comparaciones encadenadas

Python permite encadenar comparaciones de forma natural, sin necesidad de usar operadores lógicos:

x = 5

print(1 < x < 10)   # True → 1 < x y x < 10
print(x < 10 < 20)  # True
print(x == 5 == 5.0)  # True → compara todos los valores secuencialmente

Este formato mejora la legibilidad y evita escribir expresiones largas como (1 < x) and (x < 10).

🧠 Comparación de objetos y tipos personalizados

Los operadores de comparación también funcionan con objetos definidos por el usuario,
siempre que implementen los métodos mágicos (__eq__, __lt__, etc.).

class Persona:
    def __init__(self, nombre, edad):
        self.nombre = nombre
        self.edad = edad

    def __eq__(self, other):
        return self.edad == other.edad

p1 = Persona("Javier", 30)
p2 = Persona("Lucía", 30)
p3 = Persona("Carlos", 25)

print(p1 == p2)  # True → edades iguales
print(p1 == p3)  # False

Este ejemplo demuestra que la igualdad puede redefinirse según el contexto de tu programa.

📊 Tabla resumen de comparación

🧩 Mini práctica guiada

# Comparador de edades
edad = int(input("Introduce tu edad: "))

if edad < 18:
    print("Eres menor de edad.")
elif edad < 65:
    print("Eres adulto.")
else:
    print("Eres jubilado.")

💬 Reto adicional: pide dos números y muestra cuál es mayor, menor o si son iguales.

🔗 Parte 3 – Operadores Lógicos en Python (and, or, not)

Los operadores lógicos permiten combinar o negar condiciones booleanas.
Son esenciales para la toma de decisiones en estructuras como if, while o en expresiones más complejas.

En Python, las expresiones lógicas devuelven un valor True o False, y pueden aplicarse tanto a valores booleanos como a otros tipos de datos (números, cadenas, listas, etc.).

📊 Tablas de verdad

and — (Y lógico)

or — (O lógico)

not — (Negación lógica)

⚙️ Precedencia de los operadores lógicos

Cuando se combinan varios operadores lógicos en una sola expresión,
Python evalúa primero not, luego and y por último or.

💡 Para evitar confusiones, usa siempre paréntesis cuando combines varios operadores:

edad = 25
licencia = True

if (edad >= 18) and licencia:
    print("Puedes conducir 🚗")
else:
    print("No puedes conducir ❌")

Salida:

Puedes conducir 🚗

⚡ Evaluación de cortocircuito

Python evalúa las expresiones lógicas de izquierda a derecha y detiene la evaluación tan pronto como conoce el resultado.
Esto se llama evaluación de cortocircuito.

def prueba():
    print("Ejecutando función...")
    return True

# Como el primer operando es False, el segundo nunca se evalúa
print(False and prueba())  # No ejecuta prueba()

# Como el primer operando es True, el segundo tampoco se evalúa
print(True or prueba())    # No ejecuta prueba()

Esto mejora el rendimiento y evita errores innecesarios, por ejemplo:

usuario = None

# Evita error: no intenta acceder a .upper() si usuario es None
if usuario and usuario.upper() == "JAVIER":
    print("Bienvenido, Javier")

🔢 Operadores lógicos con valores no booleanos

En Python, los operadores lógicos no se limitan a True o False:
pueden devolver directamente el valor de los operandos.
Esto ocurre porque todo objeto tiene un valor de verdad (truthy o falsy).

Ejemplos prácticos:

nombre = "Javier"
edad = 0

print(nombre and edad)   # → 0 (porque edad es falsy)
print(edad or nombre)    # → "Javier" (devuelve el primero truthy)
print(not nombre)        # → False

💬 Ejemplo real — Sistema de acceso

usuario = input("Usuario: ")
password = input("Contraseña: ")

if usuario == "admin" and password == "1234":
    print("✅ Acceso concedido.")
else:
    print("❌ Usuario o contraseña incorrectos.")

Salida:

Usuario: admin
Contraseña: 1234
✅ Acceso concedido.

🧩 Ejemplo combinado — Condiciones anidadas

Veamos un ejemplo que combina and, or y not:

edad = int(input("Edad: "))
tiene_licencia = input("¿Tienes licencia? (s/n): ").lower() == "s"

if (edad >= 18 and tiene_licencia) or edad >= 70:
    print("✅ Puedes conducir.")
else:
    print("❌ No puedes conducir.")

Este programa permite conducir si la persona tiene 18 o más años y licencia,
o si tiene más de 70 años (por ejemplo, con licencia especial).

🧠 Diferencias entre and y && (Java, C++)

En otros lenguajes como Java o C++, se usa && y || para operadores lógicos.
Python simplifica la sintaxis y utiliza directamente palabras clave (and, or, not) por legibilidad.

📘 Buenas prácticas

• Evita expresiones lógicas muy largas. Divide en pasos o usa variables intermedias.
• Usa paréntesis para aclarar la intención.
• Recuerda que las condiciones se evalúan de izquierda a derecha (cortocircuito).
• No abuses del operador not: puede dificultar la lectura si se encadena varias veces.

🧩 Mini práctica guiada

# Evaluador de acceso
edad = int(input("Edad: "))
dni = input("¿Tienes DNI? (s/n): ").lower() == "s"

if edad >= 18 and dni:
    print("✅ Puedes votar.")
else:
    print("❌ No puedes votar todavía.")

💬 Reto adicional: Crea un programa que determine si un número es positivo y par,
usando and y % (módulo).

🧱 Parte 4 – Operadores de Asignación Compuesta en Python

Los operadores de asignación sirven para almacenar valores en variables,
pero Python ofrece una forma más compacta de actualizar esos valores sin repetir el nombre de la variable.
Estos son los llamados operadores de asignación compuesta.

Por ejemplo, en lugar de escribir:

x = x + 1

podemos escribir simplemente:

x += 1

Ambas expresiones tienen el mismo efecto, pero la segunda es más limpia y rápida de leer.

⚙️ Sintaxis básica

El formato general de un operador de asignación compuesta es:

variable operador= expresión

Donde el operador puede ser +, -, *, /, %, etc.

💻 Ejemplo práctico básico

x = 10

x += 5   # x = 10 + 5
x -= 2   # x = 15 - 2
x *= 3   # x = 13 * 3
x /= 4   # x = 39 / 4

print(x)

Resultado:

9.75

Cada operación actualiza la variable x sin tener que escribirla dos veces.
Esto es especialmente útil dentro de bucles o programas con muchas actualizaciones de valores.

🧮 Comparación con la forma extendida

Ambos métodos son equivalentes, pero la forma compuesta mejora la legibilidad y reduce errores.

# Forma extendida
contador = 0
contador = contador + 1

# Forma compuesta
contador += 1

👉 Ambas producen el mismo resultado, pero la segunda es más “pythónica”.

🏦 Ejemplo integrado: simulador de cuenta bancaria

Vamos a construir un pequeño programa que use operadores de asignación para simular
el comportamiento de una cuenta bancaria.

saldo = 1000.0  # Saldo inicial

print("Saldo inicial:", saldo)

# Depósito
deposito = float(input("¿Cuánto deseas depositar? "))
saldo += deposito
print("Nuevo saldo:", saldo)

# Retiro
retiro = float(input("¿Cuánto deseas retirar? "))
saldo -= retiro
print("Saldo tras retiro:", saldo)

# Interés del 2%
saldo *= 1.02
print("Saldo tras aplicar interés del 2%:", round(saldo, 2))

Este ejemplo usa +=, -= y *= para reflejar cambios en el saldo sin reescribir la variable.
También es una oportunidad para practicar entrada de datos y redondeo.

🧩 Ejemplo: contador de iteraciones

El operador += es muy común en bucles, especialmente para contadores o acumuladores.

contador = 0

for i in range(1, 6):
    contador += i
    print(f"Iteración {i}, contador = {contador}")

print("Suma total:", contador)

Salida:

Iteración 1, contador = 1
Iteración 2, contador = 3
Iteración 3, contador = 6
Iteración 4, contador = 10
Iteración 5, contador = 15
Suma total: 15

💡 Este patrón aparece constantemente en programación: sumar, multiplicar, o concatenar valores dentro de un ciclo.

🧠 Asignación con cadenas y listas

Los operadores de asignación también funcionan con otros tipos de datos como cadenas (str) o listas (list).

# Con cadenas
mensaje = "Hola"
mensaje += " Pythonista!"
print(mensaje)  # Hola Pythonista!

# Con listas
numeros = [1, 2, 3]
numeros += [4, 5]
print(numeros)  # [1, 2, 3, 4, 5]

En el caso de las listas, += funciona igual que extend(),
agregando los elementos de una lista dentro de otra.

📊 Resumen de operadores de asignación

💬 Mini práctica guiada

# Calculadora de puntos
puntos = 0

print("Bienvenido al juego 🕹️")
puntos += 10
print("Has ganado 10 puntos.")
puntos *= 2
print("¡Doble puntuación!")
puntos -= 5
print("Pierdes 5 puntos por error.")
print("Puntuación final:", puntos)

💬 Reto adicional: crea un script que calcule el ahorro mensual usando += dentro de un bucle for.

🧩 Parte 5 – Operadores de Pertenencia e Identidad

Python incluye dos grupos de operadores muy útiles que van más allá de las operaciones matemáticas o lógicas:
los operadores de pertenencia y los operadores de identidad.
Ambos ayudan a verificar relaciones entre objetos, valores y estructuras de datos.

🔍 Operadores de Pertenencia — in y not in

Los operadores de pertenencia sirven para comprobar si un elemento se encuentra (o no) dentro de una secuencia
como una lista, cadena, tupla, conjunto o diccionario.

Estos operadores se usan frecuentemente para comprobar pertenencia en listas, textos o diccionarios.

# En cadenas
print("p" in "python")       # True
print("z" not in "python")   # True

# En listas
numeros = [10, 20, 30, 40]
print(20 in numeros)         # True
print(50 not in numeros)     # True

# En diccionarios (verifica claves)
edades = {"Ana": 25, "Luis": 30}
print("Ana" in edades)       # True
print("Pedro" not in edades) # True

💡 Ejemplo práctico — Verificar acceso

Usando in y not in, podemos verificar si un usuario tiene permisos o si una palabra clave está en un texto:

usuarios_autorizados = ["admin", "soporte", "javier"]

usuario = input("Introduce tu usuario: ")

if usuario in usuarios_autorizados:
    print("✅ Acceso permitido.")
else:
    print("❌ Acceso denegado.")

💬 Pro tip: El operador in es ideal para búsquedas rápidas y legibles.
Internamente, Python recorre las estructuras hasta encontrar coincidencias.

📦 Aplicaciones comunes de in

• Comprobar si un elemento está en una lista, conjunto o tupla.
• Buscar caracteres o subcadenas en una cadena.
• Verificar claves dentro de un diccionario.
• Controlar accesos o validaciones dentro de estructuras de datos.

🧠 Operadores de Identidad — is y is not

Los operadores de identidad sirven para comprobar si dos variables apuntan al mismo objeto en memoria.
No comparan valores, sino la identidad del objeto.

💬 Es común confundir is con ==, pero no son lo mismo:

# Comparación por valor (==)
x = [1, 2, 3]
y = [1, 2, 3]
print(x == y)   # True → los valores son iguales
print(x is y)   # False → son objetos distintos en memoria

# Asignación a la misma referencia
z = x
print(x is z)   # True → apuntan al mismo objeto

🔬 Ejemplo con tipos inmutables

Para tipos inmutables como int, str o tuple,
Python puede optimizar la memoria y hacer que algunos objetos compartan la misma referencia.

a = 10
b = 10
print(a is b)  # True (optimizados internamente)

texto1 = "Hola"
texto2 = "Hola"
print(texto1 is texto2)  # True → cadenas iguales internamente

Sin embargo, con listas, diccionarios u objetos personalizados, cada instancia tiene su propia dirección de memoria.

🧩 Ejemplo práctico — Comprobación con None

Un caso muy común de uso de is es verificar si una variable es None (sin valor asignado).

dato = None

if dato is None:
    print("⚠️ La variable no tiene valor todavía.")
else:
    print("✅ La variable contiene datos.")

💡 Usa siempre is None o is not None en lugar de == None,
porque es más seguro y claro semánticamente.

🧠 Comparación de identidad y valor

Veamos un resumen comparativo entre los operadores de igualdad (==) y los de identidad (is):

🏗️ Caso práctico — Gestión de objetos

Supón que tienes un programa que gestiona sesiones de usuarios y necesitas saber si dos variables apuntan al mismo usuario en memoria:

class Usuario:
    def __init__(self, nombre):
        self.nombre = nombre

u1 = Usuario("Javier")
u2 = Usuario("Javier")
u3 = u1

print(u1 == u2)  # False (a menos que se implemente __eq__)
print(u1 is u2)  # False → objetos diferentes
print(u1 is u3)  # True → misma instancia en memoria

El operador is es ideal para comprobar si dos variables apuntan exactamente al mismo objeto,
algo muy útil en patrones como “singleton”, cachés, o comparaciones con None.

📊 Tabla resumen final

🧩 Mini práctica guiada

# Programa de búsqueda
palabra = input("Introduce una palabra: ")

if "a" in palabra:
    print("✅ La palabra contiene la letra 'a'")
else:
    print("❌ No contiene la letra 'a'")

# Verificar identidad
x = None
if x is None:
    print("⚠️ Sin valor asignado")
else:
    print("✅ Variable inicializada")

💬 Reto adicional: crea una lista de productos y pregunta al usuario si un producto está disponible.
Usa in y not in para verificarlo.

🎓 Conclusión final del módulo

Con esta parte final, completamos el estudio de los operadores en Python:
aritméticos, de comparación, lógicos, de asignación, de pertenencia e identidad.
Cada uno de ellos cumple una función específica dentro del lenguaje y te permite escribir código más expresivo, eficiente y legible.

💡 Resumen:

• Aritméticos: realizan operaciones matemáticas.
• Comparación: comparan valores entre variables.
• Lógicos: combinan o niegan condiciones booleanas.
• Asignación: actualizan el valor de variables.
• Pertenencia: comprueban si un elemento está dentro de una colección.
• Identidad: verifican si dos variables apuntan al mismo objeto en memoria.

Has aprendido a combinarlos en expresiones, crear condiciones complejas, y aplicarlos a ejemplos reales.
Estos conocimientos serán la base de las estructuras de control (if, for, while) que veremos a continuación.

⬆️ Volver al índice

🐍 ¡Felicidades! Has completado la lección sobre Operadores en Python.