Saltar a contenido

Ejercitación aplicada
Estructuras repetitivas de control de flujo

  1. Escribe un programa que solicite la cantidad de empleados a saludar todas las mañanas en una empresa. Luego, que solicite, uno a uno, el nombre de cada empleado y efectúe el saludo.
    Este saludo debe ser: "Hola" y el nombre de empleado.

    El programa no puede contener líneas de código que en su acción o tarea hagan lo mismo.
    Debes utilizar estructuras repetitivas de control de flujo.
    El programa debe finalizar cuando se haya saludado a todos los empleados.

    Haz clic aquí para ver la solución propuesta
    Python
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
    # Solicita al usuario la cantidad de empleados a saludar todas las mañanas
cantidad_empleados = int(input("Ingrese la cantidad de empleados a saludar esta mañana: "))

# Estructura repetitiva de control de flujo para saludar a todos los empleados
while cantidad_empleados > 0:
    # Solicita al usuario el nombre del empleado y lo almacena en una variable
    nombre_empleado = input("Ingrese el nombre del empleado: ")

    # Saluda al empleado
    print(f"Hola {nombre_empleado}.")

    # Decrementa la cantidad de empleados a saludar
    cantidad_empleados = cantidad_empleados - 1
    Terminal (Entrada/Salida)
    1
2
3
4
5
6
7
8
    Ingrese la cantidad de empleados a saludar esta mañana: 3
Ingrese el nombre del empleado: Juan
Hola Juan.
Ingrese el nombre del empleado: María
Hola María.
Ingrese el nombre del empleado: Pedro
Hola Pedro.
_

    Se utiliza la función input() para solicitar al usuario la cantidad de empleados a saludar todas las mañanas. La función input() muestra un mensaje en la salida estándar y espera a que el usuario presione ENTER (ingresando un valor previamente). En este caso, el mensaje es "Ingrese la cantidad de empleados a saludar esta mañana: ".

    El valor ingresado por el usuario es devuelto como cadena por la función input() por lo que se convierte a un número entero y se almacena en la variable cantidad_empleados. Recuerda que input() siempre devuelve una cadena de caracteres.

    Se utiliza una estructura repetitiva de control de flujo while para saludar a todos los empleados. La condición de la estructura repetitiva es que la cantidad de empleados a saludar sea mayor a 0. Mientras la condición sea verdadera, se solicita al usuario el nombre del empleado y se almacena en la variable nombre_empleado. Luego, se saluda al empleado con el mensaje "Hola" seguido del nombre del empleado. Finalmente, se decrementa la cantidad de empleados a saludar en 1.

    La salida en la Terminal (Entrada/Salida) es "Hola Juan.", "Hola María." y "Hola Pedro.", ya que se ingresaron los nombres de los empleados Juan, María y Pedro respectivamente.

    El símbolo _ significa que el cursor queda en esa línea de la Terminal luego del salto de línea producido por la función print() por defecto.

    Para pensar:

    ¿Te parece que la estructura de control de flujo for es más adecuada que while para este caso? ¿Por qué?

    Pista

    Recuerda que existen dos tipos de estructuras repetitivas de control de flujo: for y while. Una se emplea para ciclos abiertos (cuando no se conoce la cantidad de iteraciones -o repeticiones-) y la otra para ciclos cerrados (cuando se conoce la cantidad de iteraciones -o repeticiones).

    También recuerda que el concepto de ciclo abierto o de ciclo cerrado se refiere a que el programa sabe en su lógica cuántas veces se va a repetir una acción o tarea. Esto quiere decir que si esa cantidad de repeticiones es definida en una variable, no significa que el ciclo sea cerrado. Al momento de ejecutarse el ciclo, el programa ya sabrá cuántas veces se repetirá la acción o tarea porque la variable de control ya tendría un valor asignado.

    Si lo crees conveniente, refactoriza tu programa para lograr una solución más eficiente.

    Haz clic aquí para ver una mejor solución propuesta
    Python
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
    # Solicita al usuario la cantidad de empleados a saludar todas las mañanas
cantidad_empleados = int(input("Ingrese la cantidad de empleados a saludar esta mañana: "))

# Estructura repetitiva de control de flujo para saludar a todos los empleados
for empleado in range(1, cantidad_empleados + 1): # cantidad_empleados + 1 es para incluir el último empleado

    # Solicita al usuario el nombre del empleado y lo almacena en una variable 
    nombre_empleado = input(f"Ingrese el nombre del empleado {empleado}: ")

    # Saluda al empleado
    print(f"Hola {nombre_empleado}.")
    Terminal (Entrada/Salida)
    1
