Lambda-Funktion, der König von allen in Python

Einführung in die Lambda-Funktion

Die Lambda-Funktion ist auch als anonyme Funktion (kein Name) bekannt, die direkt die Anzahl der Parameter und die auszuführende Bedingung oder Operation mithilfe der durch Doppelpunkte getrennten Parameter akzeptiert und die zurückgibt Endergebnis. Um beim Schreiben von Code auf einer großen Codebasis eine kleine Aufgabe auszuführen oder um eine kleine Aufgabe in einer Funktion auszuführen, werden im normalen Prozess Lambda-Funktionen verwendet.

lambda argument_list:expersion

argument_list ist eine Parameterliste in Python.

a,b
a=1,b=2
*args
**kwargs
a,b=1,*args
空
....

expression ist ein Ausdruck über Parameter, die in argument_list angezeigt werden müssen nur in einer einzigen Zeile stehen.

1
None
a+b
sum(a)
1 if a >10 else 0
[i for i in range(10)]
...

Der Unterschied zwischen gewöhnlichen Funktionen und Lambda-Funktionen

• Kein Name Lambda-Funktionen haben keine Namen, während gewöhnliche Operationen einen passenden Namen haben.
• Lambda-Funktion hat keinen Rückgabewert. Eine normale Funktion, die mit dem Schlüsselwort def erstellt wurde, gibt einen Wert oder einen Sequenzdatentyp zurück, aber in einer Lambda-Funktion wird ein vollständiger Prozess zurückgegeben. Angenommen, wir möchten mithilfe einer Lambda-Funktionssyntax, die dem folgenden Codeausschnitt ähnelt, prüfen, ob eine Zahl gerade oder ungerade ist.

b = lambda x: "Even" if x%2==0 else "Odd"
b(9)

• Funktionen werden nur in einer Zeile geschrieben und erstellt, während Einrückungen in normalen Funktionen verwendet werden.
• Nicht für die Wiederverwendung von Code geeignet. oder nicht in einer anderen Datei. Im Gegensatz dazu dienen normale Funktionen der Wiederverwendung von Code und können in externen Dateien verwendet werden.

Warum die Lambda-Funktion verwenden?

Im Allgemeinen verwenden wir die Lambda-Funktion nicht, sondern verwenden sie mit Funktionen höherer Ordnung. Eine Funktion höherer Ordnung ist eine Funktion, die mehr als eine Funktion benötigt, um eine Aufgabe abzuschließen. Wenn eine Funktion eine andere Funktion zurückgibt, kann optional eine Lambda-Funktion verwendet werden.

Was ist eine Funktion höherer Ordnung?

Funktionen höherer Ordnung anhand eines Beispiels verstehen. Angenommen, Sie haben eine Liste mit Ganzzahlen und drei Ausgaben müssen zurückgegeben werden.

• Die Summe aller geraden Zahlen in einer Liste
• Die Summe aller ungeraden Zahlen in einer Liste
• Die Summe aller durch drei teilbaren Zahlen

Nehmen Sie zunächst an, dass eine gewöhnliche Funktion zur Lösung dieses Problems verwendet wird. In diesem Fall werden drei verschiedene Variablen zum Speichern der einzelnen Aufgaben deklariert und eine for-Schleife verwendet, um die resultierenden drei Variablen zu verarbeiten und zurückzugeben. Diese Methode funktioniert normal.

Verwenden Sie nun die Lambda-Funktion, um dieses Problem zu lösen. Anschließend können Sie mit drei verschiedenen Lambda-Funktionen prüfen, ob eine zu testende Zahl gerade, ungerade oder durch drei teilbar ist, und dann eine Zahl zum Ergebnis hinzufügen.

def return_sum(func, lst):
 result = 0
 for i in lst:
 #if val satisfies func
 if func(i):
 result = result + i
 return result
