Autor: Juan Pablo Fuentes

# función a la que le pasamos una lista de números y nos devuelve una tupla
# con el número de pares y el número de impares
# contarParidad([1,2,3,4,5])->(2,3) (dos pares y tres impares)

def contarParidad(lista):
    pares = 0
    impares = 0
    for numero in lista:
        if numero % 2 == 0:
            pares += 1
        else:
            impares += 1
    return (pares, impares)


def contarParidad2(lista):
    pares = len([numero for numero in lista if numero % 2 == 0])
    return (pares, len(lista) - pares)


print(contarParidad([1, 2, 3, 4, 5]))
print(contarParidad2([1, 2, 3, 4, 5]))
concesionario = [{"marca": "Tesla", "tipo": "Electrico", "autonomía": 500, "precio": 40000},
                 {"marca": "Citroen", "tipo": "Gasolina", "autonomía": 2500, "precio": 10000},
                 {"marca": "Ford", "tipo": "Gasolina", "autonomía": 3500, "precio": 20000},
                 {"marca": "Ferrari", "tipo": "Gasolina", "autonomía": 5500, "precio": 120000},
                 {"marca": "Seat", "tipo": "Electrico", "autonomía": 700, "precio": 10000},
                 {"marca": "Skoda", "tipo": "Gasolina", "autonomía": 3500, "precio": 7000},
                 ]

# Cread una función que nos devuelva la suma de precios del concesionario
def sumaPrecios(concesionario):
    total=0
    for coche in concesionario:
        total+=coche["precio"]
    return total

def sumaPrecios2(concesionario):
    return sum([coche["precio"] for coche in concesionario])
print(sumaPrecios(concesionario))
print(sumaPrecios2(concesionario))
# Cread una función a la que le pasamos una cadena y una longitud y nos devuelve las cadenas
# que superan esa longitud
# masLargas("hola que tal vamos",3)->["hola","vamos"]

def masLargas(cadena, longitud):
    palabras=cadena.split(" ")
    resultado=[]
    for palabra in palabras:
        if len(palabra)>longitud:
            resultado.append(palabra)
    return resultado

def masLargas2(cadena, longitud):
    palabras=cadena.split(" ")
    return [palabra for palabra in palabras if len(palabra)>longitud]

print(masLargas("hola que tal vamos",3))
print(masLargas2("hola que tal vamos",3))

# corregir código

def factorial(numero):
    total = 1
    while numero > 1:
        total *= numero
        numero -= 1
    return total


print(factorial(5))  # 120 5*4*3*2*1


def palabraMaslarga(cadena):
    palabras = cadena.split(" ")
    masLarga = palabras[0]  # Aquí NO hay un error
    for palabra in palabras:
        if len(palabra) > len(masLarga):  # Aquí hay un error (al revés)
            masLarga = palabra  # Aquí hay un error
    return masLarga


def numeroMayor(lista):
    mayor = lista[0]
    for numero in lista:
        if numero > mayor:  # Aquí hay un error (al revés)
            mayor = numero  # Aquí hay un error
    return mayor


print(palabraMaslarga("En un lugar de la mancha de cuyo nombre no quiero acordarme"))
print(numeroMayor([1, 2, 3, 7, 6, 5, 2]))
print(numeroMayor([-5, -2, -17 - 3]))


# Cread una función porcentajeIva que nos devuelva:
# 0 si el producto es "primera necesidad"
# 4 si es 'libro' o 'revista'
# 10 si es 'pañales'
# 21 en otros casos
def porcentajeIva(producto):
    if producto == "primera necesidad":
        return 0
    elif producto == "libro" or producto == "revista":
        return 4
    elif producto == "pañales":
        return 10
    else:
        return 21


print(porcentajeIva("primera necesidad"))
print(porcentajeIva("libro"))
print(porcentajeIva("revista"))
print(porcentajeIva("pañales"))
print(porcentajeIva("cacahuetes"))


# define una función a la que le pasamos una cadena y nos dice la media de longitud
# de las palabras de la cadena
def mediaLongitud(cadena):
    palabras = cadena.split(" ")
    longitudTotal = 0
    for palabra in palabras:
        longitudTotal += len(palabra)
    return longitudTotal / len(palabras)


def mediaLongitud2(cadena):
    palabras = cadena.split(" ")
    longitudes = [len(palabra) for palabra in palabras]
    return sum(longitudes) / len(palabras)


