Trifulcas

🧪 Ejercicio 1: Alumnos y sus notas

Diccionario: Cada alumno tiene una lista de notas.

alumnos = {
    "Ana": [8, 9, 10],
    "Luis": [5, 6, 7],
    "Marta": [9, 8, 9]
}

📌 Tareas:

1. Imprime el promedio de notas de cada alumno.
2. Añade una nota más a cada alumno (da igual la que sea).
3. Muestra el alumno con la nota media más alta.

---

🧪 Ejercicio 2: Inventario por categoría

Diccionario: Categorías con listas de productos.

inventario = {
    "frutas": ["manzana", "pera", "plátano"],
    "verduras": ["zanahoria", "brócoli"],
    "bebidas": ["agua", "zumo"]
}

📌 Tareas:

1. Añade “sandía” a la categoría de frutas.
2. Imprime todos los productos (uno por línea).
3. Cuenta cuántos productos hay en total.

# Diccionario donde cada cliente tiene una lista de pedidos (cada pedido es un dict)
clientes = {
“Juan”: [{“producto”: “Libro”, “precio”: 20}, {“producto”: “Lápiz”, “precio”: 2}],
“Ana”: [{“producto”: “Cuaderno”, “precio”: 5}],
“Luis”: [{“producto”: “Tablet”, “precio”: 200}, {“producto”: “Funda”, “precio”: 15}]
}

def total_gastado(cliente, datos): # Nos devuelve cuanto ha gastado cada cliente en total

def productosPorCliente(datos): # nos devuelve un diccionario donde la clave es el nombre del cliente y el valor es el número de productos

Para saber si un diccionario ya tiene una clave usamos ‘in’ como en las listas

if “Ana” in clientes:

 

# Listas: conjunto de elementos sobre el que podemos realizar diferentes operaciones
# Tuplas: como las listas pero se pueden desempaquetar
# Diccionarios: Conjunto de pares clave, valor

notas = [1, 2, 3, 4]
tupla = (1, 2, 3)
diccionario = {
    "nombre": "Ana",
    "nota": 6
}

# En python todo esto se puede combinar

# Quiero guardar los datos de un alumno
alumno = {
    "nombre": "ana",
    "email": "ana@ana.es",
    "curso": "Python"
}
# Quiero guardar también las asignaturas, que son varias
alumno = {
    "nombre": "ana",
    "email": "ana@ana.es",
    "curso": "Python",
    "asignaturas": ["Programación", "Bases de datos"]
}

# Para cada asignatura, quiero guardar su nota y su profesor
alumno = {
    "nombre": "ana",
    "email": "ana@ana.es",
    "curso": "Python",
    "asignaturas": [{"nombre": "Programación", "nota": 7, "profesor": "JP"},
                    {"nombre": "Bases de datos", "nota": 8, "profesor": "Iu"}]
}
# Para cada asignatura, tiene 3 notas
alumno = {
    "nombre": "ana",
    "email": "ana@ana.es",
    "curso": "Python",
    "asignaturas": [{"nombre": "Programación", "nota": [7, 8, 6], "profesor": "JP"},
                    {"nombre": "Bases de datos", "nota": [8, 9, 9], "profesor": "Iu"}]
}
# Guardar la información de toda la clase que son varios alumnos
clase = [{
    "nombre": "ana",
    "email": "ana@ana.es",
    "curso": "Python",
    "asignaturas": [{"nombre": "Programación", "nota": [7, 8, 6], "profesor": "JP"},
                    {"nombre": "Bases de datos", "nota": [8, 9, 9], "profesor": "Iu"}]
},
    {
        "nombre": "iu",
        "email": "iu@iu.es",
        "curso": "Python",
        "asignaturas": [{"nombre": "Programación", "nota": [4, 2, 3], "profesor": "JP"},
                        {"nombre": "Bases de datos", "nota": [8, 9, 9], "profesor": "Iu"}]
    }
    ,
    {
        "nombre": "Eva",
        "email": "eva@eva.es",
        "curso": "Bases de datos",
        "asignaturas": [{"nombre": "sistema", "nota": [5, 7, 6], "profesor": "Pep"},
                        {"nombre": "Bases de datos", "nota": [7, 6, 9], "profesor": "Iu"}]
    }
]

for alumno in clase:
    print(alumno)  # Recorro los alumnos que, recordemos, son diccionarios

