One place for hosting & domains

      asignación

      Cómo usar la función de asignación en Python


      Introducción

      Podemos usar la función integrada de Python map() para aplicar una función a cada elemento en un iterable (como una lista o un diccionario) y devolver un nuevo iterador para recuperar los resultados. map() devuelve un objeto de asignación (un iterador) que podemos usar en otras partes de nuestro programa. Podemos también pasar el objeto de asignación a la función list() o a otro tipo de secuencia, para crear un iterable.

      La sintaxis para la función map() es la siguiente:

      map(function, iterable, [iterable 2, iterable 3, ...])
      

      En vez de usar un bucle for, la función map() proporciona una forma de aplicar una función a cada elemento en un iterable. Por tanto, a menudo puede funcionar mejor, ya que solo aplica la función a un elemento cada vez en vez de realizar copias de los elementos a otro iterable. Esto es muy útil cuando se trabaja en programas que procesan grandes conjuntos de datos. map() puede además tomar múltiples iterables como argumentos para la función enviando un elemento desde cada iterable a la función cada vez.

      En este tutorial, revisaremos tres formas diferentes de trabajar con map(): con una función lambda, con una función definida por el usuario y, finalmente, con una función integrada que utiliza múltiples argumentos iterables.

      Usar una función Lambda

      El primer argumento para map() es una función que usamos para aplicar a cada elemento. Python invoca la función una vez para cada elemento en el iterable que pasamos a map() y devuelve el elemento manipulado en un objeto map. Para el primer argumento de la función, podemos pasar una función definida por el usuario o podemos usar las funciones lambda, sobre todo cuando la expresión es menos compleja.

      La sintaxis de map() con una función lambda es la siguiente:

      map(lambda item: item[] expression, iterable)
      

      Con una lista como la siguiente, podemos implementar una función lambda con una expresión que queramos aplicar a cada elemento de nuestra lista:

      numbers = [10, 15, 21, 33, 42, 55]
      

      Para aplicar una expresión contra cada uno de nuestros números, podemos usar map() y lambda:

      mapped_numbers = list(map(lambda x: x * 2 + 3, numbers))
      

      Aquí declaramos un elemento en nuestra lista como x. A continuación, añadimos nuestra expresión. Pasamos nuestra lista de números como el iterable para map().

      Para recibir los resultados de esto inmediatamente, imprimimos una lista del objeto map:

      print(mapped_numbers)
      

      Output

      [23, 33, 45, 69, 87, 113]

      Hemos usado list() de forma que el objeto map se devuelve como una lista, en vez de como un objeto menos legible por el ser humano como <map object at 0x7fc250003a58>. El objeto map es un iterador sobre nuestros resultados, de forma que podríamos hacer un bucle con for o podemos usar list() para convertirlo en una lista. Estamos haciendo esto aquí porque es una buena forma de revisar los resultados.

      Finalmente, map() es muy útil cuando se trabaja con grandes conjuntos de datos, de forma que probablemente trabajemos con el objeto map algo más, y generalmente no usaremos un constructor como list() sobre estos conjuntos de datos.

      Para conjuntos de datos más pequeños, las comprensiones de lista pueden ser más adecuadas, pero, a efectos de este tutorial, estamos usando un conjunto de datos pequeño para demostrar map().

      Implementar una función definida por el usuario

      De forma simular a lambda, podemos usar una función que hayamos definido para aplicarla a un iterable. Aunque es más útil implementar las funciones lambda cuando trabaja con una expresión de una línea, las funciones definidas por el usuario son más apropiadas cuando la expresión aumenta en complejidad. Además, cuando necesitamos pasar otra pieza de datos a la función que está aplicando a su iterable, las funciones definidas por el usuario pueden ser una mejor opción en términos de legibilidad.

      Por ejemplo, en el siguiente iterable, cada elemento es un diccionario que contiene diferentes detalles sobre cada una de nuestras criaturas del acuario:

      aquarium_creatures = [
          {"name": "sammy", "species": "shark", "tank number": 11, "type": "fish"},
          {"name": "ashley", "species": "crab", "tank number": 25, "type": "shellfish"},
          {"name": "jo", "species": "guppy", "tank number": 18, "type": "fish"},
          {"name": "jackie", "species": "lobster", "tank number": 21, "type": "shellfish"},
          {"name": "charlie", "species": "clownfish", "tank number": 12, "type": "fish"},
          {"name": "olly", "species": "green turtle", "tank number": 34, "type": "turtle"}
      ]
      

      Hemos decidido que todas las criaturas del acuario van a ir, de hecho al mismo tanque. Debemos actualizar nuestros registros para reflejar que todas nuestras criaturas se trasladan al tanque 42. Para que map() acceda a cada diccionario y a cada par key:value en los diccionarios, construimos una función anidada:

      def assign_to_tank(aquarium_creatures, new_tank_number):
          def apply(x):
              x["tank number"] = new_tank_number
              return x
          return map(apply, aquarium_creatures)
      

      Definimos una función assign_to_tank() que toma aquarium_creatures y new_tank_number como parámetros. En assign_to_tank() pasamos apply() como la función para map() en la línea final. La función assign_to_tank devolverá el iterador resultante desde map().

      apply() toma x como argumento, lo que representa un elemento en nuestra lista: un diccionario único.

      A continuación, definimos que x es la clave "tank number" de aquarium_creatures y que debería almacenar la pasada en new_tank_number. Devolvemos cada elemento tras aplicar el nuevo número de tanque.

      Invocamos assign_to_tank() con nuestra lista de diccionarios y el nuevo número de tanque que queremos sustituir para cada criatura:

      assigned_tanks = assign_to_tank(aquarium_creatures, 42)
      

      Una vez que la función se completa, tenemos nuestro objeto map almacenado en la variable assigned_tanks, que convertimos en una lista e imprimimos:

      print(list(assigned_tanks))
      

      Recibiremos el siguiente resultado de este programa:

      Output

      [{'name': 'sammy', 'species': 'shark', 'tank number': 42, 'type': 'fish'}, {'name': 'ashley', 'species': 'crab', 'tank number': 42, 'type': 'shellfish'}, {'name': 'jo', 'species': 'guppy', 'tank number': 42, 'type': 'fish'}, {'name': 'jackie', 'species': 'lobster', 'tank number': 42, 'type': 'shellfish'}, {'name': 'charlie', 'species': 'clownfish', 'tank number': 42, 'type': 'fish'}, {'name': 'olly', 'species': 'green turtle', 'tank number': 42, 'type': 'turtle'}]

      Hemos asignado el nuevo número de tanque a nuestra lista de diccionarios. Usando una función que definimos, podemos incorporar map() para aplicar la función de forma eficiente sobre cada elemento de la lista.

      Usar una función integrada con múltiples iterables

      De la misma forma que las funciones lambda o nuestras propias funciones definidas, podemos usar las funciones integradas de Python con map(). Para aplicar una función con múltiples iterables, pasamos otro nombre de iterable tras el primero. Por ejemplo, usando la función pow() que toma dos números para buscar la potencia del número base para el exponente proporcionado.

      Aquí tenemos nuestras listas de enteros que deseamos usar con pow():

      base_numbers = [2, 4, 6, 8, 10]
      powers = [1, 2, 3, 4, 5]
      

      A continuación pasamos pow() como nuestra función en map() y proporcionamos las dos listas como nuestros iterables:

      numbers_powers = list(map(pow, base_numbers, powers))
      
      print(numbers_powers)
      

      map() aplicará la función pow() al mismo elemento en cada lista para proporcionar la potencia. Por tanto, nuestros resultados mostrarán 2**1, 4**2, 6**3, etcétera:

      Output

      [2, 16, 216, 4096, 100000]

      Si fuésemos a proporcionar map() con un iterable que era más largo que el otro, map() dejaría de calcular una vez que llegue al final del iterable más corto. En el siguiente programa, estamos ampliando base_numbers con tres números adicionales:

      base_numbers = [2, 4, 6, 8, 10, 12, 14, 16]
      powers = [1, 2, 3, 4, 5]
      
      numbers_powers = list(map(pow, base_numbers, powers))
      
      print(numbers_powers)
      

      Como resultado, nada cambiará en el cálculo de este programa y así resultará en el mismo resultado:

      Output

      [2, 16, 216, 4096, 100000]

      Hemos usado la función map() con una función de Python integrada y hemos visto que puede gestionar múltiples iterables. También hemos revisado que map() seguirá procesando múltiples iterables hasta que haya llegado al final del iterable con menos elementos.

      Conclusión

      En este tutorial, hemos aprendido las diferentes formas de usar la función map() en Python. Ahora puede usar map() con su propia función, una función lambda y con cualquier otra función integrada. También puede implementar map() con funciones que requieren múltiples iterables.

      En este tutorial, hemos impreso los resultados desde map() de forma inmediata a un formato de lista a efectos demostrativos. En nuestros programas, normalmente, usaríamos el objeto map devuelto para seguir manipulando los datos.

      Si desea aprender más sobre Python, consulte nuestra serie Cómo crear código en Python 3 y en nuestra página de tema Python. Para obtener más información sobre trabajar con conjuntos de datos consulte nuestro artículo sobre la función filter().



      Source link