FP - IDAP - AD 2024

arreglos.py

'''
Cuando se requiere almacenar varios valores en una sola variable, se puede
utilizar un arreglo.

Un arreglo es una estructura de datos que permite almacenar varios valores
de un mismo tipo en una sola variable, a través de un índice que representa
la posición de cada valor.

Comúnmente, los arreglos se utilizan para almacenar colecciones de datos
homogéneos, es decir, del mismo tipo y tamaño fijo.
'''

def main():
    # Crear una lista de letras
    #        [ 0,   1,   2,   3,   4 ] Índices
    letras = ["J", "a", "i", "m", "e"]
    print(letras)

    # Cambiar la letra en la posición 1
    letras[1] = "X"  # variable[índice] = valor -> asignación
    print(letras)

    # Intentar acceder a un índice fuera de rango causaría un error
    # letras[10] = "?" # Error: índice fuera de rango

    # Imprimir la letra en la posición 3
    print(letras[3])  # variable[índice] -> valor

    # Iterar sobre la lista e imprimir cada letra con su posición
    for i in range(len(letras)):
        print(f"La letra en la posición {i} es {letras[i]}")


# Punto de entrada del programa
if __name__ == "__main__":
    main()

granja.py

cerdos = 0
vacas = 0
pollos = 0


def main():
    '''
    Función principal del programa.
    '''
    global cerdos, vacas, pollos

    print("= LA GRANJA =")
    cerdos = int(input("¿Cuántos cerdos hay? "))
    vacas = int(input("¿Cuántas vacas hay? "))
    pollos = int(input("¿Cuántos pollos hay? "))
    imprime_total()

    # vender(0, 1, 0)  # Vender 1 vaca
    # comprar(0, 0, 5)  # Comprar 5 pollos
    salir = False
    while not salir:
        salir = menu()


def menu():
    '''
    Muestra el menú principal.
    Returns:
        bool: True si el usuario desea salir, False en caso contrario.
    '''
    print("1. Comprar animales")
    print("2. Vender animales")
    print("3. Salir")
    opcion = int(input("Opción: "))

    match opcion:
        case 1:
            menu_comprar()
            return False
        case 2:
            menu_vender()
            return False
        case _:
            return True


def menu_comprar():
    '''
    Muestra el menú para comprar animales.
    '''
    print("1. Comprar cerdos")
    print("2. Comprar vacas")
    print("3. Comprar pollos")
    print("4. Regresar")
    opcion = int(input("Opción: "))

    match opcion:
        case 1:  # Comprar cerdos
            cantidad = int(input("¿Cuántos cerdos desea comprar? "))
            comprar(cantidad, 0, 0)
        case 2:  # Comprar vacas
            cantidad = int(input("¿Cuántas vacas desea comprar? "))
            comprar(0, cantidad, 0)
        case 3:  # Comprar pollos
            cantidad = int(input("¿Cuántos pollos desea comprar? "))
            comprar(0, 0, cantidad)
        case _:
            menu()


def menu_vender():
    '''
    Muestra el menú para vender animales.
    '''
    print("1. Vender cerdos")
    print("2. Vender vacas")
    print("3. Vender pollos")
    print("4. Regresar")
    opcion = int(input("Opción: "))

    match opcion:
        case 1:  # Vender cerdos
            cantidad = int(input("¿Cuántos cerdos desea vender? "))
            vender(cantidad, 0, 0)
        case 2:  # Vender vacas
            cantidad = int(input("¿Cuántas vacas desea vender? "))
            vender(0, cantidad, 0)
        case 3:  # Vender pollos
            cantidad = int(input("¿Cuántos pollos desea vender? "))
            vender(0, 0, cantidad)
        case _:
            menu()


def patas(cerdos, vacas, pollos):
    '''
    Calcula la cantidad de patas en la granja.
    Args:
        cerdos (int): Cantidad de cerdos.
        vacas (int): Cantidad de vacas.
        pollos (int): Cantidad de pollos.
    Returns:
        int: Cantidad total de patas.
    '''
    return (cerdos * 4) + (vacas * 4) + (pollos * 2)


def imprime_total():
    '''
    Imprime la cantidad de animales en la granja y el total de patas.
    Usa las variables globales cerdos, vacas y pollos.
    Returns:
        None
    '''
    global cerdos, vacas, pollos
    total = patas(cerdos, vacas, pollos)
    print(f"Hay {cerdos} 🐷, {vacas} 🐄 y {pollos} 🐥")
    print(f"Hay un total de {total} pezuñas en la granja.")


