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
You don't have access to this class
Keep learning! Join and start boosting your career
If you already have an account,
Resources
How do decorators work in Python?
Decorators in Python are a powerful tool that allows you to modify or extend the behavior of functions or methods, without altering your original code. This approach is especially useful in a professional environment where you often want to add behaviors before or after the execution of a main function.
What is the basic structure of a Python decorator?
A decorator in Python starts by creating a function that acts on another function. This process involves:
- A primary function that performs a basic task, such as printing a message or performing a transaction.
- A decorator that receives this function as an argument, executes code before and/or after the function, and returns the modified function.
For example, consider a basic decorator that prints messages before and after a function:
def my_function(parameter): print(f "Processing: {parameter}")
def my_decorator(func): def wrapper(*args, **kwargs): print("Before executing the function....") result = func(*args, **kwargs) print("After executing the function...") return result return wrapper
# Apply decorator@my_decoratordef process_payment(): print("Processing payment...")
process_payment()How do we apply a decorator in a practical example?
To better understand decorators, we will consider an example where functionality is added before and after a function that processes a payment:
-
The basic function
process_paymentis defined:def process_payment(): print("Processing payment...") -
A decorator is created that adds logs before and after executing the function:
def log_decorator(func): def wrapper(): print("Starting transaction log...") func() print("Transaction log completed.") return wrapper. -
The decorator is applied using the
@symbol and the function is executed:@log_decoratordef process_payment(): print("Processing payment...") process_payment()
How do we handle permissions with decorators?
Decorators can also be useful to check permissions before executing functions. Suppose we want to control access to a function that deletes employees, only allowing the action to administrators:
-
We define a function that deletes an employee, based on a data dictionary:
def remove_employee(employee): print(f "Employee {employee['name']} has been removed.") -
A decorator is created to verify the employee's role:
def verify_access(func): def wrapper(employee): if employee.get('role') == 'admin': return func(employee) else: print("Access denied: only administrators can access.") return wrapper. -
The decorator is applied and tested with different roles:
@check_accessdef delete_employee(employee): print(f "Employee {employee['name']} has been deleted.") admin = {'name': 'Carlos', 'role': 'admin'}employee = {'name': 'Ana', 'role': 'employee'} delete_employee(admin)delete_employee(employee)
This practical example shows how you can control which actions are allowed for whom, which is essential in collaborative and security environments.
What do we propose as a practice to improve in decorators?
As an additional challenge, try implementing a decorator that records all actions performed by an employee in a text file. This will not only help you consolidate the use of decorators, but will also encourage the reuse and extension of functionality in your code.
You will continue to learn about decorators and their advanced uses, such as including parameters and nesting multiple decorators. Continue on your programming learning journey!
Contributions 47
Questions 2
Sort by:
Los decoradores en Python son funciones que modifican el comportamiento de otras funciones o m茅todos. Son una herramienta muy 煤til para a帽adir funcionalidades o preprocesamientos sin tener que cambiar el c贸digo original de la funci贸n decorada.
\### 驴Qu茅 es un Decorador?
Un decorador es una funci贸n que toma otra funci贸n como argumento y le a帽ade funcionalidades adicionales. Devuelve una nueva funci贸n modificada o envuelta con el comportamiento adicional.
La sintaxis b谩sica de un decorador utiliza el s铆mbolo `@` seguido del nombre del decorador antes de la definici贸n de la funci贸n que se quiere decorar:
```python
@mi\_decorador
def funcion():
pass
```
\### Ejemplo B谩sico de Decorador
Aqu铆 tienes un ejemplo de un decorador que muestra un mensaje antes y despu茅s de ejecutar la funci贸n:
```python
def mi\_decorador(funcion):
def wrapper():
print("Antes de la funci贸n")
funcion()
print("Despu茅s de la funci贸n")
return wrapper
@mi\_decorador
def saludo():
print("Hola")
saludo()
```
\*\*Salida:\*\*
```plaintext
Antes de la funci贸n
Hola
Despu茅s de la funci贸n
```
\### Decoradores con Argumentos en las Funciones
Si la funci贸n original toma argumentos, el decorador debe adaptarse para recibirlos y pasarlos correctamente:
```python
def decorador\_con\_argumentos(funcion):
def wrapper(\*args, \*\*kwargs):
print("Llamando a la funci贸n con argumentos:", args, kwargs)
resultado = funcion(\*args, \*\*kwargs)
print("Resultado:", resultado)
return resultado
return wrapper
@decorador\_con\_argumentos
def suma(a, b):
return a + b
suma(3, 5)
```
\*\*Salida:\*\*
```plaintext
Llamando a la funci贸n con argumentos: (3, 5) {}
Resultado: 8
```
\### Decoradores Anidados
Se pueden aplicar varios decoradores a una misma funci贸n. En este caso, los decoradores se aplican en orden desde el m谩s cercano a la funci贸n hacia el exterior:
```python
def decorador1(funcion):
def wrapper():
print("Decorador 1")
funcion()
return wrapper
def decorador2(funcion):
def wrapper():
print("Decorador 2")
funcion()
return wrapper
@decorador1
@decorador2
def mi\_funcion():
print("Funci贸n original")
mi\_funcion()
```
\*\*Salida:\*\*
```plaintext
Decorador 1
Decorador 2
Funci贸n original
```
\### Decoradores de Clase
Los decoradores no solo se limitan a funciones; tambi茅n pueden aplicarse a clases para modificar su comportamiento. Aqu铆 tienes un ejemplo de decorador que modifica el m茅todo `\_\_init\_\_` de una clase:
```python
def decorador\_clase(cls):
class NuevaClase(cls):
def \_\_init\_\_(self, \*args, \*\*kwargs):
print("Iniciando con decorador de clase")
super().\_\_init\_\_(\*args, \*\*kwargs)
return NuevaClase
@decorador\_clase
class Persona:
def \_\_init\_\_(self, nombre):
self.nombre = nombre
p = Persona("Carlos")
```
\*\*Salida:\*\*
```plaintext
Iniciando con decorador de clase
```
\### Decoradores Integrados en Python
Python ofrece algunos decoradores integrados, como:
\- `@staticmethod`: Define m茅todos est谩ticos que no requieren una instancia de la clase.
\- `@classmethod`: Define m茅todos de clase que reciben la clase como primer argumento en lugar de la instancia.
\- `@property`: Define m茅todos como propiedades, permitiendo acceso a m茅todos como si fueran atributos.
\### Decoradores con Argumentos Propios
A veces, es 煤til que un decorador acepte argumentos. En estos casos, el decorador se define dentro de otra funci贸n, lo cual permite que la funci贸n exterior reciba argumentos:
```python
def decorador\_con\_parametros(mensaje):
def decorador(funcion):
def wrapper(\*args, \*\*kwargs):
print(mensaje)
return funcion(\*args, \*\*kwargs)
return wrapper
return decorador
@decorador\_con\_parametros("Ejecutando funci贸n")
def resta(a, b):
return a - b
resta(10, 3)
```
\*\*Salida:\*\*
```plaintext
Ejecutando funci贸n
```
\### Conclusi贸n
Los decoradores son una herramienta poderosa en Python que permite modificar funciones y m茅todos sin cambiar su implementaci贸n interna, siendo 煤tiles para casos como:
\- Validaci贸n de datos
\- Manejo de excepciones
\- Medici贸n de tiempo de ejecuci贸n
\- Creaci贸n de APIs
```python
from datetime import datetime
"""
Implementa un decorador llamado log_employee_action
que registre cualquier acci贸n realizada por un empleado en un archivo de texto.
"""
# Funci贸n decorador que ser谩 la de escribir en el archivo de texto las acciones de los empleados
def log_empleados(func):
def wrapper(empleado):
print('Log de la transaccion...')
with open('log.txt', 'a') as file:
file.write(f'{func(empleado)}\n')
print('Log terminado...')
return wrapper
# Funci贸n decorador que ser谩 la de escribir en el archivo de texto las acciones de los admin
# La diferencia es la cantidad de par谩metros, todos se registra en el mismo log.txt
def log_admin(func):
def wrapper(empleado, admin):
print('Log de la transaccion...')
with open('log.txt', 'a') as file:
file.write(f'{func(empleado, admin)}\n')
print('Log terminado...')
return wrapper
# Funci贸n que permite al rol admin eliminar un empleado
@log_admin
def eliminar_empleado(empleado, admin):
print(f"{datetime.now()} El administrador {admin['nombre']} ha eliminado al empleado {empleado['nombre']}")
return f"{datetime.now()} El administrador {admin['nombre']} ha eliminado al empleado {empleado['nombre']}"
# Funci贸n que permite al rol admin registrar un empleado
@log_admin
def registrar_empleado(empleado, admin):
print(f"{datetime.now()} El administrador {admin['nombre']} ha registrado al empleado {empleado['nombre']}")
return f"{datetime.now()} El administrador {admin['nombre']} ha registrado al empleado {empleado['nombre']}"
# Funci贸n que permite al rol empleado ingresar al sistema
@log_empleados
def ingresar_al_sistema(empleado):
print(f"{datetime.now()} El empleado {empleado['nombre']} ha ingresado al sistema")
return f"{datetime.now()} El empleado {empleado['nombre']} ha ingresado al sistema"
# Funci贸n que permite al rol empleado salir del sistema
@log_empleados
def salir_del_sistema(empleado):
print(f"{datetime.now()} El empleado {empleado['nombre']} ha salido al sistema")
return f"{datetime.now()} El empleado {empleado['nombre']} ha salido del sistema"
# Ejemplo de uso
# Se crea un admin y 3 empleados
admin = {'nombre': 'Iris', 'rol': 'admin'}
e1 = {'nombre': 'Jose', 'rol': 'empleado'}
e2 = {'nombre': 'Ana', 'rol': 'empleado'}
e3 = {'nombre': 'Samuel', 'rol': 'empleado'}
ingresar_al_sistema(e1) # Jos茅 ingresa al sistema
ingresar_al_sistema(e3) # Samuel ingresa al sistema
salir_del_sistema(e3) # Samuel sale del sistema
eliminar_empleado(e3, admin) # El admin Iris elimina al empleado Samuel
registrar_empleado(e2, admin) # El admin Iris registra al empleado Ana
```
Los **decoradores** en Python son una herramienta poderosa y flexible que permite modificar o extender la funcionalidad de funciones o m茅todos sin cambiar su c贸digo original. Son **funciones** que "envuelven" otra funci贸n o m茅todo, lo que permite agregar comportamientos adicionales antes o despu茅s de la ejecuci贸n de la funci贸n original.
### 驴C贸mo funcionan los decoradores?
Un decorador toma una funci贸n como entrada, la "envuelve" o "modifica", y luego devuelve una nueva funci贸n con la funcionalidad extendida o alterada. Los decoradores se aplican a las funciones usando el s铆mbolo `@` encima de la definici贸n de la funci贸n.
### Sintaxis b谩sica de un decorador:
```python
def decorador(func):
def envoltura():
print("Algo antes de la funci贸n original.")
func()
print("Algo despu茅s de la funci贸n original.")
return envoltura
@decorador
def mi_funcion():
print("Esta es la funci贸n original.")
mi_funcion()
```Explicaci贸n del ejemplo:
* `decorador(func)`: El decorador toma una funci贸n `func` como par谩metro.
* `envoltura()`: Es una nueva funci贸n que envuelve a la funci贸n original. Dentro de esta funci贸n, puedes agregar c贸digo antes y despu茅s de llamar a la funci贸n original.
* `return envoltura`: El decorador devuelve la funci贸n modificada.
Cuando ejecutas `mi_funcion()`, el decorador "envuelve" la funci贸n y se ejecuta el c贸digo adicional alrededor de la funci贸n original.
### Salida del c贸digo anterior:
Algo antes de la funci贸n original.
Esta es la funci贸n original.
Algo despu茅s de la funci贸n original.
### Ejemplo de un decorador con par谩metros:
A veces, los decoradores tambi茅n pueden aceptar par谩metros adicionales, permitiendo mayor flexibilidad.
```python
def decorador_con_parametros(valor):
def decorador(func):
def envoltura(*args, **kwargs):
print(f"Valor del decorador: {valor}")
return func(*args, **kwargs)
return envoltura
return decorador
@decorador_con_parametros("Hola Mundo")
def saludar():
print("Saludos!")
saludar()
```Salida:
Valor del decorador: Hola Mundo
Saludos!
### Aplicaciones de los decoradores:
1. **Registro de actividades (logging)**: Puedes usar decoradores para hacer seguimiento de las funciones que se ejecutan, qu茅 par谩metros se pasan, y qu茅 resultados devuelven.
2. **Autenticaci贸n y autorizaci贸n**: Puedes aplicar decoradores para verificar si un usuario tiene permiso para ejecutar ciertas funciones.
3. **Medici贸n de tiempo de ejecuci贸n (timing)**: Un decorador puede medir cu谩nto tiempo tarda en ejecutarse una funci贸n.
4. **Cacheo o memoizaci贸n**: Los decoradores tambi茅n son 煤tiles para almacenar en cach茅 los resultados de una funci贸n para evitar c谩lculos repetidos.
### Decoradores en Python con funciones est谩ndar y clases:
* **Funciones est谩ndar**: Como se mostr贸 en los ejemplos anteriores.
* **Clases y m茅todos**: Tambi茅n se pueden usar decoradores con m茅todos dentro de clases, donde el decorador modifica el comportamiento de los m茅todos.
### En resumen:
Los decoradores son una forma de **modificar el comportamiento de una funci贸n o m茅todo** sin cambiar su c贸digo directamente. Son 煤tiles para tareas comunes y repetitivas como el registro de actividades, la medici贸n de tiempos, la verificaci贸n de permisos, y m谩s.
```python
# Implementar nuevo decorador que registre cualquier acci贸n realizada por un empleado
# Decorador para verificar rol de usuario
def check_access(func):
def wrapper(user, employee, employee_act):
if user.get('role') == 'admin':
return func(user, employee, employee_act)
else:
print("Acceso denegado. Solo los administradores pueden modificar usuarios")
return wrapper
# Funci贸n que ejecuta la acci贸n pedida por el usuario
@check_access
def log_employee_action(user, employee, employee_act) -> str:
if employee_act == 'add':
print(f"El empleado {employee['name']} ha sido agregado correctamente")
elif employee_act == 'delete':
print(f"El empleado {employee['name']} ha sido eliminado correctamente")
elif employee_act == 'modify role':
print(f"El rol del empleado {employee['name']} se ha modificado correctamente")
# Lista de empleados
employees = [
{
'name': 'David',
'role': 'employee',
'actions': ['add', 'delete', 'modify role']
},
{
'name': 'Samuel',
'role': 'employee',
'actions': ['add', 'delete', 'modify role']
},
{
'name': 'Jhon',
'role': 'admin',
'actions': ['add', 'delete', 'modify role']
}]
# Usuario: Jhon, empleado a modificar: David, acci贸n: agregar
log_employee_action(employees[2], employees[0], employees[2]['actions'][0])
# Usuario: Jhon, empleado a modificar: David, acci贸n: eliminar
log_employee_action(employees[2], employees[0], employees[2]['actions'][1])
# Usuario: Jhon, empleado a modificar: David, acci贸n: modificar rol
log_employee_action(employees[2], employees[0], employees[2]['actions'][2])
```
Mi aporte :)
```js
from datetime import datetime
def log_employee_action(func):
def wrapper(employer):
#Verifica el momento en que se hizo el ajuste en el archivo
print('Inicia acci贸n en .txt')
with open('historico de acceso employee.txt', 'a') as file:
file.write(f"{func(employer)}\n")
print('Se ha registrado acci贸n')
return wrapper
def log_admin_action(func):
def wrapper(employer, admin):
print('Inicia acci贸n en .txt')
with open('Historico de acceso employee.txt', 'a') as file:
file.write(f'{func(employer, admin)}\n')
print('Se ha registrado acci贸n')
return wrapper
@log_admin_action
def delete_employee(employee, admin):
print(f"{datetime.now()} El administrador {admin['nombre']} ha eliminado al empleado {employee['nombre']}")
return f"{datetime.now()} El administrador {admin['nombre']} ha eliminado al empleado {employee['nombre']}"
@log_admin_action
def registre_employee(employee, admin):
print(f"{datetime.now()} El administrador {admin['nombre']} ha registrado al empleado {employee['nombre']}")
return f"{datetime.now()} El administrador {admin['nombre']} ha registrado al empleado {employee['nombre']}"
@log_employee_action
def open_system(employee):
print(f"{datetime.now()} El empleado {employee['nombre']} ha entrado al sistema")
return (f"{datetime.now()} El empleado {employee['nombre']} ha entrado al sistema")
@log_employee_action
def close_system(employee):
print(f"{datetime.now()} El empleado {employee['nombre']} ha salido del sistema")
return (f"{datetime.now()} El empleado {employee['nombre']} ha salido del sistema")
# Ejemplo de uso
# Se crea un admin y 3 empleados
admin = {'nombre': 'Iris', 'rol': 'admin'}
e1 = {'nombre': 'Jose', 'rol': 'empleado'}
e2 = {'nombre': 'Ana', 'rol': 'empleado'}
e3 = {'nombre': 'Samuel', 'rol': 'empleado'}
open_system(e1)
open_system(e2)
close_system(e1)
close_system(e2)
delete_employee(e1, admin)
registre_employee(e2, admin)
```from datetime import datetime
def log\_employee\_action(func):聽 聽 def wrapper(employer):聽 聽 聽 聽 #Verifica el momento en que se hizo el ajuste en el archivo聽 聽 聽 聽 print('Inicia acci贸n en .txt')聽 聽 聽 聽 聽 聽 聽 聽 with open('historico de acceso employee.txt', 'a') as file:聽 聽 聽 聽 聽 聽 file.write(f"{func(employer)}\n")聽 聽 聽 聽 print('Se ha registrado acci贸n')聽 聽 return wrapper
def log\_admin\_action(func):聽 聽 def wrapper(employer, admin):聽 聽 聽 聽 print('Inicia acci贸n en .txt')聽 聽 聽 聽 聽 聽 聽 聽 with open('Historico de acceso employee.txt', 'a') as file:聽 聽 聽 聽 聽 聽 file.write(f'{func(employer, admin)}\n')聽 聽 聽 聽 print('Se ha registrado acci贸n')聽 聽 return wrapper
@log\_admin\_actiondef delete\_employee(employee, admin):聽 聽 print(f"{datetime.now()} El administrador {admin\['nombre']} ha eliminado al empleado {employee\['nombre']}")聽 聽 return f"{datetime.now()} El administrador {admin\['nombre']} ha eliminado al empleado {employee\['nombre']}"
@log\_admin\_actiondef registre\_employee(employee, admin):聽 聽 print(f"{datetime.now()} El administrador {admin\['nombre']} ha registrado al empleado {employee\['nombre']}")聽 聽 return f"{datetime.now()} El administrador {admin\['nombre']} ha registrado al empleado {employee\['nombre']}"
@log\_employee\_actiondef open\_system(employee):聽 聽 print(f"{datetime.now()} El empleado {employee\['nombre']} ha entrado al sistema")聽 聽 return (f"{datetime.now()} El empleado {employee\['nombre']} ha entrado al sistema")
@log\_employee\_actiondef close\_system(employee):聽 聽 print(f"{datetime.now()} El empleado {employee\['nombre']} ha salido del sistema")聽 聽 return (f"{datetime.now()} El empleado {employee\['nombre']} ha salido del sistema")
\# Ejemplo de uso# Se crea un admin y 3 empleadosadmin = {'nombre': 'Iris', 'rol': 'admin'}e1 = {'nombre': 'Jose', 'rol': 'empleado'}e2 = {'nombre': 'Ana', 'rol': 'empleado'}e3 = {'nombre': 'Samuel', 'rol': 'empleado'}
open\_system(e1)open\_system(e2)close\_system(e1)close\_system(e2)delete\_employee(e1, admin)registre\_employee(e2, admin)
import time
def medir\_tiempo(funcion):
def envoltura(\*args, \*\*kwargs):
inicio = time.time()
resultado = funcion(\*args, \*\*kwargs)
fin = time.time()
print(f"Tiempo de ejecuci贸n: {fin - inicio} segundos")
return resultado
return envoltura
@medir\_tiempo
def suma(a, b):
time.sleep(1) # Simula una operaci贸n que tarda 1 segundo
return a + b
resultado = suma(2, 3)
print(f"Resultado: {resultado}")
my solution!!
No me quedaba claro como se invoca la funci贸n "procesar\_pago()" dentro del wrapper, si no lo invocaba directamente. ChatGPT me ayudo diciendo esto:
* Cuando usamos `@log_decorator`, `procesar_pago` se reemplaza por `wrapper()`.
* Dentro de `wrapper()`, `func()` es **la funci贸n original** `procesar_pago()`.
* Por eso, cuando llamamos a `procesar_pago()`, en realidad ejecutamos `wrapper()`, que a su vez llama a `procesar_pago()` en `func()`.
My soution!!
mi ejercicio :)
```python
def log_employee_action(func):
def wrapper(employee):
print("Logging employee action...")
with open("employee_actions.log", "a") as f:
f.write(f"{employee['name']} {func.__name__} at {datetime.now()}\n")
func(employee)
print("Employee action logged.")
return wrapper
def check_access(func):
def wrapper(employee):
if employee.get("role") == "admin":
func(employee)
else:
print("Access denied.")
return wrapper
@check_access
@log_employee_action
def delete_employee(employee):
print(f"Deleting employee: {employee["name"]}")
delete_employee({"name": "John Doe", "role": "admin"})
```def log\_employee\_action(func):聽 聽 def wrapper(employee):聽 聽 聽 聽 print("Logging employee action...")聽 聽 聽 聽 with open("employee\_actions.log", "a") as f:聽 聽 聽 聽 聽 聽 f.write(f"{employee\['name']} {func.\_\_name\_\_} at {datetime.now()}\n")
聽 聽 聽 聽 func(employee)聽 聽 聽 聽 print("Employee action logged.")
聽 聽 return wrapper
def check\_access(func):聽 聽 def wrapper(employee):聽 聽 聽 聽 if employee.get("role") == "admin":聽 聽 聽 聽 聽 聽 func(employee)聽 聽 聽 聽 else:聽 聽 聽 聽 聽 聽 print("Access denied.")
聽 聽 return wrapper
@check\_access@log\_employee\_actiondef delete\_employee(employee):聽 聽 print(f"Deleting employee: {employee\["name"]}")
delete\_employee({"name": "John Doe", "role": "admin"})
```python
import datetime
def checkAccess(func):
def wrapper(employee):
# Comprobar si el empleado tiene el rol 'writer'
if employee.get('role') == 'writer':
print("Escribiendo en el archivo...")
with open('documentacion.txt', 'a') as file:
# Escribir la fecha y nombre del empleado en el archivo
file.write(f'{datetime.datetime.now()} - Usuario: {employee["name"]}\n')
return func(employee) # Pasar el 'employee' a la funci贸n original
else:
return 'ACCESO DENEGADO. Solo los escritores tienen permitido cambiar el archivo'
return wrapper
@checkAccess
def writerChange(employee):
print(f'El empleado {employee["name"]} ah hecho una modificacion al archivo.txt')
employee = {
'name': 'John Doe',
'age': 30,
'position': 'Software Engineer',
'salary': 75000,
'role': 'writer'
}
writerChange(employee)
```Me gusto la idea de mostrar la fecha y hora de la modificaci贸n
```python
from collections import deque
from datetime import datetime
class Employee_Action:
list_employees = dict # {name: {rol: "", job_title: ""}}
log = dict # {name_employee: {date_change: "", text_added: ""}}
def __init__(self, list_employees: dict):
self.list_employees = list_employees
self.log = {}
def show_log(func):
def wrapped(self, name_employee: str, text_file: str, posicion: str, new_text: str):
now = datetime.now().date()
self.log[name_employee] = {
"date_change": now,
"text_added": new_text,
}
print(self.log)
return func(name_employee, text_file, posicion, new_text)
return wrapped
@show_log
def add_text_to_file (name: str, text_file: str, posicion: str, new_text: str):
deque_text = deque(text_file)
if posicion == 'I' or posicion == 'i':
deque_text.extendleft(new_text[::-1])
elif posicion == 'F' or posicion == 'f':
deque_text.extend(new_text)
texto_final = ''.join(deque_text)
return texto_final
lista = {
"Cristian": {"rol": "admin", "job_title": "Senior Developer"},
"David": {"rol": "employee", "job_title": "Mid Developer"},
"Mora": {"rol": "employee", "job_title": "Mid Developer"},
"Saenz": {"rol": "employee", "job_title": "Junior Developer"}
}
st = True
text_file = "隆Hola mundo!"
while st == True:
name = str(input("\n Escriba su nombre (El registrado): ")).lower()
pos = str(input("\n Para escribir al inicio digite la letra [ I ] / Para escribir al final [ F ]: "))
new_text = str(input("\n Escriba el texto que desea guardar: "))
obj = Employee_Action(lista)
print(obj.add_text_to_file(name, text_file, pos, new_text))
des = str(input("Desea continuar digite [ Y ] / [ N ]: "))
if des in ('y','Y'):
st = True
elif des in ('N', 'n'):
st = False
```
import datetime
def log\_employee\_action(func):聽 聽 def wrap(tarea, empleado\_id):聽 聽 聽 聽 result = func(tarea, empleado\_id)聽 聽 聽 聽 with open('registro\_acciones.txt', 'a') as file:聽 聽 聽 聽 聽 聽 file.write(f"{datetime.datetime.now()} - Empleado {empleado\_id} realiz贸 la tarea: {tarea}\n")聽 聽 聽 聽 return result聽 聽 return wrap
@log\_employee\_actiondef realizar\_tarea(tarea, empleado\_id):聽 聽 # Se realiza la tarea por parte del empleado聽 聽 print(f"Empleado {empleado\_id} est谩 realizando la tarea: {tarea}")
\# Ejemplo de usorealizar\_tarea("Revisar inventario", 14020)realizar\_tarea("Revisar ventas", 14021)realizar\_tarea("Recoger productos", 14022)realizar\_tarea("Atender clientes", 14023)
```js
import datetime
def log_employee_action(func):
def wrap(tarea, empleado_id):
result = func(tarea, empleado_id)
with open('registro_acciones.txt', 'a') as file:
file.write(f"{datetime.datetime.now()} - Empleado {empleado_id} realiz贸 la tarea: {tarea}\n")
return result
return wrap
@log_employee_action
def realizar_tarea(tarea, empleado_id):
# Se realiza la tarea por parte del empleado
print(f"Empleado {empleado_id} est谩 realizando la tarea: {tarea}")
# Ejemplo de uso
realizar_tarea("Revisar inventario", 14020)
realizar_tarea("Revisar ventas", 14021)
realizar_tarea("Recoger productos", 14022)
realizar_tarea("Atender clientes", 14023)
```
```js
```
yo realice algo sencillo por aqu铆 lo dejo
```js
"""
Implementar un decorador llamado log_employee_action
que registre cualquier acci贸n realizada por un empleado
en un archivo de texto
"""
import datetime
empleado = {'name':'Juan'}
log:str = 'acci贸n del empleado'
def log_employee_action(func):
def envoltura():
print(f'Procesando la solicitud...')
with open('log.txt', 'a') as archivo:
archivo.write(log + '\n')
func()
print(f'Solicitud realizada...')
return envoltura
def ejecutar_accion():
accion = int(input('Ingrese un valor para \n Registrar: 1, Eliminar: 2, Modificar: 3 \n'))
global log
if accion == 1:
log = f'El empleado {empleado['name']} quiere realizar un registro'
registrar()
elif accion == 2:
log = f'El empleado {empleado['name']} quiere eliminar registro'
eliminar()
elif accion ==3:
log = f'El empleado {empleado['name']} quiere modificar un registro'
modificar()
else:
print(f'Acci贸n no valida')
@log_employee_action
def registrar():
ahora = datetime.datetime.now()
with open('texto.txt', 'a') as archivo:
archivo.write(f'Hola, nuevo registro a las {ahora}\n')
@log_employee_action
def eliminar():
ahora = datetime.datetime.now()
with open('texto.txt', 'a') as archivo:
archivo.write(f'Hola, se elimina un registro a las {ahora}\n')
@log_employee_action
def modificar():
ahora = datetime.datetime.now()
with open('texto.txt', 'a') as archivo:
archivo.write(f'Hola, se modifica un registro a las {ahora}\n')
ejecutar_accion()
```
```js
# Archivo: decorators.py (o el nombre que desees)
print("")
print("* Ejercicio 1:")
print("- Uso de un decorador para registrar transacciones.")
print("")
def log_transacciones(func):
"""
Decorador para registrar (log) transacciones.
Este decorador toma una funci贸n (que se asume que realiza una transacci贸n)
como argumento y la "envuelve" con funcionalidad de registro. Antes y despu茅s
de la ejecuci贸n de la funci贸n original, se imprimen mensajes en la consola
indicando el inicio y el fin del registro de la transacci贸n.
Args:
func: La funci贸n que realiza la transacci贸n y que se va a decorar. Se
asume que esta funci贸n no recibe argumentos y no devuelve ning煤n
valor directamente (aunque podr铆a tener efectos secundarios).
Returns:
La funci贸n "envolvedor" (wrapper), que contiene la l贸gica de registro
y la llamada a la funci贸n original. Esta funci贸n "envolvedor" es la que
se ejecuta realmente cuando se llama a la funci贸n decorada.
"""
def envolvedor():
print("Log de la transacci贸n...") # Mensaje de inicio de registro
func() # Llama a la funci贸n original (la que realiza la transacci贸n)
print("Log terminado...") # Mensaje de fin de registro
return envolvedor # Devuelve la funci贸n "envolvedor" (no la ejecuta)
@log_transacciones # Aplica el decorador a la funci贸n procesar_pago
def procesar_pago():
"""
Funci贸n que simula el procesamiento de un pago.
Esta funci贸n representa una operaci贸n que realiza un pago. En este ejemplo,
simplemente imprime un mensaje en la consola indicando que se est谩 procesando
el pago. En un escenario real, aqu铆 ir铆a la l贸gica para interactuar con un
sistema de pagos, etc.
"""
print("Procesando pago")
# Llamada a la funci贸n decorada. Observa que llamamos a procesar_pago(), pero en
# realidad se ejecuta la funci贸n "envolvedor" del decorador, que a su vez llama a
# procesar_pago().
procesar_pago()
# El resultado de la ejecuci贸n ser铆a:
# Log de la transacci贸n...
# Procesando pago
# Log terminado...
print("")
print("* Ejercicio 2:")
print("- Uso de un decorador para validar permisos antes de eliminar un empleado.")
print("")
def validar_permisos_eliminar(func):
"""
Decorador para validar permisos antes de eliminar un empleado.
Este decorador verifica si un empleado tiene el rol de "ADMIN" antes de permitir
que se ejecute la funci贸n para eliminar un empleado. Si el empleado no tiene
permiso, se imprime un mensaje indicando la falta de permisos.
Args:
func: La funci贸n que realiza la eliminaci贸n del empleado, que se va a decorar.
Se espera que esta funci贸n tome un diccionario (empleado) como argumento,
que contiene informaci贸n sobre el empleado, incluyendo su rol.
Returns:
La funci贸n "envolvedor" (wrapper). Esta funci贸n interna contiene la l贸gica
de verificaci贸n de permisos y la llamada a la funci贸n original (si los
permisos son suficientes).
"""
def envolvedor(empleado):
print()
print("Iniciando transacci贸n...")
if empleado.get('rol') == "ADMIN": # Verifica si el empleado es ADMIN
print(func(empleado)) # Llama a la funci贸n original si tiene permisos
return "Fin transacci贸n..."
else:
print("No tienes permisos para eliminar un empleado")
return "Fin transacci贸n..." # Retorna None expl铆citamente para indicar que la funci贸n no se ejecut贸
return envolvedor # Devuelve la funci贸n "envolvedor" (no la ejecuta)
@validar_permisos_eliminar # Aplica el decorador a la funci贸n eliminar_empleado
def eliminar_empleado(empleado):
"""
Funci贸n para eliminar un empleado (solo accesible para administradores).
Esta funci贸n simula la eliminaci贸n de un empleado. Simplemente imprime un
mensaje en la consola indicando que el empleado ha sido eliminado. En una
aplicaci贸n real, aqu铆 ir铆a la l贸gica para interactuar con una base de datos,
etc.
Args:
empleado: Un diccionario que contiene la informaci贸n del empleado que se va a eliminar.
"""
return f"El empleado {empleado['nombre']} ha sido eliminado" # Retorna un mensaje indicando el 茅xito de la operaci贸n.
# Ejemplos de uso:
usuario_admin = {"nombre": "Alexis Dorado", "rol": "ADMIN"}
print(usuario_admin)
resultado_admin = eliminar_empleado(usuario_admin) # El admin tiene permisos
print(resultado_admin)
print()
usuario_no_admin = {"nombre": "Juan P茅rez", "rol": "EMPLEADO"}
print(usuario_no_admin)
resultado_no_admin = eliminar_empleado(usuario_no_admin) # El empleado NO tiene permisos
print(resultado_no_admin)
# El resultado de la ejecuci贸n ser铆a:
# El empleado Alexis Dorado ha sido eliminado
# Empleado eliminado con 茅xito
# No tienes permisos para eliminar un empleado
# None
```*# Archivo: decorators.py (o el nombre que desees)*
print("")print("\* Ejercicio 1:")print("- Uso de un decorador para registrar transacciones.")print("")
def log\_transacciones(func):聽 聽 """聽 聽 Decorador para registrar (log) transacciones.
聽 聽 Este decorador toma una funci贸n (que se asume que realiza una transacci贸n)聽 聽 como argumento y la "envuelve" con funcionalidad de registro. 聽Antes y despu茅s聽 聽 de la ejecuci贸n de la funci贸n original, se imprimen mensajes en la consola聽 聽 indicando el inicio y el fin del registro de la transacci贸n.
聽 聽 Args:聽 聽 聽 聽 func: La funci贸n que realiza la transacci贸n y que se va a decorar. 聽Se聽 聽 聽 聽 聽 聽 聽 asume que esta funci贸n no recibe argumentos y no devuelve ning煤n聽 聽 聽 聽 聽 聽 聽 valor directamente (aunque podr铆a tener efectos secundarios).
聽 聽 Returns:聽 聽 聽 聽 La funci贸n "envolvedor" (wrapper), que contiene la l贸gica de registro聽 聽 聽 聽 y la llamada a la funci贸n original. 聽Esta funci贸n "envolvedor" es la que聽 聽 聽 聽 se ejecuta realmente cuando se llama a la funci贸n decorada.聽 聽 """聽 聽 def envolvedor():聽 聽 聽 聽 print("Log de la transacci贸n...") 聽*# Mensaje de inicio de registro*聽 聽 聽 聽 func() 聽*# Llama a la funci贸n original (la que realiza la transacci贸n)*聽 聽 聽 聽 print("Log terminado...") 聽*# Mensaje de fin de registro*聽 聽 return envolvedor 聽*# Devuelve la funci贸n "envolvedor" (no la ejecuta)*
@log\_transacciones 聽*# Aplica el decorador a la funci贸n procesar\_pago*def procesar\_pago():聽 聽 """聽 聽 Funci贸n que simula el procesamiento de un pago.
聽 聽 Esta funci贸n representa una operaci贸n que realiza un pago. 聽En este ejemplo,聽 聽 simplemente imprime un mensaje en la consola indicando que se est谩 procesando聽 聽 el pago. 聽En un escenario real, aqu铆 ir铆a la l贸gica para interactuar con un 聽 聽 sistema de pagos, etc.聽 聽 """聽 聽 print("Procesando pago")
*# Llamada a la funci贸n decorada. 聽Observa que llamamos a procesar\_pago(), pero en# realidad se ejecuta la funci贸n "envolvedor" del decorador, que a su vez llama a# procesar\_pago().*
procesar\_pago()
*# El resultado de la ejecuci贸n ser铆a:# Log de la transacci贸n...# Procesando pago# Log terminado...*
print("")print("\* Ejercicio 2:")print("- Uso de un decorador para validar permisos antes de eliminar un empleado.")print("")
def validar\_permisos\_eliminar(func):聽 聽 """聽 聽 Decorador para validar permisos antes de eliminar un empleado.
聽 聽 Este decorador verifica si un empleado tiene el rol de "ADMIN" antes de permitir聽 聽 que se ejecute la funci贸n para eliminar un empleado. Si el empleado no tiene聽 聽 permiso, se imprime un mensaje indicando la falta de permisos.
聽 聽 Args:聽 聽 聽 聽 func: La funci贸n que realiza la eliminaci贸n del empleado, que se va a decorar.聽 聽 聽 聽 聽 聽 聽 Se espera que esta funci贸n tome un diccionario (empleado) como argumento,聽 聽 聽 聽 聽 聽 聽 que contiene informaci贸n sobre el empleado, incluyendo su rol.
聽 聽 Returns:聽 聽 聽 聽 La funci贸n "envolvedor" (wrapper). Esta funci贸n interna contiene la l贸gica聽 聽 聽 聽 de verificaci贸n de permisos y la llamada a la funci贸n original (si los 聽 聽 聽 聽 permisos son suficientes).聽 聽 """
聽 聽 def envolvedor(empleado):聽 聽 聽 聽 print()聽 聽 聽 聽 print("Iniciando transacci贸n...")聽 聽 聽 聽 if empleado.get('rol') == "ADMIN": 聽*# Verifica si el empleado es ADMIN*聽 聽 聽 聽 聽 聽 聽print(func(empleado)) 聽*# Llama a la funci贸n original si tiene permisos*聽 聽 聽 聽 聽 聽 聽return "Fin transacci贸n..."聽 聽 聽 聽 else:聽 聽 聽 聽 聽 聽 print("No tienes permisos para eliminar un empleado")聽 聽 聽 聽 聽 聽 return "Fin transacci贸n..." *# Retorna None expl铆citamente para indicar que la funci贸n no se ejecut贸*聽 聽 聽 聽 聽 聽 return envolvedor 聽*# Devuelve la funci贸n "envolvedor" (no la ejecuta)*
@validar\_permisos\_eliminar 聽*# Aplica el decorador a la funci贸n eliminar\_empleado*def eliminar\_empleado(empleado):聽 聽 """聽 聽 Funci贸n para eliminar un empleado (solo accesible para administradores).
聽 聽 Esta funci贸n simula la eliminaci贸n de un empleado. 聽Simplemente imprime un聽 聽 mensaje en la consola indicando que el empleado ha sido eliminado. 聽En una聽 聽 aplicaci贸n real, aqu铆 ir铆a la l贸gica para interactuar con una base de datos,聽 聽 etc.
聽 聽 Args:聽 聽 聽 empleado: Un diccionario que contiene la informaci贸n del empleado que se va a eliminar.聽 聽 """聽 聽 return f"El empleado {empleado\['nombre']} ha sido eliminado" *# Retorna un mensaje indicando el 茅xito de la operaci贸n.*
*# Ejemplos de uso:*
usuario\_admin = {"nombre": "Alexis Dorado", "rol": "ADMIN"}print(usuario\_admin)resultado\_admin = eliminar\_empleado(usuario\_admin) 聽*# El admin tiene permisos*print(resultado\_admin)
print()
usuario\_no\_admin = {"nombre": "Juan P茅rez", "rol": "EMPLEADO"}print(usuario\_no\_admin)resultado\_no\_admin = eliminar\_empleado(usuario\_no\_admin) 聽*# El empleado NO tiene permisos*print(resultado\_no\_admin)
*# El resultado de la ejecuci贸n ser铆a:# El empleado Alexis Dorado ha sido eliminado# Empleado eliminado con 茅xito# No tienes permisos para eliminar un empleado# None*
```python
"""Implementa un decorador llamado log_employee_action
que registre cualquier acci贸n realizada por un empleado
en un archivo de texto"""
#Decorador que verifica si el usuario tiene acceso
def check_access (funcion):
def wrapper(user):
if user.get("rol") == "admin":
return funcion(user)
else:
print("Acceso denegado. Se reportar谩 el intento a direcci贸n")
return wrapper
#Nuevo decorador que registra la acci贸n en un archivo de texto
def log_action (funcion):
def wrapper(user):
with open ("log_employee.txt", "a") as log_file:
log_file.write(f"Empleado {user['name']} borr贸 a un empleado\n")
return funcion(user)
return wrapper
#Aplicamos ambos decoradores (primero log, luego acceso)
@log_action
@check_access
def remove_staff(admin):
print(f"El administrador {admin['name']} ha sido eliminado")
#Ejemplo de uso
admin_user = {"name": "Marta", "rol": "admin"}
regular_user = {"name": "Marc", "rol": "employee"}
#remove_staff(admin_user)
remove_staff(regular_user)
```
Aqu铆 est谩 mi c贸digo, lo implemente conforme el input de acci贸n de cada usuario, los n煤meros representan el flujo del c贸digo.
```js
import json
def check_access(func):
#El Wrapper recibe los mismos elementos que la funci贸n que contiene
def wrapper(): #2
print("Bienvenido")
action_admin = input(f"Administrador {admin['name']} ingrese la acci贸n que desea realizar: ")
action_employee = input(f"Empleado {employee['name']} ingrese la acci贸n que desea realizar: ")
for emp in employees:
if emp.get('role') == 'admin':
func(emp, action_admin)
else:
func(emp, action_employee)
#Formas de convertir una lista a string
actions_text = '\n'.join(map(str, actions_list))
#actions_text = json.dumps(actions_list)
with open('avanzado/decorators/actions-list.txt', 'w') as file:
file.write(actions_text)
print("Se ha registrado la accion del usuario")
print(actions_list)
return wrapper
@check_access #2
def add_action_employee(employe, actions):
#3
#Creamos la forma de empleado
emp_action = {
'name' : employe.get('name'),
'actions' : actions
}
actions_list.append(emp_action)
actions_list = []
admin = {'name': 'Carlos', 'role': 'admin'}
employee = {'name': 'Ana', 'role': 'employee'}
employees = [
{'name': 'Carlos', 'role': 'admin'},
{'name': 'Ana', 'role': 'employee'}
]
#NOTA IMPORTANTE
#Se puede llamar una funci贸n a ejecutarse sin recibir ningun elemento si despu茅s
# le pasas los valores requeridos a la funcion dentro del wrapper no al wrapper mismo
#El wrapper debe recibir exactamente los mismo valores que
#uses al llamar una funcion y si no mandas nada, el wrapper tampoco
#recibe nada
add_action_employee() #1
```
```python
import datetime
def log_employee_action(func):
"""Decorador para registrar las acciones de un empleado en 'bitacora.txt' incluyendo la ubicaci贸n."""
def wrapper(*args, **kwargs):
result = func(*args, **kwargs)
employee_name = args[0] # Primer argumento: nombre del empleado
location = args[1] # Segundo argumento: ubicaci贸n
action = func.__name__
timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
log_message = f"[{timestamp}] Empleado: {employee_name} - Accion: {action} - Ubicacion: {location}\n"
# Guardar en bitacora.txt
with open("bitacora.txt", "a", encoding="utf-8") as log_file:
log_file.write(log_message)
return result
return wrapper
# Uso del decorador en funciones de ejemplo
@log_employee_action
def check_in(employee_name, location):
print(f"{employee_name} ha registrado su entrada en {location}.")
@log_employee_action
def check_out(employee_name, location):
print(f"{employee_name} ha registrado su salida en {location}.")
# Pruebas de ejecuci贸n
check_in("Carlos", "Oficina Central")
check_out("Carlos", "Oficina Central")
```import datetime
def log\_employee\_action(func):聽 聽 """Decorador para registrar las acciones de un empleado en 'bitacora.txt' incluyendo la ubicaci贸n."""聽 聽 def wrapper(\*args, \*\*kwargs):聽 聽 聽 聽 result = func(\*args, \*\*kwargs)聽 聽 聽 聽 employee\_name = args\[0] 聽# Primer argumento: nombre del empleado聽 聽 聽 聽 location = args\[1] 聽 聽 聽 # Segundo argumento: ubicaci贸n聽 聽 聽 聽 action = func.\_\_name\_\_聽 聽 聽 聽 timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
聽 聽 聽 聽 log\_message = f"\[{timestamp}] Empleado: {employee\_name} - Accion: {action} - Ubicacion: {location}\n"聽 聽 聽 聽 聽 聽 聽 聽 # Guardar en bitacora.txt聽 聽 聽 聽 with open("bitacora.txt", "a", encoding="utf-8") as log\_file:聽 聽 聽 聽 聽 聽 log\_file.write(log\_message)聽 聽 聽 聽 聽 聽 聽 聽 return result聽 聽 聽 聽 return wrapper
\# Uso del decorador en funciones de ejemplo@log\_employee\_actiondef check\_in(employee\_name, location):聽 聽 print(f"{employee\_name} ha registrado su entrada en {location}.")
@log\_employee\_actiondef check\_out(employee\_name, location):聽 聽 print(f"{employee\_name} ha registrado su salida en {location}.")
\# Pruebas de ejecuci贸ncheck\_in("Carlos", "Oficina Central")check\_out("Carlos", "Oficina Central")
Yo lo entendi asi:
```python
def log_employee_action(func):
def wrapper(employee):
print('1.Registro de Ingreso')
#A脩ADIR TEXTO:
with open('44registro.txt', 'a') as file: #a de a帽adir
file.write(f"Ingreso: {employee['name']}\n") # \n es salto de linea
return func(employee) return wrapper
#Ingreso del empleado accion
@ log_employee_action
def ingreso(employee):
print(f'2.El empleado {employee['name']} ha Ingresado')
admin= {'name': 'Carlos', 'role': 'admin'}
employee= {'name': 'Ana', 'role': 'employee'}
#llamar a la funcion:
ingreso(admin)
ingreso(employee)
```
Pude hacerlo de una manera algo sencilla, buscando guardar la hora de llegada de un empleado```python
from datetime import datetime
def log_employee_action(func):
def wrapper(employee):
with open ('guardando_acciones.txt','a') as file:
print("Se guardar谩 la acci贸n...")
mensaje = f"El empleado ha realizado la acci贸n: {func(employee)}\n"
file.write(mensaje)
print("acci贸n guardada...")
return wrapper
@log_employee_action
def hora_llegada_empleado(empleado):
hora_actual = datetime.now()
mensaje = f"el empleado {empleado["nombre"]} ha llegado a las {hora_actual}."
print(mensaje)
return mensaje
empleado= {
'nombre' : 'Juan',
'apellido' : 'Guerra'
}
hora_llegada_empleado(empleado)
```
me divert铆 bastante haciendo la actividad (o reto) de esta clase, mientras lo hacia aprend铆 una que otra cosilla, en mi c贸digo se genera un archivo TXT para cada empleado (us茅 OOP)
```js
"""
Implementar un decorador llamado 'log_employee_action' que registre cualquier accion realizada por un archivo de texto
"""
from datetime import datetime
from time import sleep as wait
from enum import Enum
class WorkRole(Enum):
SUPERVISOR = "supervisor"
EMPLOYEE = "empleado"
class Employee:
def __init__(self, name: str, age: int, role: WorkRole) -> None:
self.name = name
self.age = age
self.role = role
self._actions = []
def log_employee_action(func):
def wrapper(self, *args, **kwargs):
action = func(self, *args, **kwargs)
self._actions.append(f"{datetime.now()} - {action}")
with open(f'{self.name}_employee_actions.txt', 'a') as file:
file.write(f"{datetime.now()} - {action}\n")
return action
return wrapper
@log_employee_action
def introduce(self, someone) -> str:
"""
Introduce a person to another person
"""
print(f"Hello, my name is {self.name} and I am {self.age} years old")
return f'{self.name} se present贸 con {someone.name}'
@log_employee_action
def greet(self, someone) -> str:
"""
Greet a person
"""
print(f"Hello, {someone.name}!")
return f'{self.name} salud贸 a {someone.name}'
@log_employee_action
def work(self, task: str) -> str:
"""
Work on a task
"""
print(f"{self.name} is working on '{task}'")
return f'{self.name} est谩 trabajando en "{task}"'
@log_employee_action
def scold(self, someone) -> str:
"""
Scold a person if the role is supervisor
"""
# Check if the role is supervisor
if self.role != WorkRole.SUPERVISOR:
print(f"{self.name} is not a supervisor and cannot scold anyone")
return f'{self.name} intent贸 rega帽ar a {someone.name}, pero {self.name} no es supervisor por lo que se v铆o idiota'
else:
print(f"{self.name} scolded {someone.name}")
return f'{self.name} rega帽贸 a {someone.name}'
employee1 = Employee("John", 30, WorkRole.EMPLOYEE)
employee2 = Employee("Jane", 25, WorkRole.EMPLOYEE)
supervisor = Employee("Alice", 35, WorkRole.SUPERVISOR)
supervisor.introduce(employee1)
wait(2)
employee1.introduce(employee2)
employee2.greet(employee1)
wait(2)
employee1.introduce(supervisor)
wait(2)
supervisor.scold(employee1)
wait(1)
supervisor.greet(employee2)
wait(2)
employee1.work("write a report")
employee1.scold(employee2)
wait(3)
supervisor.scold(employee2)
print(employee1._actions)
print(employee2._actions)
print(supervisor._actions)
```
Wow esto se pude resumir, como a la la herencia en Java.
馃馃馃
Aunque es como una mezcla entre herencia e interfaz.
Vengo del mundo de Java y JavaScript y la verdad esto es una maravilla de lenguaje
驴pprque se retorna la funcion envoltorio?
```js
def check_access(func):
def wrapper(employeer: dict, action):
with open('40. Arhivo.txt', 'a') as file:
file.write(func(employeer, action))
return wrapper
employeers = [
{'name': 'Luis', 'permissions': 'admi'},
{'name': 'Ana', 'permissions': 'user'},
{'name': 'Juan', 'permissions': 'user'},
{'name': 'Jose', 'permissions': 'user'}
]
@check_access
def log_emplyee_action(employeer: dict, action: str) -> str:
return f"{employeer['name']} {action}"
def borrar_archivo():
return f"ha borrado un archivo \n"
def iniciar_sesion():
return f"ha iniciado sesion \n"
def cerrar_sesion():
return f"ha cerrado sesion \n"
log_emplyee_action(employeers[0], borrar_archivo())
log_emplyee_action(employeers[1], iniciar_sesion())
log_emplyee_action(employeers[2], cerrar_sesion())
```
```python
from time import sleep
def registro_log(func):
def wrapper(employee):
with open('logs.txt', mode='a') as file:
file.write(f"Empleado {employee.get('name')}\n")
return func(employee)
return wrapper
registered_employees = set()
employees = []
@registro_log
def registrar_empleado(employee):
employee_tuple = tuple(employee.items())
if employee_tuple not in registered_employees:
print("Registrando usuario....")
employees.append(employee)
registered_employees.add(employee_tuple)
sleep(1)
print(f"Usuario {employee['name']} registrado exitosamente")
else:
print(f"El usuario {employee['name']} ya esta registrado")
employee_1 = {'name': 'Daniel', 'age': 27}
employee_2 = {'name': 'Matias', 'age': 8}
employee_3 = {'name': 'Daniel', 'age': 13}
registrar_empleado(employee_1)
registrar_empleado(employee_2)
registrar_empleado(employee_3)
registrar_empleado(employee_2)
print(employees)
print(registered_employees)
```
```js
def check_activity(func):
def wrapper(employee):
func(employee)
if employee.get('action')==True:
print(f"{employee.get('name')} made something")
else:
print("No action recorded")
return wrapper
@check_activity
def activity(employee):
action1=input("What is going to make the employee? ")
if action1.strip():
print(f"{action1}: Recorded")
employee['action']=True
else:
print("No action recorded")
employee['action']=False
user1={'name':'Charles','age':12,'action':False}
activity(user1)
```
Soluci贸n al reto:
```js
def check_and_log_access(file_name):
def decorator(func):
def wrapper(employee):
action = f"Empleado: {employee['name']}, Rol: {employee['role']}, Acci贸n: {func.__name__}"
if employee.get('role') == 'admin':
# Registrar la acci贸n en el archivo de texto
with open(file_name, 'a') as file:
file.write(f"{action} - ACCI脫N REALIZADA\n")
return func(employee)
else:
# Registrar el acceso denegado en el archivo de texto
with open(file_name, 'a') as file:
file.write(f"{action} - ACCESO DENEGADO\n")
print('ACCESO DENEGADO. Solo los administradores pueden acceder.')
return wrapper
return decorator
@check_and_log_access('07-employee_actions.txt')
def delete_employee(employee):
print(f"El empleado {employee['name']} ha sido eliminado.")
admin = {'name': 'Carlos', 'role': 'admin'}
employee = {'name': 'Ana', 'role': 'employee'}
employee1 = {'name': 'Nik', 'role': 'subadmin'}
admin2 = {'name': 'Coverdale', 'role': 'admin'}
print('Uso del decorador check_and_log_access:')
delete_employee(employee1)
```def check\_and\_log\_access(file\_name):聽 聽 def decorator(func):聽 聽 聽 聽 def wrapper(employee):聽 聽 聽 聽 聽 聽 action = f"Empleado: {employee\['name']}, Rol: {employee\['role']}, Acci贸n: {func.\_\_name\_\_}"聽 聽 聽 聽 聽 聽 if employee.get('role') == 'admin':聽 聽 聽 聽 聽 聽 聽 聽 *# Registrar la acci贸n en el archivo de texto*聽 聽 聽 聽 聽 聽 聽 聽 with open(file\_name, 'a') as file:聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 file.write(f"{action} - ACCI脫N REALIZADA\n")聽 聽 聽 聽 聽 聽 聽 聽 return func(employee)聽 聽 聽 聽 聽 聽 else:聽 聽 聽 聽 聽 聽 聽 聽 *# Registrar el acceso denegado en el archivo de texto*聽 聽 聽 聽 聽 聽 聽 聽 with open(file\_name, 'a') as file:聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 file.write(f"{action} - ACCESO DENEGADO\n")聽 聽 聽 聽 聽 聽 聽 聽 print('ACCESO DENEGADO. Solo los administradores pueden acceder.')聽 聽 聽 聽 return wrapper聽 聽 return decorator
@check\_and\_log\_access('07-employee\_actions.txt')def delete\_employee(employee):聽 聽 print(f"El empleado {employee\['name']} ha sido eliminado.")
admin = {'name': 'Carlos', 'role': 'admin'}employee = {'name': 'Ana', 'role': 'employee'}employee1 = {'name': 'Nik', 'role': 'subadmin'}admin2 = {'name': 'Coverdale', 'role': 'admin'}
print('Uso del decorador check\_and\_log\_access:')delete\_employee(employee1)
Modificaci贸n de Comportamiento: Los decoradores permiten modificar o extender el comportamiento de funciones o m茅todos sin modificar su c贸digo fuente.
2\.
C贸digo Reutilizable: Facilitan la reutilizaci贸n de c贸digo, permitiendo aplicar la misma l贸gica en m煤ltiples funciones de manera elegante y concisa.
3\.
Autorizaci贸n y Autenticaci贸n: Com煤nmente utilizados en el control de acceso, verificando permisos antes de ejecutar una funci贸n.
4\.
Registro (Logging): Pueden agregar autom谩ticamente registros de llamadas a funciones, par谩metros y resultados.
5\.
Memoizaci贸n: Utilizados para almacenar en cach茅 los resultados de funciones costosas, mejorando el rendimiento.
aca un par de conceptos con los que me tope al intentar entender este tema **Listas de Default Factory**: Usan `defaultdict` para evitar errores de clave inexistente proporcionando valores predeterminados.
* **Objeto Hashable**: Objeto que puede ser utilizado como clave en un diccionario debido a su valor hash inmutable.
* **Factory Function**: Funci贸n que crea y devuelve objetos, encapsulando la l贸gica de creaci贸n.
hice este codigo para ver el registro de operaciones de un empleado en un txt.
```js
import os
from time import sleep
ruta_python = os.path.dirname(os.path.abspath(__file__))
ruta_ejecucion = os.getcwd()
if ruta_python != ruta_ejecucion:
print(f'Ruta Python: {ruta_python}')
print(f'Ruta Ejecucion: {ruta_ejecucion}')
os.chdir(ruta_python)
else:
print('No es necesario cambiar rutas:')
print('Terminado el proceso de verificacion de rutas....')
print('Verificando archivo txt.')
sleep(5)
archivo = 'registro.txt'
def confirmacion_escrito(funcion):
def wrapper():
lineas_anteriores = set()
while True:
nuevas_lineas = funcion()
if nuevas_lineas:
for linea in nuevas_lineas:
if linea not in lineas_anteriores:
print(linea.strip())
lineas_anteriores.add(linea)
print(lineas_anteriores)
else:
print('No ha habido actualizaciones...')
print("Presiona 'q' y Enter para salir, o simplemente Enter para continuar.")
user_input = input()
if user_input.lower() == 'q':
break
print('Continuando en 5 segundos...')
sleep(5)
return wrapper
@confirmacion_escrito
def registros_empleado():
with open(archivo, 'r') as file:
return file.readlines()
registros_empleado()
```import osfrom time import sleep
ruta\_python = os.path.dirname(os.path.abspath(\_\_file\_\_))ruta\_ejecucion = os.getcwd()
if ruta\_python != ruta\_ejecucion:聽 聽 print(f'Ruta Python: {ruta\_python}')聽 聽 print(f'Ruta Ejecucion: {ruta\_ejecucion}')聽 聽 os.chdir(ruta\_python)else:聽 聽 print('No es necesario cambiar rutas:')
print('Terminado el proceso de verificacion de rutas....')print('Verificando archivo txt.')
sleep(5)
archivo = 'registro.txt'
def confirmacion\_escrito(funcion):聽 聽 def wrapper():聽 聽 聽 聽 lineas\_anteriores = set()聽 聽 聽 聽 while True:聽 聽 聽 聽 聽 聽 nuevas\_lineas = funcion()聽 聽 聽 聽 聽 聽 if nuevas\_lineas:聽 聽 聽 聽 聽 聽 聽 聽 for linea in nuevas\_lineas:聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 if linea not in lineas\_anteriores:聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 print(linea.strip())聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 lineas\_anteriores.add(linea)聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 print(lineas\_anteriores)聽 聽 聽 聽 聽 聽 else:聽 聽 聽 聽 聽 聽 聽 聽 print('No ha habido actualizaciones...')聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 print("Presiona 'q' y Enter para salir, o simplemente Enter para continuar.")聽 聽 聽 聽 聽 聽 user\_input = input()聽 聽 聽 聽 聽 聽 if user\_input.lower() == 'q':聽 聽 聽 聽 聽 聽 聽 聽 break聽 聽 聽 聽 聽 聽 print('Continuando en 5 segundos...')聽 聽 聽 聽 聽 聽 sleep(5)聽 聽 return wrapper
@confirmacion\_escritodef registros\_empleado():聽 聽 with open(archivo, 'r') as file:聽 聽 聽 聽 return file.readlines()
registros\_empleado()
```js
from datetime import datetime
def log_employee_action(func):
def wrapper(admin, employee, action):
with open('log.txt', 'a') as file:
file.write(f"{datetime.now()} - El administrador {admin['name']} ha {action} al empleado {employee['name']}\n")
return func(admin, employee, action)
return wrapper
@log_employee_action
def delete_employee(admin, employee, action):
print(f"El administrador {admin['name']} ha {action} a {employee['name']}")
admin = {
'name': 'Juan',
'role': 'admin'
}
employee = {
'name': 'Pedro',
'role': 'employee'
}
delete_employee(admin, employee, 'eliminado')
```
```python
import datetime
def log_employee_action(func):
def wrapper(employee, *args, **kwargs):
# Registra la acci贸n en el archivo de log
with open("employee_actions.log", "a") as log_file:
log_file.write(f"{datetime.datetime.now()} - {employee['name']} ({employee['role']}) realiz贸 la acci贸n: {func.__name__}\n")
# Llama a la funci贸n original
return func(employee, *args, **kwargs)
return wrapper
@log_employee_action
def delete_employee(employee):
print(f"El empleado {employee['name']} ha sido despedido.")
@log_employee_action
def promote_employee(employee):
print(f"El empleado {employee['name']} ha sido promovido.")
# Ejemplo de uso
admin = {'name': 'Carlos', 'role': 'admin'}
employee = {'name': 'Ana', 'role': 'employee'}
delete_employee(admin) # Esto registrar谩 la acci贸n y la imprimir谩
promote_employee(employee) # Lo mismo para promover empleados
```import datetime
def log\_employee\_action(func):聽 聽 def wrapper(employee, \*args, \*\*kwargs):聽 聽 聽 聽 # Registra la acci贸n en el archivo de log聽 聽 聽 聽 with open("employee\_actions.log", "a") as log\_file:聽 聽 聽 聽 聽 聽 log\_file.write(f"{datetime.datetime.now()} - {employee\['name']} ({employee\['role']}) realiz贸 la acci贸n: {func.\_\_name\_\_}\n")聽 聽 聽 聽 聽 聽 聽 聽 # Llama a la funci贸n original聽 聽 聽 聽 return func(employee, \*args, \*\*kwargs)聽 聽 聽 聽 return wrapper
@log\_employee\_actiondef delete\_employee(employee):聽 聽 print(f"El empleado {employee\['name']} ha sido despedido.")
@log\_employee\_actiondef promote\_employee(employee):聽 聽 print(f"El empleado {employee\['name']} ha sido promovido.")
\# Ejemplo de usoadmin = {'name': 'Carlos', 'role': 'admin'}employee = {'name': 'Ana', 'role': 'employee'}
delete\_employee(admin) 聽# Esto registrar谩 la acci贸n y la imprimir谩promote\_employee(employee) 聽# Lo mismo para promover empleados
`import datetime as dt #Importar libreria para obtener fecha/hora`
`def log_employee_actions(func):聽 聽 def wrapper(employee,id):聽 聽 聽 聽 print("Inicio de las acciones...")聽 聽 聽 聽 func(employee,id)聽 聽 聽 聽 print("Accion terminada...")聽 聽 return wrapper`
`@log_employee_actionsdef save_in_log(employee,id):聽 聽 employeer_info = employee[id] #Toma la informacion del empleado deseado de la tupla聽 聽 action = input("Ingrese accion: ")`
`聽 聽 #Guarda en el log聽 聽 with open('file.txt','a') as file:聽 聽 聽 聽 file.write(f"\n {dt.datetime.now()},{employeer_info['name']}, {action}")聽 聽 聽 聽 file.close()`
`employee = ({'name': 'Ana', 'role': 'employee'},{'name': 'Erick', 'role': 'employee'})`
`save_in_log(employee,0)`
```js
def log_employee_action(action):
def decorator(func):
def wrapper(employee):
print(f"El empleado {employee['name']} ha ejecutado la acci贸n de {action}")
func(employee)
return wrapper
return decorator
def check_access(func):
def wrapper(employee):
# Comprobar el rol 'admin'
if employee.get('role') == 'admin':
func(employee)
else:
print('ACCESO DENEGADO, no eres admin')
return wrapper
@check_access
@log_employee_action('ELIMINAR EMPLEADO')
def delete_employee(employee):
print(f'El empleado {employee['name']} ha sido eliminado')
@check_access
@log_employee_action('AGREGAR EMPLEADO')
def add_employee(employee):
print(f'El empleado {employee['name']} ha sido agregado')
admin = {'name': 'Richard', 'role': 'admin'}
employee = {'name': 'Parker', 'role': 'dev'}
delete_employee(admin)
add_employee(admin)
delete_employee(employee)
```
```js
from datetime import datetime
from functools import wraps
def log_employee_action(func):
@wraps(func)
def wrapper(employee, *args, **kwargs):
# Ejecutar la funci贸n solo si el rol es 'admin'
if employee.get('role') == 'admin':
result = func(employee, *args, **kwargs)
# Registrar la acci贸n en el archivo de log
with open("employee_actions.log", "a") as log_file:
log_file.write(f"{datetime.now()} - {employee['name']} realiz贸 la acci贸n: {func.__name__}\n")
return result
else:
print("ACCESO DENEGADO. Solo los administradores pueden acceder.")
return wrapper
# Ejemplo de funci贸n que utiliza el decorador
@log_employee_action
def delete_employee(employee):
print(f"El empleado {employee['name']} ha sido eliminado.")
# Crear empleados de ejemplo
admin = {'name': 'Carlos', 'role': 'admin'}
employee = {'name': 'Ana', 'role': 'employee'}
# Intentar ejecutar la funci贸n con diferentes usuarios
delete_employee(admin) # Esto deber铆a tener acceso y registrar la acci贸n
delete_employee(employee) # Esto deber铆a denegar el acceso
```from datetime import datetime
from functools import wraps
def log\_employee\_action(func):
@wraps(func)
def wrapper(employee, \*args, \*\*kwargs):
\# Ejecutar la funci贸n solo si el rol es 'admin'
if employee.get('role') == 'admin':
result = func(employee, \*args, \*\*kwargs)
\# Registrar la acci贸n en el archivo de log
with open("employee\_actions.log", "a") as log\_file:
log\_file.write(f"{datetime.now()} - {employee\['name']} realiz贸 la acci贸n: {func.\_\_name\_\_}\n")
return result
else:
print("ACCESO DENEGADO. Solo los administradores pueden acceder.")
return wrapper
\# Ejemplo de funci贸n que utiliza el decorador
@log\_employee\_action
def delete\_employee(employee):
print(f"El empleado {employee\['name']} ha sido eliminado.")
\# Crear empleados de ejemplo
admin = {'name': 'Carlos', 'role': 'admin'}
employee = {'name': 'Ana', 'role': 'employee'}
\# Intentar ejecutar la funci贸n con diferentes usuarios
delete\_employee(admin) # Esto deber铆a tener acceso y registrar la acci贸n
delete\_employee(employee) # Esto deber铆a denegar el acceso
from datetime import datetime
from functools import wraps
def log\_employee\_action(func):
@wraps(func)
def wrapper(employee, \*args, \*\*kwargs):
\# Ejecutar la funci贸n solo si el rol es 'admin'
if employee.get('role') == 'admin':
result = func(employee, \*args, \*\*kwargs)
\# Registrar la acci贸n en el archivo de log
with open("employee\_actions.log", "a") as log\_file:
log\_file.write(f"{datetime.now()} - {employee\['name']} realiz贸 la acci贸n: {func.\_\_name\_\_}\n")
return result
else:
print("ACCESO DENEGADO. Solo los administradores pueden acceder.")
return wrapper
\# Ejemplo de funci贸n que utiliza el decorador
@log\_employee\_action
def delete\_employee(employee):
print(f"El empleado {employee\['name']} ha sido eliminado.")
\# Crear empleados de ejemplo
admin = {'name': 'Carlos', 'role': 'admin'}
employee = {'name': 'Ana', 'role': 'employee'}
\# Intentar ejecutar la funci贸n con diferentes usuarios
delete\_employee(admin) # Esto deber铆a tener acceso y registrar la acci贸n
delete\_employee(employee) # Esto deber铆a denegar el acceso```js
```
```js
def log_employee_action(func):
def wrapper(employee):
# Verificar que el rol sea 'employee'
if employee.get('rol') == 'employee':
# Ejecutar la funci贸n y guardar el resultado
action_result = func(employee)
# Registrar la acci贸n en el archivo de log
with open("log.txt", "a") as log_file:
log_file.write(f"{employee['name']} realiz贸 una acci贸n.\n")
# Retornar el resultado de la funci贸n original
return action_result
else:
return "You are not an employee"
return wrapper
@log_employee_action
def employee_action(employee):
return f"Employee {employee['name']} is performing an action"
# Ejemplo de uso
employee = {'name': 'John', 'rol': 'employee'}
print(employee_action(employee)) # Esto ejecutar谩 la acci贸n y registrar谩 en el archivo
```def log\_employee\_action(func):聽 聽 def wrapper(employee):聽 聽 聽 聽 *# Verificar que el rol sea 'employee'*聽 聽 聽 聽 if employee.get('rol') == 'employee':聽 聽 聽 聽 聽 聽 *# Ejecutar la funci贸n y guardar el resultado*聽 聽 聽 聽 聽 聽 action\_result = func(employee)聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 *# Registrar la acci贸n en el archivo de log*聽 聽 聽 聽 聽 聽 with open("log.txt", "a") as log\_file:聽 聽 聽 聽 聽 聽 聽 聽 log\_file.write(f"{employee\['name']} realiz贸 una acci贸n.\n")聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 聽 *# Retornar el resultado de la funci贸n original*聽 聽 聽 聽 聽 聽 return action\_result聽 聽 聽 聽 else:聽 聽 聽 聽 聽 聽 return "You are not an employee"聽 聽 return wrapper
@log\_employee\_actiondef employee\_action(employee):聽 聽 return f"Employee {employee\['name']} is performing an action"
*# Ejemplo de uso*employee = {'name': 'John', 'rol': 'employee'}print(employee\_action(employee)) 聽*# Esto ejecutar谩 la acci贸n y registrar谩 en el archivo*
```python
def log_employee_action(func):
def wrapper():
with open('nuevo_txt.txt', 'x') as file:
activity = func('Daniel', 'entrega de inmueble')
file.write(activity)
return wrapper
@log_employee_action
def employee_action(name, action):
activity = f'El empleado {name} ha hecho {action}'
return activity
employee_action()
```def log\_employee\_action(func):聽 聽 def wrapper():聽 聽 聽 聽 with open('nuevo\_txt.txt', 'x') as file:聽 聽 聽 聽 聽 聽 activity = func('Daniel', 'entrega de inmueble')聽 聽 聽 聽 聽 聽 file.write(activity)聽 聽 聽 聽 聽 聽 聽 聽 return wrapper聽 聽 聽 聽
@log\_employee\_actiondef employee\_action(name, action):聽 聽 activity = f'El empleado {name} ha hecho {action}'聽 聽 return activity
employee\_action()
```python
from datetime import datetime
log_file = "log.txt"
def _log_transaction(message):
with open(log_file, "a") as f:
f.write(message + "\n")
def check_access(func):
def wrapper(employee):
# Comprobar si el empleado tiene rol 'admin'
if employee.get('role') == 'admin':
_log_transaction(f"Usuario {employee.get('name')} elimin贸 un empleado: {datetime.now()}")
return func(employee)
else:
print('ACCESO DENEGADO. Solo los administradores pueden acceder.')
_log_transaction(f"Usuario {employee.get('name')} intento eliminar un empleado: {datetime.now()}")
return wrapper
@check_access
def delete_employee(employee):
print(f"Elempleado {employee['name']} ha sido eliminado.")
admin = {'name': 'Carlos', 'role': 'admin'}
employee = {'name': 'Ana', 'role': 'employee'}
#delete_employee(admin)
delete_employee(employee)
```
```js
def log_employee_action(func):
def wrapper(employee):
with open('44_log.txt', 'a') as my_file:
my_file.write(f"1 - {employee.name} - {employee.accion}")
my_file.write("\n")
return func(employee)
return wrapper
class Employee:
name: str
accion: str
def __init__(self, name: str, accion: str) -> str:
self.name = name
self.accion = accion
@log_employee_action
def acciones(self):
print(f'2 - {self.name} realizo la accion {self.accion}')
emp1 = Employee('Mike', 'ingresa')
emp2 = Employee('Mike', 'sale')
emp1.acciones()
emp2.acciones()
```def log\_employee\_action(func):聽 聽 def wrapper(employee):聽 聽 聽 聽 with open('44\_log.txt', 'a') as my\_file:聽 聽 聽 聽 聽 聽 my\_file.write(f"1 - {employee.name} - {employee.accion}")聽 聽 聽 聽 聽 聽 my\_file.write("\n")聽 聽 聽 聽 return func(employee)聽 聽 return wrapper
class Employee:聽 聽 name: str聽 聽 accion: str
聽 聽 def \_\_init\_\_(self, name: str, accion: str) -> str:聽 聽 聽 聽 self.name = name聽 聽 聽 聽 self.accion = accion
聽 聽 @log\_employee\_action聽 聽 def acciones(self):聽 聽 聽 聽 print(f'2 - {self.name} realizo la accion {self.accion}')
emp1 = Employee('Mike', 'ingresa')emp2 = Employee('Mike', 'sale')emp1.acciones()emp2.acciones()
Implementaci贸n:
```python
def log_employee_action(func):
def wrapper(*args, **kwargs):
result = func(*args, **kwargs)
with open('acciones_empleados.txt', 'a') as archivo:
archivo.write(f"Acci贸n: {func.__name__}, Argumentos: {args}, {kwargs}\n")
return result
return wrapper
@log_employee_action
def realizar_accion_empleado(accion):
print(f"Empleado realiz贸 la acci贸n: {accion}")
realizar_accion_empleado("Iniciar turno")
realizar_accion_empleado("Finalizar turno")
```
```js
user2.report_action('logout', file_path)
```user2.report\_action('logout', file\_path)
```python
def log_employee_action(func):
def wrapper(employee):
with open('log.txt', 'a') as file:
file.write(f"{employee.name} - {func.__name__}")
file.write("\n")
return wrapper
class Employee:
name: str
def __init__(self, name: str):
self.name = name
@log_employee_action
def operacion(self):
print(f"{self.name} realiz贸 una operaci贸n")
gaston = Employee('Gaston')
gaston.operacion()
pablo = Employee('Pablo')
pablo.operacion()
```
Want to see more contributions, questions and answers from the community?