Map con diccionarios

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

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 “diccionario” 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 “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)

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)

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)

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.

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. 👍

Hola a todos, aquí mi aporte. Cambié items por celulares y quise agregar la información “tax” y sumarla con “price” para obtener “total”.

Me apoyé de la documentación de Python para hacer uso de “d | 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))