Verwenden der Python-Map-Funktion

Einführung

Wir können die integrierte Python-Funktion map() verwenden, um für jedes Element in einer Iterablen (wie einer Liste oder einem Wörterbuch) eine Funktion anzuwenden und einen neuen Iterator zum Abrufen der Ergebnisse zurückgeben. map() gibt ein map-Objekt (einen Iterator) zurück, das wir in anderen Teilen unseres Programms nutzen können. Außerdem können wir das map-Objekt an die Funktion list() oder einen anderen Sequenztyp übergeben, um eine Iterable zu erstellen.

Die Syntax für die Funktion map() lautet folgendermaßen:

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

Anstatt eine for-Schleife zu verwenden, bietet die Funktion map() die Möglichkeit, für jedes Element in einer Iterablen eine Funktion anzugeben. Daher kann dies oft effektiver sein, da die Funktion nur auf ein Element auf einmal angewendet wird, anstatt Kopien der Elemente in einer anderen Iterablen zu erstellen. Dies ist besonders nützlich, wenn Sie Programme verwenden, die große Datenmengen verarbeiten. map() kann zudem mehrere Iterablen als Argumente an die Funktion übergeben, indem ein Element aus jeder Iterablen an die Funktion gesendet wird.

In diesem Tutorial werden wir uns drei verschiedene Möglichkeiten der Verwendung von map() ansehen: mit einer lambda-Funktion, mit einer benutzerdefinierten Funktion und schließlich mit einer integrierten Funktion unter Verwendung mehrerer Iterablenargumente.

Verwenden einer Lambda-Funktion

Das erste Argument für map() ist eine Funktion, die wir auf die einzelnen Elemente anwenden. Python ruft die Funktion für jedes Element in der Iterablen, das wir an map() übergeben, einmal auf und gibt das bearbeitete Element innerhalb eines map-Objekts zurück. Für das erste Funktionsargument können wir entweder eine benutzerdefinierte Funktion übergeben oder lambda-Funktionen nutzen (insbesondere wenn der Ausdruck nicht sehr komplex ist).

Die Syntax von map() mit einer lambda-Funktion lautet wie folgt:

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

Mit einer Liste wie der folgenden können wir eine lambda-Funktion mit einem Ausdruck implementieren, den wir auf jedes Element in unserer Liste anwenden möchten:

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

Um einen Ausdruck auf jede unserer Zahlen anzuwenden, können wir map() und lambda nutzen:

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

Hier deklarieren wir in unserer Liste ein Element als x. Dann fügen wir unseren Ausdruck hinzu. Wir übergeben unsere Liste mit Zahlen als Iterable für map().

Um die Ergebnisse davon sofort zu erhalten, drucken wir eine Liste des map-Objekts aus:

print(mapped_numbers)

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

Wir haben list() verwendet, damit das map-Objekt als Liste zurückgegeben wird und nicht als schlechter menschenlesbares Objekt wie: <map object at 0x7fc250003a58>. Das map-Objekt ist ein Iterator über unsere Ergebnisse; daher können wir mit for eine Schleife darüber legen oder list() verwenden, um es in eine Liste umzuwandeln. Wir tun dies hier, da es eine gute Möglichkeit zur Prüfung der Ergebnisse darstellt.

Letztlich ist map() am nützlichsten bei der Arbeit mit großen Datensätzen; daher würden wir mit dem map-Objekt wahrscheinlich weiter arbeiten und in der Regel keinen Konstruktor wie list() anwenden.

Für kleinere Datensätze eignet sich die Erfassung in Listen ggf. besser; für die Zwecke dieses Tutorials verwenden wir jedoch einen kleinen Datensatz zum Demonstrieren von map().

Implementieren einer benutzerdefinierten Funktion

Ähnlich wie bei lambda können wir eine Funktion verwenden, die wir zur Anwendung auf eine Iterable definiert haben. Zwar sind lambda-Funktionen nützlicher für die Implementierung, wenn Sie mit einem einzeiligen Ausdruck arbeiten, doch sind benutzerdefinierte Funktionen besser geeignet, wenn der Ausdruck komplexer wird. Wenn wir weitere Daten an die Funktion übergeben müssen, die Sie auf Ihre Iterable anwenden möchten, können benutzerdefinierte Funktionen außerdem besser lesbar sein.

Beispielsweise ist jedes Element in der folgenden Iterable ein Wörterbuch, das verschiedene Details zu den einzelnen Aquariumgeschöpfen enthält:

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

