Introducci贸n

1

El Zen de Python

Conjuntos

2

Sets

3

Modificando conjuntos

4

Operaciones con conjuntos

5

Playgrounds: Elimina elementos duplicados usando conjuntos

Comprehensions

6

List Comprehension

7

Dictionary Comprehension

8

Dictionary Comprehension: condition

9

Playgrounds: Crea una lista usando List Comprehension

10

Lists vs. Tuples vs. Sets

Funciones

11

Funciones

12

Funciones: return

13

Par谩metros por defecto y m煤ltiples returns

14

El scope

15

Refactor game

16

Playgrounds: Tienda de Tecnolog铆a

17

Funciones an贸nimas: lambda

18

Higher order function: una funci贸n dentro de otra funci贸n

19

Map

20

Map con diccionarios

21

Reto: map con inmutabilidad

22

Playgrounds: Multiplica todos los elementos por dos

23

Filter

24

Playgrounds: Retorna solo palabras de 4 letras y m谩s

25

Reduce

M贸dulos

26

M贸dulos

27

Mis propios m贸dulos

28

M贸dulos como scripts: __name__ y __main__

29

Paquetes

30

Playgrounds: Calcular la suma de todas las compras

Manipulaci贸n de archivos y errores

31

Iterables

32

Errores en Python

33

Manejo de excepciones

34

Playgrounds: Captura la excepci贸n: ZeroDivisionError

35

Leer un archivo de texto

36

Escribir en un archivo

37

Leer un CSV

38

Playgrounds: Lee un CSV para calcular el total de gastos

Gr谩ficas en Python

39

Creando una gr谩fica

40

Reto: graficando la poblaci贸n de un pa铆s

41

Reto: graficando la poblaci贸n mundial

Pr贸ximos pasos

42

隆Conoce otros proyectos de este curso!

43

Reconoce tu proceso y certif铆cate

44

Toma el Curso de PIP y Entornos Virtuales con Python

No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Map con diccionarios

20/44
Recursos

Aportes 74

Preguntas 7

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

hola,
resolvi el problema de la siguiente manera, hice el mismo map pero concatene el nuevo elemento 鈥榯ax鈥 a cada elemento asi:

items =[
    {'product': 'shirt',
    'price':120},
    {'product': 'pants',
    'price':160},
    {'product': 'jacket',
    'price':205}
]

new_items = list(map( lambda x: x|{'tax': x['price']*0.19} ,items)) 

print(new_items)   
print(items)

y el output me quedo asi:

[{'product': 'shirt', 'price': 120, 'tax': 22.8}, {'product': 'pants', 'price': 160, 'tax': 30.4}, {'product': 'socks', 'price': 205, 'tax': 38.95}]

[{'product': 'shirt', 'price': 120}, {'product': 'pants', 'price': 160}, {'product': 'socks', 'price': 205}]

Se viste caro el Nico camisa de $100 USD y pantalones de $300 USD 馃槀

no se, si era lo que pedian, tengo entendido que no quiere que modifique el array original, por tanto solo cree un nuevo array con el atributo copy() y listo, he visto que todos hicieron varias lineas extra de codigo, espero les funcione.

items_cp = items.copy()
print(items_cp)

Soluci贸n al problema de overwritting en el dict original:

def add_taxes(item):
    items_copy = item.copy()
    items_copy["taxes"] = items_copy["price"] * 0.19
    return items_copy

asi solucione el problema.
Lo que hay que hacer es importar la funci贸n copy (la cual es un archivo que tiene muchas funciones)
despu茅s de importar nuestro archivo vamos donde tenemos el problema (linea 27) y en el map colocamos la funci贸n que usaremos para agregar el nuevo campo y en vez de pasar directamente items lo que hacemos es usar una funcion que tiene nuestro querido archivo copy que copia todos los objetos que esten guardados dentro de nuestra lista

map(add_campo_sum,copy.deepcopy(items))

import copy

items = [
    {
        'product':'remera',
        'price':100,
    },
    {
        'product':'pantalon',
        'price':300,
    },
    {
        'product':'pantalon 2',
        'price':200,
    },
]

def add_campo_sum( item):
    item['taxes'] = item['price'] * .19
    return item

print(items)

price = list(map(lambda item: item['price'], items))
print(price)

new_item = list(map(add_campo_sum,copy.deepcopy(items)))
print(f'Lista vieja \n{items}')
print(f'Lista nueva \n{new_item}')

Bueno, en este caso, la soluci贸n que proponga al problema planteado se basa en utilizar la funci贸n copy y utilizando el m茅todo deepcopy, lo cual nos permitir谩 copiar el diccionario items en una nueva versi贸n, y poder de esa manera modifcar en esta nueva, sin modifcar en la original:

Este es mi aporte teniendo en cuenta algunas soluciones que plantearon otros compa帽eros, hago uso del ** para desempaquetar el diccionario, recomiendo leer m谩s acerca de esta caracter铆stica puesto que su uso es variado:

items = [
  {
    'product': 'tshirt',
    'price': 100,
  },
  {
    'product': 'pants',
    'price': 300,
  },
  {
    'product': 'blue white pants',
    'price': 200,
  },
]

newItems = map(lambda item: {**item, 'tax': item['price'] * .19}, items)

print(list(newItems))
<
items = [
  {
    'product': 'camisa',
    'price': 100,
  },
  {
    'product': 'pantalones',
    'price': 300
  },
  {
    'product': 'pantalones 2',
    'price': 200
  }
]

prices = list(map(lambda item: item['price'], items))
print(items)
print(prices)

def add_taxes(item):
  item['taxes'] = item['price'] * .19
  return item

new_items = list(map(add_taxes, items))
print(new_items)
print(items)
> 

