Trifulcas

# conjunto es una colección de elementos que no se repiten

lista=[1,2,1,2,1,2]
print(lista)
print(lista[2])
conjunto={1,2,1,2,1,2}
print(conjunto)

vacio=set()
vacio2={}

while True:
    num=int(input("Numero (0 para salir) "))
    if num!=0:
        vacio.add(num)
    else:
        break

print(vacio)
c3=set("hola amigo")
print(c3)
c4=set([1,2,3,3,2,1,4,4,3,2])
print(c4)

c1={1,2,3}
c2={2,3,4,"hola",6.78, False}

print(c1 | c2)
print(c1.union(c2))
print(c1 & c2)
print(c1.intersection(c2))
print(c1-c2)
print(c1.difference(c2))

clase_mates={"ana","eva","pep","rosa","juan"}
clase_fisica={"eva","albert","pep","maria"}

total_alumnos=clase_mates | clase_fisica
alumnos_dos_clases=clase_mates & clase_fisica
alumnos_mates_noen_fisica=clase_mates-clase_fisica

print(total_alumnos)
print(alumnos_dos_clases)
print(alumnos_mates_noen_fisica)


# Escribe un programa que tome una lista de palabras y
# elimine los duplicados, devolviendo una nueva lista sin duplicados.

def sin_duplicados(lista):
    res=[]
    for palabra in lista:
        if palabra not in res:
            res.append(palabra)
    return res

def sin_duplicados2(lista):
    conjunto=set(lista) # lo paso a conjunto, eliminan duplicados
    return list(conjunto)

print(sin_duplicados2(["hola","que","hola","que","pasa"]))

# Escribe un programa que tome una cadena de texto y cuente cuántas
# vocales diferentes (a, e, i, o, u) se encuentran en la cadena.
# Utiliza un conjunto para realizar el seguimiento de las vocales
# únicas encontradas.

def vocales(cadena):
    diferentes=set()
    for letra in cadena:
        if letra in "aeiou":
            diferentes.add(letra)
    return diferentes

print (vocales("hola que tal"))

alumnos=[
        {"nombre":"Ana",
        "asignaturas":{"fisica","mates"},
        "pagos":[20,50,60,70]
        },
         {"nombre": "Pep",
          "asignaturas": {"quimica", "mates"},
          "pagos": [20, 150, 60, 70]
          },
         {"nombre": "Eva",
          "asignaturas": {"fisica", "quimica"},
          "pagos": [20, 50, 60, 70]
          }
         ]
print(alumnos)

for alumno in alumnos:
    print(alumno["nombre"],sum(alumno["pagos"]))
# matricular a todos los alumnos en 'mates'
for alumno in alumnos:
    alumno["asignaturas"].add("mates")

print(alumnos)

for alumno in alumnos:
    for asignatura in alumno["asignaturas"]:
        print(alumno["nombre"],asignatura)
# crear un diccionario cuyas claves sean las asignaturas y el valor
# un conjunto de alumnos
asignaturas={}
for alumno in alumnos:
    for asignatura in alumno["asignaturas"]:
        if asignatura in asignaturas:
            asignaturas[asignatura].add(alumno["nombre"])
        else:
            asignaturas[asignatura]={alumno["nombre"]}
print(asignaturas)

total=0
pagos={}
# total de pagos de todos los alumnos
for alumno in alumnos:
    total+=sum(alumno["pagos"])
    pagos[alumno["nombre"]]=total

print(total)
print(pagos)

# Conteo de letras: Crea una función llamada contar_letras(palabra)
# que tome una cadena de texto como argumento y devuelva un diccionario
# que contenga el recuento de cada letra en la palabra. Ignora los espacios
# y considera las letras en minúsculas y mayúsculas como iguales.

def contar_letras(palabra):
    res = {}
    for letra in palabra:
        letra=letra.lower() # La paso a minúsculas
        if letra.isalpha(): # compruebo que sea una letra
            if letra in res:
                res[letra] += 1
            else:
                res[letra] = 1
    return res

print(contar_letras("hola, ¿que tal estaS?"))