2
3
4
5
6
7
8
    Ingrese la cantidad de empleados a saludar esta mañana: 3
Ingrese el nombre del empleado 1: Juan
Hola Juan.
Ingrese el nombre del empleado 2: María
Hola María.
Ingrese el nombre del empleado 3: Pedro
Hola Pedro.
_

    Se utiliza la función input() para solicitar al usuario la cantidad de empleados a saludar todas las mañanas. La función input() muestra un mensaje en la salida estándar y espera a que el usuario presione ENTER (ingresando un valor previamente). En este caso, el mensaje es "Ingrese la cantidad de empleados a saludar esta mañana: ".

    El valor ingresado por el usuario es devuelto como cadena por la función input() por lo que se convierte a un número entero y se almacena en la variable cantidad_empleados. Recuerda que input() siempre devuelve una cadena de caracteres.

    Se utiliza una estructura repetitiva de control de flujo for para saludar a todos los empleados. La variable empleado recorre un rango de valores desde 1 hasta la cantidad de empleados a saludar más 1. En cada iteración, se solicita al usuario el nombre del empleado y se almacena en la variable nombre_empleado. Luego, se saluda al empleado con el mensaje "Hola" seguido del nombre del empleado.

    La salida en la Terminal (Entrada/Salida) es "Hola Juan.", "Hola María." y "Hola Pedro.", ya que se ingresaron los nombres de los empleados Juan, María y Pedro respectivamente.

    El símbolo _ significa que el cursor queda en esa línea de la Terminal luego del salto de línea producido por la función print() por defecto.

    Para reflexionar

    La estructura de control de flujo for es más adecuada que while para este caso, ya que se conoce la cantidad de empleados a saludar todas las mañanas.

    Por lo tanto, el ciclo es cerrado y se puede utilizar for para recorrer un rango de valores desde 1 hasta la cantidad de empleados a saludar más 1.

  2. Refactoriza el programa del ejercicio anterior para que indique el número de empleado al que se le pregunta el nombre.
    Por ejemplo: "Ingrese el nombre del empleado 1: ". Luego, "Ingrese el nombre del empleado 2: ", y así sucesivamente.

    Pista

    Utiliza la variable de control del ciclo for para indicar el número de empleado al que se le pregunta el nombre.

    Haz clic aquí para ver la solución propuesta
    Python
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
    # Solicita al usuario la cantidad de empleados a saludar todas las mañanas
cantidad_empleados = int(input("Ingrese la cantidad de empleados a saludar esta mañana: "))

# Estructura repetitiva de control de flujo para saludar a todos los empleados
for empleado in range(1, cantidad_empleados + 1): # arranca en 1 y cantidad_empleados + 1 es para incluir el último empleado

    # Solicita al usuario el nombre del empleado y lo almacena en una variable 
    nombre_empleado = input(f"Ingrese el nombre del empleado {empleado}: ")

    # Saluda al empleado
    print(f"Hola {nombre_empleado}.")
    Terminal (Entrada/Salida)
    1
2
3
4
5
6
7
8
    Ingrese la cantidad de empleados a saludar esta mañana: 3
Ingrese el nombre del empleado 1: Juan
Hola Juan.
Ingrese el nombre del empleado 2: María
Hola María.
Ingrese el nombre del empleado 3: Pedro
Hola Pedro.
_

    Se utiliza la función input() para solicitar al usuario la cantidad de empleados a saludar todas las mañanas. La función input() muestra un mensaje en la salida estándar y espera a que el usuario presione ENTER (ingresando un valor previamente). En este caso, el mensaje es "Ingrese la cantidad de empleados a saludar esta mañana: ".

    El valor ingresado por el usuario es devuelto como cadena por la función input() por lo que se convierte a un número entero y se almacena en la variable cantidad_empleados. Recuerda que input() siempre devuelve una cadena de caracteres.

    Se utiliza una estructura repetitiva de control de flujo for para saludar a todos los empleados. La variable empleado recorre un rango de valores desde 1 hasta la cantidad de empleados a saludar más 1. En cada iteración, se solicita al usuario el nombre del empleado y se almacena en la variable nombre_empleado. Luego, se saluda al empleado con el mensaje "Hola" seguido del nombre del empleado.

    La salida en la Terminal (Entrada/Salida) es "Hola Juan.", "Hola María." y "Hola Pedro.", ya que se ingresaron los nombres de los empleados Juan, María y Pedro respectivamente.

    El símbolo _ significa que el cursor queda en esa línea de la Terminal luego del salto de línea producido por la función print() por defecto.

  3. Escribe un programa que solicite un número entero entre 2 y 10 al usuario. El número debe validarse. Luego, que el programa imprima la tabla de multiplicar de ese número.

    Haz clic aquí para ver la solución propuesta
    Python
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
    # Solicita al usuario un número entero entre 2 y 10 y controla que esté dentro del rango
