Die mysteriöseste Funktion, die häufig in Python verwendet wird! Ausführliche Zusammenfassung der Lambda-Funktion!

Was ist eine Lambda-Funktion in Python?

Eine Lambda-Funktion ist eine anonyme Funktion (d. h. kein Name definiert), die eine beliebige Anzahl von Argumenten akzeptieren kann, aber im Gegensatz zu einer normalen Funktion nur einen Ausdruck auswertet und zurückgibt.

Die Lambda-Funktion in Python wird mit der folgenden Syntax ausgedrückt:

Lambda-Parameter: Ausdruck

Lambda-Funktion enthält drei Elemente:

• Schlüsselwort Lambda: ähnelt def in einer normalen Funktion
• Parameter: unterstützt die Übergabe von Position und Schlüssel Wortparameter sind die gleichen wie normale Funktionen
• Text: Ausdrücke mit festen Parametern verarbeiten

Es ist zu beachten, dass im Gegensatz zu normalen Funktionen keine Klammern zum Einschließen der Parameter der Lambda-Funktion erforderlich sind hat zwei oder mehr Multiple-Parameter, wir listen sie mit Kommas auf

Wir verwenden die Lambda-Funktion, um nur einen kurzen Ausdruck (idealerweise eine einzelne Zeile) und nur einmal auszuwerten, was bedeutet, dass wir diese Funktion in Zukunft nicht mehr verwenden werden. Im Allgemeinen übergeben wir die Lambda-Funktion als Parameter an eine Funktion höherer Ordnung (eine Funktion, die andere Funktionen als Parameter akzeptiert), beispielsweise an in Python integrierte Funktionen wie filter (), map () oder Reduce (). usw.

Lambda-Funktion in Python So funktioniert es

Sehen wir uns ein einfaches Lambda-Funktionsbeispiel an:

lambda x: x + 1

Ausgabe:

<function __main__.<lambda>(x)>

Die obige Lambda-Funktion nimmt einen Parameter, erhöht ihn um 1 und gibt das Ergebnis zurück

Das ist es Folgendes mit den Schlüsselwörtern def und return. Eine einfachere Version einer normalen Funktion:

def increment_by_one(x):
 return x + 1

Bisher erstellt unsere Lambda-Funktion lambda x: x + 1 nur ein Funktionsobjekt und gibt nichts zurück, das liegt daran, dass wir keinen Wert (Argument) angegeben haben. für seinen Parameter x. Weisen wir zunächst eine Variable zu, übergeben sie an die Lambda-Funktion und sehen, was wir dieses Mal erhalten:

a = 2
print(lambda x: a + 1)

Ausgabe:

<function <lambda> at 0x00000250CB0A5820>

Unsere Lambda-Funktion gibt nicht wie erwartet 3 zurück, sondern das Funktionsobjekt selbst und seine Speicherort ist ersichtlich, dass dies nicht die richtige Art ist, die Lambda-Funktion aufzurufen. Um Parameter an eine Lambda-Funktion zu übergeben, sie auszuführen und das Ergebnis zurückzugeben, sollten wir die folgende Syntax verwenden:

(lambda x: x + 1)(2)

Ausgabe:

3

Obwohl die Parameter unserer Lambda-Funktion nicht in Klammern eingeschlossen sind, fügen wir beim Aufruf hinzu Klammern um den gesamten Aufbau der Lambda-Funktion und die Parameter, die wir an sie übergeben.

Eine weitere zu beachtende Sache im obigen Code ist, dass wir mit Lambda-Funktionen die Funktion ausführen und das Ergebnis erhalten können, sobald sie erstellt wird. Dies wird als „Immediate Invocation of Function Execution“ (oder IIFE) bezeichnet.

Wir können eine Lambda-Funktion mit mehreren Parametern erstellen. In diesem Fall trennen wir die Parameter in der Funktionsdefinition durch Kommas. Wenn wir eine solche Lambda-Funktion ausführen, listen wir die entsprechenden Parameter in derselben Reihenfolge auf und trennen sie durch Kommas:

(lambda x, y, z: x + y + z)(3, 8, 1)

Ausgabe:

12

Sie können Lambda-Funktionen auch verwenden, um bedingte Operationen auszuführen. Hier ist eine Lambda-Simulation einer einfachen if-else-Funktion:

