Fonctions en Python

Cet article explique les fonctions en Python.

YouTube Video

Fonctions en Python

Les fonctions en Python sont une fonctionnalité essentielle pour définir des blocs de code réutilisables, vous permettant d'organiser et de simplifier votre programme en les appelant au besoin. L'utilisation des fonctions peut améliorer la lisibilité du code et respecter le principe DRY (Don't Repeat Yourself, évitez de réécrire plusieurs fois le même code).

Définir des fonctions

Les fonctions sont définies à l'aide du mot-clé def. La syntaxe de base est la suivante :.

1def function_name(arg1, arg2, ..., argN):
2    """docstring (A brief description of the function)"""
3    processing
4    return return_value

Par exemple, pour définir une fonction qui additionne deux nombres, vous écririez :.

1def add(x, y):
2    """A function that adds two numbers and returns the result"""
3    return x + y

Appeler des fonctions

Une fonction définie peut être appelée et utilisée comme suit :.

1result = add(3, 4)
2print(result)  # Output: 7

Composants d'une fonction

1. Nom de la fonction : Le nom de la fonction, utilisé pour l'appeler.

2. Arguments (paramètres) : Noms de variables qui reçoivent les données passées lors de l'appel. Vous pouvez définir zéro ou plusieurs arguments.

3. Chaîne de documentation (Docstring) : Une chaîne utilisée pour décrire l'objectif et l'utilisation d'une fonction. Optionnel.

4. Corps de la fonction : Un bloc indenté où sont écrites les instructions qu'exécute la fonction.

5. Valeur de retour : La valeur renvoyée à l'appelant à l'aide de l'instruction return. Si return est omis, None est renvoyé par défaut.

Types d'arguments

En Python, il existe plusieurs types d'arguments.

1. Arguments positionnels : La méthode standard de passage des arguments aux fonctions.
2. Arguments par défaut : Arguments avec des valeurs par défaut qui peuvent être omis lors de l'appel.

1def greet(name, message="Hello"):
2    print(f"{message}, {name}")
3
4greet("Alice")  # "Hello, Alice"
5greet("Bob", "Good morning")  # "Good morning, Bob"

3. Arguments de longueur variable : *args pour recevoir plusieurs arguments positionnels sous forme de tuple, et **kwargs pour les recevoir sous forme de dictionnaire.

1def func(*args, **kwargs):
2    print("args:", args)
3    print("kwargs:", kwargs)
4
5func(1, 2, 3, a=4, b=5)
6# Output:
7# args: (1, 2, 3)
8# kwargs: {'a': 4, 'b': 5}

En utilisant correctement les fonctions, vous pouvez écrire des programmes Python de manière plus efficace et efficiente.

Fonctions lambda en Python

En Python, les fonctions lambda sont utilisées pour définir des fonctions anonymes et concises. Contrairement aux fonctions définies avec le mot-clé def classique, lambda permet de créer des fonctions courtes et en une seule ligne. Ici, nous allons expliquer en détail les fonctions lambda en Python.

Les bases des fonctions lambda

Les fonctions lambda, aussi appelées fonctions anonymes, sont utilisées pour définir des fonctions temporaires sans nom, comme leur nom l'indique. La syntaxe de base est la suivante :.

1lambda arguments: expression

• arguments : Spécifiez les arguments de la fonction. Plusieurs arguments peuvent être spécifiés, séparés par des virgules.
• expression : C'est une expression qui est évaluée sur la base des arguments. Le résultat de l'expression devient la valeur de retour de la fonction.

Par exemple, le code suivant définit et exécute une fonction lambda qui additionne deux nombres.

1add = lambda x, y: x + y
2print(add(5, 3))  # Output: 8

Dans cet exemple, lambda x, y: x + y est une fonction lambda qui prend deux arguments, x et y, et renvoie leur somme.

Cas d'utilisation des fonctions lambda

Les fonctions lambda sont utiles dans les situations où vous devez définir une fonction simple sur le moment. Elles sont particulièrement courantes dans les cas suivants :.

1. Lorsqu'elles sont passées comme arguments aux fonctions

   • Il est utile dans les fonctions d'ordre supérieur (fonctions qui acceptent d'autres fonctions comme arguments) lors du passage de fonctions courtes et temporaires.

