Estructuras de control en Python

1Condicionales¶

1.1Sintaxis `if`-`elif`-`else`¶

edad = 25
salario = 45000

if edad < 18:
    categoria = "menor"
elif edad < 65 and salario > 30000:
    categoria = "adulto solvente"
elif edad < 65:
    categoria = "adulto"
else:
    categoria = "jubilado"

print(f"Categoría: {categoria}")

1.2Operadores lógicos y comparación¶

x, y, z = 5, 10, 15

if x < y and y < z:  # && en Java/Go
    print("Orden ascendente")

if x == 5 or y == 5:  # || en Java/Go
    print("Alguno es 5")

if not (x > y):  # ! en Java/Go
    print("x no es mayor que y")

# Comparaciones encadenadas (única de Python)
if x < y < z:
    print("Orden ascendente (sintaxis pythónica)")

1.3Expresión condicional (operador ternario)¶

numero = 7

# Equivalente al operador ?: de Java/Go
resultado = "par" if numero % 2 == 0 else "impar"

print(f"El número {numero} es {resultado}")

El fragmento anterior es una forma concisa de asignar un valor basado en una condición. Es útil para asignaciones simples y mejora la legibilidad del código. Es equivalente a:

if numero % 2 == 0:
    resultado = "par"
else:
    resultado = "impar"

print(f"El número {numero} es {resultado}")

2Ciclos¶

2.1Ciclo `for`: iteración sobre secuencias¶

frutas = ["manzana", "banana", "naranja"]

# for-in: itera directamente sobre elementos (no índices)
for fruta in frutas:
    print(fruta)

frutas = ["manzana", "banana", "naranja"]

# Con índices usando enumerate()
for i, fruta in enumerate(frutas):
    print(f"{i}: {fruta}")

La función enumerate() es útil para obtener tanto el índice como el valor del elemento en una lista.

help(enumerate)

Help on class enumerate in module builtins:

class enumerate(object)
 |  enumerate(iterable, start=0)
 |
 |  Return an enumerate object.
 |
 |    iterable
 |      an object supporting iteration
 |
 |  The enumerate object yields pairs containing a count (from start, which
 |  defaults to zero) and a value yielded by the iterable argument.
 |
 |  enumerate is useful for obtaining an indexed list:
 |      (0, seq[0]), (1, seq[1]), (2, seq[2]), ...
 |
 |  Methods defined here:
 |
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |
 |  __iter__(self, /)
 |      Implement iter(self).
 |
 |  __next__(self, /)
 |      Implement next(self).
 |
 |  __reduce__(self, /)
 |      Return state information for pickling.
 |
 |  ----------------------------------------------------------------------
 |  Class methods defined here:
 |
 |  __class_getitem__(object, /)
 |      See PEP 585
 |
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |
 |  __new__(*args, **kwargs)
 |      Create and return a new object.  See help(type) for accurate signature.

frutas = ["manzana", "banana", "naranja"]

# Equivalente a for(int i=0; i<frutas.length; i++) en Java
for i in range(len(frutas)):
    print(f"{i}: {frutas[i]}")

2.2Función `range()` para ciclos numéricos¶

La función range() genera una secuencia de números, útil para ciclos for. Es como si generara una lista de números, pero de forma más eficiente.

La sintaxis de range() es:

range(start, stop[, step])

# range(stop)
for i in range(5):
    print(i)

# range(start, stop)
for i in range(1, 5):
    print(i)

# range(start, stop, step)
for i in range(0, 10, 2):
    print(i)

# Decremento
for i in range(10, 0, -1):
    print(i)

2.3Ciclo `while`¶

contador = 0

# Sintaxis similar a otros lenguajes
while contador < 5:
    print(f"Contador: {contador}")
    contador += 1

# Ciclo infinito con break
while True:
    respuesta = input("¿Continuar? (s/n): ")
    if respuesta.lower() != "s":
        break

2.4`break`, `continue` y `else` en ciclos¶

