Einführungs-Tutorial zur funktionalen Python-Programmierung

Einführung

Funktional Das Konzept der Programmierung (funktionale Programmierung) stammt ursprünglich von LISP, das 1958 von John McCarthy gegründet wurde und als erster das Konzept der automatischen Garbage Collection vorschlug. Dieses Konzept wird mittlerweile auch von vielen Sprachen wie Python/Java/Ruby verwendet . Heute hat LISP viele Dialekte hervorgebracht. Im Vergleich zur objektorientierten Programmierung ist Unveränderlichkeit einer der Vorteile der funktionalen Programmierung Daten (Daten sind unveränderlich) bedeuten, dass sie nicht auf externen Daten basieren und den Wert externer Daten nicht ändern. Diese Idee kann Fehler in unserem Code erheblich reduzieren, und die funktionale Programmierung unterstützt uns auch bei der Verwendung von Funktionen wie Variablen. Als objektorientierte Sprache bietet Python auch Unterstützung für funktionale Programmierung, obwohl es nicht so rein ist und keine Schwanzrekursionsoptimierung unterstützt.

Verwendung von Lambda

Lambda ist eine anonyme Funktion, die nicht nur die Menge unseres Codes reduzieren, sondern auch die Codelogik besser beschreiben kann wie jetzt Wir haben eine Funktion wie die folgende.

>>> def f(x):
...    return x + x
#
调用这个函数
>>> f(2)
4

Wenn wir diese Funktion mit Lamda umschreiben, reicht nur eine Codezeile.

#
lambda后面的x表示lambda函数要接收的参数，x + x表示lambda函数所要返回的值
>>> f = lambda x: x + x
#
可以看到f现在也是一个函数对象
>>> f
<function __main__.<lambda>>
#
调用lambda函数
>>> f(2)
4

Nutzung der Karte

Karte(Funktion, iterierbar) empfängt zwei Parameter. Der erste Parameter stellt den Empfang einer Funktion dar, und der zweite Parameter stellt den Empfang eines Objekts vom Typ Iteralbe dar, beispielsweise einer Liste.

Das Prinzip der Kartenfunktion ist: 1. Nehmen Sie jedes Mal einen Parameter aus iterable heraus, 2. Übergeben Sie diesen Parameter an unsere Funktion, 3. Fügen Sie dann den von der Funktion zurückgegebenen Wert zu einer Liste hinzu (diese Aussage ist nicht korrekt, nur um es allen verständlich zu machen, werde ich sie erklären später) . Nachdem alle iterierbaren Objekte durchlaufen wurden, gibt Map die Liste an unseren Aufrufer zurück. Lassen Sie uns anhand von Beispielen lernen, wie man Map direkt verwendet.

Beispiel1

#
还是用我们上面那个lambda的例子
>>> function = lambda x: x + x
#
定义一个iterable对象list(列表)
>>> iterable = [1, 2, 3, 4, 5, 6, 7, 8, 9]
#
函数fucntion每次从iterable中取出一个参数x，然后function返回x + x的值，
#
并将返回值加入一个新建的list，等将iterable遍历完，map就将这个新建的list返回。
>>> v = map(function, iterable)
#
注意上面的说法并不准确，只是为了帮助大家理解，其实map返回的是一个map对象，并不是list
>>> v
<map at 0x7fcb56231588>
#
但是我们可以调用内建的list函数将map转换成一个list来得到我们想要的结果
>>> list(v)
[2, 4, 6, 8, 10, 12, 14, 16, 18]

Beispiel2

Für den zweiten Parameter von Map können wir auch eine Reihe von Funktionslisten übergeben, was bedeutet, dass die Liste mehrere Funktionen enthält .

>>> multiply = lambda x: x * x
>>> add = lambda x: x + x
>>> funcs = [multiply, add]
>>> list(map(lambda f: f(1), funcs))
[1, 2]

Verwendung von Reduce

