Guida definitiva alla funzione di mappa Python per l'elaborazione dei dati
Introduzione
Possiamo usare la funzione incorporata Python map()
per applicare una funzione a ciascun elemento in un iterabile (come un elenco 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 map alla funzione list()
, o ad 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 ciclo for
, 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 solo un elemento alla volta anziché creare copie degli elementi in un altro iterabile. Ciò è particolarmente utile quando si lavora su programmi che elaborano grandi set di dati. map()
può anche accettare più iterabili come argomenti della funzione inviando alla funzione un elemento alla volta da ciascun iterabile.
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 in funzione utilizzando più argomenti iterabili.
Utilizzo di una funzione Lambda
Il primo argomento di map()
è una funzione, che usiamo 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 mappa. Per il primo argomento della funzione, possiamo passare una funzione definita dall'utente oppure utilizzare le 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 un elenco come il seguente, possiamo implementare una funzione lambda
con un'espressione che vogliamo applicare a ciascun elemento del nostro elenco:
numbers = [10, 15, 21, 33, 42, 55]
Per applicare un'espressione a ciascuno dei nostri numeri, possiamo usare map()
e lambda
:
mapped_numbers = list(map(lambda x: x * 2 + 3, numbers))
Qui dichiariamo un elemento nella nostra lista come x
. Quindi aggiungiamo la nostra espressione. Passiamo la nostra lista di numeri come iterabile per map()
.
Per ricevere immediatamente i risultati, stampiamo un elenco dell'oggetto map
:
print(mapped_numbers)
[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 dall'uomo come:
. L'oggetto mappa è un iteratore sui nostri risultati, quindi potremmo ripeterlo 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()
è molto utile quando si lavora con set di dati di grandi dimensioni, quindi probabilmente lavoreremo ulteriormente con l'oggetto map e generalmente non utilizzeremmo un costruttore come list()
su di loro.
Per set di dati più piccoli, la comprensione delle liste potrebbe essere più adatta, ma ai fini di questo tutorial utilizzeremo un piccolo set di dati per dimostrare map()
.
Implementazione di una funzione definita dall'utente
Analogamente a lambda
possiamo utilizzare una funzione che abbiamo definito da applicare a un iterabile. Mentre le funzioni lambda
sono più utili da implementare quando lavori con un'espressione su una riga, le funzioni definite dall'utente sono più appropriate quando l'espressione diventa più complessa. Inoltre, quando dobbiamo passare un altro dato alla funzione che stai applicando al tuo 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 creature del nostro acquario:
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 sposteranno nella stessa vasca. 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 nidificata:
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()
sulla riga finale. La funzione assign_to_tank
restituirà l'iteratore risultante da map()
.
apply()
accetta x
come argomento, che rappresenta un elemento nella nostra lista — un singolo dizionario.
Successivamente definiamo che x
è la chiave "tank number"
di aquarium_creatures
e che dovrebbe memorizzare il passato in new_tank_number
. Restituiamo ogni articolo dopo aver applicato il nuovo numero di serbatoio.
Chiamiamo assign_to_tank()
con il nostro elenco di dizionari e il nuovo numero di carro armato che vogliamo sostituire per ogni creatura:
assigned_tanks = assign_to_tank(aquarium_creatures, 42)
Una volta completata la funzione, il nostro oggetto mappa viene memorizzato nella variabile assigned_tanks
, che trasformiamo in un elenco e stampiamo:
print(list(assigned_tanks))
Riceveremo il seguente output da questo programma:
[{'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 nel nostro elenco di dizionari. Utilizzando una funzione da noi definita, possiamo incorporare map()
per applicare la funzione in modo efficiente su ciascun elemento dell'elenco.
Utilizzo di una funzione incorporata con più iterable
Allo stesso modo delle funzioni lambda
o delle nostre funzioni definite, possiamo usare le funzioni integrate di Python con map()
. Per applicare una funzione con più iterabili, passiamo un altro nome iterabile dopo il primo. Ad esempio, utilizzando la funzione pow()
che accetta due numeri per trovare la potenza del numero base rispetto all'esponente fornito.
Qui abbiamo i nostri elenchi di numeri interi che vorremmo utilizzare con pow()
:
base_numbers = [2, 4, 6, 8, 10]
powers = [1, 2, 3, 4, 5]
Successivamente passiamo pow()
come funzione a map()
e forniamo i due elenchi come nostri iterabili:
numbers_powers = list(map(pow, base_numbers, powers))
print(numbers_powers)
map()
applicherà la funzione pow()
allo stesso elemento in ogni elenco per fornire potenza. Pertanto i nostri risultati mostreranno 2**1
, 4**2
, 6**3
e così via:
[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ù breve. Nel seguente programma estendiamo 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, non cambierà nulla nel calcolo di questo programma e quindi produrrà comunque lo stesso risultato:
[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 verificato 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 integrate. Inoltre, map()
può essere applicato a funzioni che richiedono più iterabili, migliorando la sua versatilità nelle attività di elaborazione dati.
A scopo dimostrativo, abbiamo convertito i risultati di map()
direttamente in un elenco. Nelle applicazioni pratiche, l'oggetto mappa restituito può essere ulteriormente manipolato per soddisfare esigenze specifiche.
Per approfondire la tua comprensione di Python, utilizza le seguenti risorse:
- Tutorial sulla funzione Python
map()
per esempi e casi d'uso più dettagliati. - Comprendere i dizionari in Python per migliorare la tua conoscenza delle strutture dati Python.
- Funzioni stringa Python per esplorare varie tecniche di manipolazione delle stringhe.
Queste risorse ti forniranno una comprensione completa delle capacità di Python e di come utilizzarle in modo efficace nei tuoi progetti.
Se desideri saperne di più su Python, consulta la nostra serie Come codificare in Python e la nostra pagina di argomenti Python. Per saperne di più su come lavorare con i set di dati nella programmazione funzionale, consulta il nostro articolo sulla funzione filter()
.
Domande frequenti
Cosa fa map() in Python?
La funzione map()
in Python accetta 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?
Puoi creare un oggetto mappa chiamando la funzione incorporata map()
con una funzione e almeno un elemento iterabile come argomenti. Per esempio:
def add_one(x):
return x + 1
my_list = [1, 2, 3]
mapped = map(add_one, my_list) # Creates a map object
È quindi possibile scorrere la mappatura o convertirla in un elenco per visualizzare i risultati:
print(list(mapped)) # [2, 3, 4]
La mappa è pigra in Python?
Sì, in Python 3, map()
restituisce un iteratore pigro, il che significa che non elabora o memorizza tutti i risultati in memoria contemporaneamente. Invece, calcola ogni risultato su richiesta mentre lo si ripete. Ciò può essere più efficiente in termini di memoria, soprattutto per set di dati di grandi dimensioni, ma significa anche che non è possibile indicizzare direttamente o eseguire iterazioni ripetute sullo stesso oggetto della mappa senza ricostruirlo.
Come funziona la funzione map()
?
La funzione map()
funziona come segue:
- Fornisci una funzione e uno o più elementi iterabili.
map()
recupera un elemento da ogni iterabile.- Chiama la funzione con questi elementi come argomenti.
- Produce il risultato di quella chiamata di funzione.
- Ripete questo processo finché uno qualsiasi degli iterabili non viene esaurito.
Se vengono forniti più iterabili, map()
si ferma quando l'iterabile più breve viene esaurito. Per 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?
L'utilizzo di map()
dipende dalle preferenze personali e dalla leggibilità:
Pro:
- In alcuni casi può essere più conciso.
- Può essere leggermente più veloce della comprensione degli elenchi in determinati scenari (anche se spesso non in modo significativo).
Contro:
- Il codice che utilizza le comprensioni di elenco o le espressioni del generatore è spesso considerato più "Pythonic" e più facilmente leggibile.
- I nuovi programmatori Python potrebbero trovare la comprensione delle liste più intuitiva.
In breve, usa map()
se rende il tuo codice più chiaro e diretto. Altrimenti, le comprensioni delle liste o le espressioni del generatore sono un'alternativa molto comune.
Come convertire map
in stringa in Python?
Un oggetto map
è un iteratore, non una stringa. Se vuoi convertire i risultati di una chiamata map()
in una stringa, devi prima eseguire un'iterazione su di essa. Gli approcci comuni includono:
- Conversione in un elenco e quindi in una rappresentazione di stringa:
mapped = map(str, [1, 2, 3])
string_representation = str(list(mapped)) # "[‘1’, ‘2’, ‘3’]"
- Unione dei risultati se sono elementi stringa:
mapped = map(str, [1, 2, 3])
joined_string = ''.join(mapped) # "123"
Il metodo migliore dipende se si desidera una rappresentazione di elenco leggibile dall'uomo (str(list(...))
) o una concatenazione dei risultati (''.join(... )).
Cosa fa map count()
?
Gli oggetti map
in Python non hanno un metodo count()
integrato. Il metodo count()
è disponibile su elenchi, stringhe e alcune altre raccolte. Se vuoi contare le occorrenze di un valore prodotto da un oggetto mappa, devi prima convertirlo in un elenco (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, because 2*2=4 appears twice
Se hai bisogno di un conteggio senza convertirlo in un elenco, puoi ripetere 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(function, iterable)
: applica la funzione a ciascun elemento di iterable e restituisce un iteratore dei risultati.filter(function, iterable)
: restituisce un iteratore di elementi da iterable per il quale function(element) è True. Se funzione è None, restituisce 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 ogni elemento, mentre filter
seleziona determinati elementi in base a una condizione.