Einsatz der `map()`-Funktion in Python
In diesem Leitfaden werden wir uns ansehen, wie man die Python-Funktion `map()` verwendet, um eine bestimmte Funktion auf jedes Element einer iterierbaren Struktur anzuwenden.
Python unterstützt das Konzept der funktionalen Programmierung, das es erlaubt, Aufgaben durch Funktionen zu definieren. Python-Funktionen können wie Objekte behandelt werden, was bedeutet, dass sie als Parameter an andere Funktionen übergeben oder von diesen zurückgegeben werden können.
Die `map()`-Funktion nimmt eine Funktion als Argument und wendet diese auf jedes Element innerhalb einer Sequenz an.
Am Ende dieses Tutorials werden Sie in der Lage sein, die `map()`-Funktion anstelle von herkömmlichen Schleifen oder List-Comprehensions zu verwenden. Wir werden diverse Beispiele programmieren, um die verschiedenen Anwendungsmöglichkeiten der `map()`-Funktion zu veranschaulichen.
Anwenden einer Funktion auf Elemente einer Python-Liste
Beginnen wir mit einem einfachen Beispiel. Hier haben wir eine Liste von Zahlen:
nums = [2, 4, 3, 7]
Betrachten wir nun die Funktion `self_pow()`. Diese Funktion nimmt eine Zahl als Eingabe und gibt das Ergebnis der Zahl hoch sich selbst zurück (n**n). In Python ist `**` der Potenzierungsoperator.
def self_pow(n):
return n**n
Unsere Aufgabe ist es, eine neue Liste `nums_pow` zu erstellen, indem wir die Funktion `self_pow()` auf jedes Element der Liste `nums` anwenden.
Verwendung einer `for`-Schleife
Dies kann mit einer `for`-Schleife in Python erreicht werden:
- Gehe durch jede Zahl in der `nums`-Liste.
- Rufe die Funktion `self_pow()` mit der aktuellen Zahl auf.
- Füge das Ergebnis der neuen Liste `nums_pow` hinzu.
nums_pow = []
for num in nums:
nums_pow.append(self_pow(num))
print(nums_pow)
Die Ausgabe zeigt das Ergebnis der Potenzierung jeder Zahl mit sich selbst. Die Elemente der `nums_pow`-Liste sind somit 22, 44, 33 und 77.
Ausgabe [4, 256, 27, 823543]
Verwendung der List-Comprehension
Eine kompaktere Variante ist die Nutzung der List-Comprehension. Wir können den Ausgabeelement und die zu iterierende Liste identifizieren.
Das allgemeine Muster für eine List-Comprehension ist:
neue_liste = [<Ausdruck> for element in iterierbar]
Um die `nums_pow`-Liste mit einer List-Comprehension zu erstellen, schreiben wir:
nums_pow = [self_pow(num) for num in nums] print(nums_pow)
Die Ausgabe ist wie erwartet identisch mit der `for`-Schleifen-Version.
Ausgabe [4, 256, 27, 823543]
Anstatt Schleifen oder List-Comprehensions zu verwenden, können wir die `map()`-Funktion nutzen. Diese erlaubt es, eine Funktion auf alle Elemente eines iterierbaren Objekts anzuwenden. Schauen wir uns zunächst die Syntax dieser Funktion an.
Die Syntax der `map()`-Funktion
Die allgemeine Syntax für die `map()`-Funktion lautet:
map(funktion, iterierbar_1, [iterierbar_2,...,iterierbar_n])
Die `map()`-Funktion benötigt mindestens zwei Argumente: eine Funktion und ein iterierbares Objekt.
In der obigen Syntax:
- `funktion` ist eine Python-Funktion oder eine beliebige andere aufrufbare Python-Funktion. Dies schließt benutzerdefinierte Funktionen, integrierte Funktionen, Klassen, Instanz- und Klassenmethoden ein.
- `iterierbar` ist ein gültiges Python-Objekt, wie z.B. eine Liste, ein Tupel oder eine Zeichenkette.
- Die Funktion `map()` wendet die übergebene Funktion auf jedes Element des `iterierbar` Objekts an.
Was gibt die `map()`-Funktion zurück?
Sie gibt ein „map object“ zurück, welches man dann mit `list(map(funktion, iterierbar))` in eine Liste umwandeln kann. Je nach Bedarf ist auch die Umwandlung in ein Tupel möglich.
Nachdem wir die Syntax der `map()`-Funktion kennen, wollen wir uns einige Beispiele ansehen.
Um dieses Tutorial zu verfolgen, benötigen Sie Python 3.x. Sie können die Codebeispiele auch im Online-Python-Editor ausprobieren.
Verwendung der `map()`-Funktion mit benutzerdefinierten Funktionen
#1. Wir wenden nun die Funktion `self_pow()` auf jede Zahl in der `nums`-Liste an. In der Syntax der `map()`-Funktion übergeben wir die Funktion `self_pow` und die Liste `nums` als Argumente.
Hinweis: Geben Sie nur den Namen der Funktion an, nicht den Funktionsaufruf. Verwenden Sie `self_pow` anstelle von `self_pow()`.
Die Funktion `map()` gibt ein map-Objekt zurück.
print(map(self_pow,nums)) <map object at 0x7f7d315c14d0>
Dieses Objekt können wir mit der `list()`-Funktion in eine Liste konvertieren:
nums_pow = list(map(self_pow,nums)) print(nums_pow)
Hier ist die Ausgabe, wobei jede Zahl in `nums` auf sich selbst potenziert wurde:
Ausgabe [4, 256, 27, 823543]
#2. Betrachten Sie die Funktion `inch_to_cm()`, die Zoll in Zentimeter umrechnet (1 Zoll = 2.54 cm):
def inch_to_cm(inch):
return inch*2.54
Um die Werte einer Liste von Zollwerten in Zentimeter umzuwandeln, können wir die `map()`-Funktion nutzen:
inches = [5.54,3.4,1,25,8.2] cms = list(map(inch_to_cm,inches)) print(cms)
Die Liste `cms` enthält nun die Zollwerte in Zentimetern:
Ausgabe [14.0716, 8.636, 2.54, 63.5, 20.828]
Verwendung der `map()`-Funktion mit integrierten Funktionen
In diesem Abschnitt werden wir die Nutzung von `map()` mit integrierten Funktionen in Python erkunden.
#1. Die Liste `strings` enthält Programmiersprachen. Wir möchten eine neue Liste `strings_upper` erstellen, welche die Zeichenketten in Großbuchstaben enthält.
strings = ['JavaScript','Rust','Python','Go']
Die eingebaute String-Methode `.upper()` gibt eine in Großbuchstaben formatierte Kopie der Zeichenkette zurück:
strings_upper = list(map(str.upper,strings)) print(strings_upper)
Die Liste `strings_upper` enthält nun alle Zeichenketten der Liste `strings` in Großbuchstaben:
Ausgabe ['JAVASCRIPT', 'RUST', 'PYTHON', 'GO']
#2. Die integrierte `len()`-Funktion gibt die Länge einer Sequenz zurück. Um die Länge jeder Zeichenkette in der Liste zu ermitteln, können wir die `map()`-Funktion wie folgt anwenden:
strings_len = list(map(len,strings)) print(strings_len)
Ausgabe [10, 4, 6, 2]
#3. Die `map()`-Funktion kann auch mit anderen Datenstrukturen, wie Tupeln, verwendet werden.
Im folgenden Beispiel haben wir ein Tupel, das Informationen über die Anzahl der Schlafzimmer, die Fläche und die Stadt eines Hauses enthält.
In Python gibt die `type()`-Funktion den Datentyp eines Objekts zurück. Um den Datentyp jedes Elements des Tupels zu ermitteln, können wir die Funktion `map()` verwenden:
house = (2,758.5,'Bangalore') house_elt_type = tuple(map(type,house)) print(house_elt_type)
Hier haben wir das map-Objekt in ein Tupel umgewandelt. Man kann es aber auch in eine Liste oder ein anderes Datenstruktur konvertieren. Die Ausgabe zeigt die Datentypen der Elemente 2, 758.5 und „Bangalore“ als `int`, `float` und `str`.
Ausgabe (<class 'int'>, <class 'float'>, <class 'str'>)
#4. Sie können auch Module importieren und deren Funktionen nutzen.
Um die Quadratwurzel jeder Zahl in einer Liste zu berechnen, können wir die `sqrt`-Funktion des `math`-Moduls verwenden:
import math nums = [30,90,34,45,97] nums_sqrt = list(map(math.sqrt,nums)) print(nums_sqrt)
Ausgabe [5.477225575051661, 9.486832980505138, 5.830951894845301, 6.708203932499369, 9.848857801796104]
Die obige Ausgabe kann schwer zu analysieren sein. Wir können jeden Quadratwurzelwert auf zwei Dezimalstellen runden.
Runden einer Fließkommazahl in Python
Definieren wir die Funktion `round_2()`, welche einen Fließkommawert nimmt und auf zwei Dezimalstellen rundet:
def round_2(num):
return round(num,2)
Nun können wir die `map()`-Funktion mit der `round_2()` Funktion und der `nums_sqrt`-Liste verwenden:
nums_sqrt_round = list(map(round_2,nums_sqrt)) print(nums_sqrt_round)
Ausgabe [5.48, 9.49, 5.83, 6.71, 9.85]
Es ist auch möglich, `map()`-Funktionen zu verschachteln. Die innere Funktion berechnet die Quadratwurzeln und die äußere rundet das Ergebnis auf zwei Dezimalstellen:
nums_sqrt_round = list(map(round_2,list(map(math.sqrt,nums)))) print(nums_sqrt_round)
Ausgabe [5.48, 9.49, 5.83, 6.71, 9.85]
Die Ausgaben sind bei beiden Ansätzen identisch. Sie sollten jedoch darauf achten, den Code lesbar und wartbar zu halten, wenn Sie Funktionen verschachteln.
Verwendung der `map()`-Funktion mit Lambda-Funktionen
In den vorherigen Abschnitten haben wir gelernt, wie man die `map()`-Funktion mit integrierten und benutzerdefinierten Funktionen einsetzt. Nun werden wir uns anschauen, wie man `map()` mit Lambda-Funktionen verwendet.
Wenn Sie eine Funktion haben, die nur eine Zeile Code umfasst, und diese nur einmal verwenden wollen, können Sie diese Funktion als Lambda-Funktion definieren.
Hinweis: `lambda args: ausdruck` ist die allgemeine Syntax für eine Python Lambda-Funktion.
#1. Angenommen wir haben eine Liste von Zeichenketten. Wir möchten nun eine neue Liste `strings_rev` erstellen, welche die umgekehrte Version jeder Zeichenkette enthält.
strings = ['JavaScript','Rust','Python','Go']
Wir können eine Python-Zeichenkette mit dem String-Slicing umkehren.
Hinweis: `str[start:stop:step]` ist der allgemeine Ausdruck für das Slicing. Wenn die Start- und Stop-Werte nicht definiert sind, beginnt das Slice am Anfang der Zeichenkette und geht bis zum Ende. Negative `step`-Werte führen zu einem Slice, welches am Ende der Zeichenkette beginnt. Also gibt `str[::-1]` eine umgekehrte Kopie des ursprünglichen Strings zurück.
Sie können die Lambda-Funktion `lambda x: x[::-1]` innerhalb der `map()`-Funktion verwenden:
strings_rev = list(map(lambda x:x[::-1],strings)) print(strings_rev)
Wie in den anderen Beispielen wandeln wir das map-Objekt in eine Liste um. Die Ausgabe zeigt die umgekehrte Version jeder Zeichenkette in der Liste `strings`.
Ausgabe ['tpircSavaJ', 'tsuR', 'nohtyP', 'oG']
#2. Im vorigen Abschnitt haben wir die Quadratwurzel jeder Zahl berechnet und dann die Werte gerundet. Dies wurde mithilfe der `round_2()`-Funktion erreicht. Lassen sie uns die Funktion `round_2()` als Lambda-Funktion umschreiben:
nums_sqrt_round_l =list(map(lambda num:round(num,2),nums_sqrt)) print(nums_sqrt_round_l)
Wie wir sehen, ist die Ausgabe identisch mit der, die wir durch Verwendung der `round_2()` Funktion erhalten haben.
Ausgabe [5.48, 9.49, 5.83, 6.71, 9.85]
Verwendung der `map()`-Funktion mit mehreren Iterablen
In den bisherigen Beispielen haben wir Funktionen auf alle Elemente einer einzelnen iterierbaren Struktur angewendet. Es gibt jedoch auch Funktionen, die zwei oder mehrere Argumente benötigen. In diesem Fall werden die Argumente oft in Listen oder ähnlichen Datenstrukturen gespeichert.
Die Python `map()`-Funktion kann auch mit mehreren Listen verwendet werden.
#1. Betrachten wir die Funktion `area()`, welche Länge und Breite als Eingaben nimmt und den Flächeninhalt (Länge*Breite) zurückgibt:
def area(length,breadth):
return length*breadth
Die Länge und Breite verschiedener Rechtecke sind in separaten Listen gespeichert:
lengths = [4,8,10,18] breadths = [9,4,6,11]
Die `map()`-Funktion kann nun genutzt werden, um die `area()`-Funktion auf die beiden Listen anzuwenden:
areas = list(map(area,lengths,breadths)) print(areas)
Da die Funktion `area()` zwei Argumente erwartet, werden die entsprechenden Werte aus den Listen `lengths` und `breadths` verwendet.
Ausgabe [36, 32, 60, 198]
#2. Das Python-Modul `math` enthält die Funktion `log()`, mit der man den Logarithmus einer Zahl zu einer beliebigen Basis berechnen kann.
Hinweis: `log(x, base)` gibt den Logarithmus von `x` zur Basis `base` zurück. Wenn keine Basis definiert ist, wird der natürliche Logarithmus verwendet.
In diesem Beispiel haben wir:
- Die Liste `x` enthält die Werte, deren Logarithmus berechnet werden soll.
- Die Liste `base` enthält die dazugehörigen Basen für die Logarithmusberechnung.
x = [2,6,12,10] base = [2,3,2,5]
Wir können die `map()`-Funktion mit `math.log`, der Liste `x` und der Liste `base` nutzen:
log_x = list(map(math.log,x,base)) print(log_x)
Hier ist die Ausgabe:
Ausgabe [1.0, 1.6309297535714573, 3.5849625007211565, 1.4306765580733933]
Fazit
Zusammenfassend haben wir in diesem Tutorial folgendes gelernt:
- Die `map()`-Funktion akzeptiert mindestens zwei Argumente: Eine Funktion und ein/mehrere iterierbare Strukturen mit der Syntax `map(funktion, iterierbar(e))`.
- Die Funktion kann ein beliebiger gültiger Python-Aufruf sein.
- Wenn die Funktion `k` Argumente benötigt, wird die Funktion `map()` mit der Funktion und `k` iterierbaren Objekten verwendet.
Als nächstes werden Sie lernen, wie man mit Mengen in Python arbeitet.