# break y continue funcionan igual que en otros lenguajes
for i in range(10):
    if i == 3:
        continue  # Salta a la siguiente iteración
    if i == 7:
        break  # Sale del ciclo

    print(i)

# else en ciclos: ÚNICO DE PYTHON
# Se ejecuta si el ciclo termina normalmente (sin break)
for i in range(5):
    if i == 10:  # Nunca se cumple
        break
else:
    print("Ciclo completado sin break")  # Se ejecuta

# Ejemplo práctico: búsqueda
numeros = [1, 3, 5, 7, 9]
objetivo = 6

for num in numeros:
    if num == objetivo:
        print(f"Encontrado: {num}")
        break
else:
    print("No encontrado")  # Se ejecuta porque no hubo break

3Iteración sobre estructuras de datos¶

3.1Diccionarios¶

datos = {"nombre": "Ana", "edad": 25, "ciudad": "Madrid"}

# Solo claves
for clave in datos:
    print(clave)

datos = {"nombre": "Ana", "edad": 25, "ciudad": "Madrid"}

# Solo valores
for valor in datos.values():
    print(valor)

datos = {"nombre": "Ana", "edad": 25, "ciudad": "Madrid"}

# Claves y valores
for clave, valor in datos.items():
    print(f"{clave}: {valor}")

3.2Listas con múltiples valores¶

puntos = [(1, 2), (3, 4), (5, 6)]

# Desempaquetado en ciclos
for x, y in puntos:
    print(f"x={x}, y={y}")

puntos = [(1, 2), (3, 4), (5, 6)]

# Con enumerate para índice + desempaquetado
for i, (x, y) in enumerate(puntos):
    print(f"Punto {i}: ({x}, {y})")

4No hay `switch`¶

Python 3.10+ tiene match-case, pero la siguiente construcción usando if-elif es más común.

opcion = "b"

if opcion == "a":
    resultado = "Opción A"
elif opcion == "b":
    resultado = "Opción B"
elif opcion in ["c", "d"]:
    resultado = "Opción C o D"
else:
    resultado = "Opción desconocida"

print(resultado)

El mismo ejemplo con match-case:

opcion = "b"

match opcion:
    case "a":
        resultado = "Opción A"
    case "b":
        resultado = "Opción B"
    case "c" | "d":
        resultado = "Opción C o D"
    case _:
        resultado = "Opción desconocida"

print(resultado)

5Ejemplo práctico: procesamiento de datos¶

# Procesamiento típico de datos en Python
empleados = [
    {"nombre": "Ana", "salario": 50000, "departamento": "IT"},
    {"nombre": "Carlos", "salario": 45000, "departamento": "Ventas"},
    {"nombre": "María", "salario": 55000, "departamento": "IT"},
    {"nombre": "Juan", "salario": 40000, "departamento": "RRHH"},
]

# Filtrar y procesar con sintaxis pythónica
for empleado in empleados:
    nombre = empleado["nombre"]
    salario = empleado["salario"]

    # Determinar categoría y bonus
    if salario >= 50000:
        categoria = "Senior"
        bonus = salario * 0.15
    elif salario >= 45000:
        categoria = "Mid"
        bonus = salario * 0.10
    else:
        categoria = "Junior"
        bonus = salario * 0.05

    print(f"{nombre}: {categoria} - Bonus: ${bonus:,.2f}")

6Diferencias sintácticas resumidas¶

Característica	Python	Java/Go
Delimitadores	Indentación	`{`, `}`
Operadores lógicos	`and`, `or`, `not`	`&&`, `\|\|`, `!`
Ciclo for	`for item in collection:`	`for (type item : collection)` / `for k, v := range collection`
`else` en ciclos	Sí	No
Operador ternario	`value_if_true if condition else value_if_false`	`condition ? value_if_true : value_if_false`
switch/match	`if`-`elif` o `match`-`case` (Python 3.10+)	`switch`

La sintaxis de Python prioriza la legibilidad y expresividad, usando palabras en inglés en lugar de símbolos cuando es posible.

1Condicionales¶

1.1Sintaxis if-elif-else¶