Yo resolv铆 el tema de que sobrescriba en el original de esta manera:

dicts=(
    {
        'product':'camisa',
        'price':120,
    },
    {
        'product':'pantalon',
        'price':160
    },
    {
        'product':'pantalon_2',
        'price':205
    },
)
prices= list(map(lambda item: item['price'],dicts))
print(prices)


def add_element(item:dict):
    dictsio={k:item.get(k) for k in item.keys()}
    dictsio['tax']=item['price']*.18
    return dictsio
    

new_items= list(map(add_element, dicts))
print(new_items)
print(dicts)

Map con Diccionarios

Hay que tener precaucion al trabajar con map sobre diccionarios ya que al modificar un atributo de un diccionario puedes estar modificando todo el array original y no generando uno nuevo lo cual puede que no sea lo que estas esperando

#-------------Map con diccionario------------------

# transformar una lista de diccionario a una lista de numeros
items = [
  {
    'product':'camisa',
    'price':100
  },
  {
    'product':'pantalon',
    'price':300
  },
  {
    'product':'vestido',
    'price':150
  },
  {
    'product':'chaqueta',
    'price':400
  }
]

prices = list(map(lambda item: item['price'], items))
print(prices)
--> [100, 300, 150, 400] # lista de precios

# agregar un nuevo atributo a la lista de diccionarios
def add_taxes(items):
  items['taxes'] = items['price'] * .19
  return items
  
new_items = list(map(add_taxes, items))
print(new_items)
--> [{'product': 'camisa', 'price': 100, 'taxes': 19.0}, 
		 {'product': 'pantalon', 'price': 300, 'taxes': 57.0}, 
		 {'product': 'vestido', 'price': 150, 'taxes': 28.5}, 
		 {'product': 'chaqueta', 'price': 400, 'taxes': 76.0}]

# el array original es modificado
print(items)
--> [{'product': 'camisa', 'price': 100, 'taxes': 19.0}, 
		 {'product': 'pantalon', 'price': 300, 'taxes': 57.0}, 
		 {'product': 'vestido', 'price': 150, 'taxes': 28.5}, 
		 {'product': 'chaqueta', 'price': 400, 'taxes': 76.0}]

Yo crear铆a un copia del diccionario items en otra variable antes de modificarlo con la funci贸n map

Algo mas.

  • Un Map con diccionarios es una estructura de datos que permite almacenar pares clave-valor.
  • Se puede acceder a los valores utilizando las claves asociadas a ellos en lugar de los 铆ndices num茅ricos t铆picos de otras estructuras de datos.
  • Map tambi茅n se conoce como 鈥渄iccionario鈥 en Python y se denota con llaves {}.

Hola,

Para solucionar la referencia al mismo espacio de memoria del diccionario original, mi propuesta es, antes de la transformaci贸n hacer una copia del diccionario original en un nuevo diccionario usando el metodo copy().

items = [
  {
    'product': 'camisa',
    'price': 100,
  },
  {
    'product': 'pantalones',
    'price': 300
  },
  {
    'product': 'pantalones 2',
    'price': 200
  }
]

prices = list(map(lambda item: item['price'], items))
print(items)
print(prices)

'''
def add_taxes(item):
  item['taxes'] = item['price'] * .19
  return item
'''

def add_taxes(item):
  new_item = item.copy()
  new_item['taxes'] = new_item['price'] * .19
  return new_item

new_items = list(map(add_taxes, items))
print(new_items)
print(items)

son increibles las posibilidades que nos ofrece python, hasta ahora me ha gustado mucho este curso.

he encontrado una forma muy curiosa de a帽adir una nueva clave valor.

new = list(map(lambda q: {**q, 'iva': q['precio'] * 0.21}, items))

Al usar **q, obtenemos un nuevo diccionario con los mismos elementos que q. Es como si estuvi茅ramos haciendo una copia del diccionario q en un nuevo diccionario sin modificar el original.

Lo que esta modificando el diccionario original no es el map sino la funci贸n 鈥渁dd_taxes鈥

Esta fue mi forma de resolverlo, agregu茅 tipado al c贸digo; un map que solo obtiene los taxes y otro map que une todo

from typing import List

tax = 0.12

class Product:
    def __init__(self, name: str, price: float) -> None:
        self.name: str = name
        self.price: float = price


items: List[Product] = [
    Product(
        'shirt',
        120.0
    ),
    Product(
        'pants',
        160.0,
    ),
    Product(
        'jacket',
        205.0,
    ),
]

# get taxes
prices_with_taxes: List[float] = list(map(lambda product: product.price * tax, items))

# Add taxes to price
items_with_taxes: List[Product] = list(map(lambda product, price: Product(product.name, product.price + price), items, prices_with_taxes))

Con taxes sumados:

{'name': 'shirt', 'price': 134.4}
{'name': 'pants', 'price': 179.2}
{'name': 'jacket', 'price': 229.6}

Sin taxes:

{'name': 'shirt', 'price': 120.0}
{'name': 'pants', 'price': 160.0}
{'name': 'jacket', 'price': 205.0}

Taxes por producto:

{'name': 'shirt', 'tax': 14.4}
{'name': 'pants', 'tax': 19.2}
{'name': 'jacket', 'tax': 24.6}
new_items = list(map(lambda item: item | {'tax': item['price'] * .19}, items)) # gracias a '|' no modificamos el array original
print(new_items)

Soluci贸n al reto:

items_sin_tax = [
    {'product':'camisa',
     'price'  :100},
    {'product':'pantal贸n',
     'price'  :200},
    {'product':'zapato',
     'price'  :300}
]