def vender(c, v, p):
    """
    Vende (reduce) la cantidad de animales en la granja.
    Usa las variables globales cerdos, vacas y pollos.
    Args:
        c (int): Cantidad de cerdos a vender.
        v (int): Cantidad de vacas a vender.
        p (int): Cantidad de pollos a vender.
    Returns:
        None
    """
    global cerdos, vacas, pollos

    if c > 0 and c <= cerdos:
        cerdos -= c  # cerdos = cerdos - c
        print(f"Se vendió {c} 🐷")

    if v > 0 and v <= vacas:
        vacas -= v
        print(f"Se vendió {v} 🐄")

    if p > 0 and p <= pollos:
        pollos -= p
        print(f"Se vendió {p} 🐥")

    imprime_total()


def comprar(c, v, p):
    """
    Compra (aumenta) la cantidad de animales en la granja.
    Usa las variables globales cerdos, vacas y pollos.
    Args:
        c (int): Cantidad de cerdos a comprar.
        v (int): Cantidad de vacas a comprar.
        p (int): Cantidad de pollos a comprar.
    Returns:
        None
    """

    global cerdos, vacas, pollos

    if c > 0:
        cerdos += c  # cerdos = cerdos + c
        print(f"Se compraron {c} 🐷")

    if v > 0:
        vacas += v
        print(f"Se compraron {v} 🐄")

    if p > 0:
        pollos += p
        print(f"Se compraron {p} 🐥")

    imprime_total()


if __name__ == "__main__":
    main()

listas.py

'''
Al hablar de listas, nos referimos en esencia a un tipo de arreglo que 
puede redimensionarse dinámicamente. Es decir, que no se necesita especificar
su tamaño al momento de declararla.

En Python, las listas se declaran con
corchetes [] y los elementos se separan por comas.
'''


def main():
    # Declarar el arreglo vacío
    estaturas = []
    print(len(estaturas))  # len: length -> tamaño

    # Leer datos del teclado
    otro = True
    while otro:
        estatura = float(input("Dame una estatura: "))
        # Agregar los datos al arreglo
        estaturas.append(estatura)  # append: agregar al final

        opcion = input("Otra estatura? (s/n) ").lower()
        otro = (opcion == "s")

    # Imprimir el arreglo
    print(estaturas)

    # Eliminar un elemento del arreglo
    eliminable = float(input("Dame la estatura a eliminar: "))
    '''
    # Eliminar un elemento de forma "bruta"
    for i in range(len(estaturas)):
        if estaturas[i-1] == eliminable:
            estaturas.remove(estaturas[i-1])  # Elimina la estatura
            print(f"Se elimino {eliminable}")
    '''

    # Eliminar un elemento de forma "elegante"
    if eliminable in estaturas:
        estaturas.remove(eliminable)  # remove: eliminar un elemento específico
        print(f"Se elimino {eliminable}")

    print(estaturas)

    # Calcular el promedio de las estaturas
    suma = 0
    for estatura in estaturas:
        suma += estatura
    promedio = suma / len(estaturas)
    print(f"El promedio de estaturas es {promedio:.2f}")

    '''
    Como alternativa a la suma manual, se puede utilizar la función sum
    que recibe un arreglo y devuelve la suma de sus elementos.
    '''

    # Ordenar el arreglo y mostrar la estatura menor y mayor
    estaturas.sort()
    print(f"La estatura menor es {estaturas[0]}")
    print(f"La estatura mayor es {estaturas[-1]}")

    '''
    Como alternativa a la función sort, se puede utilizar la función
    min y max que recibe un arreglo y devuelve el elemento menor y mayor
    respectivamente.
    '''


if __name__ == "__main__":
    main()

matrices.py

'''
Obtener el promedio de calificaciones de un grupo de alumnos.
Cada alumno tendra 5 calificaciones en escala 100.
'''


def main():
    alumnos = []
    calificaciones = []
    otro = True
    while otro:
        nombre = input(f"Nombre del alumno {len(alumnos)+1}:")
        alumnos.append(nombre)

        temporal = []
        for i in range(5):
            calif = int(input(f"Calificación {i+1} de {nombre}:"))
            temporal.append(calif)

        calificaciones.append(temporal.copy())
        temporal.clear()

        opcion = input("Otro alumno? (s/n) ").lower()
        otro = (opcion == "s")

    imprimir_tabla(alumnos, calificaciones)


def imprimir_tabla(alumnos, califs):
    #               15       3   3   3   3   3
    print("+---------------+---+---+---+---+---+----------+")
    print("|    Nombre     | 1 | 2 | 3 | 4 | 5 | Promedio |")
    print("+---------------+---+---+---+---+---+----------+")
    promedios = []
    for i, alumno in enumerate(alumnos):
        promedio = sum(califs[i]) / 5
        promedios.append(promedio)

        print(f"|{alumno:15}|{califs[i][0]:3}|{califs[i][1]:3}|{
            califs[i][2]:3}|{califs[i][3]:3}|{califs[i][4]:3}| {promedio:9.2f}|")
    print("+---------------+---+---+---+---+---+----------+")
    promedio_general = sum(promedios) / len(promedios)
    print(
        f"+---------------+---+---+---+---+---+{promedio_general:10.2f}+")


