Bucles en Python

Un bucle repite un bloque de código. Cada pasada por el bloque es una iteración. Un bucle while comprueba una condición antes de cada pasada y ejecuta su cuerpo mientras esa condición sea verdadera. Esto encaja con una tarea como «seguir sumando hasta que el total llegue a 100».

Inicio, comprobación y actualización

Un bucle de conteo necesita un valor inicial, una condición y una actualización. La cabecera termina en dos puntos. Aplica al cuerpo una sangría de cuatro espacios:

n = 3
while n > 0:
    print(n)
    n = n - 1
print("Liftoff!")

La salida es:

3
2
1
Liftoff!

En la primera comprobación, n > 0 es verdadero porque n es 3. Python imprime 3, resta 1 y vuelve a la cabecera. Repite con 2 y después con 1. La actualización hace que n sea igual a 0, así que la siguiente comprobación es falsa. Python omite el cuerpo y ejecuta el último print.

La sangría determina qué se repite. Ambas líneas con sangría pertenecen al cuerpo. La última línea está alineada con while, así que se ejecuta una vez después del bucle. Un if comprueba su condición una vez; while vuelve a comprobarla después de completar cada ejecución del cuerpo.

La comprobación se hace al principio

Cambiar una variable no interrumpe el resto de la ejecución actual del cuerpo:

n = 1
while n > 0:
    n -= 1
    print("Still in this pass")
print(n)

Esto imprime Still in this pass y después 0, en líneas separadas. La actualización hace falsa la condición, pero Python solo la comprueba al volver a la cabecera. Empezar con n = 0 omitiría todo el cuerpo: un bucle while puede ejecutarse cero veces.

Actualizaciones breves y cambios de valores

n -= 1 significa n = n - 1. Del mismo modo, count += 1 suma 1, balance *= 1.07 multiplica por 1,07 y n //= 10 sustituye n por su cociente entero entre 10. Python no tiene operador de incremento: count++ es un error de sintaxis. Escribir ++count aplica dos veces el más unario y deja el entero sin cambios.

Aquí un bucle elimina un dígito en cada pasada:

n = 472
total = 0
while n > 0:
    total += n % 10
    n //= 10
print(total)

El resto (residuo) n % 10 es el último dígito. Primero se suma 2 y n pasa a ser 47. Después se suma 7 y n pasa a ser 4. Por último se suma 4 y n pasa a ser 0. La salida es 13. La actualización prepara la siguiente pasada y acerca el bucle a la salida.

Un bucle con un objetivo no necesita tener un número de repeticiones conocido de antemano. Partir de un saldo de 1000, multiplicarlo por 1,07 e incrementar un contador de años hasta que el saldo alcance 2000 requiere 11 pasadas. Tras 10 pasadas, el saldo es aproximadamente 1967,15; tras 11, es aproximadamente 2104,85.

Las condiciones pueden combinar comparaciones con and, or y not. También funciona el valor de verdad en un contexto booleano: para un entero, while n: repite mientras n sea distinto de cero. Usa una condición cuyo significado resulte fácil de seguir. Mantén una sangría uniforme con espacios; los niveles que no coinciden pueden lanzar IndentationError, y mezclar tabulaciones y espacios puede lanzar TabError.

Un bucle infinito sigue repitiéndose sin alcanzar una salida. Puedes ver la misma salida desplazándose por la pantalla o un programa que parece no hacer nada. Para encontrar la causa, sigue los valores usados en la condición y busca una vía de salida alcanzable.

Localiza la actualización

Este bucle sigue imprimiendo 3:

n = 3
while n > 0:
    print(n)

La comprobación sigue siendo verdadera porque nada cambia n. Añade n -= 1 dentro del cuerpo para que se impriman los valores 3, 2 y 1 antes de que termine el bucle. Poner esa actualización después del bucle no ayuda: el programa no puede alcanzarla mientras el bucle siga ejecutándose.

La dirección también importa. Con while n > 0:, una actualización de n += 1 hace crecer un valor positivo. Los enteros de Python no pasan a ser negativos al superar un máximo fijo que permita una salida accidental. Expresa el cambio que esperas, como «queda un intento menos», y comprueba que el código realiza ese cambio en cada ruta por el cuerpo.

Un objetivo puede no alcanzarse

Una actualización puede cambiar el valor en cada pasada y aun así no alcanzar nunca un objetivo de igualdad:

n = 1
while n != 10:
    print(n)
    n += 2

Los valores son 1, 3, 5, 7, 9, 11 y así sucesivamente. Siempre son impares, así que ninguno es igual a 10. Para la tarea «imprimir valores impares menores que 10», usa while n < 10:. En cuanto n pasa a ser 11, esa condición es falsa. La comparación elegida debe corresponder a si la tarea termina en un valor o al cruzar un límite.

Pasos decimales e igualdad exacta

Muchas fracciones decimales se almacenan de forma aproximada como números de coma flotante. Sumar repetidamente 0.1 a 0.0 diez veces da 0.9999999999999999. Por tanto, un bucle que espera una igualdad exacta con 1.0 no se detiene donde se pretendía.

Cuando la tarea consiste en recorrer un conjunto fijo de décimas, cuenta con enteros y calcula cada decimal:

for i in range(11):
    x = i / 10
    print(x)

Esto recorre 11 valores desde 0.0 hasta 1.0. El conteo entero controla las repeticiones; el decimal almacenado no decide si el bucle debe detenerse.

Comprueba todas las rutas por el cuerpo

Antes de ejecutar un bucle while, localiza sus valores iniciales, su condición y todas las sentencias que cambian esos valores. Comprueba que el cambio puede hacer falsa la condición. Si un if omite una actualización, sigue también esa ruta. Una línea temporal como print("n =", n) dentro del cuerpo puede mostrar un valor atascado o que se aleja del límite.