print(mediaLongitud("aa bbbb ccc"))
print(mediaLongitud2("aa bbbb ccc"))


# Una función números pares a la que le pasamos una lista de números y nos devuelve los pares

def numerosPares(lista):
    resultado = []
    for numero in lista:
        if numero % 2 == 0:
            resultado.append(numero)
    return resultado


def numerosPares2(lista):
    return [numero for numero in lista if numero % 2 == 0]


print(numerosPares([1, 2, 3, 4, 5, 6, 7, 8]))
print(numerosPares2([1, 2, 3, 4, 5, 6, 7, 8]))

clase = [{
    "nombre": "Ana",
    "creditos": 15,
    "curso": "Python"
}, {
    "nombre": "Iu",
    "creditos": 5,
    "curso": "Python"
}, {
    "nombre": "Eva",
    "creditos": 25,
    "curso": "BBDD"
}, {
    "nombre": "Pep",
    "creditos": 7,
    "curso": "BBDD"
}, ]


# Crea una función a la que le pasamos una clase y nos devuelve el total de créditos
def totalCreditos(clase):
    total = 0
    for alumno in clase:
        total += alumno['creditos']
    return total


def totalCreditos2(clase):
    total = sum([alumno['creditos'] for alumno in clase])
    return total


def totalCreditosCurso(clase, curso):
    total = 0
    for alumno in clase:
        if alumno['curso'] == curso:
            total += alumno['creditos']
    return total


def totalCreditosCurso2(clase, curso):
    total = sum([alumno['creditos'] for alumno in clase if alumno['curso'] == curso])
    return total


print(totalCreditos(clase))
print(totalCreditos2(clase))
print(totalCreditosCurso(clase, "BBDD"))
print(totalCreditosCurso2(clase, "BBDD"))


# ordenar los alumnos por crédito

def ordenCredito(clase):
    ordenados = sorted(clase, key=lambda x: x['creditos'])
    return ordenados


def ordenarCredito(clase):
    ordenados = sorted([alumno['creditos'] for alumno in clase])
    return ordenados


def mayorCredito(clase):
    mayor = max(clase, key=lambda x: x['creditos'])
    return mayor


def mayorCredito2(clase):
    mayor = max([alumno['creditos'] for alumno in clase])
    return mayor


print(ordenCredito(clase))
print(ordenarCredito(clase))
print(mayorCredito(clase))
print(mayorCredito2(clase))


# Cread una función a la que le pasamos una cadena y una letra y nos devueve una
# lista con las palabras que tienen esa letra

def palabrasConLetra(cadena, letra):
    palabras = cadena.split(" ")
    resultado = []
    for palabra in palabras:
        if letra in palabra:
            resultado.append(palabra)
    return resultado


def palabrasConLetra2(cadena, letra):
    palabras = cadena.split(" ")
    return [palabra for palabra in palabras if letra in palabra]


print(palabrasConLetra("hola que tal yo mal", "a"))
print(palabrasConLetra2("hola que tal yo mal", "a"))


# Una función a la que le pasamos una cadena y nos devuelve una lista
# con la primera letra de cada palabra

def primeraLetra(cadena):
    palabras = cadena.split(" ")
    resultado = []
    for palabra in palabras:
        resultado.append(palabra[0])
    return resultado


def primeraLetra2(cadena):
    palabras = cadena.split(" ")
    return [palabra[0] for palabra in palabras]


print(primeraLetra("hola que tal yo muy bien"))
print(primeraLetra2("hola que tal yo muy bien"))

# Cread una función a la que le pasamos una cadena y nos devuelve una lista de palabras
# que empiecen y acaben con la misma letra
def inicioFin(cadena):
    palabras = cadena.split(" ")
    resultado=[]
    for palabra in palabras:
        if palabra[0]==palabra[-1]:
            resultado.append(palabra)
    return resultado

def inicioFin2(cadena):
    palabras = cadena.split(" ")
    return [palabra for palabra in palabras if palabra[0]==palabra[-1]]

print(inicioFin("hola ana como sales tan pronto"))
print(inicioFin2("hola ana como sales tan pronto"))

import datetime
import random


# Cread una función tiradaDado que nos devuelva un número aleatorio del 1 al 6

def tiradaDado(limite=6):
    return random.randint(1, limite)


for i in range(10):
    print(tiradaDado())


# Cread una función que nos devuelva al azar una provincia de Barcelona
def provinciaAzar():
    provincias = ["Barcelona", "Tarragona", "Lleida", "Girona"]
    return random.choice(provincias)