print((lambda x: x if(x > 10) else 10)(5))
print((lambda x: x if(x > 10) else 10)(12))

Ausgabe:

10
12

Wenn es mehrere Bedingungen gibt (if-elif-...-else), müssen wir sie verschachteln:

(lambda x: x * 10 if x > 10 else (x * 5 if x < 5 else x))(11)

Ausgabe:

110

Aber die obige Schreibmethode macht den Code schwer lesbar

In diesem Fall ist eine gewöhnliche Funktion mit festgelegter if-elif-...-else-Bedingung eine bessere Wahl als die Lambda-Funktion. Tatsächlich können wir die Lambda-Funktion im obigen Beispiel wie folgt schreiben:

def check_conditions(x):
 if x > 10:
 return x * 10
 elif x < 5:
 return x * 5
 else:
 return x
check_conditions(11)

Ausgabe:

110

Obwohl die obige Funktion mehr Zeilen hinzufügt als die entsprechende Lambda-Funktion, ist sie einfacher zu lesen

Wir können die Lambda-A-Funktion konvertieren wird einer Variablen zugewiesen und dann wird diese Variable als normale Funktion aufgerufen:

increment = lambda x: x + 1
increment(2)

Ausgabe:

3

Aber gemäß den PEP 8-Stilregeln für Python-Code ist dies eine schlechte Praxis

• Die Verwendung von Zuweisungsanweisungen eliminiert The Der einzige Vorteil, den ein Lambda-Ausdruck gegenüber einer expliziten Def-Anweisung bietet (d. h. er kann in einen größeren Ausdruck eingebettet werden)

Wenn wir also eine Funktion zur weiteren Verwendung speichern müssen, sollten wir besser ein Äquivalent zu einer normalen Funktion definieren. Anstatt die Lambda-Funktion einer Variablen zuzuweisen

Anwendung der Lambda-Funktion in Python

Lambda mit filter()-Funktion

Die filter()-Funktion in Python erfordert zwei Parameter:

• Funktion, die Filterbedingungen definiert
• Iterierbares Objekt auf dem die Funktion arbeitet

Beim Ausführen der Funktion erhalten wir ein Filterobjekt:

lst = [33, 3, 22, 2, 11, 1]
filter(lambda x: x > 10, lst)

Ausgabe:

<filter at 0x250cb090520>

Um einen neuen Iterator aus dem Filterobjekt zu erhalten und alle Elemente im ursprünglichen Iterator die vordefinierten Bedingungen erfüllen, benötigen wir um das Filterobjekt an die entsprechende Funktion der Python-Standardbibliothek zu übergeben: list(), tuple(), set(), Frozenset() oder sorted() (Gibt eine sortierte Liste zurück)

Filtern wir eine Liste mit Zahlen nur nach Wählen Sie Zahlen größer als 10 aus und geben Sie eine in aufsteigender Reihenfolge sortierte Liste zurück:

lst = [33, 3, 22, 2, 11, 1]
sorted(filter(lambda x: x > 10, lst))

Ausgabe:

[11, 22, 33]

Wir müssen kein neues iterierbares Objekt vom gleichen Typ wie das Originalobjekt erstellen, außerdem können wir das Ergebnis speichern Operation in einer Variablen:

lst = [33, 3, 22, 2, 11, 1]
tpl = tuple(filter(lambda x: x > 10, lst))
tpl

Output:

(33, 22, 11)

带有 map() 函数的 Lambda

我们使用 Python 中的 map() 函数对可迭代的每个项目执行特定操作。它的语法与 filter() 相同：一个要执行的函数和一个该函数适用的可迭代对象。

map() 函数返回一个 map 对象，我们可以通过将该对象传递给相应的 Python 函数来从中获取一个新的迭代：list()、tuple()、set()、frozenset() 或 sorted()

与 filter() 函数一样，我们可以从 map 对象中提取与原始类型不同类型的可迭代对象，并将其分配给变量。

下面是使用 map() 函数将列表中的每个项目乘以 10 并将映射值作为分配给变量 tpl 的元组输出的示例：

