Saltar a contenido

2.2.-Iterativas y saltos

2.2. Sentencias iterativas y de salto

Idea principal

Las sentencias iterativas, también llamadas bucles, permiten ejecutar un bloque de código varias veces. En Python, while repite mientras una condición sea verdadera y for recorre los elementos de un objeto iterable. break, continue y pass permiten controlar o preparar el cuerpo de esos bucles.

Los ordenadores son especialmente útiles para realizar tareas repetitivas: procesar una lista, validar entradas hasta que sean correctas, calcular un total o revisar los caracteres de un texto. Un bucle evita copiar el mismo código muchas veces y hace explícita la regla que determina cuándo se repite.

Python proporciona dos tipos principales de bucle: while y for. Otros lenguajes como C, C++, Java o Kotlin incluyen una sentencia do-while, que ejecuta el cuerpo al menos una vez; Python no tiene esa sentencia. Más adelante se muestra su equivalencia estructurada mediante una variable de control, sin recurrir a while True, break ni continue.

Este tema se relaciona con el RA 3 del módulo de Programación. La normativa indica que se debe escribir y depurar código utilizando las estructuras de control del lenguaje:

Código Descripción literal de la normativa
RA 3 Escribe y depura código, analizando y utilizando las estructuras de control del lenguaje.
CE 3.b Se han utilizado estructuras de repetición.
CE 3.c Se han reconocido las posibilidades de las sentencias de salto.
CE 3.e Se han creado programas ejecutables utilizando diferentes estructuras de control.

Se trabajan los criterios que tienen que ver con la creación de programas, el uso de bucles y sentencias de salto. Los bucles permiten repetir tareas y recorrer datos, mientras que las sentencias de salto permiten controlar el flujo del programa de manera más flexible.

El objetivo no es memorizar while y for de forma aislada, sino saber elegir el bucle adecuado, garantizar que termina y comprobar que produce el resultado esperado.

Qué deberías saber al terminar

Al acabar este tema deberías poder:

  • inicializar y actualizar variables que controlan una repetición;
  • elegir entre while y for según el problema que se quiere resolver;
  • recorrer secuencias y rangos con for;
  • utilizar contadores, acumuladores y patrones de búsqueda;
  • explicar el efecto de break, continue y pass;
  • detectar bucles infinitos y errores de límite, y depurar el código con evidencias.

Mapa del tema

En este documento seguiremos esta progresión:

  1. actualización de variables y conceptos básicos;
  2. bucles while, terminación y bucles infinitos;
  3. sentencias de salto: break, continue y pass;
  4. bucles for, range() y bucles anidados;
  5. diseños de bucles, depuración y actividades.

1. Actualización de variables y conceptos básicos

Antes de crear un bucle conviene recordar cómo se actualiza una variable. En una asignación, Python evalúa primero la expresión de la derecha y después guarda el resultado en la variable de la izquierda.

x = x + 1

Esta instrucción se puede leer así: «toma el valor actual de x, añádele 1 y guarda el nuevo valor en x». No es una igualdad matemática, sino una actualización del estado del programa.

Si la variable todavía no existe, no se puede actualizar:

>>> x = x + 1
NameError: name 'x' is not defined

Primero hay que inicializarla:

>>> x = 0
>>> x = x + 1
>>> x
1

Añadir una cantidad se denomina incrementar; restarla se denomina decrementar. También se pueden utilizar operadores de asignación compuesta, que expresan la misma operación de forma más breve:

contador = 0
contador += 1       # Equivale a contador = contador + 1.
contador -= 1       # Equivale a contador = contador - 1.
total = 10
total *= 2          # Equivale a total = total * 2.

Python no tiene los operadores ++ y -- de otros lenguajes. Para incrementar o decrementar se utilizan += y -=.

1.1. Vocabulario de los bucles

Estos conceptos aparecerán durante todo el tema:

Concepto Significado Ejemplo
Iteración Una ejecución del cuerpo del bucle. Cada vuelta de while contador < 3.
Variable de iteración Variable que cambia o toma nuevos valores para controlar el recorrido o la terminación. contador o amigo.
Contador Variable que registra cuántos elementos o casos se han procesado. contador += 1.
Acumulador Variable que conserva un resultado parcial. total += valor.
Centinela Valor especial que indica que una entrada ha terminado. La palabra "fin".
Bucle infinito Bucle cuya condición no llega a ser falsa o que no tiene salida alcanzable. Un while sin actualización.

