Guida definitiva alla funzione Map di Python per l’elaborazione dei dati

Introduzione

Possiamo utilizzare la funzione integrata di Python map() per applicare una funzione a ciascun elemento in un iterabile (come una lista o un dizionario) e restituire un nuovo iteratore per recuperare i risultati. map() restituisce un oggetto mappa (un iteratore), che possiamo utilizzare in altre parti del nostro programma. Possiamo anche passare l’oggetto mappa alla funzione list(), o a un altro tipo di sequenza, per creare un iterabile.

La sintassi per la funzione map() è la seguente:

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

Invece di utilizzare un for loop, la funzione map() fornisce un modo per applicare una funzione a ogni elemento in un iterabile. Pertanto, può spesso essere più performante poiché applica la funzione a un elemento alla volta anziché copiare gli elementi in un altro iterabile. Questo è particolarmente utile quando si lavora su programmi che elaborano grandi set di dati. map() può anche accettare più iterabili come argomenti per la funzione, inviando un elemento da ciascun iterabile alla funzione alla volta.

In questo tutorial, esamineremo tre diversi modi di lavorare con map(): con una funzione lambda, con una funzione definita dall’utente e infine con una funzione integrata che utilizza più argomenti iterabili.

Utilizzo di una funzione Lambda

Il primo argomento di map() è una funzione, che utilizziamo per applicare a ciascun elemento. Python chiama la funzione una volta per ogni elemento nell’iterabile che passiamo a map() e restituisce l’elemento manipolato all’interno di un oggetto mappato. Per il primo argomento della funzione, possiamo passare una funzione definita dall’utente oppure possiamo fare uso di funzioni lambda, in particolare quando l’espressione è meno complessa.

La sintassi di map() con una funzione lambda è la seguente:

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

Con una lista come quella seguente, possiamo implementare una funzione lambda con un’espressione che vogliamo applicare a ciascun elemento nella nostra lista:

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

Per applicare un’espressione su ciascuno dei nostri numeri, possiamo utilizzare map() e lambda:

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

Qui dichiariamo un elemento nella nostra lista come x. Poi aggiungiamo la nostra espressione. Passiamo la nostra lista di numeri come iterabile per map().

Per ricevere immediatamente i risultati di questo, stampiamo una lista dell’oggetto map:

print(mapped_numbers)

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

Abbiamo utilizzato list() in modo che l’oggetto mappa ci venga restituito come un elenco, piuttosto che un oggetto meno leggibile come: <map object at 0x7fc250003a58>. L’oggetto mappa è un iteratore sui nostri risultati, quindi potremmo iterarlo con for oppure possiamo usare list() per trasformarlo in un elenco. Lo stiamo facendo qui perché è un buon modo per rivedere i risultati.

In definitiva map() è più utile quando si lavora con grandi set di dati, quindi probabilmente lavoreremo ulteriormente con l’oggetto mappa e generalmente non utilizzeremmo un costruttore come list() su di essi.

Per set di dati più piccoli, le comprensioni di elenco potrebbero essere più adatte, ma per gli scopi di questo tutorial stiamo usando un piccolo set di dati per dimostrare map().

Implementazione di una Funzione Definita dall’Utente

Allo stesso modo di una lambda possiamo usare una funzione che abbiamo definito per applicarla a un iterabile. Mentre le funzioni lambda sono più utili da implementare quando si lavora con un’espressione su una sola riga, le funzioni definite dall’utente sono più appropriate quando l’espressione cresce in complessità. Inoltre, quando è necessario passare un altro pezzo di dati alla funzione che si sta applicando al proprio iterabile, le funzioni definite dall’utente possono essere una scelta migliore per la leggibilità.

Ad esempio, nel seguente iterabile, ogni elemento è un dizionario che contiene diversi dettagli su ciascuna delle nostre creature acquatiche:

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

Abbiamo deciso che tutte le creature dell’acquario si trasferiranno nello stesso serbatoio. Dobbiamo aggiornare i nostri registri per riflettere che tutte le nostre creature si stanno spostando nel serbatoio 42. Per fare in modo che map() acceda a ciascun dizionario e a ciascuna coppia chiave:valore nei dizionari, costruiamo una funzione annidata:

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)

Definiamo una funzione assign_to_tank() che accetta aquarium_creatures e new_tank_number come parametri. In assign_to_tank() passiamo apply() come funzione a map() nell’ultima riga. La funzione assign_to_tank restituirà l’iteratore risultante da map().