lst = [1, 2, 3, 4, 5]
print(map(lambda x: x * 10, lst))
tpl = tuple(map(lambda x: x * 10, lst))
tpl

Output:

<map object at 0x00000250CB0D5F40>
(10, 20, 30, 40, 50)

map() 和 filter() 函数之间的一个重要区别是第一个函数总是返回与原始函数相同长度的迭代。因此由于 pandas Series 对象也是可迭代的，我们可以在 DataFrame 列上应用 map() 函数来创建一个新列：

import pandas as pd
df = pd.DataFrame({'col1': [1, 2, 3, 4, 5], 'col2': [0, 0, 0, 0, 0]})
print(df)
df['col3'] = df['col1'].map(lambda x: x * 10)
df

Output:

col1col2
0 1 0
1 2 0
2 3 0
3 4 0
4 5 0
col1col2col3
0 1 010
1 2 020
2 3 030
3 4 040
4 5 050

当然要在上述情况下获得相同的结果，也可以使用 apply() 函数：

df['col3'] = df['col1'].apply(lambda x: x * 10)
df

Output:

col1col2col3
0 1 010
1 2 020
2 3 030
3 4 040
4 5 050

我们还可以根据某些条件为另一列创建一个新的 DataFrame 列，对于下面的代码，我们可以互换使用 map() 或 apply() 函数：

df['col4'] = df['col3'].map(lambda x: 30 if x < 30 else x)
df

Output:

col1col2col3col4
0 1 01030
1 2 02030
2 3 03030
3 4 04040
4 5 05050

带有 reduce() 函数的 Lambda

reduce() 函数与 functools Python 模块相关，它的工作方式如下：

• 对可迭代对象的前两项进行操作并保存结果
• 对保存的结果和可迭代的下一项进行操作
• 以这种方式在值对上进行，直到所有项目使用可迭代的

该函数与前两个函数具有相同的两个参数：一个函数和一个可迭代对象。但是与前面的函数不同的是，这个函数不需要传递给任何其他函数，直接返回结果标量值：

from functools import reduce
lst = [1, 2, 3, 4, 5]
reduce(lambda x, y: x + y, lst)

Output:

15

上面的代码展示了我们使用 reduce() 函数计算列表总和时的作用

需要注意的是，reduce() 函数总是需要一个带有两个参数的 lambda 函数，而且我们必须首先从 functools Python 模块中导入它

Python 中 Lambda 函数的优缺点

优点

• 评估单个表达式的理想选择，应该只评估一次
• 它可以在定义后立即调用
• 与相应的普通语法相比，它的语法更紧凑
• 它可以作为参数传递给高阶函数，例如 filter()、map() 和 reduce()

缺点

• 它不能执行多个表达式
• 它很容易变得麻烦，可读性差，例如当它包括一个 if-elif-...-else 循环
• 它不能包含任何变量赋值（例如，lambda x: x=0 将抛出一个语法错误）
• 我们不能为 lambda 函数提供文档字符串

总结

总而言之，我们已经详细讨论了在 Python 中定义和使用 lambda 函数的许多方面：

• lambda 函数与普通 Python 函数有何不同
• Python 中 lambda 函数的语法和剖析
• 何时使用 lambda 函数
• lambda 函数的工作原理
• 如何调用 lambda 函数
• 调用函数执行（IIFE）的定义
• 如何使用 lambda 函数执行条件操作，如何嵌套多个条件，以及为什么我们应该避免它
• 为什么我们应该避免将 lambda 函数分配给变量
• 如何将 lambda 函数与 filter() 函数一起使用
• 如何将 lambda 函数与 map() 函数一起使用
• 我们如何在 pandas DataFrame 中使用
• 带有传递给它的 lambda 函数的 map() 函数 - 以及在这种情况下使用的替代功能
• 如何将 lambda 函数与 reduce() 函数一起使用
• 普通 Python 上使用 lambda 函数的优缺点

希望今天的讨论可以使 Python 中看似令人生畏的 lambda 函数概念更清晰、更易于应用，更希望小伙伴们能够喜欢，喜欢就点个赞吧！

Das obige ist der detaillierte Inhalt vonDie mysteriöseste Funktion, die häufig in Python verwendet wird! Ausführliche Zusammenfassung der Lambda-Funktion!. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!