Skip to main content
Niveau : Intermédiaire

Chapitre 15 : Les Fonctions

def, return, Arguments, Portée

1. Quoi : Les Fonctions​

Une fonction est un bloc de code réutilisable qui effectue une action spécifique. Les fonctions permettent de structurer le code en le décomposant en tâches plus petites et plus gérables.

Une fonction peut :

  • Prendre des paramètres (ou arguments) en entrée.
  • Effectuer une série d'opérations.
  • Retourner une valeur en sortie.

2. Pourquoi : Le Principe DRY (Don't Repeat Yourself)​

Les fonctions sont au cœur du principe DRY ("Ne vous répétez pas").

  • Réutilisabilité : Au lieu de copier-coller le même code à plusieurs endroits, vous l'écrivez une seule fois dans une fonction et l'appelez autant de fois que nécessaire.
  • Modularité : Elles décomposent un problème complexe en sous-problèmes plus simples. Chaque fonction a une responsabilité unique.
  • Lisibilité : Un code bien structuré avec des fonctions aux noms clairs est beaucoup plus facile à lire et à comprendre.
  • Maintenance : Si vous devez corriger un bug ou modifier une logique, vous ne le faites qu'à un seul endroit : dans la fonction elle-même.

3. Comment : Définir et Appeler une Fonction​

A. Définition et Appel​

  • On définit une fonction avec le mot-clé def, suivi du nom de la fonction, de parenthèses () et de deux-points :.
  • Le code à l'intérieur de la fonction doit être indenté.
  • On appelle la fonction en utilisant son nom suivi des parenthèses.
# Définition de la fonction
def greet():
    print("Hello, World!")

# Appel de la fonction
greet() # Affiche "Hello, World!"
greet() # Affiche "Hello, World!"

B. Paramètres et Arguments​

  • Un paramètre est la variable listée à l'intérieur des parenthèses dans la définition de la fonction.
  • Un argument est la valeur qui est envoyée à la fonction lorsque vous l'appelez.
# 'name' est un paramètre
def greet_user(name):
    print(f"Hello, {name}!")

# "Alice" et "Bob" sont des arguments
greet_user("Alice") # Affiche "Hello, Alice!"
greet_user("Bob")   # Affiche "Hello, Bob!"

C. L'instruction return​

L'instruction return est utilisée pour qu'une fonction renvoie une valeur. Lorsqu'une instruction return est exécutée, la fonction se termine immédiatement.

Une fonction qui ne contient pas d'instruction return renvoie implicitement None.

# Cette fonction prend deux nombres et retourne leur somme
def add(a, b):
    result = a + b
    return result

# On appelle la fonction et on stocke la valeur de retour dans une variable
sum_result = add(5, 3)
print(sum_result) # Affiche 8

D. Paramètres par Défaut​

Vous pouvez assigner une valeur par défaut à un paramètre. Si un argument pour ce paramètre n'est pas fourni lors de l'appel, la valeur par défaut sera utilisée.

Les paramètres avec une valeur par défaut doivent être placés après les paramètres sans valeur par défaut.

def greet_with_message(name, message="Welcome"):
    print(f"{message}, {name}!")

greet_with_message("Alice") # Utilise la valeur par défaut -> "Welcome, Alice!"
greet_with_message("Bob", "Good morning") # Fournit une valeur -> "Good morning, Bob!"

E. Arguments Nommés (Keyword Arguments)​

Lorsque vous appelez une fonction, vous pouvez spécifier les arguments par leur nom. Cela améliore la lisibilité et vous permet de ne pas vous soucier de l'ordre des arguments.

def create_user(name, age, is_admin):
    print(f"Creating user {name}, age {age}, admin status: {is_admin}")

# Appel avec des arguments positionnels (l'ordre compte)
create_user("Alice", 30, False)

# Appel avec des arguments nommés (l'ordre ne compte pas)
create_user(age=30, is_admin=False, name="Alice")

F. Docstrings (Chaînes de Documentation)​

C'est une bonne pratique d'inclure une chaîne de caractères (docstring) juste après la ligne de définition de la fonction pour expliquer ce qu'elle fait.

def calculate_area(radius):
    """
    Calculates the area of a circle given its radius.

    Args:
        radius (float): The radius of the circle.

    Returns:
        float: The area of the circle.
    """
    pi = 3.14159
    return pi * (radius ** 2)

# Les outils et les IDE peuvent afficher cette documentation.
help(calculate_area)

4. Portée des Variables (Scope)​

  • Variable locale : Une variable créée à l'intérieur d'une fonction n'est accessible qu'à l'intérieur de cette fonction.
  • Variable globale : Une variable créée à l'extérieur de toute fonction est globale et peut être lue de n'importe où dans le script.
global_var = "I am global"

def my_function():
    local_var = "I am local"
    print(global_var) # OK pour lire une variable globale
    print(local_var)

my_function()
# print(local_var) # ❌ Erreur ! NameError: name 'local_var' is not defined

✅ Bonne pratique : Les fonctions doivent, autant que possible, dépendre de leurs paramètres d'entrée plutôt que de variables globales. Cela les rend plus autonomes et plus faciles à tester.

Exercices :​

Exercice 15 - Validateur de Mot de Passe​

Objectif​

Cet exercice a pour but de vous faire créer une fonction qui prend un mot de passe en entrée et retourne un booléen (True/False) indiquant s'il respecte un ensemble de règles de validation.

Contexte​

Vous devez implémenter une fonction de validation pour un formulaire d'inscription. Un mot de passe est considéré comme valide s'il respecte toutes les règles suivantes :

  1. Il doit faire au moins 8 caractères de long.
  2. Il doit contenir au moins une lettre majuscule.
  3. Il doit contenir au moins un chiffre.

Énoncé​

  1. Créez un nouveau fichier Python nommé password_validator.py.

  2. Définissez une fonction nommée is_password_valid qui accepte un seul paramètre, password.

    • N'oubliez pas d'ajouter une docstring pour expliquer ce que fait la fonction.

  3. À l'intérieur de la fonction, implémentez la logique de validation : a. Vérifiez la longueur : La première condition est de vérifier si len(password) est supérieur ou égal à 8. Si ce n'est pas le cas, la fonction peut immédiatement retourner False.

    b. Vérifiez la présence d'une majuscule et d'un chiffre :

    • Initialisez deux variables booléennes, has_upper et has_digit, à False.
    • Utilisez une boucle for pour itérer sur chaque char du password. - Dans la boucle, utilisez les méthodes de chaînes de caractères .isupper() et .isdigit() pour vérifier la nature du caractère.
    • Si vous trouvez une majuscule, passez has_upper à True.
    • Si vous trouvez un chiffre, passez has_digit à True.

    c. Retournez le résultat final : Après la boucle, la fonction doit retourner le résultat de l'expression has_upper and has_digit. Si les deux sont True (et que la condition de longueur a été passée), le mot de passe est valide.

  4. Testez votre fonction :

    • À l'extérieur de la fonction, créez une liste de mots de passe à tester.
    • Utilisez une boucle for pour appeler votre fonction is_password_valid sur chaque mot de passe et affichez le résultat de manière claire.

Résultat Attendu​

Testing 'short': False
Testing 'longpasswordwithoutdigits': False
Testing 'LongPasswordWithoutDigits': False
Testing 'longpasswordwith123': False
Testing 'ValidPass1': True
Testing 'AnotherValidPassword2': True
Cliquez ici pour voir un exemple de code de solution
# password_validator.py

def is_password_valid(password):
    """
    Checks if a password meets the required criteria.

    A valid password must:
    1. Be at least 8 characters long.
    2. Contain at least one uppercase letter.
    3. Contain at least one digit.

    Args:
        password (str): The password to validate.

    Returns:
        bool: True if the password is valid, False otherwise.
    """
    # 1. Vérification de la longueur
    if len(password) < 8:
        return False

    # 2. Initialisation des "drapeaux"
    has_upper = False
    has_digit = False

    # 3. Itération pour trouver une majuscule et un chiffre
    for char in password:
        if char.isupper():
            has_upper = True
        elif char.isdigit():
            has_digit = True

    # Optimisation : si on a déjà trouvé les deux, on peut arrêter la boucle
    # if has_upper and has_digit:
    #     break

    # 4. Retourner le résultat final
    return has_upper and has_digit

# --- Zone de test ---
passwords_to_test = [
    "short",
    "longpasswordwithoutdigits",
    "LongPasswordWithoutDigits",
    "longpasswordwith123",
    "ValidPass1",
    "AnotherValidPassword2"
]