<jupyter_start><jupyter_text>Bucle ```for```Cuando se sabe el número de ciclos que debe dar el loop es mejor usar un bucle ```for```.<jupyter_code>for i in range(10):      # objeto de tipo range
  print(i)
for _ in range(3):   # también se puede usar como variable _, que es habitual cuando luego no se utiliza
  print("Hola")
for letra in "Europa":      # string
  print(letra)
for numero in [10,20,30,40]:      # lista
  print(numero)
for dia in ("lunes","martes","miércoles","jueves","viernes","sábado","domingo"):     # tupla
  print(dia)<jupyter_output>lunes
martes
miércoles
jueves
viernes
sábado
domingo<jupyter_text>Countdown to Zero (Cuenta atrás)Realizar una cuenta regresiva desde 10 hasta 0.  Solución 1<jupyter_code>for i in range(10,-1,-1):
  print(i)<jupyter_output>10
9
8
7
6
5
4
3
2
1
0<jupyter_text>Solución 2<jupyter_code>for i in range(11):
  print(10-i)<jupyter_output>10
9
8
7
6
5
4
3
2
1
0<jupyter_text>Solución 3 usando un bucle ```while```Al comparar las resolución con ambos búcles vemos que con un ```for``` se resuelve en menos líneas en este caso.  Un bucle ```for``` será más interesante que un bucle ```while``` normalmente pero es necesario conocer cuantos ciclos se van a realizar.<jupyter_code>i = 10
while i>=0:
  print(i)
  i -= 1<jupyter_output>10
9
8
7
6
5
4
3
2
1
0<jupyter_text>Reto 8.1. Bucle ```for``` con los paresCrear un bucle ```for``` con los pares entre 10 y 30, ambos incluidos y en orden inverso.  Sumar cinco números* Pedir al usuario cinco números.* Después de introducir cada número se proporcionará el valor acumulado.  Solución ```for```Podemos solucionar este caso con ```for``` o con ```while```, pero es más interesate resolverlo con ```for``` ya que sabemos cuantas iteraciones son necesarias.<jupyter_code>total = 0
for i in range(5):
  valor = float(input(f"Indique el número {i+1}: "))
  total += valor
  print(f"El acumulado asciende a {total}.")<jupyter_output>Indique el número 1: 1
El acumulado asciende a 1.0.
Indique el número 2: 2
El acumulado asciende a 3.0.
Indique el número 3: 3
El acumulado asciende a 6.0.
Indique el número 4: 4
El acumulado asciende a 10.0.
Indique el número 5: 90
El acumulado asciende a 100.0.<jupyter_text>Sumar hasta llegar a 100Programa que va pidiendo números hasta llegar a 100 o más, momento en el que termina.  Ir mostrando el acumulado en cada tirada.  Solución ```while```En este caso, como no sabemos cuantas tiradas serán necesarias, es recomendable utilizar un bucle ```while```.<jupyter_code>total = 0
while total<100:
  n = int(input("Introduzca un número entero: "))
  total += n
  print(f"El acumulado asciende a {total}.")

print("Fin del programa.")<jupyter_output>Introduzca un número entero: 10
El acumulado asciende a 10.
Introduzca un número entero: 60
El acumulado asciende a 70.
Introduzca un número entero: 40
El acumulado asciende a 110.
Fin del programa.<jupyter_text>Añadir un elemento a una listaPodemos añadir un elemento al final de una lista con ```append```.* Crear una lista de 8 números aleatorios entre 1 y 9.* Ir mostrando la lista a medida que se van añadiendo elementos.<jupyter_code>import random
lista=[]                         # inicializamos una lista vacía
for i in range(8):
  n = random.randint(1,10)
  lista.append(n)                # append añade el elemento al final de la lista
  print(lista)<jupyter_output>[2]