if __name__ == "__main__":
    main()

reloj.py

# Inicialización de variables globales para horas y minutos
horas = 0
minutos = 0


def main():
    global horas, minutos
    print("= Reloj digital =")

    # Solicitar la hora y los minutos iniciales al usuario
    horas = int(input("Hora inicial: "))
    minutos = int(input("Minutos iniciales: "))

    # Ajuste de hora y minutos si están fuera de los límites permitidos
    if (horas < 0 or horas > 23):
        horas = 12

    if (minutos < 0 or minutos > 59):
        minutos = 0

    # Mostrar la hora inicial en pantalla
    pantalla(horas, minutos)

    # Ejemplo de restar minutos y mostrar el resultado en pantalla
    minutos = restar_minutos(minutos)
    minutos = restar_minutos(minutos)
    pantalla(horas, minutos)


def pantalla(h, m):
    # Función para mostrar la hora en formato HH:MM
    print("+--+--+")
    print(f"|{h:02}:{m:02}|")
    print("+--+--+")


def sumar_hora(h):
    # Función para sumar una hora, con ajuste si se pasa de 23
    h += 1
    if h > 23:
        h = 0
    return h


def restar_hora(h):
    # Función para restar una hora, con ajuste si es menor de 0
    h -= 1
    if h < 0:
        h = 23
    return h


def sumar_minutos(m):
    # Función para sumar un minuto, con ajuste si se pasa de 59
    m += 1
    if m > 59:
        global horas
        horas = sumar_hora(horas)
        m = 0
    return m


def restar_minutos(m):
    # Función para restar un minuto, con ajuste si es menor de 0
    m -= 1
    if m < 0:
        global horas
        horas = restar_hora(horas)
        m = 59
    return m


if __name__ == "__main__":
    main()

salarios.py

COSTO_A = 50
COSTO_B = 65
COSTO_C = 75
HRS_MAX = 40
RANGO_A = 20
RANGO_B = 15
RANGO_C = 5


def main():
    hrs = int(input("Cantidad de hrs trabajadas: "))

    if hrs < 0:
        print("❌ Las horas trabajadas no pueden ser negativas")
    else:
        no_pagadas = hrs - HRS_MAX
        if no_pagadas > 0:
            hrs_pagar = hrs - no_pagadas
        else:
            hrs_pagar = hrs

        hrs_a = 0  # Tipo A: COSTO_A
        hrs_b = 0  # Tipo B: COSTO_B
        hrs_c = 0  # Tipo C: COSTO_C

        if hrs_pagar > 0 and hrs_pagar <= RANGO_A:
            hrs_a = hrs_pagar * COSTO_A
        elif hrs_pagar > RANGO_A and hrs_pagar <= RANGO_A + RANGO_B:
            hrs_a = RANGO_A * COSTO_A
            hrs_b = (hrs_pagar - RANGO_A) * COSTO_B
        else:
            hrs_a = RANGO_A * COSTO_A
            hrs_b = RANGO_B * COSTO_B
            hrs_c = (hrs_pagar - (RANGO_A + RANGO_B)) * COSTO_C

        # print(f"Hrs no pagadas: {no_pagadas}")
        # print(f"Hrs por pagar: {hrs_pagar}")
        # print(f"{hrs_a / 50} hrs x $50: ${hrs_a}")
        # print(f"{hrs_b / 65} hrs x $65: ${hrs_b}")
        # print(f"{hrs_c / 75} hrs x $75: ${hrs_c}")

        imprimir_totales(no_pagadas, hrs_pagar, hrs_a, hrs_b, hrs_c)


def imprimir_totales(no_pagadas, pagadas, hrs_a, hrs_b, hrs_c):
    if no_pagadas > 0:
        print(f"Hrs no pagadas: {no_pagadas}")

    print(f"Hrs por pagar: {pagadas}")

    if hrs_a / COSTO_A > 0:
        print(f"{(hrs_a / COSTO_A):.0f} hrs x ${COSTO_A}: ${hrs_a:0,.0f}")

    if hrs_b / COSTO_B > 0:
        print(f"{hrs_b / COSTO_B} hrs x ${COSTO_B}: ${hrs_b}")

    if hrs_c / COSTO_C > 0:
        print(f"{hrs_c / COSTO_C} hrs x ${COSTO_C}: ${hrs_c}")

    total = hrs_a + hrs_b + hrs_c
    print(f"Total a pagar: ${total:0,.0f}")


if __name__ == "__main__":
    main()