# Quiero un listado de todos los alumnos
for alumno in clase:
    print(alumno["nombre"])

nombres = [alumno['nombre'] for alumno in clase]
print(nombres)

# Para cada alumno ver las asignaturas que tiene
# Primero me recorro los alumnos
for alumno in clase:
    print(f"El alumno {alumno['nombre']} tiene las asignaturas:")
    for asignatura in alumno["asignaturas"]:
        print(asignatura["nombre"])

# Para cada alumno ver los profesores que tiene
for alumno in clase:
    print(f"El alumno {alumno['nombre']} tiene los profesores:")
    for asignatura in alumno["asignaturas"]:
        print(asignatura["profesor"])
        print(f"Que le ha puesto las siguienes notas")
        for nota in asignatura["nota"]:
            print(nota)

votaciones = [
    {
        "votante": "Juan",
        "votos": [
            {"participante": "Ana", "puntos": 5},
            {"participante": "Pedro", "puntos": 3}
        ]
    },
    {
        "votante": "Marta",
        "votos": [
            {"participante": "Ana", "puntos": 4},
            {"participante": "Luis", "puntos": 2}
        ]
    },
    {
        "votante": "Pedro",
        "votos": [
            {"participante": "Ana", "puntos": 3},
            {"participante": "Luis", "puntos": 5}
        ]
    }
]

# Nombre de los votantes
for votante in votaciones:
    print(f"El votante {votante["votante"]} ha hecho los siguientes votos")
    for voto in votante["votos"]:
        print(f"{voto["puntos"]} al participante {voto["participante"]}")


# Cuantos puntos tiene un participante
def puntosParticipante(votaciones, participante):
    puntos = 0
    for votante in votaciones:
        for voto in votante["votos"]:
            if voto["participante"] == participante:
                puntos += voto["puntos"]
    return puntos


print(puntosParticipante(votaciones, "Ana"))

# Cread una función provincias() que nos devuelva una tupla con las provincias de Catalunya
# utilizad desempaquetamiento para asignarlo a cuatro variables a,b,c,d
# Recorred la tupla con un for

def provincias():
    return ("Barcelona", "Girona", "Lleida", "Tarragona")


a, b, c, d = provincias()
print(c)  # Lleida

for provincia in provincias():
    print(provincia)


# Cread una función descuentos que nos devuelva una tupla con descuentos de 5,10 y 20
# utilizad desempaquetamiento para:
# obtener los 3 descuentos
# obtener el primer descuento e ignorar los otros dos
def descuentos():
    return (5, 10, 20)


d1, d2, d3 = descuentos()
print(d1, d2, d3)
d1, *_ = descuentos()
d1, _, _ = descuentos()
print(d1)
print(descuentos())


# Cread una función estadística a la que le pasamos una lista de números y nos devuelve una tupla
# con la cantidad de números, la suma, y la media
# estadistica([1,2,3,4])->(4,10,2.5)

# Tuplas
def estadistica(lista):
    return (len(lista), sum(lista), sum(lista) / len(lista))


print(estadistica([1, 2, 3, 4]))
# Ejemplos de desempaquetado
# solo quiero la media
*_, media = estadistica([1, 2, 3, 4])
print(media)
# solo quiero la suma
_, suma, _ = estadistica([1, 2, 3, 4])
print(suma)
# Si quiero recuperar todo hago esto
longitud, suma, media = estadistica([1, 2, 3, 4])


# vs Listas
def estadistica(lista):
    return [len(lista), sum(lista), sum(lista) / len(lista)]


# quiero saber la media
media = estadistica([2, 4, 91, 7])[2]
# quiero todos
longitud = estadistica([2, 4, 91, 7])[0]
suma = estadistica([2, 4, 91, 7])[1]
media = estadistica([2, 4, 91, 7])[2]
# Cread un diccionario para almacenar los datos de un cliente que son nombre Eva, email eva@eva.com
# telefono 666777666 y credito 5000
cliente = {
    "nombre": "Eva",
    "email": "eva@eva.com",
    "telefono": "666777666",
    "credito": 5000
}


# Cread una función a la que le pasamos un diccionario como el de los libros y nos devuelve el
# título del libro que tenga más ejemplares
def masEjemplares(libros):
    titulo = ""
    ejemplares = 0
    for clave, valor in libros.items():
        if valor > ejemplares:
            ejemplares = valor
            titulo = clave

    return titulo


