Fungsi Lambda, raja segala-galanya dalam Python

Pengenalan fungsi Lambda

Fungsi Lambda juga dikenali sebagai fungsi tanpa nama (tiada nama), yang menerima secara langsung bilangan parameter dan keadaan atau operasi yang dilakukan menggunakan parameter , Parameter dipisahkan oleh titik bertindih dan hasil akhir dikembalikan. Untuk melaksanakan tugas kecil semasa menulis kod pada asas kod yang besar, atau untuk melaksanakan tugas kecil dalam fungsi, fungsi lambda digunakan dalam proses biasa.

lambda argument_list:expersion

argument_list ialah senarai parameter, strukturnya adalah sama dengan senarai parameter fungsi dalam Python

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

ungkapan ialah ungkapan tentang parameter, ekspresi Parameter yang muncul dalam perlu ditakrifkan dalam argument_list, dan ungkapan hanya boleh menjadi satu baris.

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

Perbezaan antara fungsi biasa dan fungsi Lambda

• Tiada nama Fungsi Lambda tidak mempunyai nama, manakala operasi biasa mempunyai nama yang sesuai.
• Fungsi Lambda tidak mempunyai nilai pulangan Fungsi biasa yang dibina menggunakan kata kunci def mengembalikan nilai atau jenis data jujukan, tetapi dalam fungsi Lambda proses lengkap dikembalikan. Katakan kita ingin menyemak sama ada nombor genap atau ganjil, menggunakan sintaks fungsi lambda yang serupa dengan coretan kod di bawah.

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

• Fungsi ditulis dan dibuat dalam satu baris sahaja Fungsi Lambda ditulis dan dibuat dalam satu baris sahaja, manakala lekukan digunakan dalam fungsi biasa tidak digunakan untuk penggunaan semula kod Lambda Fungsi tidak boleh digunakan untuk penggunaan semula kod, atau fungsi tidak boleh diimport dalam mana-mana fail lain. Sebaliknya, fungsi biasa digunakan untuk penggunaan semula kod dan boleh digunakan dalam fail luaran.
Mengapa menggunakan fungsi Lambda?

Secara amnya, kami tidak menggunakan fungsi Lambda, tetapi menggunakannya dengan fungsi tertib lebih tinggi. Fungsi tertib lebih tinggi ialah fungsi yang memerlukan lebih daripada satu fungsi untuk menyelesaikan tugas, atau apabila fungsi mengembalikan sebarang fungsi lain, fungsi Lambda boleh digunakan secara pilihan.

Apakah fungsi tertib tinggi?

Fahami fungsi tertib tinggi melalui contoh. Katakan anda mempunyai senarai integer dan tiga output mesti dikembalikan.

Jumlah semua nombor genap dalam senarai

• Jumlah semua nombor ganjil dalam senarai
• Jumlah semua nombor boleh dibahagi dengan tiga
Mula-mula andaikan bahawa fungsi biasa digunakan untuk menangani masalah ini. Dalam kes ini, tiga pembolehubah berbeza diisytiharkan untuk menyimpan tugas individu, dan gelung for digunakan untuk memproses dan mengembalikan tiga pembolehubah yang terhasil. Kaedah ini berfungsi seperti biasa.

Sekarang gunakan fungsi Lambda untuk menyelesaikan masalah ini Kemudian anda boleh menggunakan tiga fungsi Lambda yang berbeza untuk menyemak sama ada nombor yang hendak diuji adalah genap, ganjil atau boleh dibahagikan dengan tiga, dan kemudian tambahkan nombor pada hasilnya. .

Di sini fungsi tertib lebih tinggi dicipta di mana fungsi Lambda dihantar sebagai sebahagian daripada fungsi biasa. Malah, kod jenis ini boleh didapati di mana-mana di Internet. Walau bagaimanapun, ramai orang mengabaikan fungsi ini apabila menggunakan Python, atau hanya menggunakannya sekali-sekala, tetapi sebenarnya fungsi ini sangat mudah dan boleh menyimpan lebih banyak baris kod. Seterusnya mari kita lihat fungsi tertib lebih tinggi ini.

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))

Fungsi peringkat tinggi terbina dalam Python

Fungsi peta

map() akan memetakan jujukan yang ditentukan mengikut fungsi yang disediakan.

Fungsi Peta ialah fungsi yang menerima dua parameter. Fungsi parameter pertama memanggil fungsi fungsi dengan setiap elemen dalam jujukan parameter, dan parameter kedua ialah sebarang jenis data jujukan boleh lelar. Mengembalikan senarai baharu yang mengandungi nilai yang dikembalikan oleh setiap fungsi.

Fungsi peta akan menentukan beberapa jenis operasi dalam objek iterator. Katakan kita ingin menduakan elemen tatasusunan, iaitu memetakan kuasa dua setiap elemen satu tatasusunan kepada tatasusunan lain yang menghasilkan hasil yang diingini.

map(function, iterable, ...)

Kita boleh menggunakan fungsi Peta dengan cara yang berbeza. Katakan terdapat senarai kamus yang mengandungi butiran seperti nama, alamat, dsb. dan matlamatnya adalah untuk menjana senarai baharu yang mengandungi semua nama.

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

Operasi di atas biasanya berlaku dalam senario seperti mendapatkan data daripada pangkalan data atau merangkak web.

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']

Fungsi penapis

Fungsi penapis menapis data berdasarkan syarat khusus yang diberikan. Iaitu, tetapkan keadaan penapis dalam fungsi, lelaran elemen, dan kekalkan elemen dengan nilai pulangan True. Fungsi peta beroperasi pada setiap elemen, manakala fungsi penapis hanya mengeluarkan elemen yang memenuhi keperluan khusus.

Andaikan terdapat senarai nama buah-buahan dan tugasnya adalah untuk mengeluarkan hanya nama-nama yang mengandungi aksara "g" dalam nama mereka.

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

filter(function or None, iterable) --> filter object

Mengembalikan iterator untuk item boleh lelar yang fungsi atau item itu benar . Jika fungsi itu Tiada, mengembalikan benar.

Fungsi Reduce

Fungsi ini agak istimewa Ia bukan fungsi terbina dalam Python dan perlu diimport melalui dari functools import reduce. Reduce mengembalikan nilai output tunggal daripada struktur data jujukan dengan menggunakan fungsi yang diberikan untuk mengurangkan elemen.

Gunakan fungsi dua hujah secara kumulatif pada item jujukan, dari kiri ke kanan, dengan itu mengurangkan jujukan kepada satu nilai.

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

Jika parap hadir, ia diletakkan sebelum item dalam jujukan dan berfungsi sebagai nilai lalai apabila jujukan itu kosong.

假设有一个整数列表，并求得所有元素的总和。且使用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函数。

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

Atas ialah kandungan terperinci Fungsi Lambda, raja segala-galanya dalam Python. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!