items_con_tax = [{**item, 'taxes': item['price']*0.19} for item in items_sin_tax]

print('items_sin_tax:\n',items_sin_tax)
print()
print('items_con_tax:\n',items_con_tax)

Es preferible el 3:

new_items_1 = list(map(lambda x: x|{'tax': x['price']*0.19} ,items)) 
new_items_2 = list(map(lambda x: {**x, 'tax': x['price']*0.19}, items))
new_items_3 = [{**item, 'tax': item['price']*0.19} for item in items]

print(new_items_1 == new_items_2 == new_items_3) # True

As铆 lo har铆a:

items = [
    {
        'product': 'camisa',
        'price': 100,
    },
    {
        'product':'pantalones',
        'price': 300,
    },
    {
        'product':'pantalones_2',
        'price': 400
    }
]

# copia de items
items_copy = [dict(item) for item in items]
prices = list(map(lambda item: item['price'], items_copy))
print(prices)
print(items)

def add_taxes(item):
    item['taxes'] = item['price'] *.19
    return item

new_items = list(map(add_taxes, items_copy))
print(new_items)
print(items)

output:

[100, 300, 400]
[{'product': 'camisa', 'price': 100}, {'product': 'pantalones', 'price': 300}, {'product': 'pantalones_2', 'price': 400}]
[{'product': 'camisa', 'price': 100, 'taxes': 19.0}, {'product': 'pantalones', 'price': 300, 'taxes': 57.0}, {'product': 'pantalones_2', 'price': 400, 'taxes': 76.0}]
[{'product': 'camisa', 'price': 100}, {'product': 'pantalones', 'price': 300}, {'product': 'pantalones_2', 'price': 400}]

Mis solucion al reto.

# Importa el m贸dulo 'copy' para realizar copias profundas de los diccionarios.
import copy

# Crea una lista de diccionarios llamada 'items' con informaci贸n de productos y precios.
items = [
  {
    'product': 'camisa',
    'price': 100,
  },
  {
    'product': 'pantalones',
    'price': 300
  },
  {
    'product': 'pantalones 2',
    'price': 200
  }
]

# Muestra la lista de productos y sus precios originales.
print("Lista de productos:")
print(items)

# Calcula los precios y almacena los resultados en una nueva lista llamada 'prices'.
prices = list(map(lambda item: item['price'], items))
print("Lista de precios:")
print(prices)

# Definici贸n de una funci贸n 'add_taxes' que agrega un campo 'taxes' a cada elemento.
def add_taxes(item):
  # Realiza una copia profunda del diccionario original para no modificarlo.
  item_copy = copy.deepcopy(item)
  # Calcula los impuestos (19% del precio) y agrega el resultado al diccionario copiado.
  item_copy['taxes'] = item_copy['price'] * 0.19
  return item_copy

# Aplica la funci贸n 'add_taxes' a cada elemento de la lista 'items' y almacena los resultados en 'new_items'.
new_items = list(map(add_taxes, items))

# Muestra la lista de productos con los impuestos agregados.
print("Lista de productos con impuestos:")
print(new_items)

# Muestra la lista de productos original nuevamente.
print("Lista de productos original:")
print(items)

Yo logr茅 resolver el problema con este c贸digo, quedo muy sencilloitems = \[ {"product": "Shirt", "price": 100}, {"product": "Pants", "price": 300}, {"product": "Shoes", "price": 200} ] def applyTaxes(percentage): return \[ {"product": item\["product"], "price": item\["price"], "taxes": item\["price"] \* percentage / 100} for item in items ] itemsWithTaxes = applyTaxes(19) print(itemsWithTaxes) ```python items = [ {"product": "Shirt", "price": 100}, {"product": "Pants", "price": 300}, {"product": "Shoes", "price": 200} ] def applyTaxes(percentage): return [ {"product": item["product"], "price": item["price"], "taxes": item["price"] * percentage / 100} for item in items ] itemsWithTaxes = applyTaxes(19) print(itemsWithTaxes) ```
No entiendo, por qu茅 no puede ser as铆: ```python new_items = list(map(lambda item:{'product': item['product'], 'price': item['price'], 'taxes': item['price']*.19}, items)) print(new_items) ```
Yo solucionar铆a ese reto creando un nuevo diccionario dentro de la funci贸n map() => ```js def add_taxes(item): dic = { 'product': item['product'], 'price': item['price'], 'taxes': item['price'] * .19, } return dic ```

Este metodo es interesante. Me gusta la parte en tener que agregar los valores en nuestro diccionario y como este nos permite trabajar de manera sencilla. El problema es que me gustaria aprender a que no cambie el valor original.

# Map con diccionarios

items = [
  {
    'product': 'camisa',
    'price': 100,
  },
  {
    'product': 'pantalones',
    'price': 300
  },
  {
    'product': 'pantalones 2',
    'price': 200
  }
]

prices = list(map(lambda item: item['price'], items)) #item corresponde al diccionario.
print(items)
print(prices)

# Se crea una funci贸n para calcular el taxes, ya que los Map solo se deben crear en una sola l铆nea.
def add_taxes(item):
  item['taxes'] = item['price'] * .19
  return item

# Se agrega un atributo nuevo al array de n煤meros.
new_items = list(map(add_taxes, items))
print(new_items)
print(items)
Queria hacerlo con lambda, lo logre haciendolo de la siguiente manera `taxes = list(map(lambda item: item | {"taxes": item["precio"] * 0.19}, obj))` Asi igual se crea otro arr contatenando el item con el nuevo dic

Todos los metodos visto en aportes con sus respectivos comentarios

  • Estas desventajas se deben aclarar en clases posteriores鈥
