Trifulcas

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

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