Python map() Funktion, förklaras med exempel

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.