[2, 1]
[2, 1, 5]
[2, 1, 5, 7]
[2, 1, 5, 7, 6]
[2, 1, 5, 7, 6, 8]
[2, 1, 5, 7, 6, 8, 6]
[2, 1, 5, 7, 6, 8, 6, 2]<jupyter_text>Reto 8.2. Generar listas de aleatorios que sumen 100Generar diez listas de números aleatorios, entre 10 y 20, ambos incluidos, que sumen exactamente 100.  Recorrer un dato secuencia con un ```for```* Para ver si un dato está en una lista o* Para ver si un dato está en una tupla o* Para ver si un caracter está en un stringen Python podemos utilizar el comando ```in```. Sería la forma más sencilla.También podemos utilizar un bucle ```for``` para recorrer la secuencia e ir comprobando si está el dato.<jupyter_code># resuelto con in

palabra = "ahorrar"
'h' in palabra
existe = False            # bandera inicializada como False
palabra = "ahorrar"
for caracter in palabra:
  if caracter == "h": existe = True

print("¿Está la 'h' en la palabra?", existe)
lista = [2,5,9,14,19,20]
9 in lista 
lista = [2,5,9,14,19,20]
for num in lista:
  if num==9:
    print("El número si está en la lista.")
  else:
    print("El número no está en la lista.")<jupyter_output>El número no está en la lista.
El número no está en la lista.
El número si está en la lista.
El número no está en la lista.
El número no está en la lista.
El número no está en la lista.<jupyter_text>Es posible que no deseemos que nos informe de si está o no el número analizado por cada ciclo del bucle.  Vamos a incluir una bandera para saber si está y mostrarlo solo al final.<jupyter_code>lista = [2,5,9,14,19,20]
esta = False                 # bandera
for num in lista:
  if num==9:
    esta = True

if esta:                      # analizamos si la bandera es True o False
  print("El número si está en la lista.")
else:
  print("El número no está en la lista.")<jupyter_output>El número si está en la lista.<jupyter_text>Otra forma de solucionarlo es accediendo a cada elemento de la lista con lista[i].  En este caso, i es el índice que va entre 0 y la longitud de la cadena -1.<jupyter_code>lista = [2,5,9,14,19,20]
existe = False                # bandera
for i in range(len(lista)):   # recorremos todos los index desde cero hasta la longitud-1
  if lista[i]==9:             # accedemos al elemento i-ésimo
    existe = True

if existe:                    # convertimos la bandera 'existe' en un si o un no según sea True o False
  sino="si"
else:
  sino="no"

print(f"El número 9 {sino} esta en la lista.")<jupyter_output>El número 9 si esta en la lista.<jupyter_text>Generar una lista de números aleatorios sin repeticiónLa librería ```random``` tiene una función que nos permite generar listas, sin repetición, utilizando la función sample.<jupyter_code>import random
# genera 5 números aleatorios entre 10 and 20
randomlist = random.sample(range(10, 21), 5)
print(randomlist)
# ordenando la lista
randomlist.sort()
print(randomlist)<jupyter_output>[10, 13, 15, 16, 17]<jupyter_text>Comprobar si un número está en una lista de números aleatorios* Generar una lista de 20 números aleatorios enteros entre 1 y 99, ambos incluidos.* Imprimir la lista ordenada.* Generar un número aleatorio entero entre 1 y 99* Imprimir el número.* Comprobar si ese número sumado a alguno de los elementos de la lista da 100.  Solución 1. Usando ```in```<jupyter_code>import random
lista = random.sample(range(1, 100), 20)
lista.sort()
print(lista)
num =random.randint(1,100)
print(num)
if 100-num in lista:                               # si 100-num está en la lista quiere decir que num más algún valor de la lista suman 100
  print(f"El número {num} cumple la condición.")<jupyter_output>[1, 3, 11, 21, 24, 29, 33, 37, 44, 45, 55, 56, 59, 67, 84, 86, 93, 96, 98, 99]
67
El número 67 cumple la condición.<jupyter_text>Solución 2. Usando ```for``` y una bandera lógica<jupyter_code>import random
lista = random.sample(range(1, 100), 20)
lista.sort()
print(lista)
num =random.randint(1,100)
print(num)

encontrado = False            # bandera

