Tutoriel d'introduction à la programmation fonctionnelle Python

Introduction

Fonctionnel Le concept de programmation (programmation fonctionnelle) est né de LISP, fondé par John McCarthy en 1958, qui a été le premier à proposer le concept de garbage collection automatique. Ce concept est désormais également utilisé par de nombreux langages tels que Python/Java/Ruby. . Aujourd'hui, LISP a engendré de nombreux dialectes. Par rapport à la programmation orientée objet, l'un des avantages de la programmation fonctionnelle est l'immuabilité. Les données (les données sont immuables) signifient qu'elles ne dépendent pas de données externes et ne modifient pas la valeur des données externes. Cette idée peut réduire considérablement les bogues dans notre code, et la programmation fonctionnelle nous aide également à utiliser des fonctions telles que des variables. En tant que langage orienté objet, Python prend également en charge la programmation fonctionnelle, bien qu'il ne soit pas si pur et ne prenne pas en charge l'optimisation de la récursion finale.

Utilisation de lambda

lambda est une fonction anonyme. Une utilisation appropriée de lambda peut non seulement réduire la quantité de notre code, mais aussi mieux décrire la logique du code, par exemple. comme maintenant, nous avons une fonction comme la suivante.

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

Si on réécrit cette fonction en utilisant lamda, une seule ligne de code suffit.

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

Utilisation de map

map(function, iterable) reçoit deux paramètres. Le premier paramètre représente la réception d'une fonction et le deuxième paramètre représente la réception d'un objet de type iteralbe, tel qu'une liste.

Le principe de la fonction map est : 1. Supprimez à chaque fois un paramètre d'itérable, 2. Passez ce paramètre à notre fonction, 3. Ajoutez ensuite la valeur renvoyée par la fonction à une liste (cette instruction n'est pas exacte, juste pour aider tout le monde à comprendre, je vais l'expliquer plus tard) . Une fois que tous les objets itérables ont été parcourus, map renvoie la liste à notre appelant. Apprenons à utiliser map directement à travers des exemples.

exemple1

# 
还是用我们上面那个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]

exemple2

Pour le deuxième paramètre de map, nous pouvons également transmettre un ensemble de listes de fonctions, ce qui signifie que la liste contient plusieurs objets de fonctions. .

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

Utilisation de réduire

Identique à la carte, réduire(fonction, iterable) reçoit également deux paramètres. Le premier paramètre représente la réception d'une fonction et le deuxième paramètre représente la réception d'un objet de type iteralbe, tel qu'une liste. Mais la différence est que la fonction dans réduire doit recevoir deux paramètres. Apprenons à utiliser réduire à travers l'exemple de recherche de la somme cumulée d'une liste.

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

L'utilisation du filtre

est similaire à map/reduce, filter(function, itérable) reçoit également deux paramètres à la fois, un paramètre est une fonction et l'autre paramètre est un objet itérable. Comme le montre son nom, le filtre est utilisé pour filtrer les objets itérables, tels que la liste (liste).

Son principe est de retirer un élément de l'objet itérable et de l'appliquer à notre fonction. Si la fonction renvoie True, l'élément sera conservé. Si la fonction renvoie False, l'élément sera supprimé. Jetons un coup d'œil à l'utilisation du filtre à travers un exemple.

# 
定义一个函数，如果接收的字符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 est une syntaxe Python avancée. Les décorateurs peuvent traiter une fonction, une méthode ou une classe. Une utilisation raisonnable des décorateurs peut réduire la quantité de notre code et améliorer la lisibilité du programme. Dans de nombreux frameworks Python, comme Django, nous pouvons voir un grand nombre de décorateurs.

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

Nous avons maintenant les deux fonctions ci-dessus, qui sont utilisées respectivement pour calculer l'addition et la multiplication, mais maintenant nous pensons que la fonction n'est pas suffisante et souhaitons ajouter quelques instructions de sortie avant de renvoyer le résultat en général. parlant, nous devons reconstruire les deux fonctions A function, comme indiqué ci-dessous.

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

Si nous utilisons un décorateur, nous pouvons procéder comme suit Bien qu'il semble qu'il n'y ait aucun avantage à utiliser un décorateur dans notre situation actuelle, si nous voulons ajouter plus d'une fonction d'impression, et. en plus d'ajouter/multiplier, nous avons également des fonctions telles que moins/division. À ce stade, la puissance du décorateur est reflétée. Nous n'avons besoin de modifier qu'un seul code. Cela améliore non seulement la lisibilité du programme mais permet également de gagner du temps. pour nous de reconstruire le code à l'avenir, cela a demandé beaucoup de travail.

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

Ce qui précède est le contenu du didacticiel d'introduction à la programmation fonctionnelle Python. Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !