# ─────────────────────────────────────────────
# DESCRIPCIÓN GENERAL DEL PROGRAMA
# ─────────────────────────────────────────────
# Este programa practica las operaciones más habituales sobre listas:
# - Encontrar el número más pequeño de una lista.
# - Encontrar el mayor y el menor
# - Dado un número, indica si está en la lista.
# - Añadido: contar cuantas veces aparece
# - Cuenta cuántas veces aparece cada número.
# La lista de trabajo. Contiene 20 números, algunos repetidos (3, -2, 7, 0)
# y algunos negativos. Todos los ejercicios trabajan sobre esta misma lista.
lista=[3, -2, 7, 0, 10, -5, 4, 8, -1, 6, 2, -3, 9, 1, -4, 5, 7, 0, 3, -2]
# ─────────────────────────────────────────────
# BLOQUE 1: Encontrar el mayor y el menor
# ─────────────────────────────────────────────
# Partimos de que el primer elemento es tanto el menor como el mayor provisional.
# lista[0] accede al primer elemento de la lista, que es el 3.
# Conforme recorramos la lista iremos actualizando estos valores si encontramos
# algo más pequeño o más grande.
menor=lista[0]
mayor=lista[0]
# Recorro la lista ← comentario original
# En cada vuelta 'numero' toma el valor del siguiente elemento de la lista.
for numero in lista:
# Si el número actual es menor que el menor que llevamos hasta ahora,
# actualizamos el menor. Así al final de la lista menor tendrá el mínimo real.
if numero<menor:
menor=numero
# Mismo patrón pero para el mayor.
# Usamos dos if separados (no elif) porque queremos comparar ambas condiciones
# en cada vuelta, aunque en la práctica un número nunca puede ser a la vez
# mayor Y menor que el provisional.
if numero>mayor:
mayor=numero
# Imprimimos nuestro resultado y lo comparamos con las funciones built-in de Python.
# min(lista) y max(lista) hacen exactamente lo mismo que nuestro bucle pero en una línea.
# Si ambas columnas coinciden, nuestro algoritmo es correcto.
print(menor,min(lista)) # Resultado: -5 -5
print(mayor,max(lista)) # Resultado: 10 10
# Sugerencia: en la práctica siempre usarías min() y max() directamente.
# Hacer el bucle a mano sirve para entender cómo funcionan por dentro.
# ─────────────────────────────────────────────
# BLOQUE 2: Buscar si un número está en la lista
# ─────────────────────────────────────────────
# Dado un número, indica si está en la lista. ← comentario original
# El número que queremos encontrar.
# Cambia este valor para buscar cualquier otro número.
buscado=9 # Número a buscar
# La bandera (flag) empieza en False.
# Se convertirá en True solo si encontramos el número.
encontrado=False
for numero in lista:
if numero==buscado:
encontrado=True
# break interrumpe el bucle inmediatamente en cuanto encuentra el número.
# No tiene sentido seguir recorriendo el resto de la lista si ya lo encontramos.
# Sin el break el bucle seguiría hasta el final aunque ya supiera la respuesta.
break
# Este if está FUERA del bucle. Se ejecuta una sola vez cuando el bucle ha terminado.
# En ese momento encontrado es True (si lo encontró) o False (si recorrió todo sin éxito).
if encontrado:
print("Encontrado")
else:
print("No encontrado")
# Resultado: Encontrado (el 9 sí está en la lista, en la posición 12)
# Sugerencia: Python tiene una forma más corta de hacer esto sin bucle ni bandera:
# if buscado in lista:
# print("Encontrado")
# El operador 'in' hace la búsqueda por nosotros. Lo veremos más adelante en el código.
# ─────────────────────────────────────────────
# BLOQUE 3: Contar cuántas veces aparece un número concreto
# ─────────────────────────────────────────────
# Añadido: contar cuantas veces aparece ← comentario original
# Ahora buscamos el 3. Fíjate que hay DOS 3 en la lista (posiciones 0 y 18).
buscado=3
# El contador acumulador empieza en 0.
# Cada vez que encontremos el número buscado, sumamos 1.
contador=0
for numero in lista:
if numero==buscado:
contador+=1 # equivale a: contador = contador + 1
# Aquí NO usamos break porque queremos contar TODAS las apariciones,
# no solo la primera. El bucle recorre la lista entera.
print(f"El número {buscado} aparece {contador} veces")
# Resultado: El número 3 aparece 2 veces
# Sugerencia: Python tiene el método count() que hace lo mismo en una línea:
# print(lista.count(3)) → 2
# ─────────────────────────────────────────────
# BLOQUE 4: Contar cuántas veces aparece CADA número (con bucles anidados)
# ─────────────────────────────────────────────
# Cuenta cuántas veces aparece cada número. ← comentario original
# Esta línea está comentada, es una lista de prueba más pequeña que el autor usó
# para verificar el comportamiento antes de aplicarlo a la lista grande.
#lista=[1,2,2,4]
# Bucle exterior: recorre cada número de la lista como "el buscado del momento".
# En cada vuelta buscado toma un valor de la lista: 3, luego -2, luego 7...
for buscado in lista:
# El contador se reinicia a 0 en cada vuelta del exterior.
# Esto es fundamental: si no lo reiniciáramos, el contador seguiría acumulando
# de una búsqueda a la siguiente y los resultados serían incorrectos.
contador = 0
# Bucle interior: recorre TODA la lista buscando el número actual.
# Por cada vuelta del exterior, el interior da 20 vueltas (tamaño de la lista).
# Total de comparaciones: 20 × 20 = 400 comparaciones en total.
for numero in lista:
if numero == buscado:
contador += 1
# Este print está dentro del exterior pero fuera del interior.
# Se ejecuta una vez por cada número buscado.
print(f"El número {buscado} aparece {contador} veces")
# Resultado: imprime 20 líneas, una por cada elemento.
# Los repetidos aparecen varias veces: el 3 aparece dos veces en el resultado
# (una cuando buscado=3 la primera vez y otra cuando buscado=3 la segunda vez).
# Esto se mejorará en el último bloque usando una lista sin repetidos.
# Sugerencia: existe una estructura llamada diccionario (dict) que es perfecta
# para este tipo de conteos, pero eso es un tema más avanzado.
# ─────────────────────────────────────────────
# BLOQUE 5: Separar pares e impares con append
# ─────────────────────────────────────────────
# para añadir elementos a una lista usamos append ← comentario original
# append(elemento) añade un elemento al FINAL de una lista existente.
# Dos listas vacías que iremos llenando dentro del bucle.
# Empiezan vacías [] y crecen con cada append.
pares=[]
impares=[]
for numero in lista:
# numero%2 es el resto de dividir numero entre 2.
# Si el resto es 0 el número es par (4%2=0, 6%2=0, 0%2=0).
# Si el resto es 1 (o -1 para negativos) el número es impar.
if numero%2==0:
pares.append(numero) # añade numero al final de la lista pares
else:
impares.append(numero) # añade numero al final de la lista impares
# Los print están FUERA del bucle: muestran las listas completas al terminar.
print(f"Pares: {pares}")
print(f"Impares: {impares}")
# Resultado:
# Pares: [-2, 0, 10, 4, 8, 6, 2, 0, -2] (divisibles entre 2, incluido el 0)
# Impares: [3, 7, -5, -1, -3, 9, 1, -4, 5, 7, 3]
# Sugerencia: Python tiene una forma compacta llamada comprensión de lista:
# pares = [n for n in lista if n % 2 == 0]
# Pero usar append con el bucle es más claro cuando se está aprendiendo.
# ─────────────────────────────────────────────
# BLOQUE 6: Separar positivos y negativos
# ─────────────────────────────────────────────
# Con la otra lista separar entre positivos y negativos. El 0 lo ponemos en positivos
# ← comentario original. La decisión de incluir el 0 en positivos es arbitraria
# y se refleja en la condición: >= 0 en lugar de > 0.
positivos=[]
negativos=[]
for numero in lista:
# El 0 entra aquí porque 0 >= 0 es True.
# Si quisiéramos el 0 en negativos cambiaríamos >= por >.
if numero>=0:
positivos.append(numero)
else:
negativos.append(numero)
# len() devuelve el número de elementos que tiene una lista.
# len(positivos) nos dice cuántos números positivos (incluido el 0) hay.
print(f"Positivos: {positivos} y tiene {len(positivos)} elementos")
print(f"Negativos: {negativos}")
# Resultado:
# Positivos: [3, 7, 0, 10, 4, 8, 6, 2, 9, 1, 5, 7, 0, 3] y tiene 14 elementos
# Negativos: [-2, -5, -1, -3, -4, -2]
# ─────────────────────────────────────────────
# BLOQUE 7: Comprobar si un elemento está en una lista con 'in'
# ─────────────────────────────────────────────
# Como sabe si un elemento está en una lista ← comentario original
# Este bloque muestra la forma corta de buscar, sin necesidad de bucle ni bandera.
buscado=34
# El operador 'in' recorre la lista internamente y devuelve True o False.
# Es equivalente al bucle con bandera del bloque 2, pero en una sola palabra.
# Si el 34 estuviera en la lista, entraría por el if. Como no está, entra por el else.
if buscado in lista:
print(f"{buscado} está en lista")
else:
print(f"{buscado} NO está en lista")
# Resultado: 34 NO está en lista
# 'not in' es el contrario: devuelve True si el elemento NO está en la lista.
# Ejemplo:
# if buscado not in lista:
# print("No está")
# ─────────────────────────────────────────────
# BLOQUE 8: Eliminar repetidos y contar apariciones de forma limpia
# ─────────────────────────────────────────────
# Redefinimos la lista con una más pequeña y con repetidos evidentes para ver mejor el resultado.
# Esta asignación sobreescribe la lista original del principio del programa.
lista=[1,2,2,4,1,4,9]
# Lista auxiliar donde guardaremos solo los valores únicos (sin repetidos).
# Iremos añadiendo números uno a uno, pero solo si no están ya dentro.
sin_repetidos=[]
for numero in lista:
# 'not in' comprueba si numero NO está ya en sin_repetidos.
# Si no está → lo añadimos. Si ya está → lo ignoramos (no entra en el if).
# Traza con la lista [1,2,2,4,1,4,9]:
# numero=1: sin_repetidos=[] → 1 no está → añadimos → [1]
# numero=2: sin_repetidos=[1] → 2 no está → añadimos → [1,2]
# numero=2: sin_repetidos=[1,2] → 2 SÍ está → ignoramos → [1,2]
# numero=4: sin_repetidos=[1,2] → 4 no está → añadimos → [1,2,4]
# numero=1: sin_repetidos=[1,2,4] → 1 SÍ está → ignoramos → [1,2,4]
# numero=4: sin_repetidos=[1,2,4] → 4 SÍ está → ignoramos → [1,2,4]
# numero=9: sin_repetidos=[1,2,4] → 9 no está → añadimos → [1,2,4,9]
if not numero in sin_repetidos:
sin_repetidos.append(numero)
# Ahora sin_repetidos = [1, 2, 4, 9] — solo los valores únicos, en orden de aparición.
# Bucle exterior: recorre solo los valores únicos (4 vueltas en vez de 7).
# Así cada número aparece exactamente una vez en el resultado, sin duplicados.
for buscado in sin_repetidos:
# Reiniciamos el contador en cada valor único buscado.
contador = 0
# Bucle interior: recorre la lista ORIGINAL completa (con repetidos)
# para contar cuántas veces aparece el valor buscado.
for numero in lista:
if numero == buscado:
contador += 1
# Este print está dentro del exterior pero fuera del interior.
# Imprime el número y su contador, pero SIN salto de línea al final (end=" ").
# Así el siguiente print (vez/veces) se imprime en la misma línea.
print(f"El número {buscado} aparece {contador}", end=" ")
# Gramática correcta: "1 vez" en singular, "2 veces" en plural.
# Este if decide qué palabra usar según el valor del contador.
# Al no tener end=" ", este print sí añade el salto de línea normal al final.
if contador != 1:
print("veces")
else:
print("vez")
# Resultado final:
# El número 1 aparece 2 veces
# El número 2 aparece 2 veces
# El número 4 aparece 2 veces
# El número 9 aparece 1 vez ← singular correcto gracias al if de arriba
# Sugerencia: el mismo resultado puede obtenerse con el método count() y sin bucles anidados:
# for numero in sin_repetidos:
# veces = lista.count(numero)
# print(f"El número {numero} aparece {veces} {'vez' if veces == 1 else 'veces'}")
# La expresión 'vez' if veces == 1 else 'veces' es un if de una sola línea (operador ternario).