for elemento in lista:        # para cada elemento en la lista
  if num+elemento==100:       # si se cumple la condición
    encontrado = True         # hacemos que la bandera sea True

if encontrado:                # si la bandera es True
  print(f"El número {num} si cumple la condición.")
else:
  print(f"El número {num} no cumple la condición.")<jupyter_output>[7, 9, 17, 20, 28, 32, 33, 38, 53, 54, 57, 58, 61, 64, 66, 67, 82, 83, 91, 96]
80
El número 80 si cumple la condición.<jupyter_text>Reto 8.3. Ver en cuantas tiradas un número está en una lista de números aleatorios* Generar una lista de 20 números aleatorios enteros entre 1 y 99, ambos incluidos.* Generar un número aleatorio entero entre 1 y 99* Comprobar si ese número sumado a alguno de los elementos de la lista da 100.* Si ese número no da 100 con ninguno de los elementos de la lista, en otra tirada, generar otro número y comprobar la condición de la suma.* Al final se pide mostrar por pantalla: - La lista ordenada - Los dos números que sumados dan 100 - El número de tiradas que han sido necesarias para conseguirlo.  Generación de una lista de números aleatorios con repeticiónUsando la librería ```random``` y la función ```choices``` podemos generar una lista de números aleatorios enteros con posible repetición.<jupyter_code>import random
random.seed()
lista = random.choices(range(10), k=8)   # elige 8 elementos, con posible repetición, del rango que va entre 0 y 9
print(lista)                             # imprimimos la lista
lista.sort()
lista                                    # imprimimos la list ordenada<jupyter_output>[41, 25, 20, 11, 22, 15, 13, 28, 33, 39, 14, 37, 39, 20, 21, 32, 35, 24, 20]<jupyter_text>Cuantas veces aparece un número en una litaDada una lista decir cuantas veces aparece un elemento.Para resolverlo, es preferible usar un ```for``` en lugar de un ```in``` ya que la instrucción ```in``` solo nos proporcionará si el número está o no en la lista, pero no nos dice cuantas veces aparece.<jupyter_code>lista = [41, 25, 20, 11, 22, 15, 13, 28, 33, 39, 14, 37, 39, 20, 21, 32, 35, 24, 20]
print(lista)
num = 20                 # queremos saber cuantas veces aparece le 20 en la lista
contador = 0
for elemento in lista:   # para cada elemento de la lista
  if elemento==num:
    contador += 1

print(f"El número {num} aparece {contador} veces en la lista.")
lista.sort()
print(lista)<jupyter_output>[41, 25, 20, 11, 22, 15, 13, 28, 33, 39, 14, 37, 39, 20, 21, 32, 35, 24, 20]
El número 20 aparece 3 veces en la lista.
[11, 13, 14, 15, 20, 20, 20, 21, 22, 24, 25, 28, 32, 33, 35, 37, 39, 39, 41]<jupyter_text>Reto 8.4. Frecuencia de cada elemento de una lista* Generar una lista de 19 números aleatorios enteros, entre 1 y 30, ambos incluidos, con posible repetición.* Mostrar en pantalla, cada elemento de esa lista en orden creciente, indicando cuántas veces aparece, esto es, indicando su frecuencia.  Dada una tupla con los meses calcular cuántos tienen 'r'.Mostrar los meses que tienen 'r' y decir cuántos son.  El saber popular dice que los meses con 'r' son buenos meses para el marisco.  Solución 1Imprimiendo los meses.<jupyter_code>meses = ("Enero","Febrero","Marzo","Abril","Mayo","Junio","Julio","Agosto","Septiembre","Octubre","Noviembre","Diciembre")
contador = 0
for mes in meses:
  if 'r' in mes:
    contador += 1
    print(mes)

print(f"Existen {contador} meses con 'r'.")<jupyter_output>Enero
Febrero
Marzo
Abril
Septiembre
Octubre
Noviembre
Diciembre
Existen 8 meses con 'r'.<jupyter_text>Solución 2Creando una tupla con los meses que cumplen la condición.<jupyter_code>meses = ("Enero","Febrero","Marzo","Abril","Mayo","Junio","Julio","Agosto","Septiembre","Octubre","Noviembre","Diciembre")
contador = 0
meses_elegidos = ()    # inicializamos una tupla vacía

