Die Python map-Methode: Über Sammlungen iterieren

    Avatarbild von Perica Glavas
    Perica Glavas

    veröffentlicht am: 28.08.2020
    zuletzt aktualisiert am: 02.02.2023

    Die Python map-Methode im Detail

    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.

    Elemente einer Python Liste mit Hilfe einer for-Schleife multiplizieren.

    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:

    Elemente einer Python Liste mit Hilfe der map-Methode multiplizieren.

    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))
    Das zurückgegebene Elemente wird im Anschluss zur einer Liste konvertiert.

    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()))
    Die values-Methode in Kombination.

    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.

    Nutzung der map-Methode in Kombination mit Lambdas

    Ü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.

    Mehrere Sammlungen miteinander multiplizieren.

    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))
    Multiplikation mit Hilfe der Lambda-Funktion.

    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.

    Verwendung der map()-Funktion in Kombination mit der pow-Methode.

    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.

    😩 Gelangweilt von den Udemy & YouTube-Tutorials?!

    Lerne spielerisch Python und komme deiner gutbezahlten (und an der 🌴 liegenden) Traumkarriere einen Schritt weiter.

    TP Star TP Star TP Star TP Star TP Star

    "Für Leute die gerne Python oder Java lernen wollen ist Codegree klasse. Ist nicht wie bei anderen Konkurrenten auf Videokursen aufgebaut..."

    - Lennart Sparbier

    100% kostenlos registrieren · keine Kreditkarte notwendig

    👋 Wir warten bereits auf dich!

    Lerne das, was du wirklich brauchst.

    Im Gegensatz zu der Abendschule oder der alteingesessenen Uni lernst du bei codegree die Sprachen & Pakete, die wirklich im Jobmarkt gesucht werden.

    Logo von Python
    Logo von PyTorch
    Logo von Pandas
    Logo von Matplotlib
    Logo von Java
    Logo von NumPy
    Mehr erfahren

    100% kostenlos registrieren · keine Zahlungsdaten notwendig