Coder en utilisant def: la programmation fonctionnelle
Dans ce tutoriel, nous parlons de la programmation avec les fonctions def
La programmation fonctionnelle est un style de programmation qui (comme son nom l’indique) est basé sur des fonctions. Les fonctions d’ordre supérieur constituent un élément clé de la programmation fonctionnelle.
Les fonctions d’ordre supérieur prennent d’autres fonctionnent comme arguments ou les renvoient comme résultats.
def apply_twice(func, arg):
return func(func(arg))
def add_five(x):
return x + 5
print(apply_twice(add_five, 10))
Output
20
La fonction apply prend deux fois une autre fonction comme argument et l’appelle deux fois dans son corps.
La programmation fonctionnelle cherche à utiliser des fonctions pures. Les fonctions pures n’ont pas d’effets secondaires et renvoient une valeur cela ne dépend que de leurs arguments.
C’est ainsi que fonctionnent les fonctions en mathématiques : par exemple, le cos(x) renverra, pour la même valeur de x, toujours le même résultat.
Voici des exemples de fonctions pures et impures.
def pure_function(x, y):
temp = x + 2*y
return temp/(2*x + y)
Fonction impure :
some_list = []
Pure Functions
def impure(arg):
some_list.append(arg)
L’utilisation de fonctions pures présente à la fois des avantages et des inconvénients.
Les fonctions pures sont :
– plus facile à raisonner et à tester.
– plus efficace. Une fois que la fonction a été évaluée pour une entrée, le résultat peut être stocké et référencé
la prochaine fois que la fonction de cette entrée est nécessaire, réduisant le nombre de fois que la fonction est appelée. Cela s’appelle la mémorisation.
– plus facile à exécuter en parallèle.
Les fonctions pures sont plus difficiles à écrire dans certaines situations.
Créer une fonction normalement en utilisant def
Python nous permet de créer des fonctions à la volée, à condition qu’elles soient créées à l’aide de la syntaxe lambda.
Cette approche est la plus couramment utilisée lors du passage d’une fonction simple comme argument à une autre fonction.
La syntaxe est illustrée dans l’exemple suivant et se compose du mot-clé lambda suivi d’une liste des arguments, deux-points et l’expression à évaluer et à renvoyer.
def my func(f, arg):
return f(arg)
my_func(lambda x: 2*x*x, 5)
Les fonctions créées à l’aide de la syntaxe lambda sont dites anonymes.
Lambda
Les fonctions Lambda ne sont pas aussi puissantes que les fonctions nommées.
Ils ne peuvent faire que des choses qui nécessitent une seule expression – généralement équivalente à une seule ligne de code.
Exemple:
# fonction nommée
def polynomial(x):
return x**2 + 5*x + 4
print(polynomial(-4))
#lambda
print((lambda x: x**2 + 5*x + 4) (-4))
Output:
0
0
La fonction map
Dans le code ci-dessus, nous avons créé une fonction anonyme à la volée et l’avons appelée avec un argument.
Les fonctions intégrées map et filter sont des fonctions d’ordre supérieur très utiles qui fonctionnent sur des listes ou des fonctions similaires.
Sur des objets appelés itérables).
La fonction map prend une fonction et un itérable comme arguments, et renvoie un nouvel itérable
avec la fonction appliquée à chaque argument.
def add_five(x):
return x + 5
nums = [11, 22, 33, 44, 55]
result = list(map(add_five, nums))
print(result)
Output
[16, 27, 38, 49, 60]
Nous aurions pu obtenir le même résultat plus facilement en utilisant la syntaxe lambda.
nombres = [11, 22, 33, 44, 55]
result = list(map(lambda x: x+5, nums))
imprimer (résultat)
Output
[16, 27, 38, 49, 60]
Pour convertir le résultat en liste, nous avons utilisé list explicitement.
Cas d’usage:
Supposons que
Vous travaillez sur un programme de paie.
Étant donné une liste de salaires, vous devez prendre le bonus que tout le monde reçoit comme entrée et augmenter tous les salaires par ce montant.
Sortez la liste résultante.
Vous pouvez utiliser la fonction map() pour augmenter toutes les valeurs de la liste.
salaires [2000, 1800, 3100, 4400, 1500]
bonus = int(input())
salaries =list(map(lambda x:x+bonus,salaries))
print(salaries)
Input : 420
Output: [2420, 2220, 3520, 4820, 1920]
La fonction filtre filtre un itérable en ne laissant que les éléments qui correspondent à une condition (également appelée un prédicat).
Exemple:
chiffres [11, 22, 33, 44, 55]
res = list(filter(lambda x: x%2==0, nums))
print(res)
Output
[22, 44]
Comme map, le résultat doit être explicitement converti en liste si vous souhaitez l’imprimer.
Les générateurs sont un type d’itérable, comme les listes ou les tuples.
Contrairement aux listes, elles ne permettent pas l’indexation avec des indices arbitraires, mais elles peuvent toujours être itérées à travers avec des boucles.
Ils peuvent être créés à l’aide de fonctions et de l’instruction yield.
def countdown():
i=5
while i > 0:
yield i
i-= 1
for i in countdown():
print(i)
Output:
5
4
3
2
1
L’instruction yield est utilisée pour définir un générateur, remplaçant le retour d’une fonction pour fournir un résultat à son appelant sans détruire les variables locales.
Du fait qu’ils produisent un élément à la fois, les générateurs n’ont pas les restrictions de mémoire des listes. En fait, ils peuvent être infinis !
def infinite_sevens():
while True:
yield 7
for i in infinite_sevens():
print(i)Output:
En bref, les générateurs permettent de déclarer une fonction qui se comporte comme un itérateur, c’est-à-dire qu’elle peut être utilisée dans une boucle for. nombres def(x):
pour i dans la plage (x):
def numbers(x):
for i in range(x):
if i % 2 == 0:
yield i
print(list(numbers(11)))
[0, 2, 4, 6, 8, 10]L’utilisation de générateurs améliore les performances, résultat de la génération paresseuse (à la demande) de valeurs, ce qui se traduit par une utilisation réduite de la mémoire. De plus, nous n’avons pas besoin d’attendre que tous les éléments ont été générés avant de commencer à les utiliser.
Trouver des nombres premiers est une tâche classique de codage.
Le code donné définit une fonction isPrime(x), qui renvoie True si x est premier.
Vous devez créer une fonction génératrice primeGenerator), qui prendra deux nombres comme arguments, et utilisez la fonction isPrime() pour afficher les nombres premiers dans la plage donnée (entre les deux arguments).
Sample Input
10
20
Sample Output
[11, 13, 17, 19]
Le code donné prend les deux arguments en entrée et les transmet à la fonction générateur, en sortant le résultat sous forme de liste.
def isPrime(x):
if x < 2:
return false
elif x = = 2:
return True
for n in range(2, x):
if x % n == 0:
return false
return True
def primeGenerator(a, b):
for number in range(a,b):
if isPrime(number):
yield number
f = int(input())
t = int(input())
print(list(primeGenerator(f, t)))
Input
5
18
Output [5, 7, 11, 13, 17]
Le code donné prend les deux arguments en entrée et les transmet à la fonction générateur, en sortant le résultat sous forme de liste.
def decor(func):
def wrap():
print("============")
func()
print("== =========")
return wrap
def print_text():
print("Hello world!")
Decorators
decorated decor(print_text)
decorated()
Output
Hello world!
Nous avons défini une fonction nommée décor qui a un seul paramètre func. A l’intérieur du décor, nous avons défini un imbriqué la fonction nommée wrap. La fonction wrap imprimera une chaîne, puis appellera func() et imprimera une autre chaîne.
La fonction décor renvoie la fonction wrap comme résultat.
Nous pourrions dire que la variable décorée est une version décorée de print_text — c’est print_text plus
quelque chose.
En fait, si nous écrivions un décorateur utile, nous voudrions peut-être remplacer print_text par la version décorée
au total, nous avons donc toujours notre version “plus quelque chose” de print_text.
Cela se fait en affectant la variable qui contient notre fonction :
def decor(func):
def wrap():
print("============")
print("============")
func()
return wrap
def print_text():
print("Hello world!")
print_text = decor(print_text)
print_text()
Maintenant, le texte imprimé correspond à notre version décorée.
Dans notre exemple précédent, nous avons décoré notre fonction en remplaçant la variable contenant la fonction par une version enveloppée.
def decor(func):
def wrap():
print("= =========")
func()
print("==
return wrap
@decor
def print_text():
print("Hello world!")
print_text();
Output
Hello world!
Cela donne le même résultat que le code ci-dessus.
Une même fonction peut avoir plusieurs décorateurs.
Cas d’usage
Vous travaillez sur un système de facturation.
Le système a une fonction facture() déjà définie, qui prend le numéro de facture comme argument et
le sort.
Vous devez ajouter un décorateur pour la fonction facture(), qui imprimera la facture au format suivant :
42
***
★★★
Sample Output
INVOICE #42
==”)
Le code donné prend le numéro de facture en entrée et le transmet à la fonction facture().
def decor(func):
def wrap(num):
print("***")
func(num)
print("***")
print("END OF PAGE")
return wrap
@decor
def invoice(num):
print("INVOICE #" +num)
invoice(input());
Input
128
Output
*** INVOICE #128 ***
Récursivité
La récursivité est un concept très important en programmation fonctionnelle.
La partie fondamentale de la récursivité est l’auto-référence – les fonctions s’appelant elles-mêmes. Il est utilisé pour résoudre problèmes qui peuvent être décomposés en sous-problèmes plus faciles du même type.
Un exemple classique de fonction implémentée de manière récursive est la fonction factorielle, qui trouve le produit de tous les entiers positifs inférieurs à un nombre spécifié.
Par exemple, 5 ! (5 factoriel) est 5* 4 * 3 * 2 * 1 (120). Pour implémenter cela de manière récursive, notez que 5! = 5 * 4 !, 4 !
= 4*3 !, 3 ! = 3 * 2 !, et ainsi de suite. Généralement, n! = n* (n-1)!.
De plus, 1!= 1. C’est ce qu’on appelle le cas de base, car il peut être calculé sans effectuer plus factorielles.
def my min(*args):
return min(args)
print(my_min(8, 13, 4, 42, 120, 7))
4
Problème
Orthographe à l’envers
Étant donné une chaîne en entrée, utilisez la récursivité pour afficher chaque lettre des chaînes dans l’ordre inverse, sur une nouvelle ligne.
Sample Input
HELLO
Sample Output
O
L
L
E
H
Complétez la fonction récursive spell() pour produire le résultat attendu.
def spell(txt):
txt=txt[::-1]
for a in txt:
print (a)
txt = input()
spell(txt)
Input
awesome
Output
Autres articles
