Programmation fonctionnelle Python, lisez simplement cet article !

Cet article fournit une introduction simple à la technologie de programmation fonctionnelle en Python.

Fonctions de première classe

En Python, les fonctions sont des "citoyens de première classe". Autrement dit, les fonctions sont sur un pied d'égalité avec d'autres types de données tels que int.

Ainsi, nous pouvons attribuer des fonctions à des variables, les transmettre comme arguments à d'autres fonctions, les stocker dans d'autres structures de données (telles que des dicts) et les utiliser comme valeurs de retour d'autres fonctions.

Traitez les fonctions comme des objets

Puisque d'autres types de données (tels que string, list et int) sont des objets, alors les fonctions sont également des objets en Python. Regardons l'exemple de fonction foo, qui affiche son propre nom :

def foo():
print("foo")

Puisque les fonctions sont des objets, nous pouvons attribuer la fonction foo à n'importe quelle variable, puis appeler cette variable. Par exemple, on peut affecter une fonction à la variable bar :

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

L'instruction bar = foo assigne l'objet référencé par la fonction foo à la variable bar.

Traiter les objets comme des fonctions

Lorsque les objets sont appelables, ils sont identiques aux fonctions, telles que object(). Ceci est réalisé grâce à la méthode __call__.

L'exemple est le suivant :

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

Chaque fois que nous configurons un objet de la classe Greeter, nous créerons un nouvel objet, qui est un nouveau nom qui peut être crié lors du salut. Comme indiqué ci-dessous :

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

La raison pour laquelle nous pouvons appeler l'objet matin est que nous avons utilisé la méthode __call__ dans la définition de la classe. Pour vérifier si un objet est appelable, nous utilisons la fonction intégrée callable :

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

Fonctions à l'intérieur des structures de données

Les fonctions, comme les autres objets, peuvent être stockées dans des structures de données. Par exemple, nous pouvons créer un dictionnaire de int à func. Cela s'avère pratique lorsqu'un int est un raccourci pour l'étape à effectuer.

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

De même, les fonctions peuvent être stockées dans diverses autres structures de données.

Utiliser des fonctions comme paramètres et valeurs de retour

Les fonctions peuvent également être utilisées comme paramètres et valeurs de retour d'autres fonctions. Les fonctions qui acceptent des fonctions comme fonctions d'entrée ou de retour sont appelées fonctions d'ordre supérieur et constituent une partie importante de la programmation fonctionnelle.

Les fonctions d'ordre supérieur ont des capacités puissantes. Comme expliqué dans "Eloquent JavaScript" :

• "Les fonctions d'ordre supérieur nous permettent d'abstraire des actions, pas seulement des valeurs abstraites."

Regardons un exemple. Supposons que nous souhaitions parcourir une liste d’éléments et les imprimer dans l’ordre. Nous pouvons facilement créer une fonction itérer :

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

Cela a l'air cool, mais ce n'est qu'une abstraction de premier niveau. Et si nous voulons faire autre chose qu’imprimer en parcourant la liste ?

C'est le sens de l'existence de fonctions d'ordre supérieur. Nous pouvons créer une fonction iterate_custom, où la liste des itérations à effectuer et la fonction à appliquer à chaque élément sont les entrées de la fonction iterate_custom :

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

Cela peut sembler trivial, mais est en réalité très puissant.

Nous avons élevé le niveau d'abstraction pour rendre le code plus réutilisable. Désormais, non seulement nous pouvons appeler cette fonction lors de l'impression d'une liste, mais nous pouvons également effectuer des opérations arbitraires sur la liste impliquant une itération de séquence.

Les fonctions peuvent également être renvoyées, ce qui rend les choses encore plus simples. Tout comme nous stockons des fonctions dans un dict, nous pouvons également utiliser des fonctions comme instructions de contrôle pour déterminer la fonction appropriée. Par exemple :

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.

Fonctions imbriquées

Les fonctions peuvent également être à l'intérieur d'autres fonctions. Il s'agit d'une "fonction interne". Les fonctions intrinsèques sont utiles lors de la création de fonctions d'assistance, de petites fonctions réutilisables qui servent de sous-modules pour prendre en charge la fonction principale.

Nous pouvons utiliser des fonctions d'assistance lorsque le problème nécessite une définition de fonction spécifique (type ou ordre de paramètre). Cette approche non traditionnelle rend la résolution de problèmes beaucoup plus simple, voir par exemple : http://www-inst.eecs.berkeley.edu/~cs61a/sp12/lectures/lect4-2x3.pdf.

Supposons que vous souhaitiez définir une fonction de Fibonacci fib(n), qui n'a qu'un seul paramètre n, et que nous devons renvoyer le nième nombre de Fibonacci.

Une façon possible de définir une telle fonction est d'utiliser une fonction d'assistance pour suivre les deux premiers termes de la séquence de Fibonacci (puisque le nombre de Fibonacci est la somme des deux premiers nombres).

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)

Déplacer ce calcul du corps de la fonction vers les paramètres de la fonction est très puissant. Parce que cela réduit les calculs redondants pouvant survenir dans les méthodes récursives.

Fonction d'expression unique (expression Lambda)

Que devons-nous faire si nous voulons écrire une fonction avant de lui donner un nom ? Que se passe-t-il si nous voulons écrire une courte fonction sur une ligne (comme la fonction foo ou mult dans l'exemple ci-dessus) ?

Nous pouvons définir de telles fonctions en Python en utilisant le mot-clé lambda. Voici un exemple :

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

La fonction mult se comporte de la même manière qu'une fonction définie à l'aide du mot-clé traditionnel def.

Remarque : la fonction lambda doit être une seule ligne et ne peut pas contenir d'instructions de retour écrites par le programmeur.

事实上，它们通常具备隐式的返回语句（在上面的示例中，函数想表达 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/

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!