apply() prende x come argomento, che rappresenta un elemento nella nostra lista – un singolo dizionario.

Successivamente definiamo che x è la chiave "tank number" da aquarium_creatures e che dovrebbe memorizzare il new_tank_number passato. Restituiamo ciascun elemento dopo aver applicato il nuovo numero del serbatoio.

Chiamiamo assign_to_tank() con la nostra lista di dizionari e il nuovo numero del serbatoio che vogliamo sostituire per ciascuna creatura:

assigned_tanks = assign_to_tank(aquarium_creatures, 42)

Una volta completata la funzione, abbiamo il nostro oggetto mappa memorizzato nella variabile assigned_tanks, che trasformiamo in una lista e stampiamo:

print(list(assigned_tanks))

Riceveremo il seguente output da questo programma:

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

Abbiamo mappato il nuovo numero del serbatoio alla nostra lista di dizionari. Utilizzando una funzione che definiamo, possiamo incorporare map() per applicare la funzione in modo efficiente su ciascun elemento della lista.

Utilizzare una Funzione Integrata con più Iterabili

Allo stesso modo delle funzioni lambda o delle nostre funzioni definite, possiamo utilizzare le funzioni integrate di Python con map(). Per applicare una funzione con più iterabili, passiamo un altro nome di iterabile dopo il primo. Ad esempio, utilizzando la pow() funzione che prende due numeri per trovare la potenza del numero di base all’esponente fornito.

Qui abbiamo le nostre liste di interi che vorremmo usare con pow():

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

Successivamente passiamo pow() come nostra funzione a map() e forniamo le due liste come nostri iterabili:

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

print(numbers_powers)

map() applicherà la funzione pow() allo stesso elemento in ciascuna lista per fornire la potenza. Pertanto, i nostri risultati mostreranno 2**1, 4**2, 6**3, e così via:

Output
[2, 16, 216, 4096, 100000]

Se dovessimo fornire a map() un iterabile più lungo dell’altro, map() smetterebbe di calcolare una volta raggiunta la fine dell’iterabile più corto. Nel seguente programma stiamo estendendo base_numbers con tre numeri aggiuntivi:

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)

Di conseguenza, nulla cambierà nel calcolo di questo programma e quindi produrrà ancora lo stesso risultato:

Output
[2, 16, 216, 4096, 100000]

Abbiamo usato la funzione map() con una funzione incorporata di Python e abbiamo visto che può gestire più iterabili. Abbiamo anche rivisto che map() continuerà a elaborare più iterabili fino a raggiungere la fine dell’iterabile con il minor numero di elementi.

Conclusione

In questo tutorial, abbiamo esplorato vari metodi per utilizzare la funzione map() in Python. Ora hai la possibilità di utilizzare map() con funzioni personalizzate, espressioni lambda e altre funzioni incorporate. Inoltre, map() può essere applicato a funzioni che richiedono più iterabili, migliorando la sua versatilità nelle attività di elaborazione dei dati.

Per scopi dimostrativi, abbiamo convertito i risultati da map() direttamente in una lista. Nelle applicazioni pratiche, l’oggetto mappa restituito può essere ulteriormente manipolato per soddisfare esigenze specifiche.

Per approfondire la tua comprensione di Python, ti preghiamo di utilizzare le seguenti risorse:

• tutorial sulla funzione map() di Python per esempi e casi d’uso più dettagliati.
• Comprensione dei dizionari in Python per migliorare la tua conoscenza delle strutture dati in Python.
• Funzioni delle stringhe in Python per esplorare varie tecniche di manipolazione delle stringhe.

Queste risorse ti forniranno una comprensione esaustiva delle capacità di Python e di come utilizzarle in modo efficace nei tuoi progetti.

Se desideri apprendere di più su Python, dai un’occhiata alla nostra serie Come programmare in Python e alla nostra pagina sugli argomenti di Python. Per saperne di più sul lavoro con insiemi di dati nella programmazione funzionale, consulta il nostro articolo sulla funzione filter().

Domande frequenti

Cosa fa la funzione map() in Python?

La funzione map() in Python prende una funzione e uno o più iterabili e restituisce un iteratore che applica la funzione data a ciascun elemento degli iterabili forniti. In altre parole, “mappa” la funzione su ciascun elemento dell’iterabile. Per esempio:

numbers = [1, 2, 3, 4]
squares = map(lambda x: x**2, numbers)

Qui, squares sarà un iteratore di 1, 4, 9, 16.

