Bucles en Python

Bucles en Python

Los bucles son estructuras de control que permiten ejecutar un bloque de código repetidamente. Son fundamentales en programación porque automatizan tareas repetitivas, procesan colecciones de datos y crean algoritmos eficientes. Python ofrece principalmente dos tipos de bucles: for y while, cada uno con características y usos específicos.

El bucle for

El bucle for en Python se utiliza para iterar sobre una secuencia (como listas, tuplas, diccionarios, conjuntos o cadenas) o cualquier objeto iterable. A diferencia de otros lenguajes, el bucle for de Python es más parecido a lo que en otros lenguajes se conoce como "foreach".

Sintaxis básica

for elemento in secuencia:
    # Código a ejecutar para cada elemento

Ejemplos básicos

Iterando sobre una lista

frutas = ["manzana", "banana", "cereza"]
for fruta in frutas:
    print(fruta)

# Salida:
# manzana
# banana
# cereza

Iterando sobre una cadena

mensaje = "Hola"
for caracter in mensaje:
    print(caracter)

# Salida:
# H
# o
# l
# a

Iterando sobre un rango de números

La función range() genera una secuencia de números que podemos usar en un bucle for:

# range(inicio, fin, paso) - fin no está incluido
for i in range(1, 6):  # 1, 2, 3, 4, 5
    print(i)

# Con un solo argumento, range comienza desde 0
for i in range(3):  # 0, 1, 2
    print(i)

# Con paso negativo para contar hacia atrás
for i in range(10, 0, -2):  # 10, 8, 6, 4, 2
    print(i)

Iterando sobre un diccionario

persona = {
    "nombre": "Ana",
    "edad": 28,
    "ciudad": "Madrid"
}

# Iterando sobre claves
for clave in persona:
    print(clave)

# Iterando sobre valores
for valor in persona.values():
    print(valor)

# Iterando sobre pares clave-valor
for clave, valor in persona.items():
    print(f"{clave}: {valor}")

El bucle while

El bucle while ejecuta un bloque de código mientras una condición sea verdadera. Es útil cuando no sabemos de antemano cuántas iteraciones necesitaremos.

Sintaxis básica

while condición:
    # Código a ejecutar mientras la condición sea verdadera

Ejemplos básicos

Contador simple

contador = 1
while contador <= 5:
    print(contador)
    contador += 1  # Importante: actualizar la condición para evitar bucles infinitos

# Salida:
# 1
# 2
# 3
# 4
# 5

Validación de entrada

contraseña = ""
while len(contraseña) < 8:
    contraseña = input("Introduce una contraseña (mínimo 8 caracteres): ")
    if len(contraseña) < 8:
        print("La contraseña es demasiado corta.")

print("Contraseña aceptada.")

Bucle con condición compleja

import random

número_secreto = random.randint(1, 10)
adivinado = False

while not adivinado:
    intento = int(input("Adivina el número (1-10): "))
    
    if intento == número_secreto:
        print("¡Correcto! Has adivinado el número.")
        adivinado = True
    elif intento < número_secreto:
        print("Demasiado bajo. Intenta de nuevo.")
    else:
        print("Demasiado alto. Intenta de nuevo.")

Control de bucles: break, continue y else

Python proporciona palabras clave para controlar el flujo de los bucles:

break

La instrucción break termina el bucle inmediatamente y continúa con la ejecución después del bucle:

for i in range(1, 11):
    if i == 5:
        break  # Sale del bucle cuando i es 5
    print(i)

# Salida:
# 1
# 2
# 3
# 4

continue

La instrucción continue salta a la siguiente iteración del bucle, omitiendo el resto del código en la iteración actual:

for i in range(1, 11):
    if i % 2 == 0:
        continue  # Salta los números pares
    print(i)

# Salida:
# 1
# 3
# 5
# 7
# 9

else en bucles

Los bucles for y while pueden tener una cláusula else que se ejecuta cuando el bucle termina normalmente (sin un break):

