In Python, puoi usare map() per applicare funzioni integral, espressioni lambda (lambda), definite funzioni con def, ecc., a tutti gli elementi gli di iterabili come liste e tuple.
In questo articolo vengono descritti i seguenti contenuti.
- Utilizzo di base di map()
- map() fornisce un iteratore in Python3
- Converti in un elenco
- Applicazione espressioni lambda (lambda)
- applicare le funzioni definite con def
- Specifica più iterabili come argomenti
- Utilizzare invece le comprensioni degli elenchi e le espressioni del generatore
- Usa invece NumPy
Si noti che map() può essere sostituito da comprensioni di liste o espressioni del generatore. Come più avanti, è preferibile utilizzarli in molti casi.
Utilizzo di base di map()
Il primo argomento di map() è un oggetto richiamabile come una funzione da applicare e il secondo argomento è un oggetto iterabile come un elenco.
map() fornisce un iteratore in Python3
applicare la funzione incorporata abs() che contiene il valore assoluto.
In Python 3, map() aggiunge un oggetto di tipo map che è un iteratore e print() non generi elementi.
l = [-2, -1, 0]
print(map(abs, l))
#
print(type(map(abs, l)))
# <class 'map'>
Il valore dell’iteratore può essere recuperato con un’istruzione per.
for i in map(abs, l):
print(i)
# 2
# 1
# 0
Lo stesso risultato si ottiene se il processo viene eseguito in un blocco per senza utilizzare map().
for i in l:
print(abs(i))
# 2
# 1
# 0
Nota che map() in Python 2 riporta un elenco, quindi fai attenzione quando esegui il codice Python 2 in Python 3.
Converti in un elenco
Se vuoi ottenere il risultato di map() in una lista, usa list().
print(list(map(abs, l)))
# [2, 1, 0]
Ad esempio, applica len() a un elenco di stringhe per convertirlo in un elenco del numero di caratteri.
l_s = ['apple', 'orange', 'strawberry']
print(list(map(len, l_s)))
# [5, 6, 10]
Nel secondo argomento di map(), è possibile specificare non solo una lista ma anche un iterabile come una tupla o un intervallo.
print(list(map(abs, range(-2, 1))))
# [2, 1, 0]
Applicazione espressioni lambda (lambda)
Se vuoi applicare un processo invece di una funzione incorporata, usa l’espressione lambda (lambda).
l = [-2, -1, 0]
print(list(map(lambda x: x**2, l)))
# [4, 1, 0]
applicare le funzioni definite con def
È anche possibile definire una funzione con def e specificarla come primo argomento di map().
def square(x):
return x**2
print(list(map(square, l)))
# [4, 1, 0]
Specifica più iterabili come argomenti
Puoi specificare più iterabili come map(function, iterable1, iterable2, …).
Se vengono specificati più iterabili, il primo argomento deve essere una funzione che riceve quel numero di argomenti. Viene generato un errore se il numero di iterabili non corrisponde al numero di argomenti ricevuti dalla funzione.
l_1 = [1, 2, 3]
l_2 = [10, 20, 30]
print(list(map(lambda x, y: x * y, l_1, l_2)))
# [10, 40, 90]
# print(list(map(abs, l_1, l_2)))
# TypeError: abs() takes exactly one argument (2 given)
Se gli iterabili hanno dimensioni diverse (numero di elementi), gli elementi extra vengono ignorati.
l_3 = [100, 200, 300, 400]
print(list(map(lambda x, y, z: x * y * z, l_1, l_2, l_3)))
# [1000, 8000, 27000]
Utilizzare invece le comprensioni degli elenchi e le espressioni del generatore
Lo stesso processo di map() può essere ottenuto con la comprensione degli elenchi e le espressioni del generatore.
l = [-2, -1, 0]
print([abs(x) for x in l])
# [2, 1, 0]
print([x**2 for x in l])
# [4, 1, 0]
l_1 = [1, 2, 3]
l_2 = [10, 20, 30]
print([x * y for x, y in zip(l_1, l_2)])
# [10, 40, 90]
Se vuoi ottenere una lista come list(map()), usa le list comprehensions, e se vuoi ottenere un iteratore come map(), usa un’generatore.
Come mostrato nella seguente domanda sull’overflow dello stack, nella maggior parte dei casi, è preferibile utilizzare la comprensione degli elenchi e le espressioni del generatore a map() perché il codice è più conciso e chiaro.
Per la velocità di elaborazione, sono state fornite le seguenti risposte.
Tieni che, poiché la velocità di più può presentare variazione a causa di vari fattori, se la velocità è importante per te, ti riguarda di misurarla in condizioni il vicino possibile tue ipotesi.
Usa invece NumPy
Nel caso di una lista di numeri, il processo di map() può essere realizzato anche con NumPy. Il codice è ancora più chiaro di map() e list comprehensions.
import numpy as np
a = np.array([-2, -1, 0])
print(np.abs(a))
# [2 1 0]
print(a**2)
# [4 1 0]
a_1 = np.array([1, 2, 3])
a_2 = np.array([10, 20, 30])
print(a_1 * a_2)
# [10 40 90]
NumPy è più veloce per elenchi di grandi dimensioni ed elaborazioni complesse. NumPy fornisce varie funzioni, quindi deve provarle se stai elaborando una matrice di numeri.