Semestre 02, 2026
x = 1
while x <= 10:
print(x)
x = x + 1
Funciona, pero hay que inicializar, evaluar y actualizar a mano. Son tres responsabilidades repartidas en tres líneas distintas, y olvidar la última produce un ciclo infinito.
El ciclo for fue diseñado exactamente para este caso.
El ciclo for repite un bloque de código una vez por cada valor de una secuencia. La variable de control toma cada valor automáticamente en cada iteración.
for variable in secuencia:
# bloque de código
| Característica | while | for |
|---|---|---|
| Cuándo se usa | Cantidad desconocida | Cantidad conocida |
| Variable de control | Manual | Automática |
| Condición de parada | La escribe el programador | La define la secuencia |
| Riesgo de ciclo infinito | Sí | No con range |
range genera una secuencia de números enteros. Es la forma más común de controlar cuántas veces se repite un for.
Se puede llamar de tres formas, según cuánta información se le dé.
Las tres formas comparten una regla.El fin nunca se incluye.
Esta es la fuente número uno de errores al empezar con for.
range(fin)
El inicio es cero y el paso es uno aunque no se escriban. Lo único que hay que decir es dónde parar.
Recorrer cinco valores empezando desde cero.
for i in range(5):
print(i)
0
1
2
3
4
Exactamente cinco, con la variable tomando los valores de 0 a 4. Es la forma más corta de repetir algo una cantidad conocida de veces.
range(inicio, fin)
Ahora el inicio es explícito. El fin se comporta igual que antes, así que el último valor de la secuencia es el anterior.
Recorrer los valores del 2 al 7.
for i in range(2, 8):
print(i)
2
3
4
5
6
7
La cantidad de valores es la resta del fin menos el inicio. Aquí ocho menos dos da seis vueltas.
range(inicio, fin, paso)
El paso dice de cuánto es cada salto. El recorrido avanza 1, 4, 7 y el siguiente salto ya se pasaría del fin.
Avanzar de tres en tres desde el 1.
for i in range(1, 10, 3):
print(i)
1
4
7
El fin marca hasta dónde se puede llegar, no un valor que la secuencia deba alcanzar. Con paso 3 nunca cae justo en 10, y aun así el ciclo termina bien.
range(10, 0, -2)
Con paso negativo la secuencia va hacia atrás y el inicio es mayor que el fin. El cero tampoco entra, por eso el último valor es 2.
Secuencia vacía
range(10, 1, 1)
Secuencia correcta
range(10, 1, -1)
Si el paso se aleja del fin, la secuencia queda vacía y el ciclo no da ni una vuelta. No hay mensaje de error, el programa simplemente no hace nada.
| Expresión | Secuencia generada |
|---|---|
| range(5) | 0, 1, 2, 3, 4 |
| range(2, 8) | 2, 3, 4, 5, 6, 7 |
| range(1, 10, 3) | 1, 4, 7 |
| range(10, 0, -2) | 10, 8, 6, 4, 2 |
| range(1, 1) | vacía, el ciclo no se ejecuta |
range(1, 1000000) ocupa la misma memoria que range(1, 5).
Imprimir los números del 1 al 5.
for x in range(1, 6):
print("El valor de x es:", x)
Todo el control del ciclo cabe en la primera línea. No hay inicialización antes ni actualización adentro.
| Iteración | x | Pantalla |
|---|---|---|
| 1 | 1 | El valor de x es: 1 |
| 2 | 2 | El valor de x es: 2 |
| 3 | 3 | El valor de x es: 3 |
| 4 | 4 | El valor de x es: 4 |
| 5 | 5 | El valor de x es: 5 |
El ciclo termina solo cuando la secuencia se agota.
Sumar todos los números del 1 al 100.
total = 0
for numero in range(1, 101):
total = total + numero
print("La suma es:", total)
total = 0
for numero in range(1, 101):
total = total + numero
print("La suma es:", total)
El acumulador se crea antes del ciclo y arranca en cero, porque todavía no se ha sumado nada.
total = 0
for numero in range(1, 101):
total = total + numero
print("La suma es:", total)
La secuencia va del 1 al 100. El fin se escribe 101 justamente porque el último valor queda fuera. El ciclo da cien vueltas exactas.
total = 0
for numero in range(1, 101):
total = total + numero
print("La suma es:", total)
El patrón acumulador. La variable toma su propio valor anterior y le agrega el dato de esta vuelta. Así se arrastra un resultado de una iteración a la siguiente.
total = 0
for numero in range(1, 101):
total = total + numero
print("La suma es:", total)
El resultado se imprime fuera del ciclo, con la suma ya completa. La salida es 5050. Si esta línea estuviera indentada, el programa mostraría cien resultados parciales.
Contar desde 10 hasta 1 y mostrar el despegue.
for i in range(10, 0, -1):
print(i)
print("¡Despegue!")
10
9
8
...
1
¡Despegue!
Mostrar la tabla del 7.
numero = 7
for i in range(1, 11):
resultado = numero * i
print(numero, "x", i, "=", resultado)
7 x 1 = 7
7 x 2 = 14
7 x 3 = 21
...
7 x 10 = 70
frutas = ["manzana", "naranja", "uva", "mango"]
for fruta in frutas:
print("Fruta:", fruta)
Se imprime una línea por cada fruta de la lista, en el mismo orden en que fueron escritas.
Un string también es una secuencia, así que el for lo recorre letra por letra.
for letra in "Python":
print(letra)
Se imprimen seis líneas, una por cada carácter de la palabra.
Calcular el promedio de 5 notas ingresadas por el usuario.
total = 0
for i in range(1, 6):
nota = float(input("Ingresa la nota " + str(i) + ": "))
total = total + nota
promedio = total / 5
print("Promedio:", promedio)
Un for puede contener otro for dentro de su bloque. Por cada vuelta del ciclo externo, el interno se ejecuta completo.
for tabla in range(1, 4):
for i in range(1, 4):
print(tabla, "x", i, "=", tabla * i)
print("---")
for tabla in range(1, 4):
for i in range(1, 4):
print(tabla, "x", i, "=", tabla * i)
print("---")
El ciclo externo da tres vueltas, una por cada tabla. Su variable se queda quieta mientras el ciclo interno trabaja.
for tabla in range(1, 4):
for i in range(1, 4):
print(tabla, "x", i, "=", tabla * i)
print("---")
El ciclo interno arranca desde el principio en cada vuelta del externo. Su variable debe llamarse distinto para no pisar la otra.
for tabla in range(1, 4):
for i in range(1, 4):
print(tabla, "x", i, "=", tabla * i)
print("---")
Esta línea pertenece al ciclo interno y se ejecuta nueve veces en total, tres por cada tabla.
for tabla in range(1, 4):
for i in range(1, 4):
print(tabla, "x", i, "=", tabla * i)
print("---")
La indentación la deja fuera del ciclo interno pero dentro del externo, así que se imprime tres veces, una al cerrar cada tabla.
continue salta a la siguiente iteración sin terminar el ciclo. Las líneas que quedan debajo de él se omiten en esa vuelta.
for x in range(1, 11):
if x % 2 != 0:
continue
print(x)
Se imprimen 2, 4, 6, 8 y 10. Cuando el número es impar el continue corta esa vuelta y el for pasa al siguiente valor del range.
break detiene un ciclo de forma abrupta desde adentro. Existe en Python, pero en este curso no se usará.
Cuando se usa break, el ciclo ya no se controla por su secuencia.
En lugar de esto
for i in range(1, 11):
if i == 5:
break
print(i)
Se escribe esto
for i in range(1, 5):
print(i)
La condición de parada queda explícita en el range. El ciclo es claro, predecible y fácil de leer.
for i in range(10):
print(i)
Imprime del 0 al 9, no del 0 al 10. El valor final nunca entra en la secuencia.
for i in range(1, 6):
print(i)
i = i + 10
La última línea no tiene efecto sobre el ciclo. En la siguiente vuelta la variable vuelve a tomar el valor que le toca del range.
for i in range(10, 1, 1):
print(i)
No imprime nada. El paso es positivo pero el inicio es mayor que el fin, así que la secuencia queda vacía. Lo correcto es range(10, 1, -1).
for i in 5:
print(i)
El programa falla con TypeError porque un número no es una secuencia. Lo correcto es recorrer range(5).
for i in range(1, 4):
print(i)
print("Fin")
La última línea está fuera del ciclo y se ejecuta una sola vez. La indentación es lo único que marca qué pertenece al bloque.
| Situación | Estructura |
|---|---|
| Repetir exactamente n veces | for |
| Recorrer una lista o un string | for |
| Repetir mientras una condición | while |
| Validar entrada del usuario | while |
| No se sabe cuántas repeticiones | while |
Si alguna respuesta es sí, el ciclo que se necesita es un for.