# Verificar si un número es primo
num = 13
for i in range(2, num):
    if num % i == 0:
        print(f"{num} no es primo: es divisible por {i}")
        break
else:
    print(f"{num} es un número primo")

# Ejemplo con while
contador = 1
while contador <= 5:
    print(contador)
    contador += 1
else:
    print("Bucle completado normalmente")

Bucles anidados

Puedes anidar bucles dentro de otros bucles para trabajar con estructuras de datos multidimensionales o realizar tareas más complejas:

# Patrón de asteriscos
for i in range(1, 6):
    for j in range(i):
        print("*", end="")
    print()  # Nueva línea después de cada fila

# Salida:
# *
# **
# ***
# ****
# *****

# Multiplicación de matrices
matriz1 = [[1, 2], [3, 4]]
matriz2 = [[5, 6], [7, 8]]
resultado = [[0, 0], [0, 0]]

for i in range(len(matriz1)):
    for j in range(len(matriz2[0])):
        for k in range(len(matriz2)):
            resultado[i][j] += matriz1[i][k] * matriz2[k][j]

for fila in resultado:
    print(fila)

# Salida:
# [19, 22]
# [43, 50]

Comprensiones de listas

Las comprensiones de listas ofrecen una sintaxis concisa para crear listas basadas en secuencias existentes:

Sintaxis básica

[expresión for elemento in secuencia if condición]

Ejemplos

Comprensión simple

# Crear una lista de cuadrados
cuadrados = [x**2 for x in range(1, 11)]
print(cuadrados)  # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

Con condición

# Solo números pares
pares = [x for x in range(1, 21) if x % 2 == 0]
print(pares)  # [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]

Anidada

# Coordenadas de una matriz 3x3
coordenadas = [(x, y) for x in range(3) for y in range(3)]
print(coordenadas)
# [(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

Comprensiones de diccionarios y conjuntos

Python también permite crear diccionarios y conjuntos usando sintaxis de comprensión:

Comprensión de diccionarios

# Diccionario de cuadrados
cuadrados_dict = {x: x**2 for x in range(1, 6)}
print(cuadrados_dict)  # {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# Convertir unidades de temperatura
celsius = {0: 0, 10: 10, 20: 20, 30: 30, 40: 40}
fahrenheit = {k: (v * 9/5) + 32 for k, v in celsius.items()}
print(fahrenheit)  # {0: 32.0, 10: 50.0, 20: 68.0, 30: 86.0, 40: 104.0}

Comprensión de conjuntos

# Conjunto de letras únicas
texto = "hola mundo"
letras = {c for c in texto if c.isalpha()}
print(letras)  # {'h', 'o', 'l', 'a', 'm', 'u', 'n', 'd'}

La función enumerate()

La función enumerate() es útil cuando necesitas tanto el índice como el valor de cada elemento en una secuencia:

frutas = ["manzana", "banana", "cereza"]
for i, fruta in enumerate(frutas):
    print(f"Índice {i}: {fruta}")

# Salida:
# Índice 0: manzana
# Índice 1: banana
# Índice 2: cereza

Puedes especificar el valor inicial del índice:

for i, fruta in enumerate(frutas, start=1):
    print(f"Fruta #{i}: {fruta}")

# Salida:
# Fruta #1: manzana
# Fruta #2: banana
# Fruta #3: cereza

La función zip()

La función zip() combina elementos de múltiples secuencias:

nombres = ["Ana", "Carlos", "Elena"]
edades = [28, 32, 25]
ciudades = ["Madrid", "Barcelona", "Sevilla"]

for nombre, edad, ciudad in zip(nombres, edades, ciudades):
    print(f"{nombre} tiene {edad} años y vive en {ciudad}")

# Salida:
# Ana tiene 28 años y vive en Madrid
# Carlos tiene 32 años y vive en Barcelona
# Elena tiene 25 años y vive en Sevilla