inventario = {
    "Cien años de soledad": 400,
    "El Principito": 10,
    "1984": 6,
    "Tierra yerma": 400
}
inventario["El Quijote"] = 90
print(masEjemplares(inventario))

print(list(inventario.keys())[1:3])
# list, tuple y dict podemos convertir a lista, tupla o diccionario
print(list(inventario))  # todas las claves
print(list(inventario.values()))  # todos los valores
print(max(inventario.values()))


def masEjemplares2(libros):
    maximo = max(libros.values())
    titulo = [libro for libro, ejemplares in libros.items() if ejemplares == maximo]
    return titulo


print(masEjemplares2(inventario))

# Cread una función provincias() que nos devuelva una tupla con las provincias de Catalunya
# utilizad desempaquetamiento para asignarlo a cuatro variables a,b,c,d
# Recorred la tupla con un for


# Cread una función descuentos que nos devuelva una tupla con descuentos de 5,10 y 20
# utilizad desempaquetamiento para:
# obtener los 3 descuentos
# obtener el primer descuento e ignorar los otros dos


# Cread una función estadística a la que le pasamos una lista de números y nos devuelve una tupla
# con la cantidad de números, la suma, y la media
# estadistica([1,2,3,4])->(4,10,2.5)


# Cread un diccionario para almacenar los datos de un cliente que son nombre Eva, email eva@eva.com
# telefono 666777666 y credito 5000

# Cread una función a la que le pasamos un diccionario como el de los libros y nos devuelve el 
# título del libro que tenga más ejemplares

# Un diccionario es una estructura de datos que almacena un conjunto de pares
# clave, valor
# Es decir, no son valores únicos, sino que se componen de una clave y de un valor
# La clave es inmutable y el valor no

persona = {
    "nombre": "Ana",
    "edad": 30,
    "profesion": "Ingeniera"
}
print(persona)
print(persona["edad"])  # 30
persona["edad"] = 32
print(persona)
persona["sueldo"] = 5000
print(persona)
# print(persona["foo"]) # Da error porque no hay esa clave
print(persona.get("foo"))  # NO da error aunque no hay esa clave
print(persona.get("foo", "Sin valor"))  # NO da error aunque no hay esa clave y le doy un valor por defecto

# probad a crear un diccionario para un alumno que tenga nombre, nota y curso

alumno = {
    "nombre": "Ana",
    "nota": 8,
    "curso": "Bachillerato"
}

print(alumno.keys())  # Me devuelve todas las claves
print(alumno.values())  # Me devuelve todos los valores
print(alumno.items())  # Me devuelve todos los pares clave,valor

# recorrer un diccionario
for clave, valor in alumno.items():
    print(f"La clave {clave} tiene el valor {valor}")

for i in alumno.items():
    print(i)

# 1. Crear un diccionario con libros y su cantidad en inventario
inventario = {
    "Cien años de soledad": 4,
    "El Principito": 10,
    "1984": 6
}

# 2. Añadir un nuevo libro
inventario["Don Quijote"] = 3

# 3. Modificar la cantidad de un libro existente
inventario["1984"] = 8

# 4. Eliminar un libro del inventario
del inventario["El Principito"] # inventario.pop("El Principito")

# 5. Recorrer el diccionario e imprimir el inventario
print("Inventario actual:")
for titulo, cantidad in inventario.items():
    print(f"{titulo}: {cantidad} ejemplares")

# 6. Obtener solo los títulos disponibles
titulos = [titulo for titulo in inventario]
print("\nTítulos disponibles:", titulos)

# 7. Crear una lista de libros con más de 5 ejemplares
populares = [titulo for titulo, cantidad in inventario.items() if cantidad > 5]
print("\nLibros populares (más de 5 ejemplares):", populares)

# 8. Crear un nuevo diccionario con solo los libros escasos (3 o menos)
escasos = {titulo: cantidad for titulo, cantidad in inventario.items() if cantidad <= 3}
print("\nLibros escasos:", escasos)

# las tuplas son como las listas, pero inmutables
# No se pueden modificar
# Si las listas se definen con corchetes, las tuplas se definen con paréntesis

mitupla = (1, 2, 3, 4)
otratupla = ("Ana", "Pep", "Eva")

for numero in mitupla:
    print(numero)

print(mitupla[1])
print(mitupla[-1])
print(mitupla[1:3])