"""
Transformar un diccionario en una lista que me de solo numeros
"""
items = [
    {
        'product': 'camisa',
        'price': 100
    },
    {
        'product': 'pantalones',
        'price': 300
    },
    {
        'product': 'pantalones 2',
        'price': 200
    }
]

# Retornar todos los precios
prices = list(map(lambda item: item['price'], items))
print(prices)
print()

# Colocar impuestos en las listas
prices = list(map(
    lambda item:
    {
        'product': item['product'],
        'price': item['price'],
        'taxes': item['price'] * 0.19
    },
    items))
"""
Nota:
- esto pierde el proposito de la lambda function, utilizar una sola linea...
- mejor creamos una nueva funcion

- a pesar de perder el proposito no modifica el array original...
"""
print('Metodo lambda ---\n')
print(items)
print(prices)
print()

# Colocar impuetos en la lista: forma correcta

"""
Nota:
- cuando realizamos esto, estamos editando el array original
- entonces si llamamos al array original veremos lo mismo que vemos
- en el nuevo array creado
"""


def add_taxes(item_dic):
    """
    Dado un item tipo diccionario, retorna el mismo con una dato extra, el impuesto
    """
    item_dic['taxes'] = item_dic['price'] * 0.19
    return item_dic


mis_items = list(map(add_taxes, items))
print('Metodo correcto ---\n')
print(items)
print(mis_items)
print()

# Colocar impuestos en la lista: forma sugerida
"""
Nota:
- este metodo tambien usa labda y por lo tanto tampoco modifica el array original
"""
seugerida_items = [
    {
        'product': 'shirt',
        'price': 120
    },
    {
        'product': 'pants',
        'price': 160
    },
    {
        'product': 'jacket',
        'price': 205
    }
]

new_seugerida_items = list(map(lambda x: x | {'tax': x['price']*0.19}, items))

print('Metodo sugerido ---\n')
print(seugerida_items)
print(new_seugerida_items)

"""
Nota:
- esto problemas de sobrescritura ocurren por la referencia de memoria
"""

Una lambda function en si deber铆a ser sencilla de una l铆nea, por lo cu谩l si vamos a hacer una funci贸n compleja es mejor declararla aparte. Aqu铆 podemos ver como agregar un nuevo atributo a un dictionary --> item['taxes'] = item['precio'] * .19. Una forma de hacer una adici贸n de un nuevo atributo por medio de una lambda function ser铆a por este: new_items = list(map( lambda x: x|{'tax': x['price']*0.19} ,items))

items = [
{
" producto " : " camisa " ,
" precio " : 80000 ,
},

{
    " producto " : " pantalon " ,
    " precio " : 110000
},

{
    " producto " : " zapatos " ,
    " precio " : 200000
}

]
print(type(items))

productos = list ( map ( lambda item: item [" producto " ] , items ) )
print(productos)

precios = list ( map ( lambda item: item [" precio " ] , items ) )
print(precios)

def impuesto (item):
item[ " impuesto " ] = item [ " precio " ] * .19
return item

nuevos_itemss = list(map( impuesto , items ))
print (nuevos_itemss)

ingredientes = ['馃悢', '馃惍', '馃', '馃崌']

mapeo_ingredientes = {
    '馃悢': '馃崡',
    '馃惍': '馃崝',
    '馃': '馃崯',
    '馃崌': '馃嵎'
}

# Usamos map para aplicar el mapeo de ingredientes a cada elemento de la lista
resultado = list(map(lambda x: mapeo_ingredientes.get(x, '馃崻'), ingredientes))

print(resultado)


Yo copio el diccionario o el valor que voy a modificar en una variable auxiliar