for i in range(10):
    print(provinciaAzar())


# Cread una función que nos devuelva el año actual
def anyoActual():
    return datetime.date.today().year


print(anyoActual())


# Cread una función que nos devuelva True si hoy es viernes y false en caso contrario
def esViernes():
    return datetime.date.today().weekday() == 4  # 0 lunes hasta 6 domingo


print(esViernes())


# Cread una función que nos devuelva la fecha actual en formato día/mes/año

def fechaActual():
    return datetime.date.today().strftime("%d/%m/%Y")


print(fechaActual())


# Cread una función que nos devuelva el siguiente día laborable a partir de hoy
def siguienteLaborable():
    fecha = datetime.date.today()
    fecha += datetime.timedelta(days=1)
    while fecha.weekday() > 4:
        fecha += datetime.timedelta(days=1)
    return fecha


def siguienteLaborable2():
    fecha = datetime.date.today()
    fecha += datetime.timedelta(days=1)
    if fecha.weekday() > 4:
        fecha += datetime.timedelta(days=(7 - fecha.weekday()))
    return fecha


print(siguienteLaborable2())

SESIÓN VIRTUAL (10-04-2025 18_00_00)-20250410_180338-Grabación de la reunión.mp4

SESIÓN VIRTUAL (16-04-2025 18_00_00)-20250416_180432-Grabación de la reunión.mp4

SESIÓN VIRTUAL (22-04-2025 18_00_00)-20250422_180529-Grabación de la reunión.mp4

SESIÓN VIRTUAL (24-04-2025 18_00_00)-20250424_180332-Grabación de la reunión.mp4

SESIÓN VIRTUAL (25-04-2025 18_00_00)-20250425_180447-Grabación de la reunión.mp4

SESIÓN VIRTUAL (29-04-2025 18_00_00)-20250429_180841-Grabación de la reunión.mp4

SESIÓN VIRTUAL (30-04-2025 18_00_00)-20250430_180856-Grabación de la reunión.mp4

SESIÓN VIRTUAL (02-05-2025 18_00_00)-20250502_180552-Grabación de la reunión.mp4

SESIÓN VIRTUAL (05-05-2025 18_00_00)-20250505_180717-Grabación de la reunión.mp4

SESIÓN VIRTUAL (06-05-2025 18_00_00)-20250506_180919-Grabación de la reunión.mp4

SESIÓN VIRTUAL (07-05-2025 18_00_00)-20250507_181546-Grabación de la reunión.mp4

SESIÓN VIRTUAL (08-05-2025 18_00_00)-20250508_180607-Grabación de la reunión.mp4

SESIÓN VIRTUAL (09-05-2025 18_00_00)-20250509_181432-Grabación de la reunión.mp4

# Cread una función tiradaDado que nos devuelva un número aleatorio del 1 al 6

# Cread una función que nos devuelva al azar una provincia de Cataluña

# Cread una función que nos devuelva el año actual

# Cread una función que nos devuelva True si hoy es viernes y false en caso contrario

# Cread una función que nos devuelva la fecha actual en formato día/mes/año

# Cread una función que nos devuelva el siguiente día laborable a partir de hoy

biblioteca = [
    {"titulo": "El Quijote", "autor": "Cervantes", "precio": 20},
    {"titulo": "Las olas", "autor": "Virginia Woolf", "precio": 17},
    {"titulo": "Los detectives salvajes", "autor": "Roberto Bolaño", "precio": 23},
    {"titulo": "Tom va a la escuela", "autor": "Rick Sánchez", "precio": 10}
]

# Para resolver los siguientes ejercicios podéis usar cualquier método de los vistos en clase

# Calcular la suma de todos los precios

# obtener precio
# Haciendo el bucle de toda la vida y sumando los precios
suma = 0
for libro in biblioteca:
    suma += libro["precio"]
print(suma)
# Comprension de listas obteniendo solo el precio, entonces ya puedo usar 'sum'
precios = [libro["precio"] for libro in biblioteca]
print(sum(precios))
# Obteniendo los precios mediante el 'map' y una función lambda, después puedo usar 'sum'
precios = list(map(lambda x: x["precio"], biblioteca))
print(sum(precios))