Si las secuencias tienen diferentes longitudes, zip() se detiene cuando se agota la secuencia más corta.

Patrones comunes con bucles

Acumulación de valores

# Suma de números
números = [1, 2, 3, 4, 5]
suma = 0
for num in números:
    suma += num
print(f"La suma es: {suma}")  # La suma es: 15

Búsqueda de elementos

# Buscar un elemento en una lista
nombres = ["Ana", "Carlos", "Elena", "David"]
buscar = "Elena"

for nombre in nombres:
    if nombre == buscar:
        print(f"¡{buscar} encontrado!")
        break
else:
    print(f"{buscar} no encontrado.")

Filtrado de elementos

# Filtrar números pares
números = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
pares = []

for num in números:
    if num % 2 == 0:
        pares.append(num)

print(f"Números pares: {pares}")  # Números pares: [2, 4, 6, 8, 10]

Transformación de datos

# Convertir temperaturas de Celsius a Fahrenheit
celsius = [0, 10, 20, 30, 40]
fahrenheit = []

for temp in celsius:
    fahrenheit.append((temp * 9/5) + 32)

print(f"Fahrenheit: {fahrenheit}")  # Fahrenheit: [32.0, 50.0, 68.0, 86.0, 104.0]

Ejemplos prácticos

Ejemplo 1: Generador de tabla de multiplicar

def tabla_multiplicar(número, hasta=10):
    print(f"Tabla de multiplicar del {número}:")
    for i in range(1, hasta + 1):
        print(f"{número} x {i} = {número * i}")

tabla_multiplicar(7)

Ejemplo 2: Contador de vocales

def contar_vocales(texto):
    vocales = "aeiouAEIOU"
    contador = 0
    
    for caracter in texto:
        if caracter in vocales:
            contador += 1
    
    return contador

texto = "Python es un lenguaje de programación versátil"
print(f"El texto tiene {contar_vocales(texto)} vocales.")

Ejemplo 3: Validación de contraseña

def validar_contraseña():
    while True:
        contraseña = input("Introduce una contraseña: ")
        
        if len(contraseña) < 8:
            print("Error: La contraseña debe tener al menos 8 caracteres.")
            continue
            
        tiene_mayúscula = False
        tiene_minúscula = False
        tiene_número = False
        
        for caracter in contraseña:
            if caracter.isupper():
                tiene_mayúscula = True
            elif caracter.islower():
                tiene_minúscula = True
            elif caracter.isdigit():
                tiene_número = True
        
        if not tiene_mayúscula:
            print("Error: La contraseña debe contener al menos una letra mayúscula.")
        elif not tiene_minúscula:
            print("Error: La contraseña debe contener al menos una letra minúscula.")
        elif not tiene_número:
            print("Error: La contraseña debe contener al menos un número.")
        else:
            print("Contraseña válida.")
            return contraseña

# validar_contraseña()  # Descomenta para probar

Ejemplo 4: Análisis de texto

def analizar_texto(texto):
    caracteres = len(texto)
    palabras = len(texto.split())
    líneas = texto.count('\n') + 1
    
    vocales = 0
    consonantes = 0
    espacios = 0
    dígitos = 0
    otros = 0
    
    for caracter in texto.lower():
        if caracter in "aeiou":
            vocales += 1
        elif 'a' <= caracter <= 'z':
            consonantes += 1
        elif caracter.isdigit():
            dígitos += 1
        elif caracter.isspace():
            espacios += 1
        else:
            otros += 1
    
    return {
        "caracteres": caracteres,
        "palabras": palabras,
        "líneas": líneas,
        "vocales": vocales,
        "consonantes": consonantes,
        "dígitos": dígitos,
        "espacios": espacios,
        "otros": otros
    }

texto_ejemplo = """Python es un lenguaje de programación interpretado
cuya filosofía hace hincapié en la legibilidad de su código.
Se trata de un lenguaje de programación multiparadigma,
ya que soporta programación orientada a objetos,
programación imperativa y programación funcional."""

