Fundamentos de Programación y Python
¿Por qué aprender Python?
Introducción a Python
Conceptos Básicos de Programación
Práctica: Te doy la bienvenida a los ejercicios interactivos
Manipulación de Cadenas de Texto en Python
Enteros, Flotantes y Booleanos
Todo lo que Debes Saber sobre print en Python
Operaciones Matemáticas en Python
Operaciones de Entrada/Salida en Consola
Colección y Procesamiento de Datos en Python
Listas
Método slice
Listas de más dimensiones y Tuplas
Aplicación de Matrices
Diccionarios
Comprehension Lists en Python (CLASE NUEVA)
Control de Flujo en Python
Estructuras condicionales
Bucles y Control de Iteraciones
Generadores e Iteradores
Funciones y Manejo de Excepciones en Python
Uso de Funciones en Python
Funciones Lambda y Programación Funcional en Python
¿Cómo realizar una función recursiva en Python?
Manejo de Excepciones y Uso de Pass (CLASE NUEVA)
Programación Orientada a Objetos en Python
Fundamentos de Programación Orientada a Objetos en Python
Ejercicio Biblioteca con POO
Herencia en POO con Python
Objetos heredados
Los 4 pilares de la programacion orientada a objetos
Uso de super() en Python (CLASE NUEVA)
Superando los Fundamentos de Programación Orientada a Objetos en Python
Lectura y escritura de archivos
Manejo de Archivos .TXT (CLASE NUEVA)
Manejo de Archivos CSV (CLASE NUEVA)
Manejo de Archivos JSON (CLASE NUEVA)
Biblioteca estándar de Python
Biblioteca estándar en Python (CLASE NUEVA)
Librería Os, Math y Random (CLASE NUEVA)
Librería Statistics y Análisis Estadístico (CLASE NUEVA)
Proyecto final: Guerra naval
Conceptos avanzados de Python
Recapitulación de lo aprendido hasta ahora
Escribir código Pythonico y profesional
Comentarios y Docstrings en Python
Scope y closures: variables locales y globales
Anotaciones de tipo
Validación de tipos en métodos
Librería Collections y Enumeraciones
Decoradores
Decoradores en Python
Decoradores anidados y con parámetros
Uso de Decoradores en clases y métodos
Métodos y estructura de clases en Python
Métodos mágicos
Sobrecarga de operadores
Implementación de `if __name__ == "__main__":`
Metaprogramación en Python
Uso de *args y **kwargs
Métodos privados y protegidos
Gestión avanzada de propiedades
Métodos estáticos y de clase avanzados
Programación concurrente y asíncrona
Introducción a la concurrencia y paralelismo
Threading y multiprocessing en Python
Asincronismo con asyncio
Asincronismo y concurrencia
Creación de módulos y paquetes
Creación de módulos en Python
Gestión de paquetes
Publicación de paquetes en PyPI
Proyecto final
Implementación de un sistema completo
Implementación de un Sistema Completo
No tienes acceso a esta clase
¡Continúa aprendiendo! Únete y comienza a potenciar tu carrera
Si ya tienes una cuenta,
Scope y closures: variables locales y globales
40/63Recursos
¿Qué son las variables locales y globales?
En el fascinante mundo de la programación, comprender la vida útil de una variable es vital para evitar errores comunes y mejorar el rendimiento del código. Las variables locales y globales juegan un papel crucial en este ámbito. Mientras que las variables locales existen sólo dentro de un bloque de código determinado, las variables globales pueden ser accedidas desde cualquier parte del programa.
¿Cómo trabajan las variables locales?
Para ilustrar este concepto, imaginemos una función que crea una variable local en Python. Aquí, la variable x es asignada al número 10. Esta variable es de tipo local porque solo persiste y puede ser accesada dentro del cuerpo de la función donde se define.
def funcion_local():
x = 10 # Variable local
print("El valor de la variable es", x)
funcion_local()
Al llamar a funcion_local(), se imprime el valor de x. Sin embargo, intentar acceder a x fuera de la función genera un error, ya que x no está definida globalmente.
¿Cómo se comportan las variables globales?
En contraste, una variable global x puede ser definida fuera de cualquier función, lo que permite que su valor sea accedido o modificado desde cualquier parte del programa.
x = 100 # Variable global
def mostrar_variable_global():
print("El valor de la variable global es", x)
mostrar_variable_global()
En este caso, imprimir x desde la función mostrar_variable_global() no genera errores, mostrando su valor globalmente definido.
¿Cómo combinar funciones internas y externas?
Las funciones pueden anidar otras funciones internamente. En tal caso, se debe prestar especial atención al alcance de las variables definidas.
Usando variables globales con funciones internas
Supongamos que tenemos una variable global y deseamos modificar sus valores a través de funciones interiores y exteriores.
x = "global" # Variable global
def funcion_externa():
x = "externa" # Redefine 'x' en el ámbito de la función externa
def funcion_interna():
x = "local" # Redefine 'x' en el ámbito de la función interna
print(x)
funcion_interna()
print(x)
funcion_externa()
print(x)
Al ejecutar este código, se observa cómo los distintos valores de x son imprimidos dependiendo del ámbito de la función donde se encuentren.
¿Qué son las variables nonlocal?
Las variables nonlocal actúan como un puente entre variables locales y globales, permitiendo que las funciones internas accedan y modifiquen variables en funciones 'encapsulantes' externas.
def funcion_externa():
x = "inicial"
def funcion_interna():
nonlocal x
x = "modificado"
print("El valor en inner es", x)
funcion_interna()
print("El valor afuera es", x)
funcion_externa()
En este ejemplo, la variable x se marca como nonlocal, permitiendo que la función interna modifique su valor, y se refleja tanto dentro como fuera de funcion_interna().
¡Nunca dejes de explorar nuevos conceptos en programación! El entendimiento profundo de variables locales, globales y nonlocal refuerza una base sólida para construir aplicaciones más sofisticadas y robustas. ¡Sigue aprendiendo y realizando retos que pongan a prueba tus habilidades!
Aportes 90
Preguntas 0
Ordenar por:
esto debería estar en las primeras clases después de variables.
Veo que todos usaron el bucle for, yo estoy tan acostumbrado a usar los métodos .map(), .filter() y otros de JS, que quise usar lo mismo con Python
```js
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 filter_salary():
"""
Filtra a los empleados que ganan más de 4000 USD
Sin parámetros
Retorna:
list: Una lista de empleados
"""
return list(filter(lambda employe: employe['salary'] >= 4000, employees))
print(f'Esta es la lista de todos los empleados: {employees}')
print(f'Los empleados que ganan 4000 o más USD al mes son: {filter_salary()}')
```
Buenas noches, compañeros y profesora.
Aquí mi solución y abajo de ella la explicación:
En realidad no es necesario utilizar dos funciones (es redundante), y gracias a la forma en cómo se comportan las listas en Python, es posible hacer referencia a ellas sin necesidad de utilizar la instrucción Global.
En efecto, si dentro de cualquier función (o anidación de estas), hacemos referencia a una lista, Python 2 y Python 3, entienden que es global. Y por lo tanto no es necesario especificar que lo sea.
```js
def gan(lista:list, limite_salary:float):
print([l for l in lista if l['salary'] > limite_salary])
```
En Python, \*\*scope\*\* (alcance) se refiere a la visibilidad y duración de una variable en diferentes partes del código, mientras que \*\*closures\*\* (cierres) son funciones que recuerdan el entorno en el que fueron creadas, incluso después de que el entorno haya terminado de ejecutarse. Vamos a desglosar ambos conceptos, comenzando por las variables locales y globales.
\### 1. Variables Locales y Globales
\#### Variables Locales
Las variables locales son aquellas definidas dentro de una función. Solo son accesibles dentro de esa función y se destruyen una vez que la función termina de ejecutarse.
```python
def funcion\_local():
variable\_local = 10 # Variable local
print("Dentro de la función:", variable\_local)
funcion\_local()
\# print(variable\_local) # Esto generará un error porque variable\_local no está definida aquí
```
\#### Variables Globales
Las variables globales son aquellas definidas fuera de cualquier función. Son accesibles desde cualquier parte del código, incluyendo dentro de funciones. Sin embargo, para modificar una variable global dentro de una función, se debe usar la palabra clave `global`.
```python
variable\_global = 20 # Variable global
def funcion\_global():
global variable\_global # Indica que se va a usar la variable global
variable\_global += 5 # Modifica la variable global
print("Dentro de la función:", variable\_global)
funcion\_global()
print("Fuera de la función:", variable\_global)
```
\### 2. Closures
Los closures son funciones anidadas que recuerdan el entorno en el que fueron creadas, incluso si su función contenedora ha terminado de ejecutarse. Esto es útil para crear funciones que mantienen el estado entre llamadas.
\#### Ejemplo de Closure
```python
def crear\_multiplicador(factor):
def multiplicar(numero):
return numero \* factor # factor es una variable no local
return multiplicar
multiplicador\_por\_2 = crear\_multiplicador(2)
print(multiplicador\_por\_2(5)) # Salida: 10
multiplicador\_por\_3 = crear\_multiplicador(3)
print(multiplicador\_por\_3(5)) # Salida: 15
```
En este ejemplo:
\- `crear\_multiplicador` es una función que devuelve otra función (`multiplicar`).
\- `multiplicar` recuerda el valor de `factor` incluso después de que `crear\_multiplicador` ha terminado de ejecutarse.
\- Cada vez que se llama a `multiplicador\_por\_2` o `multiplicador\_por\_3`, se utiliza el valor de `factor` que se pasó cuando se creó el closure.
\### Resumen de Alcance y Closures
\- \*\*Alcance\*\*: Define donde una variable puede ser accedida (local, global, etc.).
\- Las \*\*variables locales\*\* solo se pueden usar dentro de la función donde fueron declaradas.
\- Las \*\*variables globales\*\* se pueden usar en cualquier parte del código.
\- \*\*Closures\*\*: Permiten que una función "recuerde" el entorno en el que fue creada, manteniendo el acceso a variables no locales (que no están definidas dentro de ella) a través de su estado interno.
Estos conceptos son fundamentales para entender cómo funcionan las funciones en Python y cómo se puede gestionar el estado y la visibilidad de las variables en el código.
Mi solución al reto:
```python
empleados = [
{'name': 'Iris', 'age': '43', 'salary': 100},
{'name': 'Ivan', 'age': '45', 'salary': 200},
{'name': 'Andres', 'age': '25', 'salary': 300},
{'name': 'Nohelia', 'age': '21', 'salary': 400},
{'name': 'Samuel', 'age': '27', 'salary': 500 },
{'name': 'David', 'age': '33', 'salary': 600 },
{'name': 'Sarahi', 'age': '30', 'salary': 700},
{'name': 'Jesus', 'age': '54', 'salary': 800},
{'name': 'Haydee', 'age': '34', 'salary': 900},
{'name': 'Francisco', 'age': '43', 'salary': 1000}
] # Variable global
def empleados_con_mejor_sueldo(empleados,sueldo):
empleados_superan_sueldo = [] # Variable local
empleados_superan_sueldo = [empleado["name"] for empleado in empleados if empleado["salary"]>= sueldo]
return empleados_superan_sueldo
sueldo = 800
print(f'Los empleados con suledo superior a {sueldo} son: {empleados_con_mejor_sueldo(empleados, sueldo)}')
```
RETO: Aquí va una posible solución al reto. Sigo trabajando en el principio de simplicidad y eficiencia del código, así que a seguir!!!
```python
# -------- RETO --------
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 paid_employees(employees):
"""
Busca los mejores empleados en el diccionario y los guarda en una lista
Input: Lista de diccionarios de los empleados
Output: Empleados con mejor pago
"""
best_paid = []
for i in employees:
if i['salary'] > 3000:
best_paid.append(i['name']) # guarda los nombres de los mejores pagos en la lista
best_paid.sort()
print(f'Los empleados que más ganan son {best_paid}')
paid_employees(employees)
```
Como la practica es importante estaba practicando y me dio por crear algo simple pero que entiende el concepto de **<u>GLOBAL</u>** de manera correcta
**CODE:**
```python
x = int(input("Elige un numero para cambiarlo: ")) #Solicito un numero
print(f"Tu numero elegido fue {x} ")# Imprimo el numero solicitado
def modify_var(): #va a modificar el numero pedido
print("Actualizacion de numero ")
global x #Llama la variable global
x = int(input("Nuevo numero que quieres: ")) #La global cambia su valor al nuevo dato pedido
print(f"Tu nuevo numero es : {x}") #Imprime la variable global
modify_var() #llamo la funcion de modificar numero
```
**RETO CUMPLIDO 💚:**
**CODIGO:**
```python
#Crear dos funciones una con una lista de diccionarios
#la otra funcion deve cevovler la lista de empleados que ganen cierto sueldo
#Variable local , con los datos de empleados
empl = [
{'name': 'Juan', 'age': 17, 'Salario': 2000},
{'name': 'Lucia', 'age': 27, 'Salario': 8000},
{'name': 'Marta', 'age': 57, 'Salario': 20000}
]
def empleados():
trabajdores = empl #Trae la variable con los datos
def mejor_sueldo(): #Modifica los datos locales de empleados
nonlocal trabajdores #Modifica la variable local
trabajdores = [p for p in trabajdores if p['Salario'] > 3000] #Da una lista con los que ganan mas de 3000
print(trabajdores) #Me imprime los mejroes pagados
mejor_sueldo() #Ejectua la subfuncion cuando se llame la funcion empleados
empleados() #Empieza a cargar el codigo que hay dentro
```
🎓 **Variables Locales y Globales en Python** 🐍
En programación, especialmente en Python, es súper importante entender la diferencia entre **variables locales** y **variables globales**, ya que afectan directamente cómo funciona tu código.
🔹 **Variable Global**
Es una variable que se declara **fuera de cualquier función** y puede ser usada **en cualquier parte del programa**.
🔹 **Variable Local**
Es una variable que se declara **dentro de una función** y **solo existe dentro de ella**.
**PLUS 🚀:**
**1.** Lo **local** se queda en su casita (la función).
**2.** Lo **global** puede salir y ser visto por todos.
**3.** Si usas una variable global **dentro de una función y quieres modificarla**, debes usar la palabra clave `global`
```js
empleados = [
{"nombre":"Kmilo",
"edad": 32,
"salario": 1000000},
{"nombre":"Carlos",
"edad": 32,
"salario": 40000},
{"nombre":"Luis",
"edad": 32,
"salario": 3000},
{"nombre":"Oscar",
"edad": 32,
"salario": 300000}
]
#print(v_madid[{"nombre"}])
def buscar_emple(salario_pro):
madid = [x["nombre"] for x in empleados if x["salario"]>salario_pro]
print(f'los empleados con el salario mayor a {salario_pro} son {madid}')
buscar_emple(50000)
```empleados = \[ {"nombre":"Kmilo", "edad": 32, "salario": 1000000}, {"nombre":"Carlos", "edad": 32, "salario": 40000}, {"nombre":"Luis", "edad": 32, "salario": 3000}, {"nombre":"Oscar", "edad": 32, "salario": 300000}]
\#print(v\_madid\[{"nombre"}])*def* buscar\_emple(*salario\_pro*): madid = \[x\["nombre"] for x in empleados if x\["salario"]>*salario\_pro*] print(*f*'los empleados con el salario mayor a {*salario\_pro*} son {madid}')
buscar\_emple(50000)
`def outer_function():`
`x = 'enclosing'`
`print(x)`
`def inner_function():`
`x='local'`
`print(x)`
`outer_funtion()`
```js
def funtion ()
```
Aquí va mi aporte. Me pareció súper interesante que pude explorar con diferentes maneras de imprimir la info. En la terminal pueden ver los diferentes formatos.
![]()
```js
employeers = [
{'name': 'Yesica', 'age': 27, "salary": 5000},
{'name': 'Santiago', 'age': 28, "salary": 4000},
{'name': 'Maria Ofelia', 'age': 30, "salary": 2200},
{'name': 'Yesica', 'age': 15, "salary": 3000}
]
def maximum_salary(employeers):
"""
Determina cuales empleados tienen mejor salario
"""
max_salary =[]
for i in employeers:
if i['salary'] >= 4000:
max_salary.append(i['name'])
print(f"Los empleados que mas ganan son: {max_salary}")
maximum_salary(employeers)
```employeers = \[ {'name': 'Yesica', 'age': 27, "salary": 5000}, {'name': 'Santiago', 'age': 28, "salary": 4000}, {'name': 'Maria Ofelia', 'age': 30, "salary": 2200}, {'name': 'Yesica', 'age': 15, "salary": 3000} ]
def maximum\_salary(employeers): """ Determina cuales empleados tienen mejor salario
""" max\_salary =\[] for i in employeers: if i\['salary'] >= 4000: max\_salary.append(i\['name']) print(f"Los empleados que mas ganan son: {max\_salary}")
maximum\_salary(employeers)
```python
employees = [
{"name": "Alice", "age": 30, "salary": 50000},
{"name": "Bob", "age": 25, "salary": 45000},
{"name": "Charlie", "age": 35, "salary": 60000},
{"name": "Diana", "age": 28, "salary": 48000},
{"name": "Ethan", "age": 40, "salary": 75000}
]
def firtsclasss():
return list (filter(lambda employe: employe['salary'] >= 60000, employees))
print(f'Ellos don el 1% de la poblacion: {firtsclasss()}')
```Mi pequeño aporte
```js
empleados = {
"empleado1": {
"nombre": "Carlos",
"edad": 28,
"salario": 3500
},
"empleado2": {
"nombre": "Laura",
"edad": 34,
"salario": 4200
},
"empleado3": {
"nombre": "Miguel",
"edad": 45,
"salario": 5000
}
}
salario_minimo = [empleado for empleado, datos in empleados.items() if datos["salario"] >= 4000]
print(salario_minimo)
#En el bucle, empleado recibe el nombre de la clave que es empleado1 o el 2 o el 3 y dato recibe la informacion que contiene cada clave, como nombre edad y salario y EMPLEADOS.ITEMS() recibe las dos cosasa al tiempo
```empleados = { "empleado1": { "nombre": "Carlos", "edad": 28, "salario": 3500 }, "empleado2": { "nombre": "Laura", "edad": 34, "salario": 4200 }, "empleado3": { "nombre": "Miguel", "edad": 45, "salario": 5000 }}
salario\_minimo = \[empleado for empleado, datos in empleados.items() if datos\["salario"] >= 4000]print(salario\_minimo)
\#En el bucle, empleado recibe el nombre de la clave que es empleado1 o el 2 o el 3 y dato recibe la informacion que contiene cada clave, como nombre edad y salario y EMPLEADOS.ITEMS() recibe las dos cosasa al tiempo
revisando los comentarios copie este ejemplo que es el que resuelve literalmente el reto,
salario\_referencia = 3500 #variable global
def outer\_funtion(lista\_empleados): x = \[] #variable local def inner\_funtion(): for row in lista\_empleados: if row \['salary']> salario\_referencia: x.append(row) return x inner\_funtion() for mejor\_pagos in x: print(mejor\_pagos)
outer\_funtion(\[ {"name": "Juan", "age": 30, "salary": 3000}, {"name": "Ana", "age": 26, "salary": 4500}, {"name": "Luis", "age": 28, "salary": 5000,}, {"name": "Marta", "age": 32, "salary": 4000}, {"name": "Carlos", "age": 35, "salary": 5000}, {"name": "Sofía", "age": 25, "salary": 3800}, {"name": "Pedro", "age": 31, "salary": 3500}, {"name": "Laura", "age": 24, "salary": 4500}, {"name": "Elena", "age": 33, "salary": 3200}, {"name": "David", "age": 29, "salary": 4000}])
aqui el codigo del reto y su resultado
empleados = \[ {"name": "Juan", "age": 30, "salary": 3000}, {"name": "Ana", "age": 26, "salary": 4500}, {"name": "Luis", "age": 28, "salary": 5000,}, {"name": "Marta", "age": 32, "salary": 4000}, {"name": "Carlos", "age": 35, "salary": 5000}, {"name": "Sofía", "age": 25, "salary": 3800}, {"name": "Pedro", "age": 31, "salary": 3500}, {"name": "Laura", "age": 24, "salary": 4500}, {"name": "Elena", "age": 33, "salary": 3200}, {"name": "David", "age": 29, "salary": 4000}]def empleados\_mejor\_pagados(empleados): """funcion para seleccionar los empleados que ganan mas de 3500""" print("Empleados con salario mayor a 3500:","\n") mejor\_pagados = \[empleado for empleado in empleados if empleado\["salary"] >= 3500] print(mejor\_pagados) empleados\_mejor\_pagados(empleados)
resultado:
Empleados con salario mayor a 3500:
\[{'name': 'Ana', 'age': 26, 'salary': 4500}, {'name': 'Luis', 'age': 28, 'salary': 5000}, {'name': 'Marta', 'age': 32, 'salary': 4000}, {'name': 'Carlos', 'age': 35, 'salary': 5000}, {'name': 'Sofía', 'age': 25, 'salary': 3800}, {'name': 'Pedro', 'age': 31, 'salary': 3500}, {'name': 'Laura', 'age': 24, 'salary': 4500}, {'name': 'David', 'age': 29, 'salary': 4000}]
Creo que fuera mas claro si el ejemplo lo fuera dejado de esta forma.x = 100
def local\_function(): x = 10 print(f'El valor de la variable local es: {x}')
def show\_global(): print(f'El valor de la variable global es: {x}')
local\_function()show\_global()print('Global:', x)
```js
x = 100
def local_function():
x = 10
print(f'El valor de la variable local es: {x}')
def show_global():
print(f'El valor de la variable global es: {x}')
local_function()
show_global()
print('Global:', x)
```Así puedes notar al llamar la función con la variable local no afecta la variable global aunque se este llamando antes.
Resultado:
`El valor de la variable local es: 10`
`El valor de la variable global es: 100`
`Global: 100`
```python
employees = [{"name":"Adriana","age": 27, "salary": 3000},
{"name":"Luis","age": 34, "salary": 1000},
{"name":"Abel","age": 27, "salary": 4000}]
limite_salary = 2000
def filter_salary(list_employees:list, salary:int):
return [emp for emp in list_employees if emp['salary'] > salary]
print(f'La lista de empleados que ganan mas de {limite_salary} son: {filter_salary(employees, limite_salary)}')
```
Con gusto te explico el concepto de `nonlocal` en Python.
La palabra clave `nonlocal` es similar a `global`, pero se utiliza en un contexto diferente. Mientras que `global` te permite acceder y modificar variables definidas en el ámbito global (fuera de todas las funciones), `nonlocal` te permite acceder y modificar variables definidas en un ámbito exterior pero no global (es decir, en una función contenedora).
`nonlocal` es especialmente útil cuando trabajas con funciones anidadas (funciones definidas dentro de otras funciones).
Ejemplo básico:
```js
def funcion_externa():
x = 10 # Variable en el ámbito de funcion_externa
def funcion_interna():
nonlocal x # Indica que queremos usar la x de funcion_externa, no crear una local
x = 20 # Modifica la x de funcion_externa
print(f"Valor de x dentro de funcion_interna: {x}")
print(f"Valor de x antes de llamar a funcion_interna: {x}")
funcion_interna()
print(f"Valor de x después de llamar a funcion_interna: {x}")
funcion_externa()
#Valor de x antes de llamar a funcion_interna: 10
#Valor de x dentro de funcion_interna: 20
#Valor de x después de llamar a funcion_interna: 20
```### Explicación detallada:1. `nonlocal` busca la variable en el ámbito inmediatamente exterior (la función que contiene a la función actual).
2. Si no encuentra la variable ahí, busca en el siguiente ámbito exterior, y así sucesivamente.
3. No busca en el ámbito global - para eso deberías usar `global`.
4. Si no encuentra la variable en ningún ámbito exterior (excepto el global), Python generará un error.### Diferencias importantes entre `nonlocal` y `global`:1. `global` siempre se refiere a variables en el ámbito global (nivel superior del módulo).
2. `nonlocal` se refiere a variables en ámbitos externos, pero no globales.
3. `nonlocal` no puede crear variables nuevas, mientras que `global` sí puede.
Fuente: claude.ai
My Solution!!
```js
# Ejemplo de lista de diccionarios
empleados = [
{"name": "Ana", "age": 28, "salary": 3500},
{"name": "Luis", "age": 35, "salary": 4500},
{"name": "Carlos", "age": 40, "salary": 3000},
{"name": "María", "age": 30, "salary": 5000},
]
# Función que filtra empleados con salario mayor a un cierto límite
def filtrar_empleados_por_salario(lista_empleados, salario_minimo):
return [empleado for empleado in lista_empleados if empleado["salary"] > salario_minimo]
# Probar la función
salario_minimo = 4000
resultado = filtrar_empleados_por_salario(empleados, salario_minimo)
print(resultado)
```
```js
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 filter_employees():
"""
Filter employees with a salary greater than 4000
return: List of employees with salary greater than 4000
"""
global employees
return [emp for emp in employees if emp['salary'] > 4000]
def filter_employees():
global employees
return [emp for emp in employees if emp['salary'] > 4000]
filtered_employees = filter_employees()
print(filtered_employees)
```
Mi aporte: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 filter\_employees(): """ Filter employees with a salary greater than 4000 return: List of employees with salary greater than 4000 """ global employees return \[emp for emp in employees if emp\['salary'] > 4000]def filter\_employees(): global employees return \[emp for emp in employees if emp\['salary'] > 4000]
filtered\_employees = filter\_employees()print(filtered\_employees)
```js
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 filter_employees():
"""
Filter employees with a salary greater than 4000
return: List of employees with salary greater than 4000
"""
global employees
return [emp for emp in employees if emp['salary'] > 4000]
def filter_employees():
global employees
return [emp for emp in employees if emp['salary'] > 4000]
filtered_employees = filter_employees()
print(filtered_employees)
```
Mi aporte:
```js
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},
]
# Funcion para devolver una lista de empleados con un salario mayor a 4000 con variables locales y globales
def filter_employees():
global employees
return [emp for emp in employees if emp['salary'] > 4000]
filtered_employees = filter_employees()
print(filtered_employees)
```
```python
data = [
{ 'name':'juan',
'salary': 12000,
'age': 30 },
{'name':'jose',
'salary': 14000,
'age': 28},
{'name':'maria',
'salary': 20000,
'age': 24}
]
def salary_tall(person):
if person['salary'] > 11000:
print(f" el salario de {person['name']} es mayor ")
else:
print('no gana lo sufciiente')
for person in data:
salary_tall(person)
```
Mi reto:
```js
employees = [
{'name': 'John', 'age': 30, 'salary': 50000},
{'name': 'Jane', 'age': 25, 'salary': 60000},
{'name': 'Jim', 'age': 35, 'salary': 70000},
{'name': 'Jill', 'age': 28, 'salary': 55000},
]
def get_employees_salary(employees, salary):
employees_salary = []
for employee in employees:
if employee['salary'] > salary:
employees_salary.append(employee)
return employees_salary
print(get_employees_salary(employees, 55000))
```
le dije a chat GPT que haga una lista mas extensa para diferenciarme un poquito =D
recomiendo no prestarle atención a los nombres de las variables.
esta es la salida:
```js
employees = [
{"name": "Alice", "age": 30, "salary": 50000},
{"name": "Bob", "age": 25, "salary": 45000},
{"name": "Charlie", "age": 35, "salary": 60000}
]
limit_salary = 50000
def get_limit_salary(employees):
employees2 =[]
for row in employees:
if analyze_salary(row['salary']):
employees2.append(row)
print(employees2)
def analyze_salary(salary):
if salary >= limit_salary:
return True
return False
get_limit_salary(employees)
```mi solucion al reto
```python
employees = [
{"name": "John", "age": 30, "salary": 50000},
{"name": "Jane", "age": 25, "salary": 60000},
{"name": "Bob", "age": 35, "salary": 70000},
{"name": "Alice", "age": 28, "salary": 55000},
]
def filter_by_salary(employees, salary):
employees = [emp for emp in employees if emp["salary"] > salary]
# This is a local variable
print(employees)
return employees
filter_by_salary(employees, 60000)
# This is a global variable
print(employees)
```
```python
# Variable global para almacenar la lista de empleados
empleados = []
def establecer_empleados(lista_empleados):
"""
Esta función recibe una lista de diccionarios, cada uno representando un empleado con claves:
"nombre", "edad" y "salario", y la asigna a la variable global 'empleados'.
"""
global empleados # Indicamos que modificamos la variable global
empleados = lista_empleados
def filtrar_por_salario(salario_minimo):
"""
Esta función analiza la lista global de empleados y devuelve aquellos que ganan más del salario indicado.
Usa una variable local 'resultado' para almacenar los empleados que cumplen la condición.
"""
# Variable local para almacenar el resultado
resultado = [empleado for empleado in empleados if empleado.get("salario", 0) > salario_minimo]
return resultado
# Ejemplo de uso:
datos_empleados = [
{"nombre": "Alice", "edad": 30, "salario": 5000},
{"nombre": "Bob", "edad": 25, "salario": 4000},
{"nombre": "Charlie", "edad": 28, "salario": 6000},
{"nombre": "Diana", "edad": 32, "salario": 4500},
{"nombre": "Andrea", "edad": 33, "salario": 4000},
{"nombre": "Paulina", "edad": 35, "salario": 5000}
]
# Establecer la lista de empleados en la variable global
establecer_empleados(datos_empleados)
# Filtrar y mostrar los empleados que ganan más de 4500
empleados_filtrados = filtrar_por_salario(4500)
print("Empleados que ganan más de 4500:")
for emp in empleados_filtrados:
print(emp)
```
```python
def info():
number_employee = int(input("Ingrese el número de empleados a registrar: "))
counter = 0
list_employees = []
while counter < number_employee:
name = input("Ingrese nombre: ")
age = int(input("Ingrese edad: "))
salary = float(input("Ingrese salario: "))
employee = {"name": name, "age": age, "salary": salary}
list_employees.append(employee)
counter = counter + 1
def filter_employee():
search = float(input("Ingrese el salario de busqueda: "))
filter_list = [employee["name"] for employee in list_employees if employee["salary"] >= search]
print(filter_list)
filter_employee()
info()
```def info(): number\_employee = int(input("Ingrese el número de empleados a registrar: ")) counter = 0 list\_employees = \[]
while counter < number\_employee: name = input("Ingrese nombre: ") age = int(input("Ingrese edad: ")) salary = float(input("Ingrese salario: ")) employee = {"name": name, "age": age, "salary": salary} list\_employees.append(employee) counter = counter + 1 print(list\_employees)
def filter\_employee(): search = float(input("Ingrese el salario de busqueda: ")) filter\_list = \[employee\["name"] for employee in list\_employees if employee\["salary"] >= search] print(filter\_list)
filter\_employee()
info()
```js
# Primera función: recibe la información de los empleados
def recibir_informacion_empleados(diccionario_empleados):
empleados = []
for clave, valor in diccionario_empleados.items():
empleados.append(valor)
return empleados
# Segunda función: analiza los empleados y devuelve aquellos que ganan un cierto monto
def empleados_con_salario_superior(empleados, monto):
empleados_filtrados = [empleado for empleado in empleados if empleado["salario"] >= monto]
return empleados_filtrados
# Ejemplo de uso
diccionario_empleados = {
1: {"nombre": "Juan", "edad": 30, "salario": 50000},
2: {"nombre": "María", "edad": 25, "salario": 60000},
3: {"nombre": "Pedro", "edad": 35, "salario": 40000}
}
empleados = recibir_informacion_empleados(diccionario_empleados)
monto = 50000
empleados_filtrados = empleados_con_salario_superior(empleados, monto)
print("Empleados que ganan {} o más:".format(monto))
for empleado in empleados_filtrados:
print(empleado)
```
```python
empleados = [
{'name': 'Luis','age': 28,'salary': 10000},
{'name': 'Maria','age': 21,'salary': 14000},
{'name': 'Jose','age': 30,'salary': 15000}
]
def filter_empleados():
''' 1. Debo crear una función que reciba una lista de diccionarios, Cada diccionario tendra las claves:
'name', 'age' y 'salary'
2. Crear una función que devuelva una lista de empleados que ganen más dinero de un cierto sueldo'''
global empleados
salario_base = int(input('Ingresa salario base a filtrar: '))
empleados_filtrados = [empleado for empleado in empleados if empleado['salary'] >= salario_base]
if empleados_filtrados:
print(f'Los empleados con sueldo mayor a {salario_base} son:')
for empleado in empleados_filtrados:
print(f'{empleado['name']} cuenta con un sueldo de $COP {empleado['salary']}')
else:
print(f'No hay empleados con salarios superiores a $COP {salario_base}')
filter_empleados()
```
```js
empleados = [
{
'nombre': 'Juan',
'edad' : 32,
'salario': 6000000
},
{
'nombre': 'Felipe',
'edad' : 46,
'salario': 12000000
},
{
'nombre': 'Carolina',
'edad' : 34,
'salario': 5000000
},
{
'nombre': 'Cindy',
'edad' : 30,
'salario': 15000000
}
]
salario_filtro = int(input("Ingresa el salario por el cual quieres filtrar a los empleados: "))
#definir la función para filtar, la cual usará dos parámetros de entrada definidos anteriormente:
def salary_filter(empleados,salario_filtro):
empleados = list(filter(lambda item: item['salario'] > salario_filtro, empleados))
return empleados
empleados = salary_filter(empleados,salario_filtro)
print(f'los empleados que tienen el salario superior a {salario_filtro} son: {empleados}')
```
x='global' # global variable
\#Funcion externadef outer\_function(): x='ENCLOSING' #Funcion interna def inner\_function(): x='LOCAL' # variable local print(f'El valor de la variable 1 es {x}')
inner\_function() print(f'El valor de la variable 2 es {x}')
outer\_function()print(f'El valor 3 es : {x}')
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 paid\_employees(employees): best\_paid = sorted(\[i\['name'] for i in employees if i\['salary'] > 3000]) print(f'Los empleados que más ganan son {best\_paid}')
paid\_employees(employees)
El reto:
```python
empleados = [
{'name': 'Luis','age': 28,'salary': 10000},
{'name': 'Maria','age': 21,'salary': 14000},
{'name': 'Jose','age': 30,'salary': 15000}
]
def lista_empleados(empleados):
"""
Imprime una lista de empleados y solicita un salario superior
"""
for empleado in empleados:
print(f"Nombre: {empleado['name']} - Edad: {empleado['age']} - Salario {empleado['salary']}")
salario_superior(empleados)
def salario_superior(empleados):
"""
Evalúa el salario superior de los empleados e imprime los superiores al valor
"""
salario_maximo = int(input(f"Ingrese un salario máximo: "))
personas_filtadas = [
empleado for empleado in empleados
if empleado['salary']>= salario_maximo
]
if personas_filtadas:
print(f"\n Personas con salario >= {salario_maximo}")
for persona in personas_filtadas:
print(f"Nombre: {persona['name']} - Edad: {persona['age']} - Salario {persona['salary']}")
else:
print(f"No hay empleados con ese valor de salarios")
lista_empleados(empleados)
```
```js
#Variables locales y globales
print()
print("* Ejercicio 1:")
print("- Variables locales y globales:")
print()
y = 100 #Variable global
def funcion_local():
x = 10 #Variable local
print(f"El valor de la variable local x es { x }")
print(f"El valor de la variable global y es { y }")
funcion_local()
```*#Variables locales y globales*print()print("\* Ejercicio 1:")print("- Variables locales y globales:")print()
y = 100 *#Variable global*
def funcion\_local(): x = 10 *#Variable local* print(f"El valor de la variable local x es { x }") print(f"El valor de la variable global y es { y }")
funcion\_local()
```python
salarys = [
{ "name": 'John', "salary": 1000, "age": 25 },
{ "name": 'Jane', "salary": 1500, "age": 30 },
{ "name": 'Tom', "salary": 2000, "age": 35 },
{ "name": 'Sam', "salary": 2500, "age": 30 },
{ "name": 'Jerry', "salary": 2500, "age": 40 },
{ "name": 'Alice', "salary": 2500, "age": 20 },
{ "name": 'Bob', "salary": 3000, "age": 45 },
{ "name": 'Charlie', "salary": 3500, "age": 50 },
{ "name": 'David', "salary": 4000, "age": 55 },
{ "name": 'Eve', "salary": 4500, "age": 60 },
{ "name": 'Frank', "salary": 5000, "age": 65 },
]
def get_salarys(salary: int, salarys: list):
"""Obtiene las personas que tienen un salario mayor o igual al salario recibido.
Args:
salary (int)
salarys (list)
Returns:
list: Lista con las personas que tienen un salario mayor o igual al salario recibido.
"""
return [person for person in salarys if person['salary'] >= salary]
print(get_salarys(4000, salarys)) # [{'name': 'David', 'salary': 4000, 'age': 55}, {'name': 'Eve', 'salary': 4500, 'age': 60}, {'name': 'Frank', 'salary': 5000, 'age': 65}]
```💥
```python
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},
]
"""
Parameters:
dict: list,
salary: int
Retorna:
list: Lista de empleados cuyo salario es mayor al salario ingresado
"""
def get_employees(dict, salary):
return list(filter(lambda x: x["salary"] > salary, dict))
search_salary = int(input("Ingrese el salario a buscar: "))
print(f'\n {get_employees(employees, search_salary)}')
```
```js
empleados = [
{'name': 'Juan', 'age': 31, 'salary': 3000},
{'name': 'Miguel', 'age': 31, 'salary': 4020},
{'name': 'Carlos', 'age': 31, 'salary': 4500},
{'name': 'Antonio', 'age': 31, 'salary': 2200}
]
def filtrar(empleados):
empleados_filtrados = []
for empleado in empleados:
if empleado['salary'] > 4000:
empleados_filtrados.append(empleado)
for emp_filtrado in empleados_filtrados:
print(f"Nombre: {emp_filtrado['name']}, sueldo: {emp_filtrado['salary']}")
print("Los empleados con un sueldo mayor a 4000 son:")
filtrar(empleados)
```empleados = \[ {'name': 'Juan', 'age': 31, 'salary': 3000}, {'name': 'Miguel', 'age': 31, 'salary': 4020}, {'name': 'Carlos', 'age': 31, 'salary': 4500}, {'name': 'Antonio', 'age': 31, 'salary': 2200}]
def filtrar(empleados): empleados\_filtrados = \[] for empleado in empleados: if empleado\['salary'] > 4000: empleados\_filtrados.append(empleado) for emp\_filtrado in empleados\_filtrados: print(f"Nombre: {emp\_filtrado\['name']}, sueldo: {emp\_filtrado\['salary']}")
print("Los empleados con un sueldo mayor a 4000 son:")filtrar(empleados)
```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": "232", "Salary": "3000"}]
#Hayar el dato máximo y el mínimo de los salarios:
salaries = [int(person["Salary"]) for person in people]
employees = [person["name"] for person in people]
max_salary = max (salaries)
min_salary = min(salaries)
#Encontrar empleados con salario concreto
def find_employees_by_salary (people, salary):
return [person["name"] for person in people if int(person ["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}")
```
```js
# Variable global para almacenar el resultado
resultado_global = []
def lista_empleados(list_dict: list[dict]):
"""
Filtra a los empleados con salario mayor o igual a 3,000.
Recibe una lista de diccionarios con la clave 'name', 'age', y 'salary'.
:param list_dict: Lista de diccionarios con datos de empleados
:return: Lista de empleados con salarios mayores o iguales a 3,000
"""
resultado_local = [] # Variable local para almacenar los empleados filtrados
def salarios_altos(dict_1: dict):
"""
Comprueba si el salario del empleado es mayor o igual a 3,000.
:param dict_1: Diccionario con los datos del empleado
:return: El diccionario del empleado si cumple la condición
"""
nonlocal resultado_local # Para acceder a la variable local de la función exterior
if dict_1["salary"] >= 3000:
resultado_local.append(dict_1)
# Iterar sobre la lista de empleados y aplicar el filtro
for empleado in list_dict:
salarios_altos(empleado)
# Actualizar la variable global con el resultado local
global resultado_global
resultado_global = resultado_local
return resultado_local
# Lista de empleados para prueba
empleados = [
{"name": "Juan", "age": 28, "salary": 4000},
{"name": "Ana", "age": 32, "salary": 2500},
{"name": "Luis", "age": 45, "salary": 3500},
{"name": "Maria", "age": 25, "salary": 2900}
]
# Llamar a la función y obtener el resultado
resultado = lista_empleados(empleados)
# Imprimir los empleados con salarios mayores a 3,000
print("Empleados con salarios mayores o iguales a 3,000:")
for emp in resultado:
print(emp)
# Verificar que la variable global también contiene el resultado
print("\nContenido de la variable global:", resultado_global)
```# Variable global para almacenar el resultado
resultado\_global = \[]
def lista\_empleados(list\_dict: list\[dict]):
"""
Filtra a los empleados con salario mayor o igual a 3,000.
Recibe una lista de diccionarios con la clave 'name', 'age', y 'salary'.
:param list\_dict: Lista de diccionarios con datos de empleados
:return: Lista de empleados con salarios mayores o iguales a 3,000
"""
resultado\_local = \[] # Variable local para almacenar los empleados filtrados
def salarios\_altos(dict\_1: dict):
"""
Comprueba si el salario del empleado es mayor o igual a 3,000.
:param dict\_1: Diccionario con los datos del empleado
:return: El diccionario del empleado si cumple la condición
"""
nonlocal resultado\_local # Para acceder a la variable local de la función exterior
if dict\_1\["salary"] >= 3000:
resultado\_local.append(dict\_1)
\# Iterar sobre la lista de empleados y aplicar el filtro
for empleado in list\_dict:
salarios\_altos(empleado)
\# Actualizar la variable global con el resultado local
global resultado\_global
resultado\_global = resultado\_local
return resultado\_local
\# Lista de empleados para prueba
empleados = \[
{"name": "Juan", "age": 28, "salary": 4000},
{"name": "Ana", "age": 32, "salary": 2500},
{"name": "Luis", "age": 45, "salary": 3500},
{"name": "Maria", "age": 25, "salary": 2900}
]
\# Llamar a la función y obtener el resultado
resultado = lista\_empleados(empleados)
\# Imprimir los empleados con salarios mayores a 3,000
print("Empleados con salarios mayores o iguales a 3,000:")
for emp in resultado:
print(emp)
\# Verificar que la variable global también contiene el resultado
print("\nContenido de la variable global:", resultado\_global)
Siguiendo las condiciones pedidas para el ejercicio, este es mi codigo, teniendo en cuenta las buenas practicas de programación:
\# Variable global para almacenar el resultado
resultado\_global = \[]
def lista\_empleados(list\_dict: list\[dict]):
"""
Filtra a los empleados con salario mayor o igual a 3,000.
Recibe una lista de diccionarios con la clave 'name', 'age', y 'salary'.
:param list\_dict: Lista de diccionarios con datos de empleados
:return: Lista de empleados con salarios mayores o iguales a 3,000
"""
resultado\_local = \[] # Variable local para almacenar los empleados filtrados
def salarios\_altos(dict\_1: dict):
"""
Comprueba si el salario del empleado es mayor o igual a 3,000.
:param dict\_1: Diccionario con los datos del empleado
:return: El diccionario del empleado si cumple la condición
"""
nonlocal resultado\_local # Para acceder a la variable local de la función exterior
if dict\_1\["salary"] >= 3000:
resultado\_local.append(dict\_1)
\# Iterar sobre la lista de empleados y aplicar el filtro
for empleado in list\_dict:
salarios\_altos(empleado)
\# Actualizar la variable global con el resultado local
global resultado\_global
resultado\_global = resultado\_local
return resultado\_local
\# Lista de empleados para prueba
empleados = \[
{"name": "Juan", "age": 28, "salary": 4000},
{"name": "Ana", "age": 32, "salary": 2500},
{"name": "Luis", "age": 45, "salary": 3500},
{"name": "Maria", "age": 25, "salary": 2900}
]
\# Llamar a la función y obtener el resultado
resultado = lista\_empleados(empleados)
\# Imprimir los empleados con salarios mayores a 3,000
print("Empleados con salarios mayores o iguales a 3,000:")
for emp in resultado:
print(emp)
\# Verificar que la variable global también contiene el resultado
print("\nContenido de la variable global:", resultado\_global)
```js
def filter_employees_by_salary(employees, min_salary):
return [employee for employee in employees if employee['salary'] > min_salary]
if __name__ == "__main__":
employees = [
{"name": "Ana", "age": 28, "salary": 3000},
{"name": "Luis", "age": 35, "salary": 4500},
{"name": "María", "age": 40, "salary": 2500},
{"name": "Juan", "age": 30, "salary": 4000},
]
min_salary = 3000
result = filter_employees_by_salary(employees, min_salary)
print("Empleados que ganan más de", min_salary, ":")
for emp in result:
print(emp)
```def filter\_employees\_by\_salary(employees, min\_salary): return \[employee for employee in employees if employee\['salary'] > min\_salary]
if \_\_name\_\_ == "\_\_main\_\_": employees = \[ {"name": "Ana", "age": 28, "salary": 3000}, {"name": "Luis", "age": 35, "salary": 4500}, {"name": "María", "age": 40, "salary": 2500}, {"name": "Juan", "age": 30, "salary": 4000}, ]
min\_salary = 3000 result = filter\_employees\_by\_salary(employees, min\_salary)
print("Empleados que ganan más de", min\_salary, ":") for emp in result: print(emp)
```js
empleado = [
{
"nombre": "Juan",
"edad": 25,
"salario": 1000,
},
{
"nombre": "Pedro",
"edad": 30,
"salario": 2000,
},
{
"nombre": "Maria",
"edad": 28,
"salario": 1500,
},
{
"nombre": "Ana",
"edad": 27,
"salario": 1800,
},
{
"nombre": "Luis",
"edad": 26,
"salario": 1700,
}
]
def filtrar_salario_menor_o_igual_a_1500():
"""
Filtra los empleados cuyo salario es menor o igual a 1500
"""
return [empleado_filtrado for empleado_filtrado in empleado if empleado_filtrado["salario"] <= 1500]
print(f"Los empleados cuyo salario es menor o igual a 1500 son: {filtrar_salario_menor_o_igual_a_1500()}")
def filtrar_salario_mayor_a_1500():
"""
Filtra los empleados cuyo salario es mayor a 1500
"""
return [empleado_filtrado for empleado_filtrado in empleado if empleado_filtrado["salario"] > 1500]
print(f"Los empleados cuyo salario es mayor a 1500 son: {filtrar_salario_mayor_a_1500()}")
```empleado = \[ { "nombre": "Juan", "edad": 25, "salario": 1000, }, { "nombre": "Pedro", "edad": 30, "salario": 2000, }, { "nombre": "Maria", "edad": 28, "salario": 1500, }, { "nombre": "Ana", "edad": 27, "salario": 1800, }, { "nombre": "Luis", "edad": 26, "salario": 1700, }]
def filtrar\_salario\_menor\_o\_igual\_a\_1500(): """ Filtra los empleados cuyo salario es menor o igual a 1500 """ *return* \[empleado\_filtrado *for* empleado\_filtrado *in* empleado *if* empleado\_filtrado\["salario"] <= 1500]
print(f"Los empleados cuyo salario es menor o igual a 1500 son: {filtrar\_salario\_menor\_o\_igual\_a\_1500()}")
def filtrar\_salario\_mayor\_a\_1500(): """ Filtra los empleados cuyo salario es mayor a 1500 """ *return* \[empleado\_filtrado *for* empleado\_filtrado *in* empleado *if* empleado\_filtrado\["salario"] > 1500]
print(f"Los empleados cuyo salario es mayor a 1500 son: {filtrar\_salario\_mayor\_a\_1500()}")
Listo
```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):
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))
```
clase muy importante! gracias
```js
#Lista de empreados:
empleados = [
{"name":"Ana", "age": 25, "salary":4000},
{"name":"Pedro", "age":30, "salary":5000},
{"name":"Cesar", "age":41,"salary":7000},
{"name":"Carmen", "age":35, "salary":3500}
]
#Lista de empeleados que ganan mas de 4999:
def empleados_salario_alto(empleados, sueldo):
lista_nueva = [] #variable local
lista_nueva = [x["name"] for x in empleados if x["salary"] > sueldo]
return lista_nueva
sueldo = 3000
print(f'Los empleados con sueldo superior a {sueldo} son: {empleados_salario_alto(empleados, sueldo)}')
#Forma mas larga:
def empleados_salario_alto1(lista):
lista_nueva=[]
for x in lista:
if x["salary"] > 3000:
y= x["name"]
lista_nueva.append(y)
#return lista_nueva
print(lista_nueva)
empleados_salario_alto1(empleados)
```#Lista de empreados:empleados = \[ {"name":"Ana", "age": 25, "salary":4000}, {"name":"Pedro", "age":30, "salary":5000}, {"name":"Cesar", "age":41,"salary":7000}, {"name":"Carmen", "age":35, "salary":3500}]
\#Debera analizar este salario y devolver la lsta # de empeados que ganen mas de un cierto sueldo
\#Lista de empeleados que ganan mas de 4999:
*def* empleados\_salario\_alto(*empleados*, *sueldo*): lista\_nueva = \[] #variable local lista\_nueva = \[x\["name"] for x in empleados if x\["salary"] > sueldo] return lista\_nueva
sueldo = 3000print(*f*'Los empleados con sueldo superior a {sueldo} son: {empleados\_salario\_alto(empleados, sueldo)}')
\#la x pasa a ser i del for o cada item de la lista. puedo llamar valores con x"lo q defini
\#Forma mas larga:*def* empleados\_salario\_alto1(*lista*): lista\_nueva=\[] for x in lista: if x\["salary"] > 3000: y= x\["name"] lista\_nueva.append(y) #return lista\_nueva print(lista\_nueva)
empleados\_salario\_alto1(empleados)
Dejo mi version por aqui:
```python
employees = [
{
"name": "John Doe",
"age": 30,
"salary": 1000
},
{
"name": "Jane Doe",
"age": 25,
"salary": 900
},
{
"name": "Bob Smith",
"age": 35,
"salary": 1500
},
{
"name": "Alice Johnson",
"age": 40,
"salary": 2000
}
]
MIN_SALARY = 999
def outer_function(dicts_list):
def show_employees_who_earn_more_than():
nonlocal dicts_list
dicts_list = [x for x in dicts_list if x["salary"] > MIN_SALARY]
show_employees_who_earn_more_than()
print(f"expensive_employees: {dicts_list}")
outer_function(employees)
```
```python
#1.La funcion recibira una lista de diccionarios.
#2.-La funcion debe devolver una lista de empleados que ganen mas de un cierto sueldo
def empleados_con_sueldo_mayor_a(empleados,sueldo_minimo):
"""Devuelve una lista de empleados que ganen mas de un cierto sueldo.
Args:
empleados (list): Lista de empleados. Cada empleado es
un diccionario con las claves 'name', 'age' y 'salary'.
sueldo_minimo (float):
Sueldo minimo para considerar a un empleado en la lista.
Returns:
list: Lista de empleados que ganen mas de 'sueldo_minimo'."""
# Filtramos la lista de empleados para obtener solo aquellos que ganen mas de 'sueldo_minimo'
empleados_filtrados = [empleado for empleado in empleados if empleado['salary'] > sueldo_minimo]
return empleados_filtrados
# Ejemplo de uso
empleados = [
{'name': 'Juan', 'age': 30, 'salary':50000},
{'name': 'Maria', 'age':25, 'salary':60000},
{'name': 'Pedro', 'age':40, 'salary':40000},
{'name': 'Ana', 'age':35, 'salary':70000}]
sueldo_minimo = 55000
empleados_ricos = empleados_con_sueldo_mayor_a(empleados,sueldo_minimo)
print(empleados_ricos)
```
Me tomo un poco de tiempo ya que no estaba haciendo bien el Diccionario, pero a la final pude lograrlo
![]()
\# Variable globalsalary\_threshold = 50000 # Umbral de salario para filtrar empleados
def filter\_high\_salary\_employees(employees): """ Filtra empleados que ganen más del salario definido en la variable global salary\_threshold.
Args: employees (list of dict): Lista de diccionarios con claves "name", "age", y "salary".
Returns: list of dict: Lista de empleados que cumplen con el criterio de salario. """ # Accediendo a la variable global global salary\_threshold
# Variable local: empleados filtrados high\_salary\_employees = \[employee for employee in employees if employee\["salary"] > salary\_threshold]
return high\_salary\_employees
\# Ejemplo de usoemployees\_data = \[ {"name": "Alice", "age": 30, "salary": 60000}, {"name": "Bob", "age": 25, "salary": 45000}, {"name": "Charlie", "age": 35, "salary": 70000}, {"name": "Diana", "age": 28, "salary": 48000},]
\# Llamada a la funciónresult = filter\_high\_salary\_employees(employees\_data)
\# Imprimir resultadosprint("Empleados con salarios altos:")for employee in result:
Manage lo que hasta ahora se ha aprendido, no vi la necesidad de comentarios.from typing import TypedDict, List
class Employe(TypedDict): name: str age: int salary: float employees: List\[Employe] = \[ {"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 top\_salary\_employe() -> None: """Funcion para listar los empleados que ganan mas de 36000 """ ref\_salary: int = 3600 def filter\_salary() -> List\[Employe]: """Funcion encargada de filtrar los empleados
Returns: list\[Employe]: Lista de empleados donde ganan mas 36000 """ return \[employe for employe in employees if employe\["salary"] > ref\_salary] print(f"Los empleados que tienen mas salario: {filter\_salary()}") top\_salary\_employe()
```js
from typing import TypedDict, List
class Employe(TypedDict):
name: str
age: int
salary: float
employees: List[Employe] = [
{"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 top_salary_employe() -> None:
"""Funcion para listar los empleados que ganan mas de 36000
"""
ref_salary: int = 3600
def filter_salary() -> List[Employe]:
"""Funcion encargada de filtrar los empleados
Returns:
list[Employe]: Lista de empleados donde ganan mas 36000
"""
return [employe for employe in employees if employe["salary"] > ref_salary]
print(f"Los empleados que tienen mas salario: {filter_salary()}")
top_salary_employe()
```
```python
# Definimos una lista global de empleados
empleados = []
# Función para agregar empleados a la lista
def agregar_empleado(name, age, salary):
global empleados
empleado = {
"name": name,
"age": age,
"salary": salary
}
empleados.append(empleado)
# Función para obtener empleados que ganen más de un cierto sueldo
def empleados_con_sueldo_mayor_a(sueldo):
global empleados
empleados_filtrados = [empleado for empleado in empleados if empleado["salary"] > sueldo]
return empleados_filtrados
# Ejemplo de uso
agregar_empleado("Juan", 30, 5000)
agregar_empleado("Ana", 25, 6000)
agregar_empleado("Luis", 28, 4000)
print("lista de empleados: ", empleados)
print("estos son los empleados con sueldos mayores: ", empleados_con_sueldo_mayor_a(4500))
```
por comprehesion lists sale rapido
```js
employees = [
{'name': 'Juan Martinez', 'age': 28, 'salary': 45000},
{'name': 'Maria Garcia', 'age': 35, 'salary': 52000},
{'name': 'Carlos Rodriguez', 'age': 42, 'salary': 63000},
{'name': 'Ana Lopez', 'age': 31, 'salary': 48000},
{'name': 'Pedro Sanchez', 'age': 45, 'salary': 71000},
{'name': 'Sofia Fernandez', 'age': 29, 'salary': 46000},
{'name': 'Diego Morales', 'age': 38, 'salary': 58000},
{'name': 'Laura Torres', 'age': 33, 'salary': 51000},
{'name': 'Miguel Ramirez', 'age': 41, 'salary': 62000},
{'name': 'Isabel Castro', 'age': 27, 'salary': 44000},
{'name': 'Roberto Herrera', 'age': 36, 'salary': 55000},
{'name': 'Carmen Ortiz', 'age': 44, 'salary': 67000},
{'name': 'Javier Ruiz', 'age': 30, 'salary': 47000},
{'name': 'Patricia Flores', 'age': 39, 'salary': 59000},
{'name': 'Fernando Silva', 'age': 34, 'salary': 53000},
{'name': 'Elena Vargas', 'age': 32, 'salary': 49000},
{'name': 'Ricardo Mendoza', 'age': 47, 'salary': 72000},
{'name': 'Monica Jimenez', 'age': 37, 'salary': 56000},
{'name': 'Andres Reyes', 'age': 43, 'salary': 65000},
{'name': 'Valentina Cruz', 'age': 26, 'salary': 43000}
]
salaries = [employee for employee in employees if employee['salary'] < 50000]
print(salaries)
```
employes = \[]
def employes\_list( name, age, salary): employes.append({"name":name, "age":age, "salary":salary} )
def max\_salary(): max\_salary\_ = max(employes, key = lambda x: x\["salary"]) print(f"El Salario maximo es : {max\_salary\_\["salary"]}")
def min\_salary(): min\_salary\_ = min(employes, key = lambda x: x\["salary"]) print(f"El Salario minimo es : {min\_salary\_\["salary"]}")
employe1 = employes\_list("Fer",34,320000)employe2 = employes\_list("Bre",27,35000)
print (f"La lista empleados es: {employes}")
max\_salary()min\_salary()
Hola! Comparto mi código del ejercicio, si alguien tiene comentarios de como mejorarlo se los agradezco, saludos!
```js
import json
# assignment: get the employee list from the file and get which of the makes more than $70k
employees = {}
path = 'employees.json'
with open(path, 'r') as file:
# getting the employees from the json file
employees = json.load(file)
def filter_by_wage(threshold):
"""
This function gets a dictionary of employees and returns the list of employees that make more than the threshold.
Parameters:
- employees: dictionary of employees
- threshold: minimum value of to filter
Returns a list of elements included in the threshold
"""
global employees
included_employees = [] # local list
for employee in employees:
if employee['wage'] >= threshold:
included_employees.append(employee)
print(f"Total of {len(included_employees)} found.")
return included_employees
included_employees = filter_by_wage(70000)
for i in included_employees:
print(f"{i['name']}, {i['wage']}")
```import json
*# assignment: get the employee list from the file and get which of the makes more than $70k*employees = {}path = 'employees.json'
with open(path, 'r') as file: *# getting the employees from the json file*
employees = json.load(file)
*def* filter\_by\_wage(*threshold*): """ This function gets a dictionary of employees and returns the list of employees that make more than the threshold. Parameters: - employees: dictionary of employees - threshold: minimum value of to filter
Returns a list of elements included in the threshold """ *global* employees included\_employees = \[] *# local list*
for employee in employees: if employee\['wage'] >= *threshold*: included\_employees.append(employee)
print(*f*"Total of {len(included\_employees)} found.")
return included\_employees
included\_employees = filter\_by\_wage(70000)for i in included\_employees: print(*f*"{i\['name']}, {i\['wage']}")
```js
def obtener_info():
global empleados
empleados={}
num_empleados=int(input("Ingrese el numero de empleados: "))
for i in range(1,num_empleados+1):
name,age,salary=input("Favor ingresar el nombre, la edad y el salario del empleado separado por un espacio: ").split()
empleados[f'empleado {i}']={'nombre':name,'edad':int(age),'salario':int(salary)}
def monto_sup():
obtener_info()
mayor_monto=[emp for emp in empleados.values() if emp['salario']>1000]
return mayor_monto
print(f'Los empleados con mayor monto son {monto_sup()}')
```
```python
from typing import List, Dict
def salario(lista: List[Dict], limite_salary: float) -> List[Dict]:
"""
Filtra los elementos de una lista de diccionarios, devolviendo aquellos cuyo valor de 'salary' sea mayor al límite.
Args:
lista (List[Dict]): Lista de diccionarios con al menos la clave 'salary'.
limite_salary (float): Límite de salario para filtrar los elementos.
Returns:
List[Dict]: Lista de diccionarios con salarios superiores al límite.
"""
# Validación de entrada
if not isinstance(limite_salary, (int, float)):
raise ValueError("El límite de salario debe ser un número.")
if not all(isinstance(l, dict) and 'salary' in l for l in lista):
raise ValueError("Cada elemento de la lista debe ser un diccionario con la clave 'salary'.")
# Filtramos y devolvemos el resultado
return [l for l in lista if l.get('salary', 0) > limite_salary]
personas = [
{"name": "Pedro", "age": 40, "salary": 35000},
{"name": "Ana", "age": 32,"salary": 43000},
{"name": "Luis", "age": 34,"salary": 70000}
]
resultado = salario(personas, 40000)
print(resultado)
```from typing import List, Dict
def salario(lista: List\[Dict], limite\_salary: float) -> List\[Dict]: """ Filtra los elementos de una lista de diccionarios, devolviendo aquellos cuyo valor de 'salary' sea mayor al límite.
Args: lista (List\[Dict]): Lista de diccionarios con al menos la clave 'salary'. limite\_salary (float): Límite de salario para filtrar los elementos.
Returns: List\[Dict]: Lista de diccionarios con salarios superiores al límite. """ # Validación de entrada if not isinstance(limite\_salary, (int, float)): raise ValueError("El límite de salario debe ser un número.") if not all(isinstance(l, dict) and 'salary' in l for l in lista): raise ValueError("Cada elemento de la lista debe ser un diccionario con la clave 'salary'.") # Filtramos y devolvemos el resultado return \[l for l in lista if l.get('salary', 0) > limite\_salary]
personas = \[ {"name": "Pedro", "age": 40, "salary": 35000}, {"name": "Ana", "age": 32,"salary": 43000}, {"name": "Luis", "age": 34,"salary": 70000}]
resultado = salario(personas, 40000)print(resultado)
```js
employees = [
{'name': 'jose', 'age': 50, 'salary': 1000},
{'name': 'manuel', 'age': 45, 'salary': 3000},
{'name': 'ricardo', 'age': 30, 'salary': 2000},
{'name': 'alejandro', 'age': 46, 'salary': 5000},
{"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 set_empleados(employees: list[dict], minimun_wage):
def salary_grater():
employees_filter = [employee for employee in employees
if(employee.get('salary') >= minimun_wage)]
return employees_filter
print( salary_grater())
set_empleados(employees, 3100)
```
# Hola Platzinautas Pythonistas.
Me costo un montón el pensar como podría hacer la lógica de las variables ya que generalmente pondría estas cosas como parámetros de las funciones, pero creo que lo logré, aquí les dejo mi código y por favor díganme si lo hice bien o al final no implemente bien a lógica de las variable.
## Mi código:
```js
'''
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, minSalary):
# 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]
print(salaries)
salaryFilter()
highterSalary(employees, 3500)
highterSalary(employees, 4500)
```
Buenas noches, adjunto mi versión del programa, donde leo un archivo json, y me genera unos resultados , los cuales se plasman en un listado de empleados los cuales tienen salarios más altos.
<https://rapolan2050.github.io/readjsonresultpython/>
```js
def lista_empleados(lista_empleados, salario_minimo):
# Convierte el salario a entero antes de comparar
empleados_selecionados = [empleado for empleado in lista_empleados if int(empleado['salary']) > salario_minimo]
return empleados_selecionados
empleados = [
{'name': 'Teresa', 'age': '34', 'salary': '7000'},
{'name': 'Alonso', 'age': '35', 'salary': '4800'},
{'name': 'Matteo', 'age': '22', 'salary': '5500'},
{'name': 'Angela', 'age': '45', 'salary': '4900'}
]
# Llamada de la función
resultado = lista_empleados(empleados, 5000)
print(resultado)
```def lista\_empleados(lista\_empleados, salario\_minimo): # Convierte el salario a entero antes de comparar empleados\_selecionados = \[empleado for empleado in lista\_empleados if int(empleado\['salary']) > salario\_minimo] return empleados\_selecionados
empleados = \[ {'name': 'Teresa', 'age': '34', 'salary': '7000'}, {'name': 'Alonso', 'age': '35', 'salary': '4800'}, {'name': 'Matteo', 'age': '22', 'salary': '5500'}, {'name': 'Angela', 'age': '45', 'salary': '4900'} ]
\# Llamada de la función resultado = lista\_empleados(empleados, 5000)print(resultado)
```python
HOLA aca mi ejercicio
import random as rand
import string as str
"""this program recives from a data base of employes and filter by salary"""
name='';
def names_generator():
for i in range (5):
global name #no es posible unificar estas dos linea de codigo
name+=(rand.choice(str.ascii_uppercase))
return name
#for the sake of the example the data base is not in a file and is not pass as a parameter
database = [ {
'name':names_generator(),
'age':rand.randint(18,68),
'salary':rand.randint(5000,20000)
} for _ in range(300) ]
def loadData():
"""it lods the data from the data base"""
dataToFilter= database # nunca se toca la db original
def salary_filter(treshhole):
"""it filters the data using nonlocal"""
nonlocal dataToFilter
return [dic for dic in dataToFilter if dic['salary']>=treshhole]
return salary_filter(10000)
print(loadData())
```
esto debería estar después de la clase de variables
No entiendo por que son necesarios la palabra reservada de global y el nonlocal. no entendí su utilidad.
Hola, esta es mi función aplicando algunas cosas de clases pasadas.
```js
def reparto(empleados, monto):
lista = []
# recorre la lista de empleados
for empleado in empleados:
nombre = empleado["nombre"]
edad = empleado["edad"]
salario = empleado["salario"]
# si gana mas del monto los guarda en ena lista para luego devolverlos
def analizadora(monto):
nonlocal salario
if salario > monto:
lista.append("Nombre: " + nombre + ", Edad: " + str(edad))
analizadora(monto)
return lista
empleados = [
{"nombre": "juan", "edad": 25, "salario": 20000},
{"nombre": "pedro", "edad": 30, "salario": 10000},
{"nombre": "luis", "edad": 35, "salario": 25000}
]
monto = 10000
lista = reparto(empleados, monto)
print(f'Empleados que ganan mas de {monto}: {lista}')
```
Aquí está mi resolución al reto planteado en esta clase:employees = \[ { 'name': 'Javier', 'age': 35, 'salary': 2400 }, { 'name': 'Víctor', 'age': 47, 'salary': 2100 }, { 'name': 'Sergio', 'age': 50, 'salary': 2800 }, { 'name': 'Mari Luz', 'age': 46, 'salary': 1800 }, { 'name': 'Pedro', 'age': 54, 'salary': 2900 },]
def get\_employees\_with\_salary\_bigger\_than(): ''' Devuelve la lista de empleados que cobren m´as del sueldo de referencia especificado ''' target\_employees = \[]
ref\_salary = int(input("\nDefine un salario de referencia: "))
for employee in employees: if employee\["salary"] > ref\_salary: target\_employees.append(employee)
print(f"\nLos empleados que cobran más de {ref\_salary} son:\n")
for employee in target\_employees: print(f" > {employee\['name']}\t{employee\['age']} años\t(Salario: {employee\['salary']})")
print("\nLista de empleados:\n")
for employee in employees: print(f" > {employee\['name']}\t{employee\['age']} años\t(Salario: {employee\['salary']})")
get\_employees\_with\_salary\_bigger\_than()
```js
employees = [
{
'name': 'Javier',
'age': 35,
'salary': 2400
},
{
'name': 'Víctor',
'age': 47,
'salary': 2100
},
{
'name': 'Sergio',
'age': 50,
'salary': 2800
},
{
'name': 'Mari Luz',
'age': 46,
'salary': 1800
},
{
'name': 'Pedro',
'age': 54,
'salary': 2900
},
]
def get_employees_with_salary_bigger_than():
'''
Devuelve la lista de empleados que cobren m´as del sueldo de referencia especificado
'''
target_employees = []
ref_salary = int(input("\nDefine un salario de referencia: "))
for employee in employees:
if employee["salary"] > ref_salary:
target_employees.append(employee)
print(f"\nLos empleados que cobran más de {ref_salary} son:\n")
for employee in target_employees:
print(f" > {employee['name']}\t{employee['age']} años\t(Salario: {employee['salary']})")
print("\nLista de empleados:\n")
for employee in employees:
print(f" > {employee['name']}\t{employee['age']} años\t(Salario: {employee['salary']})")
get_employees_with_salary_bigger_than()
```
```python
"""Esta es mi solución"""
employees=[
{
"name":"Arturo",
"age":34,
"salary":20000
},
{
"name":"Ana",
"age":44,
"salary":30000
},
{
"name":"Antonio",
"age":19,
"salary":10000
},
{
"name":"Ammanda",
"age":50,
"salary":50000
},
{
"name":"Carla",
"age":29,
"salary":2500
},
{
"name":"Bruno",
"age":44,
"salary":60000
},
{
"name":"Romina",
"age":19,
"salary":8000
},
]
def get_employees(employees_list):
employee_by_salary=[(employee["name"],employee["salary"])
for employee in employees_list
if employee["salary"] < 20000]
return employee_by_salary
print(get_employees(employees))
```
```python
employees = [
{ 'name': 'Ramón', 'age': 27, 'salary': 700 },
{ 'name': 'Julian', 'age': 18, 'salary': 200 },
{ 'name': 'Karl', 'age': 35, 'salary': 1000 },
{ 'name': 'Paco', 'age': 24, 'salary': 500 },
{ 'name': 'Damian', 'age': 22, 'salary': 1200 }
]
def employees_bigger_salary(employees: list) -> list:
new_employees = []
def analyze_salary():
nonlocal new_employees
new_employees = [employee for employee in employees if employee['salary'] >= 700]
analyze_salary()
return new_employees
employees_bigger_salary = employees_bigger_salary(employees)
print(employees_bigger_salary)
```Así fue como entendí el reto teniendo en cuenta el último ejemplo.
Mi aporte, se podría imprimir directamente pero se me hace mas eficiente un returnlimit\_salary=150informacion\_empleados=\[ {'name':'Erick', 'age':17, 'salary':200}, {'name':'Andrea', 'age':18, 'salary':300}, {'name':'alex', 'age':19, 'salary':100},]
def analizar\_salario(): return \[seleccion for seleccion in informacion\_empleados if seleccion\['salary']>limit\_salary]
empleados\_seleccionados=analizar\_salario()print(empleados\_seleccionados)```python
limit_salary=150
informacion_empleados=[
{'name':'Erick',
'age':17,
'salary':200},
{'name':'Andrea',
'age':18,
'salary':300},
{'name':'alex',
'age':19,
'salary':100},
]
def analizar_salario():
return [seleccion for seleccion in informacion_empleados if seleccion['salary']>limit_salary]
empleados_seleccionados=analizar_salario()
print(empleados_seleccionados)
```![]()```js
```
Hola, par mí la explicación de la secuencia de impresión en el programa inner\_outer.py es:
1.- se invoca outer\_function
2.- x = 'enclosing'
3.- se invoca inner\_function
4.- x = 'local'
5.- se imprime local
6.- después de salir de inner\_function, x = 'enclosing'
7.- se imprime enclosing
8.- se ejecuta el método print que fuera de la función outer\_function, x = 'global'
9.- se imprime global
```js
x = 100
def local_function():
x = 10 #Variable local
print(f"El valor de la variable es: {x}")
def show_global():
print(f"El valor de la variable global es: {x}")
local_function()
show_global()
```x = 100
def local\_function(): x = 10 *#Variable local* print(f"El valor de la variable es: {x}")
def show\_global(): print(f"El valor de la variable global es: {x}")
local\_function()show\_global()
Carli, no sé si estuvo bien, pero creo que con simple list comprehension se podía resolver el reto, sino, entendí mal la actividad:
```python
employees = [
{
"name": "John Doe",
"age": 30,
"salary": 1000
},
{
"name": "Jane Doe",
"age": 25,
"salary": 900
},
{
"name": "Bob Smith",
"age": 35,
"salary": 1500
},
{
"name": "Alice Johnson",
"age": 40,
"salary": 2000
}
]
salary_min = [employed for employed in employees if employed["salary"]>=1499]
print(salary_min)
```
```python
#Diccionario que contiene información inicial
dictionary_list = [
{
'Name':'Daniel',
'Age' : 26,
'Salary' : 1500
},
{
'Name':'Maria',
'Age' : 27,
'Salary' : 3000
},
{
'Name':'Mateo',
'Age' : 20,
'Salary' : 5000
}
]
def employee_salary(data: list):
'''
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):
'''
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(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)
```#Diccionario que contiene información inicialdictionary\_list = \[ { 'Name':'Daniel', 'Age' : 26, 'Salary' : 1500 }, { 'Name':'Maria', 'Age' : 27, 'Salary' : 3000 }, { 'Name':'Mateo', 'Age' : 20, 'Salary' : 5000 }]
def employee\_salary(data: list):
''' 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): ''' 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(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)
de esta forma tambien me funciono
````python
empleados = [
{"nombre": "Juan", "edad": 25, "salario": 1000},
{"nombre": "Ana", "edad": 32, "salario": 400},
{"nombre": "Pedro", "edad": 35, "salario": 5000},
{"nombre": "Laura", "edad": 40, "salario": 100}
]
sueldoMinimo = 400
def sueldo_empleados(lista, salario_minimo):
listaEmpleados= []
for empleado in lista:
if empleado['salario']> salario_minimo:
listaEmpleados.append(empleado)
#print(listaEmpleados)
return listaEmpleados
resultado = sueldo_empleados(empleados, sueldoMinimo)
print(resultado)
```empleados = \[ {"nombre": "Juan", "edad": 25, "salario": 1000}, {"nombre": "Ana", "edad": 32, "salario": 400}, {"nombre": "Pedro", "edad": 35, "salario": 5000}, {"nombre": "Laura", "edad": 40, "salario": 100}]
sueldoMinimo = 400
def sueldo\_empleados(lista, salario\_minimo):
listaEmpleados= \[] for empleado in lista: if empleado\['salario']> salario\_minimo: listaEmpleados.append(empleado) #print(listaEmpleados) return listaEmpleados
resultado = sueldo\_empleados(empleados, sueldoMinimo)print(resultado)
````
no lo hice en funcion, pero lo hice de esta manera
```python
personas = [
{"nombre": "Juan", "edad": 25, "salario": 1000},
{"nombre": "Ana", "edad": 32, "salario": 400},
{"nombre": "Pedro", "edad": 35, "salario": 5000},
{"nombre": "Laura", "edad": 40, "salario": 100}
]
lista= list(filter(lambda x: x['salario']>= 400,personas))
print(lista)
```personas = \[ {"nombre": "Juan", "edad": 25, "salario": 1000}, {"nombre": "Ana", "edad": 32, "salario": 400}, {"nombre": "Pedro", "edad": 35, "salario": 5000}, {"nombre": "Laura", "edad": 40, "salario": 100}]
lista= list(filter(lambda x: x\['salario']>= 400,personas))print(lista)
My solución utilizando filter y lambda function:
```js
employes = [
{
"name": "Fabian",
"age": 12,
"salary": 1000,
},
{
"name": "Jose",
"age": 14,
"salary": 2000,
},
{
"name": "Maria",
"age": 15,
"salary": 3000,
},
{
"name": "Carli",
"age": 33,
"salary": 1500,
}
]
def more_than_salary(employees: list, threshold: int = 2000) ->list:
return list(filter(lambda x: x['salary'] > threshold, employees))
print(more_than_salary(employes))
print(more_than_salary(employes, 1000))
```
print(more\_than\_salary(employes))
Nota complementaria.
En el caso de las listas, es posible hacer referencia a ellas en cualquier función, sin necesidad de utilizar la palabra clave Global.
Así, cada ocasión en que se utilice el nombre de una lista dentro de funciones, Python entiende que hacemos referencia a la variable global. Esto no sucede con variables primitivas, como el caso de "x=10", que la profesora describe al inicio.
```js
"""Filtro de salarios"""
empleados = [
{"name": "Ana", "age": 30, "salary": 3500},
{"name": "Luis", "age": 25, "salary": 2500},
{"name": "Sofia", "age": 40, "salary": 4500}
]
# Añadir un empleado a la lista global
def agregar_empleado(info_empleado):
global empleados # Modificamos la variable global de empleados
empleados.append(info_empleado)
def empleados_sueldo_mayor_a(sueldo_minimo):
empleados_filtrados = [] # Lista local de empleados que cumplen la condición
for empleado in empleados:
if empleado['salary'] > sueldo_minimo:
empleados_filtrados.append(empleado)
return empleados_filtrados
# Agregar empleados con la función 'agregar_empleado'
agregar_empleado({"name": "Raul", "age": 21, "salary": 3800})
agregar_empleado({"name": "María", "age": 23, "salary": 2900})
agregar_empleado({"name": "Vanessa", "age": 25, "salary": 3100})
# Filtro de empleados con sueldo mayor a 3000
sueldo_minimo = 3000
empleados_filtrados = empleados_sueldo_mayor_a(sueldo_minimo)
# Mostrar empleados con el filtro
print(empleados_filtrados)
```Salida:
\[{'name': 'Ana', 'age': 30, 'salary': 3500}, {'name': 'Sofia', 'age': 40, 'salary': 4500}, {'name': 'Raul', 'age': 21, 'salary': 3800}, {'name': 'Vanessa', 'age': 25, 'salary': 3100}]
Hola comunidad, aqui mi solucion:
`employees_information = [ { "name": "name One", "age": 12, "salary": 1200 }, { "name": "name Two", "age": 13, "salary": 1500 }, { "name": "name Three", "age": 19, "salary": 2000 }]`
`def get_employee_by_salary(salary): return list(filter(lambda employe: employe['salary'] >= salary, employees_information))`
`print(get_employee_by_salary(1900))`
¿Quieres ver más aportes, preguntas y respuestas de la comunidad?