Ausführlicher Artikel über Techniken der funktionalen Python-Programmierung

Dieser Artikel bietet eine einfache Einführung in die funktionale Programmiertechnologie in Python.

Erstklassige Funktionen

In Python sind Funktionen „erstklassige Bürger“. Das heißt, Funktionen sind anderen Datentypen wie int gleichgestellt.

So können wir Variablen Funktionen zuweisen, sie als Argumente an andere Funktionen übergeben, sie in anderen Datenstrukturen (z. B. Diktate) speichern und sie als Rückgabewerte anderer Funktionen verwenden.

Funktionen als Objekte behandeln

Da andere Datentypen (wie String, Liste und Int) Objekte sind, sind Funktionen in Python auch Objekte. Schauen wir uns die Beispielfunktion foo an, die ihren eigenen Namen ausgibt:

def foo():
 print("foo")

Da Funktionen Objekte sind, können wir die Funktion foo jeder Variablen zuweisen und diese Variable dann aufrufen. Beispielsweise können wir der Variablen bar eine Funktion zuweisen:

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

Die Anweisung bar = foo weist der Variablen bar das von der Funktion foo referenzierte Objekt zu.

Objekte als Funktionen behandeln

Wenn Objekte aufrufbar sind, sind sie dasselbe wie Funktionen, z. B. object(). Dies wird durch die Call-Methode erreicht.

Das Beispiel lautet wie folgt:

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

Jedes Mal, wenn wir ein Objekt der Greeter-Klasse konfigurieren, erstellen wir ein neues Objekt, das einen neuen Namen hat, der bei der Begrüßung gerufen werden kann. Wie unten gezeigt:

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

Der Grund, warum wir das Morgenobjekt aufrufen können, ist, dass wir die Call-Methode in der Klassendefinition verwendet haben. Um zu überprüfen, ob ein Objekt aufrufbar ist, verwenden wir die integrierte Funktion aufrufbar:

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

Funktionen in Datenstrukturen

Funktionen können wie andere Objekte in Datenstrukturen gespeichert werden. Zum Beispiel können wir ein Wörterbuch von int bis func erstellen. Dies ist praktisch, wenn ein int eine Abkürzung für den auszuführenden Schritt ist.

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

Ähnlich können Funktionen in einer Vielzahl anderer Datenstrukturen gespeichert werden.

Funktionen als Parameter und Rückgabewerte verwenden

Funktionen können auch als Parameter und Rückgabewerte anderer Funktionen verwendet werden. Funktionen, die Funktionen als Eingabe- oder Rückgabefunktionen akzeptieren, werden als Funktionen höherer Ordnung bezeichnet und sind ein wichtiger Bestandteil der funktionalen Programmierung.

Funktionen höherer Ordnung verfügen über leistungsstarke Funktionen. Wie in „Eloquent JavaScript“ erklärt:

„Funktionen höherer Ordnung ermöglichen es uns, Aktionen zu abstrahieren, nicht nur Werte zu abstrahieren.“

Schauen wir uns ein Beispiel an. Angenommen, wir möchten eine Liste von Elementen durchlaufen und diese nacheinander ausdrucken. Wir können ganz einfach eine Iterationsfunktion erstellen:

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

Sie sieht cool aus, ist aber nur eine Abstraktion der ersten Ebene. Was ist, wenn wir beim Durchlaufen der Liste etwas anderes als drucken möchten?

Das ist die Bedeutung der Existenz von Funktionen höherer Ordnung. Wir können eine Funktion iterate_custom erstellen, wobei die Liste der auszuführenden Iterationen und die auf jedes Element anzuwendende Funktion die Eingaben für die Funktion iterate_custom sind:

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

Das mag trivial erscheinen, ist aber tatsächlich sehr mächtig.

Wir haben die Abstraktionsebene erhöht, um den Code wiederverwendbar zu machen. Nun können wir diese Funktion nicht nur beim Drucken einer Liste aufrufen, sondern auch beliebige Operationen an der Liste ausführen, die eine Sequenziteration beinhalten.

Funktionen können auch zurückgegeben werden, was die Sache noch einfacher macht. So wie wir Funktionen in dict speichern, können wir Funktionen auch als Steueranweisungen verwenden, um die geeignete Funktion zu bestimmen. Zum Beispiel:

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.

Verschachtelte Funktionen

Funktionen können auch in anderen Funktionen enthalten sein. Dies ist eine „interne Funktion“. Intrinsische Funktionen sind nützlich beim Erstellen von Hilfsfunktionen, kleinen wiederverwendbaren Funktionen, die als Untermodule zur Unterstützung der Hauptfunktion dienen.

Wir können Hilfsfunktionen verwenden, wenn das Problem eine bestimmte Funktionsdefinition (Parametertyp oder -reihenfolge) erfordert. Dieser nicht-traditionelle Ansatz vereinfacht die Problemlösung erheblich. Ein Beispiel finden Sie unter:

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

Angenommen, Sie möchten eine Fibonacci-Funktion fib(n) definieren, die nur einen Parameter n hat, und wir müssen die n-te Fibonacci-Zahl zurückgeben.

Eine Möglichkeit, eine solche Funktion zu definieren, besteht darin, eine Hilfsfunktion zu verwenden, um die ersten beiden Terme der Fibonacci-Folge zu verfolgen (da die Fibonacci-Zahl die Summe der ersten beiden Zahlen ist).

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)

Das Verschieben dieser Berechnung vom Funktionskörper auf die Funktionsparameter ist sehr leistungsstark. Weil es redundante Berechnungen reduziert, die bei rekursiven Methoden auftreten können.

Einzelausdrucksfunktion (Lambda-Ausdruck)

Was sollen wir tun, wenn wir eine Funktion schreiben möchten, bevor wir der Funktion einen Namen geben? Was wäre, wenn wir eine kurze einzeilige Funktion schreiben möchten (z. B. die Funktion foo oder mult im obigen Beispiel)?

我们可以在 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 的函数需要两个参数：一个表示正在接受检查的项，另一个表示所用运算的累积结果。

Das obige ist der detaillierte Inhalt vonAusführlicher Artikel über Techniken der funktionalen Python-Programmierung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!