while True:
    numero = int(input("Ingrese un número entero entre 2 y 10: "))
    if 2 <= numero <= 10:
        # Si el número ingresado está dentro del rango, se sale del ciclo while
        break
    else:
        print("El número ingresado debe estar entre 2 y 10.")

# Estructura repetitiva de control de flujo para imprimir la tabla de multiplicar del número ingresado
for multiplicador in range(1, 11): # Recorre un rango de valores desde 1 hasta 10

    resultado = numero * multiplicador # Calcula el resultado de la multiplicación
    print(f"{numero} x {multiplicador} = {resultado}") # Imprime la tabla de multiplicar
    Terminal (Entrada/Salida)
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
    Ingrese un número entero entre 2 y 10: 5
5 x 1 = 5
5 x 2 = 10
5 x 3 = 15
5 x 4 = 20
5 x 5 = 25
5 x 6 = 30
5 x 7 = 35
5 x 8 = 40
5 x 9 = 45
5 x 10 = 50
_

    Se utiliza una estructura repetitiva de control de flujo while True para solicitar al usuario un número entero entre 2 y 10. Se controla que el número ingresado esté dentro del rango correspondiente. Si el número ingresado no está dentro del rango, se muestra un mensaje de error y se solicita nuevamente un número entero.

    Se utiliza una estructura repetitiva de control de flujo for para imprimir la tabla de multiplicar del número ingresado. La variable multiplicador recorre un rango de valores desde 1 hasta 10. En cada iteración, se calcula el resultado de la multiplicación entre el número ingresado y el multiplicador. Luego, se imprime la tabla de multiplicar en la salida estándar.

    La salida en la Terminal (Entrada/Salida) es "5 x 1 = 5", "5 x 2 = 10", "5 x 3 = 15", "5 x 4 = 20", "5 x 5 = 25", "5 x 6 = 30", "5 x 7 = 35", "5 x 8 = 40", "5 x 9 = 45" y "5 x 10 = 50", ya que se ingresó el número 5 y se imprimió la tabla de multiplicar del 5.

  4. Escribe un programa que imprima los primeros 10 múltiplos de un número entero ingresado por el usuario.

    Haz clic aquí para ver la solución propuesta
    Python
    1
2
3
4
5
6
7
8
9
    # Solicita al usuario un número entero
numero = int(input("Ingrese un número entero: "))

print(f"Los primeros 10 múltiplos de {numero} son:")

# Estructura repetitiva de control de flujo para imprimir los primeros 10 múltiplos del número ingresado
for multiplo in range(numero, (numero + numero * 10), numero): # Recorre un rango de valores desde el número ingresado hasta el número ingresado más 10 veces el número ingresado, incrementándose en el número ingresado

    print(f"{multiplo} es múltiplo de {numero}") # Imprime los primeros 10 múltiplos del número ingresado
    Terminal (Entrada/Salida)
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
    Ingrese un número entero: 3
3 x 1 = 3
3 x 2 = 6
3 x 3 = 9
3 x 4 = 12
3 x 5 = 15
3 x 6 = 18
3 x 7 = 21
3 x 8 = 24
3 x 9 = 27
3 x 10 = 30
_

    Se utiliza la función input() para solicitar al usuario un número entero. La función input() muestra un mensaje en la salida estándar y espera a que el usuario presione ENTER (ingresando un valor previamente). En este caso, el mensaje es "Ingrese un número entero: ".

    El valor ingresado por el usuario es devuelto como cadena por la función input() por lo que se convierte a un número entero y se almacena en la variable numero. Recuerda que input() siempre devuelve una cadena de caracteres.

    Se utiliza una estructura repetitiva de control de flujo for para imprimir los primeros 10 múltiplos del número ingresado. La variable multiplo recorre un rango de valores desde 1 hasta 10. En cada iteración, se calcula el resultado de la multiplicación entre el número ingresado y el multiplicador. Luego, se imprime los primeros 10 múltiplos del número ingresado en la salida estándar.

    La salida en la Terminal (Entrada/Salida) es "3 x 1 = 3", "3 x 2 = 6", "3 x 3 = 9", "3 x 4 = 12", "3 x 5 = 15", "3 x 6 = 18", "3 x 7 = 21", "3 x 8 = 24", "3 x 9 = 27" y "3 x 10 = 30", ya que se ingresó el número 3 y se imprimieron los primeros 10 múltiplos del 3.

  5. Dado el siguiente fragmento de un programa:

    Python
    # Importa la función sleep del módulo time. Esta función permite pausar la ejecución del programa durante un tiempo determinado.