# Calculadora de calificaciones: Crea una función llamada
# calcular_promedio(calificaciones) que tome un diccionario
# de calificaciones (nombre del estudiante como clave y calificación
# como valor) y devuelva el promedio de todas las calificaciones.

def calcular_promedio(calificaciones):
    total=sum(calificaciones.values())
    return round(total/len(calificaciones),2)

def calcular_promedio2(calificaciones):
    total=0
    for calificacion in calificaciones.values():
        total+=calificacion
    return round(total/len(calificaciones),2)

print(calcular_promedio2({'Juan': 90, 'Ana': 85, 'Pedro': 88}))

diccionario={}
def calcular_algo(): # No es una función pura y suspendes el examen
    diccionario['algo']=42 # No debemos acceder a información fuera de la función
    return diccionario

print(calcular_algo())

# bucle infinito: explota
# Que una función se llame a ella misma se llama recursividad
def error_gordo(numero):
    return 3#error_gordo(numero)

def factorial(numero):
    if numero<=1:
        return 1
    else:
        return factorial(numero-1)*numero
print(error_gordo(4))
print(factorial(5))

import random

nombres_alumnos = [
    "Juan", "María", "Pedro", "Ana", "Carlos",
    "Luisa", "José", "Elena", "Miguel", "Sofía",
    "Laura", "Diego", "Isabel", "Antonio", "Carmen",
    "Manuel", "Rosa", "Francisco", "Eva", "Javier"
]

clases = ["Clase A", "Clase B", "Clase C"]


diccionario_alumnos = {}

for alumno in nombres_alumnos:
    clase_asignada = random.choice(clases)

    if clase_asignada not in diccionario_alumnos:
        diccionario_alumnos[clase_asignada] = []

    diccionario_alumnos[clase_asignada].append(alumno)

print(diccionario_alumnos)
alumnos={}
for clase in diccionario_alumnos:
    for alumno in diccionario_alumnos[clase]:
        alumnos[alumno]=clase
print(alumnos)

# Crea un diccionario que almacene nombres de frutas como
# claves y sus precios como valores. Luego, escribe un programa que
# calcule el costo total de comprar una cantidad específica de cada fruta.

precios={"pera":3,"melón":4,"uva":7,"manzana":2}

def calcula_precio(precios,fruta,cantidad):
    precio=precios.get(fruta,0)
    return cantidad*precio

def cesta(precios,cesta):
    total=0
    for elemento,cantidad in cesta.items():
        total+=calcula_precio(precios,elemento,cantidad)
    return total

print(calcula_precio(precios,"melocotón",5))

micesta={"uva":3,"pera":2,"melón":1}
print(cesta(precios,micesta))

# Escribe un programa que tome una lista de palabras y cuente cuántas
# veces aparece cada palabra en la lista. Almacena los resultados en
# un diccionario donde las palabras son las claves y el recuento de
# apariciones es el valor.

def cuenta_palabras(lista):
    res={}
    for palabra in lista:
        if palabra in res:
            res[palabra]+=1
        else:
            res[palabra]=1
    return res

lista="hola que tal que pasa hola tal dia que fui".split(" ")
print(lista)
print(cuenta_palabras(lista))

alumnos=["Ana","juan","pep"]
notas=[1,2,3]
clase=dict(zip(alumnos,notas))
print(clase)

# dos listas relacionadas pero porque lo sabemos nosotros
alumnos=["Ana","Juan","Eva"]
notas=[5,7,10]
# recorro las dos listas propenso a errores
for i in range(len(alumnos)):
    print(alumnos[i],notas[i])

# Esto es un diccionario donde la información SI está relacionada
clase={"Ana":5,"Juan":7,"Eva":9}

# Recorriendo el diccionario a través de las claves
for alumno in clase:
    print(alumno,clase[alumno])

# recorriendo el diccionario a través de los items
# que son la clave y el valor
for alumno,nota in clase.items():
    print(alumno,nota)


for notas in clase.values():
    print(notas)

print(len(clase)) # longitud del diccionario

print(clase.keys())
print(clase.values())
print(clase.items())