Dasselbe wie bei Karte, Reduce(Funktion, iterierbar) empfängt außerdem zwei Parameter. Der erste Parameter stellt den Empfang einer Funktion dar, und der zweite Parameter stellt den Empfang eines Objekts vom Typ iteralbe dar, beispielsweise einer Liste. Der Unterschied besteht jedoch darin, dass die Funktion in Reduce zwei Parameter erhalten muss. Lassen Sie uns anhand des Beispiels der Ermittlung der kumulativen Summe einer Liste lernen, wie man Reduce verwendet.

from functools import reduce
#
使用lambda定义一个函数，函数的作用是接收两个参数，然后返回两个参数之和
>>> function = lambda x, y: x+y
>>> iterable = [1, 2, 3, 4, 5, 6, 7, 8, 9]
#
函数function每次接收两个参数，除第一次外每次从iterable中取一个元素作为一个参数
#
另外一个参数取自上一次function返回的值
>>> reduce(function,  iterable)
45

Die Verwendung des Filters

ähnelt Map/Reduce, Filter(function, iterierbar) empfängt auch zwei Parameter gleichzeitig, ein Parameter ist eine Funktion und der andere Parameter ist ein iterierbares Objekt. Wie aus dem Namen hervorgeht, wird Filter zum Filtern iterierbarer Objekte wie Listen (Listen) verwendet.

Das Prinzip besteht darin, ein Element aus dem iterierbaren Objekt herauszunehmen und es auf unsere Funktion anzuwenden. Wenn die Funktion „True“ zurückgibt, wird das Element beibehalten. Wenn die Funktion „False“ zurückgibt, wird das Element gelöscht. Schauen wir uns die Verwendung von Filtern anhand eines Beispiels an.

#
定义一个函数，如果接收的字符s为空，那么返回False，如果为非空，那么返回True
>>> function = lambda s : s and s.strip()
>>> iterable = ['AJ', ' ', 'Stussy', '', 'CLOT', 'FCB', None]
>>> filter(function, iterable)
<filter at 0x7fcb562319b0>
>>> list(filter(function, iterable))
[&#39;AJ&#39;, &#39;Stussy&#39;, &#39;CLOT&#39;, &#39;FCB&#39;]

Decorator

Decorator ist eine erweiterte Python-Syntax. Dekorateure können eine Funktion, Methode oder Klasse verarbeiten. Der sinnvolle Einsatz von Dekoratoren kann die Menge unseres Codes reduzieren und die Lesbarkeit des Programms verbessern. In vielen Python-Frameworks wie Django können wir eine große Anzahl von Dekoratoren sehen.

>>> def add(x, y):
...     return x + y
...
>>> def multiply(x, y):
...     return x * y
...

Jetzt haben wir die beiden oben genannten Funktionen, die zur Berechnung der Addition bzw. Multiplikation verwendet werden, aber jetzt sind wir der Meinung, dass die Funktion nicht ausreicht, und möchten im Allgemeinen einige Ausgabeanweisungen hinzufügen, bevor wir das Ergebnis zurückgeben Wenn wir sprechen, müssen wir die beiden Funktionen A rekonstruieren, wie unten gezeigt.

>>> def add(x, y):
...     print("input:", x, y)
...     return x + y
...
>>> def multiply(x, y):
...     print("input:", x, y)
...     return x * y
...

Wenn wir einen Dekorator verwenden, können wir wie folgt vorgehen. Obwohl die Verwendung eines Dekorators in unserer aktuellen Situation keinen Vorteil zu haben scheint, wenn wir mehr als eine Druckfunktion hinzufügen möchten, und Zusätzlich zum Addieren/Multiplizieren haben wir auch Funktionen wie Minus/Dividieren. Dies spiegelt die Leistung des Dekorators wider. Dies verbessert nicht nur die Lesbarkeit des Programms, sondern spart auch Zeit Es war eine Menge Arbeit, den Code in Zukunft zu rekonstruieren.

def decorator(F):
    def new_function(x, y):
        print("input:", x, y)
        return F(x, y)
    return new_function
@decorator
def add(x, y):
    return x + y
@decorator
def multiply(x, y):
    return x * y

Das Obige ist der Inhalt des Einführungs-Tutorials in die funktionale Python-Programmierung. Weitere verwandte Inhalte finden Sie auf der chinesischen PHP-Website (www.php.cn).