Artikel terperinci tentang teknik pengaturcaraan berfungsi Python

Artikel ini menyediakan pengenalan ringkas kepada teknologi pengaturcaraan berfungsi dalam Python.

Fungsi kelas pertama

Dalam Python, fungsi ialah "warga kelas pertama". Iaitu, fungsi berada pada kedudukan yang sama dengan jenis data lain seperti int.

Oleh itu, kita boleh menetapkan fungsi kepada pembolehubah, menghantarnya sebagai argumen kepada fungsi lain, menyimpannya dalam struktur data lain (seperti dicts), dan menggunakannya sebagai nilai pulangan fungsi lain.

Anggap fungsi sebagai objek

Memandangkan jenis data lain (seperti rentetan, senarai dan int) ialah objek, maka fungsi juga merupakan objek dalam Python. Mari lihat contoh fungsi foo, yang mencetak namanya sendiri:

def foo():
 print("foo")

Memandangkan fungsi ialah objek, kita boleh menetapkan fungsi foo kepada mana-mana pembolehubah dan kemudian memanggil pembolehubah itu. Sebagai contoh, kita boleh menetapkan fungsi kepada bar pembolehubah:

bar = foo
bar()
#will print "foo" to the console

Bar pernyataan = foo memperuntukkan objek yang dirujuk oleh fungsi foo kepada bar pembolehubah.

Merawat objek sebagai fungsi

Apabila objek boleh dipanggil, ia adalah sama dengan fungsi, seperti objek(). Ini dicapai melalui kaedah panggilan.

Contohnya adalah seperti berikut:

class Greeter:
 def __init__(self, greeting):
self.greeting = greeting
 def __call__(self, name):
return self.greeting + " " + name

Setiap kali kita mengkonfigurasi objek kelas Greeter, kita mencipta objek baharu, iaitu nama baharu yang boleh dilaungkan apabila memberi salam. Seperti yang ditunjukkan di bawah:

morning = Greeter("good morning") #creates the callable object
morning("john") # calling the object
#prints "good morning john" to the console

Sebab kita boleh memanggil objek pagi adalah kerana kita telah menggunakan kaedah panggilan dalam definisi kelas. Untuk menyemak sama ada objek boleh dipanggil, kami menggunakan fungsi boleh panggil terbina dalam:

callable(morning) #true
callable(145) #false. int is not callable.

Fungsi dalam struktur data

Fungsi, seperti objek lain, boleh disimpan di dalam struktur data. Sebagai contoh, kita boleh mencipta kamus int to func. Ini berguna apabila int adalah singkatan untuk langkah yang akan dilakukan.

# store in dictionary
mapping = {
 0 : foo,
 1 : bar
}
x = input() #get integer value from user
mapping[x]() #call the func returned by dictionary access

Begitu juga, fungsi boleh disimpan dalam pelbagai struktur data lain.

Gunakan fungsi sebagai parameter dan nilai pulangan

Fungsi juga boleh digunakan sebagai parameter dan mengembalikan nilai fungsi lain. Fungsi yang menerima fungsi sebagai input atau fungsi pengembalian dipanggil fungsi peringkat tinggi, dan ia merupakan bahagian penting dalam pengaturcaraan berfungsi.

Fungsi tertib tinggi mempunyai keupayaan berkuasa. Seperti yang dijelaskan dalam "JavaScript yang fasih":

"Fungsi tertib lebih tinggi membolehkan kita mengabstraksi tindakan, bukan hanya nilai abstrak." contoh. Katakan kita ingin mengulangi senarai item dan mencetaknya mengikut urutan. Kita boleh membina fungsi lelaran dengan mudah:

Ia kelihatan hebat, tetapi ia hanyalah abstraksi peringkat pertama. Bagaimana jika kita mahu melakukan sesuatu selain daripada mencetak semasa mengulang senarai?

Ini ialah maksud fungsi tertib tinggi. Kita boleh mencipta fungsi iterate_custom, di mana senarai yang akan diulang dan fungsi yang akan digunakan pada setiap item adalah input kepada fungsi iterate_custom:

def iterate(list_of_items):
for item in list_of_items:
print(item)

Ini mungkin kelihatan remeh, tetapi sebenarnya sangat berkuasa.

Kami telah meningkatkan tahap pengabstrakan satu tahap lebih tinggi untuk menjadikan kod lebih boleh digunakan semula. Kini, bukan sahaja kita boleh memanggil fungsi ini semasa mencetak senarai, kita juga boleh melakukan operasi sewenang-wenangnya pada senarai yang melibatkan lelaran jujukan.

def iterate_custom(list_of_items, custom_func):
 for item in list_of_items:
custom_func(item)

Fungsi juga boleh dikembalikan, menjadikan perkara lebih mudah. Sama seperti kita menyimpan fungsi dalam dict, kita juga boleh menggunakan fungsi sebagai pernyataan kawalan untuk menentukan fungsi yang sesuai. Contohnya:

Fungsi bersarang

Fungsi juga boleh berada di dalam fungsi lain. Ini ialah "fungsi dalaman". Fungsi intrinsik berguna apabila mencipta fungsi pembantu, fungsi kecil boleh guna semula yang berfungsi sebagai submodul untuk menyokong fungsi utama.

def add(x, y):
return x + y
def sub(x, y):
return x - y
def mult(x, y):
return x * y
def calculator(opcode):
if opcode == 1:
 return add
elif opcode == 2:
 return sub
else:
 return mult 
my_calc = calculator(2) #my calc is a subtractor
my_calc(5, 4) #returns 5 - 4 = 1 
my_calc = calculator(9) #my calc is now a multiplier
my_calc(5, 4) #returns 5 x 4 = 20.

Kami boleh menggunakan fungsi pembantu apabila masalah memerlukan definisi fungsi tertentu (jenis atau susunan parameter). Pendekatan bukan tradisional ini menjadikan penyelesaian masalah lebih mudah, sebagai contoh lihat:

http://www-inst.eecs.berkeley.edu/~cs61a/sp12/lectures/lect4-2x3 pdf.

Andaikan anda ingin mentakrifkan fungsi Fibonacci fib(n), yang mempunyai hanya satu parameter n, dan kita mesti mengembalikan nombor Fibonacci ke-.

Satu cara yang mungkin untuk mentakrifkan fungsi sedemikian adalah dengan menggunakan fungsi pembantu untuk menjejaki dua sebutan pertama jujukan Fibonacci (memandangkan nombor Fibonacci ialah jumlah dua nombor pertama).

Alihkan pengiraan ini dari badan fungsi ke parameter fungsi, yang sangat berkuasa. Kerana ia mengurangkan pengiraan berlebihan yang mungkin berlaku dalam kaedah rekursif.

Fungsi ungkapan tunggal (ungkapan Lambda)

def fib(n):
def fib_helper(fk1, fk, k):
if n == k:
 return fk
else:
 return fib_helper(fk, fk1+fk, k+1)
if n <= 1:
 return n
else:
 return fib_helper(0, 1, 1)

Bagaimana jika kita mahu menulis fungsi tanpa memberikan nama? Bagaimana jika kita ingin menulis fungsi satu baris pendek (seperti fungsi foo atau mult dalam contoh di atas)?

我们可以在 Python 中使用 lambda 关键字来定义此类函数。示例如下：

mult = lambda x, y: x * y
mult(1, 2) #returns 2

该 mult 函数的行为与使用传统 def 关键字定义函数的行为相同。

注意：lambda 函数必须为单行，且不能包含程序员写的返回语句。

事实上，它们通常具备隐式的返回语句（在上面的示例中，函数想表达 return x * y，不过我们省略了 lambda 函数中的显式返回语句）。

lambda 函数更加强大和精准，因为我们还可以构建匿名函数（即没有名称的函数）：

(lambda x, y: x * y)(9, 10) #returns 90

当我们只需要一次性使用某函数时，这种方法非常方便。例如，当我们想填充字典时：

import collections
pre_fill = collections.defaultdict(lambda: (0, 0))
#all dictionary keys and values are set to 0

接下来我们来看 Map、Filter 和 Reduce，以更多地了解 lambda。

Map、Filter 和 Reduce

Map

map 函数基于指定过程（函数）将输入集转换为另一个集合。这类似于上文提到的 iterate_custom 函数。例如：

def multiply_by_four(x):
return x * 4
scores = [3, 6, 8, 3, 5, 7]
modified_scores = list(map(multiply_by_four, scores))
#modified scores is now [12, 24, 32, 12, 20, 28]

在 Python 3 中，map 函数返回的 map 对象可被类型转换为 list，以方便使用。现在，我们无需显式地定义 multiply_by_four 函数，而是定义 lambda 表达式：

modified_scores = list(map(lambda x: 4 * x, scores))

当我们想对集合内的所有值执行某项操作时，map 函数很有用。

Filter

就像名称所显示的那样，filter 函数可以帮助筛除不想要的项。例如，我们想要去除 scores 中的奇数，那么我们可以使用 filter：

even_scores = list(filter(lambda x: True if (x % 2 == 0) else False, scores))
#even_scores = [6, 8]

由于提供给 filter 的函数是逐个决定是否接受每一个项的，因此该函数必须返回 bool 值，且该函数必须是一元函数（即只使用一个输入参数）。

Reduce

reduce 函数用于「总结」或「概述」数据集。例如，如果我们想要计算所有分数的总和，就可以使用 reduce：

sum_scores = reduce((lambda x, y: x + y), scores)
#sum_scores = 32

这要比写循环语句简单多了。注意：提供给 reduce 的函数需要两个参数：一个表示正在接受检查的项，另一个表示所用运算的累积结果。

Atas ialah kandungan terperinci Artikel terperinci tentang teknik pengaturcaraan berfungsi Python. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!