lst = [11,14,21,56,78,45,29,28]
x = lambda a: a%2 == 0
y = lambda a: a%2 != 0
z = lambda a: a%3 == 0
print(return_sum(x, lst))
print(return_sum(y, lst))
print(return_sum(z, lst))

Hier wird eine Funktion höherer Ordnung erstellt, bei der eine Lambda-Funktion als Teil einer normalen Funktion übergeben wird. Tatsächlich ist diese Art von Code überall im Internet zu finden. Viele Leute ignorieren diese Funktion jedoch bei der Verwendung von Python oder verwenden sie nur gelegentlich. Tatsächlich sind diese Funktionen jedoch sehr praktisch und können mehr Codezeilen einsparen. Schauen wir uns als Nächstes diese Funktionen höherer Ordnung an.

Pythons integrierte Funktion höherer Ordnung

Map-Funktion

map() ordnet die angegebene Sequenz gemäß der bereitgestellten Funktion zu.

Die Kartenfunktion ist eine Funktion, die zwei Parameter akzeptiert. Die erste Parameterfunktion ruft die Funktionsfunktion mit jedem Element in der Parametersequenz auf, und der zweite Parameter ist ein beliebiger iterierbarer Sequenzdatentyp. Gibt eine neue Liste zurück, die den von jeder Funktion zurückgegebenen Wert enthält. Die

map(function, iterable, ...)

Map-Funktion definiert eine Art Operation im Iteratorobjekt. Angenommen, wir möchten Array-Elemente quadrieren, d. h. das Quadrat jedes Elements eines Arrays auf ein anderes Array abbilden, das das gewünschte Ergebnis liefert.

arr = [2,4,6,8]
arr = list(map(lambda x: x*x, arr))
print(arr)

Wir können die Kartenfunktion auf verschiedene Arten nutzen. Angenommen, es gibt eine Liste von Wörterbüchern mit Details wie Namen, Adressen usw. und das Ziel besteht darin, eine neue Liste mit allen Namen zu erstellen.

students = [
 {"name": "John Doe",
"father name": "Robert Doe",
"Address": "123 Hall street"
},
 {
 "name": "Rahul Garg",
 "father name": "Kamal Garg",
 "Address": "3-Upper-Street corner"
 },
 {
 "name": "Angela Steven",
"father name": "Jabob steven",
"Address": "Unknown"
 }
]
print(list(map(lambda student: student['name'], students)))
>>> ['John Doe', 'Rahul Garg', 'Angela Steven']

Die oben genannten Vorgänge treten normalerweise in Szenarien wie dem Abrufen von Daten aus einer Datenbank oder dem Web-Crawling auf.

Filterfunktion

Die Filterfunktion filtert Daten basierend auf bestimmten spezifischen Bedingungen heraus. Das heißt, Sie legen Filterbedingungen in der Funktion fest, iterieren Elemente und behalten Elemente mit dem Rückgabewert „True“. Die Kartenfunktion bearbeitet jedes Element, während die Filterfunktion nur Elemente ausgibt, die bestimmte Anforderungen erfüllen.

Angenommen, es gibt eine Liste mit Fruchtnamen und die Aufgabe besteht darin, nur die Namen auszugeben, deren Namen das Zeichen „g“ enthalten.

fruits = ['mango', 'apple', 'orange', 'cherry', 'grapes']
print(list(filter(lambda fruit: 'g' in fruit, fruits)))

filter(Funktion oder Keine, iterierbar) --> Filterobjekt

Gibt einen Iterator für die iterierbaren Elemente zurück, bei denen die Funktion oder das Element wahr ist. Wenn die Funktion „None“ ist, wird „true“ zurückgegeben.

Reduzierfunktion

Diese Funktion ist etwas ganz Besonderes. Sie ist keine integrierte Funktion von Python und muss über functools import Reduce importiert werden. Reduzieren gibt einen einzelnen Ausgabewert aus einer Sequenzdatenstruktur zurück, indem eine bestimmte Funktion zum Reduzieren von Elementen angewendet wird.