Para interrumpir un programa en ejecución, pulsa Ctrl+C en una terminal o usa el botón Detener o Interrumpir del editor. En una terminal, Python suele mostrar KeyboardInterrupt con una traza de la excepción.

Repetición deliberada

while True: mantiene deliberadamente verdadera la condición de su cabecera. Su cuerpo usa break para salir del bucle cuando ocurre un evento, como que el usuario introduzca «quit». La salida debe ser alcanzable. Un bucle de entrada puede seguir esperando porque el usuario no ha solicitado salir; un error de programación es un bucle cuya lógica hace imposible la salida prevista.

Un bucle de entrada puede recoger una cantidad desconocida de datos o seguir preguntando hasta que una respuesta sea aceptable. En ambos casos, la nueva entrada debe influir en la siguiente decisión de repetir.

Detente ante un valor centinela

Un valor centinela es una entrada especial que significa «no hay más datos». Elige un valor que no pueda ser un dato real. Para conteos positivos, 0 puede servir; si 0 es una medida válida, elige otra señal de parada.

La lectura inicial obtiene el primer valor antes de comprobar la condición:

total = 0
number = int(input("Number (0 to stop): "))
while number != 0:
    total += number
    number = int(input("Number (0 to stop): "))
print("Total:", total)

Para las entradas 4, 7 y 0, el cuerpo suma primero 4 y después 7. Leer 0 hace falsa la siguiente condición. El programa imprime Total: 11; nunca procesa el centinela. Si la primera entrada es 0, el cuerpo se ejecuta cero veces y el total sigue siendo 0.

La lectura final dentro del cuerpo es esencial. Sin ella, el mismo primer valor se procesa indefinidamente. La comprobación también debe hacerse antes de procesar un valor recién leído: de lo contrario, un centinela puede contarse como dato.

Mantén la coherencia de los tipos

input() devuelve texto. La cadena "0" no es igual al entero 0. Convierte la entrada numérica con int() antes de compararla con un centinela numérico, o conserva la entrada como texto y compara con una cadena como "done". Una conversión numérica espera una cadena numérica válida; una comprobación de rango evalúa el número resultante.

Para una media, mantén un contador junto al total. Con el centinela -1 y las entradas 8, 6, 10 y -1, el total es 24 y el conteo es 3. Divide después del bucle para obtener 8.0. Si la primera entrada es -1, el conteo sigue siendo 0, así que usa if count > 0: antes de dividir. Esto permite manejar un conjunto de datos vacío sin ZeroDivisionError.

Vuelve a preguntar mientras la respuesta no sea válida

Un bucle de validación describe las respuestas no aceptables en su condición:

age = int(input("Age (0-120): "))
while age < 0 or age > 120:
    print("Please enter an age from 0 to 120.")
    age = int(input("Age (0-120): "))
print("Thank you.")

Con 150, -2 y 34, el aviso aparece dos veces. El valor 34 hace falsas ambas comparaciones, así que el bucle termina. También se aceptan los extremos 0 y 120.

La palabra or importa: una edad no es válida si está por debajo del mínimo o por encima del máximo. Escribir age < 0 and age > 120 no rechazaría nada, porque un número no puede cumplir ambas condiciones.

Para una respuesta de sí o no, la comprobación de invalidez es answer != "y" and answer != "n". Una respuesta debe ser distinta de ambas cadenas aceptadas para rechazarse. Con or, incluso "y" provocaría otra repetición porque es distinta de "n". Sigue la ejecución con una respuesta aceptable y otra no aceptable para comprobar una condición de este tipo.

Las mismas tareas pueden usar while True con una sola lectura en el cuerpo, seguida de una comprobación de salida y break. Esto sitúa la decisión inmediatamente después de la entrada y evita escribir la lectura dos veces.

Un bucle for recorre en orden los elementos de una secuencia. En cada pasada, Python asigna el siguiente elemento a la variable del bucle y ejecuta el cuerpo con sangría. Un bucle sobre una secuencia suele llamarse bucle de iteraciones determinadas porque los elementos le proporcionan un conjunto definido de tareas.

Un elemento cada vez

Una cadena es una secuencia de caracteres:

for ch in "cat":
    print(ch)

Esto imprime c, a y t en líneas separadas. Los espacios y los signos de puntuación también cuentan como caracteres. La cadena "hi there" tiene ocho caracteres, incluido su espacio, así que recorrer cada carácter requiere ocho pasadas.

Una lista contiene una secuencia de valores. Su forma literal usa corchetes y comas:

scores = [3, 41, 12]
for score in scores:
    print(score * 2)

La salida es 6, 82 y 24, cada uno en su propia línea. score contiene un número cada vez, no toda la lista ni su posición. No hace falta actualizar manualmente un contador para pasar de 3 a 41 y a 12.

Usa un nombre que describa un elemento: name en names o score en scores. Si el cuerpo nunca necesita el valor actual, _ es un nombre habitual para esa variable del bucle que no se usa.

La asignación no sustituye un elemento

La variable del bucle es una variable normal. Asignarle un número diferente no sustituye el número de la lista:

numbers = [1, 2, 3]
for n in numbers:
    n = n * 10
    print(n)
print(numbers)

El cuerpo imprime 10, 20 y 30. En cada nueva iteración, se asigna a n el siguiente elemento original de la lista. La última línea de salida es [1, 2, 3]: la lista en sí no ha cambiado. Después del bucle, n conserva 30, el último valor que se le asignó en el cuerpo.

Una secuencia vacía no da trabajo al cuerpo. Con for ch in "":, hay cero pasadas y el bucle no realiza ninguna asignación a ch. No des por hecho que un bucle creará su variable cuando pueda no haber elementos.

Pertenencia dentro de un bucle

