TP Python - Les Fonctions

Durée estimée : 2-3 heures​

Niveau : Débutant avec bases acquises (variables, boucles, conditions)​
Focus : Fonctions uniquement

📚 PARTIE 0 : RAPPEL SUR LES FONCTIONS (30 min)

Pourquoi utiliser des fonctions ?

Imagine que tu dois calculer l'aire d'un rectangle plusieurs fois dans ton programme :

❌ SANS fonctions (code répétitif) :

# Calcul 1
longueur1 = 10
largeur1 = 5
aire1 = longueur1 * largeur1
print(f"Aire 1 : {aire1}")

# Calcul 2
longueur2 = 8
largeur2 = 3
aire2 = longueur2 * largeur2
print(f"Aire 2 : {aire2}")

# Calcul 3
longueur3 = 15
largeur3 = 7
aire3 = longueur3 * largeur3
print(f"Aire 3 : {aire3}")

✅ AVEC fonctions (code réutilisable) :

def calculer_aire(longueur, largeur):
aire = longueur * largeur
return aire

print(f"Aire 1 : {calculer_aire(10, 5)}")

print(f"Aire 2 : {calculer_aire(8, 3)}")
print(f"Aire 3 : {calculer_aire(15, 7)}")

Avantages :

🔄 Réutilisable : écris une fois, utilise partout

🧹 Plus propre : code organisé et lisible
●​

🐛 Facile à déboguer : un bug = un seul endroit à corriger

●​

👥 Travail d'équipe : chacun peut créer ses fonctions

●​
●​

1️⃣ Structure d'une fonction

def nom_de_la_fonction(parametre1, parametre2):
"""
Ceci est une docstring (documentation)
Elle explique ce que fait la fonction
"""
# Corps de la fonction
resultat = parametre1 + parametre2
return resultat

Décomposition :

●​ def : mot-clé pour définir une fonction