Come si crea una mappa in Python?

Si crea un oggetto mappa chiamando la funzione built-in map() con una funzione e almeno un iterabile come argomenti. Per esempio:

def add_one(x):
    return x + 1

my_list = [1, 2, 3]
mapped = map(add_one, my_list)  # Crea un oggetto mappa

È possibile quindi iterare su mappato o convertirlo in una lista per visualizzare i risultati:

print(list(mapped))  # [2, 3, 4]

È map lazy in Python?

Sì, in Python 3, map() restituisce un iteratore lazy, il che significa che non elabora o memorizza tutti i risultati in memoria contemporaneamente. Invece, calcola ciascun risultato su richiesta durante l’iterazione su di esso. Questo può essere più efficiente in termini di memoria, specialmente per grandi set di dati, ma significa anche che non è possibile indicizzare direttamente o iterare ripetutamente sullo stesso oggetto mappa senza ricostruirlo.

Come funziona la funzione map()?

La funzione map() funziona come segue:

1. Si fornisce una funzione e uno o più iterabili.
2. map() recupera un elemento da ciascun iterabile.
3. Chiama la funzione con questi elementi come argomenti.
4. Restituisce il risultato di quella chiamata alla funzione.
5. Ripete questo processo fino a quando uno degli iterabili è esaurito.

Se vengono forniti più iterabili, map() si ferma quando l’iterabile più corto è esaurito. Ad esempio:

numbers = [1, 2, 3]
others = [10, 20, 30]
result = map(lambda x, y: x + y, numbers, others)
print(list(result))  # [11, 22, 33]

Dovrei usare map in Python?

Se dovresti usare map() dipende dalle preferenze personali e dalla leggibilità:

Pro:

• Può essere più conciso in alcuni casi.
• Può essere leggermente più veloce delle comprensioni di lista in alcuni scenari (anche se spesso non in modo significativo).

Contro:

• Il codice che utilizza le comprensioni di lista o le espressioni generatori è spesso considerato più “Pythonic” e più facilmente leggibile.
• I programmatori più nuovi di Python potrebbero trovare le comprensioni di lista più intuitive.

In breve, utilizza map() se rende il tuo codice più chiaro e diretto. Altrimenti, le comprensioni di lista o le espressioni generator sono un’alternativa molto comune.

Come convertire map in una stringa in Python?

Un oggetto map è un iteratore, non una stringa. Se desideri convertire i risultati di una chiamata a map() in una stringa, devi prima iterarvi. Approcci comuni includono:

• Convertire in una lista e poi in una rappresentazione stringa:

mapped = map(str, [1, 2, 3])
string_representation = str(list(mapped))  # "[‘1’, ‘2’, ‘3’]"

• Unire i risultati se sono elementi di stringa:

mapped = map(str, [1, 2, 3])
joined_string = ''.join(mapped)  # "123"

Il metodo migliore dipende dal fatto che tu voglia una rappresentazione della lista leggibile dall’umanità (str(list(...))) o una concatenazione dei risultati (''.join(...)).

Cosa fa map count()?

Gli oggetti map in Python non hanno un metodo count() incorporato. Il metodo count() è disponibile nelle liste, nelle stringhe e in alcune altre collezioni. Se si desidera contare le occorrenze di un valore prodotto da un oggetto mappato, è necessario prima convertirlo in una lista (che consuma l’iteratore):

mapped = map(lambda x: x*2, [1, 2, 3, 2])
mapped_list = list(mapped)
count_of_4 = mapped_list.count(4)  # 2, perché 2*2=4 appare due volte

Se hai bisogno di un conteggio senza convertire in una lista, potresti iterare manualmente:

count_of_value = sum(1 for x in map(lambda x: x*2, [1, 2, 3, 2]) if x == 4)

Cosa fanno map e filter in Python?

• map(funzione, iterabile): Applica la funzione ad ogni elemento dell’iterabile e restituisce un iteratore dei risultati.

• filter(funzione, iterabile): Restituisce un iteratore degli elementi dell’iterabile per i quali funzione(elemento) è True. Se la funzione è None, restituisce gli elementi che sono veri di per sé.

Per esempio:

nums = [1, 2, 3, 4, 5]
mapped_nums = map(lambda x: x*2, nums)        # [2, 4, 6, 8, 10]
filtered_nums = filter(lambda x: x > 2, nums) # [3, 4, 5]

map trasforma ciascun elemento, mentre filter seleziona determinati elementi in base a una condizione.