# dos listas relacionadas pero porque lo sabemos nosotros
alumnos=["Ana","Juan","Eva"]
notas=[5,7,10]
# recorro las dos listas propenso a errores
for i in range(len(alumnos)):
    print(alumnos[i],notas[i])

# Esto es un diccionario donde la información SI está relacionada
clase={"Ana":5,"Juan":7,"Eva":{"ingles":8,"matematicas":6,"catalán":9}}

# Recorriendo el diccionario a través de las claves
for alumno in clase:
    print(alumno,clase[alumno])

# recorriendo el diccionario a través de los items
# que son la clave y el valor
for alumno,nota in clase.items():
    print(alumno,nota)

for notas in clase.values():
    print(notas)

print(len(clase)) # longitud del diccionario

print(clase.keys())
print(clase.values())
print(clase.items())

personas = [
    {"nombre": "Juan", "edad": 30,"notas":[3,5,6,7,(8,9),{"extra":8,"comun":8}]},
    {"nombre": "María", "edad": 25},
    {"nombre": "Pedro", "edad": 35}
]

# Crear una lista con los números que se pidan al usuario y que cuando
# introduzca un 0 se acabe de pedir e imprima la lista

lista=[]

numero=int(input("Dame un numero (0 para salir) "))
while numero!=0:
    lista.append(numero)
    numero = int(input("Dame un numero (0 para salir) "))
print(lista)

lista2=[]
while True:
    numero = int(input("Dame un numero (0 para salir) "))
    if numero==0:
        break
    lista2.append(numero)
print(lista2)

# Crear una función primos a la que le pasamos una lista de
# números y nos devuelva la cantidad de números primos que hay
# (usando la función primos que ya vimos en otro ejercicio)

def esprimo(numero):
    esprimo = True
    for i in range(2, numero):
        if numero % i == 0:  # que sí que es divisible y por lo tanto NO ES PriMO
            esprimo = False
            break
    return esprimo

def cuentaPrimos(lista):
    total=0
    for numero in lista:
        if esprimo(numero):
            total+=1
    return total

print(cuentaPrimos([3,5,9]))

# recorrer la lista de cadenas (ok)
# obtener la primera letra de una cadena cadena[0]
# obtengo la letra de la primera cadena y miro si todos empiezan por lo mismo

def inicioIgual(cadenas):
    primera=cadenas[0]
    letra=primera[0]
    res=True
    for cadena in cadenas:
        if cadena[0]!=letra:
            res= False
            break
    return res

print(inicioIgual(["pepe","pque","ptal"]))

# Crear una función eliminaMultiplos a la que le pasamos una lista
# de números y un número y nos devuelva la lista que nos han pasado
# sin los números que sean múltiplos

# recorrer la lista (ok)
# saber si un numero es multiplo de otro (ok)
# si el numero NO es multiplo lo añado

def eliminaMultiplos(lista, numero):
    resultado=[]
    for elemento in lista:
        if elemento%numero!=0:
            resultado.append(elemento)
    return resultado

# CÓDIGO ninja
def eliminaMultiplos2(lista, numero):
    return [num for num in lista if num%numero!=0]


print(eliminaMultiplos2((1,2,3,4,5,6,7,8,9),3))

#Crear una tupla con tus cuatro colores favoritos e imprimirla por la consola

# Crear una tupla con otros dos colores y crear otra tupla más con la suma de las dos

favoritos=("rojo","verde","rosa palo","gris")


otros=("amarillo","blanco")

print(favoritos)

for color in favoritos:
    print(color)

suma=favoritos+otros

print(suma)

# Crear una función hayverde a la que le pasamos una tupla y nos
# devuelve true si en esa tupla está el color verde y false en caso contrario

def hayverde(colores):
    res=False
    for color in colores:
        if color=="verde":
            res= True
    return res

def hayverde2(colores):
    return colores.count("verde")>0

def hayverde3(colores):
    return "verde" in colores
# Todos True
print(1 in (1,2,3))
print("h" in "hola")
print(hayverde3(favoritos))

# Crear una función sumatupla a la que le pasamos
# una tupla de números y nos devuelve la suma

def sumatupla(numeros):
    total=0
    for numero in numeros:
        total+=numero
    return total

