Fundamentos de Programación y Python

1

¿Por qué aprender Python?

2

Introducción a Python

3

Conceptos Básicos de Programación

4

Práctica: Te doy la bienvenida a los ejercicios interactivos

5

Manipulación de Cadenas de Texto en Python

6

Enteros, Flotantes y Booleanos

7

Todo lo que Debes Saber sobre print en Python

8

Operaciones Matemáticas en Python

9

Operaciones de Entrada/Salida en Consola

Colección y Procesamiento de Datos en Python

10

Listas

11

Método slice

12

Listas de más dimensiones y Tuplas

13

Aplicación de Matrices

14

Diccionarios

15

Comprehension Lists en Python (CLASE NUEVA)

Control de Flujo en Python

16

Estructuras condicionales

17

Bucles y Control de Iteraciones

18

Generadores e Iteradores

Funciones y Manejo de Excepciones en Python

19

Uso de Funciones en Python

20

Funciones Lambda y Programación Funcional en Python

21

¿Cómo realizar una función recursiva en Python?

22

Manejo de Excepciones y Uso de Pass (CLASE NUEVA)

Programación Orientada a Objetos en Python

23

Fundamentos de Programación Orientada a Objetos en Python

24

Ejercicio Biblioteca con POO

25

Herencia en POO con Python

26

Objetos heredados

27

Los 4 pilares de la programacion orientada a objetos

28

Uso de super() en Python (CLASE NUEVA)

29

Superando los Fundamentos de Programación Orientada a Objetos en Python

Lectura y escritura de archivos

30

Manejo de Archivos .TXT (CLASE NUEVA)

31

Manejo de Archivos CSV (CLASE NUEVA)

32

Manejo de Archivos JSON (CLASE NUEVA)

Biblioteca estándar de Python

33

Biblioteca estándar en Python (CLASE NUEVA)

34

Librería Os, Math y Random (CLASE NUEVA)

35

Librería Statistics y Análisis Estadístico (CLASE NUEVA)

36

Proyecto final: Guerra naval

Conceptos avanzados de Python

37

Recapitulación de lo aprendido hasta ahora

38

Escribir código Pythonico y profesional

39

Comentarios y Docstrings en Python

40

Scope y closures: variables locales y globales

41

Anotaciones de tipo

42

Validación de tipos en métodos

43

Librería Collections y Enumeraciones

Decoradores

44

Decoradores en Python

45

Decoradores anidados y con parámetros

46

Uso de Decoradores en clases y métodos

Métodos y estructura de clases en Python

47

Métodos mágicos

48

Sobrecarga de operadores

49

Implementación de `if __name__ == "__main__":`

50

Metaprogramación en Python

51

Uso de *args y **kwargs

52

Métodos privados y protegidos

53

Gestión avanzada de propiedades

54

Métodos estáticos y de clase avanzados

Programación concurrente y asíncrona

55

Introducción a la concurrencia y paralelismo

56

Threading y multiprocessing en Python

57

Asincronismo con asyncio

58

Asincronismo y concurrencia

Creación de módulos y paquetes

59

Creación de módulos en Python

60

Gestión de paquetes

61

Publicación de paquetes en PyPI

Proyecto final

62

Implementación de un sistema completo

63

Implementación de un Sistema Completo

No tienes acceso a esta clase

¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera

Curso de Python

Curso de Python

Carli Code

Carli Code

Anotaciones de tipo

41/63
Recursos

Aportes 47

Preguntas 3

Ordenar por:

¿Quieres ver más aportes, preguntas y respuestas de la comunidad?