from time import sleep 

for …: # Completa los puntos suspensivos

    print(f"{seg}...") # ¿Te acuerdas que hace el f-string?

    sleep(1) # ¿Qué crees que hace la función sleep?

print("BOOM!") # ¿Cuándo se imprime "BOOM!"?

    Completa los puntos suspensivos para que el programa realice una cuenta regresiva desde 5 hasta 1 y luego imprima "BOOM!".

    Haz clic aquí para ver la solución propuesta
    Python
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
    # Importa la función sleep del módulo time. Esta función permite pausar la ejecución del programa durante un tiempo determinado.
from time import sleep 

for seg in range(5, 0, -1): # Cuenta regresiva desde 5 hasta 1

    print(f"{seg}...") # Imprime el valor de la variable seg seguido de tres puntos

    sleep(1) # Espera 1 segundo

# Impresión del mensaje "BOOM!" al finalizar la cuenta regresiva (saliendo del ciclo for)
print("BOOM!")
    Terminal (Entrada/Salida)
    1
2
3
4
5
6
7
    5...
4...
3...
2...
1...
BOOM!
_

    Se importa la función sleep del módulo time. Esta función permite pausar la ejecución del programa durante un tiempo determinado.

    Se utiliza una estructura repetitiva de control de flujo for para realizar una cuenta regresiva desde 5 hasta 1. La variable seg recorre un rango de valores desde 5 hasta 1, decrementándose en 1 unidad en cada iteración. En cada iteración, se imprime el valor de la variable seg seguido de tres puntos (...) y se espera 1 segundo.

    La salida en la Terminal (Entrada/Salida) es "5...", "4...", "3...", "2...", "1..." y "BOOM!".

  6. Escribe un programa que le pregunte al usuario, entre las 9 (hora de ingreso al trabajo) y las 18 (hora de egreso del trabajo): ¿Qué tarea va a realizar?

    La pregunta debe ser: "¿Qué tarea va a realizar a las xxx horas?" y el programa debe esperar a que el usuario ingrese una tarea, aunque no se almacene en ninguna variable.

    Haz clic aquí para ver la solución propuesta
    Python
    1
2
3
4
5
6
    # Estructura repetitiva de control de flujo para preguntar al usuario qué tarea va a realizar a cada hora
# Recorre un rango de valores desde 9 hasta 18, sin incluir la hora 18 puesto que a esa hora se retira del trabajo
for hora in range(9, 18): 

    # Pregunta al usuario qué tarea va a realizar a la hora correspondiente
    input(f"¿Qué tarea va a realizar a las {hora} horas? ") # Uso de f-string para mostrar la hora
    Terminal (Entrada/Salida)
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
    ¿Qué tarea va a realizar a las 9 horas? Trabajar en el informe.