# Queremos obtener el libro con el precio más alto
# Método tradicional con un for nos guardamos el más caro 'de momento'
libroCaro = None
precio = 0
for libro in biblioteca:
    # Si encontramos uno más caro nos lo quedamos
    if libro["precio"] > precio:
        precio = libro["precio"]
        libroCaro = libro
print(libroCaro)

# Usar max junto con lambda para que busque el máximo de la propiedad 'precio'
libroCaro = max(biblioteca, key=lambda x: x["precio"])
print(libroCaro)

# queremos ordenarlos por título

# Ordenamos mediante título usando una lambda
librosPorTitulo = sorted(biblioteca, key=lambda x: x["titulo"])
print(librosPorTitulo)

proyectos = [
    {"nombre": "Análisis", "horas": 10, "precio": 60},
    {"nombre": "Desarrollo", "horas": 50, "precio": 50},
    {"nombre": "Implementación", "horas": 5, "precio": 70},
    {"nombre": "Pruebas", "horas": 15, "precio": 40},
]

# Queremos calcular el coste total de todos los proyectos (horas*precio)

total = 0
for proyecto in proyectos:
    total += proyecto["horas"] * proyecto["precio"]
print(total)

importes = [proyecto["horas"] * proyecto["precio"] for proyecto in proyectos]
print(sum(importes))
importes = list(map(lambda x: x["precio"] * x["horas"], proyectos))
print(sum(importes))

# El proyecto con mayor coste (horas*precio)
mayorCoste = max(proyectos, key=lambda proyecto: proyecto["precio"] * proyecto["horas"])
print(mayorCoste)
# ordenar por número de horas
porHoras = sorted(proyectos, key=lambda x: x["horas"])
print(porHoras)
# Filtrar los que cuesten más 1000 €

caros = [proyecto for proyecto in proyectos if proyecto["horas"] * proyecto["precio"] > 1000]
print(caros)
caros = list(filter(lambda x: x["horas"] * x["precio"] > 1000, proyectos))
print(caros)

biblioteca = [
    {"titulo": "El Quijote", "autor": "Cervantes", "precio": 20},
    {"titulo": "Las olas", "autor": "Virginia Woolf", "precio": 17},
    {"titulo": "Los detectives salvajes", "autor": "Roberto Bolaño", "precio": 23},
    {"titulo": "Tom va a la escuela", "autor": "Rick Sánchez", "precio": 10}
]

# Para resolver los siguientes ejercicios podéis usar cualquier método de los vistos en clase

# Calcular la suma de todos los precios

# Queremos obtener el libro con el precio más alto

# queremos ordenarlos por título

proyecto = [
    {"nombre": "Análisis", "horas": 10, "precio": 60},
    {"nombre": "Desarrollo", "horas": 50, "precio": 50},
    {"nombre": "Implementación", "horas": 5, "precio": 70},
    {"nombre": "Pruebas", "horas": 15, "precio": 40},
]

# Queremos calcular el coste total de todos los proyectos (horas*precio)
# El proyecto con mayor coste (horas*precio)
# ordenar por número de horas
# Filtrar los que cuesten más 1000 €

alumnos = ["Ana", "Iu", "Eva", "Victoria", "Ramon"]


def ultimaLetra(cadena):
    return cadena[-1]


ordenado = sorted(alumnos)
print(ordenado)
ordenado = sorted(alumnos, key=len)
print(ordenado)
ordenado = sorted(alumnos, key=ultimaLetra)
print(ordenado)
maslargo = max(alumnos, key=len)
print(maslargo)
maslargo = max(alumnos, key=ultimaLetra)
print(maslargo)

clase = [
    {"nombre": "Ana", "nota": 7},
    {"nombre": "Eva", "nota": 3},
    {"nombre": "Iu", "nota": 6},
    {"nombre": "Luis", "nota": 8},
    {"nombre": "Pep", "nota": 5},
]


def getNota(elemento):
    return elemento["nota"]


maslisto = max(clase, key=getNota)
print(maslisto)
peor = min(clase, key=getNota)
print(peor)

# Funciones lambda: Son funciones anónimas que se definen al momento
# lambda argumentos: expresion que se devuelve
maslisto = max(clase, key=lambda x: x["nota"])
print(maslisto)
# lo que hace el código de antes es recorrer la lista, obtener la nota de cada elemento
# ordenar por ese valor (es decir, por nota) y devolver el que tenga el valor máximo

suma_lambda = lambda x, y: x + y
print(suma_lambda(3, 4))
pornotas = sorted(clase, key=lambda alumno: alumno["nota"])
print(pornotas)