def sumatupla2(numeros):
    return sum(numeros) # max y min

print(sumatupla2((1,2,30)))
mitupla=(8,9,10)
print(sumatupla2(mitupla))

alumnos=("Ana","Pep","Eva","Pepon")
print(max(alumnos))

# Crear una función cadena_larga a la que le pasamos una tupla de cadenas y
# nos devuelva la cadena mas larga, si hay varias cadenas con
# la misma longitud podemos devolver la que prefiramos.

def cadena_larga(cadenas):
    larga=cadenas[0] # Siempre inicializo con un miembro del iterable
    for cadena in cadenas:
        if len(cadena)>len(larga):
            larga=cadena
    return larga

def min(numeros):
    minimo=numeros[0]
    for numero in numeros:
        if numero<minimo:
            minimo=numero
    return minimo

print(min((1,5,6)))
alumnos=("Ana","Eva","juan","Herminia","Pep")
print(cadena_larga(alumnos))

def cadena_larga2(cadenas):
    return max(cadenas, key=len) # En vez de usar el orden alfabético usamos la longitud

# Crear una funcion cadenaMinMax a la que le pasamos una tupla de cadenas
# y nos devuelve una tupla con la cadena más corta y la más larga

def cadenaMinMax(cadenas):
    larga=cadenas[0]
    corta=cadenas[0]
    for cadena in cadenas:
        if len(cadena)>len(larga):
            larga=cadena
        if len(cadena)<len(corta):
            corta=cadena
    return (corta,larga)

def cadenaMinMax2(cadenas):
    return (min(cadenas,key=len),max(cadenas,key=len))

print(cadenaMinMax2(("a","bbbbbb","cc")))

corta,larga=cadenaMinMax(("a","bbbbbb","cc"))

print(corta)

# tupla: conjunto de valores: int, float,str, boolean
# Se crea poniendolos entre paréntesis
tupla=(1,2,3,"nombre",False,(1,2,3),"pepe@pepe.com")
otratupla=("w",1,"ppp",3)
for valor in tupla: #valor es una variable temporal
    print(valor)
print("|||",valor)
for valor in otratupla: #valor es una variable temporal
    print(valor)

print(tupla[3])
print(len(tupla))
for i in range(len(tupla)):
    print(tupla[i])
for i in range(2,5):
    print(tupla[i])
for valor in tupla[::-1]:
    print(valor)
print(tupla[2:5])

suma=tupla+otratupla
print(suma)
print(otratupla*3)

print(tupla.count(1))
print(tupla.count(9))
print(tupla.index(1))

tupla=tupla+(1,5)
print(tupla)
# SON INMUTABLES

# Desempaquetar
valores=(1,2,3)
a,b,c=valores
print(a,b,c)

def mayor_y_menor(valores):
    mayor=valores[0]
    menor=valores[0]
    for valor in valores:
        if mayor<valor:
            mayor=valor
        if menor>valor:
            menor=valor

    return (menor,mayor)

tupla_resultado=mayor_y_menor((3,1,9,5,6))

print(tupla_resultado)
menor,mayor=tupla_resultado

def partes_correo(correo):
    parte1=list(correo.split("@"))
    parte2=list(parte1[1].split("."))
    return (parte1[0],parte2[0],parte2[1])

partes=partes_correo("ana@gmail.com")
print(partes)
nombre,servidor,extension=partes

if servidor=="gmail":
    print(nombre, "tienes un buen servidor de correo")
else:
    print("Cuidado ",nombre," hazte una cuenta en gmail")

numero=input("Introduce el número: ")

# abrir el archivo: w (escribir) r (leer) a (añadir)
archivo=open("tabla_del_"+numero+".txt","w")

# proceso la información leyéndola archivo.write
# o escribo información archivo.read
numero=int(numero)
for i in range(1,11):
    archivo.write(f"{i} x {numero} = {i*numero}\n")

# cerrarlo

archivo.close()

# abro el archivo
archivo=open("curso.txt","r")

datos=archivo.read()
total=0
lista=list(datos.split(","))
print(lista)
for valor in lista:
    total+=int(valor)
print(total)
# cierro el archivo
archivo.close()