Bucle

Un bucle es una estructura de control que repite un bloque de instrucciones. Cada ejecución del bloque es una iteración y el programa debe disponer de una regla clara para continuar y para terminar.

2. Bucles mediante la sentencia while

El bucle while se utiliza cuando la repetición depende de una condición. La condición se comprueba antes de cada iteración, por lo que el cuerpo puede ejecutarse cero veces si la condición inicial ya es falsa.

Su forma general es:

while condición:
    instrucciones

Por ejemplo, este programa cuenta hacia atrás desde cinco y después muestra un mensaje:

n = 5

while n > 0:
    print(n)
    n -= 1

print("¡Despegue!")

La salida es:

5
4
3
2
1
¡Despegue!

Se puede leer así: «mientras n sea mayor que cero, muestra n y redúcelo en una unidad». Cuando n vale 0, la condición es falsa y el programa continúa después del bucle.

2.1. Flujo de ejecución

El flujo formal de un while es el siguiente:

  1. Python evalúa la condición y obtiene un valor verdadero o falso.
  2. Si la condición es falsa, sale del bucle y continúa con la siguiente instrucción.
  3. Si la condición es verdadera, ejecuta el cuerpo.
  4. Al terminar el cuerpo, vuelve a evaluar la condición.

Cada vuelta completa del cuerpo es una iteración. En el ejemplo anterior se realizan cinco iteraciones.

flowchart TD
    A["Inicializar variables"] --> B{"¿La condición es verdadera?"}
    B -->|No| C["Continuar después del while"]
    B -->|Sí| D["Ejecutar el cuerpo"]
    D --> E["Actualizar la variable de iteración"]
    E --> B

El cuerpo debe cambiar alguna variable relacionada con la condición para que esta pueda llegar a ser falsa. Si la variable no cambia, cambia en la dirección equivocada o la condición está mal planteada, el bucle puede no terminar.

2.2. Bucles infinitos

Un bucle infinito es una repetición que no alcanza nunca su condición de salida. La frase «enjabone, aclare, repita» es un ejemplo humorístico de proceso infinito si no existe una regla que indique cuándo dejar de repetir.

En una cuenta atrás es fácil justificar la terminación: n empieza en un valor finito, disminuye una unidad en cada iteración y, finalmente, llega a cero. En cambio, este bucle no termina porque n nunca se actualiza:

n = 10

while n > 0:
    print(n)
    # Falta actualizar n: la condición seguirá siendo verdadera.

Durante el desarrollo, un programa bloqueado por un bucle infinito se puede interrumpir normalmente con Ctrl+C en la terminal. En un programa real, un bucle infinito puede consumir recursos o impedir que se atiendan otras tareas, por lo que siempre hay que justificar su condición de terminación.

Comprueba la terminación

Antes de ejecutar un while, identifica la variable que acerca el programa a la salida. Pregúntate qué valor tiene al principio, cómo cambia en cada iteración y en qué momento la condición será falsa.

2.3. Bucles controlados por un centinela

Un centinela es un valor reservado para señalar que ya no quedan datos. Este patrón resulta apropiado cuando no se conoce de antemano cuántas entradas se van a recibir.

linea = input("Escribe una línea (fin para terminar): ")

while linea != "fin":
    print(linea)
    linea = input("Escribe una línea (fin para terminar): ")

print("¡Terminado!")

La condición de salida aparece en la cabecera del while, de modo que el flujo es fácil de leer. Es importante solicitar una nueva entrada dentro del cuerpo; si no se actualiza linea, el programa procesará siempre el mismo valor.

También puede encontrarse el patrón while True con una salida mediante break cuando la condición se conoce en mitad del cuerpo. Es una construcción válida de Python, pero en este tema se incluye únicamente para reconocerla en código ajeno. En los ejercicios se recomienda la primera versión, con una condición explícita en while, porque deja visible la regla de terminación y evita depender de una salida escondida en el cuerpo. El ejemplo de Python para todos: copiar hasta escribir fin muestra esa otra forma.

2.4. Equivalente estructurado a do...while

La estructura do...while de otros lenguajes ejecuta el cuerpo una vez y comprueba la condición después. Su forma general es:

do {
    instrucciones
} while (condición);

Python no dispone de esta sentencia. Si se necesita mostrar su comportamiento sin utilizar while True, break ni continue, se puede emplear una variable de control que se actualiza al final del cuerpo:

