Fonctions

Leverage the power of code recycling with functions. For interactive reading and executing code blocks and find b04-pyfun.ipynb, or install Python and JupyterLab locally.

Quelles sont les fonctions?¶

Les fonctions sont un moyen pratique de diviser le code en blocs pratiques, réutilisables et plus lisibles, ce qui aide à structurer le code. Les blocs de fonctions peuvent accepter des arguments paramétriques et sont réutilisables. Ainsi, les fonctions sont un élément clé pour le partage du code et le travail en équipe. La structure de base d’une fonction Python implique:

• Un mot-clé def suivi d’un nom de fonction avec arguments entre parenthèses et un bloc de code.

• Le type de arguments qu’une fonction peut recevoir sont :

  • arguments requis: arg

  • Paramètres de mots clés par défaut (avec valeurs par défaut) : arg=value

  • arguments facultatifs: *args

  • Mot-clé facultatif : **kwargs

L’utilisation d’arguments optionnels (mot clé) rend les fonctions plus robustes et flexibles. Le bloc de code d’une fonction est dentelé, similaire aux boucles:

Un exemple de base¶

Seuls quelques pays (notamment les États-Unis) utilisent encore des unités impériales dans la vie quotidienne, tandis que la plupart des pays utilisent le système international d’unités* (SI). Écrivons une fonction simple pour aider les utilisateurs d’unités impériales à convertir pieds (impériaux) en mètres (SI).

Dans l’exemple suivant, le nom de la fonction est feet_to_meter et la fonction accepte un argument, qui est feet. La fonction renvoie l’argument feet multiplié par un conversion_factor de 0.3048, qui correspond au facteur de conversion des pieds aux mètres. Dans cet exemple simple, la variable conversion_factor ne peut être modifiée externement et n’existe que dans l’espace namespace de la fonction.

Fonction Appels¶

Pour appeler une fonction, elle doit être définie avant l’appel. La fonction peut être définie dans le même script ou dans un autre script, qui peut ensuite être importé comme module (read more about modules and packages in the next section). Ensuite, nous pouvons appeler, par exemple, la fonction feet_to_meter définie ci-dessus comme suit:

Arguments facultatifs¶

Remplacer l’argument non facultatif feet dans la fonction ci-dessus par un argument facultatif *args permet de convertir autant de valeurs de longueur que la fonction reçoit. Les lignes suivantes expliquent étape par étape comment cela fonctionne.