for mes in meses:
  if 'r' in mes:
    contador += 1
    meses_elegidos += (mes,)   # añadimos los meses a la tupla, la coma es necesaria

print(f"Existen {contador} meses con 'r'.")
print(meses_elegidos)<jupyter_output>Existen 8 meses con 'r'.
('Enero', 'Febrero', 'Marzo', 'Abril', 'Septiembre', 'Octubre', 'Noviembre', 'Diciembre')<jupyter_text>Solución 3Creando una lista con los meses que cumplen la condición.<jupyter_code>meses = ("Enero","Febrero","Marzo","Abril","Mayo","Junio","Julio","Agosto","Septiembre","Octubre","Noviembre","Diciembre")
contador = 0
meses_elegidos = []    # inicializamos una lista vacía

for mes in meses:
  if 'r' in mes:
    contador += 1
    meses_elegidos += [mes]   # añadimos los meses a la lista

print(f"Existen {contador} meses con 'r'.")
print(meses_elegidos)<jupyter_output>Existen 8 meses con 'r'.
['Enero', 'Febrero', 'Marzo', 'Abril', 'Septiembre', 'Octubre', 'Noviembre', 'Diciembre']<jupyter_text>Solución 4Creando una lista con los meses que cumplen la condición, usando ```append```.<jupyter_code>meses = ("Enero","Febrero","Marzo","Abril","Mayo","Junio","Julio","Agosto","Septiembre","Octubre","Noviembre","Diciembre")
contador = 0
meses_elegidos = []    # inicializamos una lista vacía

for mes in meses:
  if 'r' in mes:
    contador += 1
    meses_elegidos.append(mes)   # añadimos los meses a la lista usando append

print(f"Existen {contador} meses con 'r'.")
print(meses_elegidos)<jupyter_output>Existen 8 meses con 'r'.
['Enero', 'Febrero', 'Marzo', 'Abril', 'Septiembre', 'Octubre', 'Noviembre', 'Diciembre']<jupyter_text>Ver si un elemento está en la lista y su índiceCreamos un programa que comprueba si un elemento está en la lista y nos dice en qué posición (índice) se encuentra.<jupyter_code>lista = [41,25,11,22,15,13,28,33,39,14,37,20,21,32,35,24]
print(lista)
num = 25

for i in range(len(lista)):
  if lista[i]==num:
    print(f"El número {num} está en la lista en el índice {i}.")<jupyter_output>[41, 25, 11, 22, 15, 13, 28, 33, 39, 14, 37, 20, 21, 32, 35, 24]
El número 25 está en la lista en el índice 1.<jupyter_text>Tabla de multiplicar de un número dadoDado un número mostrar su tabla de multiplicar.<jupyter_code>n = int(input("Dime un número entre 1 y 10: "))
for i in range(1,11):
  print(f"{n}x{i}={n*i}")<jupyter_output>Dime un número entre 1 y 10: 7
7x1=7
7x2=14
7x3=21
7x4=28
7x5=35
7x6=42
7x7=49
7x8=56
7x9=63
7x10=70<jupyter_text>Comprobar si un número está dentro de un rangoDado un objeto de tipo ```range``` y un número, comprobar si está dentro del rango.  Solución 1Usando ```in```.<jupyter_code>num = 6
rango = range(2,101,2)     # step=2 y comenzando en 2, son 50 pares
if num in rango:
  print(f"El número {num} si está dentro del rango.")
else:
  print(f"El número {num} no está dentro del rango.")<jupyter_output>El número 6 si está dentro del rango.<jupyter_text>Solución 2Usando un ```for``` y hanciendo un rango más grande.  Deseamos mostrar que la condición se cumple al inicio del bucle y luego el resto de las comprobaciones no serían necesarias.  Estaría bien disponer de una instrucción que nos permitiera salir del bucle una vez que ya hemos comprobado que se cumple la condición.<jupyter_code>num = 6