continuar = True

while continuar:
    numero = int(input("Introduce un número (0 para terminar): "))

    if numero != 0:
        print("Procesado:", numero)

    continuar = numero != 0

La primera asignación garantiza una ejecución. Después, el cuerpo actualiza continuar con la condición que se comprobará antes de la siguiente iteración. Si la primera entrada es 0, la lectura se ha realizado una vez, pero el bucle no vuelve a ejecutarse.

Patrón solo de referencia

Esta traducción se muestra para entender o adaptar algoritmos escritos con do...while. No se recomienda utilizarla como patrón habitual, porque añade una variable de control y obliga a buscar la condición al final del cuerpo. Cuando la condición se puede comprobar antes, es preferible un while convencional con la condición visible en su cabecera. En este repositorio tampoco se recomienda sustituirlo por while True y break.

3. Sentencias de salto y control del bucle

Las sentencias de salto alteran el flujo normal del cuerpo de un bucle. En este tema se estudian para entender su funcionamiento y reconocerlas en código existente. Desde un enfoque estructurado, no deben ser la primera opción: una condición visible en la cabecera o un if suele hacer más claro el flujo.

Criterio de programación estructurada

Los ejemplos de break y continue son ilustrativos. Antes de utilizarlos, intenta expresar la condición de salida o de filtrado sin saltos. Así se reduce el número de caminos ocultos y resulta más sencillo justificar cuándo termina el bucle.

Sentencia Efecto
break Termina inmediatamente el bucle más interno que la contiene.
continue Termina la iteración actual y pasa a comprobar la siguiente iteración.
pass No hace nada; sirve como bloque vacío temporal o intencionado. No es una salida del bucle.

3.1. Salir con break

break termina el bucle más interno en el mismo momento en que se ejecuta. Es útil cuando la condición de salida solo se conoce después de procesar parte del cuerpo, por ejemplo, al encontrar un dato.

numeros = [3, 7, 2, 9, 5]
buscar = 9
encontrado = False

for numero in numeros:
    if numero == buscar:
        encontrado = True
        break

if encontrado:
    print("El número está en la lista")
else:
    print("El número no está en la lista")

La búsqueda deja de recorrer la lista cuando encuentra el 9; no tiene sentido seguir buscando si solo se necesita saber si existe. Para búsquedas sencillas, el operador in suele ser más directo:

print(buscar in numeros)  # True

Para pensar

¿Cómo escribirías la lectura de líneas hasta fin sin utilizar while True ni break? Intenta expresar la condición de salida en la cabecera del while.

En bucles anidados, break solo afecta al bucle en el que aparece:

for fila in range(3):
    for columna in range(3):
        if fila == 1 and columna == 1:
            break       # Solo termina el bucle de columnas.
        print(fila, columna)

El bucle exterior continúa con la siguiente fila. Si se necesita abandonar varios niveles, hay que diseñar una salida explícita, usar una variable de control o extraer la búsqueda a una función.

3.2. Saltar una iteración con continue

continue omite el resto de la iteración actual y vuelve al inicio del bucle. En un while, vuelve a evaluar la condición; en un for, toma el siguiente elemento.

Este ejemplo ignora las líneas que empiezan por # y muestra las demás:

lineas = ["hola a todos", "# no mostrar", "imprime esto"]

for linea in lineas:
    if linea.startswith("#"):
        continue
    print(linea)

Se ha utilizado startswith("#") en lugar de linea[0] == "#", porque acceder a linea[0] fallaría si la cadena estuviera vacía. En un programa que lea entradas del teclado, conviene tratar también ese caso.

La misma idea se puede aplicar a una lectura interactiva: se muestra la línea salvo cuando empieza por #, y el proceso termina cuando se escribe fin. El ejemplo completo de Python para todos: copiar hasta escribir fin ignorando comentarios combina continue y break con ese propósito.

En ocasiones continue evita varios niveles de anidamiento. En el siguiente ejemplo se actualiza el índice antes del posible salto, para que ninguna entrada pueda bloquear el bucle:

datos = [3, -1, 5]
indice = 0

while indice < len(datos):
    dato = datos[indice]
    indice += 1
    if dato < 0:
        continue
    print(dato)

Hay que revisar que el continue no salte una actualización necesaria. Por ejemplo, si está dentro de un while y evita incrementar el contador, puede convertir un bucle que debía terminar en un bucle infinito.