1. Assurez-vous que quiconque comprend les paramètres d’entrée et de sortie de la fonction en ajoutant en ligne docstrings avec une paire de doubles apostrophes triples (""") qui englobe les paramètres d’entrée (:params parameter_name: definition) et le retour de la fonction (:output: definition).

2. Par défaut, nous supposerons que plusieurs valeurs sont fournies. Par conséquent, une liste appelée value_list est instantanée au début de la fonction, tandis que conversion_factor reste la même qu’avant.

3. A for-loop over *args identifie et traite les arguments fournis. Pourquoi une boucle ?
   Python collecte automatiquement *args dans un tuple, et donc, nous pouvons itérer sur *args, même si les valeurs fournies n’ont pas été passées comme une liste ou un tuple.

4. Dans le bloc de code try, la zone de référence comprend un énoncé try - except pour vérifier si les valeurs fournies (arguments) sont numériques et peuvent être converties en compteurs. Si le bloc try fonctionne avec succès, l’expression arg * conversion_factor ajoute l’argument converti arg à value_list.

5. Finalement, le mot-clé return retourne la liste de valeurs.

Avec la fonction nouvellement définie et plus flexible, nous pouvons maintenant appeler feet_to_meter avec autant d’arguments que nécessaire:

Mot-clé optionnel Arguments **kwargs¶

Dans les derniers paragraphes, nous avons rendu la fonction feet_to_meter plus flexible afin qu’elle puisse maintenant recevoir autant d’arguments que nécessaire. Jusqu’à présent, la variable interne conversion_factor ne peut pas être modifiée de l’extérieur de la fonction, ce qui limite la flexibilité. Par exemple, imaginons que nous écrivions cette fonction pour un historien. Dans le passé, les unités impériales étaient répandues dans de nombreuses cultures (p. ex. grecques, romaines ou chinoises) avec des définitions de longueur variant entre 0,250 m et 0,335 m. Cela signifie que l’historien aura besoin de flexibilité en ce qui concerne le facteur de conversion, alors que nous voulons toujours utiliser 0.3048 m comme valeur par défaut. Cette exigence peut être implémentée avec des arguments optionnels **kwargs et c’est ainsi que cela fonctionne dans le bloc de code ci-dessous:

1. Ajouter **kwargs après *args dans la fonction def parenthèses (l’ordre de *args, **kwargs est important).

2. Gardez conversion_factor = 0.3048 comme valeur par défaut (nous voulons que la fonction soit fonctionnelle aussi sans aucun argument de mot-clé fourni).

3. Comme pour l’instruction *args, Python identifie automatiquement les variables commençant par ** comme des arguments optionnels (en fait, le nom args et kwargs n’a pas d’importance - les signes * sont importants). La différence à *args est que Python identifie **kwargs comme un dictionnaire.

4. A for-loop itrates over the kwargs-dictionary et l’instruction if identifie tout paramètre de mot-clé optionnel qui contient la chaîne "conv" en tant que conversion factor.

5. A try- except statement teste si la valeur fournie pour l’argument clé est numérique en tentant une conversion à float().

Le reste de la fonction reste inchangé.

Tester différents facteurs de conversion avec la flexibilité nouvellement définie de la fonction feet_to_meter:

Arguments de mots clés par défaut¶

Les arguments de mots clés peuvent également être définis par défaut. L’exemple ci-dessous montre comment le conversion_factor peut être défini par défaut dans les parenthèses de la fonction def. Notez que conversion_factor doit être défini après tout argument optionnel *args.

Maintenant nous pouvons utiliser feet_to_meter avec ou sans ou avec un facteur de conversion et après une liste de valeurs:

Function Wrappers and Decorators¶

Si plusieurs fonctions contiennent des lignes similaires, il est probable que ces fonctions peuvent être davantage factorisées en utilisant des enveloppes de fonction et des décorateurs. Un exemple typique est une commande de licence (par exemple pour utiliser un module/paquet Python commercial, comme le arcpy d’Esri) ou si nous voulons utiliser une déclaration d’erreur récurrente avec try - except des déclarations.

Par exemple, envisagez deux ou plusieurs fonctions qui devraient recevoir, traiter et produire la sortie numérique à partir de l’entrée de l’utilisateur. Ces fonctions peuvent ressembler à ceci :

Les deux fonctions impliquent l’instruction print("The result is: " + str(result)) pour imprimer les résultats à la console Python (p. ex., pour obtenir des informations intermédiaires) et pour exécuter uniquement sur des entrées valides (c.-à-d. numériques) à l’aide d’une exception (try - except). Cependant, nous voulons que nos fonctions se concentrent uniquement sur le calcul et c’est là qu’une fonction d’emballage aide.

Une fonction d’emballage peut être définie en définissant d’abord une fonction standard (par exemple, def verify_result) puis en passant une autre fonction (func) comme argument. Dans cette fonction (verify_result), nous pouvons alors placer une fonction imbriquée def wrapper() qui embrassera func. Il est important d’utiliser le mot-clé optionnel *args et le mot-clé optionnel **kwargs dans la fonction d’emballage et d’appeler func pour rendre l’emballage aussi flexible que possible.

Maintenant, nous pouvons utiliser un @-decorator pour envelopper les fonctions de mathématiques ci-dessus dans la fonction verify_result(fun). Lorsque Python lit le beau signe @, il recherche automatiquement la fonction d’emballage définie après le signe @ pour envelopper la fonction suivante.

Les deux fonctions (multiply_arguments et sum_up_arguments) peuvent être appelées comme d’habitude, par exemple :

La fonction wrapper ci-dessus renvoie aussi les résultats de la fonction enveloppée. Cependant, pour utiliser des attributs de fonction intégrés (par exemple, le nom de la fonction avec __name__, le docstring de la fonction avec __doc__, ou le module dans lequel la fonction est définie avec __module__) en dehors de l’emballage, nous avons besoin de la fonction d’emballage pour retourner la fonction enveloppée (décorée) elle-même. Cela peut se faire comme suit:

Notez la différence : la fonction wrapper retourne maintenant func(*arg, **kwargs) au lieu des variables numériques en conséquence. Si la fonction ne peut pas être exécutée à cause d’une entrée non valide, l’emballage retourne une fonction d’erreur (error_func), ce qui assure la cohérence de la fonction d’emballage. On peut penser que la fonction d’erreur renvoyant 0.0 est obsolète car les instructions d’exception pourraient directement retourner 0.0. Cependant, 0.0 est une variable float, alors que error_func est une fonction et que l’emballage de la fonction doit toujours retourner le même type de données, indépendamment d’une augmentation d’exception (erreur) ou d’une exécution réussie. C’est ce qui rend le code cohérent.

Ce paragraphe montre des exemples d’utilisation des décorateurs sous la forme d’un signe @ pour envelopper (embrace) une fonction. Les décorateurs sont également une fonctionnalité utile dans les classes Python, par exemple, quand une fonction de classe retourne des valeurs statiques. En savoir plus sur les décorateurs dans les cours plus tard dans le chapitre sur object orientation and classes.

Itérateurs et générateurs¶

Une caractéristique des types de données list, tuple et dictionnaire est leur itérabilité, qui est fournie par leur méthode intégrée __iter__. Ainsi, l’itérérabilité est la raison pour laquelle nous pouvons écrire:

Outre les itérations, Python permet également la création de générateurs (c.-à-d. fonctions de générateur). Au lieu d’utiliser une déclaration return, une fonction de générateur se termine par une déclaration yield, qui retourne les données tant qu’une fonction next() (étape inhérente dans les itérations) est appelée. Une application d’un générateur est, par exemple, l’aplatissement des listes imbriquées (c.-à-d., supprimer les sous-listes et écrire toutes les variables directement dans une liste non-négative) :

Fonctions Lambda¶

Lambda (λ) calcul est un langage formel pour exprimer l’abstraction de fonction basée sur le calcul et a été introduit dans les années 1930 par l’église Alonzo mathématicien. Les fonctions Lambda proviennent de la programmation fonctionnelle et représentent des fonctions courtes et anonymes (sans nom). Bien que le Python ne soit pas intrinsèquement un langage de programmation fonctionnelle, des concepts fonctionnels ont été mis en œuvre au début du Python, par exemple avec les fonctions map(), filter() et reduce() et aussi l’opérateur lambda.

Dans Python, une fonction anonyme (sans nom) lambda peut prendre n’importe quel nombre d’arguments, mais ne peut avoir qu’une seule expression. Les arguments consistent en une liste de variables séparées par des virgules et l’expression utilise ces arguments. Les fonctions syntax de lambda sont :

lambda arguments : expression

L’exemple suivant illustre une fonction lambda avec un seul argument et ajoute 1 à l’argument :

C’était gentil mais tout à fait inutile. Voici un exemple d’une fonction lambda un peu plus utile qui résume deux arguments d’entrée:

La fonction ci-dessus montrée pour convertir les pieds en mètres peut également être écrite comme une fonction lambda:

Grâce à une fonction lambda, le code est plus court et plus efficace. De plus, pour évaluer la fonction feet_to_meter lambda pour plusieurs valeurs, nous pouvons utiliser la fonction map(). La syntaxe d’une fonction map() est :

result = map(function, sequence)

où sequence peut être une list ou un tuple. Ainsi, pour évaluer un tuple de quatre valeurs, nous pouvons écrire:

La fonction list() convertit la sortie map() en une list pour évaluer la fonction map() (autrement, le résultat serait quelque chose comme <map object at ...>).

Si la fonction feet_to_meter n’est pas nécessaire à un autre endroit du code, on peut aussi écrire :

Une autre caractéristique de Python est la fonction filter(function, list) qui représente une solution élégante pour filtrer ces éléments d’une liste pour laquelle la fonction retourne True. Le bloc de code suivant illustre un filter qui élimine tous les numéros d’une liste some_numbers, qui peut être divisée par trois.

Auparavant, la fonction reduce() pour fusionner l’entrée de liste vers le bas en une seule valeur a été implémentée dans Python. Cependant, l’auteur original de Python Guido van Rossum l’a retiré de l’espace de noms intégré dans Python 3 — il vit maintenant à functools.reduce (lire son post), ce qui explique pourquoi il n’est pas présenté ici comme un élément intégré.

Vérification de la réussite en apprentissage¶

Prenez le test de réussite d’apprentissage pour ce carnet Jupyter.

Unfold QR Code