Wir haben beschlossen, dass alle Aquariumgeschöpfe tatsächlich in den gleichen Tank kommen sollen. Wir müssen unsere Datensätze aktualisieren, um widerzuspiegeln, dass alle unsere Geschöpfe in Tank 42 kommen werden. Um map()-Zugriff auf alle Wörterbücher und Schlüsselwertpaare in den Wörterbüchern zu erhalten, erstellen wir eine geschachtelte Funktion:

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)

Wir definieren eine assign_to_tank()-Funktion, die aquarium_creatures und new_tank_number als Parameter verwendet. In assign_to_tank() übergeben wir in der letzten Zeile apply() als Funktion an map(). Die Funktion assign_to_tank gibt den Iterator zurück, der sich aus map() ergibt.

apply() nimmt x als Argument, das einen Eintrag in unserer Liste darstellt (ein einzelnes Wörterbuch).

Als Nächstes definieren wir, dass x der Schlüssel "tank number" von aquarium_creatures sein und die übergebene new_tank_number speichern soll. Wir geben jedes Element nach Anwenden der neuen Tanknummer zurück.

Wir rufen assign_to_tank() mit unserer Liste von Wörterbüchern und der neuen Tanknummer auf, die wir für die einzelnen Geschöpfe ersetzen möchten:

assigned_tanks = assign_to_tank(aquarium_creatures, 42)

Nach Abschluss der Funktion ist unser map-Objekt in der Variable assigned_tanks gespeichert, die wir in eine Liste verwandeln und drucken:

print(list(assigned_tanks))

Wir erhalten die folgende Ausgabe aus diesem Programm:

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

Wir haben die neue Tanknummer unserer Liste von Wörterbüchern zugeordnet. Mithilfe einer von uns definierten Funktion können wir map() integrieren, um die Funktion effizient auf jedes Element der Liste anzuwenden.

Verwenden einer integrierten Funktion mit mehreren Iterablen

Genauso wie bei lambda-Funktionen oder unseren selbst definierten Funktionen können wir integrierte Python-Funktionen mit map() verwenden. Um eine Funktion mit mehreren Iterablen anzuwenden, übergeben wir nach dem ersten einen weiteren Iterablennamen. Verwenden Sie beispielsweise die Funktion pow(), die in zwei Zahlen nimmt, um die Potenz der Basisnummer für den bereitgestellten Exponenten zu finden.

Hier sehen wir unsere Listen mit Integerzahlen, die wir mit pow() verwenden möchten:

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

Als Nächstes übergeben wir pow() als unsere Funktion an map() und stellen die beiden Listen als unsere Iterablen bereit:

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

print(numbers_powers)

map() wendet die Funktion pow() in jeder Liste auf das gleiche Element an, um die Potenz anzugeben. Daher werden unsere Ergebnisse 2**1, 4**2, 6**3 usw. anzeigen:

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

Wenn wir map() eine Iterable zur Verfügung stellen würden, die länger als die andere ist, würde map() die Berechnung stoppen, sobald das Ende der kürzesten Iterable erreicht ist. Im folgenden Programm ergänzen wir base_numbers um drei zusätzliche Zahlen:

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 Folge ändert sich innerhalb der Berechnung dieses Programms nichts und bleibt das Ergebnis somit gleich:

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

Wir haben die Funktion map() mit einer integrierten Python-Funktion verwendet und gesehen, dass sie mehrere Iterablen handhaben kann. Außerdem haben wir überprüft, ob map() weitere Iterablen verarbeitet, bis das Ende der Iterablen mit den wenigsten Elementen erreicht wurde.

Zusammenfassung

In diesem Tutorial haben wir die verschiedenen Möglichkeiten zur Verwendung der Funktion map() in Python kennengelernt. Jetzt können Sie map() mit Ihrer eigenen Funktion, einer lambda-Funktion und anderen integrierten Funktionen verwenden. Zudem können Sie map() mit Funktionen implementieren, die mehrere Iterablen erfordern.

In diesem Tutorial haben wir die Ergebnisse von map() für Demonstrationszwecke sofort in einem Listenformat ausgegeben. In unseren Programmen würden wir normalerweise das zurückgegebene map-Objekt verwenden, um die Daten weiter zu bearbeiten.

Wenn Sie mehr über Python erfahren möchten, lesen Sie unsere Reihe Codieren in Python 3 und unsere Python Themenseite. Wenn Sie mehr über die Arbeit mit Datensätzen in funktionaler Programmierung erfahren möchten, lesen Sie unseren Artikel zur Funktion filter().