Autor: Juan Pablo Fuentes

# funcion pivote de una lista de números nos divide la lista en 2 partes
# primero los menores del número que pasemos y por otra los mayores
# pivote([4,1,9,5,3,7],6)->([4,1,5,3],[9,7])

def pivote(lista,numero):
    menores=[]
    mayores=[]
    for i in lista:
        if i<numero:
            menores.append(i)
        else:
            mayores.append(i)
    return(menores,mayores)

print(pivote([4,1,9,5,3,7],5))

# definir la función con los parámetros def pivote(lista,numero)
# saber que tengo que devolver ¿un número? p. ej. un total, una cuenta, un promedio..
# ¿Una lista? los que cumplen una condicion, un filtro
# ¿Una tupla con diferentes valores? (menores,mayores)
# son una lista pues lo tengo que definir.
# Cualquier cosa que vaya a devolver la tengo definir: total, res, menores, mayores...
# recorrer la lista de numeros, de palabras, de lo que sea
# Con cada uno de los elementos de la lista tenemos que hacer algo
# sumarlo, contarlo, añadirlo, transformarlo
# Si cumple alguna condicion: es par, si es mayor si es algo...

# sacar todos lo anagramas de una palabra
# mar->amr arm mar mra ram rma

# vamos a crear una función a la que pasamos una lista de números y nos diga cuantos
# pares hay contarPares([1,2,3,4])->2

def contarPares(lista):
    cont=0
    for numero in lista:
        # que condicion es relevante aquí: numero sea par
        if numero%2==0:
            cont+=1

    return cont

print(contarPares([1,5,7,9]))

# Una función palabras con a a la que le pasamos una cadena y nos devuelve
# la lista de palabras que tienen una a
# palabrasConA('hola que tal')->['hola','tal']

def palabrasConA(cadena):
    res=[]
    for palabra in cadena.split():
        # si la palabra tiene una a la añado a res
        if 'a' in palabra:
            res+=[palabra]
    return res

print(palabrasConA('hola que tal'))

def palabrasconA2(cadena):
    res=[]
    for palabra in cadena.split():
        for i in palabra:
            if i == "a":
                res.append(palabra)
                break
    return res
print(palabrasconA2("hola que tal mejor mañana"))

# Vamos a hacer una función que calcule el PVP de un producto
# le pasamos el precio, el tipo y si está en oferta o no
# Tenemos que devolver:
# Si el tipo es reducido el iva es  un 10% en cualquier otro caso es un 21%
# Si está en oferta hacemos un descuento del 5%

def PvP(precio,tipo,oferta=False): # precio de un producto es el precio mas el iva menos el descuento
    if tipo=='reducido':
        iva=precio*0.1
    else:
        iva=precio*.21
    if oferta:
        descuento=precio*.05
    else:
        descuento=0
    return precio+iva-descuento


print(PvP(100,'normal',True))
print(PvP(100,'normal'))

# vamos a hacer una función a la que le pasamos un tipo de bono
# un tipo de cliente y una cantidad y nos calcule el precio de acuerdo a lo siguiente
# bono=vip precio=3000
# bono=extra precio=2000
# bono=normal precio=1000
# tipo cliente= standard, el precio no cambia
# tipo cliente=premium, el precio es la mitad

def precioBono(cantidad,bono,cliente): # precio por cantidad
    if bono=='vip':
        precio=3000
    elif bono=='extra':
        precio=2000
    else:
        precio=1000

    if cliente=='premium':
        precio/=2
    return precio*cantidad

# por defecto el bono sea normal y el cliente tambien
# los parámetros por defecto siempre al final
def precioBono2(cantidad,bono='normal',cliente='normal'): # precio por cantidad
    if cliente=='premium':
        coeficiente=.5
    else:
        coeficiente=1
    if bono=='vip':
        precio=3000
    elif bono=='extra':
        precio=2000
    else:
        precio=1000
    return precio*cantidad*coeficiente

print(precioBono2(1))

# esta función, en teoría, cuenta el número de pares que hay en la lista
# ¿Funciona? Si es que no por qué y como arreglarlo
def contarPares(lista):
    total=0
    for i in lista:
        if total%2==0:
            total+=i
    return total