3.3. Usar pass

pass es una instrucción que no realiza ninguna acción. Se utiliza cuando la sintaxis exige un bloque, pero todavía no se ha implementado su comportamiento o se quiere indicar deliberadamente que no hay nada que hacer.

numero = -1

if numero < 0:
    pass  # Pendiente de decidir cómo gestionar los negativos.

pass no hace que el programa espere, no repite el bucle y no lo termina. En código entregado, un pass debe tener un propósito claro o sustituirse por la implementación definitiva.

4. Bucles definidos con for

El bucle for se utiliza para recorrer un objeto iterable, como una lista, una cadena, un rango o las líneas de un archivo. En cada iteración, la variable de iteración toma el siguiente elemento.

amigos = ["Joseph", "Glenn", "Sally"]

for amigo in amigos:
    print("Feliz año nuevo:", amigo)

print("¡Terminado!")

La salida es:

Feliz año nuevo: Joseph
Feliz año nuevo: Glenn
Feliz año nuevo: Sally
¡Terminado!

La cabecera se puede leer como «para cada amigo que haya en amigos». for e in son palabras reservadas de Python; amigo y amigos son nombres elegidos por quien programa. La variable amigo cambia automáticamente y el bucle termina cuando se han recorrido todos los elementos.

La variable de iteración

La variable de un for no necesita inicializarse antes. Python le asigna cada elemento durante el recorrido. En Python, el nombre puede seguir existiendo después del bucle con el último valor asignado, pero conviene no depender de él fuera de su cuerpo: su propósito es representar el elemento actual.

4.1. Recorrer números con range()

La función range() permite generar una secuencia de enteros, muy útil cuando se necesita repetir un número concreto de veces:

Forma Valores generados
range(fin) Desde 0 hasta fin - 1.
range(inicio, fin) Desde inicio hasta fin - 1.
range(inicio, fin, paso) Desde inicio, avanzando según paso, sin incluir fin.

El límite final nunca se incluye:

for i in range(1, 10, 2):
    print(i, end=", ")

1, 3, 5, 7, 9,

También se puede utilizar un paso negativo para contar hacia atrás:

for numero in range(10, 0, -1):
    print(numero)

Este código imprime del 10 al 1; no imprime el 0. range() representa un objeto de rango y genera sus valores cuando se recorren, por lo que no es necesario crear una lista con todos ellos para usar un for.

4.2. for frente a while

Situación Bucle habitual Motivo
Recorrer directamente una colección. for La variable toma cada elemento automáticamente.
Repetir un número conocido de veces. for con range() El rango expresa el número y los límites.
Repetir mientras una condición evoluciona. while La terminación depende del estado del programa.
Leer entradas hasta un centinela. while No se conoce de antemano cuántas entradas habrá.

Siempre que el problema consista en recorrer una colección o un rango, for suele ser más claro y evita olvidar la actualización de un índice. while es más apropiado cuando la condición de salida no se puede expresar como un recorrido previamente definido.

4.3. Bucles anidados

Un bucle anidado es un bucle dentro de otro. El bucle interior se ejecuta por completo en cada iteración del exterior:

for fila in range(1, 4):
    for columna in range(1, 3):
        print(f"fila={fila}, columna={columna}")

El bucle exterior realiza tres iteraciones y el interior dos por cada una, por lo que se realizan seis impresiones. Este patrón permite recorrer una matriz, generar combinaciones o construir tablas, pero el número de operaciones puede crecer rápidamente. Dos bucles de n iteraciones suelen producir del orden de n² operaciones.

5. Diseños de bucles y depuración

Los bucles no se escriben al azar. Un diseño habitual sigue tres fases:

  1. Inicializar una o más variables antes del bucle.
  2. Procesar cada elemento o actualizar el estado en el cuerpo.
  3. Consultar el resultado cuando el bucle termina.

5.1. Patrón de recuento

Para contar cuántos elementos tiene una lista, se inicializa el contador a cero y se incrementa una vez por cada elemento:

contador = 0

for valor in [3, 41, 12, 9, 74, 15]:
    contador += 1

print("Número de elementos:", contador)

La variable valor controla el recorrido, aunque no se utilice dentro del cuerpo. Al terminar, contador contiene el número total de elementos. En código real se puede usar len(), pero este patrón permite entender cómo funciona un contador.

5.2. Patrón de suma y acumulación

Un acumulador conserva la suma parcial de los valores ya procesados:

total = 0

for valor in [3, 41, 12, 9, 74, 15]:
    total += valor

print("Total:", total)

Al principio total vale cero porque todavía no se ha procesado ningún valor. En cada iteración se añade el valor actual. Al final, el acumulador contiene la suma total. Para una lista, Python proporciona sum(), pero conocer el patrón es necesario para construir otros cálculos.

Para acumular un producto, el valor inicial debe ser 1, porque multiplicar por cero haría que el resultado fuese siempre cero:

producto = 1

for valor in [2, 3, 4]:
    producto *= valor

print(producto)  # 24

5.3. Patrones de máximo y mínimo

Para buscar el máximo, se puede utilizar None como marcador de que todavía no se ha procesado ningún elemento:

mayor = None
print("Antes:", mayor)

for valor in [3, 41, 12, 9, 74, 15]:
    if mayor is None or valor > mayor:
        mayor = valor
    print("Bucle:", valor, mayor)

print("Mayor:", mayor)

La variable mayor significa «el mayor valor visto hasta este momento». En la primera iteración, como su valor es None, toma el primer elemento. Después solo cambia cuando aparece un valor más grande.

La salida de seguimiento es:

Antes: None
Bucle: 3 3
Bucle: 41 41
Bucle: 12 41
Bucle: 9 41
Bucle: 74 74
Bucle: 15 74
Mayor: 74

Para el mínimo se utiliza el mismo patrón, cambiando la comparación. Es necesario inicializar menor antes del bucle:

menor = None

for valor in [3, 41, 12, 9, 74, 15]:
    if menor is None or valor < menor:
        menor = valor

print("Menor:", menor)

None representa aquí «todavía no hay un valor». Para compararlo se utiliza is None, no == None. En una lista no vacía, las funciones incorporadas max() y min() resuelven directamente este problema.

Una versión didáctica de min() sería:

def minimo(valores):
    menor = None

    for valor in valores:
        if menor is None or valor < menor:
            menor = valor

    return menor

La función devuelve None cuando recibe una secuencia vacía. En un programa real hay que decidir explícitamente si ese comportamiento es adecuado o si se debe validar la entrada antes de llamar a la función.

5.4. Bucles anidados aplicados a una matriz

Para recorrer una lista de listas, el bucle exterior puede representar las filas y el interior las columnas:

matriz = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9],
]

buscar = 5
encontrado = False

for fila in matriz:
    for valor in fila:
        if valor == buscar:
            encontrado = True
            break
    if encontrado:
        break

print("Encontrado:", encontrado)

El segundo break permite abandonar también el recorrido de filas después de que el bucle interior haya encontrado el valor. En problemas grandes conviene valorar el coste de estos recorridos y buscar una solución más directa cuando exista.

5.5. Depurar por bisección

En programas grandes, revisar cada línea una a una puede ser lento. Una técnica sencilla consiste en depurar por bisección:

  1. Elige un valor intermedio que puedas comprobar, como un contador, un total parcial o una salida.
  2. Muestra temporalmente ese valor con print() o inspecciónalo con el depurador.
  3. Si es incorrecto, el problema está antes de ese punto; si es correcto, probablemente está después.
  4. Repite el proceso reduciendo a la mitad la zona en la que buscas.

Si un programa tiene cien líneas, seis comprobaciones pueden reducir la búsqueda a una o dos líneas, porque cada comprobación descarta aproximadamente la mitad del código. No es necesario encontrar la línea que queda exactamente en el centro: hay que elegir un punto que separe de forma razonable las partes del algoritmo y cuya salida sea fácil de verificar.

En los bucles, suele ser útil observar la variable de iteración y el estado del contador o acumulador al principio y al final de cada vuelta:

suma = 0

for numero in range(1, 4):
    print("Antes:", numero, suma)
    suma += numero
    print("Después:", numero, suma)

print("Resultado:", suma)

Si el problema es más complejo, se puede colocar un punto de interrupción en el IDE y ejecutar el programa paso a paso, como se explica en depuración de programas.

5.6. Actividades de aplicación

Actividad 1. Escribe un programa que lea repetidamente números hasta que el usuario introduzca fin. Cuando termine, muestra el total, la cantidad de números y la media. Si se introduce algo que no sea un número, muestra Entrada inválida y vuelve a solicitar otro dato. En este tema puedes dejar la conversión y el control de errores preparados para estudiarlos en captura de excepciones.