En la cabecera de un for, in introduce la secuencia que se va a recorrer. En una condición, comprueba la pertenencia y produce True o False. Estos usos pueden combinarse:

vowels = 0
for ch in "education":
    if ch in "aeiou":
        vowels += 1
print(vowels)

Se recorre cada carácter, pero el contador solo cambia para e, u, a, i y o. La salida es 5. El if tiene sangría dentro del bucle y la actualización del contador tiene sangría dentro del if.

Este bucle también muestra por qué una variable del bucle y un contador tienen funciones distintas. ch contiene el carácter actual; vowels registra cuántos caracteres han cumplido la condición hasta el momento. El contador se inicializa antes del bucle para conservar su resultado entre pasadas.

Un entero por sí solo no puede proporcionar elementos: for i in 5: lanza TypeError. Para repetir una acción cinco veces, escribe for _ in range(5):. El rango proporciona los pasos, aunque el cuerpo no use sus valores.

Un rango describe enteros separados por un paso constante. Es útil para repetir tareas un número fijo de veces, contar hacia delante o hacia atrás y seleccionar pasos regulares. Su límite de parada siempre queda excluido.

Tres formas

Con un argumento, ese argumento es el límite de parada. Con dos, son el inicio y el límite de parada. Con tres, el último argumento es el paso que se suma después de cada valor. range(0, 10, 3) recorre 0, 3, 6 y 9; el siguiente paso llegaría a 12, así que no se proporciona.

El límite de parada sigue excluido incluso cuando un paso podría caer exactamente en él. range(0, 10, 5) proporciona solo 0 y 5. Con el paso positivo predeterminado de 1 y un límite de parada mayor que el inicio, el número de valores proporcionados es el límite de parada menos el inicio.

Cuenta hacia atrás con un paso negativo

range(5, 0, -1) proporciona 5, 4, 3, 2 y 1. Para incluir 0, sitúa el límite de parada por debajo: range(5, -1, -1) proporciona seis valores y termina en 0.

La dirección debe concordar con los límites. range(5, 0) está vacío porque su paso predeterminado es positivo. range(1, 5, -1) también está vacío porque empieza por debajo del límite de parada, pero avanza hacia abajo. Los rangos vacíos son válidos y provocan cero iteraciones; un paso cero, en cambio, lanza ValueError.

Sitúa el último valor necesario dentro del límite

Para sumar los enteros pares del 2 al 20:

total = 0
for n in range(2, 21, 2):
    total += n
print(total)

El límite de parada de 21 permite recorrer el 20. Los diez valores suman 110, así que el programa imprime 110. Usar 20 como límite de parada excluiría el 20 y daría 90.

Para una tabla de multiplicar, deja que el rango proporcione los factores:

for i in range(1, 11):
    print(7, "x", i, "=", 7 * i)

La primera línea de salida es 7 x 1 = 7 y la décima es 7 x 10 = 70. Si no se usa el número en sí, for _ in range(3): puede repetir un mensaje tres veces.

Inspecciona un rango y comprueba sus argumentos

list(range(2, 6)) produce [2, 3, 4, 5], lo que resulta útil para comprobar los límites. len(range(0, 10, 3)) es 4. Un rango almacena los límites y el paso que lo definen en lugar de construir una lista que contenga todos los enteros.

Los argumentos son enteros, incluidos el cero y los enteros negativos: range(-3, 3) recorre de -3 a 2. Un número de coma flotante como 3.0 se rechaza con TypeError, aunque no tenga parte fraccionaria. Un conteo introducido como texto puede convertirse primero con n = int(input("How many? ")) y usarse después en range(n).

Elige un bucle preguntándote qué controla la repetición. Si hay una secuencia de elementos que recorrer o un número de repeticiones, for suele expresar la tarea directamente. Si la siguiente repetición depende de una condición cambiante o de una entrada futura, while sitúa esa decisión en su cabecera.

Elementos definidos o una condición cambiante

No es necesario escribir el conteo como un literal en el programa. Después de leer n de la entrada, range(n) sigue proporcionando un conjunto determinado de pasos. Un bucle de iteraciones indeterminadas depende de una condición cuyo momento de parada no se especifica como un número de repeticiones.

Suponer un número grande de repeticiones no se adapta bien a «hasta terminar». Un bucle sobre range(1000) puede agotar sus intentos antes de que el usuario termine, y una versión sin comprobación de salida continuará cuando el trabajo ya esté completo.

Reescribe un bucle de conteo

Estos dos bucles imprimen del 1 al 5, cada número en su propia línea:

for i in range(1, 6):
    print(i)

i = 1
while i < 6:
    print(i)
    i += 1

En la versión while, el inicio del rango pasa a ser la inicialización, el límite de parada excluido pasa a ser la comparación < y el paso pasa a ser la actualización. El cuerpo usa i antes de esa actualización. Mover la actualización antes de print(i) desplazaría los valores impresos.

Contar hacia atrás cambia tanto la comparación como la actualización:

i = 10
while i > 0:
    print(i)
    i -= 2

Esto imprime 10, 8, 6, 4 y 2, igual que lo haría for i in range(10, 0, -2):. El rango descendente excluye su límite de parada, así que la condición while correspondiente es i > 0.

Ambas formas realizan la misma tarea de imprimir el conteo; los valores finales de sus variables de bucle son distintos. La versión while realiza su última actualización a 0 antes de detenerse. La versión for termina después de asignar el último valor proporcionado, 2.

Un rango conserva los límites que recibió

n = 3
for i in range(n):
    n = 10
    print(i)

Esto sigue imprimiendo 0, 1 y 2. El rango se creó usando 3; asignar 10 a n no lo reconstruye. Un break puede terminar el bucle antes de tiempo, pero cambiar esa variable separada no cambia los números que proporciona el rango.

