Fungsi paling misteri yang biasa digunakan dalam Python! Ringkasan mendalam fungsi lambda!

Apakah fungsi Lambda dalam Python

Fungsi lambda ialah fungsi tanpa nama (iaitu, tidak mempunyai nama yang ditentukan) yang boleh menerima sebarang bilangan argumen, tetapi mempunyai Fungsi yang sama adalah berbeza kerana ia hanya menilai dan mengembalikan ungkapan.

Fungsi lambda dalam Python dinyatakan menggunakan sintaks berikut:

parameter lambda: ungkapan

fungsi lambda terdiri daripada tiga elemen:

• Kata kunci lambda: serupa dengan def dalam fungsi biasa
• Parameter: menyokong menghantar parameter kedudukan dan kata kunci, sama seperti fungsi biasa
• Teks: memproses ungkapan dengan parameter tetap

Perlu diambil perhatian bahawa, tidak seperti fungsi biasa, tidak perlu menggunakan kurungan untuk menyertakan parameter fungsi lambda Jika fungsi lambda mempunyai dua atau lebih parameter, kami menyenaraikannya dengan koma

Kami. gunakan lambda Fungsi hanya menilai ungkapan pendek (sebaik-baiknya, satu baris) dan hanya menilai sekali, yang bermaksud kami tidak akan menggunakan semula fungsi itu lagi pada masa hadapan. Secara umumnya, kami akan menghantar fungsi lambda sebagai parameter kepada fungsi tertib lebih tinggi (fungsi yang menerima fungsi lain sebagai parameter), seperti fungsi terbina dalam Python, seperti filter(), map() atau reduce() , dsb.

Python Bagaimana fungsi Lambda berfungsi dalam

Mari kita lihat contoh fungsi lambda yang mudah:

lambda x: x + 1

Output:

<function __main__.<lambda>(x)>

Fungsi lambda di atas menerima satu parameter, Naikkannya sebanyak 1 dan kembalikan hasilnya

yang merupakan versi yang lebih ringkas bagi fungsi normal berikut dengan kata kunci def dan return:

def increment_by_one(x):
 return x + 1

Setakat ini fungsi lambda kami lambda x: x + 1 hanya mencipta objek fungsi dan tidak mengembalikan apa-apa kerana kami tidak memberikan sebarang nilai (argumen) untuk parameter xnya. Mari kita tetapkan pembolehubah dahulu, hantarkannya ke fungsi lambda dan lihat apa yang kita dapat kali ini:

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

Output:

<function <lambda> at 0x00000250CB0A5820>

Fungsi lambda kami tidak mempunyai apa-apa seperti milik kita Ia mengembalikan 3 seperti yang diharapkan, tetapi sebaliknya mengembalikan objek fungsi itu sendiri dan lokasi ingatannya, yang menunjukkan bahawa ini bukan cara yang betul untuk memanggil fungsi lambda. Untuk menghantar parameter kepada fungsi lambda, laksanakannya dan kembalikan hasilnya, kita harus menggunakan sintaks berikut:

(lambda x: x + 1)(2)

Output:

3

Walaupun parameter fungsi lambda kami bukan digunakan dalam kurungan kurungan, tetapi apabila kami memanggilnya, kami menambah kurungan di sekeliling keseluruhan pembinaan fungsi lambda dan hujah yang kami hantar kepadanya

Perkara lain yang perlu diperhatikan dalam kod di atas ialah, menggunakan fungsi lambda , Kami boleh melaksanakan fungsi dan menerima hasilnya serta-merta selepas menciptanya. Ini dipanggil Invokasi Segera bagi Pelaksanaan Fungsi (atau IIFE)

Kita boleh mencipta fungsi lambda dengan berbilang parameter, dalam hal ini kita memisahkan parameter dalam definisi fungsi dengan koma. Apabila kami melaksanakan fungsi lambda sedemikian, kami menyenaraikan parameter yang sepadan dalam susunan yang sama dan memisahkannya dengan koma:

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

Output:

12

Anda juga boleh menggunakan fungsi lambda untuk melakukan operasi bersyarat. Berikut ialah simulasi lambda bagi fungsi if-else yang mudah:

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

Output:

10
12

Jika terdapat berbilang keadaan (if-elif-...-else) , kita Mereka mesti bersarang:

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

Output:

110

Tetapi kaedah penulisan di atas menjadikan kod sukar dibaca

Dalam kes ini, terdapat Fungsi biasa dengan set keadaan if-elif-...-else akan menjadi pilihan yang lebih baik daripada fungsi lambda. Sebenarnya, kita boleh menulis fungsi lambda dalam contoh di atas dengan:

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

Output:

110

Walaupun fungsi di atas menambah lebih banyak baris daripada fungsi lambda yang sepadan, tetapi ia lebih mudah untuk membaca

Kita boleh menetapkan fungsi lambda kepada pembolehubah dan kemudian memanggil pembolehubah itu sebagai fungsi biasa:

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

Output:

3

Tetapi menurut peraturan gaya PEP 8 untuk kod Python, ini adalah amalan buruk

• Penggunaan pernyataan tugasan menghapuskan satu-satunya faedah yang boleh diberikan oleh ungkapan lambda berbanding pernyataan def eksplisit ( iaitu ia boleh dibenamkan ke dalam ungkapan yang lebih besar )

Jadi jika kita benar-benar perlu menyimpan fungsi untuk kegunaan selanjutnya, lebih baik kita mentakrifkan fungsi normal yang setara dan bukannya Fungsi lambda yang diberikan kepada pembolehubah

Aplikasi fungsi Lambda dalam Python

Lambda dengan fungsi penapis()

Fungsi penapis() dalam Python memerlukan dua parameter:

• Fungsi yang mentakrifkan keadaan penapis
• Objek boleh lelar di mana fungsi dijalankan

Menjalankan fungsi, kita mendapat objek penapis:

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

Output:

<filter at 0x250cb090520>

Untuk mendapatkan iterator baru daripada objek penapis, dan semua item dalam iterator asal memenuhi syarat yang telah ditetapkan, kita perlu menapis Objek dihantar ke fungsi sepadan perpustakaan standard Python: list(), tuple(), set (), frozenset() atau sorted() (mengembalikan senarai diisih)

Mari kita menapis senarai nombor dan hanya pilih Nombor yang lebih besar daripada 10 dan mengembalikan senarai yang diisih dalam tertib menaik:

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

Output:

[11, 22, 33]

Kita tidak perlu mencipta objek lelaran baharu daripada jenis yang sama seperti objek asal, selain itu kita boleh Menyimpan hasil operasi ini dalam pembolehubah:

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 函数概念更清晰、更易于应用，更希望小伙伴们能够喜欢，喜欢就点个赞吧！

Atas ialah kandungan terperinci Fungsi paling misteri yang biasa digunakan dalam Python! Ringkasan mendalam fungsi lambda!. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!