Una ejecución posible es:

Introduzca un número: 4
Introduzca un número: 5
Introduzca un número: dato erróneo
Entrada inválida
Introduzca un número: 7
Introduzca un número: fin
16 3 5.333333333333333

Actividad 2. Escribe otro programa que lea una lista de números y muestre al final el máximo y el mínimo, sin utilizar directamente max() ni min(). Debe contemplar qué ocurre si no se introduce ningún número.

6. Buenas prácticas

Para trabajar con bucles de forma clara y segura, conviene aplicar estas pautas:

  • Elige el bucle por el problema: usa for para recorrer colecciones o rangos y while cuando la condición de salida dependa del estado o de una entrada.
  • Haz visible la terminación: inicializa y actualiza la variable que controla un while; si usas un centinela, documenta cuál es.
  • Inicializa con el valor neutro correcto: 0 para contar o sumar, 1 para multiplicar y None cuando todavía no existe un máximo o mínimo.
  • Usa nombres descriptivos: numero, total o linea explican mejor el código que nombres genéricos cuando no se está trabajando con índices.
  • Prioriza el flujo estructurado: evita break y continue salvo que exista una razón clara; una condición explícita suele ser preferible y más fácil de revisar.
  • Protege los casos límite: prueba una colección vacía, un solo elemento, muchos elementos y los valores justo en los límites de un range().
  • No modifiques una colección mientras la recorres: si hay que filtrar una lista, crea otra o recorre una copia para no saltarte elementos.
  • Controla el anidamiento: si hay demasiados niveles de bucles y condiciones, extrae parte de la lógica a funciones más pequeñas.
  • Depura con datos observables: inspecciona condiciones, contadores, acumuladores y número de iteraciones antes de cambiar el algoritmo.

7. Errores frecuentes

Error frecuente Por qué ocurre Cómo evitarlo
Actualizar una variable que no se ha inicializado. Se intenta evaluar el lado derecho de una asignación antes de que exista la variable. Inicializa la variable antes del bucle o de la primera actualización.
Crear un bucle infinito con while. La variable de control no cambia, cambia en la dirección equivocada o la condición nunca puede ser falsa. Comprueba el estado inicial, la actualización y la condición de salida.
Colocar mal los límites de range(). El límite final es exclusivo y los índices suelen empezar en cero. Escribe algunos valores del rango y prueba los casos frontera.
Confundir for y while. Se usa un contador manual para recorrer una colección y se olvida actualizarlo. Recorre directamente la colección con for cuando sea posible.
Usar continue antes de actualizar un while. El salto evita la instrucción que hacía avanzar la variable de control. Coloca la actualización antes del salto o rediseña el bucle.
Pensar que break sale de todos los bucles. break solo termina el bucle más interno que lo contiene. Usa una bandera, una función o una condición exterior para salir de varios niveles.
Ejecutar linea[0] con una cadena vacía. No existe una posición cero en una cadena sin caracteres. Comprueba que no esté vacía o utiliza startswith().
Inicializar un máximo o mínimo con un número arbitrario. Ese número puede no ser válido para todos los datos de entrada. Usa None o el primer elemento y comprueba la colección vacía.
Calcular una media sin contar elementos. Una entrada vacía provoca una división entre cero. Comprueba que la cantidad sea mayor que cero antes de dividir.
Usar while True sin una salida alcanzable. La condición siempre es verdadera y se ha olvidado un break o el centinela. Prefiere una condición explícita o verifica que exista una salida clara.

8. Resumen

En este tema has aprendido que:

  • while evalúa una condición antes de cada iteración y requiere una actualización que permita terminar;
  • for recorre iterables y range() permite expresar recorridos numéricos con límites claros;
  • break sale del bucle más interno, continue salta la iteración actual y pass deja un bloque sin operación;
  • los patrones de contador, acumulador, máximo y mínimo transforman una colección de datos en un resultado;
  • los bucles anidados son útiles, pero multiplican el número de operaciones;
  • la depuración por bisección y la observación de valores intermedios ayudan a localizar errores de lógica.

Idea clave

Un buen bucle expresa con claridad qué se repite, qué cambia en cada iteración y cuándo termina. Después hay que probar sus límites y verificar sus resultados con datos observables.

9. Para seguir practicando

Bibliografía y fuentes

Presentación

Puedes repasar los conceptos principales con la presentación de sentencias iterativas.