I denna handledning kommer du att utforska hur du kan dra nytta av Pythons `map()`-funktion för att applicera en specifik funktion på varje element i en itererbar samling.
Python stödjer ett funktionellt programmeringsparadigm, vilket ger dig förmågan att definiera operationer som funktionsberäkningar på ett programmatiskt sätt. I Python kan funktioner behandlas som objekt, vilket innebär att en funktion kan ta emot en annan funktion som parameter, och även returnera en funktion som resultat.
Funktionen `map()` fungerar genom att ta en funktion som indata och sedan tillämpa denna funktion på vartenda objekt i en given sekvens.
Genom att gå igenom denna handledning kommer du att lära dig hur du effektivt kan använda Pythons `map()`-funktion för att ersätta mer detaljerade loopar och listkomprehensioner. Vi kommer att koda flera exempel tillsammans för att ge dig en djupare förståelse för hur du kan använda `map()`-funktionen på olika sätt.
Hur man tillämpar en funktion på element i en Python-lista
Låt oss börja med ett konkret exempel. 👩🏫
Vi har en lista med siffror som vi kallar `nums`.
nums = [2, 4, 3, 7]
Vi har också definierat funktionen `self_pow()`. Denna funktion accepterar ett numeriskt argument och returnerar talet upphöjt till sin egen potens, det vill säga nn.
I Python används `**`-operatorn för exponentiering. Så `a**b` beräknar `a` upphöjt till `b`, alltså ab.
def self_pow(n): return n**n
Vår uppgift är nu att skapa en ny lista, `nums_pow`, där varje element är resultatet av att applicera `self_pow()` på motsvarande element i `nums`.
Användning av for-loop
För att lösa detta kan vi använda en `for`-loop i Python:
- För varje tal i `nums`-listan, anropa funktionen `self_pow()` med talet som argument.
- Lägg till resultatet av varje funktionsanrop till den nya listan `nums_pow`.
nums_pow = [] for num in nums: nums_pow.append(self_pow(num)) print(nums_pow)
I utdata ser vi att varje tal i `nums` har höjts till sin egen potens. Således innehåller `nums_pow` elementen: 22, 44, 33 och 77.
Output [4, 256, 27, 823543]
Använda listkomprehension
Vi kan uppnå samma resultat mer kortfattat med listkomprehension. Om vi analyserar `for`-loopen ovan kan vi identifiera uttrycket för utdata och den itererbara lista som ska genomlöpas.
Vi kan använda följande generella struktur för listkomprehension:
new_list = [<uttryck för utdata> for item in iterable]
För att generera `nums_pow`-listan, ser listkomprehensionen ut såhär:
nums_pow = [self_pow(num) for num in nums] print(nums_pow)
Utdata är densamma som för `for`-loopen, vilket förväntas.
Output [4, 256, 27, 823543]
Istället för `for`-loopar och listkomprehensioner kan vi använda Pythons `map()`-funktion, som ger en mer kortfattad syntax och hjälper oss att tillämpa en funktion på alla element i en itererbar samling. Låt oss börja med att lära oss syntaxen för `map()`-funktionen.
Syntax för Pythons `map()`-funktion
Den grundläggande syntaxen för att använda Pythons `map()`-funktion är:
map(funktion, itererbar_1, [itererbar_2, ..., itererbar_n])
`map()`-funktionen tar minst två argument: en funktion och en itererbar.
I syntaxen ovan:
- `funktion` är en Python-funktion eller en godtycklig anropsbar Python-enhet. Detta kan vara användardefinierade funktioner, inbyggda funktioner, klasser, instansmetoder och klassmetoder med mera.
- `itererbar` är en giltig Python-itererbar, till exempel en lista, en tupel eller en sträng.
- `map()`-funktionen tillämpar den angivna `funktionen` på varje element i den `itererbara` samlingen.
Vad returnerar `map()`-funktionen?
Den returnerar ett map-objekt. Detta objekt kan sedan omvandlas till en lista med syntaxen: `list(map(funktion, itererbar))`.
Beroende på användningsfallet kan du också konvertera det till en tupel i Python.
Nu när vi har förstått syntaxen för Pythons `map()`-funktion, låt oss börja med några kodexempel.
Det är en fördel om du har Python 3.x installerat för att kunna följa med i handledningen. Om inte, kan du också använda online-redigeraren för Python på adminvista.com för att köra kodsnuttarna.
Använda `map()`-funktionen med användardefinierade funktioner
#1. Tidigare tillämpade vi funktionen `self_pow()` på varje nummer i `nums`-listan. Med syntaxen för `map()`-funktionen kan vi ge `self_pow`-funktionen och `nums`-listan som argument.
Obs: Du ska ange funktionen som ett namn, inte som ett anrop, så använd `self_pow` och inte `self_pow()`.
`map()`-funktionen returnerar ett map-objekt.
print(map(self_pow, nums)) <map object at 0x7f7d315c14d0>
Vi kan omvandla detta map-objekt till en lista med funktionen `list()`, som visas nedan.
nums_pow = list(map(self_pow, nums)) print(nums_pow)
Här är resultatet, där varje tal i `nums` har mappats till taltal i `nums_pow`-listan.
Output [4, 256, 27, 823543]
#2. Betrakta nu funktionen `inch_to_cm()`, som omvandlar tum till centimeter, där 1 tum = 2.54 cm.
def inch_to_cm(inch): return inch * 2.54
För att konvertera tumvärdena i `inches`-listan till centimeter kan vi använda `map()`-funktionen som visas i kodcellen nedan.
inches = [5.54, 3.4, 1, 25, 8.2] cms = list(map(inch_to_cm, inches)) print(cms)
`cms`-listan innehåller nu tumvärdena omvandlade till centimeter.
Output [14.0716, 8.636, 2.54, 63.5, 20.828]
Använda `map()`-funktionen med inbyggda funktioner
I detta avsnitt kommer vi att utforska hur man använder `map()` med inbyggda Python-funktioner.
#1. Vi har listan `strings` som innehåller namn på programmeringsspråk. Vi vill skapa en ny lista, `strings_upper`, som innehåller samma strängar, men i versaler.
strings = ['JavaScript', 'Rust', 'Python', 'Go']
Den inbyggda strängmetoden `.upper()` appliceras på en sträng och returnerar en kopia av strängen, i versaler.
strings_upper = list(map(str.upper, strings)) print(strings_upper)
Listan `strings_upper` innehåller strängarna från `strings` i versaler.
Output ['JAVASCRIPT', 'RUST', 'PYTHON', 'GO']
#2. Den inbyggda funktionen `len()` i Python tar en sekvens som argument och returnerar dess längd. För att få längden på varje sträng i `strings`-listan kan vi använda `map()`-funktionen och applicera `len()` på varje sträng, som visas nedan.
strings_len = list(map(len, strings)) print(strings_len)
Output [10, 4, 6, 2]
#3. Du kan använda `map()`-funktionen med andra samlingar, till exempel tupler.
Följande exempel innehåller en tupel som beskriver ett hus med information om antalet sovrum, yta och stad.
I Python returnerar funktionen `type()` datatypen för ett givet Python-objekt. För att få datatyperna för alla objekt i tupeln kan vi använda `map()`-funktionen för att anropa `type()`-funktionen på varje element.
house = (2, 758.5, 'Bangalore') house_elt_type = tuple(map(type, house)) print(house_elt_type)
Vi har konverterat map-objektet till en tupel. Det går även att konvertera till en lista eller annan samling.
I utdata ser vi att datatyperna för 2, 758.5 och Bangalore har identifierats som `int`, `float` och `str`, respektive.
Output (<class 'int'>, <class 'float'>, <class 'str'>)
#4. I Python kan du importera inbyggda moduler och använda funktioner som är definierade i dessa moduler.
För att beräkna kvadratroten för varje tal i `nums`-listan, kan vi använda funktionen `sqrt` från `math`-modulen.
import math nums = [30, 90, 34, 45, 97] nums_sqrt = list(map(math.sqrt, nums)) print(nums_sqrt)
Output [5.477225575051661, 9.486832980505138, 5.830951894845301, 6.708203932499369, 9.848857801796104]
Utdata ovan kan vara svårt att analysera. Vi kanske vill avrunda varje kvadratrot till två decimaler.
Hur man avrundar ett flyttal i Python
Låt oss definiera en funktion `round_2()` som tar ett flyttal och avrundar det till två decimaler.
def round_2(num): return round(num, 2)
Nu kan vi använda `map()`-funktionen med `round_2` och `nums_sqrt`-listan.
nums_sqrt_round = list(map(round_2, nums_sqrt)) print(nums_sqrt_round)
Output [5.48, 9.49, 5.83, 6.71, 9.85]
Vi kan också använda nästlade `map()`-funktioner, där den inre `map()`-funktionen beräknar kvadratrotslistan `nums_sqrt`, och den yttre `map()`-funktionen utför avrundningen.
nums_sqrt_round = list(map(round_2, list(map(math.sqrt, nums)))) print(nums_sqrt_round)
Output [5.48, 9.49, 5.83, 6.71, 9.85]
Utdata är identisk för båda metoderna ovan. Du bör dock se till att koden är läsbar och enkel att underhålla när nästlade funktioner används.
Använda `map()`-funktionen med lambda-funktioner
I de tidigare avsnitten har vi lärt oss hur man använder Pythons `map()`-funktion med inbyggda och användardefinierade funktioner. Nu kommer vi att lära oss hur man använder `map()`-funktionen med lambda-funktioner, som är anonyma i Python.
Ibland kan en funktion ha ett enkelt kodblock på en rad, och du kanske bara behöver använda funktionen en gång, utan att referera till den någon annanstans i programmet. Du kan definiera sådana funktioner som lambda-funktioner i Python.
Obs: `lambda args: uttryck` är den allmänna syntaxen för en Python lambda-funktion.
#1. Tänk på följande lista med strängar. Anta att vi vill ha en lista `strings_rev` som innehåller en spegelvänd version av varje sträng.
strings = ['JavaScript', 'Rust', 'Python', 'Go']
Vi kan spegelvända en Python-sträng med hjälp av strängskärning.
Obs: Detta är en generalisering av strängskärningsuttrycket `str[start:stop:step]`.
- Utan start- och stoppvärden börjar skivan i början av strängen och sträcker sig till slutet.
- Negativa stegvärden genererar skivor som börjar från slutet av strängen.
- Därför returnerar `str[::-1]` en spegelvänd kopia av `str`.
Vi kan använda lambda-funktionen `lambda x: x[::-1]` inuti `map()`-funktionen, som visas nedan.
strings_rev = list(map(lambda x: x[::-1], strings)) print(strings_rev)
Som i andra exempel, omvandlar vi map-objektet till en lista. I utdata kan vi se att varje sträng i `strings`-listan har blivit spegelvänd.
Output ['tpircSavaJ', 'tsuR', 'nohtyP', 'oG']
#2. I det tidigare avsnittet beräknade vi kvadratroten av varje tal i `nums`-listan, och sedan avrundade vi varje kvadratrot till två decimaler.
Vi använde funktionen `round_2()` för detta. Låt oss nu skriva om `round_2()` som en lambda-funktion och använda den med `map()`-funktionen enligt beskrivningen nedan.
nums_sqrt_round_l = list(map(lambda num: round(num, 2), nums_sqrt)) print(nums_sqrt_round_l)
Som utdata visar, är resultatet identiskt med vad vi fick genom att använda funktionen `round_2()`.
Output [5.48, 9.49, 5.83, 6.71, 9.85]
Använda `map()`-funktionen med flera itererbara samlingar
I exemplen vi har sett hittills har vi applicerat en funktion på varje element i en enda itererbar samling.
Ibland kan vi ha funktioner som accepterar två eller fler argument. I sådana fall kan varje argument lagras i en lista eller liknande samling.
Vi kan också använda Pythons `map()`-funktion med flera listor.
#1. Betrakta funktionen `area()` som tar längd och bredd som inparameter och returnerar arean, alltså längd * bredd.
def area(length, breadth): return length * breadth
Längd och bredd för olika rektanglar är lagrade i två separata listor, `lengths` respektive `breadths`.
lengths = [4, 8, 10, 18] breadths = [9, 4, 6, 11]
Vi kan använda `map()`-funktionen för att applicera `area`-funktionen på listorna ovan genom att ge både `lengths`- och `breadths`-listorna som input.
areas = list(map(area, lengths, breadths)) print(areas)
Eftersom funktionen `area` tar två argument kommer längd- och breddvärdena tas från `lengths`- respektive `breadths`-listorna.
Output [36, 32, 60, 198]
#2. Pythons `math`-modul har en logaritmfunktion som hjälper oss att beräkna logaritmen för ett tal med en valfri bas.
Obs: `log(x, bas)` returnerar värdet på logbas x. Om basen inte anges är standardbasen `e` (log beräknar då den naturliga logaritmen).
I detta exempel:
- Listan `x` motsvarar värdena vars logaritmer vi vill beräkna.
- Listan `base` innehåller de basvärden som ska användas i logaritmberäkningen.
x = [2, 6, 12, 10] base = [2, 3, 2, 5]
Vi kan använda Pythons `map()`-funktion med `math.log`, listorna `x` och `base` för att få en ny lista `log_x`, som följer.
log_x = list(map(math.log, x, base)) print(log_x)
Här är resultatet.
Output [1.0, 1.6309297535714573, 3.5849625007211565, 1.4306765580733933]
Slutsats
Här är en sammanfattning av det du har lärt dig i denna handledning:
- Pythons `map()`-funktion tar minst två argument: en funktion och en itererbar samling. Syntaxen är `map(funktion, itererbar(a))`.
- Funktionen kan vara vilken giltig Python-anropbar som helst.
- Om funktionen tar k-argument ska du använda `map()`-funktionen med funktionen och alla k-argumenten som separata itererbara samlingar.
Nästa steg är att utforska hur man arbetar med mängder (`set`) i Python.