En cambio, una cabecera while vuelve a evaluar su expresión cada vez que se regresa a ella. Si esa expresión usa n, cambiar n en el cuerpo puede cambiar cuándo termina el bucle. Cuando ambas formas expresan claramente una tarea de conteo, la versión for se encarga de avanzar sin una actualización manual que puedas olvidar.

break termina inmediatamente el bucle más interno que lo contiene. Python omite el resto de ese cuerpo y todas las iteraciones restantes, y después continúa tras el bucle. Una condición dentro del cuerpo decide cuándo debe producirse esta salida anticipada.

Detente al encontrar el primer resultado

Busca el primer múltiplo de 7 mayor que 50:

for n in range(51, 100):
    if n % 7 == 0:
        print(n)
        break

El bucle comprueba 51, 52, 53, 54, 55 y 56. El resto es cero en 56, así que Python imprime 56 y sale del bucle. Requiere seis iteraciones, aunque el rango puede proporcionar 49 números. Sin break, el bucle también imprimiría los múltiplos de 7 posteriores.

break tiene sangría dentro del if, así que solo se ejecuta cuando hay una coincidencia. Si estuviera alineado con if, se ejecutaría en la primera iteración, independientemente de la comprobación. Un break dentro de un if termina el bucle que contiene ese if; no se limita a terminar el bloque condicional.

Lee una vez y después decide si procesar

Un bucle while True sitúa la decisión de salida después de leer la entrada:

while True:
    line = input("> ")
    if line == "done":
        break
    print(line)
print("Done!")

Para las entradas «hello», «there» y «done», las líneas de respuesta son:

hello
there
Done!

El centinela se comprueba antes de la línea de procesamiento. Cuando aparece, break salta por encima de print(line). El print final sin sangría se ejecuta después del bucle. Solo hay una sentencia de entrada porque cada pasada empieza leyendo una línea nueva.

Un total numérico usa el mismo orden: inicializa total = 0 antes del bucle; lee y convierte un número; sal con break si es 0; en caso contrario, súmalo. Para 4, 7 y 0, el total es 11. Procesar antes de comprobar la salida permitiría que el centinela entrara en el cálculo, lo que importa cuando el valor de parada podría alterar un conteo, un producto o una media.

Valida al leer la entrada

while True:
    age = int(input("Age: "))
    if 0 <= age <= 120:
        break
    print("Please enter an age from 0 to 120.")
print("Accepted:", age)

La comparación encadenada acepta una edad de 0 a 120, ambos incluidos. Significa 0 <= age and age <= 120. Un número aceptado provoca la salida antes del aviso; un número fuera de ese rango llega al aviso y después a otra lectura. En esta forma, el if describe una respuesta válida, mientras que un bucle de validación controlado desde la cabecera describe una no válida.

Interpreta el salto literalmente

Una sentencia después de break en el mismo bloque no puede ejecutarse. Coloca un mensaje o un resultado guardado antes del break cuando pertenezca al caso de éxito. Coloca el código después del bucle cuando deba ejecutarse tanto tras una salida anticipada como tras una finalización normal.

break debe estar dentro de un bucle; de lo contrario, Python lanza SyntaxError. Varios puntos de salida separados pueden dificultar el seguimiento de un bucle. Cuando una única condición describe de forma natural la regla de parada de la tarea, mantenerla en la cabecera puede facilitar el seguimiento de la ruta.

continue omite el resto de la iteración actual. El bucle sigue activo: un bucle for toma su siguiente elemento y un bucle while vuelve a su condición. Resulta útil cuando un elemento no debe recibir ninguna parte del procesamiento posterior a una comprobación.

Omite valores seleccionados

total = 0
for n in range(1, 11):
    if n % 3 == 0:
        continue
    total += n
print(total)

El rango proporciona los diez enteros del 1 al 10. En 3, 6 y 9, continue omite la suma. La suma de los diez es 55; excluir esos tres valores resta 18, así que el programa imprime 37.

Continue no elimina una iteración del rango. El cuerpo sigue empezando con cada valor, incluidos los que se omiten. Cambia qué líneas posteriores se ejecutan en esa pasada.

Un filtro positivo puede expresar la misma tarea. En un bucle sobre [5, -2, 8, -7, 3], if n < 0: continue seguido de print(n) imprime 5, 8 y 3. Poner el print dentro de if n >= 0: da la misma salida. Continue suele ser útil cuando siguen varias líneas de procesamiento, porque los elementos rechazados pueden salir inmediatamente de esa parte del cuerpo.

No omitas una actualización de while

i = 0
while i < 5:
    if i == 2:
        continue
    print(i)
    i += 1

Esto imprime 0 y 1 y después se atasca en 2. En 2, continue salta a la condición sin alcanzar la actualización. La condición sigue siendo verdadera y se vuelve a tomar la misma rama.

Para omitir la impresión de 2 y seguir avanzando, actualiza también en esa rama:

i = 0
while i < 5:
    if i == 2:
        i += 1
        continue
    print(i)
    i += 1

Ahora la salida es 0, 1, 3 y 4 en líneas separadas. La ruta que omite la impresión avanza de 2 a 3. Cada ruta por este cuerpo realiza exactamente una actualización.

Break, continue y pass

Para un bucle sobre [1, 2, 3, 4], supón que un if n == 2: contiene una de estas sentencias y que print(n) va después del if. Break imprime solo 1. Continue imprime 1, 3 y 4. Pass imprime los cuatro valores porque no omite el print.

pass puede ocupar un cuerpo donde Python exige una sentencia mientras se desarrolla el código. No proporciona una actualización ni una salida: while True: pass sigue ejecutándose. Break y continue deben estar dentro de un bucle y afectan solo al bucle más interno que los contiene.