¿Qué tarea va a realizar a las 10 horas? Reunión con el equipo.
¿Qué tarea va a realizar a las 11 horas? Llamada con el cliente.
¿Qué tarea va a realizar a las 12 horas? Almorzar.
¿Qué tarea va a realizar a las 13 horas? Revisar correos electrónicos.
¿Qué tarea va a realizar a las 14 horas? Capacitación en línea.
¿Qué tarea va a realizar a las 15 horas? Reunión de seguimiento.
¿Qué tarea va a realizar a las 16 horas? Trabajar en el proyecto.
¿Qué tarea va a realizar a las 17 horas? Preparar informe de cierre.
_

    Se utiliza una estructura repetitiva de control de flujo for para preguntar al usuario qué tarea va a realizar a cada hora. La variable hora recorre un rango de valores desde 9 hasta 18, sin incluir la hora 18, ya que a esa hora se retira del trabajo. En cada iteración, se muestra un mensaje al usuario preguntando qué tarea va a realizar a la hora correspondiente.

    La salida en la Terminal (Entrada/Salida) es "¿Qué tarea va a realizar a las 9 horas? Trabajar en el informe.", "¿Qué tarea va a realizar a las 10 horas? Reunión con el equipo.", "¿Qué tarea va a realizar a las 11 horas? Llamada con el cliente.", "¿Qué tarea va a realizar a las 12 horas? Almorzar.", "¿Qué tarea va a realizar a las 13 horas? Revisar correos electrónicos.", "¿Qué tarea va a realizar a las 14 horas? Capacitación en línea.", "¿Qué tarea va a realizar a las 15 horas? Reunión de seguimiento.", "¿Qué tarea va a realizar a las 16 horas? Trabajar en el proyecto.", "¿Qué tarea va a realizar a las 17 horas? Preparar informe de cierre.".

  7. Dado el siguiente fragmento inicial de un programa:

    Python
    # Importa el módulo random. Este módulo permite trabajar con números aleatorios.
import random

# Limpia la pantalla de la Terminal
print("\033c", end="")

# Muestra un mensaje en la Terminal
print("Adivine el numero!")

# Solicita al usuario su nombre
nombre = input("Ingrese su nombre: ")

# Muestra un saludo en la Terminal
print(f"Hola {nombre}!")

# Genera un número aleatorio entre 1 y 100
n_escondido = random.randint(1, 100)
⋮

    Escribe un programa que permita adivinar el número n_escondido generado aleatoriamente.
    El usuario deberá ingresar un número entero dentro del rango correspondiente y el programa deberá indicar si el número ingresado es mayor, menor o igual al número n_escondido.

    El programa debe finalizar cuando el usuario adivine el número n_escondido. Al ganar, el programa deberá indicar la cantidad de intentos que le llevó al usuario adivinar el número.

    El programa, además, debe controlar que el número ingresado por el usuario se encuentre dentro del rango correspondiente.

    Haz clic aquí para ver la solución propuesta
    Python
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
    # Importa el módulo random. Este módulo permite trabajar con números aleatorios.
import random

# Limpia la pantalla de la Terminal
print("\033c", end="")

# Muestra un mensaje en la Terminal
print("Adivine el numero!")

# Solicita al usuario su nombre
nombre = input("Ingrese su nombre: ")

# Muestra un saludo en la Terminal
print(f"Hola {nombre}!")

# Genera un número aleatorio entre 1 y 100
n_escondido = random.randint(1, 100)

# Inicializa la variable de control de intentos
intentos = 0

# Estructura repetitiva de control de flujo para adivinar el número n_escondido
while True:

    # Solicita al usuario un número entero y controla que esté dentro del rango
    while True:
        numero = int(input("Adivina el número escondido (entre 1 y 100): "))
        if 1 <= numero <= 100:
            break
        else:
            print("El número ingresado debe estar entre 1 y 100.")

    # Incrementa la cantidad de intentos
    intentos += 1 # Es lo mismo que intentos = intentos + 1

    # Muestra el intento actual
    print(f"Intento {intentos}:")

    # Compara el número ingresado con el número escondido
    # Verifica si el número escondido es mayoral número ingresado
    if numero < n_escondido:
        print("El número escondido es mayor.")
    # Verifica si el número escondido es menor al número ingresado
    elif numero > n_escondido:
        print("El número escondido es menor.")
    # Por defecto el número escondido es igual al número ingresado
    else:
        print(f"¡Felicitaciones! Adivinaste el número escondido en {intentos} intentos.")
        break

    print() # Ejecuta un salto de línea
    Terminal (Entrada/Salida)
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
    Adivina el número escondido (entre 1 y 100): 50
