# ─────────────────────────────────────────────
# BLOQUE 1: Recorrer una lista de frutas
# ─────────────────────────────────────────────
# Una lista es una colección de elementos entre corchetes, separados por comas.
# Cada elemento va entre comillas porque son cadenas de texto (strings).
frutas=["melón", "sandía", "banana", "melocotón"]
# El bucle for recorre la lista elemento a elemento.
# En cada vuelta, la variable fruta toma el valor del elemento actual.
# Vuelta 1: fruta = "melón"
# Vuelta 2: fruta = "sandía"
# Vuelta 3: fruta = "banana"
# Vuelta 4: fruta = "melocotón"
# Cuando se acaban los elementos, el bucle termina solo.
for fruta in frutas:
print(fruta)
# La variable puede llamarse como quieras. fruta es un nombre descriptivo
# que nos ayuda a entender qué contiene, pero podría llamarse x, elemento o cosa.
# Variación con índice (si también quisieras saber la posición):
# for i, fruta in enumerate(frutas):
# print(i, fruta)
# Resultado: 0 melón / 1 sandía / 2 banana / 3 melocotón
# ─────────────────────────────────────────────
# BLOQUE 2: Recorrer una cadena de texto carácter a carácter
# ─────────────────────────────────────────────
# Una cadena de texto (string) también es iterable: el for puede recorrerla
# letra a letra igual que recorre una lista elemento a elemento.
# La variable puede tener cualquier nombre, aunque sea absurdo como cacahuete_pelado.
# Esto demuestra que Python no exige nombres con sentido, pero tú sí deberías ponerlos.
for cacahuete_pelado in "hola que tal":
print(cacahuete_pelado)
# Cada carácter se imprime en su propia línea, incluyendo los espacios.
# Resultado: h / o / l / a / / q / u / e / / t / a / l
# (los espacios también son caracteres y también se imprimen)
#
# Un nombre más descriptivo sería:
# for caracter in "hola que tal":
# print(caracter)
# ─────────────────────────────────────────────
# BLOQUE 3: Recorrer un rango de números con range()
# ─────────────────────────────────────────────
# range(inicio, fin) genera una secuencia de números enteros.
# IMPORTANTE: el número final NO se incluye. range(1, 11) genera del 1 al 10.
# Para incluir el 11 habría que escribir range(1, 12).
for numero in range(1,11):
print(numero)
# Variaciones útiles de range():
# range(5) → del 0 al 4 (si solo hay un argumento, empieza en 0)
# range(1, 11) → del 1 al 10
# range(0, 11, 2) → 0, 2, 4, 6, 8, 10 (tercer argumento es el paso o salto)
# range(10, 0, -1)→ 10, 9, 8... 1 (paso negativo = cuenta hacia atrás)
# ─────────────────────────────────────────────
# BLOQUE 4: Sumar números con un acumulador
# ─────────────────────────────────────────────
# suma los números del 1 al 100 ← comentario original
# (aunque el range solo llega al 5, el comentario indica la intención original)
# El acumulador es una variable que empieza en 0 y va acumulando valores.
# Es el patrón más habitual en bucles: inicializar antes, acumular dentro.
suma=0
# range(1, 6) genera: 1, 2, 3, 4, 5 (el 6 no se incluye)
for numero in range(1,6):
suma+=numero # suma += numero es lo mismo que suma = suma + numero
# Vuelta 1: suma = 0 + 1 = 1
# Vuelta 2: suma = 1 + 2 = 3
# Vuelta 3: suma = 3 + 3 = 6
# Vuelta 4: suma = 6 + 4 = 10
# Vuelta 5: suma = 10 + 5 = 15
# El print está FUERA del bucle (sin sangría).
# Si estuviera dentro, imprimiría el valor parcial en cada vuelta.
# Al estar fuera, solo imprime el resultado final una vez.
print(suma)
# Resultado: 15
#
# Para sumar del 1 al 100 como dice el comentario original,
# solo habría que cambiar range(1,6) por range(1,101)
# La famosa fórmula de Gauss da el mismo resultado: n*(n+1)/2 = 100*101/2 = 5050
# ─────────────────────────────────────────────
# BLOQUE 5: Contar las letras 'a' en una cadena
# ─────────────────────────────────────────────
# COntar el número de aes en una cadena ← comentario original (con errata en la C)
# Recorro la cadena y si es una a, la cuento ← estrategia en comentario original
cadena="hola que tal estás, Bárbara"
# ¿Sé recorrer una cadena? ← preguntas guía del autor para plantearse el problema
# ¿Sé como averiguar si una letra es una a?
# ¿Sé contar?
# Estas tres preguntas son exactamente cómo debe pensar un programador:
# descomponer el problema en partes pequeñas antes de escribir código.
# El contador empieza en 0. Cada vez que encontremos una 'a' sumaremos 1.
cuenta=0
# El for recorre la cadena carácter a carácter, igual que en el bloque 2.
for letra in cadena:
# Comprobamos si la letra actual es una 'a' minúscula o una 'á' con tilde.
# Sin la segunda condición, la 'á' de "estás" y las de "Bárbara" no se contarían.
# Nota: la 'B' mayúscula de "Bárbara" no se cuenta porque solo buscamos minúsculas.
# Si también quisiéramos contar la 'A' mayúscula habría que añadir: or letra == "A"
if letra == "a" or letra == "á":
cuenta+=1 # encontramos una 'a', sumamos 1 al contador
# El print está fuera del bucle: muestra el total al terminar de recorrer toda la cadena.
# La f-string permite insertar la variable cuenta directamente en el texto con {cuenta}.
print(f"La cadena tiene {cuenta} letras 'a'")
# Resultado: La cadena tiene 6 letras 'a'
# Las 'a' encontradas son: hol[a] qu[e] t[a]l est[á]s, B[á]rb[a]r[a]
# (posiciones 3, 9, 11, 17, 21, 24... aprox)
#
# Alternativa con método built-in (sin bucle):
# total = cadena.count("a") + cadena.count("á")
# print(total)
# Python tiene muchas funciones ya hechas, pero construir el bucle a mano
# es la mejor forma de entender cómo funcionan por dentro.