Un bloque else puede pertenecer a un bucle for o while. Se ejecuta una vez cuando el bucle termina normalmente: un bucle for agota sus elementos o la condición de un while se vuelve falsa. Se omite cuando ese bucle termina mediante break. Interprétalo como el caso sin break.

Informa de una búsqueda sin coincidencias

for n in [4, 9, 15, 22]:
    if n % 5 == 0:
        print("First multiple of 5:", n)
        break
else:
    print("No multiple of 5")

El bucle llega a 15, imprime First multiple of 5: 15 y sale mediante break. Se omite el else. Con [4, 9, 22], el bucle usa todos los elementos sin ejecutar break e imprime No multiple of 5 una vez.

La alineación es decisiva. El else está alineado con for, así que pertenece al bucle. Un else alineado con el if interno se ejecutaría para cada elemento que no coincidiera, anunciando el fracaso antes de que terminara la búsqueda.

Una lista vacía también llega al else del bucle. No hay elementos, así que el cuerpo se ejecuta cero veces y no se ejecuta ningún break. Del mismo modo, un bucle while cuya condición es falsa en la primera comprobación ejecuta su else inmediatamente.

Busca un divisor

Un número primo es un entero mayor o igual que 2 cuyos únicos divisores positivos son 1 y él mismo. Busca un divisor entre esos extremos:

n = 29
if n < 2:
    print("Not prime")
else:
    for d in range(2, n):
        if n % d == 0:
            print(n, "is divisible by", d)
            break
    else:
        print(n, "is prime")

Para 29, todos los restos son distintos de cero y el else del bucle imprime 29 is prime. Para 21, el primer divisor es 3 y el break omite el else del bucle. La comprobación externa se ocupa de los números menores que 2. Sin ella, un rango vacío para 1 llegaría al else e indicaría erróneamente que 1 es primo. Para 2, el rango también está vacío, pero la conclusión de que es primo es correcta.

Intentos limitados con while y else

attempts = 0
while attempts < 3:
    guess = input("Password: ")
    if guess == "open sesame":
        print("Welcome!")
        break
    attempts += 1
else:
    print("Too many attempts.")

Una respuesta correcta ejecuta el break, incluso en el tercer intento. Tres respuestas incorrectas elevan el contador a 3; la condición se vuelve falsa y el else imprime el mensaje de fracaso. Una sentencia normal después del bucle se ejecutaría en ambos casos, así que no los distinguiría.

Registra el resultado con una variable indicadora

Una variable indicadora es una variable booleana que registra si ha ocurrido algo. Empieza con found = False, cámbiala a True cuando aparezca una coincidencia y sal con break. Después del bucle, if not found: se ocupa del fracaso. Esto proporciona el mismo resultado de búsqueda que el else del bucle, usando un registro explícito del evento. Elige una forma cuya sangría y ruta de salida puedas explicar con claridad.

Un acumulador conserva un resultado entre iteraciones. Un contador es un acumulador particular que aumenta en 1 cada vez que ocurre un evento. Establece el valor inicial antes del bucle, actualízalo dentro y usa después el resultado terminado.

Cuenta eventos o suma valores

count = 0
for n in [4, 15, 22, 8, 11]:
    if n > 10:
        count += 1
print(count)

La condición se cumple para 15, 22 y 11, así que la salida es 3. La actualización suma 1 por cada elemento que cumple la condición; sumar n daría, en cambio, el total de los valores que la cumplen.

Para sumar todos los elementos, inicializa total = 0, elimina la comprobación if, añade total += n directamente en el cuerpo e imprime total después. Los cinco valores suman 60. Su media es 60 / 5, que da 12.0; la división con / devuelve un número de coma flotante para estos operandos enteros.

Para una media de valores filtrados, actualiza tanto el total como el conteo bajo la misma condición:

total = 0
count = 0
for n in [4, 15, 22, 8, 11]:
    if n > 10:
        total += n
        count += 1
if count > 0:
    print(total / count)
else:
    print("No matching values")

Aquí el total seleccionado es 48 y el conteo es 3, así que la salida es 16.0. Dividir entre la longitud de toda la lista usaría el grupo equivocado. La comprobación del conteo también permite manejar una lista vacía o sin coincidencias.

Elige un valor inicial adecuado para la operación

Un producto de los enteros del 1 al 5 empieza en 1 y termina en 120. Empezarlo en 0 mantendría todos los productos en 0.

La acumulación de texto también depende del orden:

rev = ""
for ch in "stressed":
    rev = ch + rev
print(rev)

Cada carácter nuevo se coloca delante del texto guardado y produce desserts. Cambiar la actualización a rev = rev + ch añade caracteres al final y reconstruye stressed.

Conserva el resultado entre iteraciones

Mover total = 0 al interior de un bucle de suma borra el trabajo anterior en cada pasada. Con [4, 15, 22, 8, 11], reiniciar antes de cada suma deja solo 11 al final. Inicializa fuera del bucle para que la siguiente suma use el subtotal anterior.

Un print dentro del cuerpo muestra la suma acumulada después de cada actualización: 4, 19, 41, 49 y 60 en este ejemplo. Un print después del bucle muestra solo 60. Elige su ubicación según la salida solicitada.

Para una lista sencilla almacenada, sum(values) da su total y len(values) da su conteo. Un bucle explícito te permite filtrar valores, llevar varios resultados a la vez o procesar los valores conforme llegan desde la entrada.

Para encontrar un máximo, conserva el mayor valor encontrado hasta el momento. Compara cada elemento nuevo con ese valor guardado y sustitúyelo solo cuando el nuevo sea mayor. El patrón de mínimo funciona del mismo modo, con la comparación invertida.

Empieza sin inventar un valor de los datos

None es el valor de Python para «todavía nada». Ofrece una forma clara de que el primer elemento se convierta en el mejor valor actual:

largest = None
for n in [12, -3, 25, 7]:
    if largest is None or n > largest:
        largest = n