lista=[2,3,4,5,6]
print(contarPares(lista)) #debería imprimir 2

# esta funcion nos debería devolver las palabras más largas de un numero

def palabrasLargas(cadena, numero):
    res=[]
    for palabra in cadena:
        if len(palabra)>=numero:
            res+=[palabra]
    return res

cadena="Hola mi amigo piensa un poco"
print(palabrasLargas(cadena,5)) # ['amigo','piensa']


def separarParidad(lista):
    pares=[]
    impares=[]
    for numero in lista:
        if numero%2==0:
            impares.append(numero)
        else:
            pares.append(numero)
    return (pares, impares)

print(separarParidad([1,2,3,4,5])) # ([2,4],[1,3,5])

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

El test:

from unittest import TestCase

from acceso import acceso


class Test(TestCase):
    def test_acceso(self):
        test = acceso('gerencia', 'jefe de proyecto')
        self.assertTrue(test)
        test = acceso('gerencia', 'becario')
        self.assertTrue(test)
        test = acceso('administracion', 'becario')
        self.assertFalse(test)
        test = acceso('administracion', 'mando intermedio')
        self.assertTrue(test)
        test = acceso('administracion', 'jefe de proyecto')
        self.assertFalse(test)

def cuadrado(lado=1):
    return lado**2

def rectangulo(lado1,lado2):
    return lado1*lado2

El test:

from unittest import TestCase

import areas


class Test(TestCase):
    def test_cuadrado(self):
        resultado = areas.cuadrado(1)
        self.assertEqual(resultado, 1)
        resultado = areas.cuadrado(3)
        self.assertEqual(resultado, 9)
        resultado = areas.cuadrado(10)
        self.assertEqual(resultado, 100)
    def test_rectangulo(self):
        resultado=areas.rectangulo(2,3)
        self.assertEqual(resultado,6)
        resultado = areas.rectangulo(0, 3)
        self.assertEqual(resultado, 0)
        resultado = areas.rectangulo(20, 3)
        self.assertEqual(resultado, 60)

try:
    num = input("Ingrese un número: ")
    print(num)
    num=int(num)
    print(num)
    resultado = 10 / num
    print(resultado)
except Exception as e:
    print(f"Ocurrió una excepción no manejada: {e}")
else:
    print("esto se imprime si va bien")
# cualquier código lo podemos 'envolver' dentro de un
# try:
#...
# except Exception as e:
# Y si sucede un error salta a except

# sintaxis del C
# java, c++, c#, php, js...
# try catch if (){...}
# python NO TIENE la sintaxis del C

# PENSAR -> ¿Cómo lo haría yo? ¿Cómo le explico al ordenador como lo haría yo?
# divide y vencerás: Todo problema está hecho de problemas más pequeños
# PRACTICAR y practicar y practicar MAS QUE LEER
import datetime


# Crear una función cuanto_falta que nos devuelva los dias que faltan para el fin de
# semana. Si ya es fin de semana devolvemos 0 (es mucho más fácil de lo que parece)

# cuanto_falta(fecha) -> dias hasta el siguiente fin de semana

# saber el día de la semana weekday (0-lunes y 6 domingo)
# 0 lunes faltan 5  0+5=5
# 1 martes faltan 4 1+4=5
#... 4 viernes falta 1 4+1=5 5-weekday
# 5 sabado faltan 0
# 6 domingo 0


def cuanto_falta(fecha):
    dia_semana=fecha.weekday()
    if dia_semana>=5: # in [5,6]
        return 0
    else:
        return 5-dia_semana

print(cuanto_falta(datetime.date(2023,10,16)))

# Crear una función primero_de_mes a la que le pasemos un año y nos devuelva una lista
# de fechas del 1 de cada mes de ese año:
#
# primero_de_mes(2024) -> ['2024-01-01'.'2024-02-01',...'2024-12-01']

