You don't have access to this class

Keep learning! Join and start boosting your career

Aprovecha el precio especial y haz tu profesión a prueba de IA

Antes: $249

Currency
$209
Suscríbete

Termina en:

0 Días
10 Hrs
53 Min
34 Seg

Map con diccionarios

20/44
Resources

How to transform data with map and complex dictionaries?

You've heard of map in Python, right? This function is an efficient tool that allows you to transform lists in an elegant way, even when you are working with more complex data structures such as dictionaries. Often, when handling dictionaries, the need arises to transform these elements into other types of data, such as lists of numbers. Exploring how to do this with map can open up a world of new possibilities.

What is map and how does it work in Python?

The map function is a fundamental part of Python when we talk about higher-order functions. With it, you can apply a specific function to each item in a list or iterable. The result is a map object, which is an iterable that you can easily convert into a list.

  • To use map, you need a list of items and a function (lambda or defined) that you want to apply to each item.
  • You can transform it for different purposes, such as converting data types.

As a small example, imagine you have a list of dictionaries representing products in a purchase order, and you need to extract only the prices and get a new list with them.

Example dictionary list:

items = [ {"product": "shirt", "price":  100}, {"product": "pants", "price":  300}, {"product": "pants 2", "price":  200},]

To extract the prices:

prices = list(map(lambda item: item["price"], items))print(prices) # Output: [100, 300, 200].

How do I add a new attribute using map?

Suppose you need to add a tax attribute to each product. Here, the use of map is combined with a custom function to calculate the taxes and add them to the original dictionary.

First, define the function to calculate and add the taxes:

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

Then, apply this function to each dictionary using map:

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

How do we avoid modifying the original state?

It is important to remember that map does not modify the state of the original iterable, but creates a new one. However, when working with dictionaries you can change the original state if you are not careful. This is a behavior that can become a headache if it is not what you expected.

  • Be sure not to modify the original dictionary if you need to keep it intact.
  • Use techniques such as deep copying to ensure that changes are applied only to the new iterable.

Practical example: tax and dictionary management

Through the above example, we have worked with a simple tax calculation and dictionary list to price list transformations:

  1. Dictionary list creation:

    items = [ {"product": "shirt", "price":  100}, {"product": "pants", "price":  300}, {"product": "pants 2", "price":  200},]
  2. Price extraction using Lambda:

    prices = list(map(lambda item: item["price"], items)).
  3. Adds a new attribute with defined function:

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

It is essential to remember that accurate handling of transformations and care with the original state of the data are fundamental when practicing programming with Python. Experiment and discover for yourself the various applications that map can offer in your projects - go ahead, the learning never stops!

Contributions 105

Questions 9

Sort by:

Want to see more contributions, questions and answers from the community?

hola,
resolvi el problema de la siguiente manera, hice el mismo map pero concatene el nuevo elemento ‘tax’ 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}]

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}')

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))

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:

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}]
<
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)

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 “diccionario” en Python y se denota con llaves {}.

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

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.

