Fonctions 🧩

Qu'est-ce qu'une fonction ? 🤔

Une fonction est un bloc de code nomme qu'on peut appeler (reutiliser) autant de fois que necessaire. C'est comme une recette : tu la definis une fois, et tu l'utilises quand tu veux.

💡 Les fonctions permettent de DRY (Don't Repeat Yourself) — ne jamais repeter le meme code deux fois.

---

Definir une fonction avec def 🏗️

def dire_bonjour():
    """Affiche un message de bienvenue."""
    print("Bonjour le monde ! 👋")
    print("Bienvenue dans mon programme.")

# Appel de la fonction
dire_bonjour()
dire_bonjour()  # On peut l'appeler autant de fois qu'on veut

---

Parametres et arguments 📦

def saluer(prenom, age):
    print(f"Bonjour {prenom}, tu as {age} ans !")

saluer("Alice", 25)    # prenom="Alice", age=25
saluer(age=30, prenom="Bob")  # Mots-cles : l'ordre n'importe pas

Arguments positionnels vs mots-cles

def creer_profil(nom, age, ville):
    print(f"{nom}, {age} ans, habite a {ville}")

# Positionnel : l'ordre compte
creer_profil("Alice", 25, "Paris")

# Mot-cle : l'ordre n'importe pas
creer_profil(ville="Lyon", nom="Bob", age=30)

---

Valeur de retour avec return 📤

def additionner(a, b):
    """Retourne la somme de deux nombres."""
    return a + b

resultat = additionner(3, 7)
print(resultat)  # 10

Plusieurs valeurs retournees

def min_max(liste):
    return min(liste), max(liste)

minimum, maximum = min_max([3, 1, 4, 1, 5, 9])
print(f"Min: {minimum}, Max: {maximum}")  # Min: 1, Max: 9

Fonction sans return

def afficher_message(msg):
    print(msg)
    # Pas de return -> retourne implicitement None

resultat = afficher_message("Hello")
print(resultat)  # None

---

Arguments par defaut 🎚️

def saluer(prenom, message="Bonjour"):
    print(f"{message} {prenom} !")

saluer("Alice")              # "Bonjour Alice !"
saluer("Bob", "Salut")       # "Salut Bob !"

⚠️ Les parametres avec valeur par defaut doivent etre apres les parametres sans valeur par defaut.

---

*args et **kwargs 🔧

*args — arguments positionnels variables

def moyenne(*nombres):
    """Calcule la moyenne d'un nombre variable d'arguments."""
    return sum(nombres) / len(nombres)

print(moyenne(10, 15, 20))       # 15.0
print(moyenne(10, 15, 20, 25))   # 17.5

💡 *args collecte tous les arguments positionnels supplementaires dans un tuple.

**kwargs — arguments mots-cles variables

def profil(**infos):
    for cle, valeur in infos.items():
        print(f"{cle}: {valeur}")

profil(nom="Alice", age=25, ville="Paris")
# nom: Alice
# age: 25
# ville: Paris

💡 **kwargs collecte tous les arguments mots-cles dans un dictionnaire.

Les deux ensemble

def tout(a, b, *args, **kwargs):
    print(f"a={a}, b={b}")
    print(f"args={args}")
    print(f"kwargs={kwargs}")

tout(1, 2, 3, 4, nom="Alice", age=25)
# a=1, b=2
# args=(3, 4)
# kwargs={'nom': 'Alice', 'age': 25}

---

Portee des variables 🌍

globale = "je suis globale"

def ma_fonction():
    locale = "je suis locale"
    print(globale)   # On peut lire une variable globale
    print(locale)    # On peut lire une variable locale

ma_fonction()
print(globale)       # OK
# print(locale)      # NameError

compteur = 0

def incrementer():
    global compteur
    compteur += 1

incrementer()
incrementer()
print(compteur)  # 2

📌 Bonne pratique : Evite global autant que possible.

---

Fonctions lambda (anonymes) 🎭

# Fonction classique
def doubler(x):
    return x * 2

# Equivalente lambda
doubler = lambda x: x * 2
print(doubler(5))  # 10

Utilisation principale : tri et fonctions d'ordre superieur

# Trier des tuples par le deuxieme element
etudiants = [("Alice", 15), ("Bob", 18), ("Charlie", 12)]
etudiants.sort(key=lambda e: e[1])
print(etudiants)  # [('Charlie', 12), ('Alice', 15), ('Bob', 18)]

# Filtrer
nombres = [1, 2, 3, 4, 5, 6, 7, 8]
impairs = list(filter(lambda x: x % 2 != 0, nombres))
print(impairs)  # [1, 3, 5, 7]

# Mapper
carres = list(map(lambda x: x ** 2, nombres))
print(carres)  # [1, 4, 9, 16, 25, 36, 49, 64]

---

Diagramme d'execution 🔄

---

Bonnes pratiques ✅

# 1. Nommer clairement
def calculer_moyenne(notes):  # ✅
    pass

def calc(n):  # ❌ Trop court
    pass

# 2. Une fonction = une responsabilite

# 3. Limiter les parametres (max 3-4)

# 4. Documenter les fonctions publiques
def calculer_imc(poids_kg, taille_m):
    """
    Calcule l'indice de masse corporelle.
    
    Args:
        poids_kg: Poids en kilogrammes
        taille_m: Taille en metres
    
    Returns:
        float: L'IMC calcule
    """
    return poids_kg / (taille_m ** 2)

---

Exercice pour toi 🎯

# Exercice 1 : Fonction maximum
def trouver_max(a, b, c):
    max_val = a
    if b > max_val:
        max_val = b
    if c > max_val:
        max_val = c
    return max_val

print(trouver_max(3, 7, 5))   # 7

# Exercice 2 : Fonction qui inverse une chaine
def inverser_chaine(texte):
    resultat = ""
    for i in range(len(texte) - 1, -1, -1):
        resultat += texte[i]
    return resultat

print(inverser_chaine("Python"))  # "nohtyP"

# Exercice 3 : Fonction avec *args
def somme(*nombres):
    total = 0
    for n in nombres:
        total += n
    return total

print(somme(1, 2, 3, 4, 5))  # 15

💡 Regle d'or : Si tu copie-colles du code plus de 2 fois, c'est le moment de creer une fonction !