# Hay una función predefinida de python que es 'map'
# aplica una función a todos los elementos de un iterable
numeros = [1, 2, 3, 4, 5]


def cuadrado(x):
    return x ** 2


cuadrados = list(map(cuadrado, numeros))
print(cuadrados)

cuadrados2 = list(map(lambda x: x ** 2, numeros))
print(cuadrados2)

aprobados = list(filter(lambda x: x["nota"] >= 5, clase))
print(aprobados)


notas = [10, 2, 3, 4, 5, 6, 7, 8, 9]


def esPar(numero):
    return numero % 2 == 0


pares = []
for nota in notas:
    if esPar(nota):
        pares.append(nota)
print(pares)

pares2 = [nota for nota in notas if esPar(nota)]
print(pares2)

pares3 = list(filter(esPar, notas))
print(pares3)

# Reescribir esto sin usar esPar

pares = []
for nota in notas:
    if nota % 2 == 0:
        pares.append(nota)
print(pares)

pares2 = [nota for nota in notas if nota % 2 == 0]
print(pares2)

pares3 = list(filter(lambda nota: nota % 2 == 0, notas))
print(pares3)

pedidos = [{"producto": "Libro", "precio": 20}, {"producto": "Lápiz", "precio": 2},
           {"producto": "Cuaderno", "precio": 5}, {"producto": "Tablet", "precio": 200},
           {"producto": "Funda", "precio": 15}]

# pedidos de 20 de precio o más
masde20 = []
for pedido in pedidos:
    if pedido["precio"] >= 20:
        masde20.append(pedido)

print(masde20)

masde20b = [pedido for pedido in pedidos if pedido["precio"] >= 20]
print(masde20b)

masde20c = list(filter(lambda pedido: pedido["precio"] >= 20, pedidos))
print(masde20c)

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

}
# Esto no se pedía, pero si queremos añadir notas personalizadas a cada alumno lo podemos hacer así
notasnuevas = [6, 7, 4, 8]
# Para guardar el que tenga la media más alta. Necesitamos la media para saber el valor
# y primerodelaclase para el nombre
mediaprimero = 0
primerodelaclase = ""
# recorrer un diccionario
for alumno, notas in alumnos.items():
    media = sum(notas) / len(notas)
    print(f"El alumno {alumno} tiene una nota media de {media:.2f}")
    if media > mediaprimero:
        mediaprimero = media
        primerodelaclase = alumno
    notas.append(notasnuevas.pop())
print("El primero de la clase es ", primerodelaclase)  #

# No es recomendable. Por varias cosas, una, si añado alumnos ya no funciona
# Si tengo muchos alumnos se me juntan demasiadas líneas
# Y no vale decir 'Así pongo una nota individualizada' ;)
alumnos["Ana"].append(3)
alumnos["Luis"].append(3)
alumnos["Marta"].append(3)

alumnos.keys()  # Las claves "Ana","Luis"...
alumnos.values()  # Los valores [8, 6, 10],...
alumnos.items()  # Los pares clave valor ("Ana",[8, 6, 10])....

alumnos  # python me devuelve alumnos.keys()

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

# Añade "sandía" a la categoría de frutas.
inventario["frutas"].append("sandía")
print(inventario)
# Imprime todos los productos (uno por línea).
for productos in inventario.values():
    for producto in productos:
        print(producto)

# Cuenta cuántos productos hay en total.
numproductos = 0
for productos in inventario.values():
    numproductos += len(productos)
print(numproductos)

# 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
    pedidos = datos[cliente]
    total = 0
    for pedido in pedidos:
        total += pedido["precio"]
    return total
def total_gastado_c(cliente, datos):
    return sum([pedido["precio"] for pedido in datos[cliente]])

def productosPorCliente(
        datos):  # nos devuelve un diccionario donde la clave es el nombre del cliente y el valor es el número de productos
    resultado = {}
    for clave, valor in datos.items():
       resultado[clave] = len(valor)
    return resultado

def productosPorCliente_c(
        datos):  # nos devuelve un diccionario donde la clave es el nombre del cliente y el valor es el número de productos
    return {clave:len(valor) for clave, valor in datos.items()}

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

# if "Ana" in clientes:
print(total_gastado("Luis", clientes))
print(total_gastado_c("Luis", clientes))
print(productosPorCliente(clientes))
print(productosPorCliente_c(clientes))