La funzione map() di Python

La funzione map() è una funzione built-in di Python che ti consente di applicare una funzione a tutti gli elementi di un oggetto iterabile come una lista o una tupla e restituisce un iteratore.

map(funzione, iterabile, ...)

Gli argomenti della funzione map() sono

• funzione: è la funzione da applicare a ogni elemento dell'iterabile.
• iterabile: è l'iterabile i cui elementi verranno elaborati dalla funzione.

A ogni iterazione l'iteratore prende gli elementi degli oggetti iterabili e li utilizza come argomenti della funzione, restituendo il risultato.

A cosa serve? Questa funzione è particolarmente utile quando hai bisogno trasformare una serie di dati senza dover utilizzare esplicitamente un ciclo. Inoltre, la funzione map() restituisce un iteratore, il che significa che non occupa immediatamente memoria per tutti gli elementi elaborati. Quindi, è molto efficiente perché occupa poca memoria del computer.

Ecco un esempio pratico.

Definisci una lista con alcuni numeri.

list1 = [2,3,4,5]

Poi crea un iteratore indicando la funzione bin che trasforma un numero in binario e la lista "list1".

z = map(bin, list1)

La funzione map crea un iteratore z.

Quando chiami l'iteratore z con la funzione next(), l'iteratore elabora il primo elemento della lista come argomento della funzione bin() e restituisce il risultato.

next(z)

In questo caso elabora la funzione bin(2) restituendo il numero binario 0b10

0b10

Ora chiama l'iteratore una seconda volta con la funzione next()

next(z)

L'iteratore elabora la funzione bin(3) restituendo il valore binario 0b11

0b11

Puoi usare la funzione map() anche con una funzione personalizzata lambda.

Ad esempio, supponi di avere una lista di numeri e di voler raddoppiare ogni elemento:

numeri = [1, 2, 3, 4]
raddoppiati = map(lambda x: x*2, numeri)

La funzione converte l'iteratore resultante in una lista

print(list(raddoppiati))

Il risultato è una lista con tutti i numeri raddoppiati.

[2, 4, 6, 8]

La funzione map() può prendere più di un iterabile

In questo caso la funzione che specifichi deve prendere altrettanti argomenti quanti sono gli iterabili.

Ad esempio, crea due liste "a" e "b"

a = [1, 2, 3]
b = [10, 20, 30]

Puoi crea un iteratore tramite la funzione map() e una funzione lambda x+y con due argomenti.

 

z = map(lambda x, y: x + y, a, b)

Infine, usa un ciclo for per visualizzare tutto il contenuto dell'iteratore

1. for i in z:
2. print(i)

Il risultato è la somma x+y degli elementi delle liste che si trovano nella stessa posizione: 1+11, 2+20, 3+30

11
22
33

Ti faccio un altro esempio per completezza.

Definisci una funzione chiamata product()

1. def product(x,y):
2. return x*y

Poi crea un iteratore e stampa i risultati

1. for i in map(product, (2,3,4), (5,6)):
2. print(i)

In ogni iterazione del ciclo la funzione map() chiama la funzione product() passandogli due argomenti.

Il risultato in output è il seguente:

10
18

Nella prima iterazione viene richiamata la funzione product(2,5) ossia il prodotto 2*5.

Nella seconda iterazione la funzione product(3,6) ossia il prodotto 3*6

Nota. Il ciclo termina automaticamente quando tutti gli elementi della lista più corta (5,6) sono stati utilizzati.

Molte operazioni che puoi eseguire con map() possono anche essere fatte con la list comprehension.

Ad esempio, l'esempio del raddoppio dei numeri può essere scritto come:

numeri = [1, 2, 3, 4]
raddoppiati = [x*2 for x in numeri]
print (list(raddoppiati))

Il risultato è sempre lo stesso

[2,4,6,8]

Molti sviluppatori trovano la list comprehension più leggibile, ma la scelta tra le due sintassi dipende dalla situazione e dalle tue preferenze personali.