resultado = analizar_texto(texto_ejemplo)
for clave, valor in resultado.items():
    print(f"{clave}: {valor}")

Ejemplo 5: Juego de ahorcado

def juego_ahorcado():
    import random
    
    palabras = ["python", "programacion", "computadora", "desarrollo", "algoritmo"]
    palabra = random.choice(palabras)
    letras_adivinadas = set()
    intentos_máximos = 6
    intentos = 0
    
    print("¡Bienvenido al juego del Ahorcado!")
    
    while intentos < intentos_máximos:
        # Mostrar estado actual
        display = ""
        for letra in palabra:
            if letra in letras_adivinadas:
                display += letra
            else:
                display += "_"
        
        print(f"\nPalabra: {display}")
        print(f"Intentos restantes: {intentos_máximos - intentos}")
        
        if "_" not in display:
            print("\n¡Felicidades! ¡Has adivinado la palabra!")
            return
        
        # Obtener letra del jugador
        letra = input("\nIntroduce una letra: ").lower()
        
        if len(letra) != 1 or not letra.isalpha():
            print("Por favor, introduce una sola letra.")
            continue
        
        if letra in letras_adivinadas:
            print("Ya has intentado con esa letra.")
            continue
        
        letras_adivinadas.add(letra)
        
        if letra not in palabra:
            intentos += 1
            print(f"La letra '{letra}' no está en la palabra.")
        else:
            print(f"¡Bien! La letra '{letra}' está en la palabra.")
    
    print(f"\n¡Has agotado tus intentos! La palabra era: {palabra}")

# juego_ahorcado()  # Descomenta para jugar

Mejores prácticas

1. Elegir el tipo de bucle adecuado

• Usa for cuando conozcas el número de iteraciones o estés iterando sobre una colección.
• Usa while cuando la condición de terminación dependa de factores que pueden cambiar durante la ejecución.

2. Evitar bucles infinitos

Asegúrate de que la condición de un bucle while eventualmente se vuelva falsa:

# Mal (bucle infinito)
while True:
    print("Esto nunca termina")

# Bien
contador = 0
while contador < 5:
    print(contador)
    contador += 1  # Importante: actualizar la variable de control

3. Usar comprensiones cuando sea apropiado

Las comprensiones son más concisas y a menudo más eficientes que los bucles tradicionales para operaciones simples:

# Tradicional
cuadrados = []
for x in range(10):
    cuadrados.append(x**2)

# Comprensión (más conciso)
cuadrados = [x**2 for x in range(10)]

4. Evitar modificar la colección durante la iteración

Modificar una colección mientras la recorres puede causar comportamientos inesperados:

# Problemático
numeros = [1, 2, 3, 4, 5]
for i in range(len(numeros)):
    if numeros[i] % 2 == 0:
        numeros.remove(numeros[i])  # ¡Esto cambia los índices!

# Mejor enfoque
numeros = [1, 2, 3, 4, 5]
numeros = [x for x in numeros if x % 2 != 0]

5. Usar else en bucles estratégicamente

La cláusula else en bucles puede hacer el código más claro para verificar si un bucle se completó sin interrupciones:

def es_primo(n):
    if n <= 1:
        return False
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            return False
    return True

Ejercicios prácticos

1. Escribe un programa que imprima los primeros 20 números de la secuencia de Fibonacci.
2. Crea una función que reciba una lista de números y devuelva otra lista con solo los números primos.
3. Implementa un programa que lea una cadena y cuente la frecuencia de cada carácter, mostrando los resultados ordenados.
4. Desarrolla un juego de "Piedra, Papel o Tijera" contra la computadora, donde el juego continúa hasta que el usuario decida terminar.
5. Escribe una función que reciba una matriz (lista de listas) y devuelva su transpuesta (filas por columnas).

En la próxima lección, aprenderemos sobre funciones en Python, que nos permitirán organizar nuestro código en bloques reutilizables y modulares.