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
What are args and kwargs and how do they help you in programming?
In the world of programming, especially when working with functions, we encounter situations where the number of arguments we are going to receive is uncertain. This is where args and kwargs become indispensable allies. These mechanisms allow us to handle a variable number of arguments or parameters, giving flexibility and dynamism to the functions we create.
How to use *args for variable arguments?
*args is a tool used to receive an indefinite number of arguments. In Python, when we define a function and precede it with an asterisk *, we indicate that we are ready to receive multiple arguments.
def sum_numbers(*args): return sum(args)
# Call function with different number of argumentsprint(sum_numbers(1, 2, 3, 4, 4, 5)) # Return 15print(sum_numbers(1, 2)) # Return 3print(sum_numbers(7, 8, 9, 10, 10)) # Return 34.Considerations:
- The
argsare stored in an immutable tuple. - This method is ideal when the number of arguments the function will receive is not known in advance.
How to handle arguments with **kwargs?
When you need to work with arguments that have labels (i.e., key-value pairs), the appropriate method is **kwargs. By prefixing two asterisks ** to our variable, we indicate that we are ready to receive named arguments.
def print_info(**kwargs): for key, value in kwargs.items(): print(f"{key}: {value}")
# Function call with different argumentsprint_info(name="Carlos", age=30, city="Bogot谩")# Output:# name: Carlos# age: 30# city: Bogot谩.Important details:
kwargsis stored as a dictionary.- It offers flexibility to handle multiple parameters and modify them without altering the structure of the function.
How to combine args and kwargs in classes?
In object-oriented programming, it is also possible to use args and kwargs, especially to provide flexibility in class initialization.
class Employee: def __init__(self, name, *skills, **details): self.name = name self.skills = skills self.details = details
def show_info(self): print(f "Name: {self.name}") print(f "Skills: {self.skills}") print(f "Details: {self.details}")
# Creation of an object and instance of the classemployee = Employee("Carlos", "Python", "Java", "C++ ", age=30, city="Bogot谩")employee.show_info()What is unpacking and when to use it?
Unpacking allows you to extract values from lists or dictionaries and pass them to a function without having to specify each value individually. This can be done with either args (using *) or kwargs (using **).
def sum(a, b, c): return a + b + c
# Unpacked listvalues = [1, 2, 3]print(sum(*values)) # Return 6
def show_information(name, age): print(f "Name: {name}, Age: {age}")
# Unpacked dictionarydata = {'name': 'Carlos', 'age': 30}show_information(**data)Conclusions and best practice
To put these concepts into practice, we suggest you create functions that can receive price lists and applicable discounts using *args and **kwargs. The key is to discern when one approach or the other is necessary and how we can take advantage of the dynamism offered by these mechanisms.
Programming with args and kwargs not only offers greater flexibility, but also improves the readability and efficiency of our code. We encourage you to continue exploring these concepts and apply them in your daily projects.
Contributions 46
Questions 1
Sort by:
Aqu铆 mi soluci贸n al reto:
```python
class Venta:
def __init__(self, *args, **kwargs):
self.prices = args
self.discounts = kwargs
def calcular_total(self) -> int:
print("Calculando totales")
if self.discounts: #comprobamos si un descuento fue pasado como kwarg
for key, value in self.discounts.items(): #iteramos las claves y valores del diccionario kwarg
discount = value #asignamos el valor encontrado en 'value' a discount
return print(f"La suma total aplicando un descuento del {discount} % es: {sum(self.prices) * ((100 - discount) / 100)}")
else:
return print(f"La suma de total es: {sum(self.prices)}") #retornamos la suma de los 'args' si no hay descuento.
venta1 = Venta(200,300,400, discount=10)
venta2 = Venta(800,200)
venta1.calcular_total()
venta2.calcular_total()
```
Los par谩metros `\*args` y `\*\*kwargs` en Python son utilizados para pasar un n煤mero variable de argumentos a una funci贸n. Esto es 煤til cuando no se conoce de antemano cu谩ntos argumentos se van a pasar a la funci贸n. Vamos a desglosar cada uno de ellos:
\### `\*args`
\- \*\*Significado\*\*: `\*args` permite pasar un n煤mero variable de argumentos posicionales a una funci贸n. Cuando se utiliza, Python agrupa todos los argumentos adicionales que se pasan a la funci贸n en una tupla.
\- \*\*Uso\*\*: Se usa cuando no se sabe cu谩ntos argumentos se van a pasar a la funci贸n.
\#### Ejemplo de `\*args`
```python
def sumar(\*args):
total = 0
for numero in args:
total += numero
return total
resultado = sumar(1, 2, 3, 4, 5)
print(resultado) # Salida: 15
```
En este ejemplo, la funci贸n `sumar` puede aceptar cualquier cantidad de argumentos, y todos ellos se suman.
\### `\*\*kwargs`
\- \*\*Significado\*\*: `\*\*kwargs` permite pasar un n煤mero variable de argumentos nombrados (keyword arguments) a una funci贸n. Python agrupa todos los argumentos adicionales en un diccionario.
\- \*\*Uso\*\*: Se utiliza cuando se quieren pasar un n煤mero variable de argumentos con nombre.
\#### Ejemplo de `\*\*kwargs`
```python
def imprimir\_info(\*\*kwargs):
for clave, valor in kwargs.items():
print(f"{clave}: {valor}")
imprimir\_info(nombre="Juan", edad=30, ciudad="Bogot谩")
```
Salida:
```
nombre: Juan
edad: 30
ciudad: Bogot谩
```
En este caso, la funci贸n `imprimir\_info` recibe argumentos nombrados que se almacenan en un diccionario `kwargs`. Luego, se itera sobre ese diccionario para imprimir cada clave y su correspondiente valor.
\### Uso combinado de `\*args` y `\*\*kwargs`
Puedes usar `\*args` y `\*\*kwargs` en la misma funci贸n. Sin embargo, siempre debes poner `\*args` antes de `\*\*kwargs`.
\#### Ejemplo combinado
```python
def mostrar\_datos(\*args, \*\*kwargs):
print("Argumentos posicionales:", args)
print("Argumentos con nombre:", kwargs)
mostrar\_datos(1, 2, 3, nombre="Juan", edad=30)
```
Salida:
```
Argumentos posicionales: (1, 2, 3)
Argumentos con nombre: {'nombre': 'Juan', 'edad': 30}
```
\### Resumen
\- \*\*`\*args`\*\*: Para argumentos posicionales variables, se agrupan en una tupla.
\- \*\*`\*\*kwargs`\*\*: Para argumentos nombrados variables, se agrupan en un diccionario.
Ambos son herramientas poderosas que permiten a las funciones ser m谩s flexibles y adaptables a diferentes situaciones.
les comparto mi c贸digo
```python
class Venta:
def __init__(self, name, *args,**kwargs):
self.name = name
self.products = args
self.discounts = kwargs
self.res = {}
def discount(self):
self.res ={}
for product in self.products:
name, price= product
discount = self.discounts.get(name,0)
pricef=price*(1-discount/100)
self.res[name]=round(pricef,2)
return self.res
def show_venta(self):
print(f'Client : {self.name}')
print(f'Produtos',self.products)
print(f'Descuentos: {self.discounts}')
if self.res:
print(f'Descuentos aplicados: {self.res}')
else:
print('No se han aplicado descuentos a煤n.')
venta1 = Venta('Fer',('manzana',100),('pera',200), ('platano',330),manzana=10)
venta1.discount()
venta1.show_venta()
```
el resultado es
Saludos.
```python
"""
Crear una funci贸n que reciba una cantidad variable de productos y sus precios,
calcule el total y aplique un descuento opcional si se proporciona como un argumento con nombre.
1. Usar args para recibir una lista de precios
2. Usar kwargs para aceptar un descuento opcional y aplicarlo al total.
"""
def calcular_total(*args, **kwargs) -> float:
total = 0 # Variable para llevar el total de la orden
# Recorrer la lista de diccionarios de producto, cantidad y precio
for p in args[0]:
total += (p['cant'] * p['precio'])
#Validar si hay descuento
for key, value in kwargs.items():
print(f'{key}: {value}')
if key == 'descuento':
total = total - (total * value/100)
return total
# Ejemplo de uso
# Creo una orden, que ser铆a un diccionario de productos con sus cantidades y precios
orden = [
{'nombre': 'lapiz', 'cant': 2, 'precio': 3},
{'nombre': 'cuaderno', 'cant': 5, 'precio': 5},
{'nombre': 'compas', 'cant': 1, 'precio': 10},
{'nombre': 'regla', 'cant': 1, 'precio': 2},
{'nombre': 'sacapunta', 'cant': 2, 'precio': 5}
]
# Orden con descuento del 10%
print("El total de la compra con descuento es:", calcular_total(orden, descuento=10))
# Orden sin descuento
print("El total de la compra sin descuento es:", calcular_total(orden))
```"""Crear una funci贸n que reciba una cantidad variable de productos y sus precios, calcule el total y aplique un descuento opcional si se proporciona como un argumento con nombre.
1\. Usar args para recibir una lista de precios
2\. Usar kwargs para aceptar un descuento opcional y aplicarlo al total.
"""
def calcular\_total(\*args, \*\*kwargs) -> float:聽 聽 total = 0 # Variable para llevar el total de la orden聽 聽 # Recorrer la lista de diccionarios de producto, cantidad y precio聽 聽 for p in args\[0]:聽 聽 聽 聽 total += (p\['cant'] \* p\['precio'])聽 聽 #Validar si hay descuento聽 聽 for key, value in kwargs.items():聽 聽 聽 聽 print(f'{key}: {value}')聽 聽 聽 聽 if key == 'descuento':聽 聽 聽 聽 聽 聽 total = total - (total \* value/100)聽 聽 return total
\# Ejemplo de uso
\# Creo una orden, que ser铆a un diccionario de productos con sus cantidades y preciosorden = \[聽 聽 {'nombre': 'lapiz', 'cant': 2, 'precio': 3},聽 聽 {'nombre': 'cuaderno', 'cant': 5, 'precio': 5},聽 聽 {'nombre': 'compas', 'cant': 1, 'precio': 10},聽 聽 {'nombre': 'regla', 'cant': 1, 'precio': 2},聽 聽 {'nombre': 'sacapunta', 'cant': 2, 'precio': 5}]
\# Orden con descuento del 10%print("El total de la compra con descuento es:", calcular\_total(orden, descuento=10))
\# Orden sin descuentoprint("El total de la compra sin descuento es:", calcular\_total(orden))
```js
class factura_productos:
'''
Calcular el valor a pagar de una factura por una compra
recibiendo lista de productos, con nombre, cantidad y precio
El descuento es opcional y aplicado a toda la compra
Parametros:
args: descuento
kwargs: productos como lista de diccionarios
Retorna:
El valor a pagar con el descuento aplicado
'''
def __init__(self, *args, **kwargs):
self.descuento = args
self.productos = kwargs
def total_factura(self) -> float:
total = 0.0
for product in productos:
total += product['precio']*product['cantidad']
print("Sub Total:", total)
if descuento > 0:
total -= total*descuento/100
return total
def print_productos(self):
print("Lista de la compra.")
for producto in productos:
print(f"{producto['nombre']} Cantidad:{producto['cantidad']} \
Precio:${producto['precio']} Subtotal:${producto['cantidad']*producto['precio']}")
productos = [
{
"nombre": "jab貌n",
"precio": 5000,
"cantidad": 2,
},
{
"nombre": "servilletas",
"precio": 2000,
"cantidad": 1,
},
{
"nombre": "papitas",
"precio": 3000,
"cantidad":3,
}
]
#descuento en porcentaje
descuento = 10
aPagar = factura_productos(descuento, productos)
aPagar.print_productos()
print(f"Total a pagar: ${aPagar.total_factura()} descuento:{descuento}%")
```class factura\_productos: ''' Calcular el valor a pagar de una factura por una compra recibiendo lista de productos, con nombre, cantidad y precio El descuento es opcional y aplicado a toda la compra
Parametros: args: descuento kwargs: productos como lista de diccionarios
Retorna: El valor a pagar con el descuento aplicado ''' def \_\_init\_\_(self, \*args, \*\*kwargs): *self*.descuento = args *self*.productos = kwargs
def total\_factura(self) -> float: total = 0.0 for product in productos: total += product\['precio']\*product\['cantidad'] print("Sub Total:", total) if descuento > 0: total -= total\*descuento/100 return total def print\_productos(self): print("Lista de la compra.") for producto in productos: print(f"{producto\['nombre']} Cantidad:{producto\['cantidad']} \ Precio:${producto\['precio']} Subtotal:${producto\['cantidad']\*producto\['precio']}")
productos = \[ { "nombre": "jab貌n", "precio": 5000, "cantidad": 2, }, { "nombre": "servilletas", "precio": 2000, "cantidad": 1, }, { "nombre": "papitas", "precio": 3000, "cantidad":3, }]*#descuento en porcentaje*descuento = 10
aPagar = factura\_productos(descuento, productos)aPagar.print\_productos()print(f"Total a pagar: ${aPagar.total\_factura()} descuento:{descuento}%")
Adjunto mi soluci贸n:
```python
class Sale:
def __init__(self, *args,**kwargs):
self.prices = args
self.discount = kwargs
def discount_apply(self):
if self.discount:
print(f'The individual prices are: {self.prices}')
price = sum(self.prices)
print(f'The price without the discount is {price}')
discount = 0
for key, value in self.discount.items():
discount += value
print(f'The total discount is: {discount}')
total_price = price - (price*(discount/100))
print(f'The final price with the discount is: {total_price}')
else:
print(f'The individual prices are: {self.prices}')
print(f'The total price is: ',sum(self.prices))
sale1 = Sale(100,200,300, discount1 = 10, discount2= 20, discount3 = 5)
sale1.discount_apply()
```
Esto est谩 increbile!
esta clase me gusto mucho y resolvi贸 una duda como dice la profe que tenia hace mucho
```js
'''
Crear una funci贸n que reciba una cantidad variable de productos y sus precios.
1. Calcula el total.
2. Aplica un descuento opcional si se proporciona un argumento de descuento.
'''
class Sales:
def __init__ (self, name: str, *args, **kwargs): #Atributos de la clase de ventas, nombre y argumentos y keyword arguments
self.name = name
self.prices = args
self.discounts = kwargs
def adding_product(self): #Funci贸n que calcula la suma de productos y si hay descuentos los aplica igualmente
print("Calculo del total por ventas: ")
if self.discounts:
for key, value in self.discounts.items():
discount = value
return print(f"La suma total de {self.name} aplicando un descuento del {discount} % es: {sum(self.prices) * ((100 - discount) / 100)}")
return print(f"La suma total de {self.name} es: {sum(self.prices)}")
#Creaci贸n de dos ventas con sus datos
sale1 = Sales('Daniela', 200, 400, 2000, discount=10)
sale2 = Sales('Yesica Giraldo Tique', 200, 400, 2000, 5000000, 40000, discount=10)
#Activa la funcion de adicionar productos 1 y 2
sale1.adding_product()
sale2.adding_product()
```'''Crear una funci贸n que reciba una cantidad variable de productos y sus precios. 1. Calcula el total. 2. Aplica un descuento opcional 聽si se proporciona un argumento de descuento.
'''class Sales:聽 聽 def \_\_init\_\_ (self, name: str, \*args, \*\*kwargs): #Atributos de la clase de ventas, nombre y argumentos y keyword arguments聽 聽 聽 聽 self.name = name聽 聽 聽 聽 self.prices = args聽 聽 聽 聽 self.discounts = kwargs聽 聽 聽 聽 def adding\_product(self): #Funci贸n que calcula la suma de productos y si hay descuentos los aplica igualmente聽 聽 聽 聽 print("Calculo del total por ventas: ")聽 聽 聽 聽 if self.discounts:聽 聽 聽 聽 聽 聽 for key, value in self.discounts.items():聽 聽 聽 聽 聽 聽 聽 聽 discount = value聽 聽 聽 聽 聽 聽 return print(f"La suma total de {self.name} aplicando un descuento del {discount} % es: {sum(self.prices) \* ((100 - discount) / 100)}")聽 聽 聽 聽 return print(f"La suma total de {self.name} 聽es: {sum(self.prices)}")聽 聽 #Creaci贸n de dos ventas con sus datos 聽 聽 sale1 = Sales('Daniela', 200, 400, 2000, discount=10)sale2 = Sales('Yesica Giraldo Tique', 200, 400, 2000, 5000000, 40000, discount=10)
\#Activa la funcion de adicionar productos 1 y 2sale1.adding\_product()sale2.adding\_product()
My solution!!
1. ````python
class venta:
def __init__(self, *precio, **descuento):
self.precio = precio
self.descuento = descuento
def calcular_precio(self) -> float:
precio_final = sum(self.precio) * (sum(self.descuento.values()) / 100)
print({precio_final})
venta1 = venta(100, 200, 300, 400, 500, descuento1=10, descuento2=20, descuento3=30)
venta1.calcular_precio()
```class venta:聽 聽 def \_\_init\_\_(self, \*precio, \*\*descuento):聽 聽 聽 聽 self.precio = precio聽 聽 聽 聽 self.descuento = descuento聽 聽 聽 聽 聽 聽 def calcular\_precio(self) -> float:聽 聽 聽 聽 precio\_final = sum(self.precio) \* (sum(self.descuento.values()) / 100)聽 聽 聽 聽 print({precio\_final})
venta1 = venta(100, 200, 300, 400, 500, descuento1=10, descuento2=20, descuento3=30)venta1.calcular\_precio()
````
Les comparto mi soluci贸n:
```js
def calcular_precio(*args, **kwargs):
#Se suma el valor de los productos recibidos
subtotal = sum(args)
print('El subtotal de los productos es $', subtotal)
#Aqu铆 se realiza la operaci贸n por cada c贸digo de descuento recibido
for key, value in kwargs.items():
print(f'Aplicando el c贸digo {key.upper()} del {value}% de descuento...')
subtotal -= ((subtotal * value) / 100)
#Redondeando el valor
subtotal= round(subtotal, 2)
print(f'Total a pagar: $', subtotal)
return subtotal
# calcular_precio(5.15,45.00,9.99,12.10, temporada_15 = 15)
calcular_precio(5.15,45.00,9.99,12.10,50.25,16.32, temporada_15 = 15, trump_nos_shingo = 20)
```
Aqu铆 el ejercicio propuesto en clases no se si entend铆 bien, pero lo resolv铆 de la siguiente manera us茅 una Clases para agregar algo m谩s, pero funciona cualquier comentario es bienvenido
```python
class Producto:
def __init__(self, nombre, precio):
self.nombre = nombre
self.precio = precio
def __str__(self):
return f'Nombre: {self.nombre}, Precio: {self.precio}'
def productos_descuento(*productos, **kwargs):
# Extraemos el valor de 'porcentaje' del diccionario kwargs.
# Si no se pasa 'porcentaje', se asume 0.
porcentaje = kwargs.get('porcentaje', 0)
for producto in productos:
if porcentaje == 0:
print(f'No hay descuento para {producto.nombre}, precio: {producto.precio}')
else:
precio_final = producto.precio - (producto.precio * porcentaje)
print(f'El precio de {producto.nombre} con descuento {porcentaje} es: {precio_final}')
lista_productos = [
Producto('Camisa', 500),
Producto('Pantalon', 1000),
Producto('Zapatos', 1500),
Producto('Gorra', 200),
Producto('Cinturon', 300),
Producto('Calcetines', 1123654.5),
]
# Ejemplos de uso:
print('Ejemplos de uso:')
productos_descuento(*lista_productos, porcentaje=0) # Sin descuento
print('-'*50)
productos_descuento(*lista_productos, porcentaje=0.1) # Aplica un 10% de descuento
print('-'*50)
productos_descuento(*lista_productos, porcentaje = 0.5) # Aplica un 50% # Sin descuento
print('-'*50)
```class Producto:聽 聽 def \_\_init\_\_(self, nombre, precio):聽 聽 聽 聽 self.nombre = nombre聽 聽 聽 聽 self.precio = precio聽 聽 聽 聽 def \_\_str\_\_(self):聽 聽 聽 聽 return f'Nombre: {self.nombre}, Precio: {self.precio}'
def productos\_descuento(\*productos, \*\*kwargs):聽 聽 # Extraemos el valor de 'porcentaje' del diccionario kwargs.聽 聽 # Si no se pasa 'porcentaje', se asume 0.聽 聽 porcentaje = kwargs.get('porcentaje', 0)聽 聽 聽 聽 for producto in productos:聽 聽 聽 聽 if porcentaje == 0:聽 聽 聽 聽 聽 聽 print(f'No hay descuento para {producto.nombre}, precio: {producto.precio}')聽 聽 聽 聽 else:聽 聽 聽 聽 聽 聽 precio\_final = producto.precio - (producto.precio \* porcentaje)聽 聽 聽 聽 聽 聽 print(f'El precio de {producto.nombre} con descuento {porcentaje} es: {precio\_final}')
lista\_productos = \[聽 聽 Producto('Camisa', 500),聽 聽 Producto('Pantalon', 1000),聽 聽 Producto('Zapatos', 1500),聽 聽 Producto('Gorra', 200),聽 聽 Producto('Cinturon', 300),聽 聽 Producto('Calcetines', 1123654.5),]
\# Ejemplos de uso:print('Ejemplos de uso:')productos\_descuento(\*lista\_productos, porcentaje=0) 聽 聽 聽# Sin descuentoprint('-'\*50)productos\_descuento(\*lista\_productos, porcentaje=0.1) 聽 聽# Aplica un 10% de descuentoprint('-'\*50)productos\_descuento(\*lista\_productos, porcentaje = 0.5) 聽# Aplica un 50% 聽 聽 聽 聽 聽 聽 聽 聽 聽# Sin descuentoprint('-'\*50)```js
```
Apreciados les envio codigo de descuento por proudcto:
class Venta:聽 聽 def \_\_init\_\_(self, \*args, \*\*kwargs):聽 聽 聽 聽 self.productos = list(args) 聽# Lista de tuplas (nombre, precio)聽 聽 聽 聽 self.descuentos = kwargs
聽 聽 聽 聽 print(f"Productos: {self.productos}") 聽# Imprime el contenido de la lista de productos聽 聽 聽 聽 print(f"Descuentos: {self.descuentos}") 聽# Imprime el contenido del diccionario de descuentos
聽 聽 def calcular\_total(self) -> int:聽 聽 聽 聽 print("Calculando totales")聽 聽 聽 聽 total = 0聽 聽 聽 聽 for i, (nombre, precio) in enumerate(self.productos):聽 聽 聽 聽 聽 聽 descuento = self.descuentos.get(f'producto{i}', 0)聽 聽 聽 聽 聽 聽 precio\_con\_descuento = precio \* (1 - descuento)聽 聽 聽 聽 聽 聽 print(f"{nombre}: Precio original = {precio}, Descuento = {descuento\*100}%, Precio con descuento = {precio\_con\_descuento}")聽 聽 聽 聽 聽 聽 total += precio\_con\_descuento聽 聽 聽 聽 return print(f"La suma total es: {total}")
\# Ejemplo de usoventa1 = Venta(('Tomate', 200), ('Lechuga', 300), ('Pescado', 400), producto0=0.10, producto2=0.05)venta2 = Venta(('Carne', 800), ('Pollo', 200))
venta1.calcular\_total()venta2.calcular\_total()
```python
def totalize_order(*args, **kwargs):
total = 0
for item in args:
total += item["price"]
print(f"The total price is {total}")
if "discount" in kwargs:
total *= 1 - kwargs["discount"] / 100
print(f"The total price with discount is {total}")
return total
items = (
{"name": "Laptop", "price": 1500},
{"name": "Mouse", "price": 50},
{"name": "Keyboard", "price": 100},
{"name": "Monitor", "price": 300},
)
totalize_order(*items, discount=10)
```
```python
from datetime import datetime
import json
class Ventas:
def __init__(self, *args, store, client, date):
self.store = store
self.client = client
self.date = date
self.products = args
def show_products(self) -> json:
final_ticket = {}
total_price = 0
total_discount = 0
count = 0
final_ticket[self.client] = {
"store": self.store,
"date": self.date.isoformat(),
"productos": {}
}
lista = list(self.products)
for i, fila in enumerate(lista):
for j, valor in enumerate(fila):
product = str(lista[i][j][0])
price = float(lista[i][j][1])
discount = float(lista[i][j][2])
total_price += price
total_discount += discount
discount_name = str("Discoount_"+str(count))
final_ticket[self.client]["productos"].update({
product: price,
discount_name: discount
})
count += 1
final_ticket[self.client]["productos"].update({
"total_discounts": (total_discount)
})
final_ticket[self.client]["productos"].update({
"total_price": (total_price - total_discount)
})
return json.dumps(final_ticket, indent=4)
# La variable ticket se utiliza para **kwargs, se utiliza desempaquetando los argumentos.
ticket = {
"store": "Mercado zapatoca",
"client": "Cristian David Mora Saenz",
"date": datetime.now().date()
}
# La variable products se utiliza para *args
products = [
["manzana",30.5, 10.8],
["Leche", 50.5, 0.1]
]
obj = Ventas(products, **ticket)
print(obj.show_products())
```
Mi soluci贸n al reto:
```python
"""
Reto51
*Crear una funci贸n que reciba una cantidad variable de productos y sus precios, calcule
el total y aplique un descuento opcional si se proporciona como un argumento con su nombre
usar args para recibir una lista de precios
usar kwargs para aceptar un descuento opcional y aplicarlo al total
"""
def verificar_estado_producto(funcion):
def envoltorio(self,producto):
if producto not in self.lista_productos:
print(f"El producto '{producto.nombre}', id '{producto.detalles['id']}' no se encuentra registrado")
return
return funcion(self,producto)
return envoltorio
class Supermercado:
nombre:str
lista_productos: list
def __init__(self,nombre):
self.nombre = nombre
self.lista_productos=[]
@verificar_estado_producto
def mostrar_producto(self,producto):
if producto in self.lista_productos:
precio_neto = producto.detalles['precio']
promocion = 500 if producto.detalles.get('promocion',False) else 0
descuento = producto.detalles.get('descuento',0) * precio_neto
precio_final = precio_neto - promocion - descuento
return precio_final
return None
def ingresar_producto(self,producto):
if not producto in self.lista_productos:
self.lista_productos.append(producto)
print(f'Se ha agregado un nuevo producto: \nProducto: {producto.nombre}, id: {producto.detalles['id']}')
else:
print(f'El producto que busca ingresar Producto: {producto.nombre}, id: {producto.detalles['id']}, ya se encuentra registrado')
@verificar_estado_producto
def eliminar_producto(self,producto):
if producto in self.lista_productos:
self.lista_productos.remove(producto)
print('El producto ya se ha retirado de la lista')
@verificar_estado_producto
def verificar_producto(self,producto):
for producto in self.lista_productos:
print(f'Producto: {producto.nombre} \n Categorias: {producto.categoria} \n Detalles: {producto.detalles}')
class Producto:
id: int
nombre:str
categoria:list
detalles:dict
def __init__(self,nombre,*args, **kwargs):
self.nombre = nombre
self.categoria = args
self.detalles = kwargs
def mostrar_producto(self):
print(f'Producto: {self.nombre} \n Categorias: {self.categoria} \n Detalles: {self.detalles}')
def buscar_producto(self):
pass
def activar_descuento(self):
if self.detalles['descuento'] == False:
self.detalles['descuento'] = True
print('Se ha activado el descuento')
else:
print('El producto ya tiene descuento activado')
def desactivar_descuento(self):
self.detalles['descuento'] = False
print('Se ha desactivado el descuento')
class Compra:
id:int
lista_compras: tuple
total: float
def __init__(self, id, *args):
self.id = id
self.lista_compras = args
self.total = 0
def comprar_productos(self,supermercado):
print('Detalle de la compra: ')
for producto in self.lista_compras:
precio_producto = supermercado.mostrar_producto(producto)
self.total = self.total + precio_producto
print(f'Producto: {producto.nombre}, Precio neto: {producto.detalles['precio']}, Precio venta {precio_producto}')
print(f'El precio total de la compra es de: {self.total}')
if __name__=="__main__":
#registrar los productos
producto1 = Producto('Jabon', 'limpieza', 'productos del hogar', 'cuidado personal', id=1534, precio = 14000, promocion= True)
producto2 = Producto('Champo', 'limpieza', 'productos del hogar', 'cuidado personal','ba帽o', id=1880, precio = 10000, promocion= True, descuento=0.1)
producto3 = Producto('crema', 'limpieza', 'productos del hogar', 'cuidado personal', id=1548, precio = 18000, promocion= False)
producto4 = Producto('acondicionador', 'limpieza', 'productos del hogar', 'cuidado personal','ba帽o', id=1180, precio = 5000, promocion= False, descuento=0.3)
#registrar el supermercado
supermercado1 = Supermercado("La total")
#registrar los productos en el supermercado
supermercado1.ingresar_producto(producto1)
supermercado1.ingresar_producto(producto2)
supermercado1.ingresar_producto(producto3)
supermercado1.ingresar_producto(producto4)
#Crear una compra de x productos
compra1 = Compra(125,producto1,producto2,producto4)
#Realizar la compra
compra1.comprar_productos(supermercado1)
```
```python
"""
crear una funcion que reciba una cantidad variable de productos y sus precios, calcule el total y aplique un descuento opcional si se proporciona como un argumento con nombre.
1. usar args para recibir una lista de precios.
2. usar kwargs para aceptar un descuento opcional y aplicarlo al total.
"""
class SellingManager:
def __init__(self, *args, **kwargs):
self.prices = args
self.discounts = kwargs
def __str__(self):
return f"Total prices: {self.calculate_prices()}, Discounts: {self.calculate_discount() * 100}%, total: {self.calculate_total()}"
def calculate_discount(self) -> float:
"""
return the total percentage of discounts
"""
if self.discounts:
discount = sum(self.discounts.values())
return discount
return 0
def calculate_prices(self):
"""
return the total prices of the products
"""
total_prices = sum(self.prices)
return total_prices
def calculate_total(self):
"""
return the total price after applying the discount
"""
prices = self.calculate_prices()
discount = self.calculate_discount()
total = prices - (prices * discount)
return total
sm = SellingManager(100, 200, 300, 600, 1200, discount1=.15, discount2=.20)
print(sm)
```
```js
print("")
print("* Ejercicio 1:")
print("- Uso de *args y **kwargs para funciones y clases.")
print("")
def sum_numbers(*args):
"""
Suma una cantidad variable de n煤meros.
Esta funci贸n utiliza *args para aceptar cualquier n煤mero de argumentos
posicionales y los suma.
Args:
*args: Una tupla de n煤meros.
Returns:
La suma de todos los n煤meros en args.
"""
return sum(args)
# Ejemplos de uso de sum_numbers:
resultado = sum_numbers(1, 2, 3, 4)
print(f"Suma de 1, 2, 3, 4: {resultado}") # Salida: 10
resultado = sum_numbers(1, 2, 3, 4, 10)
print(f"Suma de 1, 2, 3, 4, 10: {resultado}") # Salida: 20
resultado = sum_numbers(1, 20, 30, 4, 10)
print(f"Suma de 1, 20, 30, 4, 10: {resultado}") # Salida: 65
def print_info(**kwargs):
"""
Imprime informaci贸n de un diccionario de argumentos de palabra clave.
Esta funci贸n utiliza **kwargs para aceptar cualquier n煤mero de argumentos
de palabra clave y los imprime en un formato legible.
Args:
**kwargs: Un diccionario de argumentos de palabra clave.
"""
for key, value in kwargs.items():
print(f"Key: {key} | Valor: {value}")
# Ejemplos de uso de print_info:
print_info(name='Carlos', age=39, city='Bogot谩')
# Salida:
# Key: name | Valor: Carlos
# Key: age | Valor: 39
# Key: city | Valor: Bogot谩
print_info(name='Carlos', age=39, city='Bogot谩', country="Colombia")
# Salida:
# Key: name | Valor: Carlos
# Key: age | Valor: 39
# Key: city | Valor: Bogot谩
# Key: country | Valor: Colombia
class Employee:
"""
Clase Employee que utiliza *args y **kwargs en su constructor.
Esta clase demuestra c贸mo usar *args y **kwargs en el constructor de una
clase para aceptar una cantidad variable de argumentos posicionales y de
palabra clave.
"""
def __init__(self, name, *args, **kwargs):
"""
Constructor de la clase Employee.
Args:
name: El nombre del empleado (str).
*args: Una tupla de habilidades del empleado (str).
**kwargs: Un diccionario de detalles adicionales del empleado.
"""
self.name = name
self.skills = args
self.detail = kwargs
def show_info_employee(self):
"""
Imprime la informaci贸n del empleado.
"""
print(f"Employee: {self.name}")
print(f"Skills: {self.skills}")
print(f"Details: {self.detail}")
# Ejemplo de uso de la clase Employee:
employee = Employee('Alexis Dorado', 'Python', 'C#', 'Js', age=30, ciudad="Popay谩n", country="Colombia")
employee.show_info_employee()
# Salida:
# Employee: Alexis Dorado
# Skills: ('Python', 'C#', 'Js')
# Details: {'age': 30, 'ciudad': 'Popay谩n', 'country': 'Colombia'}
print("")
print("* Ejercicio 1:")
print("- Desempaquetando una lista o tupla de argumentos en una funci贸n.")
print("")
def add(a, b, c):
"""
Suma tres n煤meros.
Args:
a: El primer n煤mero.
b: El segundo n煤mero.
c: El tercer n煤mero.
Returns:
La suma de los tres n煤meros.
"""
return a + b + c
# Desempaquetar una tupla de valores en la funci贸n add
values = (1, 2, 3) # Tupla de valores
resultado = add(*values) # Desempaquetar la tupla usando *
print(f"Suma de {values}: {resultado}") # Salida: Suma de (1, 2, 3): 6
print("")
print("* Ejercicio 2:")
print("- Desempaquetando un diccionario de argumentos de palabra clave en una funci贸n.")
print("")
def show_info(name, age):
"""
Imprime informaci贸n sobre una persona.
Args:
name: El nombre de la persona.
age: La edad de la persona.
"""
print(f"Name: {name} | Age: {age}")
# Desempaquetar un diccionario de datos en la funci贸n show_info
data = {"name": "Alexis", "age": 33}
show_info(**data) # Desempaquetar el diccionario usando **
# Salida: Name: Alexis | Age: 33
```
```js
print("")
print("* Ejercicio 1:")
print("- Uso de *args y **kwargs para funciones y clases.")
print("")
def sum_numbers(*args):
"""
Suma una cantidad variable de n煤meros.
Esta funci贸n utiliza *args para aceptar cualquier n煤mero de argumentos
posicionales y los suma.
Args:
*args: Una tupla de n煤meros.
Returns:
La suma de todos los n煤meros en args.
"""
return sum(args)
# Ejemplos de uso de sum_numbers:
resultado = sum_numbers(1, 2, 3, 4)
print(f"Suma de 1, 2, 3, 4: {resultado}") # Salida: 10
resultado = sum_numbers(1, 2, 3, 4, 10)
print(f"Suma de 1, 2, 3, 4, 10: {resultado}") # Salida: 20
resultado = sum_numbers(1, 20, 30, 4, 10)
print(f"Suma de 1, 20, 30, 4, 10: {resultado}") # Salida: 65
def print_info(**kwargs):
"""
Imprime informaci贸n de un diccionario de argumentos de palabra clave.
Esta funci贸n utiliza **kwargs para aceptar cualquier n煤mero de argumentos
de palabra clave y los imprime en un formato legible.
Args:
**kwargs: Un diccionario de argumentos de palabra clave.
"""
for key, value in kwargs.items():
print(f"Key: {key} | Valor: {value}")
# Ejemplos de uso de print_info:
print_info(name='Carlos', age=39, city='Bogot谩')
# Salida:
# Key: name | Valor: Carlos
# Key: age | Valor: 39
# Key: city | Valor: Bogot谩
print_info(name='Carlos', age=39, city='Bogot谩', country="Colombia")
# Salida:
# Key: name | Valor: Carlos
# Key: age | Valor: 39
# Key: city | Valor: Bogot谩
# Key: country | Valor: Colombia
class Employee:
"""
Clase Employee que utiliza *args y **kwargs en su constructor.
Esta clase demuestra c贸mo usar *args y **kwargs en el constructor de una
clase para aceptar una cantidad variable de argumentos posicionales y de
palabra clave.
"""
def __init__(self, name, *args, **kwargs):
"""
Constructor de la clase Employee.
Args:
name: El nombre del empleado (str).
*args: Una tupla de habilidades del empleado (str).
**kwargs: Un diccionario de detalles adicionales del empleado.
"""
self.name = name
self.skills = args
self.detail = kwargs
def show_info_employee(self):
"""
Imprime la informaci贸n del empleado.
"""
print(f"Employee: {self.name}")
print(f"Skills: {self.skills}")
print(f"Details: {self.detail}")
# Ejemplo de uso de la clase Employee:
employee = Employee('Alexis Dorado', 'Python', 'C#', 'Js', age=30, ciudad="Popay谩n", country="Colombia")
employee.show_info_employee()
# Salida:
# Employee: Alexis Dorado
# Skills: ('Python', 'C#', 'Js')
# Details: {'age': 30, 'ciudad': 'Popay谩n', 'country': 'Colombia'}
```print("")print("\* Ejercicio 1:")print("- Uso de \*args y \*\*kwargs para funciones y clases.")print("")
def sum\_numbers(\*args):聽 聽 """聽 聽 Suma una cantidad variable de n煤meros.
聽 聽 Esta funci贸n utiliza \*args para aceptar cualquier n煤mero de argumentos聽 聽 posicionales y los suma.
聽 聽 Args:聽 聽 聽 聽 \*args: Una tupla de n煤meros.
聽 聽 Returns:聽 聽 聽 聽 La suma de todos los n煤meros en args.聽 聽 """聽 聽 return sum(args)
*# Ejemplos de uso de sum\_numbers:*resultado = sum\_numbers(1, 2, 3, 4)print(f"Suma de 1, 2, 3, 4: {resultado}") 聽*# Salida: 10*
resultado = sum\_numbers(1, 2, 3, 4, 10)print(f"Suma de 1, 2, 3, 4, 10: {resultado}") 聽*# Salida: 20*
resultado = sum\_numbers(1, 20, 30, 4, 10)print(f"Suma de 1, 20, 30, 4, 10: {resultado}") 聽*# Salida: 65*
def print\_info(\*\*kwargs):聽 聽 """聽 聽 Imprime informaci贸n de un diccionario de argumentos de palabra clave.
聽 聽 Esta funci贸n utiliza \*\*kwargs para aceptar cualquier n煤mero de argumentos聽 聽 de palabra clave y los imprime en un formato legible.
聽 聽 Args:聽 聽 聽 聽 \*\*kwargs: Un diccionario de argumentos de palabra clave.聽 聽 """聽 聽 for key, value in kwargs.items():聽 聽 聽 聽 print(f"Key: {key} | Valor: {value}")
*# Ejemplos de uso de print\_info:*print\_info(name='Carlos', age=39, city='Bogot谩')*# Salida:# Key: name | Valor: Carlos# Key: age | Valor: 39# Key: city | Valor: Bogot谩*
print\_info(name='Carlos', age=39, city='Bogot谩', country="Colombia")*# Salida:# Key: name | Valor: Carlos# Key: age | Valor: 39# Key: city | Valor: Bogot谩# Key: country | Valor: Colombia*
class Employee:聽 聽 """聽 聽 Clase Employee que utiliza \*args y \*\*kwargs en su constructor.
聽 聽 Esta clase demuestra c贸mo usar \*args y \*\*kwargs en el constructor de una聽 聽 clase para aceptar una cantidad variable de argumentos posicionales y de聽 聽 palabra clave.聽 聽 """聽 聽 def \_\_init\_\_(self, name, \*args, \*\*kwargs):聽 聽 聽 聽 """聽 聽 聽 聽 Constructor de la clase Employee.
聽 聽 聽 聽 Args:聽 聽 聽 聽 聽 聽 name: El nombre del empleado (str).聽 聽 聽 聽 聽 聽 \*args: Una tupla de habilidades del empleado (str).聽 聽 聽 聽 聽 聽 \*\*kwargs: Un diccionario de detalles adicionales del empleado.聽 聽 聽 聽 """聽 聽 聽 聽 self.name = name聽 聽 聽 聽 self.skills = args聽 聽 聽 聽 self.detail = kwargs
聽 聽 def show\_info\_employee(self):聽 聽 聽 聽 """聽 聽 聽 聽 Imprime la informaci贸n del empleado.聽 聽 聽 聽 """聽 聽 聽 聽 print(f"Employee: {self.name}")聽 聽 聽 聽 print(f"Skills: {self.skills}")聽 聽 聽 聽 print(f"Details: {self.detail}")
*# Ejemplo de uso de la clase Employee:*employee = Employee('Alexis Dorado', 'Python', 'C#', 'Js', age=30, ciudad="Popay谩n", country="Colombia")employee.show\_info\_employee()*# Salida:# Employee: Alexis Dorado# Skills: ('Python', 'C#', 'Js')# Details: {'age': 30, 'ciudad': 'Popay谩n', 'country': 'Colombia'}*
```python
def collect_money(*args, **kwargs):
price = sum(args)
if kwargs:
total, discount_value = apply_discount(price, **kwargs)
print(f'Discount {discount_value} applied, the total is: {total}')
else:
print(f"No discount, the total is: {price}")
def apply_discount(price, **kwargs):
discount_value = 0
for key, value in kwargs.items():
discount_value += value
total = price - ((discount_value / 100) * price)
return total, discount_value
collect_money(129900, 429900, 329900, 789900, amigazo=10, panita=5)
```def collect\_money(\*args, \*\*kwargs):
聽 聽 price = sum(args)
聽 聽 if kwargs:
聽 聽 聽 聽 total, discount\_value = apply\_discount(price, \*\*kwargs)聽 聽 聽 聽 print(f'Discount {discount\_value} applied, the total is: {total}')
聽 聽 else:
聽 聽 聽 聽 print(f"No discount, the total is: {price}")
def apply\_discount(price, \*\*kwargs):
聽 聽 discount\_value = 0
聽 聽 for key, value in kwargs.items():
聽 聽 聽 聽 discount\_value += value
聽 聽 total = 聽price - ((discount\_value / 100) \* price)
聽 聽 return total, discount\_value
collect\_money(129900, 429900, 329900, 789900, amigazo=10, panita=5)
Reto completado:
```js
def total_calculate(discount_rate: int, discount_product: str, *args, **kwargs, ) -> float:
total: float = sum(args)
print(kwargs)
if discount_product in kwargs:
total -= total * discount_rate / 100
return total
products: list = [{'name': 'laptop', 'price': 800}, {'name': 'mouse', 'price': 40}, {'name': 'monitor', 'price': 400}]
prices: list = list(map(lambda product: product['price'], products))
discount_rate: int = 10
discount_product: str = 'monitor'
args_products: dict = {product['name']: product['price'] for product in products}
print(f'Total: {total_calculate(discount_rate, discount_product, *prices, **args_products)}\n {f'Descuento: {discount_rate}%' if any(product['name'] == discount_product for product in products) else "No hay descuento"}')
```
Les dejo los c贸digos que hice, fueron dos, uno donde se toman directamente las cantidades cuando se ejecuta el c贸digo y otro donde las cantidades se toman de un array de objetos:
El primero:
```python
class Producto:
def __init__(self, *price, ** discount):
self.price = price
self.discount = discount
def show_total(self):
print(f"El total de los productos es: {sum(self.price)}")
if self.discount:
#Se convierte el descuento de dict a lista para manipularlo
#despues
total_discount = list(dict.values(self.discount))
total = sum(self.price) - ((sum(self.price) / 100) * total_discount[0])
print(f"El total menos el descuento es: {total}")
product1 = Producto(1,2,3,4,5)
product2 = Producto(10,20,30,40,50, discount=40)
product1.show_total()
product2.show_total()
```El segundo:
```python
products = [
{'Galletas': 18},
{'Papitas': 20},
{'Coca-cola': 22},
{'product': 16}
]
def total_product(*productos, **discount) -> float:
total_price = []
#Se usa la posicion 0 de productos porque arg hace que se cree una
#lista de listas y como solo tenemos una usamos la posici贸n 0
for prod in productos[0]:
#Se convierten los precios de tipo dict a lista para poder
#hacer un append a otra lista y guardar los numeros
totalP = list(dict.values(prod))
total_price.append(totalP[0])
total = sum(total_price)
#Si discount no existe se retorna el total
if not discount:
return f"El total de los productos es {total}"
else:
#Se hace la formula para saber el total final menos el descuento
disc = list(dict.values(discount))
total = total - ((total/100) * disc[0])
return f"El total de los productos menos el descuento es {total}"
products1 = total_product(products)
products2 = total_product(products, discount=50)
print(products1)
print(products2)
```
Intent茅 hacer el reto mediante funciones y ya, luego me di cuenta que era mejor hacerlo en una clase y porque me confund铆a mucho a la hora de asignar el \*arg y el \*\*kwarg, as铆 que as铆 me qued贸:
```python
class Factura:
def __init__(self, *args, **kwargs):
self.precios = args
self.descuento = kwargs
self.total = 0
self.factura = 0
def suma_productos(self):
total = 0
for precio in self.precios:
total += precio
self.total = total
print(f'El costo total de los productos es: {total}')
def calculo_factura(self):
self.factura = self.total-(self.descuento['descuento']*self.total)
print(f'El valor del descuento es de: ${self.descuento['descuento']*self.total}')
print(f'El valor de facturaci贸n es de: ${self.factura}')
factura1 = Factura(1000,1500,1200,2800,10200, descuento = 0.1)
factura1.suma_productos()
factura1.calculo_factura()
```class Factura:聽 聽 def \_\_init\_\_(self, \*args, \*\*kwargs):聽 聽 聽 聽 self.precios = args聽 聽 聽 聽 self.descuento = kwargs聽 聽 聽 聽 self.total = 0聽 聽 聽 聽 self.factura = 0聽 聽 聽 聽 聽 聽 def suma\_productos(self):聽 聽 聽 聽 total = 0聽 聽 聽 聽 for precio in self.precios:聽 聽 聽 聽 聽 聽 total += precio聽 聽 聽 聽 聽 聽 self.total = total聽 聽 聽 聽 print(f'El costo total de los productos es: {total}')聽 聽 聽 聽 聽 聽 def calculo\_factura(self):聽 聽 聽 聽 self.factura = self.total-(self.descuento\['descuento']\*self.total)聽 聽 聽 聽 print(f'El valor del descuento es de: ${self.descuento\['descuento']\*self.total}')聽 聽 聽 聽 print(f'El valor de facturaci贸n es de: ${self.factura}')聽 聽 聽 聽 factura1 = Factura(1000,1500,1200,2800,10200, descuento = 0.1)factura1.suma\_productos()factura1.calculo\_factura()
```python
def calcular_total(*productos,descuento=0):
#Calcular el total de una lista de productos y aplica un descuento opcional
"""
Args:
*productos: Una lista variable de tuplas (nombre,precio) de productos
*descuento (float,opcional): Porcentaje de descuento a aplicar. Defaults a 0.
Returns:
float:El total con descuento (si se proporciona)
"""
total = sum(precio for _,precio in productos)
if descuento:
total *= (1 - descuento / 100)
return total
productos = [("Laptop",10),("Tablet", 20), ("Mouse", 30)]
descuento = 10
total = calcular_total(*productos,descuento=descuento)
print(total)
```
```python
productos = [{'product': 'cafe', 'price': 2000},
{'product': 'leche', 'price': 4000},
{'product': 'pan', 'price': 1000},
{'product': 'huevos', 'price': 600},
{'product': 'chocolate', 'price': 1500},
{'product': 'arroz', 'price': 2000},
]
def total_products(*otros, **productos):
precios = [x['price'] for x in otros]
total = sum(precios)
if 'descuento' in productos:
des = productos['descuento']
return total-((total/100)*des)
else:
return total
print(total_products(*productos))
```productos = \[{'product': 'cafe', 'price': 2000}, {'product': 'leche', 'price': 4000}, {'product': 'pan', 'price': 1000}, {'product': 'huevos', 'price': 600}, {'product': 'chocolate', 'price': 1500}, {'product': 'arroz', 'price': 2000}, ]
def total\_products(\*otros, \*\*productos): precios = \[x\['price'] for x in otros] total = sum(precios) if 'descuento' in productos: des = productos\['descuento'] return total-((total/100)\*des) else: return total print(total\_products(\*productos))
este es mi humilde aporte
Hola! dejo mi soluci贸n al reto del final de la clase:
```js
def calc_price(*args, **kwargs):
"""Given a list of prices of items, this function will calculate the total. It also includes the possibility
to add a discount to the total amount"""
total = 0
for price in args:
total += price
print("You have to pay: $",total)
if kwargs:
discount = 0 # in %
for key, item in kwargs.items():
print(f"{key}: {item}")
discount += item
print("Total discount applied: ", discount,"%")
total_discounted = (discount*total)/100
print("With Discount applied: $", total-total_discounted)
calc_price(12.5,34,23.4,9.99,2, student_discount=10, first_responder_discount=20)
```def calc\_price(\*args, \*\*kwargs): """Given a list of prices of items, this function will calculate the total. It also includes the possibility to add a discount to the total amount""" total = 0 for price in args: total += price
print("You have to pay: $",total)
if kwargs: discount = 0 # in % for key, item in kwargs.items(): print(f"{key}: {item}") discount += item print("Total discount applied: ", discount,"%") total\_discounted = (discount\*total)/100 print("With Discount applied: $", total-total\_discounted)
calc\_price(12.5,34,23.4,9.99,2, student\_discount=10, first\_responder\_discount=20)
Trate de poner un poco m谩s en practica asi que decid铆 darle un descuento distinto seg煤n producto. Espero les guste.class Markert:聽 聽
```python
class Markert:
def __init__(self, *args, **kwargs):
self.products = args
self.discounts = kwargs
def total_bill(self):
"""
Calcula el total de cada producto seg煤n su precio y cantidad
"""
total = 0
for product in self.products:
if product['name'] in self.discounts:
total += (product['value'] * product['cuantity']) / ((self.discounts[product['name']]/100) + 1)
print(f"Producto: {product['name']}, cantidad: {product['cuantity']}, valor: {product['value']}, descuento: {self.discounts[product['name']]}%")
else:
total += product['value'] * product['cuantity']
print(f"Producto: {product['name']}, cantidad: {product['cuantity']}, valor: {product['value']}")
print(f"Total: {total}")
descuentos = { 'Manzanas':25, 'Bananos':4, 'Patilla':10 }
products = [
{
"name": "Manzanas",
"value": 20,
"cuantity": 1,
},
{
"name": "Bananos",
"value": 10,
"cuantity": 2,
},
{
"name": "Patilla",
"value": 20,
"cuantity": 4,
},
{
"name": "Pina",
"value": 30,
"cuantity": 1,
},
{
"name": "Mango",
"value": 15,
"cuantity": 1,
},
{
"name": "Pitaya",
"value": 12,
"cuantity": 2,
},
{
"name": "Melon",
"value": 32,
"cuantity": 2,
},
{
"name": "Uvas",
"value": 40,
"cuantity": 1,
},
{
"name": "Peras",
"value": 4,
"cuantity": 4,
}
]
order1 = Markert(*products, **descuentos)
order1.total_bill()
```
hola chicoss, estoy intentando sacar el reto desempacando args y kargs en la misma funcion, sin embargo en e encontrado enun punto en que mi codigo no funciona como quisiera. ya he preguntado a la ia y estoy analisando el codigo que me dio, sin embargo me gustaria sus insigths. ```python
@staticmethod
def discount (*prices:dict,**discounts:list)->dict:
answer={}
if True:
for product in prices:
if discounts[product].apply==True:
answer[product]=prices[product]-prices[product]* discounts[product].value
return answer
else:
raise AssertionError ('you need to spesify the discounts as a list of lists, [does de thiscount apply?, float or Nan]')
#when depakage you have tu spesify if depage like arg or kargs
if __name__=="__main__":
args=('carla',['teaching','datasciense','funny'])
kargs={'age':30,'health':'ok'}
asociated=Robot('stiven','python','storytelling','growd mindset',age=30,decendents=0,health='Good')
newModel=Robot(*args,**kargs)
print(asociated)
print(newModel)
products={asociated:10,newModel:20}
discounts=[{'apply':False,'value':'Nan'},{'apply':True,'value':0.4}]
Robot.discount(products,discounts)
```
El desempaquetado en Python se refiere a la t茅cnica que permite enviar elementos de una colecci贸n (como listas o diccionarios) como argumentos en funciones.
Para las funciones que usan `*args`, puedes pasar una lista y descomponerla en argumentos individuales. Por ejemplo, si tienes una lista `valores = [1, 2, 3]`, al llamar a `funcion(*valores)`, Python env铆a `1`, `2`, `3` como argumentos separados.
Con `**kwargs`, haces lo mismo pero con diccionarios. Por ejemplo, si tienes `detalle = {'nombre': 'Carlos', 'edad': 30}`, al llamar a `funcion(**detalle)`, Python env铆a `nombre='Carlos'` y `edad=30`.
Esta t茅cnica es 煤til para funciones que necesitan flexibilidad en la cantidad de argumentos que aceptan.
kwargs debe ser pasado como tupla o como diccionario? tengo problemas pasandolo como diccionario...
```js
class tiendita:
def __init__(self, name,*args, **kwargs, ):
self.name = name
self.precios = args
self.products = kwargs
def funcion_descuento(self,cliententer):
if cliententer in self.products:
categoria=self.products[cliententer]
if categoria=="limpieza":
discount=30
return print(f"El descuento es de {discount}")
else:
return print("No hay descuento")
else:
return print("Producto no esta en la tienda")
def imprimir(self):
print(f"precios: {self.precios}")
print(f"lista: {self.products}")
tiendita1 = tiendita('Mary', 1200, 1400, 1100, 1800, 11000, 1500,
cepillo="limpieza", jabon="limpieza", tv="tecno", sof谩="hogar",shampoo="limpieza",comedor1="hogar")
tiendita1.imprimir()
tiendita1.funcion_descuento("cepillo")
tiendita1.funcion_descuento("comida")
```
```js
products = [
{"item": "Smartphone", "price": 7000},
{"item": "Tablet", "price": 2000},
{"item": "Laptop", "price": 1500}
]
products_price = ()
for product in products:
products_price += (product['price'],)
def total_value( *price, **discount):
total_value = sum(price)
if(discount != {}):
total_value *= discount['porcentage']
return total_value
total_value( *products_price, porcentage= 0.5)
```
Aqu麓帽i mi c贸digo al reto planteado en esta clase:"""Funci贸n que recibe una cantidad variable de precios deproductos y calcula el precio final de todos ellosaplicando, de forma opcional, un descuento si seespecifica como argumento con nombre.
@params \*args Lista indeterminada de precios de productos@params \*\*kwargs Descuento (opcional --> por defecto = 0)
@return float"""def calcular\_total(\*args, \*\*kwargs): precio\_total = sum(args)
descuento = kwargs.get('descuento', 0) importe\_a\_descontar = precio\_total \* descuento / 100
return precio\_total - importe\_a\_descontar
print('Total art铆culos (Sin descuento):', calcular\_total(39.90, 15.50, 6.15, 57.30, 1.15))print('Total art铆culos (10% descuento):', calcular\_total(39.90, 15.50, 6.15, 57.30, 1.15, descuento = 10.0))print('Total art铆culos (25% descuento):', calcular\_total(39.90, 15.50, 6.15, 57.30, 1.15, descuento = 25.0))print('Total art铆culos (50% descuento):', calcular\_total(39.90, 15.50, 6.15, 57.30, 1.15, descuento = 50.0))
```js
"""
Funci贸n que recibe una cantidad variable de precios de
productos y calcula el precio final de todos ellos
aplicando, de forma opcional, un descuento si se
especifica como argumento con nombre.
@params *args Lista indeterminada de precios de productos
@params **kwargs Descuento (opcional --> por defecto = 0)
@return float
"""
def calcular_total(*args, **kwargs):
precio_total = sum(args)
descuento = kwargs.get('descuento', 0)
importe_a_descontar = precio_total * descuento / 100
return precio_total - importe_a_descontar
print('Total art铆culos (Sin descuento):', calcular_total(39.90, 15.50, 6.15, 57.30, 1.15))
print('Total art铆culos (10% descuento):', calcular_total(39.90, 15.50, 6.15, 57.30, 1.15, descuento = 10.0))
print('Total art铆culos (25% descuento):', calcular_total(39.90, 15.50, 6.15, 57.30, 1.15, descuento = 25.0))
print('Total art铆culos (50% descuento):', calcular_total(39.90, 15.50, 6.15, 57.30, 1.15, descuento = 50.0))
```
```js
def total_price(*args, **kwargs):
"""
Funcion que recibe una cantidad variable de productos y sus precios,
Args:
*args: lista de precios.
**kwargs: descuento opcional.
Returns:
total: total de la compra.
"""
total = sum(args)
discount = kwargs.get('discount', 0)
return total - total * discount / 100
print(total_price(100, 200, 300, 400, 500))
print(total_price(100, 200, 300, 400, 500, discount=10))
print(total_price(100, 200, 300, 400, 500, discount=20))
# Output:
# 1500
# 1350.0
# 1200.0
```
```js
def calcular_total(*productos, descuento=None):
total = 0 # Inicializa el total en 0
for producto, precio in productos:
total += precio # Suma el precio de cada producto al total
# Aplica el descuento si se proporciona
if descuento is not None:
total *= (1 - descuento) # Reduce el total en el porcentaje de descuento
return total # Devuelve el total calculado
# Ejemplo de llamada a la funci贸n
print(calcular_total(('camisa', 100), ('pantalones', 200), descuento=0.1))
# Salida esperada: 270.0 (si el descuento es del 10%)
```def calcular\_total(\*productos, descuento=None):聽 聽 """
```js
class ShoppingCart:
def __init__(self, *args, **kwargs):
self.prices = args
self.discount = kwargs.get('discount', 0) # Valor por defecto 0 si no se especifica descuento
def calculate_total(self):
total = sum(self.prices)
if self.discount:
total -= total * (self.discount / 100) # Aplica descuento como porcentaje
return total
# Ejemplo de uso
cart = ShoppingCart(100, 50, 75, discount=10) # Tres precios y un descuento del 10%
print(f'Total con descuento: {cart.calculate_total()}')
cart_no_discount = ShoppingCart(200, 150, 50) # Tres precios sin descuento
#print(f'Total sin descuento: {cart_no_discount.calculate_total()}')
```class ShoppingCart:
def \_\_init\_\_(self, \*args, \*\*kwargs):
self.prices = args
self.discount = kwargs.get('discount', 0) # Valor por defecto 0 si no se especifica descuento
def calculate\_total(self):
total = sum(self.prices)
if self.discount:
total -= total \* (self.discount / 100) # Aplica descuento como porcentaje
return total
\# Ejemplo de uso
cart = ShoppingCart(100, 50, 75, discount=10) # Tres precios y un descuento del 10%
print(f'Total con descuento: {cart.calculate\_total()}')
cart\_no\_discount = ShoppingCart(200, 150, 50) # Tres precios sin descuento
\#print(f'Total sin descuento: {cart\_no\_discount.calculate\_total()}')
```python
products = []
def add_products(*args, **kwargs) -> float:
for product in args:
products.append(product)
total_price = sum(product['price'] for product in products)
discount_code = kwargs.get('discount_code')
if discount_code == 'GIVEMEADISCOUNT':
total_price *= 0.9
return total_price
product1 = {'name': 'Laptop', 'price': 1000}
product2 = {'name': 'Mouse', 'price': 50}
total1 = add_products(product1, product2, discount_code="GIVEMEADISCOUNT")
print("Total price:", total1)
total2 = add_products(product1, product2)
print("Total price:", total2)
```
La verdad super interesante la clase, en otros c贸digos y con GPTs ve铆a eso de \*args y \*\*kwargs y no entend铆a, tampoco en el antiguo curso de Python esto estaba, y es algo super valioso <3
hola, a continuaci贸n mi funci贸n:
def calcular\_total(\*args, \*\*kwargs):
total = sum(args)
descuento = kwargs.get('descuento', 0)
if descuento:
total -= total \* (descuento / 100)
return total
\# Ejemplo de uso
productos = \[100, 200, 300] # Precios de los productos
total\_sin\_descuento = calcular\_total(\*productos)
total\_con\_descuento = calcular\_total(\*productos, descuento=10)
print(f"Total sin descuento: {total\_sin\_descuento}")
print(f"Total con descuento: {total\_con\_descuento}")
```python
import random
camisetas = ['Camisa_Barcelona','Camisa_Real_Madrid', 'Camisa_Milan']
rango = len(camisetas)
precios = [random.randint(1500,3600) for i in range(rango)]
class Store:
def __init__(self, names: list, *args: list):
self.names = names
self.prices = args
def get_product_price(self) -> dict:
global information
information = dict(zip(self.names, self.prices))
print(f'Los productos y sus precios: {information}')
return information
def total_prices(self):
values = information.values()
suma = sum(values)
print(f'Precio total es:', suma, 'USD')
def prom_(self, discount: float,**kwargs):
self.prom = kwargs
self.discount = discount
for key in self.prom:
if key in information.keys():
new_valor = information[key] * discount
print(f'el nuevo precio de {key} es {new_valor}')
information.update({key : new_valor})
print(information)
#Ejecuci贸n
store_1 = Store(camisetas, *precios)
store_1.get_product_price()
store_1.total_prices()
store_1.prom_(0.9, Camisa_Barcelona = 'descuento', Camisa_Milan = 'descuento')
store_1.total_prices()
```camisetas = \['Camisa\_Barcelona','Camisa\_Real\_Madrid', 'Camisa\_Milan']rango = len(camisetas)precios = \[random.randint(2500,3600) for i in range(rango)]
class Store:聽 聽 def \_\_init\_\_(self, names: list, \*args: list):聽 聽 聽 聽 self.names = names聽 聽 聽 聽 self.prices = args 聽 聽 聽 聽
聽 聽 def get\_product\_price(self) -> dict:聽 聽 聽 聽 global information聽 聽 聽 聽 information = dict(zip(self.names, self.prices))聽 聽 聽 聽 print(f'Los productos y sus precios: {information}')聽 聽 聽 聽 return information
聽 聽 def total\_prices(self):聽 聽 聽 聽 values = information.values()聽 聽 聽 聽 suma = sum(values)聽 聽 聽 聽 print(f'Precio total es:', suma, 'USD')
聽 聽 def prom\_(self, discount: float,\*\*kwargs):聽 聽 聽 聽 self.prom = kwargs聽 聽 聽 聽 self.discount = discount聽 聽 聽 聽 for key in self.prom:聽 聽 聽 聽 聽 聽 if key in information.keys():聽 聽 聽 聽 聽 聽 聽 聽 new\_valor = information\[key] \* discount聽 聽 聽 聽 聽 聽 聽 聽 print(f'el nuevo precio de {key} es {new\_valor}')聽 聽 聽 聽 聽 聽 information.update({key : new\_valor})聽 聽 聽 聽 print(information)
\#Ejecuci贸nstore\_1 = Store(camisetas, \*precios)store\_1.get\_product\_price()store\_1.total\_prices()store\_1.prom\_(0.9, Camisa\_Barcelona = 'descuento', Camisa\_Milan = 'descuento')store\_1.total\_prices()
Ejemplos donde su uso es conveniente y necesario:
1. **Funciones con N煤mero Variable de Argumentos**:
* `*args`: Permite pasar un n煤mero variable de argumentos posicionales a una funci贸n. Esto es 煤til cuando no sabes de antemano cu谩ntos argumentos se necesitar谩n.
```js
def sumar(*args):
total = 0
for num in args:
total += num
return total
print(sumar(1, 2, 3)) # Salida: 6
print(sumar(4, 5)) # Salida: 9
```**2. Funciones con Argumentos de Palabra Clave Variables**:
* `**kwargs`: Permite pasar un n煤mero variable de argumentos de palabra clave (keyword arguments) a una funci贸n. Esto es 煤til para manejar configuraciones flexibles o par谩metros opcionales.
```js
def imprimir_info(**kwargs):
for key, value in kwargs.items():
print(f"{key}: {value}")
imprimir_info(nombre="Juan", edad=30, ciudad="Madrid")
# Salida:
# nombre: Juan
# edad: 30
# ciudad: Madrid
```**3. Decoradores**:
* Los decoradores a menudo usan `*args` y `**kwargs` para asegurarse de que pueden aceptar cualquier combinaci贸n de argumentos cuando decoran una funci贸n
```js
def decorador(func):
def wrapper(*args, **kwargs):
print("Llamando a la funci贸n...")
resultado = func(*args, **kwargs)
print("Funci贸n llamada.")
return resultado
return wrapper
@decorador
def saludar(nombre):
print(f"Hola, {nombre}!")
saludar("Ana")
# Salida:
# Llamando a la funci贸n...
# Hola, Ana!
# Funci贸n llamada.
```
Want to see more contributions, questions and answers from the community?