# ¿Cómo creo yo una fecha a partir de numeros?
# datetime.date(año,mes,dia) año->check me lo pasan dia->check siempre es 1
# ¿mes? del 1 al 12 ¿Se hacer un bucle del 1 al 12? for i in range(1,13)
# crear una lista lista vacia: []
# añado a la lista: append
# ¿Cuantas fechas tengo que crear? 12 una por cada mes

def primero_de_mes(anyo):
    res=[]
    for i in range(1,13):
        res.append(datetime.date(anyo,i,1))
    return res

print(primero_de_mes(2023))

# Crear una funcion fines_de_semana a la que le pasemos un año y un mes y nos devuelva
# una lista con todos los fines de semana:
#
# fines_de_semana(10,2023) -> ['2023-10-01','2023-10-07','2023-10-08',...,'2023-10-29']

# me recorro todos los dias de ese mes y si es fin de semana lo añado a la lista
# empiezo por el 1 del mes de ese año, voy sumando un día en un bucle y si el dia es fin
# de semana lo añado a la lista
# crear una fecha a partir de año mes y dia
# sumar un dia a una fecha? + timedelta(days=1)
# se si es fin de semana? si el weekday es 5 o 6
# febrero tego que ir del 1 al 28 ¿Cómo lo se yo?
# lista con los dias del mes [31,28,31,30,31,30,31,31,30,31,30,31]
# el bucle lo hago añadiendo un día, 2023-2-27, 2023-2-28,2023-3-1
# 2023-10-29,2023-10-30,2023-10-31,2023-11-1
# mientras el mes de mi fecha sea el mes que me han pasado sigo en el bucle
# en cuanto sea diferente paro

def fines_de_semana(mes,anyo):
    fecha=datetime.date(anyo,mes,1)
    res=[]
    while fecha.month==mes:
        if fecha.weekday() in [5,6]:
            res.append(fecha)
        fecha+=datetime.timedelta(days=1)
    return res

print(fines_de_semana(10,2023))

import datetime
import math
# Crear un objeto datetime para la fecha y hora actual
ahora = datetime.datetime.now()
print(ahora)  # Resultado: Fecha y hora actual en formato 'YYYY-MM-DD HH:MM:SS'

# Obtener la fecha actual
fecha_actual = datetime.date.today()
print("Fecha actual:", fecha_actual)

fecha_formateada = fecha_actual.strftime("%d - %m - %Y")
print("Fecha formateada:", fecha_formateada)

print(fecha_actual.day)

print(ahora.minute)
print(ahora.second)

# Crear una fecha específica
fecha_personalizada = datetime.date(2023, 10, 3)
print("Fecha personalizada:", fecha_personalizada)

# Crear una fecha y hora específicas
fecha_hora_personalizada = datetime.datetime(2023, 10, 3, 14, 30,10,9)
print("Fecha y hora personalizada:", fecha_hora_personalizada)

anyo_que_viene=datetime.datetime(2024,10,10)

print(anyo_que_viene.weekday())

# Crear una fecha a partir de una cadena de texto formateada
fecha_desde_cadena = datetime.datetime.strptime("03/10/2023", "%d/%m/%Y")
print("Fecha desde cadena:", fecha_desde_cadena)

mifecha="10/10/2023" # ¿Es una fecha? No: es una cadena

mifecha_a_fecha=datetime.datetime.strptime(mifecha,"%d/%m/%Y")
print(mifecha_a_fecha) # ¿Es una fecha?

otrafecha=datetime.date(2023,10,10) # ¿Es una fecha?

resta=anyo_que_viene-mifecha_a_fecha
print(resta.days)
print(resta.seconds)

hoy=datetime.date.today()
manyana=hoy+datetime.timedelta(days=1)
semana_que_viene=hoy+datetime.timedelta(days=7)

print(manyana)
print(semana_que_viene)

print("Día de la semana:", fecha_actual.weekday())  # 0 es el lunes el 6 domingo

# Ejemplos

def antiguedad_empleado2(fecha_contrato):
    fecha_actual=datetime.date.today()
    anyos=fecha_actual.year-fecha_contrato.year
    meses=fecha_actual.month-fecha_contrato.month
    if (meses<0):
        meses+=12
        anyos-=1
    dias=fecha_actual.day-fecha_contrato.day
    if dias<0:
        meses-=1
        dias+=30
    return (dias,meses,anyos)

