Python-Funktionsprogrammierung, lesen Sie einfach diesen Artikel!

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

Erstklassige Funktion

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

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

Funktionen als Objekte behandeln

Da andere Datentypen (wie String, Liste und Int) Objekte sind, sind Funktionen auch Objekte in Python-Objekt. 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 die Funktion der Variablen bar zuweisen:

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

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

Objekte als Funktionen behandeln

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

Das Beispiel sieht wie folgt aus:

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 gerufen werden kann bei der Begrüßung. 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 Methode __call__ in der Klassendefinition verwendet haben. Um zu überprüfen, ob das Objekt aufrufbar ist, verwenden wir die integrierte Funktion aufrufbar:

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

Funktionen innerhalb der Datenstruktur

Funktionen sind wie andere Objekte und können innerhalb der Datenstruktur 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 Sie sich 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, bei der die Liste der auszuführenden Iterationen und die auf jedes Element anzuwendende Funktion 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 um eine Ebene höher angehoben, 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 Funktion

Funktionen können auch innerhalb anderer Funktionen sein. 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, siehe zum Beispiel: 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)?

Wir können das Schlüsselwort Lambda in Python verwenden, um solche Funktionen zu definieren. Ein Beispiel ist wie folgt:

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

Die Mult-Funktion verhält sich genauso wie eine Funktion, die mit dem traditionellen Schlüsselwort def definiert wird.

Hinweis: Die Lambda-Funktion muss eine einzelne Zeile sein und darf keine vom Programmierer geschriebenen Rückgabeanweisungen enthalten.

事实上，它们通常具备隐式的返回语句（在上面的示例中，函数想表达 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 的函数需要两个参数：一个表示正在接受检查的项，另一个表示所用运算的累积结果。

本文是关于函数式编程的一篇入门文章，虽然尽量完备地介绍了相关的知识，但并不是那么深入。如想了解更多，大家可以阅读以下资源：

• Best Practices for Using Functional Programming in Python：https://kite.com/blog/python/functional-programming/
• Functional Programming Tutorials and Notes：https://www.hackerearth.com/zh/practice/python/functional-programming/functional-programming-1/tutorial/

Das obige ist der detaillierte Inhalt vonPython-Funktionsprogrammierung, lesen Sie einfach diesen Artikel!. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!