print(largest)

Los valores guardados después de cada elemento son 12, 12, 25 y 25. El programa imprime 25. Con el primer elemento, largest is None es verdadero. El or de Python se detiene ahí, así que no intenta la comparación no válida de un número con None. En las pasadas posteriores, el valor guardado es un número y se usa la segunda comparación.

Para un mínimo, empieza con smallest = None y usa smallest is None or n < smallest. La misma lista produce -3.

Empezar un máximo en 0 puede dar un valor que nunca apareció. Para -5, -2 y -9, ningún valor supera 0, así que esa versión conservaría erróneamente 0. El máximo es -2. Empezar un mínimo en 0 tiene el problema correspondiente cuando todos los elementos son positivos.

Si se sabe que los datos contienen un elemento, también funciona usar ese primer valor como mejor valor inicial. Las funciones incorporadas resuelven los casos de listas sencillas almacenadas: max([12, -3, 25, 7]) da 25 y min([12, -3, 25, 7]) da -3. Un bucle propio puede conservar información relacionada, como dónde apareció el valor.

Guarda la posición cuando cambie el mejor valor

largest = None
best_day = None
day = 0
for temperature in [18, 23, 21, 26, 24]:
    day += 1
    if largest is None or temperature > largest:
        largest = temperature
        best_day = day
print(largest, best_day)

El contador de días avanza con cada elemento. El mejor día cambia solo cuando aparece un nuevo máximo. La salida final es 26 4, que significa una temperatura de 26 en el día 4. Guardar el día después del bucle solo guardaría el último día examinado.

Decide qué hacer con un empate

Para [5, 8, 8, 3], la comprobación n > largest conserva el primer 8 y su posición, 2 al contar desde 1. Sustituir > por >= también actualiza ante un valor igual y conserva el último 8, en la posición 3. El número máximo no cambia; la posición guardada es distinta.

Una lista vacía deja sin cambios el mejor valor inicializado en None. Comprueba ese estado antes de mostrar un número o realizar operaciones aritméticas con él. Significa que ningún elemento ha proporcionado un mejor valor.

La comparación puede usar una propiedad del elemento. Para conservar la palabra más larga entre «pera», «banana» e «higo», compara len(word) con la longitud de la palabra guardada. «Banana» tiene seis caracteres, así que gana. Guarda la propia palabra cuando pase a ser la mejor para que el resultado identifique el elemento, no solo su longitud.

Una búsqueda lineal comprueba elementos en orden hasta encontrar una coincidencia o agotar los elementos. Una coincidencia puede ser un valor exacto, el primer elemento que cumple una condición o una prueba para responder a una pregunta de «¿hay alguno?» o «¿todos?».

Recuerda el éxito

names = ["Ana", "Ben", "Chen"]
found = False
for name in names:
    if name == "Ben":
        found = True
        break
if found:
    print("Ben is on the list")
else:
    print("Ben is not on the list")

La variable indicadora empieza en falso porque todavía no se ha encontrado nada. La primera comprobación, Ana, la deja sin cambios. La segunda encuentra a Ben, pone la variable indicadora en verdadero y sale. La salida es Ben is on the list.

La variable indicadora registra un evento a lo largo de toda la búsqueda. No la reinicies cada vez que no haya coincidencia. Si un bucle continúa después de encontrar a Ben y asigna found = False al llegar a Chen, se pierde el resultado de éxito. Del mismo modo, «no encontrado» corresponde al momento en que todas las comprobaciones han fallado, no a un else por elemento que anuncia el fracaso para Ana antes de examinar a Ben.

Primera o última coincidencia

Para [7, 4, 9, 10], el primer número par es 4 y el último es 10. Este bucle guarda el primero:

match = None
for n in [7, 4, 9, 10]:
    if n % 2 == 0:
        match = n
        break
print(match)

La salida es 4. Elimina el break y cada coincidencia nueva sobrescribirá la anterior, dejando 10. Si nada coincide, el valor guardado sigue siendo None. Antes de decidir qué almacenar, elige si la tarea pide saber si existe una coincidencia, el primer elemento, el último o una posición.

Para indicar una posición, mantén un contador que avance con cada elemento examinado y guárdalo cuando haya una coincidencia. Indica cómo se numeran las posiciones: contar desde 1 sitúa a Chen en la posición 3 de la lista de nombres; la numeración habitual de posiciones de Python empieza en 0.

Para «alguno» basta un éxito; para «todos» basta un fallo

Una búsqueda de «alguno» empieza en falso y pasa a verdadero con el primer elemento que cumple la condición. Puede detenerse ahí porque un éxito responde a la pregunta.

Una búsqueda de «todos» empieza en verdadero y pasa a falso en el primer fallo:

all_positive = True
for n in [3, 8, -1, 5]:
    if n <= 0:
        all_positive = False
        break
print(all_positive)

El tercer valor, -1, refuta «todos los valores son positivos», así que la salida es False. No hace falta examinar 5. Cero también incumpliría la condición porque positivo significa mayor que cero. Si no hay elementos, la variable indicadora sigue siendo verdadera: no ha aparecido ningún contraejemplo.

Pertenencia exacta y condiciones propias

Para comprobar solo la igualdad, "Ben" in names da directamente True o False. Un bucle hace visible el estado cambiante de la búsqueda y permite que la comprobación exprese una condición propia, como «la primera palabra con más de cinco caracteres».

Las comparaciones de cadenas son exactas. "ben" es distinto de "Ben", y "Ben " incluye un espacio al final. Una búsqueda de una de esas cadenas no debe considerar iguales las demás.

Un bucle anidado es un bucle dentro del cuerpo de otro. En cada iteración externa, el bucle interno empieza y realiza su trabajo. La variable externa permanece fija mientras cambia la interna.