reduce(function, sequence[, initial]) -> value

Wenden Sie eine Funktion mit zwei Argumenten kumulativ von links nach rechts auf die Elemente einer Sequenz an und reduzieren Sie so die Sequenz auf einen einzelnen Wert.

Wenn initial vorhanden ist, wird es in der Sequenz vor dem Element platziert und dient als Standardwert, wenn die Sequenz leer ist.

假设有一个整数列表，并求得所有元素的总和。且使用reduce函数而不是使用for循环来处理此问题。

from functools import reduce
lst = [2,4,6,8,10]
print(reduce(lambda x, y: x+y, lst))
>>> 30

还可以使用 reduce 函数而不是for循环从列表中找到最大或最小的元素。

lst = [2,4,6,8]
# 找到最大元素
print(reduce(lambda x, y: x if x>y else y, lst))
# 找到最小元素
print(reduce(lambda x, y: x if x<y else y, lst))

高阶函数的替代方法

列表推导式

其实列表推导式只是一个for循环，用于添加新列表中的每一项，以从现有索引或一组元素创建一个新列表。之前使用map、filter和reduce完成的工作也可以使用列表推导式完成。然而，相比于使用Map和filter函数，很多人更喜欢使用列表推导式，也许是因为它更容易应用和记忆。

同样使用列表推导式将数组中每个元素进行平方运算，水果的例子也可以使用列表推导式来解决。

arr = [2,4,6,8]
arr = [i**2 for i in arr]
print(arr)
fruit_result = [fruit for fruit in fruits if 'g' in fruit]
print(fruit_result)

字典推导式

与列表推导式一样，使用字典推导式从现有的字典创建一个新字典。还可以从列表创建字典。

假设有一个整数列表，需要创建一个字典，其中键是列表中的每个元素，值是列表中的每个元素的平方。

lst = [2,4,6,8]
D1 = {item:item**2 for item in lst}
print(D1)
>>> {2: 4, 4: 16, 6: 36, 8: 64}
# 创建一个只包含奇数元素的字典
arr = [1,2,3,4,5,6,7,8]
D2 = {item: item**2 for item in arr if item %2 != 0}
print(D2)
>>> {1: 1, 3: 9, 5: 25, 7: 49}

一个简单应用

如何快速找到多个字典的公共键

方法一

dl = [d1, d2, d3] # d1, d2, d3为字典，目标找到所有字典的公共键
[k for k in dl[0] if all(map(lambda d: k in d, dl[1:]))]

例

dl = [{1:'life', 2: 'is'},
{1:'short', 3: 'i'},
 {1: 'use', 4: 'python'}]
[k for k in dl[0] if all(map(lambda d: k in d, dl[1:]))]
# 1

解析

# 列表表达式遍历dl中第一个字典中的键
[k for k in dl[0]]
# [1, 2]
# lambda 匿名函数判断字典中的键，即k值是否在其余字典中
list(map(lambda d: 1 in d, dl[1:]))
# [True, True]
list(map(lambda d: 2 in d, dl[1:]))
#[False, False]
# 列表表达式条件为上述结果([True, True])全为True,则输出对应的k值
#1

方法二

# 利用集合（set）的交集操作
from functools import reduce
# reduce(lambda a, b: a*b, range(1,11)) # 10!
reduce(lambda a, b: a & b, map(dict.keys, dl))

写在最后

目前已经学习了Lambda函数是什么，以及Lambda函数的一些使用方法。随后又一起学习了Python中的高阶函数，以及如何在高阶函数中使用lambda函数。

除此之外，还学习了高阶函数的替代方法：在列表推导式和字典推导式中执行之前操作。虽然这些方法看似简单，或者说你之前已经见到过这类方法，但你很可能很少使用它们。你可以尝试在其他更加复杂的函数中使用它们，以便使代码更加简洁。

Das obige ist der detaillierte Inhalt vonLambda-Funktion, der König von allen in Python. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!