rango = range(2,101,2)
for i in rango:
  if i==num:
    print(f"El número {num} si está dentro del rango.")
  else:
    print(f"No está.")<jupyter_output>No está.
No está.
El número 6 si está dentro del rango.
No está.
No está.
No está.
No está.
No está.
No está.
No está.
No está.
No está.
No está.
No está.
No está.
No está.
No está.
No está.
No está.
No está.
No está.
No está.
No está.
No está.
No está.
No está.
No está.
No está.
No está.
No está.
No está.
No está.
No está.
No está.
No está.
No está.
No está.
No está.
No está.
No está.
No está.
No está.
No está.
No está.
No está.
No está.
No está.
No está.
No está.
No está.<jupyter_text>Solución 3Usando un ```for``` y usando un ```brake``` que nos permite salir del bucle.  De esta forma conseguimos que no sea necesario imprimir 50 frases, sino solo 3, ya que cuando se cumple la condición finaliza el bucle.<jupyter_code>num = 6
rango = range(2,101,2)
for i in rango:
  if i==num:
    print(f"El número {num} si está dentro del rango.")
    break                                                 # permite salir del bucle
    print("Esta frase está después del 'break' y nunca se imprimirá") # esto nunca se imprime
  else:
    print(f"No está.")

print("Fin del programa.")<jupyter_output>No está.
No está.
El número 6 si está dentro del rango.
Fin del programa.<jupyter_text>Reto 8.5. Comprobar valores de una lista* Dada una lista de edades, comprobar que están en el rango entre 14 y 24, ambas incluidas.  * Por cada edad ir diciendo si está en el rango o no.* Si existe alguna fuera del rango, informar que no está en el rango y deterner la comprobación.* edades = [15, 22, 20, 26, 23, 18, 17, 24, 21, 19, 14]<jupyter_code>import random
# genera 5 números aleatorios entre 10 and 20
randomlist = random.sample(range(14, 25), 10)
print(randomlist)<jupyter_output>[15, 22, 20, 23, 18, 17, 24, 21, 19, 14]<jupyter_text>Adivinar un númeroDado un número secreto entre 1 y 10, pedir al usuario que diga números en ese rango hasta que lo adivine.  En el momento en el que se adivina al número ya no se siguen pidiendo número y finaliza el programa.  Solución 1. Usando una banderaSerá necesario usar un bucle ```while``` ya que no sabemos en cuantas tiradas se adivinará el número secreto.<jupyter_code>secreto = 3
jugando = True             # bandera
while jugando:
  n = int(input("Diga un número entre 1 y 10: "))
  if n==secreto:
    print(f"Felicidades, adivinó que el número secreto es {n}.")
    jugando = False
  else:
    print("No es correcto.")

print("Fin del programa.")<jupyter_output>Diga un número entre 1 y 10: 1
No es correcto.
Diga un número entre 1 y 10: 2
No es correcto.
Diga un número entre 1 y 10: 3
Felicidades, adivinó que el número secreto es 3.
Fin del programa.<jupyter_text>Solución 2. Usando ```break```También usaremos un bucle ```while```.<jupyter_code>secreto = 3
while True:
  n = int(input("Diga un número entre 1 y 10: "))
  if n==secreto:
    print(f"Felicidades, adivinó que el número secreto es {n}.")
    break
  else:
    print("No es correcto.")