def antiguedad_empleado(fecha_contrato):
    fecha_actual=datetime.date.today()
    resta=fecha_actual-fecha_contrato
    print(resta.days)
    anyos=math.floor(resta.days/365)
    print(anyos)
    meses=math.floor((resta.days-anyos*365)/30)
    print(meses)
    dias=resta.days-anyos*365-meses*30
    return (dias,meses,anyos)

print(antiguedad_empleado2(datetime.date(2015,12,21)))

# es fin de semana?

def es_fin_de_semana(fecha):
   """ if fecha.weekday()<5:
        return False
    else:
        return True
        """
   return not fecha.weekday()<5 # No es codigo ninja, es supercomún

def siguiente_dia_laborable(fecha):
    fecha+=datetime.timedelta(days=1)
    while es_fin_de_semana(fecha):
        fecha += datetime.timedelta(days=1)
    return fecha


print(siguiente_dia_laborable(datetime.date.today()))
print(siguiente_dia_laborable(datetime.date(2023,10,14)))

# estructuras de datos
# una variable nos permite almacenar un valor
# muchos valores no es comodo usar muchas variables
# Estructuras que nos permiten almacenar un numero arbitrario de valores

# tuplas: se definen con paréntesis, no se pueden modificar
tupla=(1,2,3)
otra_tupla=(1,"hola",7.8,False)

a,b,c=tupla #desempaquetado de tupla a=1, b=2 y c=3

def estadistica(*args):
    total=0
    for numero in args:
        total+=numero
    return (total,total/len(args))

print(estadistica(1,2,3))

# listas: colección de elementos que se puede modificar
# es el equivalente al array de otros lenguajes
lista=[1,2,3,4]
otra_lista=[1,"hola",7.0,True]

lista[1]=90
print(lista)
for i in range(len(lista)):
    print(lista[i])
    lista[i]*=2

for numero in lista:
    print(numero)
    numero=numero*2
print(lista)

# Comprension de listas
# [nuevo_elemento for elemento in secuencia if condición]
lista1=[elemento for elemento in lista]
print(lista1)
lista2=[elemento for elemento in lista if elemento<20]
print(lista2)
lista3=[elemento/2 for elemento in lista if elemento<20]
print(lista3)
lista4=[]
for elemento in lista:
    if elemento<20:
        lista4.append(elemento/2)
print(lista4)

# diccionarios: conjunto de pares clave, valor
diccionario={"Nombre":"Ana","nota":7,"email":"ana@ana.com"}
print(diccionario)
otro_diccionario={1:"Ana",3:7,9:"ana@ana.com"}
print(otro_diccionario)
print(diccionario["Nombre"])
print(otro_diccionario[1])
diccionario["Nombre"]="Ana Pi"
print(diccionario)
for elemento in diccionario:
    print(elemento)
for elemento in diccionario.values():
    print(elemento)
for elemento in diccionario.items():
    print(elemento)

# conjunto es lo mismo pero no podemos tener valores repetidos
conjunto={1,2,3,5,5,5,5,5}
print(conjunto)

# tener estructuras complejas: estructuras dentro de estructuras

tupla_rara=(1,"cadena",
            ["a","b","c",
             {"nombre":"Ana",
              "notas":(6,9,1,
                       {"nota":9,"observaciones":"Progresa adecuadamente"})}])
valor=tupla_rara[2][3]["notas"][3]["observaciones"]
print(valor)

clase=[{"nombre":"Ana","notas":[1,2,3]},
       {"nombre":"Pep","notas":[11,2,3]},
       {"nombre":"Eva","notas":[1,22,3]}]

for alumno in clase: # con esto recorro los alumnos
    print(alumno)
    print("Para el alumno "+alumno["nombre"]) # ya tengo un alumno individual
    total=0
    for nota in alumno["notas"]: # recorro sus notas
        print(nota) # ya tengo la nota individual
        total+=nota
    print ("La media es "+str(total/len(alumno["notas"])))

# 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())