Si bien las anotaciones de tipo solo tienen el propósito de indicar de forma explícita la naturaleza de las variables que estamos utilizando, lo cierto es que en su estructura podemos observar la forma en la que comúnmente se especifica el Dominio y el Contradominio de una función: ![](https://static.platzi.com/media/user_upload/C%C3%B3digo%202-9768f801-3d60-4cb2-81b1-760f493b0f7f.jpg)
```js def lista_empleados(lista_empleados:list, limite_salario:float)-> list: return [emp['nombre'] for emp in lista_empleados if emp['sueldo'] > limite_salario] lista = [ {"nombre": "Maria La del Barrio", "edad": 30, "sueldo": 30000 }, {"nombre": "Luis Miguel", "edad": 25, "sueldo": 25000 }, {"nombre": "Ana Bolena", "edad": 20, "sueldo": 20000 }, {"nombre": "Pepe Grillo", "edad": 20, "sueldo": 50000 } ] print(lista_empleados(lista, 25000)) ```def lista\_empleados(lista\_empleados:list, limite\_salario:float)-> list: return \[emp\['nombre'] for emp in lista\_empleados if emp\['sueldo'] > limite\_salario] lista = \[ {"nombre": "Maria La del Barrio", "edad": 30, "sueldo": 30000 }, {"nombre": "Luis Miguel", "edad": 25, "sueldo": 25000 }, {"nombre": "Ana Bolena", "edad": 20, "sueldo": 20000 }, {"nombre": "Pepe Grillo", "edad": 20, "sueldo": 50000 }] print(lista\_empleados(lista, 25000))
Bueno, terminé de ver esta clase y algo que no me quedaron claro es ¿para que se usan las anotaciones?, probando con el código en Visual Studio Code, me di cuenta que precisamente sirve para dar información de que tipo de variables se deben introducir cuando se crea una función, clase, etc. y ya, porque puedo haver: a: int = "Esto es una string" y sigue funcionando, es decir, no aletara para nada la ejecución del código, pero al crar una función y luego ir a llamarla, cuando aparece el comentario o guía de los parámetros que hay que introducir, me indica qué tipo de variable se espera que introduzca, aunque puede uno colocar la que quiera. Lo cual es genial, porque al crear proyectos otra persona al ir a usar alguna función, clase o similar, tiene una clara guía de cómo el que creó ese código espera que sea empleado. Esto lo deduje yo mismo indagando al hacer pruebas. Por favor corríganme si me equivoco, y si estoy en lo cierto, para cuando actualicen esta clase recomiendo que se explique precisamente eso, cuál es el proposito de las anotaciones, porque con esta clase me quedó super claro es cómo realizarlas y hacer código con ellas, pero al no ser consiente de su importancia, el cerebro lo ve como información "basura".
```python # Implementa una funcion que procese una lista de diccionarios con informacion de empleados, utilizando anotaciones de tipo. #1 recibira una lista de diccionarios, cada diccionario tendra las claves: "nombre", "edad", "sueldo". #2 devolvera una lista de empleados que ganen mas de cierto sueldo. #importamos las librerias necesarias from typing import List, Dict #creamos la funcion filtrar_empleados_por_sueldo que recibe una lista de diccionarios y un sueldo minimo def filtrar_empleados_por_sueldo(empleados: List[Dict[str, int]], sueldo_minimo: float) -> List[Dict[str, int]]: return [empleado for empleado in empleados if float(empleado['sueldo']) > sueldo_minimo] #lista de diccionarios con informacion de empleados empleados = [ {'nombre': 'Ana', 'edad': 28, 'sueldo': 1500}, {'nombre': 'Luis', 'edad': 35, 'sueldo': 2500}, {'nombre': 'Carlos', 'edad': 40, 'sueldo': 3500}, {'nombre': 'Maria', 'edad': 22, 'sueldo': 4500}, {'nombre': 'Jorge', 'edad': 29, 'sueldo': 5500}, {'nombre': 'Laura', 'edad': 31, 'sueldo': 6500}, {'nombre': 'Pedro', 'edad': 38, 'sueldo': 7500}, {'nombre': 'Sofia', 'edad': 26, 'sueldo': 8500}, {'nombre': 'Miguel', 'edad': 33, 'sueldo': 9500}, {'nombre': 'Lucia', 'edad': 27, 'sueldo': 10500} ] #imprimimos la lista de empleados que ganan mas de 500 print(filtrar_empleados_por_sueldo(empleados, 7000)) ```
```python # Lista de personas empleadas empleados = [ {'name': 'Derbasiso', 'age': 47, 'salary' : 979000}, {'name': 'Paula', 'age': 34, 'salary' : 2368009}, {'name': 'Efrain', 'age': 38, 'salary' : 1256000}, {'name': 'Estefania', 'age': 35, 'salary' : 1890902}, {'name': 'Peter', 'age': 44, 'salary' : 979007}, {'name': 'Paola', 'age': 44, 'salary' : 2159007}, {'name': 'Mariel', 'age': 29, 'salary' : 1968009} ] # Funcion retorna una lista con los nombres de personas empleadas cuyos salarios son mas altos que los de mas # dado un valor como referencia, sueldo_referencia def evalua_sueldos(lista_empleados : list, sueldo_referencia : float) -> list : empleados_sueldo_alto : list = [empleado['name'] for empleado in lista_empleados if empleado['salary'] > sueldo_referencia] return empleados_sueldo_alto # Guarda en la variable, lo retornado por la funcion empleados_sueldo_alto = evalua_sueldos(empleados, 1900001.1) # Impreme todal de personas empleadas print('LISTA TOTAL DE PERSONAS EMPLEADAS:') for i, empleado in enumerate(empleados, start=1): print(f' {i} : {empleado["name"]}') #De esta manera, no necesitas mantener un contador manual (i) y el enumerate te permite contar desde 1 en lugar de 0. # Imprime la lista en formato print(f'Las personas ganadoras son: {empleados_sueldo_alto}') # Se informa los bonus extra a las personas con sueldos altos print(f'La persona con acceso a: una digital card, es: {empleados_sueldo_alto[0]}') print(f'La persona con acceso a: 1 año de all-inclusive, en la fectería, es: {empleados_sueldo_alto[1]}') print(f'La persona con acceso a: refaccionar su lugar de trabajo, es: {empleados_sueldo_alto[2]}') ```
```python from typing import Optional employees = [ {"name": "Alice Johnson", "ID": 101, "salary": 55000}, {"name": "Bob Smith", "ID": 102, "salary": 60000}, {"name": "Charlie Brown", "ID": 103, "salary": 72000}, {"name": "Diana Prince", "ID": 104, "salary": 48000}, {"name": "Ethan Hunt", "ID": 105, "salary": 75000}, {"name": "Fiona Gallagher", "ID": 106, "salary": 53000}, {"name": "George Miller", "ID": 107, "salary": 64000}, {"name": "Hannah Lee", "ID": 108, "salary": 59000}, {"name": "Ian McGregor", "ID": 109, "salary": 68000}, {"name": "Jasmine Patel", "ID": 110, "salary": 72000} ] id_list = [employee["ID"] for employee in employees] def employee_info(employees_group: list[int] = None, employee_id: int = None) -> Optional[int]: if employee_id in employees_group: return "The employee with the ID number {} is in the list.".format(employee_id) return None def high_earners(employees_group: list) -> Optional[list]: high_earners_list = [] for employee in employees_group: if employee["salary"] >= 65000: high_earners_list.append(employee["name"]) high_earners_list.append(employee["salary"]) return high_earners_list print(high_earners(employees)) ```from typing import Optional employees = \[    {"name": "Alice Johnson", "ID": 101, "salary": 55000},    {"name": "Bob Smith", "ID": 102, "salary": 60000},    {"name": "Charlie Brown", "ID": 103, "salary": 72000},    {"name": "Diana Prince", "ID": 104, "salary": 48000},    {"name": "Ethan Hunt", "ID": 105, "salary": 75000},    {"name": "Fiona Gallagher", "ID": 106, "salary": 53000},    {"name": "George Miller", "ID": 107, "salary": 64000},    {"name": "Hannah Lee", "ID": 108, "salary": 59000},    {"name": "Ian McGregor", "ID": 109, "salary": 68000},    {"name": "Jasmine Patel", "ID": 110, "salary": 72000}] id\_list = \[employee\["ID"] for employee in employees] def employee\_info(employees\_group: list\[int] = None, employee\_id: int = None) -> Optional\[int]:    if employee\_id in employees\_group:        return "The employee with the ID number {} is in the list.".format(employee\_id)     return None def high\_earners(employees\_group: list) -> Optional\[list]:    high\_earners\_list = \[]    for employee in employees\_group:        if employee\["salary"] >= 65000:            high\_earners\_list.append(employee\["name"])            high\_earners\_list.append(employee\["salary"])    return high\_earners\_list print(high\_earners(employees))
## **Razón de fondo para usar anotaciones de tipo en Python** Python **permite cambiar el tipo de una variable en tiempo de ejecución** porque su tipado es **dinámico** y **débilmente tipado**. Sin embargo, **las anotaciones de tipo ayudan a mejorar la calidad del código sin perder flexibilidad**. Las razones principales para usarlas son: **1.** Detección temprana de errores con herramientas como `mypy` **2.** Código más claro y auto-documentado **3.** Facilita el mantenimiento en proyectos grandes **4.** Mejor integración con IDEs y autocompletado **5.** Optimización con `mypy` y herramientas estáticas **Conclusión: ¿Por qué usar anotaciones en Python?** ✔ **Evitan errores antes de ejecutar el código.** ✔ **Documentan mejor las funciones y variables.** ✔ **Facilitan el mantenimiento en proyectos grandes.** ✔ **Mejoran la experiencia con IDEs y herramientas de análisis estático.** Aunque **no son obligatorias**, son una **buena práctica**, especialmente en proyectos grandes. ![]()![](https://static.platzi.com/media/user_upload/Screenshot_ejercicio_anotaciones_de_tipo_y_docstrings-a17b2654-8e4d-4476-9428-468c335d2427.jpg)
```js from typing import Optional #Anotaciones print() print("* Ejercicio 1:") print("- Suma Ids") print() #Variables id_uno: int = 2210 print(id_uno + id_uno) print() print("* Ejercicio 2:") print("- Suma Ids con funcion que tiene un tipo") print() def suma_tipo(id_uno: int, id_dos: int) -> int: return id_uno + id_dos print(suma_tipo(1, 2)) print() print("* Ejercicio 3:") print("- Caso avanzado con clases") print() class Empleado: nombre: str edad: int salario: float def __init__(self, nombre: str, edad: int, salario: float): self.nombre = nombre self.edad = edad self.salario = salario def introduccion(self) -> str: return f"Hola soy { self.nombre } y tengo { self.edad } años de edad" #Usando la libreria optional #Al ejecutar mypy no encuentra error def mostrar_edad(self) -> Optional[int]: return None empleado_uno = Empleado("Alexis Dorado", 33, 4900000) print(empleado_uno.introduccion()) print(empleado_uno.mostrar_edad()) ```
Comparto el código, es muy parecido al reto anterior, pero se específica que tipo de variable es la que recibe y devuelve o al menos así fue como lo comprendí y está lo más simplificado que pude hacerlo ```js employees = [{ 'name' : 'Angel', 'age' : 24, 'salary' : 1000 }, { 'name' : 'Laura', 'age' : 29, 'salary' : 1400 }, { 'name' : 'Juan', 'age' : 25, 'salary' : 900 }, { 'name' : 'Jesus', 'age' : 22, 'salary' : 1500 }, { 'name' : 'Ramon', 'age' : 25, 'salary' : 1450 }] #Metodo for def getSalaries(employees: list, limit: int) -> str: #Creamos una lista para guardar los nombre de los empleados person_salaries = [] #Usamos un blucle para comparar el sueldo de cada empleado con el limite for person in employees: if person['salary'] > limit: #Agregamos a una lista los empleados correspondientes person_salaries.append(person['name']) print(f"Las personas con un salario mayor a {limit} son {person_salaries}") getSalaries(employees, 1200) ```
```python #Crear un diccionario con los datos "Name", "Age y "Salary". #Crear una función que nos devuelva a los empleados con un salario concreto people = [{"name": "Marta", "Age": "29", "Salary": "1900"}, {"name": "Marc", "Age": "32", "Salary": "2000"}, {"name": "Carlos", "Age": "32", "Salary": "3000"}] #Hayar el dato máximo y el mínimo de los salarios: salaries = [int(perso["Salary"]) for perso in people] employees = [perso["name"] for perso in people] ages = [int(perso["Age"]) for perso in people] max_salary = max (salaries) min_salary = min(salaries) max_age = max (ages) min_age = min (ages) print(min_age) print(max_age) #Encontrar empleados con salario concreto def find_employees_by_salary (people, salary): return [perso["name"] for perso in people if int(perso ["Salary"]) ==salary] print (f"El salario máximo entre los empleados {employees} es: {max_salary}") print (f"El salario mínimo entre los empleados {employees} es: {min_salary}") employees_min_salary = find_employees_by_salary(people, min_salary) print(f"El empleado con el salario mínimo ({min_salary}€) es: {employees_min_salary[0]}") ```
Mi aporte ![](https://static.platzi.com/media/user_upload/image-ab71cbda-8cb0-4efa-8d9b-73ac3c0e11e7.jpg)![](https://static.platzi.com/media/user_upload/image-b7de5cc9-c18e-4f7b-940c-def853b79afe.jpg)
![](https://static.platzi.com/media/user_upload/image-f1516bdf-5803-4c1a-bf92-d6526d0731b3.jpg)
```python def filtrar_empleados_por_sueldo(empleados, sueldo_minimo): return [empleado for empleado in empleados if empleado["sueldo"] > sueldo_minimo] # Ejemplo de uso if __name__ == "__main__": # Lista de empleados empleados = [ {"nombre": "Ana", "edad": 28, "sueldo": 3000}, {"nombre": "Luis", "edad": 35, "sueldo": 4500}, {"nombre": "María", "edad": 40, "sueldo": 2500}, {"nombre": "Juan", "edad": 30, "sueldo": 4000}, ] # Sueldo mínimo sueldo_minimo = 3000 # Filtrar empleados resultado = filtrar_empleados_por_sueldo(empleados, sueldo_minimo) # Imprimir resultado print(f"Empleados que ganan más de {sueldo_minimo}:") for emp in resultado: print(emp) ```def filtrar\_empleados\_por\_sueldo(empleados, sueldo\_minimo):       return \[empleado for empleado in empleados if empleado\["sueldo"] > sueldo\_minimo] \# Ejemplo de usoif \_\_name\_\_ == "\_\_main\_\_":    # Lista de empleados    empleados = \[        {"nombre": "Ana", "edad": 28, "sueldo": 3000},        {"nombre": "Luis", "edad": 35, "sueldo": 4500},        {"nombre": "María", "edad": 40, "sueldo": 2500},        {"nombre": "Juan", "edad": 30, "sueldo": 4000},    ]     # Sueldo mínimo    sueldo\_minimo = 3000     # Filtrar empleados    resultado = filtrar\_empleados\_por\_sueldo(empleados, sueldo\_minimo)     # Imprimir resultado    print(f"Empleados que ganan más de {sueldo\_minimo}:")    for emp in resultado:        print(emp)
Yo entendí así lo de las Anotaciones no estaba del todo seguro, pero puse donde me parecía que van ![](https://static.platzi.com/media/user_upload/code-ee12e880-6029-4751-99da-bac77f439225.jpg)
```python class employee(): def __init__(self, name: str, age: int, salary: float, department: str): self.name = name self.age = age self.salary = salary self.department = department def gets_more_than_1000(self): if self.salary >= 1000: return True else: return False def introduce(self) -> str: return f"Hi, my name is {self.name} and I'm {self.age} years old. i work in {self.department}, and yes i earn more than $ 1k." employee_list = [employee("Juan", 29, 1550, "IT"), employee("Pedro", 30, 900, "HR"), employee("Maria", 25, 1200, "Marketing")] for employee in employee_list: if employee.gets_more_than_1000(): print(employee.introduce()) ```
class employee():    def \_\_init\_\_(self, name: str, age: int, salary: float, department: str):        self.name = name        self.age = age        self.salary = salary        self.department = department        def gets\_more\_than\_1000(self):        if self.salary >= 1000:            return True        else:            return False        def introduce(self) -> str:        return f"Hi, my name is {self.name} and I'm {self.age} years old. i work in {self.department}, and yes i earn more than $ 1k." employee\_list = \[employee("Juan", 29, 1550, "IT"), employee("Pedro", 30, 900, "HR"), employee("Maria", 25, 1200, "Marketing")] for employee in employee\_list:    if employee.gets\_more\_than\_1000():        print(employee.introduce())
```js class Nomina: name:str #tipo string age: int #entero salary: float #tipo flotante, osea con decimal def __init__(self, name: str, age: int, salary: float): self.name = name self.age = age self.salary = salary def __repr__(self): return f'{self.name, self.age, self.salary}' def mayor_sueldo(self): # Retorna True si el salario es mayor o igual a 6000 return self.salary >= 6000 emp1 = Nomina("Maria", 35, 6411.1) emp2 = Nomina("Jose", 41, 85444.5) emp3 = Nomina("Carlos",31,5211.5) lista_empleados = [emp1, emp2, emp3] #Imprimir lista: print(lista_empleados) #[('Maria', 35, 6411.1), ('Jose', 41, 85444.5), ('Carlos', 31, 5211.5)] #Filtrar empleados con salario mayor o igual a 6000 (filtrar la lista para crear otra lista): empleado_mayor_sueldo = [empleado for empleado in lista_empleados if empleado.mayor_sueldo()] print("Empleados con mayor sueldo:") for empleado in empleado_mayor_sueldo: #uso la lista nueva print(empleado) ```*class* <u>Nomina</u>:    name:*str* #tipo string    age: *int* #entero    salary: *float* #tipo flotante, osea con decimal     *def* \_\_init\_\_(*self*, *name*: *str*, *age*: *int*, *salary*: *float*):        self.name = name        self.age = age        self.salary = salary     *def* \_\_repr\_\_(*self*):        return *f*'{self.name, self.age, self.salary}'     *def* mayor\_sueldo(*self*):    # Retorna True si el salario es mayor o igual a 6000        return self.salary >= 6000 emp1 = Nomina("Maria", 35, 6411.1)emp2 = Nomina("Jose", 41, 85444.5)emp3 = Nomina("Carlos",31,5211.5)
```python """ 1. La funcion recibira una lista de diccionarios. Cada diccionario tendra las claves: "name", "age", "salary". 2. La funcion debe devolver una lista de empleados que ganen mas de un cierto sueldo. """ # lista generada por chatgpt, si quieres copiala employees = [ { "name": "Alice", "age": 30, "salary": 55000 }, { "name": "Bob", "age": 25, "salary": 45000 }, { "name": "Charlie", "age": 35, "salary": 60000 }, { "name": "Diana", "age": 28, "salary": 48000 }, { "name": "Eve", "age": 32, "salary": 53000 }, { "name": "Frank", "age": 29, "salary": 47000 }, { "name": "Grace", "age": 27, "salary": 46000 }, { "name": "Hank", "age": 33, "salary": 52000 }, { "name": "Ivy", "age": 26, "salary": 44000 }, { "name": "Jack", "age": 31, "salary": 51000 } ] def filter_employees (amount: int|float) -> list[dict[str, str|int|float]]: if amount<0: raise Exception("No existe el monto o no es valido para el filtrado") return [employee for employee in employees if employee["salary"] > amount] print(filter_employees(50000)) ```
```python def salary(empleados, salario): """ Recibira una lista de diccionarios Parametros: empleados, salario Retorna: Debe devolver una lista de empleados que ganen mas de un cierto sueldo """ # Filtramos la lista de empleados para obtener solo aquellos que ganen mas de 'sueldo_minimo' return [empleado for empleado in empleados if empleado['sueldo'] > salario] #Ejemplo de uso empleados = [ {'nombre':'Jefferson','edad':24,'sueldo':5600}, {'nombre':'Juan','edad':23,'sueldo':6000}, {'nombre':'Pablo','edad':21,'sueldo':4000}] salario = 5000 empleados_ricos = salary(empleados,salario) print(empleados_ricos) ```
Aqui dejo mi solucion, se aceptan comentarios o correcciones :D saludos platzinautas. .. . . . . . . .. . ```python # 1) Recibira una lista de diccionarios, cada diccionario tendrá las claves: "nombre", "edad", "sueldo". # 2) Debe devolver una lista de empleados que ganen más de cierto sueldo. from typing import Union nomina = [ {"nombre": "Eric", "edad": 30, "sueldo": 2000}, {"nombre": "Linda", "edad": 21, "sueldo": 3500}, {"nombre": "Jose", "edad": 26, "sueldo": 2200}, {"nombre": "Heren", "edad": 43, "sueldo": 5000}, {"nombre": "Daniel", "edad": 55, "sueldo": 3500}, ] def hight_salaries(nomina: list[dict[Union[str, int]]], hightest_salaries: int) -> list[dict[Union[str, int]]]: return [emp["nombre"] for emp in nomina if emp["sueldo"] >= hightest_salaries] print(hight_salaries(nomina, 3000)) ```
He aquí mi aporte sobre la actividad: ```js # 1. La función recibirá una lista de diccionarios. # Cada dict tendrá las claves: name, age, salary # 2. La función deberá retornar una lista de empleados # que ganen más de cierto salario employees = [ {"name": "Juan", "age": 28, "salary": 3500}, {"name": "María", "age": 32, "salary": 4200}, {"name": "Carlos", "age": 25, "salary": 3100}, {"name": "Ana", "age": 40, "salary": 5000}, {"name": "Luis", "age": 30, "salary": 3900}, ] def filtrar_empleados(data: list[dict["name": str, "age": int, "salary": float]], min: float = 4000) -> list[dict["name": str, "age": int, "salary": float]]: """ Filtra los empleados por un minimo de salario. Argumentos: data: lista de diccionarios con la estructura "age", "name", "salary" min: salario mínimo de los empleados Retorna: Empleados que tengan más de min """ return [emp for emp in data if emp["salary"] > min] print("Empleados filtrados", filtrar_empleados(employees)) ```
`emplee = [{"nombre": "Juan", "edad": 22, "salario": 22.22}, {"nombre": "Pedro", "edad": 33, "salario": 33.33}, {"nombre": "Maria", "edad": 44, "salario": 44.44}, {"nombre": "Jose", "edad": 55, "salario": 55.55}] ` `def Better_salary2(emplee: list[dict["name": str, "age": int, "salario": float]]) -> list: return [x for x in emplee if x["salario"] > 50.00]` `print(Better_salary2(emplee)) ``# [{'nombre': 'Maria', 'edad': 44, 'salario': 44.44}, {'nombre': 'Jose', 'edad': 55, 'salario': 55.55}]`
alguien sabe como sacar el mayor que? mi teclado no tiene pintado y con el punto y la coma no me deja :( copio y pego de google y VS code no me lo acepta
![](https://static.platzi.com/media/user_upload/Captura%20de%20pantalla%202024-12-22%20165234-a34cdcb6-089e-48c0-96e2-55d407476c48.jpg)
```js from typing import Union personas = [ {"nombre": "Ana", "edad": 30, "sueldo": 2500}, {"nombre": "Carlos", "edad": 45, "sueldo": 3500}, {"nombre": "Beatriz", "edad": 28, "sueldo": 2800}, {"nombre": "Daniel", "edad": 40, "sueldo": 4000}, {"nombre": "Elena", "edad": 35, "sueldo": 3200}, ] def empresa(lista:Union[list[dict[str,Union[str,int,float]]]])->list[dict[str,Union[str,int,float]]]: empleadomas=[emp for emp in lista if emp['sueldo']>=3500] return empleadomas print (empresa(personas)) ```
```python from typing import Optional, Union """Función que procesa una lista de diccionarios con información de empleados. 1. Recibe como primer parámetro una lista de diccionarios. Cada diccionario tendrá las claves: "nombre", "edad" y "sueldo". 2. Devuelve una lista de empleados que ganen mas de cierto monto indicado en el segundo parámetro.""" def empleados_con_sueldo_mayor_a(empleados: list, monto: Union[int, float]) -> list: lista = [[empleado['nombre'], empleado['sueldo']] for empleado in empleados if empleado['sueldo'] >= monto] return lista # Crea la lista de diccionarios con los datos de los empleados. empleados = [ {'nombre': 'Iris', 'edad': '43', 'sueldo': 100}, {'nombre': 'Ivan', 'edad': '45', 'sueldo': 200}, {'nombre': 'Andres', 'edad': '25', 'sueldo': 300}, {'nombre': 'Nohelia', 'edad': '21', 'sueldo': 400}, {'nombre': 'Samuel', 'edad': '27', 'sueldo': 500 }, {'nombre': 'David', 'edad': '33', 'sueldo': 600 }, {'nombre': 'Sarahi', 'edad': '30', 'sueldo': 700}, {'nombre': 'Jesus', 'edad': '54', 'sueldo': 800}, {'nombre': 'Haydee', 'edad': '34', 'sueldo': 900}, {'nombre': 'Francisco', 'edad': '43', 'sueldo': 1000} ] # Crea e inicializa la variable monto monto = 300 # LLama a la función e imprime el resultado print(empleados_con_sueldo_mayor_a(empleados, monto)) ```
Bueno, como el ejercicio era casi el mismo que el anterior yo solo me limite a ponerle las anotaciones de tipo al código anterior 🫤. ```python ''' Reto: función 1: recibirá una lista de diccionarios, estos diccionarias tendrán como claves: "name", "age" y "salary". función 2: debe retornar una lista de empleados que ganen más de un cierto sueldo. ''' employees = [ {"name": "Jose", "age": 30, "salary": 2800}, {"name": "Marcos", "age": 25, "salary": 3500}, {"name": "Carli", "age": 28, "salary": 4200}, {"name": "Maria", "age": 42, "salary": 5600}, {"name": "Gabriel", "age": 18, "salary": 1500}, ] def highterSalary(data: list[dict], minSalary: int) -> list[dict]: # se recibe la lista de datos sobre los empleados info = data salary = minSalary def salaryFilter(): nonlocal info nonlocal salary # se crea una lista con los empleados filtardos por su salario salaries = [e for e in info if e["salary"] >= salary] return salaries return salaryFilter() print(highterSalary(employees, 3500)) print(highterSalary(employees, 4500)) ```
def empleados\_con\_mayor\_salario(lista\_empleados): """ Función para encontrar empleados con el salario más alto. :param lista\_empleados: Lista de diccionarios, donde cada diccionario contiene 'nombre', 'edad', y 'salario'. :return: Lista de diccionarios con los empleados que tienen el salario más alto. """ if not lista\_empleados: return \[] # Si la lista está vacía, retornamos una lista vacía \# Encontrar el salario máximo salario\_maximo = max(empleado\['salario'] for empleado in lista\_empleados) \# Filtrar empleados que ganen el salario máximo empleados\_mejor\_pagados = \[empleado for empleado in lista\_empleados if empleado\['salario'] == salario\_maximo] return empleados\_mejor\_pagados \# Ejemplo de uso empleados = \[ {'nombre': 'Juan', 'edad': 30, 'salario': 5000}, {'nombre': 'Ana', 'edad': 25, 'salario': 7000}, {'nombre': 'Luis', 'edad': 28, 'salario': 7000}, {'nombre': 'María', 'edad': 35, 'salario': 4500} ] resultado = empleados\_con\_mayor\_salario(empleados) print("Empleados con el mayor salario:", resultado)
```python def employee_list(employee_list, maximun_salary): find_employee = [employee for employee in employee_list if int(employee['salary']) > maximun_salary] return find_employee employee = [ {'name': 'Mike', 'age': '34', 'salary': '2800'}, {'name': 'Tony', 'age': '25', 'salary': '5000'}, {'name': 'Jorge', 'age': '37', 'salary': '5500'}, {'name': 'Mate', 'age': '40', 'salary': '4800'}, {'name': 'Yoli', 'age': '40', 'salary': '3700'}, {'name': 'Cris', 'age': '29', 'salary': '6000'} ] result = employee_list(employee, 5000) print(result) ```def employee\_list(employee\_list, maximun\_salary): find\_employee = \[employee for employee in employee\_list if int(employee\['salary']) > maximun\_salary] return find\_employee employee = \[ {'name': 'Mike', 'age': '34', 'salary': '2800'}, {'name': 'Tony', 'age': '25', 'salary': '5000'}, {'name': 'Jorge', 'age': '37', 'salary': '5500'}, {'name': 'Mate', 'age': '40', 'salary': '4800'}, {'name': 'Yoli', 'age': '40', 'salary': '3700'}, {'name': 'Cris', 'age': '29', 'salary': '6000'}] result = employee\_list(employee, 5000)print(result)![]()
Union • Uso: Permite definir que una variable puede ser de uno de varios tipos. Ejemplo: Union\[int, str] indica que la variable puede ser un entero o una cadena. • Ventajas: ◦ Flexibilidad: Permite manejar múltiples tipos en una misma variable. ◦ Claridad: Hace explícita la posibilidad de múltiples tipos, mejorando la legibilidad del código. ◦ Detección de errores: Ayuda a detectar errores de tipo en tiempo de compilación. Optional • Uso: Es una forma especial de Union que indica que una variable puede ser de un tipo específico o None. Ejemplo: Optional\[int] indica que la variable puede ser un entero o None. • Ventajas: ◦ Manejo de valores nulos: Facilita el manejo de valores nulos, evitando errores comunes relacionados con None. ◦ Claridad: Hace explícita la posibilidad de que una variable sea None, mejorando la legibilidad del código. ◦ Detección de errores: Ayuda a detectar errores de tipo en tiempo de compilación. mypy • Uso: Es una herramienta de análisis estático de tipos para Python que verifica las anotaciones de tipos y detecta inconsistencias. • Ventajas: ◦ Detección de errores: Detecta errores de tipo en tiempo de compilación, antes de ejecutar el código. ◦ Mejora de la calidad del código: Ayuda a mantener un código más limpio y consistente. ◦ Facilita la colaboración: Mejora la comprensión del código entre desarrolladores, especialmente en proyectos grandes. Mejoras con respecto a no usar ninguna de estas • Detección temprana de errores: Las herramientas como mypy y las anotaciones de tipos (Union, Optional) permiten detectar errores de tipo en tiempo de compilación, lo que reduce los errores en tiempo de ejecución. • Mejora de la legibilidad: Hacer explícitas las posibles variantes de tipos hace que el código sea más fácil de entender y mantener. • Facilita la colaboración: En proyectos de equipo, tener un código bien tipado y con anotaciones claras facilita la colaboración y la integración de nuevas contribuciones. Características desfavorables y calificación Union • Desventajas: ◦ Complejidad: Puede hacer que el código sea más complejo si se usan múltiples Union anidados. ◦ Rendimiento: El análisis estático puede ser más lento debido a la complejidad de las anotaciones. • Calificación: 80/100 Optional • Desventajas: ◦ Limitación: Solo se puede usar con un tipo base y None, lo que puede ser restrictivo en algunos casos. ◦ Rendimiento: Similar a Union, el análisis estático puede ser más lento. • Calificación: 75/100 mypy • Desventajas: ◦ Curva de aprendizaje: Puede haber una curva de aprendizaje para configurarlo y entender las anotaciones de tipos. ◦ Limitaciones: No detecta todos los errores de tipo, especialmente en código dinámico. • Calificación: 85/100 No usar ninguna de estas • Desventajas: ◦ Errores en tiempo de ejecución: Sin detección temprana de errores de tipo, es más probable que ocurran errores en tiempo de ejecución. ◦ Menor legibilidad: El código puede ser menos claro y más difícil de mantener. calificacion 55/100
```js lista_personas = [{"nombre": "Carla", "salario": "5000000"} ,{"nombre": "Jeshid", "salario": "6000000"} ,{"nombre": "Mario", "salario": "5000000"} ,{"nombre": "Juan", "salario": "8000000"}] def salario_minimo(lista_personas, salario): print(f"Personas con salario menor o igual a {salario}:") for persona in lista_personas: if float(persona["salario"]) >= salario: print(f"Nombre: {persona['nombre']}, Salario: {persona['salario']}") salario_minimo(lista_personas, 4000000.0) ```lista\_personas = \[{"nombre": "Carla", "salario": "5000000"}                       ,{"nombre": "Jeshid", "salario": "6000000"}                       ,{"nombre": "Mario", "salario": "5000000"}                       ,{"nombre": "Juan", "salario": "8000000"}] def salario\_minimo(lista\_personas, salario):    print(f"Personas con salario menor o igual a {salario}:")    for persona in lista\_personas:        if float(persona\["salario"]) >= salario:            print(f"Nombre: {persona\['nombre']}, Salario: {persona\['salario']}")    salario\_minimo(lista\_personas, 4000000.0)
```python from typing import Optional def order_employees( employees: list[dict], salary_amount: float ) -> Optional[list[dict]]: return [employee for employee in employees if employee["salary"] > salary_amount] employees = [ {"name": "John", "age": 25, "salary": 50000.0}, {"name": "Jane", "age": 30, "salary": 60000.0}, {"name": "Doe", "age": 35, "salary": 70000.0}, {"name": "Smith", "age": 40, "salary": 80000.0}, ] print(order_employees(employees, 60000.0)) ```from typing import Optional def order\_employees( employees: list\[dict], salary\_amount: float ) -> Optional\[list\[dict]]: return \[employee for employee in employees if employee\["salary"] > salary\_amount] employees = \[ {"name": "John", "age": 25, "salary": 50000.0}, {"name": "Jane", "age": 30, "salary": 60000.0}, {"name": "Doe", "age": 35, "salary": 70000.0}, {"name": "Smith", "age": 40, "salary": 80000.0}, ] print(order\_employees(employees, 60000.0))
Solución de la actividad: ```js employees = [ {'name':'Oscar Alfonzo Medrano Yilalys', 'age':22, 'salary': 10000}, {'name':'Wanesa', 'age':19, 'salary': 7000}, {'name':'Joao', 'age':33, 'salary':500} ] def high_salary(): high_salary_employees: list = [] for employee in employees: if employee['salary'] > 3000: high_salary_employees.append(employee) return high_salary_employees high_salary_list = high_salary() for e in high_salary_list: print(f"Wow {e['name']} has a very good salary of {e['salary']}") ```
```js def reparto(empleados: list, monto: int) -> list: lista: list = [] # recorre la lista de empleados for empleado in empleados: nombre: str = empleado["nombre"] edad: int = empleado["edad"] salario: float = empleado["salario"] # si gana mas del monto los guarda en ena lista para luego devolverlos def analizadora(monto: int) -> None: nonlocal salario if salario > monto: lista.append("Nombre: " + nombre + ", Edad: " + str(edad)) analizadora(monto) return lista empleados = [ {"nombre": "juan", "edad": 25, "salario": 20000.0}, {"nombre": "pedro", "edad": 30, "salario": 10000.0}, {"nombre": "luis", "edad": 35, "salario": 25000.0} ] monto: int = 10000 lista: list = reparto(empleados, monto) print(f'Empleados que ganan mas de {monto}: {lista}') ```
Aquí mi intento, según lo que entendí ```js lista_empleados = [    {    "nombre": "Toñito",     "edad": 30,     "sueldo": 30000    },        {    "nombre": "Maria",     "edad": 25,     "sueldo": 25000     },    {    "nombre": "Chucho",     "edad": 20,     "sueldo": 20000          },         {    "nombre": "Antonia",     "edad": 20,     "sueldo": 50000        }    ] def verificar_salarios(empleados: list[dict]):  resultados:list = []  # Lista para acumular los resultados  for empleado in empleados:    if empleado["sueldo"] >= 30000:      resultados.append(f"{empleado['nombre']} gana {empleado['sueldo']} y está por encima del promedio")    else:      resultados.append(f"{empleado['nombre']} gana {empleado['sueldo']} y está por debajo del promedio")    return resultados  # Retornar todos los resultados después del ciclo # listamos los resultados de la funcion resultados:list = verificar_salarios(lista_empleados) for resultado in resultados:  print(resultado) ```lista\_empleados = \[    {    "nombre": "Toñito",     "edad": 30,     "sueldo": 30000    },        {    "nombre": "Maria",     "edad": 25,     "sueldo": 25000     },    {    "nombre": "Chucho",     "edad": 20,     "sueldo": 20000          },         {    "nombre": "Antonia",     "edad": 20,     "sueldo": 50000        }    ] def verificar\_salarios(empleados: list\[dict]):  resultados:list = \[]  # Lista para acumular los resultados  for empleado in empleados:    if empleado\["sueldo"] >= 30000:      resultados.append(f"{empleado\['nombre']} gana {empleado\['sueldo']} y está por encima del promedio")    else:      resultados.append(f"{empleado\['nombre']} gana {empleado\['sueldo']} y está por debajo del promedio")    return resultados  # Retornar todos los resultados después del ciclo \# listamos los resultados de la funcionresultados:list = verificar\_salarios(lista\_empleados)for resultado in resultados:  print(resultado)
```js from typing import Union class Employee: name: str age: int salary: float def __init__(self, name: str, age: int, salary: float): self.name = name self.age = age self.salary = salary employee_1 = Employee("Javier", 35, 2400.50) employee_2 = Employee("Víctor", 47, 2100.00) employee_3 = Employee("Sergio", 50, 2800.75) employee_4 = Employee("Mari Luz", 46, 1800.35) employee_5 = Employee("Pedro", 54, 2900.99) employees = [employee_1, employee_2, employee_3, employee_4, employee_5] def get_employees_with_salary_bigger_than(employees: list[Employee], ref_salary: float): ''' Devuelve la lista de empleados que cobren más del sueldo de referencia especificado ''' target_employees = [] for employee in employees: if employee.salary > ref_salary: target_employees.append(employee) return target_employees print("\nLista de empleados:\n") for employee in employees: print(f" > {employee.name}\t{employee.age} años\t(Salario: {employee.salary})") ref_salary = float(input("\nDefine un salario de referencia: ")) print(f"\nLos empleados que cobran más de {ref_salary} son:\n") for employee in get_employees_with_salary_bigger_than(employees, ref_salary): print(f" > {employee.name}\t{employee.age} años\t(Salario: {employee.salary})") ```from typing import Union class Employee: name: str age: int salary: float def \_\_init\_\_(self, name: str, age: int, salary: float): self.name = name self.age = age self.salary = salary employee\_1 = Employee("Javier", 35, 2400.50)employee\_2 = Employee("Víctor", 47, 2100.00)employee\_3 = Employee("Sergio", 50, 2800.75)employee\_4 = Employee("Mari Luz", 46, 1800.35)employee\_5 = Employee("Pedro", 54, 2900.99) employees = \[employee\_1, employee\_2, employee\_3, employee\_4, employee\_5] def get\_employees\_with\_salary\_bigger\_than(employees: list\[Employee], ref\_salary: float): ''' Devuelve la lista de empleados que cobren más del sueldo de referencia especificado ''' target\_employees = \[] for employee in employees: if employee.salary > ref\_salary: target\_employees.append(employee) return target\_employees print("\nLista de empleados:\n") for employee in employees: print(f" > {employee.name}\t{employee.age} años\t(Salario: {employee.salary})") ref\_salary = float(input("\nDefine un salario de referencia: ")) print(f"\nLos empleados que cobran más de {ref\_salary} son:\n") for employee in get\_employees\_with\_salary\_bigger\_than(employees, ref\_salary): print(f" > {employee.name}\t{employee.age} años\t(Salario: {employee.salary})")
```python class Employee: name : str age : int salary : float def __init__ (self, name: str, age: int, salary: float): self.name = name self.age = age self.salary = salary def introduce(self) -> str: return f"Hello, my name is {self.name} and I am {self.age} years old." employee1 = Employee("John Doe", 30, 1000) employee2 = Employee("Jane Doe", 25, 900) employee3 = Employee("Bob Smith", 35, 1500) empleados = [{empleado.name, empleado.age, empleado.salary} for empleado in [employee1, employee2, employee3] if empleado.salary >= 1000] print(empleados) ```
Aquí mi intento en inglés: ```python def find_high_salary(employees:list[dict]) -> list[str]: ''' Find employees with salaries above the mean ''' mean = sum(employee["salary"] for employee in employees) / len(employees) return [employee["name"] for employee in employees if employee["salary"]>mean] employees = [ {"name": "Alice", "salary": 50000, "age": 28}, {"name": "Bob", "salary": 60000, "age": 34}, {"name": "Charlie", "salary": 70000, "age": 45}, {"name": "Diana", "salary": 80000, "age": 29}, {"name": "Eve", "salary": 90000, "age": 40} ] print(find_high_salary(employees)) ```def find\_high\_salary(*employees*:list\[dict]) -> list\[str]: *''' Find employees with salaries above the mean '''* mean = sum(employee\["salary"] for employee in *employees*) / len(*employees*) return \[employee\["name"] for employee in *employees* if employee\["salary"]>mean] employees = \[ {"name": "Alice", "salary": 50000, "age": 28}, {"name": "Bob", "salary": 60000, "age": 34}, {"name": "Charlie", "salary": 70000, "age": 45}, {"name": "Diana", "salary": 80000, "age": 29}, {"name": "Eve", "salary": 90000, "age": 40}] print(find\_high\_salary(employees))
```js from typing import TypedDict, Optional, List class EmployeeType(TypedDict): name: str age: int salary: float employee_type_list = Optional[List[EmployeeType]] employes_filters: employee_type_list = [] def employes_func(min_salary: int): employes: employee_type_list = [] def add_employes(): nonlocal employes employes = [ {"name": "Carlos", "age": 20, "salary": 100.0}, {"name": "Argeli", "age": 20, "salary": 200.0}, {"name": "Jisbel", "age": 20, "salary": 90.0}, {"name": "Armando", "age": 20, "salary": 80.0}, {"name": "Tester", "age": 20, "salary": 300.0}, {"name": "Notifier", "age": 20, "salary": 700.0}, ] def list_employes(): global employes_filters nonlocal employes for employe in range(len(employes)): if employes[employe]["salary"] > min_salary: employes_filters.append(employes[employe]) add_employes() list_employes() employes_func(250) print(employes_filters) ```from typing import TypedDict, Optional, List class EmployeeType(TypedDict): name: str age: int salary: float employee\_type\_list = Optional\[List\[EmployeeType]] employes\_filters: employee\_type\_list = \[] def employes\_func(min\_salary: int): employes: employee\_type\_list = \[] def add\_employes(): nonlocal employes employes = \[ {"name": "Carlos", "age": 20, "salary": 100.0}, {"name": "Argeli", "age": 20, "salary": 200.0}, {"name": "Jisbel", "age": 20, "salary": 90.0}, {"name": "Armando", "age": 20, "salary": 80.0}, {"name": "Tester", "age": 20, "salary": 300.0}, {"name": "Notifier", "age": 20, "salary": 700.0}, ] def list\_employes(): global employes\_filters nonlocal employes for employe in range(len(employes)): if employes\[employe]\["salary"] > min\_salary: employes\_filters.append(employes\[employe]) add\_employes() list\_employes() employes\_func(250) print(employes\_filters)
class Employee: name: str age: int salary: float def \_\_init\_\_(self, name: str, age: int, salary: float): self.name = name self.age = age self.salary = salary def introduce(self) -> str: return f"Hello, my name is {self.name} and I am {self.age} years old" employee1 = Employee("Cristian Amilcar", 28, 1000) employee2 = Employee("Benjamin Montoya", 45, 900) employee3 = Employee("Maria Aurelia Lopez", 70, 2000) empleados = \[{"nombre":empleado.name, "edad":empleado.age,"sueldo": empleado.salary} for empleado in \[employee1, employee2, employee3] if empleado.salary >= 2000] print(empleados)
def empleados\_con\_sueldo\_alto(lista\_empleados, sueldo\_minimo):    *# Filtramos la lista de empleados para encontrar aquellos que ganan más que el sueldo mínimo*    empleados\_filtrados = \[empleado for empleado in lista\_empleados if empleado\['salary'] > sueldo\_minimo]    return empleados\_filtrados *# Ejemplo de uso*empleados = \[    {'name': 'Ana', 'age': 28, 'salary': 4000},    {'name': 'Luis', 'age': 35, 'salary': 5000},    {'name': 'Maria', 'age': 24, 'salary': 3200},    {'name': 'Carlos', 'age': 30, 'salary': 4500}] *# Llamamos a la función con el sueldo mínimo de 4000*resultado = empleados\_con\_sueldo\_alto(empleados, 4000)print(resultado)
```python #Lista de diccionarios que contienen información inicial dictionary_list: list = [ { 'Name':'Daniel', 'Age' : 26, 'Salary' : 1500 }, { 'Name':'Maria', 'Age' : 27, 'Salary' : 3000 }, { 'Name':'Mateo', 'Age' : 20, 'Salary' : 5000 } ] def employee_salary(data: list) -> str: ''' Muestra el salario de cada empleado Parámetros: Una lista de diccionarios Retorna: String con nombre y salario de cada empleado ''' for i in data: print(f'El empleado {i['Name']} actualmente tiene un salario de {i['Salary']} USD') return True def filter_salary(data: list) -> str: ''' Filtra los empleados según un tope máximo de salario Parámetos: Tope máximo salarial, lista de diccionarios Retorna: Nombre y salario de los empleados que están por encima del tope salarial ''' filter: int = int(input('Ingrese tope salarial: ' )) print(f'Los empleados que ganan más de {filter} USD son: ') for i in data: if i['Salary'] > filter: print(f'- Empleado: {i['Name']}, Salario: {i['Salary']}') employee_salary(dictionary_list) filter_salary(dictionary_list) ```#Lista de diccionarios que contienen información inicialdictionary\_list: list = \[    {        'Name':'Daniel',        'Age' : 26,        'Salary' : 1500    },    {        'Name':'Maria',        'Age' : 27,        'Salary' : 3000    },    {       'Name':'Mateo',        'Age' : 20,        'Salary' : 5000     }] def employee\_salary(data: list) -> str:     '''    Muestra el salario de cada empleado     Parámetros:    Una lista de diccionarios     Retorna:    String con nombre y salario de cada empleado    '''    for i in data:         print(f'El empleado {i\['Name']} actualmente tiene un salario de {i\['Salary']} USD')    return True def filter\_salary(data: list) -> str:    '''    Filtra los empleados según un tope máximo de salario     Parámetos:    Tope máximo salarial, lista de diccionarios     Retorna:    Nombre y salario de los empleados que están por encima del tope salarial    '''    filter: int = int(input('Ingrese tope salarial: ' ))    print(f'Los empleados que ganan más de {filter} USD son: ')    for i in data:        if i\['Salary'] > filter:            print(f'- Empleado: {i\['Name']}, Salario: {i\['Salary']}') employee\_salary(dictionary\_list)filter\_salary(dictionary\_list)
Mi solución: ```python # Lista de empleados empleados = [ {"nombre": "Alan Brito", "edad": 30, "sueldo": 30000 }, {"nombre": "Luis Perez", "edad": 25, "sueldo": 10000 }, {"nombre": "Elza Payo", "edad": 20, "sueldo": 20000 }, {"nombre": "Elba Lazo", "edad": 20, "sueldo": 50000 } ] # Funcion para crear la nueva lista con el filtro de los sueldos def lista_empleados(empleados: list, limite: int = 30000) -> list: lista = [empleado for empleado in empleados if empleado['sueldo'] >= limite] return lista # Motrar el resultado print(lista_empleados(empleados)) # print(lista_empleados(empleados, limite=20000)) ```*# Lista de empleados*empleados = \[ {"nombre": "Alan Brito", "edad": 30, "sueldo": 30000 }, {"nombre": "Luis Perez", "edad": 25, "sueldo": 10000 }, {"nombre": "Elza Payo", "edad": 20, "sueldo": 20000 }, {"nombre": "Elba Lazo", "edad": 20, "sueldo": 50000 }] *# Funcion para crear la nueva lista con el filtro de los sueldosdef* lista\_empleados(*empleados*: *list*, *limite*: *int* = 30000) -> *list*: lista = \[empleado for empleado in empleados if empleado\['sueldo'] >= limite] return lista *# Motrar el resultado*print(lista\_empleados(empleados))*# print(lista\_empleados(empleados, limite=20000))*
Mi solución: ![](https://static.platzi.com/media/user_upload/Screenshot%202024-10-28%20193855-6763f94e-82e5-4415-9f02-5cd0e9961c49.jpg)
Las \*\*anotaciones de tipo\*\* en Python son una forma de especificar el tipo de variables, parámetros de funciones y valores de retorno. Aunque no afectan el funcionamiento del programa, facilitan la lectura del código y ayudan a herramientas de análisis estático a detectar errores. A continuación, te presento una explicación detallada y ejemplos sobre cómo usarlas. \### Sintaxis de Anotaciones de Tipo 1\. \*\*Parámetros de Funciones y Tipo de Retorno\*\* Puedes usar las anotaciones de tipo en la definición de funciones para indicar qué tipo de datos se espera como argumento y qué tipo se devolverá: ```python def sumar(a: int, b: int) -> int: return a + b ``` En este ejemplo, se espera que `a` y `b` sean enteros (`int`), y la función devolverá un entero. 2\. \*\*Variables\*\* Aunque no es común, también puedes anotar el tipo de las variables: ```python nombre: str = "Juan" edad: int = 30 ``` 3\. \*\*Listas y Otras Colecciones\*\* Puedes especificar el tipo de elementos en listas, tuplas y diccionarios utilizando el módulo `typing`: ```python from typing import List, Tuple, Dict def procesar\_datos(nombres: List\[str], edades: List\[int]) -> Dict\[str, int]: return dict(zip(nombres, edades)) ``` En este caso, `nombres` es una lista de cadenas (`List\[str]`) y `edades` es una lista de enteros (`List\[int]`). La función devuelve un diccionario que asocia cada nombre con una edad. 4\. \*\*Funciones Lambda\*\* También puedes usar anotaciones de tipo con funciones lambda: ```python sumar: Callable\[\[int, int], int] = lambda x, y: x + y ``` Aquí, `sumar` es una función lambda que toma dos enteros y devuelve un entero. 5\. \*\*Anotaciones en Clases\*\* Las anotaciones de tipo también se pueden utilizar en las clases para definir atributos: ```python class Persona: def \_\_init\_\_(self, nombre: str, edad: int): self.nombre: str = nombre self.edad: int = edad ``` \### Ejemplo Completo Aquí tienes un ejemplo más completo que utiliza anotaciones de tipo en funciones y clases: ```python from typing import List, Dict class Estudiante: def \_\_init\_\_(self, nombre: str, calificaciones: List\[float]): self.nombre: str = nombre self.calificaciones: List\[float] = calificaciones def promedio(self) -> float: return sum(self.calificaciones) / len(self.calificaciones) def registrar\_estudiantes(estudiantes: List\[Estudiante]) -> Dict\[str, float]: return {estudiante.nombre: estudiante.promedio() for estudiante in estudiantes} \# Uso est1 = Estudiante("Ana", \[90, 80, 85]) est2 = Estudiante("Luis", \[75, 80, 70]) resultado = registrar\_estudiantes(\[est1, est2]) print(resultado) ``` \### Ventajas de las Anotaciones de Tipo \- \*\*Mejora la Legibilidad:\*\* Facilita la comprensión del código, ya que queda claro qué tipos de datos se utilizan. \- \*\*Detección Temprana de Errores:\*\* Ayuda a herramientas de análisis estático (como `mypy`) a identificar posibles errores antes de la ejecución. \- \*\*Mejor Integración en Editores:\*\* Los editores pueden proporcionar autocompletado y sugerencias más precisas cuando tienen información sobre los tipos de datos. \### Conclusión Las anotaciones de tipo en Python son una herramienta poderosa para mejorar la calidad del código y facilitar la colaboración en proyectos. Aunque no son obligatorias, su uso es altamente recomendable en proyectos grandes o en entornos donde se requiere mantener un código limpio y fácil de entender.
Agregando las anotaciones de tipo al código que originalmente realizamos en la anterior sección, se sigue que: ![](https://static.platzi.com/media/user_upload/codigo%201-eb688839-7210-433b-8c7b-7ae96323337b.jpg)
Soy yo o el nivel de los cursos de platzi está bajando? He visto muy pocos cursos donde realmente te dicen el por qué de las cosas y no se limitan a nada más escribir código y demostrar qué hace ese codigo. Reconozco el esfuerzo que hacen los maestros para preparar sus clases, pero si es nada más copiar y pegar código me quedo un poco corto en comprender realmente de qué trata el tema. Por ejemplo, por qué definir los tipos dos veces para una clase (al inicio de la clase y en el constructor de la clase), o por ejemplo que los tipos list, dict, tuple solo están a partir de la version 3.9 de python