Paramètres de fonction

9.1 Paramètres vs arguments

Les novices se mélangent souvent les pinceaux entre les termes « paramètres » et « arguments », mais leur différence est cruciale pour comprendre la programmation fonctionnelle.

Les paramètres sont des variables listées dans la définition d'une fonction. Ils représentent des noms que la fonction utilise pour faire référence aux valeurs qui lui sont passées. Les paramètres servent de « placeholders » pour les valeurs qui seront utilisées dans le corps de la fonction. Lorsque tu définis une fonction, tu décris ses paramètres.

def print_info(name, age):  # name et age — ce sont des paramètres
    print(f"Name: {name}, Age: {age}")        

Les arguments sont des valeurs concrètes ou des données passées à la fonction lors de son appel. Les arguments remplacent les paramètres lors de l'exécution de la fonction. Les arguments peuvent être des constantes, des variables, des expressions, ou même des résultats d'autres fonctions.

print_info("Alice", 30)  # "Alice" et 30 — ce sont des arguments 

Types d'arguments

1. Arguments positionnels : les valeurs sont passées dans l'ordre où les paramètres sont définis.
2. Arguments nommés : arguments passés à la fonction en utilisant le nom du paramètre, permettant qu'ils soient listés dans n'importe quel ordre après les arguments positionnels.
3. Arguments par défaut : lors de la définition d'une fonction, les paramètres peuvent se voir attribuer des valeurs par défaut.

Tu utilises déjà des arguments positionnels, et on verra les arguments nommés et les arguments par défaut dans les prochains cours.

La différence entre paramètres et arguments en Python aide à comprendre comment les fonctions reçoivent et traitent les données. Cette distinction est importante pour créer des fonctions flexibles qui peuvent être facilement adaptées à différents scénarios d'appel, rendant ton code plus modulaire et réutilisable.

9.2 Valeurs par défaut

Les arguments par défaut en Python sont un mécanisme qui permet aux fonctions de spécifier à l'avance des valeurs prédéfinies pour un ou plusieurs paramètres. Cette possibilité rend l'appel d'une fonction plus pratique et flexible, car elle ne nécessite pas d'indiquer explicitement tous les arguments à chaque appel de fonction.

Définition des arguments par défaut

Les arguments par défaut sont définis dans la définition de la fonction, où à la déclaration du paramètre, tu spécifies une valeur qui sera utilisée, si lors de l'appel de la fonction l'argument n'est pas transmis :

def print_info(name, company='Unknown'):
    print(f"Name: {name}, Company: {company}")

Dans cet exemple, company a pour valeur par défaut 'Unknown'.

• Simplification de l'appel de fonctions: Les fonctions avec de nombreux paramètres peuvent être appelées en ne fournissant que les arguments les plus importants.
• Flexibilité: Les fonctions peuvent être adaptées à différents scénarios d'utilisation sans changer leur code.
• Lisibilité du code: Spécifier explicitement les valeurs par défaut rend le code auto-documenté.

Points importants

Immutabilité : Les valeurs par défaut pour les arguments doivent être des types de données immuables, tels que des nombres, des chaînes ou des tuples. L'utilisation de types modifiables (par exemple, des listes ou des dictionnaires) peut entraîner des effets secondaires indésirables en raison du fait que les modifications de ces objets sont conservées entre les appels de fonction.

Ordre des arguments : Les paramètres avec des arguments par défaut doivent suivre après les paramètres sans arguments par défaut dans la définition de la fonction.

Un autre exemple :

def create_user(username, is_admin=False):
    if is_admin:
        print(f"User {username} is an admin.")
    else:
        print(f"User {username} is a regular user.")
        
create_user("Alice")  # is_admin == False
create_user("Bob", is_admin=True)  # is_admin == True
create_user("Karl", True)  # is_admin == True

Ci-dessus sont montrés 3 façons d'appeler une fonction avec un argument par défaut : chacune d'entre elles fonctionne.

9.3 Passage de paramètres par nom

Passer des paramètres à une fonction par nom permet de spécifier plus clairement quelles valeurs sont passées à quels arguments, améliorant ainsi la lisibilité du code et réduisant la probabilité d'erreurs liées au mauvais ordre des arguments.

Pour passer une valeur de paramètre par nom, tu dois lors de l'appel de la fonction assigner une valeur à un paramètre spécifique :

fonction(paramètre1 = valeur, paramètre2 = valeur)

Cette méthode est particulièrement utile lors du travail avec des fonctions ayant de nombreux paramètres ou des paramètres avec des valeurs par défaut.

Avantages du passage de paramètres par nom

• Clarté et lisibilité : Indiquer le nom du paramètre lors de son appel rend le code plus clair pour d'autres développeurs ou lorsque tu reviens sur ton propre code ancien.
• Flexibilité : Les paramètres peuvent être passés dans n'importe quel ordre, ce qui est pratique lorsque la fonction a de nombreux paramètres.
• Éviter les erreurs : Il n'est pas nécessaire de se souvenir de l'ordre des paramètres de la fonction, ce qui réduit les probabilités d'erreurs liées à une mauvaise transmission des valeurs.

Exemples d'utilisation

def create_profile(name, age, job):
    print(f"Name: {name}")
    print(f"Age: {age}")
    print(f"Job: {job}")
        
create_profile(name = "John", age = 28, job = "Developer")

Dans cet exemple, les paramètres ne sont pas passés dans l'ordre, mais chacun d'eux reçoit explicitement une valeur, rendant l'appel de fonction plus flexible et compréhensible.

Exemple 2 :

D'ailleurs, tu as déjà rencontré le passage de paramètres par nom auparavant. Dans la fonction print(), tu te souviens ?

Caractéristiques et limitations

Les paramètres passés par nom doivent suivre après les paramètres sans nom, s'il y en a dans la définition de la fonction.

Il n'est pas possible d'utiliser le même nom de paramètre plus d'une fois lors de l'appel de la fonction.

Le passage de paramètres par nom est une puissante fonctionnalité de Python qui rend le code plus sûr et compréhensible, surtout lorsqu'il s'agit de fonctions avec de nombreux arguments ou des valeurs optionnelles.