print("Fin del programa.")<jupyter_output>Diga un número entre 1 y 10: 1
No es correcto.
Diga un número entre 1 y 10: 2
No es correcto.
Diga un número entre 1 y 10: 3
Felicidades, adivinó que el número secreto es 3.
Fin del programa.<jupyter_text>Sentencia ```break``` en un ```for``` Juego para adivinar una letraEl juego te pide continuamente que adivines la letra secreta.Se puede probar con cualquier letra salvo la 'ñ' que no está permitida y el juego se para.  Solución 1Usando solo una bandera.<jupyter_code>letra = 'p'
jugando = True                               # usamos solo una bandera
while jugando:
  intento = input("Dime una letra: ")
  if intento != letra:
    if intento == "ñ":
      print("Esta letra no está permitida.")
      jugando = False                        # aquí la bandera es False si hemos pulsado la letra no permitida
    else:
      print("No es correcta.")
  else:
    print("Felicidades, has acertado")
    jugando = False                          # aquí la bandera el False si ya hemos ganado y se termina el juego<jupyter_output>Dime una letra: f
No es correcta.
Dime una letra: e
No es correcta.
Dime una letra: ñ
Esta letra no está permitida.<jupyter_text>Solución 2Usando dos banderas:* una para controlar si la letra está o no permitida* otra para controlar si se ha ganado el juego en cuyo caso se finaliza<jupyter_code>letra = 'p'
jugando = True                               # usamos una bandera para controlar si se ha ganado
correcto = True                              # usamos otra bandera para saber si la letra está permitida
while jugando and correcto:
  intento = input("Dime una letra: ")
  if intento != letra:
    if intento == "ñ":
      print("Esta letra no está permitida.")
      correcto = False                        # aquí la bandera es False si hemos pulsado la letra no permitida
    else:
      print("No es correcta.")
  else:
    print("Felicidades, has acertado")
    jugando = False                          # aquí la bandera el False si ya hemos ganado y se termina el juego<jupyter_output>Dime una letra: q
No es correcta.
Dime una letra: w
No es correcta.
Dime una letra: o
No es correcta.
Dime una letra: p
Felicidades, has acertado<jupyter_text>Solución 3Con una bandera y un ```break```.<jupyter_code>letra = 'p'
jugando = True                               # usamos solo una bandera y un breake
while jugando:
  intento = input("Dime una letra: ")
  if intento != letra:
    if intento == "ñ":
      print("Esta letra no está permitida.")
      break                        # aquí el break si hemos pulsado la letra no permitida
    else:
      print("No es correcta.")
  else:
    print("Felicidades, has acertado")
    jugando = False                          # aquí la bandera el False si ya hemos ganado y se termina el juego<jupyter_output>Dime una letra: q
No es correcta.
Dime una letra: w
No es correcta.
Dime una letra: o
No es correcta.
Dime una letra: p
Felicidades, has acertado<jupyter_text>Solución 4Usando dos ```break``` y sin banderas.<jupyter_code>letra = 'p'

while True:
  intento = input("Dime una letra: ")
  if intento != letra:
    if intento == "ñ":
      print("Esta letra no está permitida.")
      break                        # aquí el break si hemos pulsado la letra no permitida
    else:
      print("No es correcta.")
  else:
    print("Felicidades, has acertado")
    break                          # este break actúa cuando se acierta y finaliza el juego<jupyter_output>Dime una letra: k
No es correcta.
Dime una letra: l
No es correcta.
Dime una letra: ñ
Esta letra no está permitida.<jupyter_text>Sentencia ```continue``` en un ```for```Programa que muestra todas las letras de un palabra a excepción de la 'h'.<jupyter_code>palabra = 'zanahoria'
for letra in palabra:
  if letra=='h':
    continue    # al llegar al 'continue' ya no se sigue ejecutando y comienza una nueva iteración
  print(letra)<jupyter_output>z
a
n
a
o
r
i
a
{'fraction_non_alphanumeric': 0.09937012315502491, 'fraction_numerical': 0.03906176553539532, 'mean_word_length': 3.7298799466429524, 'pattern_counts': {'":': 6, '<': 98, '<?xml version=': 0, '>': 98, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 46, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '32', 'dir': 'jupyter-structured-clean-dedup', 'id': '80857', 'license': 'MIT', 'n_tokens_mistral': 8317, 'n_tokens_neox': 7766, 'n_words': 2957, 'path': 'Python_CoderDojo08.ipynb', 'repo_name': 'seldoncode/Python_CoderDojo', 'size': '21274'}