Ultieme Gids voor de Python Map Functie voor Gegevensverwerking

Inleiding

We kunnen de ingebouwde Python-functie map() gebruiken om een functie toe te passen op elk item in een iterable (zoals een lijst of dictionary) en een nieuwe iterator terug te geven voor het ophalen van de resultaten. map() geeft een map-object terug (een iterator), dat we kunnen gebruiken in andere delen van ons programma. We kunnen ook het map-object doorgeven aan de list()-functie, of een ander sequentietype, om een iterable te maken.

De syntaxis voor de map()-functie is als volgt:

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

In plaats van een for-loop te gebruiken, biedt de map()-functie een manier om een functie toe te passen op elk item in een iterable. Daarom kan het vaak efficiënter zijn omdat het slechts één item per keer de functie toepast in plaats van kopieën van de items te maken in een andere iterable. Dit is vooral handig bij het werken aan programma’s die grote gegevenssets verwerken. map() kan ook meerdere iterables als argumenten aan de functie doorgeven door telkens één item uit elke iterable naar de functie te sturen.

In deze tutorial zullen we drie verschillende manieren bekijken om met map() te werken: met een lambda functie, met een door de gebruiker gedefinieerde functie, en tenslotte met een ingebouwde functie die meerdere iterabele argumenten gebruikt.

Gebruik van een Lambda-functie

Het eerste argument voor map() is een functie, die we gebruiken om op elk item toe te passen. Python roept de functie één keer aan voor elk item in de iterabele die we aan map() doorgeven en het retourneert het gemanipuleerde item binnen een map-object. Voor het eerste functieargument kunnen we ofwel een door de gebruiker gedefinieerde functie doorgeven, of we kunnen gebruikmaken van lambda functies, met name wanneer de expressie minder complex is.

De syntaxis van map() met een lambda-functie is als volgt:

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

Met een lijst zoals de volgende, kunnen we een lambda functie implementeren met een expressie die we op elk item in onze lijst willen toepassen:

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

Om een expressie toe te passen op elk van onze getallen, kunnen we map() en lambda gebruiken:

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

Hier verklaren we een item in onze lijst als x. Vervolgens voegen we onze expressie toe. We geven onze lijst met getallen door als de iterabele voor map().

Om de resultaten hiervan onmiddellijk te ontvangen, printen we een lijst van het map object:

print(mapped_numbers)

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

We hebben list() gebruikt zodat het mapobject aan ons wordt teruggegeven als een lijst, in plaats van een minder leesbaar object zoals: <map object at 0x7fc250003a58>. Het mapobject is een iterator over onze resultaten, dus we kunnen eroverheen lopen met for of we kunnen list() gebruiken om het in een lijst om te zetten. We doen dit hier omdat het een goede manier is om de resultaten te bekijken.

Uiteindelijk is map() het meest nuttig bij het werken met grote datasets, dus we zullen waarschijnlijk verder werken met het mapobject en over het algemeen geen constructor zoals list() op hen gebruiken.

Voor kleinere datasets kunnen lijstcomprehensies geschikter zijn, maar voor de doeleinden van deze tutorial gebruiken we een kleine dataset om map() te demonstreren.

Een door de gebruiker gedefinieerde functie implementeren

Vergelijkbaar met een lambda kunnen we een functie die we hebben gedefinieerd gebruiken om toe te passen op een iterable. Terwijl lambda-functies nuttiger zijn om te implementeren wanneer je werkt met een eén-regelige expressie, zijn door de gebruiker gedefinieerde functies geschikter wanneer de expressie in complexiteit toeneemt. Bovendien, wanneer we een ander stuk gegevens naar de functie moeten doorgeven die je toepast op je iterable, kunnen door de gebruiker gedefinieerde functies een betere keuze zijn voor de leesbaarheid.

Bijvoorbeeld, in de volgende iterable is elk item een woordenboek dat verschillende details bevat over elk van onze aquariumwezens:

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

We hebben besloten dat alle aquariumwezens in feite naar dezelfde tank zullen verhuizen. We moeten onze gegevens bijwerken om aan te geven dat al onze wezens naar tank 42 verhuizen. Om map() toegang te geven tot elk woordenboek en elk sleutel:waarde paar in de woordenboeken, construeren we een geneste functie:

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)