diccionario = {鈥渉ola鈥: 鈥渕undo鈥, 鈥減ython鈥: 鈥渆s genial鈥潁
longitudes = map(len, diccionario.values())
print(list(longitudes)) # [5, 9]

palabras = [鈥渉ola鈥, 鈥渕undo鈥, 鈥減ython鈥漖
longitudes = map(len, palabras)
print(list(longitudes)) # [4, 5, 6]

mi solucion al problema

import copy
def add_taxes (item):
    new_item = copy.deepcopy(item)
    new_item["taxes"] = item["price"] * 0.19
    return new_item

Dejo algunos programitas que hice con Map y Lambdas.

"""
2. Dada una lista de diccionarios con claves "nombre" y "edad", aplicar un incremento de 5 a帽os a la edad de cada persona.
"""

lista = [ {
            'nombre' : 'Patricia',
            'edad': 20
          },
          { 
            'nombre' : 'Jesus',
            'edad': 32
          },
         { 
            'nombre' : 'Guadalupe',
            'edad': 28
          },
         { 
            'nombre' : 'Jose',
            'edad': 15
          }
        ]


resultado = list(map(lambda persona: {**persona, **{'edad': persona['edad'] + 5}}, lista))
print(resultado)

"""
3. Dada una lista de diccionarios con claves "producto" y "precio", aplicar un descuento del 10% al precio de cada producto.
"""

lista = [ {
            'producto' : 'Laptop',
            'precio': 6500
          },
          { 
            'producto' : 'Mouse',
            'precio': 300
          },
         { 
            'producto' : 'Teclado',
            'precio': 500
          },
         { 
            'producto' : 'Monitor',
            'precio': 800
          }
        ]


resultado = list(map(lambda producto: {**producto, 
  **{'precio':producto['precio']*.90}}, lista))
print(resultado)

"""
4. Dada una lista de diccionarios con claves "nombre" y "sueldo", aplicar un incremento salarial del 15% a cada empleado.
"""

lista = [ {
            'nombre' : 'rodrigo',
            'sueldo': 10000
          },
          { 
            'nombre' : 'juana',
            'sueldo': 3000
          },
         { 
            'nombre' : 'romel',
            'sueldo': 1500
          },
         { 
            'nombre' : 'bertha',
            'sueldo': 30000
          }
        ]


resultado = list(map(lambda sueldo: {**sueldo,**{'sueldo':sueldo['sueldo']*1.15}}, lista))
print(resultado)

Otra forma de hacerlo:

items = [
    {
      'product': 'camisa', 
     'price': 100
    },
    {
      'product': 'pantalon', 
      'price': 150
    },
    {
      'product': 'zapatos', 
      'price': 300
    }
]

add_tax = list(map(lambda x: {**x, **{'tax': x['price'] * 0.19}}, items))

print(add_tax)

"""
Salida:
[{'product': 'camisa', 'price': 100, 'tax': 19.0}, {'product': 'pantalon', 'price': 150, 'tax': 28.5}, {'product': 'zapatos', 'price': 300, 'tax': 57.0}]
"""

El operador ** se utiliza en Python para desempaquetar elementos de un diccionario y pasarlos como argumentos de palabra clave a una funci贸n o para combinar varios diccionarios en uno solo. Tiene varios usos y aplicaciones, principalmente en el contexto de trabajar con diccionarios y funciones.

.
.
.
Usando .copy() para resolver el problema de que la funci贸n altere el diccionario original
.
.
.
.
.

items = [{'product': 'camisa','price': 100,},
  {'product': 'pantalones','price': 300},
  {'product': 'sueter','price': 200}]

#funci贸n que usa copy
def add_taxes_copy(item):
  copy_item = item.copy()
  copy_item['taxes'] = copy_item['price'] * .19
  return copy_item

#se crea un nuevo diccionario llamando a la funci贸n anterior
new_items = list(map(add_taxes_copy, items))

item[鈥榠mpuesto鈥橾 = item[鈥榩recio鈥橾 * 1.5

en el impuesto quiero poner 12% pero como lo haria

prendas_con_iva = list(map(lambda prenda: {**prenda, 鈥榠va鈥: prenda[鈥榩rice鈥橾 * 0.19}, prendas))

print(prendas_con_iva)

Yo pus茅 en pr谩ctica lo visto anteriormente y utilic茅 list comprehension

items =[ {'product': 'shirt',  'price':120},
    {'product': 'pants', 'price':160},
    {'product': 'jacket',  'price':205} ]

price = [dict['price'] for dict in items]
print(price)

El output es [100, 300, 200]

As铆 ser铆a sin la funci贸n map

items = [
{
    'product': 'camisa',
    'price':100
},
{
    'product': 'pantalones',
    'price':300
},
{
    'product': 'pantalones 2',
    'price': 200

productos =[]
for i in items:
  productos.append(i['product'])

print(productos)

Intente usar defaultdict que es para usar el default de un dict que se le indique y no lo modifique, tambien es valido pero naa. Lo normal ser铆a usar la copy(). O la otra manera la de compa帽eros que no se c贸mo funciona bien usar la lambda dentro del map.

lo que hice aprendiendo lo dey d铆a de hoy

tienda = [
  {"producto" : "leche", "precio" : 10},
  {"producto" : "cereal", "precio" : 20},
  {"producto" : "galletas", "precio" : 6},
  {"producto" : "chocomilk", "precio" : 14}
]

print(tienda)

precio = list(map(lambda item: item["precio"], tienda))
print(precio)

def IVA(item):
  iva = item["precio"] * 0.16
  item["iva incluido"] = round(item["precio"] + iva, 2)
  return item


new_tienda = list(map(IVA, tienda))
print(new_tienda)

Mi solucion

import copy

items = [
  {
    'product': 'camisa',
    'price': 100
  },
  {
    'product': 'pantaloes',
    'price': 300
  },
  {
    'product': 'pantaloes jean',
    'price': 200
  }
]

def add_taxes(item):
  item = copy.deepcopy(item)
  item['taxes'] = item['price'] * 0.18
  return item

new_items = list(map(add_taxes, items))
print(new_items)
print('*' * 40)
print(items)
items = [
  {
    'product': 'camisa',
    'price': 100
  },
  {
    'product': 'pantalones',
    'price': 200
  },
  {
    'product': 'joggers',
    'price': 348
  },
  
]

# cuando se modifica un diccionario puede que se est茅 modificando todo el array original y no uno nuevo
prices = list(map(lambda item: item['price'], items))
print(items)
print(prices)

def add_taxes(item):
  item['taxes'] = item['price'] * .19
  return item

new_items = list(map(add_taxes, items))
print(new_items)
print(items)
items = [
  {
    'product': 'camisa',
    'price': 100
  },
  {
    'product': 'pantalones',
    'price': 450
  },
  {
    'product': 'calcetas',
    'price': 25
  },
  {
    'product': 'boxer',
    'price': 50
  }
]

prices = list(map(lambda item: item['price'], items))
print(items)
print(prices)

def add_taxes(item):
  item['taxes'] = item['price'] * .19
  return item

new_items = list(map(add_taxes, items))
print(new_items)
print(items)

Asi se ve en mi consola 鈥渟hell鈥

[{'product': 'camisa', 'price': 100}, {'product': 'pantalones', 'price': 450}, {'product': 'calcetas', 'price': 25}, {'product': 'boxer', 'price': 50}]
[100, 450, 25, 50]

[{'product': 'camisa', 'price': 100, 'taxes': 19.0}, {'product': 'pantalones', 'price': 450, 'taxes': 85.5}, {'product': 'calcetas', 'price': 25, 'taxes': 4.75}, {'product': 'boxer', 'price': 50, 'taxes': 9.5}]

[{'product': 'camisa', 'price': 100, 'taxes': 19.0}, {'product': 'pantalones', 'price': 450, 'taxes': 85.5}, {'product': 'calcetas', 'price': 25, 'taxes': 4.75}, {'product': 'boxer', 'price': 50, 'taxes': 9.5}]

Este es mi aporte con la solucion del reto

La funci贸n copy es una manera de operar sobre una segunda versi贸n y no modificar la primera, funciona. Pero s贸lo por intentar hacer la tarea sin ayuda del copy, podemos colocar como output de la funci贸n lambda una cadena que incluya el producto y el precio a iterar para cada 铆tem, con el precio multiplicado por el tax al final de la cadena. Solo hay que tener cuidado de convertir el resultado de la multiplicaci贸n en un tipo STR para poder concatenarlo. Todo queda en 3 l铆neas:

items = [{ 鈥減roducto鈥: 鈥渃amisa鈥, 鈥減recio鈥: 100}, {鈥減roducto鈥: 鈥減antalon鈥, 鈥減recio鈥: 300},{鈥減roducto鈥: 鈥渟horts鈥, 鈥減recio鈥: 200}]

listcontaxes = list(map(lambda item: "Producto: 鈥+item[鈥減roducto鈥漖+鈥, Precio: 鈥+str(item[鈥減recio鈥漖)+鈥, Impuesto: "+str(item[鈥減recio鈥漖*0.19),items))

print(listcontaxes)

Vinendo de JS tenia que buscar algo analogo al spreat operator

new_items = list(map(lambda e: {**e, 'taxe': int(e['price']) * 1.20}, items))

Buenaos dias! les dejo mi codigo espero ayude!

'''
Como usar maps con diccionarios que son los tipos de datos mas comunes
'''
def jumpline():
  print('=' * 25)

items = [
  {
    'producto': 'camisa',
    'precio': 100
  },
  {
    'producto': 'pantalon',
    'precio': 300
  },
  {
    'producto': 'franela',
    'precio': 200
  }
]

# Usar map para pasar de lista de dicts a lista de numeros
prices = list(map(lambda item: item['precio'], items))
print(prices) # [100,300,200]
jumpline()

# Quiero que el atributo tax se sume al precio

items = [
  {
    'producto': 'camisa',
    'precio': 100,
  },
  {
    'producto': 'pantalon',
    'precio': 300
  },
  {
    'producto': 'franela',
    'precio': 200
  }
]

# Nueva lista que retorna el precio mas el 19% de tax
new_items = list(map(lambda item: item['precio'] + (item['precio'] * 0.19), items))
print(new_items)
jumpline()
# La lista items no esta modificada
print(items)
jumpline()

# anadir el key taxes al diccionario con funciones
def add_tax(item):
  item['taxes'] = item['precio'] * 0.19
  return item

new_items = list(map(add_tax, items))
print(new_items)
jumpline()

# anadir el key price_taxes con funciones
def add_tax(item):
  item['precio_taxes'] = item['precio'] + item['taxes']
  return item

new_items = list(map(add_tax, items))
print(new_items)
jumpline()

# Lista items tras la funcion, modificada
print(items)
'''
Recordar que map no modifica la list, sino crea una nueva
PERO al usar funciones si se modifica la 

Posible solucion:
copiar la lista original con .copy() y modificar la copia
'''

map(funci贸n, iterable): toma una funci贸n y un iterable como argumentos, y devuelve un nuevo iterable con el resultado de aplicar la funci贸n a cada elemento del iterable. Es una funci贸n de orden superior.

Sintaxis basica:

map(funci贸n, iterable)

Donde 鈥渇unci贸n鈥 es la funci贸n que se aplica a cada elemento del iterable, y 鈥渋terable鈥 es el objeto iterable (como una lista, una tupla, un conjunto o un diccionario) que se quiere procesar.

<h5>Sintaxis lambda: lambda x: x*2</h5>
numeros =  [1, 2, 3, 4, 5]
doble_numeros = map(lambda x: x*2, numeros)

personas = {"Juan": 20, "Mar铆a": 30, "Pedro": 25}

dobles_edades = map(lambda x: (x[0], x[1]*2), personas.items())

nuevo_diccionario = dict(dobles_edades)

En este ejemplo, map toma la funci贸n lambda lambda x: (x[0], x[1]*2) y el diccionario personas.items() como argumentos, y devuelve un nuevo iterable (dobles_edades) con el resultado de aplicar la funci贸n a cada par clave-valor del diccionario. Despu茅s, convertimos el iterable en un nuevo diccionario usando la funci贸n dict(). En este caso, nuevo_diccionario es igual a {鈥淛uan鈥: 40, 鈥淢ar铆a鈥: 60, 鈥淧edro鈥: 50}.

Se solucionaria duplicando el dic y manejar 2 dictionaries. Uno original y uno modificado

Voy por la pr贸xima clase para entender por qu茅 map modific贸 el array original y su relaci贸n con la referencia en memoria鈥

Les comparto el c贸digo de la clase

# Map con diccionarios

# Lista de diccionarios
items = [
  {
    'product': 'camisa',
    'price': 100
  },
  {
    'product': 'pantalones',
    'price': 300
  },
  {
    'product': 'chaqueta',
    'price': 600
  }
]

# Transformamos para obtener una lista solo de los precios
prices = list(map(lambda item: item['price'], items))
print(prices)

products = list(map(lambda item: item['product'], items))
print(products)

# Agregamos un nuevo atributo al diccionario
def add_taxes(item):
  item['taxes'] = item['price'] * .19
  return item

new_items = list(map(add_taxes, items)) 
print(new_items)

'''
Map es una de las funciones que se considera que no modifica el estado del array original, por el contrario, crea uno nuevo.
Sin embargo, aqui se evidencia una modificacion en el array, que tiene que ver con una referencia en memoria.
'''
print("*" * 10)
print(items)

Yo lo que hice fue crear una compia del diccionario

def add_taxes(item):
  copy_item = dict(item)
  copy_item["taxes"] = copy_item["price"] * .19
  return copy_item["taxes"]

hice esto usando map(), pero verif铆quenlo si pueden me sale error en algunos editores de c贸digo y no entiendo porque

datos=[  {  "nombre":"nelson",  "apellido":"alvaro",  "edad":20,  "mascota":"gato"},  {  "nombre":"brayan",  "apellido":"huisa",  "edad":19,  "mascota":"perro"},  {  "nombre":"alicia",  "apellido":"jara",  "edad":18,  "mascota":"loro"}]

resultados=list(map(lambda a:f"Hola yo me llamo {a["nombre"]} {a["apellido"]} tengo {a["edad"]} a帽os y tengo como mascota un {a["mascota"]}",datos))

print(resultados[2])

Los pasos a realizar son los siguientes:

  • Crearemos una copia del diccionario en otra variable, usando los comprenhensions

  • En nuestra nueva variable, le agregamos la clave taxes, y lo igualmanes a la formula para calcular el impuesto

  • Devolvemos nuestra nueva variable

  • Cargamos los new_item con el map usando el add_taxes

Hice un ejemplo donde utilizo list comprehensions y map, para encontrar el valor total de una compra en un grupo de elementos, como pr谩ctica de los temas que hemos visto:

products = [{
  "cantidad": 2,
  "empaque": "Paquete x 6 Unidades",
  "especificacion": "Pl谩stico Rojo",
  "existentes": 0,
  "medida": " 55 X 55",
  "precio": 1043,
  "producto": "Bolsa Blanca 55 X 55"
}, {
  "cantidad": 1,
  "empaque": "Polvo",
  "especificacion": "Bolsa",
  "existentes": 0,
  "medida": "500 grms",
  "precio": 2535,
  "producto": "Jabon en polvo"
}, {
  "cantidad": 2,
  "empaque": "Rollo",
  "especificacion": "Papel",
  "existentes": 0,
  "medida": "Rollo x400 mts, jumbo hoja sencilla ",
  "precio": 6608,
  "producto": "Papel Higi茅nico "
}, {
  "cantidad": 2,
  "empaque": "Rollo",
  "especificacion": "Papel",
  "existentes": 0,
  "medida": "Rollo x 100 mts, hoja sencilla, color blanco",
  "precio": 7901,
  "producto": "Toallas de manos"
}]

precios = [i["precio"] for i in products]
cantidades = [i["cantidad"] for i in products]
total = sum(list(map(lambda i, j: i * j, precios, cantidades)))

print(precios)
print(cantidades)
print(total)
items=[
    {
        "producto":"camisa",
        "Precio":100
    },
    {
        "producto":"pantalones",
        "Precio":300
    },
    {
        "producto":"pantalones 2",
        "Precio":200
    }
]

precios=[100,200,300]
#No cambia nada en items, se crea una lista independiente
prices=list(map(lambda item:item["Precio"],items))
print(prices)

def add_taxes(item):
    item["taxes"]=.19*item["Precio"]
    return item
#Si cambia en items, pero no debia de cambiar   
#Tiene que ver con referencia en memoria
print(list(map(add_taxes,items)))
print(items)
#Solucion mas simple
#Usar el metodo copy para crear otra lista

A mi me funcion贸 usando la funci贸n lambda como HOF

final_result = list(map(lambda item: add_taxes(item), items))

#impuestos 21%
taxes = list(map(lambda price: price * 1.21, prices))
print(f"Los precios con impuestos son: {taxes}")

Una de las formas que pude crear los impuestos utilizando una sola l铆nea de c贸digo fue de la siguiente forma:

taxes = list(map(lambda item : (item['price']*0.19)+item['price'], items))
print(taxes)

Lo resolvi, asignando a una variable nueva: items_update=items. Asi mantenfo la lista original y modifico el la items_update

Crea que queda m谩s f谩cil de leer el ejemplo del minuto 3:09 usando listas por comprensi贸n dela forma:

La forma en la que yo lo solucionaria es creando una copia del primer la lista en memoria y luego ya manipular la copia dejando intacto el valor original. Es lo primeo que se me ocurrio. 馃憤

Hola a todos, aqu铆 mi aporte. Cambi茅 items por celulares y quise agregar la informaci贸n 鈥渢ax鈥 y sumarla con 鈥減rice鈥 para obtener 鈥渢otal鈥.

Me apoy茅 de la documentaci贸n de Python para hacer uso de 鈥渄 | other鈥, les dejo el link: https://docs.python.org/3.10/library/stdtypes.html#mapping-types-dict

phones =[
    {'product': 'iPhone 11',
    'price':500},
    {'product': 'iPhone 12',
    'price':860},
    {'product': 'iPhone 13',
    'price':1000},
    {'product': 'iPhone 14',
    'price':1300}
]

taxes = list(map(lambda d: d | {'tax': d['price'] * 0.19}, phones))
def sum_taxes(taxes):
    taxes['total'] = taxes['price'] + taxes['tax']
    return taxes


total_plus_taxes = list(map(sum_taxes, taxes))
print(phones)
print(total_plus_taxes)

Este fue el output:

[{'product': 'iPhone 11', 'price': 500}, {'product': 'iPhone 12', 'price': 860}, {'product': 'iPhone 13', 'price': 1000}, {'product': 'iPhone 14', 'price': 1300}]

[{'product': 'iPhone 11', 'price': 500, 'tax': 95.0, 'total': 595.0}, {'product': 'iPhone 12', 'price': 860, 'tax': 163.4, 'total': 1023.4}, {'product': 'iPhone 13', 'price': 1000, 'tax': 190.0, 'total': 1190.0}, {'product': 'iPhone 14', 'price': 1300, 'tax': 247.0, 'total': 1547.0}]

aca esta lo del reto

def aumentar_iva(x):
  return x * 1.21  # 21% de IVA

precios = {'manzana': 0.5, 'pera': 0.25, 'naranja': 0.75}
precios_con_iva = map(aumentar_iva, precios.values())
print(list(precios_con_iva))  # [0.605, 0.3025, 0.9175]
def aumentar_iva(x):
  return (x[0], x[1] * 1.21)

precios = {'manzana': 0.5, 'pera': 0.25, 'naranja': 0.75}
precios_con_iva = map(aumentar_iva, precios.items())
precios_con_iva = dict(precios_con_iva)
print(precios_con_iva)  # {'manzana': 0.605, 'pera': 0.3025, 'naranja': 0.9175}

Hay dos tipos de pasos de par谩metros, por valor (en el cual es una copia del valor original y no se modifica el valor original) y referencia (la cual se pasa directamente el elemento original, por lo que cualquier cambio afecta la original), por defecto se pasan por referencia este tipo de datos, por lo que la soluci贸n m谩s simple es emular el paso por valor, haciendo una copia:

result = list(map(add_taxes, items.copy()))
items = [
  {
    'product':'camisa',
    'price': 100,
  },
  {
    'product':'pantalones',
    'price':300  
  },
  {
    'product':'jeans',
    'price':200  
  }
]

prices = list(map(lambda item: item['price'], items))
print(items)
print(prices)

def add_taxes(item):
  item['taxes'] = item['price'] * 0.19
  return item
  
new_items = list(map(add_taxes, items))
print(new_items)

Hola! La soluci贸n que encontr茅 fue crear una nueva estructura lista local para trabajar sin modificar la que se encontraba Globalmente 馃槂

#Agregando impuestos
def addTaxes(itemviejo):
  item = itemviejo.copy() # variable local
  item['taxes'] = int(item['price'] * .18) #modifica la var local
  return item

#modificando
newItems = list(map(addTaxes, items))
print("Utilizando Maps: ", newItems)
print(items)
#trabajando con map cambiando el tipo de dato, ya sean enteros, decimales o cadena de caracteres

producto = [
  {
    'procucto': 'compresor a/c',
    'precio': 1500000
  },
  {
    'producto': 'condensador',
    'precio': 450000
  },
  {
    'producto': 'evaporador',
    'precio': 520000
  },
  {
    'producto': 'ventiladores',
    'precio': 380000
  }
]
precio = list(map(lambda item: item['precio'], producto))
print(precio)#aca estamos sacando un diccionario con los precios de cada atributo
print(producto)
print('#' * 50)
#agregando impuestos a nuestros productos  en los diccionarios  diccionarios 
def add_impuestos(producto):
  producto['impuestos'] = producto['precio'] * .19
  return producto

new_producto = list(map(add_impuestos, producto))
print(new_producto)
print(producto)#===>> en esta clase se Aprende a trabajar con map en los diccionarios, aunque debemos de tener un poco de cuidado, ya que al modificar un atributo de un diccionario puede estar modificando todo el array original, y generando un nuevo problema

print('#*'* 50)
producto =[
    {'product': 'shirt',
    'price':120
    },
    {'product': 'pants',
    'price':160
    },
    {'product': 'jacket',
    'price':205
    }
]

new_items = list(map( lambda x: x|{'tax': x['price']*0.19} ,producto)) 

print(new_items)   
print(producto)

Me ha ido genial

En su momento lo resolv铆 de esta manera y me encanto como quedo el c贸digo:

items = [
  {
    'product':'laptop',
    'price': 200
  },
  {
    'product':'mouse',
    'price': 15
  },  
  {
    'product':'camera',
    'price': 55
  },
  {
    'product':'headphones',
    'price': 15
  }
]

price = list(map(lambda items: items['price'], items))
print(price)

def taxes_item(items):
  items['taxes'] = items['price'] * .22
  items['full_price'] = items['price'] + items['taxes']
  return items
  
taxes = list(map(taxes_item, items))
print(taxes)

Aqui mi peque帽o aporte, ademas de agregarle impuesto le agregue total es decir la suma del precio mas el impuesto y lo hice con lambda tambien!!

articulos = [ 
 
 {
 	'producto':'camisa',
 	'precio': 50

 },
 {
 	'producto':'pantalon',
 	'precio': 100

 },
 {
 	'producto':'medias',
 	'precio': 10

 }

]

'''lo que se quiere hacer con este map es obtener una lista solo con los precios'''
precios = map(lambda i: i['precio'], articulos)
print (list(precios))

print (articulos)
# O tambien se puede obtener la lista con los productos
#IMPORTANTE
'''con la funcion map en una lista de diccionarios se puede transformar la lista
agregando items nuevos comopor ejemplo seria incluirle impuestos, tambien se usa la 
funcion map con las funciones normales cuando las lambdas ya no son suficiente'''

def agregar_impuesto(item):
	item['impuesto'] = item['precio'] * .16
	item['total'] = item['impuesto'] + item['precio']
	return item

new_items = map(agregar_impuesto, articulos)

print (list(new_items))

'''otro inteesante script es este'''

nuevo_items = map(lambda i: i | {'impuesto': i['precio'] * .16, 'total': i['precio'] + (i['precio'] * .16)}, articulos)

print (list(nuevo_items))