Python bietet viele integrierte Funktionen, die vordefiniert sind und vom Endbenutzer durch einfaches Aufrufen verwendet werden können. Diese Funktionen erleichtern nicht nur die Arbeit der Programmierer, sondern schaffen auch eine Standard-Codierungsumgebung. In diesem Artikel werden wir drei dieser beeindruckenden Funktionen kennenlernen, nämlich map(), filter() und reduce() in Python.
Was sind die Funktionen map(), filter() und reduce() in Python?
Wie bereits erwähnt, sind map(), filter() und reduce() eingebaute (built-in) Funktionen von Python. Diese Funktionen ermöglichen den Aspekt der funktionalen Programmierung von Python. Bei der funktionalen Programmierung sind die übergebenen Argumente die einzigen Faktoren, die über die Ausgabe entscheiden. Diese Funktionen können jede andere Funktion als Parameter annehmen und können auch anderen Funktionen als Parameter übergeben werden.
Die Funktion map()
Die map()-Funktion ist ein Typ höherer Ordnung. Wie bereits erwähnt, nimmt diese Funktion eine andere Funktion als Parameter zusammen mit einer Folge von Iterablen und gibt eine Ausgabe zurück, nachdem die Funktion auf jede Iterable in der Folge angewendet wurde.
Ihre Syntax lautet wie folgt:
map(function, iterables)
Hier definiert die Funktion einen Ausdruck, der wiederum auf die Iterablen angewendet wird. Die map-Funktion kann sowohl benutzerdefinierte Funktionen als auch Lambda-Funktionen als Parameter annehmen.
Verwendung von benutzerdefinierten und Lambda-Funktionen
Benutzerdefinierte Funktionen innerhalb von map()
Die map()-Funktion kann benutzerdefinierte Funktionen als Parameter annehmen. Die Parameter dieser Funktionen werden ausschließlich vom Benutzer oder vom Programmierer festgelegt.
Beispiel:
def newfunc(a):
return a*a
x = map(newfunc, (1,2,3,4)) #x is the map object
print(x)
print(set(x))
Ausgabe:
<map object at 0x00000284B9AEADD8>
{16, 1, 4, 9}
Wie man sehen kann, ist x ein Map-Objekt. Die map-Funktion nimmt die newfunc() als Parameter und wendet damit a*a auf alle Iterablen an. Als Ergebnis werden die Werte aller Iterablen mit sich selbst multipliziert und zurückgegeben.
HINWEIS: Die Ausgabe erfolgt nicht in der Reihenfolge der Werte der Iterablen, da die Funktion set() verwendet wurde. Man kann auch die Funktionen list() oder tuple() verwenden:
Beispiel:
def newfunc(a):
return a*a
x = map(newfunc, (1,2,3,4)) #x is the map object
print(x)
print(list(x))
Ausgabe:
<map object at 0x00000284B9AEA940>
[1, 4, 9, 16]
Man kann auch mehr als eine Liste als Parameter übergeben.
Beispiel:
def func(a, b):
return a + b
a = map(func, [2, 4, 5], [1,2,3])
print(a)
print(tuple(a))
Ausgabe:
<map object at 0x00000284B9BA1E80>
(3, 6, 8)
Nun schauen wir uns an, wie man die Lambda-Funktionen innerhalb der Funktion map() verwenden kann.
Lambda-Funktionen innerhalb von map()
Lambda-Funktionen sind Funktionen, die einen beliebigen Namen haben. Diese Funktionen werden oft als Parameter an andere Funktionen übergeben. Versuchen wir nun, Lambda-Funktionen in die map()-Funktion einzubinden.
Beispiel:
tup = (5, 7, 22, 97, 54, 62, 77, 23, 73, 61)
newtuple = tuple(map(lambda x: x+3 , tup))
print(newtuple)
Ausgabe:
(8, 10, 25, 100, 57, 65, 80, 26, 76, 64)
Die obige Ausgabe ist das Ergebnis der Anwendung des Lambda-Ausdrucks (x+3) auf jedes Element des Tupels.
Die Funktion filter()
Die filter()-Funktion wird verwendet, um eine Ausgabeliste zu erstellen, die aus Werten besteht, für die die Funktion den Wert true zurückgibt.
Die Syntax der Funktion lautet wie folgt:
filter(function, iterables)
Verwendung von benutzerdefinierten und Lambda-Funktionen
Benutzerdefinierte Funktion innerhalb von filter()
Genau wie map() kann diese Funktion auch benutzerdefinierte Funktionen und Lambda-Funktionen als Parameter verwenden.
def func(x):
if x>=3:
return x
y = filter(func, (1,2,3,4))
print(y)
print(list(y))
Ausgabe:
<filter object at 0x00000284B9BBCC50>
[3, 4]
Wie man sehen kann, ist y das Filterobjekt und die Liste ist eine Liste von Werten, die für die Bedingung (x>=3) zutreffen.
Verwendung von lambda innerhalb von filter()
Die Lambda-Funktion, die als Parameter verwendet wird, definiert die Bedingung, die geprüft werden soll.
Beispiel:
y = filter(lambda x: (x>=3), (1,2,3,4))
print(list(y))
Ausgabe:
[3, 4]
Der obige Code erzeugt die gleiche Ausgabe wie die vorherige Funktion.
Die Funktion reduce()
Die Funktion reduce() wendet, wie der Name schon sagt, eine bestimmte Funktion auf die Iterablen an und gibt einen einzigen Wert zurück.
Die Syntax dieser Funktion lautet wie folgt:
reduce(function, iterables)
Die Funktion hier definiert, welcher Ausdruck auf die Iterables angewendet werden muss. Diese Funktion muss aus dem Modul functools importiert werden.
Beispiel:
from functools import reduce
reduce(lambda a,b: a+b,[23,21,45,98])
Ausgabe:
187
Im obigen Beispiel addiert die reduce-Funktion nacheinander jede in der Liste vorhandene Iterable und gibt eine einzige Ausgabe zurück.
Die Funktionen map(), filter() und reduce() können in Python zusammen verwendet werden.
Verwendung der Funktionen map(), filter() und reduce() zusammen
In diesem Fall werden zuerst die internen Funktionen gelöst, und dann arbeiten die äußeren Funktionen mit der Ausgabe der internen Funktionen.
Verwendung von filter() innerhalb von map()
Im folgenden Code wird zunächst geprüft, ob die Bedingung (x>=3) für die Iterablen erfüllt ist. Dann wird die Ausgabe mit der map()-Funktion abgebildet.
Beispiel:
c = map(lambda x:x+x,filter(lambda x: (x>=3), (1,2,3,4)))
print(list(c))
Ausgabe:
[6, 8]
Aus dem gegebenen Tupel ganzer Zahlenwerden alle mit größer oder gleich 3 herausgefiltert, dadurch erhält man [3,4] als Ergebnis. Wenn man dies dann mit der Bedingung (x+x) abbildet, ergibt das [6,8], was die Ausgabe ist.
Verwendung von map() innerhalb von filter()
Wenn man die map()-Funktion innerhalb der filter()-Funktion verwendet, werden die Iterablen zunächst von der map-Funktion bearbeitet und dann die Bedingung von filter() auf sie angewendet.
Beispiel:
c = filter(lambda x: (x>=3),map(lambda x:x+x, (1,2,3,4)))
print(list(c))
Ausgabe:
[4, 6, 8]
Verwendung von map() und filter() innerhalb von reduce()
Die Ausgabe der internen Funktionen wird entsprechend der Bedingung reduziert, die der Funktion reduce() übergeben wird.
Beispiel:
d = reduce(lambda x,y: x+y, map(lambda x:x+x, filter(lambda x: (x>=3), (1,2,3,4))))
print(d)
Ausgabe:
14
Die Ausgabe ist ein Ergebnis von [6,8], das das Ergebnis der internen Funktionen map() und filter() ist.