Categoría: Python

# funciones: una manera de coseguir varias cosas:
# 1) Reaprovechar código
# Pongo un código dentro de una etiqueta a la que puedo llamar cuando me haga falta
# 2) Organizar el código
# Cada cosa está en su sitio
# 3) Gano en flexibilidad porque las funciones se pueden llamar unas a otras
# Mi código puede ser mejor y  más genérico
# 4) Gano en legibilidad
# Es más fácil leer el código si utilizo funciones
# i%2==0 vs esPar(i)
"""
def nombre_de_la_funcion(parametros si hace falta):
    hago cosas
    return algo # si hace falta

"""

def saludo():
    print("hola")

saludo()

def otro_saludo(nombre="Misteriosa persona"):
    print("hola "+nombre)
    print(f"hola {nombre}")

otro_saludo("Ana")
otro_saludo("Pepe")
otro_saludo()

def sumar(*args):
    total=0
    for i in args:
        total+=i
    # print(total) ##MAL
    return total

print(sumar(1,6,7,3))

# Funciones PURAS
# Una función que solamente depende de los parámetros, es independiente del programa
# recoge parámetros calcula algo y devuelve el resultado
# es una caja negra.


import random

def moneda():
    opciones=["cara","cruz"]
    return random.choice(opciones)

print(moneda())

# variables
entero=9
decimal=9.6
cadena="hola que tal"
booleano=True

# estructura de control if
# nos permite controlar el flujo del programa si se cumplen condiciones
"""
if condicion_es_cierta:
    hago_esto
else:
    hago_esto_otro
"""
edad=20
if edad>=18:
    print("Puedes comprar alcohol")
else:
    print("No puedes comprar")

# las condiciones pueden ser muy complicadas
pais='España'
# Los paréntesis EN ESTE CASO no hacen falta
if (pais=='España' and edad>=18) or (pais=='EEUU' and edad>=21) or (edad>40) and (pais!='arabia saudi'):
    print("Puedes comprar alcohol")
else:
    print("No puedes comprar")

# Bucles: while y for
"""
Cuando no sabemos cuando se va a cumplir la condición
while condicion:
    hago algo
OJO: que dentro del bucle se cambie la condición
"""

cont=0
while cont<10:
    print(cont)
    cont+=1 # modifiquemos la condicion

# empezar por 1 y luego duplicar hasta llegar a 1000000

cont=1
while cont<1000000:
    print(cont)
    cont*=2

numero=1
while numero!=0:
    numero=int(input("Dame un numero (0 para salir"))

# bucle for: cuando si sabemos la longitud de lo que queremos recorrer

for i in range(1,11):
    print(i)

# Hace algo 10 veces va del 0 al 9
for i in range(10):
    print(i)

# recorre cualquier iterable: tuplas diccionarios conjuntos listas

lista=[1,4,2,6,3,9]
for numero in lista:
    print(numero)

# Crear una función que nos calcule el área de un círculo si le pasamos el radio (PI*radio*radio).
# Usad el módulo math parra coger el valor de PI

import math

def area_circulo(radio):
    area=math.pi*radio**2
    return round(area,2)

print(area_circulo(1))

# Crear una función acceso a la que le pasamos como parámetros
# el departamento y la categoría, nos devuelve true si

def acceso(departamento,categoria):
    res=False
    if departamento=='gerencia':
        res=True
    if departamento=='administracion' and categoria=='mando intermedio':
        res=True
    if departamento=='marketing' and categoria=='mando intermedio' or categoria=='jefe de proyecto':
        res=True
    return res
def acceso2(departamento,categoria):
    res=False
    if (departamento=='gerencia'
        or (departamento=='administracion' and categoria=='mando intermedio')
        or (departamento=='marketing' and (categoria=='mando intermedio' or categoria=='jefe de proyecto'))):
        res=True
    return res

# probar todos los casos relevantes
print(acceso('administracion','jefe de proyecto'))

# Crear una función palabras_largas a la que le pasemos una cadena y nos devuelva una lista de
# las palabras cuya longitud sea mayor de 6

def palabras_largas(cadena,longitud=6):
    palabras=cadena.split(" ")
    res=[] # [palabra for palabra in palabras if len(palabra)>6]
    for palabra in palabras:
        if len(palabra)>longitud:
            res.append(palabra)
    return res

print(palabras_largas("hola federico que comiste ayer",3))

# conocer lenguaje
# antes que eso: saber programar
# ante un problema analizar los pasos que daremos pare resolverlo
# el plan, la receta, el algoritmo
# palabras tengo una cadena y quiero las palabras cuya longitud sea myor de 6
# obtener las palabras
# ¿Si tengo una cadena, se obtener la lista de palabras?
# si con split(' ') falla si hay signos de puntuación--> para la versión 2.0
# recorriendo las palabras
# for palabra in palabras
# contando las letras
# len()
# si son más de seis las apunto
# condicion len()>6 necesito un if
# añadir append

def cadena_mas_larga(cadena):
    palabras=cadena.split(' ')
    res=[]
    for palabra in palabras:
        if len(palabra)>6:
            res.append(palabra)
    return res
print(cadena_mas_larga("hola federico que comisteis ayer"))

# Crear una funcion moneda() que devuelva aleatoriamente 'cara' o 'cruz'