El número escondido es mayor.
Adivina el número escondido (entre 1 y 100): 75
El número escondido es menor.
Adivina el número escondido (entre 1 y 100): 60
El número escondido es menor.
Adivina el número escondido (entre 1 y 100): 55
El número escondido es mayor.
Adivina el número escondido (entre 1 y 100): 57
¡Felicitaciones! Adivinaste el número escondido en 5 intentos.
_

    Se importa el módulo random para trabajar con números aleatorios. Luego, se genera un número aleatorio entre 1 y 100 y se almacena en la variable n_escondido.

    Se inicializa la variable intentos en 0 para llevar la cuenta de la cantidad de intentos que le llevó al usuario adivinar el número n_escondido.

    Se utiliza una estructura repetitiva de control de flujo while True para adivinar el número n_escondido. Dentro de esta estructura, se solicita al usuario un número entero y se controla que esté dentro del rango correspondiente (entre 1 y 100). Si el número ingresado no está dentro del rango, se muestra un mensaje de error y se solicita nuevamente un número entero.

    Se incrementa la cantidad de intentos en 1 cada vez que el usuario ingresa un número.

    Se compara el número ingresado con el número n_escondido. Si el número escondido es mayor al número ingresado, se muestra un mensaje indicando que el número escondido es mayor. Si el número escondido es menor al número ingresado, se muestra un mensaje indicando que el número escondido es menor. Si el número escondido es igual al número ingresado, se muestra un mensaje de felicitaciones y la cantidad de intentos que le llevó al usuario adivinar el número.

    La salida en la Terminal (Entrada/Salida) es "El número escondido es mayor.", "El número escondido es menor.", "El número escondido es menor.", "El número escondido es mayor." y "¡Felicitaciones! Adivinaste el número escondido en 5 intentos.".

  8. Escribe un programa que, dado un número determinado de unidades de calcetines, indique cuántos pares de medias pueden empaquetarse.

    El programa debe solicitar al usuario la cantidad de unidades de calcetines. Este número debe ser un número entero positivo.

    Además. debe indicar si sobra alguna media suelta que no se puede empaquetar en un par.

    La limitación del programa está en que para calcular, solo puede ir sumando una variable acumuladora, de a una unidad por vez.

    Pista

    Utiliza una variable acumuladora para contar la cantidad de pares de medias que se pueden empaquetar.

    Una variable acumuladora es una variable como cualquier otra, que se utiliza para incrementar o decrementar su valor en cada iteración de un ciclo.

    Haz clic aquí para ver la solución propuesta
    Python
     1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
    # Solicita al usuario la cantidad de unidades de calcetines y controla que sea un número entero positivo
while True:
    unidades_calcetines = int(input("Ingrese la cantidad de unidades de calcetines: "))
    if unidades_calcetines > 0:
        break
    else:
        print("La cantidad de unidades de calcetines debe ser mayor a 0.")

# Inicializa la variable acumuladora de pares de medias
pares_medias = 0

# Estructura repetitiva de control de flujo para empaquetar pares de medias
# Ten en cuenta que recién con la segunda unidad se arma un par, por eso arranca en 1 y se incrementa de a 2 unidades
# Piénsalo bien, ¿por qué arranca en 1 y se incrementa de a 2 unidades? ¿Qué pasaría si arrancara en 0 y se incrementara de a 2 unidades? Agarra una hoja de papel y simula el proceso.

for calcetin in range(1, calcetines, 2): # arranca en 1 y se incrementa de a 2 unidades

    pares_medias += 1 # Incrementa la cantidad de pares de medias en 1

# Muestra la cantidad de pares de medias y si sobra alguna media suelta
print(f"Se pueden empaquetar {pares_medias} pares de medias.")

# Calcula si sobra alguna media suelta
media_suelta = unidades_calcetines % 2 # Calcula el resto de la división por 2

if media_suelta == 1:
    print("Sobra 1 media suelta.")
else:
    print("No sobra ninguna media suelta.")
    Terminal (Entrada/Salida)
    1
2
3
4
    Ingrese la cantidad de unidades de calcetines: 7
Se pueden empaquetar 3 pares de medias.
Sobra 1 media suelta.
_

    Se utiliza una estructura repetitiva de control de flujo while True para solicitar al usuario la cantidad de unidades de calcetines. Se controla que la cantidad de unidades de calcetines sea un número entero positivo. Si la cantidad de unidades de calcetines no es un número entero positivo, se muestra un mensaje de error y se solicita nuevamente la cantidad de unidades de calcetines.

    Se inicializa la variable acumuladora pares_medias en 0 para contar la cantidad de pares de medias que se pueden empaquetar.

    Se utiliza una estructura repetitiva de control de flujo for para empaquetar pares de medias. La variable calcetin recorre un rango de valores desde 1 hasta la cantidad de unidades de calcetines, incrementándose de a 2 unidades. En cada iteración, se incrementa la cantidad de pares de medias en 1.

    La salida en la Terminal (Entrada/Salida) es "Se pueden empaquetar 3 pares de medias." y "Sobra 1 media suelta.", ya que se ingresaron 7 unidades de calcetines y se pueden empaquetar 3 pares de medias, sobrando 1 media suelta.