Compañeros Aquí les comparto mi solución. ```js item = [ { 'product': 'shirt', 'Price': 100, }, { 'product': 'pants', 'Price': 150 }, { 'product': 'zhoes', 'Price': 200 } ] prices = list(map(lambda element: element['Price'], item)) print(prices) def add_taxes(x): x_copy = x.copy() x_copy['taxes'] = x_copy['Price'] * .19 return x_copy new_items = list(map(add_taxes, item)) print(new_items) print(item) ```
a mi no me pasa eso que dice, que se modifica el array original, se mantiene ![](https://static.platzi.com/media/user_upload/image-c1b952a7-033c-47b7-935c-85e8e56064e7.jpg)
Hola todos , resolvi el problema creando una copia de la lista a recorer en la funcion de add\_taxes con copy() y después se agrega el nuevo atributo a la copia creada en new items a la cual se retorna el resultado de la función add\_taxes. ```python 1 items = [ 2 { 3 'product': 'camisa', 4 'price': 100 5 }, 6 { 7 'product': 'pantalones', 8 'price': 300 9 }, 10 { 11 'product': 'pantalones 2', 12 'price': 200 13 } 14 ] 15 prices = list(map(lambda item: item['price'], items)) 16 print(items) 17 print(prices) 18 19 def add_taxes(item): 20 item = item.copy() 21 item['taxes'] = item['price'] * .19 22 return item 23 24 new_items = list(map(add_taxes, items)) 25 print(new_items) 26 print(items) ```
Buena explicación y util la de este video
Hola como estan ? queria saber en donde puedo practicar y hacer más ejercicios de python, ya sea algún canal de youtube o paginas que sea de ayuda para mejorar , muchas gracias.
Esta fue la manera en que lo trabaje, haciendo una copia del diccionario original. ![](https://static.platzi.com/media/user_upload/image-dd7ef041-e26e-4305-ab48-c91e1098f32f.jpg)
En Js esto lo hubiese resuelto con el spreed operator pero esto no es Js 🥸

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 “add_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)
Con este ejemplo ya no apuntaría al mismo espacio en memoria ```js a = [1,2,3,4,5] b = a print(a) print(b) # del a[0]#Aqui estoy eliminando un elemento de a, pero como dije que b = a entonses apunta al mismo espacio en memori y por eso se borra tambien un elemento de b print(a) print(b) # con esto mo doy dcuenta que a y b apuntan al mismo espacio en la memoria de mi computadora print(id(a)) print(id(b)) c = a[:]#con esto que hice ya no apunta al mismo espacio en memoria print(id(a)) print(id(b)) print(id(c)) a.append(6)#aqui me doy decuenta que a b, ocupan un lugar diferente en memoria de c print(a) print(b) print(c) ```
puedo utilizar la función `map()` para transformar una lista de diccionarios que representan productos, si quiero obtener solo una lista con los precios de los productos?
products\_name = \['pc','celular','tv']products = \[{'id':i,'name':random.choice(products\_name),'price':random.randint(350,5000)} for i in range(1,11)]products\_reformated = list(map(lambda x: {\*\*x ,'price':x\['price'] \* 20} if x\['id']%2 == 0 else x, products))
este es mi código para solo agregar el nombre del producto:def main(list\_input, tax=0.16): name\_products = list\_input items = \[{'product': name, 'price': (index + 1) \* 100} for index, name in enumerate(name\_products)] items\_with\_taxes = list(map(lambda item: add\_taxes(item, tax), items)) for item in items\_with\_taxes: print(f"Producto: {item\['product']}, Precio: {item\['price']}, Impuestos: {item\['taxes']}, A pagar: {item\['price'] + item\['taxes']}") def add\_taxes(item, tax): try: item\['taxes'] = item\['price'] \* tax except KeyError: print(f"Error: El item {item} no tiene un precio.") except TypeError: print(f"Error: El precio de {item} no es un número válido.") return item if \_\_name\_\_ == "\_\_main\_\_": listProducts = \[ 'T-shirt', 'coat', 'jeans', 'skit', 'hoobie', 'sneakers', 'hat', 'joggers', 'gloves', 'boots', 'leggings', 'suit', 'ligthweith', 'top', 'cardigan', 'Sweter' ] main(listProducts) ```python def main(list_input, tax=0.16): name_products = list_input items = [{'product': name, 'price': (index + 1) * 100} for index, name in enumerate(name_products)] items_with_taxes = list(map(lambda item: add_taxes(item, tax), items)) for item in items_with_taxes: print(f"Producto: {item['product']}, Precio: {item['price']}, Impuestos: {item['taxes']}, A pagar: {item['price'] + item['taxes']}") def add_taxes(item, tax): try: item['taxes'] = item['price'] * tax except KeyError: print(f"Error: El item {item} no tiene un precio.") except TypeError: print(f"Error: El precio de {item} no es un número válido.") return item if __name__ == "__main__": listProducts = [ 'T-shirt', 'coat', 'jeans', 'skit', 'hoobie', 'sneakers', 'hat', 'joggers', 'gloves', 'boots', 'leggings', 'suit', 'ligthweith', 'top', 'cardigan', 'Sweter' ] main(listProducts) ```
No tenia como una solución clara, lo que pensé fue pues hacer como una copia para tener dos y que solo se modificara una, leyendo vi que existe esa función, y pues se podría añadir a la función de add\_taxes para que solo modifique a la copia. entonces pues podrias crear una copia asi, items\_copy = items.copy() lo que pasa con esta, es que sigue teniendo la misma referencia, entonces pues hace lo mismo porque las modifica igual, entonces toca usar import copy es items\_copy = copy.deepcopy(items) y por lo que entendí ahora si tiene otra referencia ( por lo que copia la lista y a los objetos dentro de ella) entonces no lo modificaría
Ejemplo: Modificar valores en un diccionario ```js # Diccionario de productos y precios precios = {"manzana": 100, "pera": 80, "uva": 120} # Aplicar un 10% de descuento a cada precio def aplicar_descuento(item): clave, valor = item return (clave, valor * 0.9) # Usar map() para modificar los valores precios_actualizados = dict(map(aplicar_descuento, precios.items())) print(precios_actualizados) # {'manzana': 90.0, 'pera': 72.0, 'uva': 108.0} ```# Diccionario de productos y precios precios = {"manzana": 100, "pera": 80, "uva": 120} \# Aplicar un 10% de descuento a cada precio def aplicar\_descuento(item): clave, valor = item return (clave, valor \* 0.9) \# Usar map() para modificar los valores precios\_actualizados = dict(map(aplicar\_descuento, precios.items())) print(precios\_actualizados) # {'manzana': 90.0, 'pera': 72.0, 'uva': 108.0}
Comparto mi solución al reto realizando una copia de los elementos en un nuevo diccionario. def transformar(item): return {\*\* item,'task': item\['Price'] \* .19}
Ese tipo del listas tambien se podrian considerar como archivos JSON (JavaScript Object Notation)
Mi propuesta de solución fue declarar items como un tupla, pero, no funcionó: ```js items = ( # lista de diccionario { 'product': 'camisa', 'price': 100, }, { 'product': 'pantalon', 'price': 120, }, { 'product': 'zapatos', 'price': 90, }, ) ```
Sera que me pueden explicar mejor esta parte= ![](https://static.platzi.com/media/user_upload/image-4ee45431-c9b7-483f-a751-598906dfc5bd.jpg)![](https://static.platzi.com/media/user_upload/image-87e04aa4-79b9-4daf-9aa5-aa04debdbe23.jpg)
```js items = [ { 'product': 'camisa', 'price': 98 }, { 'product': 'pantalon', 'price': 150 }, { 'product': 'zapatos', 'price': 450 } ] def add_taxes(item): item['taxes'] = item['price'] * .19 return items new_list = list(map(lambda item: add_taxes(item), items)) print(new_list) ``` ```js ``` ```tsx ```
Yo usaria un Diccionario aux y trabaria sobre el
* Al momento de trabajar con lista y estas deban pasar por algún proceso dentro de una función, lo aconsejable es: crear una copia de esa lista y trabajar con la copia de esa lista `list_aux= list.copy()` * Si la función iterable de la función map es más compleja que una función lambda, lo mejor es crearlo repositorio <https://github.com/angel20125/python-2-comprehension-functions-2024> ![](https://static.platzi.com/media/user_upload/clase-20-1eefaff8-5013-4260-a564-1ce738cb1658.jpg)
En este código corregido, item.copy() crea una copia del diccionario original, lo que nos permite modificar item\_copy sin afectar la lista original items. Por lo tanto, la lista items permanece sin cambios después de aplicar la función map. items = \[   {     'product': 'camisa',     'price': 100,   },   {     'product': 'pantalones',     'price': 300   },   {     'product': 'pantalones 2',     'price': 200   } ] prices = list(map(lambda item: item\['price'], items)) print(items) #\[{'product': 'camisa', 'price': 100}, {'product': 'pantalones', 'price': 300}, {'product': 'pantalones 2', 'price': 200}] print(prices) #\[100, 300, 200] def add\_taxes(item):    item\_copy = item.copy()   item\_copy\['taxes'] = item\_copy\['price'] \* .19   return item\_copy new\_items = list(map(add\_taxes, items)) print(new\_items) #\[{'product': 'camisa', 'price': 100, 'taxes': 19.0}, {'product': 'pantalones', 'price': 300, 'taxes': 57.0}, {'product': 'pantalones 2', 'price': 200, 'taxes': 38.0}] print(items) #\[{'product': 'camisa', 'price': 100}, {'product': 'pantalones', 'price': 300}, {'product': 'pantalones 2', 'price': 200}]
Importante clase para trabajar con JSON que son listas de diccionarios
Una pequeña modificación que hice para que a cada producto se le aplique un impuesto diferente: ```python items = [ { "product" : "camisa", "price" : 100, "taxes" : 1.19 }, { "product" : "pantalones", "price" : 300, "taxes" : 1.92 }, { "product" : "pantalones jean", "price" : 200, "taxes" : 1.53 } ] prices = list(map(lambda item : item["price"], items)) print(prices) def withtaxes(item): item["taxes"] = item["price"] * item["taxes"] return item realprices = list(map(withtaxes, items)) print(realprices) ```
Senti esta clase un poco mas compleja que las demas, simplemente porque mi cerebro tenia una confusion tremenda entre el uso de la lista/diccionario 'items' y el uso de la variable 'item' tanto en la funcion lambda como en la funcion de los impuestos
Encontre otra forma de hallar el mismo resultado que la funcion lambda en una sola linea asi; ```python prices_v2 = [item['price'] for item in items] print(prices_v2) ```
Con base en... con base EN!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
```python players = [ { 'name': 'Curthois', 'position': 'GK', 'age': '28', 'number': '1' }, { 'name': 'Toni Kroos', 'position': 'Midfielder', 'age': 35, 'number': '8' }, { 'name': 'Luca Modric', 'position': 'Midfielder', 'age': 38, 'number': '10' }, { 'name': 'Federico Valverde', 'position': 'Midfielder', 'age': '24', 'number': 21 }, { 'name': 'Vinicius ', 'position': 'Forward', 'age': 23, 'number': '7' }, { 'name': 'Rodrigo ', 'position': 'Forward', 'age': 22, 'number': '9' }, ] listMidfielders = list( map(lambda item: item['name'], filter(lambda item: item['position'] == 'Midfielder', players))) print(listMidfielders) print('---------------------------------') print('Players with age less than 30') print ('*'*10) listPlayerLess30 = list( map(lambda item: item['name'], filter(lambda item: int(item['age']) < 30, players))) ```
![](https://static.platzi.com/media/user_upload/code-3895db5b-d1fa-407c-8f34-660113324596.jpg)
Este tutorial sobre json y diccionarios vale mucho la pena. <https://www.freecodecamp.org/espanol/news/python-leer-archivo-json-como-cargar-json-desde-un-archivo-y-procesar-dumps/>
Comparto esta opción con List comprehension: `products = [{'product':'camisa', 'price':100},{'product':'pantalon', 'price':150},{'product':'zapatos', 'price':350}]` `new_products_v2 = [item | {'taxes': item['price'] * 0.19} for item in products] ` `print(products)` `print(new_products_v2)` Nota: El símbolo `|` funciona en este caso como operador de unión entre conjuntos y funciona si y solo si los argumentos son dos diccionarios (este es el caso, ya que se está evaluando cada ítem de la lista como un diccionario `{}`) o por supuesto, si son dos conjuntos como vimos en la clase #4; tener en cuenta que los conjuntos (set) guardan valores de todo tipo a excepción de pares clave valor. De esto último se encargan los diccionarios.
Mi solución: ![](https://static.platzi.com/media/user_upload/imagen-291aa271-b5a7-4f9e-881f-7bca6bb4d79f.jpg)
No entendi porque en este fragmento pone esto: ```python prices = list(map(lambda items : items["price"], items)) ```el ",items)) del final :(
A pesar de haberlo intentado varias veces, no podía con map y lambda... y aquí este profesor por fin me ha dado algo de claridad!

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 = {“hola”: “mundo”, “python”: “es genial”}
longitudes = map(len, diccionario.values())
print(list(longitudes)) # [5, 9]

palabras = [“hola”, “mundo”, “python”]
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[‘impuesto’] = item[‘precio’] * 1.5

en el impuesto quiero poner 12% pero como lo haria

prendas_con_iva = list(map(lambda prenda: {**prenda, ‘iva’: prenda[‘price’] * 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 “shell”

[{'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 = [{ “producto”: “camisa”, “precio”: 100}, {“producto”: “pantalon”, “precio”: 300},{“producto”: “shorts”, “precio”: 200}]

listcontaxes = list(map(lambda item: "Producto: “+item[“producto”]+”, Precio: “+str(item[“precio”])+”, Impuesto: "+str(item[“precio”]*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 “función” es la función que se aplica a cada elemento del iterable, y “iterable” 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 {“Juan”: 40, “María”: 60, “Pedro”: 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. 👍

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)