# moneda()->'cara'

import random

def moneda2():
    if random.randint(0,1)==0:
        return "cara"
    else:
        return "cruz"

def moneda3():
    # operador ternario
    return "cara" if random.randint(0,1)==0 else "cruz"
def moneda():
    opciones=["cara","cruz"]
    return random.choice(opciones)

print(moneda())

# Crear una función lanzamientos(numero) que nos devuelva una lista de 'caras' y 'cruces' de longitud numero
#
# lanzamientos(3)->['cara','cara','cruz']

def lanzamientos2(numero):
    resultado=[]
    for i in range(numero):
        resultado.append(moneda())
    return resultado

def lanzamientos(numero):
    # utilizar de manera 'ninja' la compresión de listas
    return [moneda() for i in range(numero)]

print(lanzamientos(6))

# Crear una función rascaygana() que nos devuelva un premio de la siguiente manera:
#
# obtenemos un número entre 1 y 20
#
# si el número está entre 1 y 12 no hay premio
#
# si está entre 13 y 18 un euro de premio
#
# Si está entre 19 y 20 dos euros

def rascaygana2():
    numero=random.randint(1,20)
    if numero<=12:
        return 0
    elif numero<=18:
        return 1
    elif numero<=20:
        return 2
def rascaygana():
    # premios=[0,0,0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,2,2]
    premios=[0]*12+[1]*6+[2]*2
    return random.choice(premios)

print(rascaygana())

print([0]*12+[1]*6+[2]*2)

# obtener un número aleatorio
import random

numero_aleatorio=random.random() # entre 0 y 1 sin llegar nunca al 1
print(numero_aleatorio)
print(round(numero_aleatorio*10)+1)
print(random.randint(1,10))

colores = ["rojo", "verde", "azul", "amarillo"]
color_aleatorio = random.choice(colores)
print(color_aleatorio)  # Por ejemplo, "verde"

lista=[1,2,3,4,5,6,7,8,9]
random.shuffle(lista)
print(lista)

imagenes=['gatito.jpg','peces.jpg','paisaje.png']
print(random.choice(imagenes))

numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
numeros_aleatorios = random.sample(numeros, 3)  # Selecciona 3 números únicos al azar.
print(numeros_aleatorios)


def dado():
    return random.randint(1,6)


print(dado())

def carta():
    valores=[1,2,3,4,5,6,7,10,11,12]
    palos=["oros","copas","espadas","bastos"]
    return str(random.choice(valores))+" de "+random.choice(palos)

print(carta())


def baraja():
    valores = [1, 2, 3, 4, 5, 6, 7, 10, 11, 12]
    palos = ["oros", "copas", "espadas", "bastos"]
    baraja=[]
    for valor in valores:
        for palo in palos:
            baraja.append(str(valor)+" de "+palo)
    random.shuffle(baraja)
    return baraja

print(baraja())

# Crear una función a la que le pasemos una lista de números y nos devuelva
# una tupla con la suma de los números pares y de los impares:

# sumaparidad([1,2,3,4])->(6,4)

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

def sumaparidad2(lista):
    pares=[numero for numero in lista if numero%2==0]
    impares=[numero for numero in lista if numero%2!=0]
    return (sum(pares),sum(impares))
def sumaparidad3(lista):
    return (sum([numero for numero in lista if numero%2==0]),sum([numero for numero in lista if numero%2!=0]))

print(sumaparidad3([1,2,3,4]))

milista=[1,1,1,1,1,2,2,2,2,2]
print(sumaparidad3(milista))

# Crear una función a la que le pasamos un diccionario con una lista
# de clientes y sus deudas y nos devuelva el total de deudas.
# La lista sería así:
#
clientes={"Ana":[100,500,3000],"Eva":[900,300,200]}
#
# totaldeuda(clientes)->5000

def totaldeuda(clientes):
    total=0
    for deudas in clientes.values():
        total+=sum(deudas)
    return total

def totaldeuda2(clientes):
    return sum(sum(clientes.values(),[]))

print(totaldeuda2(clientes))

# sum(clientes.values(),[]) concatena diferentes listas en una lista
print(clientes.values())
print(sum(clientes.values(),[]))

lista1=[[1,2,3],[3,4,5],[7,8,9]]
lista4=sum(lista1,[])
print(lista4)

 # Crea una función a la que le pasamos una lista de diccionarios
 # que son alumnos con el siguiente formato:
 #
clase=[{"nombre":"Ana","notas":[5,7,8]},{"nombre":"Pep","notas":[8,6,8]}]
 #
 # Y que nos devuelva la media total de las notas
 #
 # media_total(clase)->7

def media_total0(clase):
    total_notas=0
    numero_notas=0
    for alumno in clase:
        for nota in alumno["notas"]:
            total_notas+=nota
            numero_notas+=1
    return round(total_notas/numero_notas,2)

def media_total(clase):
    total_notas=[]
    for alumno in clase:
        total_notas+=alumno["notas"]
    return round(sum(total_notas)/len(total_notas),2)

def media_total_ninja(clase):
    # Anidación de compresión de listas
    total_notas=[nota for alumno in clase for nota in alumno["notas"]]
    return round(sum(total_notas) / len(total_notas), 2)

print(media_total_ninja(clase))

# 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}
]