We definiëren een assign_to_tank() functie die aquarium_creatures en new_tank_number als parameters neemt. In assign_to_tank() geven we apply() door als de functie voor map() op de laatste regel. De assign_to_tank functie zal de iterator retourneren die voortkomt uit map().

apply() neemt x als argument, wat een item in onze lijst vertegenwoordigt – een enkel woordenboek.

Daarna definiëren we dat x de "tank nummer" sleutel uit aquarium_creatures is en dat deze de doorgegeven new_tank_number moet opslaan. We retourneren elk item nadat we het nieuwe tanknummer hebben toegepast.

We roepen assign_to_tank() aan met onze lijst van woordenboeken en het nieuwe tanknummer dat we voor elk wezen willen vervangen:

assigned_tanks = assign_to_tank(aquarium_creatures, 42)

Wanneer de functie is voltooid, hebben we ons mapobject opgeslagen in de assigned_tanks variabele, die we omzetten in een lijst en afdrukken:

print(list(assigned_tanks))

We zullen de volgende uitvoer van dit programma ontvangen:

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

We hebben het nieuwe tanknummer gekoppeld aan onze lijst van woordenboeken. Door een functie die we definiëren te gebruiken, kunnen we map() toepassen om de functie efficiënt op elk item van de lijst toe te passen.

Een ingebouwde functie gebruiken met meerdere iterables

Op dezelfde manier als lambda functies of onze eigen gedefinieerde functies, kunnen we ingebouwde Python-functies gebruiken met map(). Om een functie toe te passen met meerdere iterables, geven we een andere iterable naam door na de eerste. Bijvoorbeeld, met de pow() functie die twee getallen neemt om de macht van het basisgetal tot de gegeven exponent te berekenen.

Hier hebben we onze lijsten met gehele getallen die we willen gebruiken met pow():

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

Vervolgens geven we pow() door als onze functie in map() en geven we de twee lijsten door als onze iterables:

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

print(numbers_powers)

map() zal de pow() functie toepassen op hetzelfde item in elke lijst om de macht te geven. Daarom zullen onze resultaten 2**1, 4**2, 6**3, enzovoort tonen:

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

Als we map() een iterable zouden geven die langer was dan de andere, zou map() stoppen met berekenen zodra het het einde van de kortste iterable bereikt. In het volgende programma breiden we base_numbers uit met drie extra getallen:

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)

Als gevolg hiervan zal er niets veranderen binnen de berekening van dit programma en dus zal het nog steeds hetzelfde resultaat opleveren:

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

We hebben de map()-functie gebruikt met een ingebouwde Python-functie en hebben gezien dat het meerdere iterables kan verwerken. We hebben ook besproken dat map() zal doorgaan met het verwerken van meerdere iterables totdat het het einde van de iterable met de minste items heeft bereikt.

Conclusie

In deze tutorial hebben we verschillende methoden verkend om de map()-functie in Python te gebruiken. Je hebt nu de mogelijkheid om map() te gebruiken met aangepaste functies, lambda-expressies en andere ingebouwde functies. Bovendien kan map() worden toegepast op functies die meerdere iterables vereisen, wat de veelzijdigheid in gegevensverwerkingstaken vergroot.

Voor demonstratiedoeleinden hebben we de resultaten van map() direct omgezet in een lijst. In praktische toepassingen kan het teruggegeven map-object verder worden gemanipuleerd om aan specifieke behoeften te voldoen.

Om je begrip van Python te verdiepen, gebruik alstublieft de volgende bronnen:

• Tutorial over de map()-functie in Python voor meer gedetailleerde voorbeelden en gebruiksgevallen.
• Begrijpen van woordenboeken in Python om uw kennis van Python-gegevensstructuren te verbeteren.
• Python tekenreeksfuncties om verschillende tekenreeksmanipulatietechnieken te verkennen.

Deze bronnen zullen u een uitgebreid inzicht geven in de mogelijkheden van Python en hoe u deze effectief kunt gebruiken in uw projecten.

Als u meer Python wilt leren, bekijk dan onze serie Hoe te coderen in Python en onze Python-onderwerppagina. Om meer te weten te komen over het werken met gegevenssets in functioneel programmeren, bekijk ons artikel over de filter() functie.

Veelgestelde vragen