●​ nom_de_la_fonction : nom explicite (verbe + ce qu'elle fait)
●​ (parametre1, parametre2) : entrées de la fonction (optionnel)
●​ : : deux-points obligatoires
●​ Indentation : tout le code de la fonction est indenté (4 espaces)
●​ """docstring""" : documentation (optionnel mais PRO)
●​ return : renvoie un résultat (optionnel)

2️⃣ Fonction SANS paramètres, SANS return

def dire_bonjour():
"""Affiche un message de bienvenue"""

🎉
print("=" * 40)
print(" Bienvenue dans mon programme!")
print("=" * 40)

# Appel de la fonction
dire_bonjour()

Résultat :
🎉
========================================
Bienvenue dans mon programme!
========================================

Utilité : affichage, actions simples

3️⃣ Fonction AVEC paramètres, SANS return

def afficher_infos_etudiant(nom, age, note):
"""Affiche les informations d'un étudiant"""
print(f"Nom : {nom}")
print(f"Âge : {age} ans")
print(f"Note : {note}/20")
print("-" * 30)

# Appels avec différents arguments

afficher_infos_etudiant("Ahmed", 20, 15.5)
afficher_infos_etudiant("Fatma", 22, 17.0)
afficher_infos_etudiant("Youssef", 19, 14.0)

Résultat :

Nom : Ahmed
Âge : 20 ans
Note : 15.5/20
------------------------------
Nom : Fatma
Âge : 22 ans
Note : 17.0/20
------------------------------

📌 Important : nom, age, note = paramètres (dans la définition)​

Lors de l'appel : "Ahmed", 20, 15.5 = arguments (valeurs concrètes)

4️⃣ Fonction AVEC paramètres, AVEC return

def calculer_moyenne(note1, note2, note3):
"""Calcule la moyenne de 3 notes"""
somme = note1 + note2 + note3
moyenne = somme / 3
return moyenne

# Utilisation
ma_moyenne = calculer_moyenne(15, 17, 13)
print(f"Ta moyenne est : {ma_moyenne:.2f}")

# Utilisation directe
if calculer_moyenne(18, 19, 20) >= 16:
print("Mention Très Bien!")

⚠️ ATTENTION : Différence entre print et return

# FONCTION AVEC PRINT (ne retourne rien)
def additionner_print(a, b):
resultat = a + b
print(resultat) # Affiche mais ne retourne rien

# FONCTION AVEC RETURN (retourne une valeur)

def additionner_return(a, b):
resultat = a + b
return resultat

# Test

❌
x = additionner_print(3, 5) # Affiche 8
print(f"x vaut : {x}") # x vaut : None

✅
y = additionner_return(3, 5) # Ne s'affiche pas
print(f"y vaut : {y}") # y vaut : 8

✅
# On peut utiliser y dans d'autres calculs

❌
total = y + 10 # Fonctionne
# total = x + 10 # Erreur car x = None

Règle d'or : Utilise return quand tu veux réutiliser la valeur, print juste pour afficher.

5️⃣ Paramètres avec valeurs par défaut

def calculer_prix_ttc(prix_ht, taux_tva=0.20):
"""
Calcule le prix TTC
taux_tva = 0.20 par défaut (20%)
"""
prix_ttc = prix_ht * (1 + taux_tva)
return prix_ttc

# Avec TVA par défaut (20%)

prix1 = calculer_prix_ttc(100)
print(f"Prix 1 : {prix1}€") # 120€
# Avec TVA personnalisée (10%)
prix2 = calculer_prix_ttc(100, 0.10)
print(f"Prix 2 : {prix2}€") # 110€

6️⃣ Portée des variables (scope)

# Variable GLOBALE (en dehors de toute fonction)
nom_jeu = "Super Adventure"

def afficher_niveau():
# Variable LOCALE (existe seulement dans la fonction)
niveau = 5

✅
print(f"Niveau : {niveau}")
print(f"Jeu : {nom_jeu}") # Peut lire la variable globale

❌ ERREUR! niveau n'existe pas ici

afficher_niveau()
# print(niveau) #

Règle :

●​ Variables dans une fonction = locales (meurent après la fonction)

●​ Variables hors des fonctions = globales (accessibles partout)

7️⃣ Fonctions qui appellent d'autres fonctions

def celsius_vers_fahrenheit(celsius):
"""Convertit Celsius en Fahrenheit"""
fahrenheit = celsius * 9/5 + 32
return fahrenheit

def celsius_vers_kelvin(celsius):
"""Convertit Celsius en Kelvin"""
kelvin = celsius + 273.15
return kelvin

def afficher_toutes_conversions(celsius):
"""Affiche toutes les conversions pour une température"""
print(f"Température de base : {celsius}°C")
print(f"En Fahrenheit : {celsius_vers_fahrenheit(celsius):.2f}°F")
print(f"En Kelvin : {celsius_vers_kelvin(celsius):.2f}K")

# Appel de la fonction principale

afficher_toutes_conversions(25)
Résultat :

Température de base : 25°C

En Fahrenheit : 77.00°F
En Kelvin : 298.15K

8️⃣ Bonnes Pratiques Professionnelles

✅ FAIRE :
1. Noms de fonctions clairs et explicites

#✅ BON
def calculer_moyenne(note1, note2, note3):
pass

def verifier_email_valide(email):
pass

#❌ MAUVAIS
def calc(n1, n2, n3):
pass

def check(e):
pass

2. Une fonction = Une seule responsabilité

#✅ BON - Fonctions séparées

def calculer_moyenne(note1, note2, note3):
return (note1 + note2 + note3) / 3

def afficher_mention(moyenne):
if moyenne >= 16:
print("Très Bien")
elif moyenne >= 14:
print("Bien")

#❌ MAUVAIS - Fonction qui fait trop de choses

def tout_faire(note1, note2, note3):
moyenne = (note1 + note2 + note3) / 3
if moyenne >= 16:
print("Très Bien")
# ... plein d'autres choses
3. Toujours documenter avec docstring

def calculer_surface_cercle(rayon):
"""
Calcule la surface d'un cercle

Paramètres:
rayon (float): Le rayon du cercle en mètres

Retourne:
float: La surface en mètres carrés

Exemple:
>>> calculer_surface_cercle(5)
78.54
"""
pi = 3.14159
surface = pi * rayon ** 2
return surface

4. Valider les entrées

def diviser(a, b):

"""Divise a par b avec validation"""

❌
if b == 0:
print(" Erreur : division par zéro impossible!")
return None
return a / b

# Utilisation
resultat = diviser(10, 0)
if resultat is not None:
print(f"Résultat : {resultat}")

5. Retourner plutôt qu'afficher (quand possible)

# ✅ BON - Flexible
def calculer_total(prix, quantite):
return prix * quantite

# Je peux faire ce que je veux avec le résultat

total = calculer_total(10, 5)
print(f"Total : {total}€")
nouveau_total = total + 10
# ❌ MOINS FLEXIBLE
def calculer_total_print(prix, quantite):
print(prix * quantite)

# Je ne peux pas réutiliser la valeur

calculer_total_print(10, 5)

9️⃣ Erreurs courantes à éviter

❌ Erreur 1 : Oublier return

def additionner(a, b):
resultat = a + b
# Oubli du return!

❌
somme = additionner(3, 5)
print(somme) # Affiche: None

❌ Erreur 2 : Utiliser return dans un print

# ❌ FAUX
def calculer(x):
return print(x * 2) # Ne retourne rien d'utile!

# ✅ CORRECT
def calculer(x):
return x * 2

❌ Erreur 3 : Mauvaise indentation

# ❌ FAUX
def ma_fonction():
print("Hello") # Pas indenté!

# ✅ CORRECT
def ma_fonction():
print("Hello") # Bien indenté

❌ Erreur 4 : Confusion paramètres/arguments

def saluer(prenom, nom): # prenom et nom = PARAMÈTRES
print(f"Bonjour {prenom} {nom}")

saluer("Ahmed", "Ben Ali") # "Ahmed" et "Ben Ali" = ARGUMENTS

🔟 Template de Fonction Professionnelle
def nom_de_fonction(param1, param2, param3_optionnel=valeur_defaut):
"""
[Description courte de ce que fait la fonction]

Paramètres:
param1 (type): Description du paramètre 1
param2 (type): Description du paramètre 2
param3_optionnel (type, optionnel): Description. Défaut: valeur

Retourne:
type: Description de ce qui est retourné

Exemple:
>>> nom_de_fonction(val1, val2)
résultat_attendu
"""

# 1. Validation des entrées (si nécessaire)

❌
if param1 < 0:
print(" Erreur : param1 doit être positif")
return None

# 2. Traitement principal
resultat = param1 + param2 + param3_optionnel

# 3. Retour du résultat
return resultat

📝 Exercice de Compréhension (À FAIRE AVANT LES EXERCICES)

Corrige ces fonctions pour qu'elles suivent les bonnes pratiques :

# Fonction 1 - Plusieurs problèmes

def f(x, y):
print(x + y)

# Fonction 2 - Problème de return

def calculer_carre(nombre):
carre = nombre ** 2

# Fonction 3 - Pas de validation

def diviser(a, b):
return a / b
# Fonction 4 - Fait trop de choses
def tout_faire(nom, age):
print(f"Nom : {nom}")
print(f"Age : {age}")
majeur = age >= 18
if majeur:
print("Majeur")
return majeur

Solutions :

# Fonction 1 - Corrigée
def additionner(nombre1, nombre2):
"""Additionne deux nombres et retourne le résultat"""
resultat = nombre1 + nombre2
return resultat

# Fonction 2 - Corrigée
def calculer_carre(nombre):
"""Calcule le carré d'un nombre"""

✅
carre = nombre ** 2
return carre # Return ajouté

# Fonction 3 - Corrigée
def diviser(dividende, diviseur):
"""Divise deux nombres avec validation"""

❌
if diviseur == 0:
print(" Division par zéro impossible")
return None
return dividende / diviseur

# Fonction 4 - Corrigée (séparée en 2 fonctions)

def afficher_infos_personne(nom, age):
"""Affiche les informations d'une personne"""
print(f"Nom : {nom}")
print(f"Age : {age}")

def est_majeur(age):
"""Vérifie si une personne est majeure"""
return age >= 18

🎯 Objectifs d'Apprentissage
À la fin de ce TP, tu sauras :
 ✅ Créer et appeler des fonctions
✅ Utiliser les paramètres et arguments
●​

✅ Retourner des valeurs avec return

●​

✅ Créer des fonctions avec/sans paramètres

●​

✅ Documenter tes fonctions

●​

✅ Résoudre des problèmes en décomposant en fonctions

●​
●​

🎲 Exercice 1 : Le Dé Magique (15 min)

Contexte :

Tu es un magicien et tu as créé un dé truqué qui peut lancer différents types de dés (4

faces, 6 faces, 8 faces, 20 faces comme dans les jeux de rôle).

À faire :

Fonction 1 : lancer_de(nombre_faces)

●​ Génère un nombre aléatoire entre 1 et nombre_faces

🎲
●​ Retourne le résultat
●​ Affiche un message stylisé : " Le dé à X faces montre : Y"

Fonction 2 : lancer_de_multiple(nombre_faces, nombre_lancers)

●​ Lance le dé plusieurs fois

●​ Affiche chaque résultat
●​ Calcule et retourne la somme totale

Bonus : est_critique(resultat, nombre_faces)

●​ Retourne True si le résultat est le maximum possible (coup critique!)

●​ Retourne False sinon
●​ Affiche " ⚡
COUP CRITIQUE!" si c'est un critique

Exemple d'utilisation :
# Lancer un dé à 6 faces
resultat = lancer_de(6)

# Lancer 3 fois un dé à 20 faces

total = lancer_de_multiple(20, 3)
print(f"Total des 3 lancers : {total}")

# Vérifier si critique
if est_critique(20, 20):
 print("C'était un coup critique!")

Ce que tu apprends :

●​ Fonctions avec paramètres

●​ Return de valeurs
●​ Module random
●​ Fonctions appelant d'autres fonctions

🔮 Exercice 2 : Le Générateur de Noms Fantastiques

(20 min)
Contexte :

Tu crées un générateur de noms pour personnages de jeux vidéo en combinant des

syllabes.

À faire :

Fonction 1 : generer_syllabe_debut()

●​ Choisit aléatoirement parmi : "Zar", "Kal", "Thor", "Dra", "Mor"

●​ Retourne la syllabe choisie

Fonction 2 : generer_syllabe_milieu()

●​ Choisit aléatoirement parmi : "ak", "eth", "or", "an", "ix"

●​ Retourne la syllabe choisie

Fonction 3 : generer_syllabe_fin()

●​ Choisit aléatoirement parmi : "ius", "ion", "or", "ax", "us"

●​ Retourne la syllabe choisie

Fonction 4 : creer_nom_personnage(longueur)

●​ Si longueur = 1 : retourne syllabe_debut + syllabe_fin

🧙
●​ Si longueur = 2 : retourne syllabe_debut + syllabe_milieu + syllabe_fin
●​ Affiche : " Nouveau héros : [NOM]"

Bonus : titre_personnage(nom, niveau)

●​ Si niveau < 10 : retourne "Apprenti [NOM]"

●​ Si niveau < 20 : retourne "[NOM] le Brave"
 ●​ Si niveau >= 20 : retourne "[NOM] le Légendaire"

Exemple d'utilisation :
# Générer 5 noms de personnages
for i in range(5):
nom = creer_nom_personnage(2)
titre = titre_personnage(nom, 15)
print(titre)

Astuce pour choisir aléatoirement :

import random

def generer_syllabe_debut():
nombre = [Link](1, 5)
if nombre == 1:
return "Zar"
elif nombre == 2:
return "Kal"
elif nombre == 3:
return "Thor"
elif nombre == 4:
return "Dra"
else:
return "Mor"

Ce que tu apprends :

●​ Fonctions sans paramètres

●​ Composition de fonctions
●​ Génération aléatoire
●​ Conditions dans les fonctions

🎨 Exercice 3 : L'Artiste ASCII (25 min)

Contexte :

Crée des fonctions qui dessinent des formes en ASCII art.

À faire :

Fonction 1 : dessiner_ligne(caractere, longueur)

 ●​ Affiche une ligne du caractère répété
●​ Exemple : dessiner_ligne("*", 10) → **********

Fonction 2 : dessiner_rectangle(largeur, hauteur, caractere)

●​ Dessine un rectangle plein

●​ Utilise dessiner_ligne() dans une boucle

Fonction 3 : dessiner_triangle(hauteur, caractere)

●​ Dessine un triangle
●​ Ligne 1 : 1 caractère
●​ Ligne 2 : 3 caractères
●​ Ligne 3 : 5 caractères, etc.

Fonction 4 : dessiner_sapin(hauteur)

●​ Dessine un sapin de Noël

●​ Utilise dessiner_triangle() pour la cime

⭐
●​ Ajoute un tronc (rectangle de 3x2)
●​ Ajoute une étoile au sommet

Bonus : dessiner_pyramide_centree(hauteur, caractere)

●​ Dessine une pyramide centrée avec des espaces

Exemple de résultat :
dessiner_sapin(5)

⭐
*
***
*****
*******
*********
|||
|||

Astuce pour répéter un caractère :

print("*" * 5) # Affiche: *****
print(" " * 3 + "*" * 7) # Affiche: *******

Ce que tu apprends :

●​ Fonctions appelant d'autres fonctions

 ●​ Manipulation de strings
●​ Boucles dans les fonctions
●​ Créativité visuelle

🔐 Exercice 4 : Le Codeur Secret (30 min)

Contexte :

Crée un système de chiffrement simple pour envoyer des messages secrets.

À faire :

Fonction 1 : decaler_lettre(lettre, decalage)

●​ Prend une lettre et un nombre

●​ Retourne la lettre décalée dans l'alphabet
●​ Exemple : decaler_lettre('A', 3) → 'D'
●​ Si dépasse 'Z', revenir à 'A' (circulaire)

Fonction 2 : chiffrer_caractere(caractere, decalage)

●​ Si c'est une lettre majuscule (A-Z) : utilise decaler_lettre()

●​ Si c'est une lettre minuscule (a-z) : convertit en majuscule, chiffre, reconvertit
●​ Si c'est un espace ou ponctuation : ne change rien
●​ Retourne le caractère chiffré

Fonction 3 : chiffrer_message(message, decalage)

●​ Parcourt chaque caractère du message

●​ Chiffre chaque caractère avec chiffrer_caractere()
●​ Construit et retourne le message chiffré complet

Fonction 4 : dechiffrer_message(message_chiffre, decalage)

●​ Fait l'opération inverse (décalage négatif)

●​ Utilise chiffrer_message() avec -decalage

Bonus : force_brute(message_chiffre)

●​ Essaie tous les décalages de 1 à 25

●​ Affiche chaque tentative
●​ L'utilisateur peut trouver celui qui a du sens

Exemple d'utilisation :
message_original = "PYTHON EST GENIAL"
decalage = 5

message_code = chiffrer_message(message_original, decalage)

print(f"Message codé : {message_code}")

message_decode = dechiffrer_message(message_code, decalage)

print(f"Message décodé : {message_decode}")

Astuce pour décaler une lettre :

def decaler_lettre(lettre, decalage):
# Position de A = 65 en code ASCII
position = ord(lettre) - ord('A') # Position 0-25
nouvelle_position = (position + decalage) % 26 # Circulaire
nouvelle_lettre = chr(ord('A') + nouvelle_position)
return nouvelle_lettre

Ce que tu apprends :

●​ Manipulation de caractères (ord, chr)

●​ Algorithme de chiffrement
●​ Modulo pour circularité
●​ Décomposition en sous-problèmes

🎵 Exercice 5 : Le Compositeur de Mélodies (25 min)

Contexte :

Crée des fonctions qui "jouent" des notes en ASCII (visuellement, pas de son).

À faire :

Fonction 1 : afficher_note(note, duree)

●​ Affiche une note musicale stylisée

●​ note : "do", "re", "mi", "fa", "sol", "la", "si"
●​ duree : 1 (noire), 2 (blanche), 4 (ronde)
●​ Affiche différemment selon la durée

Fonction 2 : jouer_sequence(note1, note2, note3)

🎵 🎵"
●​ Joue 3 notes consécutives
●​ Affiche : " [note1] - [note2] - [note3]
Fonction 3 : traduire_en_chiffres(note)

●​ Convertit une note en chiffre

●​ "do" → 1, "re" → 2, "mi" → 3, etc.
●​ Retourne le chiffre

Fonction 4 : composer_gamme(note_debut)

●​ À partir d'une note de départ

●​ Génère la gamme complète (8 notes)
●​ Affiche chaque note avec son numéro

Bonus : detecter_accord(note1, note2, note3)

●​ Vérifie si 3 notes forment un accord majeur (intervalle 1-3-5)

●​ Exemple : Do-Mi-Sol est un accord (1-3-5)
●​ Retourne "Accord Majeur!" ou "Pas un accord"

Exemple de résultat :

🎵
afficher_note("do", 2)
# DO (blanche) ♪♪

🎵 🎵
jouer_sequence("do", "mi", "sol")
# do - mi - sol

composer_gamme("re")
# 1. RE
# 2. MI
# 3. FA
# 4. SOL
# 5. LA
# 6. SI
# 7. DO
# 8. RE

Ce que tu apprends :

●​ Fonctions avec logique conditionnelle

●​ Comparaison de valeurs
●​ Créativité dans l'affichage
●​ Modélisation de concepts réels

🏆 Exercice 6 : Le Calculateur de Score de Jeu (30 min)

Contexte :

Crée un système de calcul de score pour un jeu vidéo avec bonus et multiplicateurs.

À faire :

Fonction 1 : calculer_score_base(ennemis_tues, temps_secondes)

●​ Score = ennemis_tués × 100

●​ Bonus de vitesse : si temps < 60s → +500 points
●​ Retourne le score de base

Fonction 2 : calculer_bonus_combo(combo)

●​ Si combo < 5 : multiplicateur × 1

●​ Si combo < 10 : multiplicateur × 1.5
●​ Si combo >= 10 : multiplicateur × 2
●​ Retourne le multiplicateur

Fonction 3 : calculer_bonus_sante(sante_restante, sante_max)

●​ Calcule le pourcentage de santé restante

●​ Si 100% → +1000 points
●​ Si >= 75% → +500 points
●​ Si >= 50% → +200 points
●​ Sinon → 0 points
●​ Retourne le bonus

Fonction 4 : afficher_niveau(niveau)

🌱
●​ Affiche un titre stylisé selon le niveau

⚔️
●​ Niveau 1 : " Débutant"

🔥
●​ Niveau 2-3 : " Guerrier"

👑
●​ Niveau 4-5 : " Vétéran"
●​ Niveau 6+ : " Légende"

Fonction 5 : calculer_score_total(ennemis, temps, combo, sante,

sante_max)

●​ Utilise TOUTES les fonctions précédentes

●​ Calcule le score final
●​ Affiche un rapport détaillé
●​ Retourne le score total

Exemple d'utilisation :
score_final = calculer_score_total(
ennemis=15,
temps=45,
 combo=8,
sante=80,
sante_max=100
)

# Affichage attendu :
# ═══════════════════════════════
# RAPPORT DE MISSION
# ═══════════════════════════════
# Ennemis éliminés : 15
# Score de base : 1500
# Bonus vitesse : +500
# Multiplicateur : ×1.5
# Bonus santé : +500
# ───────────────────────────────
# SCORE TOTAL : 3500
# ═══════════════════════════════

Ce que tu apprends :

●​ Fonctions complexes avec multiples paramètres

●​ Retour et utilisation de valeurs
●​ Composition de fonctions
●​ Logique de jeu
●​ Formatage d'affichage professionnel

🎪 Exercice Bonus : Le Générateur d'Histoires (35 min)

Contexte :

Crée un générateur d'histoires aléatoires en combinant des éléments.

À faire :

Fonction 1 : choisir_heros()

●​ Retourne aléatoirement : "un chevalier", "une sorcière", "un dragon", "un robot"

Fonction 2 : choisir_lieu()

●​ Retourne aléatoirement : "dans un château", "sur une île", "dans l'espace", "sous la
mer"

Fonction 3 : choisir_objet()
 ●​ Retourne aléatoirement : "une épée magique", "un grimoire ancien", "une carte au
trésor", "un cristal de pouvoir"

Fonction 4 : choisir_ennemi()

●​ Retourne aléatoirement : "un troll géant", "un sorcier maléfique", "une armée de
robots", "un monstre ancien"

Fonction 5 : generer_histoire()

●​ Utilise toutes les fonctions précédentes

●​ Construit une histoire avec :
○​ Introduction
○​ Rencontre avec l'objet
○​ Confrontation avec l'ennemi
○​ Conclusion
●​ Retourne l'histoire complète

Bonus : generer_suite(histoire_precedente)

●​ Génère une suite logique à l'histoire

●​ Utilise les mêmes éléments mais nouvelle aventure

Exemple de résultat :
Il était une fois un chevalier dans un château.
Un jour, il découvrit une épée magique cachée dans les donjons.
Soudain, un troll géant apparut pour lui barrer la route!
Grâce à son courage et à l'épée magique, le chevalier triompha.

FIN... ou peut-être pas? 🎭

Ce que tu apprends :

●​ Génération procédurale
●​ Narration structurée
●​ Combinaison de fonctions
●​ Créativité programmée

💡 Conseils de Pro
1. Structure d'une fonction bien écrite :

def nom_fonction(parametre1, parametre2):

"""
Description : Ce que fait la fonction
 Paramètres : Ce qu'elle reçoit
Retour : Ce qu'elle renvoie
"""
# Ton code ici
resultat = parametre1 + parametre2
return resultat

2. Testez chaque fonction séparément :

●​ Crée la fonction
●​ Teste-la avec plusieurs valeurs
●​ Vérifie qu'elle fonctionne
●​ Passe à la suivante

3. Décompose les problèmes :

●​ Fonction complexe = plusieurs petites fonctions

●​ Chaque fonction = une tâche précise

4. Utilise des noms explicites :

●​ ❌ f1(), calcul(), truc()

●​ ✅ calculer_score(), chiffrer_message(), generer_nom()

🎯 Critères de Réussite
Pour chaque exercice, vérifie que :

●​ [ ] Ta fonction a un nom clair

●​ [ ] Elle a une docstring explicative
●​ [ ] Les paramètres sont bien utilisés
●​ [ ] Elle retourne une valeur (quand nécessaire)
●​ [ ] Elle fonctionne avec différentes valeurs
●​ [ ] Le code est indenté correctement
●​ [ ] Tu peux la réutiliser facilement

Bonne programmation ! Amuse-toi bien ! 🚀