# ─────────────────────────────────────────────
# BLOQUE 1: Contar cuántas veces aparece la letra 'a' en una cadena
# ─────────────────────────────────────────────
# La cadena está en mayúsculas. Si buscamos solo "a" minúscula,
# no encontraríamos nada porque "A" y "a" son caracteres distintos para Python.
cadena="HOLA QUE TAL?"
# El contador acumulador empieza en 0 antes del bucle.
# Cada vez que encontremos una 'a' (en cualquier forma) sumaremos 1.
contador =0
# El for recorre la cadena carácter a carácter.
# En cada vuelta, letra toma el valor del siguiente carácter.
for letra in cadena:
# letra.lower() convierte la letra actual a minúscula SOLO para la comparación,
# no modifica la cadena original. Así podemos comparar siempre con "a" minúscula
# sin importar si en la cadena original era "A" o "a".
# Ejemplos:
# "A".lower() → "a" "H".lower() → "h" "a".lower() → "a"
if letra.lower()=="a":
contador+=1 # encontramos una 'a' (en cualquier forma), sumamos 1
# El print está fuera del bucle: muestra el total al terminar.
print(contador)
# Resultado: 2 (la 'A' de "HOLA" y la 'A' de "TAL")
#
# Alternativa sin bucle usando el método count():
# total = cadena.lower().count("a")
# print(total)
# Pero hacerlo con el bucle a mano ayuda a entender cómo funciona count() por dentro.
# ─────────────────────────────────────────────
# BLOQUE 2: Recorrer una cadena con letras y números mezclados
# ─────────────────────────────────────────────
# Una cadena puede contener cualquier tipo de carácter: letras, números, símbolos.
# El for los recorre todos sin distinción, uno a uno.
cadena="DX450"
# En cada vuelta, caracter toma el valor: "D", luego "X", luego "4", "5", "0"
for caracter in cadena:
print(caracter)
# Resultado:
# D
# X
# 4
# 5
# 0
#
# Fíjate en que "4", "5" y "0" son caracteres de texto, no números enteros.
# Para operar matemáticamente con ellos habría que convertirlos con int("4") = 4.
# ─────────────────────────────────────────────
# BLOQUE 3: Invertir una cadena letra a letra
# ─────────────────────────────────────────────
cadena="hola"
# La cadena invertida empieza vacía. La iremos construyendo dentro del bucle.
# Es un acumulador de texto en lugar de un acumulador numérico.
cadena_invertida=""
# El truco está en el orden en que pegamos cada letra nueva.
# En vez de añadir la letra al FINAL (como haríamos normalmente),
# la ponemos al PRINCIPIO: letra + cadena_invertida
# Así cada letra nueva empuja a las anteriores hacia la derecha.
for letra in cadena:
cadena_invertida=letra+cadena_invertida
# Traza paso a paso:
# Vuelta 1: letra="h" → cadena_invertida = "h" + "" = "h"
# Vuelta 2: letra="o" → cadena_invertida = "o" + "h" = "oh"
# Vuelta 3: letra="l" → cadena_invertida = "l" + "oh" = "loh"
# Vuelta 4: letra="a" → cadena_invertida = "a" + "loh" = "aloh"
print(cadena_invertida)
# Resultado: aloh
#
# Alternativa con slicing (atajo de Python para invertir cadenas):
# print(cadena[::-1])
# El [::-1] significa: recorre la cadena de atrás hacia adelante con paso -1.
# Pero construirlo con el bucle enseña el concepto de concatenación acumulativa.
# ─────────────────────────────────────────────
# BLOQUE 4: Sumar solo los dígitos numéricos de una cadena mixta
# ─────────────────────────────────────────────
# La cadena mezcla letras y números. Solo queremos sumar los dígitos.
cadena="2026J"
# Acumulador numérico que irá sumando los dígitos encontrados.
total=0
for letra in cadena:
# Los caracteres en Python tienen un orden (orden ASCII/Unicode).
# Los dígitos "0" al "9" están ordenados consecutivamente en ese sistema,
# por lo que comparar letra>="0" and letra<="9" es una forma válida de
# comprobar si un carácter es un dígito numérico.
# Ejemplos:
# "2" >= "0" and "2" <= "9" → True (es un dígito)
# "J" >= "0" and "J" <= "9" → False (es una letra)
# "6" >= "0" and "6" <= "9" → True (es un dígito)
if letra>="0" and letra<="9":
# int(letra) convierte el carácter "2" en el número entero 2.
# Sin esta conversión estaríamos sumando texto y daría error.
# Ejemplo: int("2") = 2 int("0") = 0 int("6") = 6
total=total+int(letra)
# Traza paso a paso:
# Vuelta 1: letra="2" → es dígito → total = 0 + 2 = 2
# Vuelta 2: letra="0" → es dígito → total = 2 + 0 = 2
# Vuelta 3: letra="2" → es dígito → total = 2 + 2 = 4 (segundo 2 del "2026")
# Vuelta 4: letra="6" → es dígito → total = 4 + 6 = 10
# Vuelta 5: letra="J" → NO es dígito → no entra en el if, total no cambia
print(total)
# Resultado: 10 (2 + 0 + 2 + 6 = 10)
#
# Alternativa usando el método isdigit():
# if letra.isdigit():
# total = total + int(letra)
# isdigit() devuelve True si el carácter es un dígito, False si no lo es.
# Es más legible que comparar con "0" y "9", pero ambas formas son correctas.
# ─────────────────────────────────────────────
# BLOQUE 5: Separar letras y números de una cadena mixta
# ─────────────────────────────────────────────
# La cadena mezcla letras y números sin ningún orden fijo.
cadena="23GH123JOP"
# Dos acumuladores de texto, uno para letras y otro para números.
# Ambos empiezan vacíos y se irán llenando dentro del bucle.
letras=""
numeros=""
# El for recorre todos los caracteres uno a uno.
for letra in cadena:
# Usamos la misma comparación del bloque anterior para detectar dígitos.
# Si el carácter está entre "0" y "9" es un número, si no es una letra.
if letra>="0" and letra<="9":
numeros=numeros+letra # pegamos el dígito al final de la cadena de números
else:
letras=letras+letra # pegamos la letra al final de la cadena de letras
# Traza paso a paso:
# Vuelta 1: letra="2" → es dígito → numeros="2", letras=""
# Vuelta 2: letra="3" → es dígito → numeros="23", letras=""
# Vuelta 3: letra="G" → NO dígito → numeros="23", letras="G"
# Vuelta 4: letra="H" → NO dígito → numeros="23", letras="GH"
# Vuelta 5: letra="1" → es dígito → numeros="231", letras="GH"
# Vuelta 6: letra="2" → es dígito → numeros="2312", letras="GH"
# Vuelta 7: letra="3" → es dígito → numeros="23123", letras="GH"
# Vuelta 8: letra="J" → NO dígito → numeros="23123", letras="GHJ"
# Vuelta 9: letra="O" → NO dígito → numeros="23123", letras="GHJO"
# Vuelta 10: letra="P" → NO dígito → numeros="23123", letras="GHJOP"
# Ambos print están fuera del bucle: muestran los resultados finales.
print(letras) # Resultado: GHJOP
print(numeros) # Resultado: 23123
#
# Fíjate en que los números se guardan como texto ("23123"), no como un entero.
# Si quisiéramos el valor numérico tendríamos que convertirlo: int(numeros) = 23123.
# Si quisiéramos SUMAR los dígitos en lugar de concatenarlos, usaríamos
# total = total + int(letra) como en el bloque anterior.