Wat doet map() in Python?

De map() functie in Python neemt een functie en een of meer iterables en retourneert een iterator die de gegeven functie toepast op elk element van de verstrekte iterables. Met andere woorden, het “mapt” de functie over elk item in de iterable. Bijvoorbeeld:

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

Hier zal squares een iterator van 1, 4, 9, 16.

Hoe maak je een map in Python?

Je maakt een mapobject aan door de ingebouwde map() functie aan te roepen met een functie en ten minste één iterable als argumenten. Bijvoorbeeld:

def add_one(x):
    return x + 1

my_list = [1, 2, 3]
mapped = map(add_one, my_list)  # Maakt een mapobject aan

Je kunt dan itereren over de gemapte waarden of het omzetten naar een lijst om de resultaten te zien:

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

Is map lui in Python?

Ja, in Python 3 retourneert map() een luie iterator, wat betekent dat het niet alle resultaten in één keer verwerkt of opslaat in het geheugen. In plaats daarvan berekent het elk resultaat op aanvraag terwijl je erover heen iterates. Dit kan geheugen efficiënter zijn, vooral voor grote datasets, maar het betekent ook dat je niet rechtstreeks kunt indexeren of herhaaldelijk kunt itereren over hetzelfde mapobject zonder het opnieuw op te bouwen.

Hoe werkt de map() functie?

De map() functie werkt als volgt:

1. Je geeft een functie en één of meer iterables op.
2. map() haalt een element op uit elke iterable.
3. Het roept de functie aan met deze elementen als argumenten.
4. Het geeft het resultaat van die functieaanroep terug.
5. Dit proces wordt herhaald totdat een van de iterables is uitgeput.

Als er meerdere iterables zijn opgegeven, stopt map() wanneer de kortste iterable is uitgeput. Bijvoorbeeld:

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

Moet ik map gebruiken in Python?

Of je map() moet gebruiken, hangt af van persoonlijke voorkeur en leesbaarheid:

Voordelen:

• Het kan in sommige gevallen beknopter zijn.
• Het kan iets sneller zijn dan lijstcomprehensies in bepaalde scenario’s (hoewel vaak niet significant).

Nadelen:

• Code die gebruikmaakt van lijstcomprehensies of generator expressies wordt vaak beschouwd als meer “Pythonic” en gemakkelijker leesbaar.
• Nieuwere Python-programmeurs vinden lijstcomprehensies misschien intuïtiever.

In het kort, gebruik map() als het je code duidelijker en directer maakt. Anders zijn lijstcomprehensies of generatorexpressies een zeer gebruikelijk alternatief.

Hoe converteer je map naar een string in Python?

Een map-object is een iterator, geen string. Als je de resultaten van een map()-aanroep naar een string wilt converteren, moet je er eerst over itereren. Veelvoorkomende benaderingen omvatten:

• Omzetten naar een lijst en vervolgens naar een stringrepresentatie:

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

• De resultaten samenvoegen als het stringelementen zijn:

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

De beste methode hangt af van of je een menselijke leesbare lijstrepresentatie wilt (str(list(...))) of een concatenatie van de resultaten (''.join(...)).

Wat doet map count()?

map objecten in Python hebben geen ingebouwde count() methode. De count() methode is beschikbaar op lijsten, strings en bepaalde andere collecties. Als je het aantal voorvallen van een waarde die door een map object wordt geproduceerd wilt tellen, moet je deze eerst omzetten naar een lijst (wat de iterator verbruikt):

mapped = map(lambda x: x*2, [1, 2, 3, 2])
mapped_list = list(mapped)
count_of_4 = mapped_list.count(4)  # 2, omdat 2*2=4 twee keer voorkomt

Als je een telling nodig hebt zonder om te zetten naar een lijst, kun je handmatig itereren:

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

Wat doen map en filter in Python?

• map(functie, iterable): Past de functie toe op elk element van de iterable en retourneert een iterator van de resultaten.

• filter(functie, iterable): Retourneert een iterator van elementen uit de iterable waarvoor functie(element) True is. Als de functie None is, retourneert het elementen die op zichzelf waarachtig zijn.

Bijvoorbeeld:

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 transformeert elk element, terwijl filter bepaalde elementen selecteert op basis van een voorwaarde.