Construye una fila cada vez

for row in range(1, 4):
    for col in range(1, 5):
        print(row * col, end=" ")
    print()

La salida tiene estas tres filas, cada una con un espacio al final después de su último número:

1 2 3 4 
2 4 6 8 
3 6 9 12 

Primero, row es 1 mientras col toma los valores del 1 al 4. Después, row pasa a ser 2 y el bucle interno empieza de nuevo en la columna 1. Por último, la fila 3 recibe las mismas cuatro columnas. El cuerpo interno se ejecuta doce veces.

end=" " sustituye el salto de línea habitual de print por un espacio. El print() vacío termina la fila. Está dentro del cuerpo externo, pero fuera del interno, así que se ejecuta tres veces. Darle un nivel más de sangría pondría cada número en su propia línea. Eliminar su sangría terminaría una línea una sola vez, después de ambos bucles.

Da a las variables de los bucles nombres distintos, como row y col. Reutilizar el nombre externo dentro del bucle interno sobrescribe el valor necesario para identificar la fila actual.

Cuenta el trabajo

Cuando cada pasada externa tiene el mismo número de pasadas internas, multiplica los conteos. Tres filas y cuatro columnas dan doce ejecuciones internas. Dos bucles de 100 pasadas cada uno dan 10 000 ejecuciones internas; tres niveles dan 1 000 000. Por tanto, un pequeño aumento de cada límite puede crear mucho más trabajo repetido.

Si el límite interno cambia con la variable externa, suma los conteos por separado:

for row in range(1, 5):
    for _ in range(row):
        print("*", end="")
    print()

Esto imprime:

*
**
***
****

Las longitudes de las filas son 1, 2, 3 y 4, con diez estrellas en total. Para un patrón con n filas de este tipo, el total es $n(n+1)\mathrm{/}2$. Multiplicar cuatro por cuatro supondría erróneamente que cada fila tiene cuatro estrellas.

Reinicia un resultado para cada grupo

Para sumar cada fila de la cuadrícula de multiplicaciones, establece row_total = 0 dentro del bucle externo, justo antes del interno. Suma row * col dentro del cuerpo interno e imprime row_total después del bucle interno. Las salidas son 10, 20 y 30.

Inicializar una sola vez, antes de ambos bucles, conserva también los totales de las filas anteriores. Imprimir después de cada fila da entonces 10, 30 y 60. Ambas ubicaciones conservan un resultado, pero una conserva el resultado de una fila y la otra conserva una suma acumulada de toda la cuadrícula.

Recorre combinaciones

Dos bucles sobre range(1, 7) recorren los 36 resultados ordenados de dos dados. El primer bucle proporciona el primer dado y el segundo proporciona el segundo. Una condición dentro del cuerpo interno puede contar los pares cuya suma es 7. La cumplen seis: (1, 6), (2, 5), (3, 4), (4, 3), (5, 2) y (6, 1). Invertir un par describe un resultado ordenado distinto.

Break y continue actúan sobre el bucle más interno que los contiene. En código anidado, localiza ese bucle antes de predecir qué ocurre después. Un break en el cuerpo interno no detiene por sí solo el bucle externo.

Sigue un break interno

for a in range(1, 4):
    for b in range(1, 4):
        if b > a:
            break
        print(a, b)

Con a = 1, se imprime el par 1 1. Cuando b pasa a ser 2, el break termina ese bucle interno. El bucle externo avanza a a = 2 y empieza un nuevo bucle interno con b igual a 1. Imprime 2 1 y 2 2, y después sale con break cuando b es igual a 3. Para a igual a 3, todos los valores de b permiten imprimir. Las seis líneas de salida son:

1 1
2 1
2 2
3 1
3 2
3 3

Detén ambos bucles con un resultado registrado

Una búsqueda de una combinación puede usar una variable indicadora y un break en cada nivel:

found = False
for a in range(1, 6):
    for b in range(1, 6):
        if a * b == 12:
            found = True
            break
    if found:
        break
if found:
    print(a, b)
else:
    print("No matching pair")

Las filas con a igual a 1 y 2 no tienen coincidencias. En la fila 3, b llega a 4 y el producto es 12. El break interno termina el bucle de b; la variable indicadora hace entonces que se ejecute el break externo. La salida final es 3 4.

La variable indicadora se inicializa antes de ambos bucles porque registra un resultado de toda la búsqueda. El if found: externo debe ir después del bucle interno, pero dentro del cuerpo externo. Su sangría hace que se compruebe una vez por fila completada o interrumpida.

Conserva los valores cuando continúa la búsqueda

Eliminar solo el break externo hace que la búsqueda continúe con las filas posteriores. En este ejemplo, una coincidencia posterior es 4 3, pero el bucle acaba examinando la fila 5 y termina con a = 5 y b = 5. Imprimir entonces las variables de los bucles da 5 5, no una coincidencia guardada.

Si la tarea necesita el último par coincidente, guarda best_a = a y best_b = b cada vez que haya una coincidencia. Esas variables separadas conservan una coincidencia mientras las variables de los bucles siguen cambiando. Comprueba la variable indicadora antes de mostrarlas cuando pueda no existir ninguna coincidencia.

Omite un par y continúa la fila

Un continue dentro del bucle interno pasa a su siguiente valor interno. Para dos bucles que recorren del 1 al 4, if a == b: continue antes del procesamiento omite cuatro pares iguales. Quedan doce pares ordenados de los dieciséis originales.

Un if también puede seleccionar pares sin saltar. Dos dados tienen tres pares ordenados con suma 10: (4, 6), (5, 5) y (6, 4). Una condición dentro del cuerpo interno los identifica.

El seguimiento de la ejecución consiste en ejecutar un programa a mano, sentencia a sentencia, mientras se registran sus valores y su salida. Una tabla de seguimiento da una columna a cada variable relevante. Indica si un valor se registra antes o después de una actualización para que las filas tengan un significado claro.