2. Lors de la spécification des clés pour trier des listes

   • Elles sont pratiques pour spécifier les critères de tri (clés) dans des fonctions comme sort() ou sorted().

Exemple d'utilisation dans des fonctions d'ordre supérieur

Des exemples typiques de fonctions d'ordre supérieur incluent map(), filter() et reduce(). Ces fonctions prennent d'autres fonctions en argument et les appliquent à des séquences comme des listes.

1numbers = [1, 2, 3, 4, 5]
2squared = list(map(lambda x: x ** 2, numbers))
3print(squared)  # Output: [1, 4, 9, 16, 25]

Dans cet exemple, une fonction lambda est passée à la fonction map() pour élever au carré chaque nombre d'une liste.

Exemples d'utilisation du tri de liste

La fonction lambda peut parfois être utilisée pour spécifier une clé personnalisée lors du tri d'une liste. Par exemple, le code suivant trie une liste de tuples en fonction du deuxième élément.

1pairs = [(1, 'one'), (2, 'two'), (3, 'three'), (4, 'four')]
2pairs.sort(key=lambda pair: pair[1])
3print(pairs)
4# Output: [(4, 'four'), (1, 'one'), (3, 'three'), (2, 'two')]

Dans cet exemple, une fonction lambda est utilisée pour trier les tuples en fonction de leur deuxième élément (une chaîne de caractères).

filter() et lambda

La fonction filter() est utilisée pour filtrer les éléments d'une liste (ou d'un autre itérable) selon une condition donnée.

1numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
2even_numbers = list(filter(lambda x: x % 2 == 0, numbers))
3print(even_numbers)  # Output: [2, 4, 6, 8]

Dans cet exemple, les nombres pairs d'une liste sont filtrés pour créer une nouvelle liste.

lambda et reduce()

La fonction reduce() est utilisée pour réduire une liste en une seule valeur. Cela peut être facilement mis en œuvre à l'aide d'une fonction lambda.

1from functools import reduce
2
3numbers = [1, 2, 3, 4, 5]
4product = reduce(lambda x, y: x * y, numbers)
5print(product)  # Output: 120

Dans cet exemple, tous les éléments de la liste sont multipliés ensemble pour produire un résultat.

Évitez d'utiliser des fonctions lambda complexes

L'avantage des fonctions lambda est leur concision, mais elles deviennent plus difficiles à lire lorsqu'elles sont utilisées pour implémenter une logique complexe. Par conséquent, elles sont appropriées pour des opérations simples pouvant être exprimées en une seule ligne. Pour les opérations complexes, il est plus lisible et maintenable de définir une fonction avec def.

Par exemple, vous devriez éviter d'utiliser des fonctions lambda complexes comme celle-ci.

1# Complex and hard-to-read lambda function
2complex_func = lambda x, y: (x * 2 + y) if x > y else (x + y * 2)

Dans ce cas, il est préférable d'utiliser une fonction définie avec def, comme indiqué ci-dessous.

1def complex_func(x, y):
2    if x > y:
3        return x * 2 + y
4    else:
5        return x + y * 2

Conclusion

Les fonctions lambda de Python sont un outil pratique pour définir des fonctions temporaires et courtes. Elles sont souvent utilisées dans des fonctions d'ordre supérieur ou des opérations sur les listes pour définir de manière concise des conditions spécifiques. Cependant, les fonctions lambda doivent être limitées à des tâches simples, les fonctions def étant préférées pour une logique complexe.

Vous pouvez suivre l'article ci-dessus avec Visual Studio Code sur notre chaîne YouTube. Veuillez également consulter la chaîne YouTube.

YouTube Video