- Fonctions d'ordre supérieur
Fonctions d'ordre supérieur
En Python, les fonctions sont traitées comme des citoyens de première classe, ce qui permet d'effectuer les opérations suivantes sur les fonctions :
- Une fonction peut prendre une ou plusieurs fonctions comme paramètres
- Une fonction peut être retournée comme résultat d'une autre fonction
- Une fonction peut être modifiée
- Une fonction peut être assignée à une variable
Dans cette section, nous aborderons :
- La manipulation des fonctions comme paramètres
- Le retour de fonctions comme valeur de retour depuis d'autres fonctions
- L'utilisation des fermetures et décorateurs Python
Fonction comme paramètre
def sum_numbers(nums): # fonction normale
return sum(nums) # une fonction simple utilisant la fonction intégrée sum
def higher_order_function(f, lst): # fonction comme paramètre
summation = f(lst)
return summation
result = higher_order_function(sum_numbers, [1, 2, 3, 4, 5])
print(result) # 15
Fonction comme valeur de retour
def square(x): # une fonction carré
return x ** 2
def cube(x): # une fonction cube
return x ** 3
def absolute(x): # une fonction valeur absolue
if x >= 0:
return x
else:
return -(x)
def higher_order_function(type): # une fonction d'ordre supérieur retournant une fonction
if type == 'square':
return square
elif type == 'cube':
return cube
elif type == 'absolute':
return absolute
result = higher_order_function('square')
print(result(3)) # 9
result = higher_order_function('cube')
print(result(3)) # 27
result = higher_order_function('absolute')
print(result(-3)) # 3
Vous pouvez voir dans l'exemple ci-dessus que la fonction d'ordre supérieur retourne différentes fonctions selon le paramètre passé.
Fermetures Python
Python permet à une fonction imbriquée d'accéder à la portée externe de la fonction englobante. C'est ce qu'on appelle une fermeture (closure). Voyons comment les fermetures fonctionnent en Python. En Python, une fermeture est créée en imbriquant une fonction à l'intérieur d'une autre fonction encapsulante, puis en retournant la fonction interne. Voir l'exemple ci-dessous.
Exemple :
def add_ten():
ten = 10
def add(num):
return num + ten
return add
closure_result = add_ten()
print(closure_result(5)) # 15
print(closure_result(10)) # 20
Décorateurs Python
Un décorateur est un patron de conception en Python qui permet d'ajouter de nouvelles fonctionnalités à un objet existant sans modifier sa structure. Les décorateurs sont généralement appelés avant la définition de la fonction que vous souhaitez décorer.
Créer des décorateurs
Pour créer une fonction décoratrice, nous avons besoin d'une fonction externe avec une fonction wrapper interne.
Exemple :
# Fonction normale
def greeting():
return 'Bienvenue à Python'
def uppercase_decorator(function):
def wrapper():
func = function()
make_uppercase = func.upper()
return make_uppercase
return wrapper
g = uppercase_decorator(greeting)
print(g()) # BIENVENUE À PYTHON
## Implémentons l'exemple ci-dessus avec un décorateur
'''Cette fonction décoratrice est une fonction d'ordre supérieur
qui prend une fonction comme paramètre'''
def uppercase_decorator(function):
def wrapper():
func = function()
make_uppercase = func.upper()
return make_uppercase
return wrapper
@uppercase_decorator
def greeting():
return 'Bienvenue à Python'
print(greeting()) # BIENVENUE À PYTHON
Appliquer plusieurs décorateurs à une seule fonction
'''Ces fonctions décoratrices sont des fonctions d'ordre supérieur
qui prennent des fonctions comme paramètres'''
# Premier décorateur
def uppercase_decorator(function):
def wrapper():
func = function()
make_uppercase = func.upper()
return make_uppercase
return wrapper
# Deuxième décorateur
def split_string_decorator(function):
def wrapper():
func = function()
splitted_string = func.split()
return splitted_string
return wrapper
# Les décorateurs sont exécutés de bas en haut
@split_string_decorator
@uppercase_decorator # l'ordre des décorateurs est important dans ce cas - .upper() ne fonctionne pas avec les listes
def greeting():
return 'Bienvenue à Python'
print(greeting()) # ['BIENVENUE', 'À', 'PYTHON']
Accepter des paramètres dans les fonctions décoratrices
La plupart du temps, nous avons besoin que nos fonctions prennent des paramètres, nous devons donc définir un décorateur qui accepte des paramètres.
def decorator_with_parameters(function):
def wrapper_accepting_parameters(para1, para2, para3):
function(para1, para2, para3)
print("Je vis à {}".format(para3))
return wrapper_accepting_parameters
@decorator_with_parameters
def print_full_name(first_name, last_name, country):
print("Je suis {} {}. J'aime enseigner.".format(
first_name, last_name))
print_full_name("Asabeneh", "Yetayeh",'Finland')
Fonctions d'ordre supérieur intégrées
Parmi les fonctions d'ordre supérieur intégrées que nous abordons dans cette partie, on trouve map(), filter et reduce. Une fonction lambda peut être passée comme paramètre et le meilleur cas d'utilisation des fonctions lambda est dans des fonctions comme map, filter et reduce.
Python - Fonction Map
La fonction map() est une fonction intégrée qui prend une fonction et un itérable comme paramètres.
# syntax
map(function, iterable)
Exemple 1 :
numbers = [1, 2, 3, 4, 5] # itérable
def square(x):
return x ** 2
numbers_squared = map(square, numbers)
print(list(numbers_squared)) # [1, 4, 9, 16, 25]
# Appliquons-la avec une fonction lambda
numbers_squared = map(lambda x : x ** 2, numbers)
print(list(numbers_squared)) # [1, 4, 9, 16, 25]
Exemple 2 :
numbers_str = ['1', '2', '3', '4', '5'] # itérable
numbers_int = map(int, numbers_str)
print(list(numbers_int)) # [1, 2, 3, 4, 5]
Exemple 3 :
names = ['Asabeneh', 'Lidiya', 'Ermias', 'Abraham'] # itérable
def change_to_upper(name):
return name.upper()
names_upper_cased = map(change_to_upper, names)
print(list(names_upper_cased)) # ['ASABENEH', 'LIDIYA', 'ERMIAS', 'ABRAHAM']
# Appliquons-la avec une fonction lambda
names_upper_cased = map(lambda name: name.upper(), names)
print(list(names_upper_cased)) # ['ASABENEH', 'LIDIYA', 'ERMIAS', 'ABRAHAM']
Ce que fait réellement map, c'est itérer sur une liste. Par exemple, elle met les noms en majuscules et retourne une nouvelle liste.
Python - Fonction Filter
La fonction filter() appelle la fonction spécifiée qui retourne un booléen pour chaque élément de l'itérable spécifié (liste). Elle filtre les éléments qui satisfont les critères de filtrage.
# syntax
filter(function, iterable)
Exemple 1 :
# Filtrons uniquement les nombres pairs
numbers = [1, 2, 3, 4, 5] # itérable
def is_even(num):
if num % 2 == 0:
return True
return False
even_numbers = filter(is_even, numbers)
print(list(even_numbers)) # [2, 4]
Exemple 2 :
numbers = [1, 2, 3, 4, 5] # itérable
def is_odd(num):
if num % 2 != 0:
return True
return False
odd_numbers = filter(is_odd, numbers)
print(list(odd_numbers)) # [1, 3, 5]
# Filtrer les noms longs
names = ['Asabeneh', 'Lidiya', 'Ermias', 'Abraham'] # itérable
def is_name_long(name):
if len(name) > 7:
return True
return False
long_names = filter(is_name_long, names)
print(list(long_names)) # ['Asabeneh']
Python - Fonction Reduce
La fonction reduce() est définie dans le module functools et nous devons l'importer depuis ce module. Comme map et filter, elle prend deux paramètres : une fonction et un itérable. Cependant, elle ne retourne pas un autre itérable, mais une valeur unique.
Exemple 1 :
numbers_str = ['1', '2', '3', '4', '5'] # itérable
def add_two_nums(x, y):
return int(x) + int(y)
total = reduce(add_two_nums, numbers_str)
print(total) # 15
💻 Exercices : Jour 14
countries = ['Estonia', 'Finland', 'Sweden', 'Denmark', 'Norway', 'Iceland']
names = ['Asabeneh', 'Lidiya', 'Ermias', 'Abraham']
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Exercices : Niveau 1
- Expliquez la différence entre map, filter et reduce.
- Expliquez la différence entre fonction d'ordre supérieur, fermeture et décorateur.
- Définissez une fonction d'appel avant map, filter ou reduce, voir les exemples.
- Utilisez une boucle for pour afficher chaque pays dans la liste countries.
- Utilisez une boucle for pour afficher chaque nom dans la liste names.
- Utilisez une boucle for pour afficher chaque nombre dans la liste numbers.
Exercices : Niveau 2
- Utilisez map pour créer une nouvelle liste en mettant chaque pays en majuscules dans la liste countries.
- Utilisez map pour créer une nouvelle liste en convertissant chaque nombre en son carré dans la liste numbers.
- Utilisez map pour mettre chaque nom en majuscules dans la liste names.
- Utilisez filter pour filtrer les pays contenant 'land'.
- Utilisez filter pour filtrer les pays ayant exactement six caractères.
- Utilisez filter pour filtrer les pays contenant six lettres ou plus dans la liste countries.
- Utilisez filter pour filtrer les pays commençant par 'E'.
- Enchaînez deux itérateurs de liste ou plus (ex. arr.map(callback).filter(callback).reduce(callback)).
- Déclarez une fonction appelée get_string_lists qui prend une liste en paramètre et retourne une liste contenant uniquement les éléments de type chaîne.
- Utilisez reduce pour additionner tous les nombres de la liste numbers.
- Utilisez reduce pour concaténer tous les pays et produire cette phrase : Estonie, Finlande, Suède, Danemark, Norvège et Islande sont des pays d'Europe du Nord.
- Déclarez une fonction appelée categorize_countries qui retourne une liste de pays ayant un motif commun (vous pouvez trouver la liste des pays dans ce dépôt sous countries.js (ex. 'land', 'ia', 'island', 'stan')).
- Créez une fonction retournant un dictionnaire, où les clés représentent les lettres de début des pays et les valeurs sont le nombre de noms de pays commençant par cette lettre.
- Déclarez une fonction get_first_ten_countries - elle retourne une liste des dix premiers pays de la liste countries.js dans le dossier data.
- Déclarez une fonction get_last_ten_countries qui retourne les dix derniers pays de la liste countries.
Exercices : Niveau 3
- Utilisez le fichier countries_data.py (https://github.com/Asabeneh/30-Days-Of-Python/blob/master/data/countries-data.py) et suivez les tâches ci-dessous :
- Triez les pays par nom, par capitale, par population.
- Triez les dix langues les plus parlées par emplacement.
- Triez les dix pays les plus peuplés.
🎉 FÉLICITATIONS ! 🎉