def extremos(lista):
    ordenada = sorted(lista) # [1,2,3,4,5,8]
    return (ordenada[0], ordenada[-1])


print(extremos([2, 4, 1, 8, 5, 3]))
# desempaquetar tupla
menor, mayor = extremos([2, 4, 1, 8, 5, 3])
print((menor))
print((mayor))

i, j = extremos([2, 4, 1, 8, 5, 3])
print((i))
print((j))

# desempaqueto 4 valores
a, b, c, d = mitupla  # a=1,b=2,c=3,d=4
print(c)

tupla = (2, 4, 8)

a, b, c = tupla  # a=2, b=4, c=8


def foo():
    return ("Sí", "No", "Quizás")


def tablairpf():
    return (5, 10, 12, 18)


s, n, q = foo()  # s="Sí", n="No", q="Quizás"

print(q)

bajo, medio, alto, superior = tablairpf()

# desempaquetar múltiples valores
b, *m, s = tablairpf()

print(b)  # 5
print(m)  # [10,12]
print(s)  # 18

b, m, *s = tablairpf()

print(b)  # 5
print(m)  # 10
print(s)  # [12, 18]

*_, m, s = tablairpf()

print(b)  # [5, 10]
print(m)  # 12
print(s)  # 18


def suma(*numeros):
    suma = 0
    for numero in numeros:
        suma += numero
    return suma


print(suma(1, 2))
print(suma(1, 2, 4, 5, 7))
print(suma(1, 2, 4, 5, 7, 8, 9, 10))

s, n, _ = foo()  # s="Sí", n="No", _ se ignora

Nivel fácil

1. Crea una lista con los cuadrados de los números del 1 al 10.
2. Obtén una lista con los números del 0 al 20 que sean múltiplos de 3.
3. Dada la lista ["Ana", "Luis", "Pedro"], obtén una lista con sus longitudes.

---

🔧 Nivel intermedio

4. Crear una función fueraNegativos a la que le pasamos una lista y nos devuelve solo los positivos fueraNegativos ([3, -1, -7, 5, 0])->[3,5,0]
5. Crea una función a la que se le pasa un límite y un número y nos devuelve una lista con todos los números hasta ese límite que son múltiplos de ese número listaMultiplos(10,4)->[4,8]
6. Crea una función a la que le pasamos un número y nos devuelve una lista con la tabla de multiplicar de ese número tablaMultiplicar(7)->[7,14,21,…70]

---

🔬 Nivel avanzado

7. Crea una función a la que le pasamos una lista de palabras y nos devuelve solo las que tengan vocales conVocales([“hola”,”qwfr”,”que”])->[“hola”,”que”]

def media(lista):
    suma = 0
    for numero in lista:
        suma += numero
    return (suma / len(lista))


def mediaAprobados2(lista):
    aprobados = []
    for numero in lista:
        if numero >= 5:
            aprobados.append(numero)
    return media(aprobados)

# Filtro la lista con el if >=5, no hago ninguna expresión
def mediaAprobados3(lista):
    aprobados = [nota for nota in lista if nota >= 5]
    return media(aprobados)


def contarCadenas(lista, longitud):
    # una variable donde contar
    cont = 0
    # recorrer la lista de cadenas
    for cadena in lista:
        # Si la cadena tiene una longitud mayor de 'longitud' contarla y si no hago nada
        if len(cadena) > longitud:
            cont += 1
    return cont

# Filtro la lista por las que tengan una longitud mayor que la que me pasan
def contarCadenas2(lista, longitud):
    # Palabras mayores de una longitud
    mayores = [cadena for cadena in lista if len(cadena) > longitud]
    # ¡Ojo! Devuelvo la longitud, porque estoy contando
    return len(mayores)


def minusculas(lista):
    resultado = []
    for elemento in lista:
        resultado.append(elemento.lower())
    return resultado

# No hago ningún filtro, solo transformo a minúsculas
def minusculas2(lista):
    minusculas = [cadena.lower() for cadena in lista]
    return minusculas


def longitudPar(lista):
    resultado = []
    for elemento in lista:
        if len(elemento) % 2 == 0:
            resultado.append(elemento)
    return resultado

# filtro las que tengan longitud par
def longitudPar2(lista):
    resultado = [cadena for cadena in lista if len(cadena) % 2 == 0]
    return resultado