Sigue un bucle while

total = 0
i = 1
while i <= 4:
    total = total + i
    i = i + 1
print(total)

Empieza con total = 0 e i = 1. Comprueba la condición antes de entrar en el cuerpo. Por cada comprobación verdadera, ejecuta la suma antes del incremento:

La siguiente comprobación es 5 <= 4, que es falsa. No hay una quinta fila del cuerpo. El cuerpo se ejecuta cuatro veces, la condición se comprueba cinco veces y el print posterior al bucle muestra 10 una vez. Los valores finales son i = 5 y total = 10.

Distingue la comprobación fallida de una iteración: termina el bucle sin ejecutar su cuerpo. Si la condición inicial ya es falsa, no hay filas del cuerpo y las variables conservan sus valores iniciales.

El orden de las sentencias cambia el resultado

Si el incremento se mueve por encima de la suma, cada pasada usa el nuevo valor de i. Las cuatro sumas pasan a ser 2, 3, 4 y 5, y dan 14. La condición sigue comprobando i al principio, antes de ese incremento. Seguir solo los valores de la cabecera no mostraría qué valor usa realmente la suma.

Cuando un cuerpo contiene un break o un continue, deja de seguir sus líneas restantes en cuanto se produzca el salto. Con continue, vuelve a la cabecera o al siguiente elemento; con break, continúa después del bucle. Un seguimiento debe seguir esas rutas, no limitarse a copiar todas las sentencias del cuerpo en cada fila.

Sigue caracteres y bucles anidados

Un bucle for asigna el siguiente elemento al principio de su pasada:

rev = ""
for ch in "abc":
    rev = ch + rev
print(rev)

El texto guardado pasa a ser "a", después "ba" y después "cba". La salida es cba. Registra el texto real, incluido su orden, en lugar de escribir solo que «se añadió un carácter».

Para bucles anidados, usa una fila por cada iteración interna. Registra ambas variables de los bucles para que el valor externo se repita en las filas que le corresponden. En un bucle de dos filas y tres columnas, los valores de fila son 1, 1, 1, 2, 2, 2 y los de columna son 1, 2, 3, 1, 2, 3.

Genera un seguimiento con print

Un print("i =", i, "total =", total) temporal después de ambas actualizaciones en el bucle de suma muestra i y total al final de cada pasada. Colocarlo antes de las actualizaciones muestra otro momento. Compara la ubicación del print con las etiquetas de las columnas de tu tabla. Elimina las salidas de diagnóstico después de corregir el código para que no se conviertan en salida adicional del programa.

Para una pregunta de «¿qué imprime?», registra solo las sentencias que realmente imprimen. El cambio de una variable no es una salida por sí mismo; pueden producirse varias actualizaciones antes de un único print final.

Un error de desfase de una unidad hace que se recorra un valor de más o de menos, o desplaza una unidad los valores recorridos. Suele deberse al límite de parada excluido de un rango, a la elección entre < y <= o al valor inicial de un contador.

Define los extremos previstos

Para sumar del 1 al 10, range(1, 10) se queda corto. Proporciona solo del 1 al 9 y da un total de 45. range(1, 11) incluye el 10 y da 55. Para un rango de enteros ascendente con paso 1, usa el límite de parada n + 1 para incluir el valor final n.

Con el paso predeterminado de 1, range(a, b) proporciona b - a valores cuando b es mayor que a. Un break puede terminar el bucle antes de usarlos todos. Con otros tamaños de paso, enumera los valores de un caso pequeño o usa len(range(...)) para comprobar el conteo.

El conteo de un bucle while depende conjuntamente de su inicio, su comparación y su actualización. Para un entero no negativo n, con i += 1 al final de cada pasada y sin salida anticipada:

Con n igual a 0, los dos primeros omiten el cuerpo. El tercero se ejecuta una vez con i igual a 0. Este caso pequeño revela la pasada adicional sin seguir un bucle largo.

Límites de la cuenta atrás

Empezando en 5 e imprimiendo antes de n -= 1, while n > 0: imprime cinco valores y termina en 1. Usar n >= 0 imprime seis y termina en 0. Los rangos descendentes correspondientes son range(5, 0, -1) y range(5, -1, -1).

Comprueba también el orden. Actualizar un contador antes de usarlo puede desplazar todos los valores aunque el bucle tenga el número previsto de pasadas. Un seguimiento debe registrar el primer y el último valor que usa realmente el cálculo.

Elementos y huecos entre ellos

Un error de conteo de elementos e intervalos confunde el número de elementos con el de huecos. Cinco tramos de valla necesitan seis postes. Cinco números impresos necesitan solo cuatro separadores entre ellos.

for i in range(1, 6):
    print(i, end="-")

Esto imprime 1-2-3-4-5-, incluido un guion final no deseado. Cada print añade un guion después de un elemento, incluso del último.

Una corrección consiste en imprimir el primer elemento por separado y después un separador antes de cada elemento posterior:

print(1, end="")
for i in range(2, 6):
    print("-" + str(i), end="")
print()

La salida es 1-2-3-4-5. El bucle imprime cuatro fragmentos de guion y número, y el print vacío final termina la línea. Esta versión tiene un primer elemento conocido; un caso general de datos vacíos debe omitir también la impresión de ese primer elemento.

Comprueba la corrección con casos pequeños

Anota el primer valor previsto, el último y el conteo antes de cambiar el código. Elige los límites y la comparación que correspondan y después sigue una ejecución corta. Comprueba cero y un elemento, además de un caso normal. Cero revela trabajo que debería omitirse; uno revela un separador innecesario o una actualización de más. Cambia el límite que causa el error para que la repetición del código coincida con la tarea.