Die Python map-Methode: Über Sammlungen iterieren

Sammlungen sind eine Art Container, in dem wir Daten auf eine gewisse Weise unabhängig von ihrem Typ speichern können. Die integrierten Sammlungen in Python heißen List, Set, Tuple und Dictionary.

Eine Python Sammlung ist iterierbar. Iterierbar bedeutet, dass die Sammlung immer ein Element zurückgibt und wir mittels einer for-Schleife alle Elemente ausgeben können. Dabei können wir nicht nur über Sammlungen, sondern auch über Strings iterieren.

Wie erwähnt gibt es mehrere integrierte Möglichkeiten für iterierbare Sammlungen in Python Die map()-Funktion ist eine dieser integrierten Möglichkeiten, die häufig zum Iterieren verwendet wird. In diesem Artikel besprechen wir deshalb die map()-Funktion und ihre Nutzung in Python.

Was ist die Python map-Methode?

In einfachen Worten ausgedrückt ist die map() eine integrierte Möglichkeit, die eine Funktion bereitstellt, um über eine Sammlung zu iterieren. Versuchen wir dafür zunächst an einem einfachen Beispiel die Funktionsweise zu verstehen.

Stellen wir uns zunächst einmal vor, dass wir eine neue Liste von Elementen aus einer bereits vorhandenen Liste erstellen wollen. Dabei soll jeder Eintrag verdoppelt werden.

Zunächst erstellen wir eine Funktion, die eine angegebene Zahl verdoppelt und wieder zurückgibt. Danach nutzen wir eine for-Schleife, um über die Liste zu iterieren und die Elemente der Funktion zu übergeben.

def multipliziereZahlen(x):
	return x * 2
list1 = [1, 2, 3, 4, 5, 6]
list2 = []
for element in list1:
	 list2.append(multipliziereZahlen (element))

Die Funktion „multipliziereZahlen“ wird bei jedem Schleifendurchlauf aufgerufen. Das zurückgegebene Element wird dann an die zweite Liste angefügt.

Es ist zwar ein möglicher Lösungsweg, kann aber deutlich verkürzt werden, wenn wir die map()-Funktion verwenden. Dabei vermeiden wir die for-Schleife. Die Funktion benötigt zwei Argumente: zum einen das zu iterierende Objekt und zum anderen der einzufügende Wert.

def multipliziereZahlen(x):
	return x * 2
	
list1 = [1, 2, 3, 4, 5, 6]
list2 = map(multipliziereZahlen, list1)

Schauen wir uns einmal das Ergebnis des Quellcodes an:

Wie bereits erwähnt, müssen wir das entstandene Objekt noch in eine Liste konvertieren. Dafür nutzen wir die list()-Funktion.

def multipliziereZahlen(x):
	return x * 2
	
list1 = [1, 2, 3, 4, 5, 6]
list2 = list(map(multipliziereZahlen, list1))

Wie wir sehen können, iteriert die map()-Funktion über unsere Liste. Dabei werden für jeden Wert die Ergebnisse der multipliziereZahlen()-Funktion gespeichert. Das zurückgegebene Objekt der map()-Funktion muss allerdings noch konvertiert werden.

Die map()-Funktion lässt sich gleichermaßen mit anderen Sammlungen wie dem Tuple und Set nutzen. Lediglich bei dem Dictionary ist das Verhalten anders und benötigt noch zusätzliche Funktionen.

def multipliziereZahlen(x):
	return x * 2
	
dict1 = { 'a' : 1, 'b' : 2, 'c' : 3, 'd' : 4, 'e' : 5, 'f' : 6 }
list2 = list(map(multipliziereZahlen, dict1))

Normalerweise wird die map()-Funktion über die Schlüssel des Dictionary iterieren. Wenn wir die Werte verwenden möchten, müssen wir die values()-Funktion verwenden.

def multipliziereZahlen(x):
	return x * 2
	
dict1 = { 'a' : 1, 'b' : 2, 'c' : 3, 'd' : 4, 'e' : 5, 'f' : 6 }
list2 = list(map(multipliziereZahlen, dict1.values()))

Verwendung der Python map-Methode in Verbindung mit Lambdas

Die Lambdas sind eine weitere Möglichkeit zur Verwendung von Funktionen. Wir können diese auch in Verbindung mit der map()-Funktion verwenden. Dies reduziert nochmal den Quellcode.

list1 = [1, 2, 3, 4, 5, 6]
list2 = list(map(lambda x: x * 2, list1))

Der obige Code erfüllt die gleiche Funktion wie folgender:

def multipliziereZahlen (x):
	return x * 2
	
list1 = [1, 2, 3, 4, 5, 6]
list2 = map(multipliziereZahlen, list1)

Die Lambda-Funktion sorgt dafür, dass wir für einfache Funktionalitäten keine neue Funktion erstellen müssen.

Über mehrere Sammlungen iterieren

Wir können mit der map()-Funktion auch über mehrere Sammlungen iterieren.

def multipliziereZahlen (x,y):
	return x * y
	
list1 = [1, 2, 3, 4, 5, 6]
list2 = [11, 12, 13, 14, 15, 16]
list3 = list(map(multipliziereZahlen, list1, list2))

Im obigen Code verfügt die multipliziereZahlen()-Funktion jetzt über zwei Argumente. In der Funktion wird nun über beide Listen gleichzeitig iteriert. Das jeweilige Element stellt dann jeweils ein Argument der multipliziereZahlen()-Funktion dar. In der dritten Liste entsteht jeweils eine Multiplikation aus den jeweiligen Elementen der beiden Listen.

Dieselbe Funktion, nur kürzer, können wir natürlich wieder über eine Lambda-Funktion erreichen.

list1 = [1, 2, 3, 4, 5, 6]
list2 = [11, 12, 13, 14, 15, 16]
list3 = list(map(lambda x, y: x * y, list1, list2))

Die Python map-Methode unter Verwendung anderer integrierter Funktionen

Bis jetzt haben wir die map()-Funktion mit selbst erstellten Funktionen verwendet. Wir können aber auch andere integrierte Funktionen nutzen.

Als Beispiel verwenden wir die pow()-Funktion mit unserer Liste.

list1 = [1, 2, 3, 4, 5, 6]
base = [2, 2, 2, 2, 2, 2]
list2 = list(map(pow, base, list1))

Die „base“ ist eine weitere Liste. In jeder Iteration wird jetzt die pow()-Funktion aufgerufen, die die Elemente der ersten Liste als Exponent zur „base“ berechnet.

Zusammenfassung

Die map()-Funktion ist eine sehr nützliche Funktion, mit der wir nicht nur Quellcode, sondern auch Aufwand und Zeit reduzieren können. Wir sind in der Lage sowohl über eine als auch über mehrere Sammlungen zu iterieren. Wir haben uns mehrheitlich mit der Liste beschäftigt, dennoch können wir die map()-Funktion aber auch mit allen anderen Sammlungen und sogar mit Strings verwenden.

Des Weiteren können wir die Lambda-Funktion nutzen, um unseren Quellcode noch weiter zu reduzieren.