JOUR 1 : VARIABLES, TYPES DE DONNEES ET F-STRINGS

1. LA LOGIQUE PROFONDE (FIRST PRINCIPLES)

Une variable en Python n'est PAS une boite qui contient une valeur. C'est un
ETICHETTE collée sur un OBJET en memoire. Quand tu ecris age = 25, Python cree
un objet entier (25) quelque part dans la RAM, et l'etiquette "age" pointe vers cet
objet. C'est crucial : deux variables peuvent pointer vers le meme objet. Les types int,
float et str sont des classes predefinies. Python est fortement type (un int reste un int)
mais dynamiquement type (tu n'as pas besoin de declarer le type). La regle d'or : le
nom de la variable est une reference, pas une boite.

2. LE CODE EN ACTION (PARETO)

prix = 19.99

quantite = 3

produit = "Casque Audio"

total = prix * quantite

message = f"Le {produit} coute {prix}€. Pour {quantite} unites, le total est de {total}€."

print(message)
print(type(prix))

print(type(quantite))

print(type(produit))

Ligne 1 : On cree l'etiquette "prix" qui pointe vers l'objet float 19.99.
Ligne 2 : L'etiquette "quantite" pointe vers l'objet int 3.

Ligne 3 : L'etiquette "produit" pointe vers l'objet str "Casque Audio".

Ligne 5 : Python multiplie les deux objets numeriques et cree un nouvel objet float
59.97, reference par "total".
Ligne 6 : F-string : le f avant les guillemets active l'interpolation. Python evalue les
expressions entre accolades {} et les convertit en texte a la volee.

Ligne 8 : Affiche le message complet avec les valeurs inserees dynamiquement.

Lignes 9-11 : type() retourne la classe de l'objet pointe par la variable.

3. CODE A ANALYSER ET CORRIGER (EXERCICE GUIDE)

- L'Enonce : Un client achete 2 articles. Le premier coute 45.50€ (float), le deuxieme

coute 30 (int, sans centimes). Calcule le total et affiche un message professionnel
avec F-string. Attention a ne pas melanger les types incorrectement.

- Le Code de la Solution :

article_1 = 45.50

article_2 = 30

nombre_articles = 2

total = article_1 + article_2

recap = f"Achats : {nombre_articles} articles pour un total de {total}€."

print(recap)
print(f"Type de article_1 : {type(article_1)}")

print(f"Type de article_2 : {type(article_2)}")

- L'Analyse : Python additionne un float et un int sans probleme car il convertit

automatiquement l'int en float pour l'operation (promotion numerique). Le resultat est
un float (75.5). La F-string evalue total et l'insere. Le type() confirme que article_1 est
float et article_2 est int. Le piege evite : ne pas mettre des guillemets autour de 30
sinon ce serait une string et l'addition ferait une concatenation de texte (45.5030).

4. DEFI AUTONOME (ACTIVE RECALL)

Cree un programme qui stocke ton nom (str), ton age (int), et ta taille en metres
(float, ex: 1.75). Calcule combien d'annees il te reste avant d'avoir 100 ans. Affiche
un message avec F-string qui dit : "Je m'appelle [nom], j'ai [age] ans, je mesure
[taille]m, et il me reste [calcul] annees avant 100 ans." Utilise type() pour verifier
chaque variable.

---

JOUR 2 : MANIPULATION ET DECOUPAGE DES CHAINES DE CARACTERES

1. LA LOGIQUE PROFONDE (FIRST PRINCIPLES)

Une string en Python est une SEQUENCE IMMUTABLE d'Unicode. Immuable

signifie que tu ne peux PAS modifier un caractere directement (texte[0] = "X" plante).
Quand tu "modifies" une string, Python cree en realite une NOUVELLE string en
memoire. Les methodes comme .upper(), .strip(), .split() sont des fonctions attachees
a la classe str : elles retournent un nouvel objet string transforme, sans toucher
l'original. La regle d'or : les strings sont immuables, donc chaque transformation cree
un nouvel objet.

2. LE CODE EN ACTION (PARETO)

email = " [Link]@[Link] "

email_propre = [Link]().lower()

nom_utilisateur = email_propre.split("@")[0]

domaine = email_propre.split("@")[1]

print(f"Original : '{email}'")

print(f"Propre : '{email_propre}'")

print(f"Utilisateur : '{nom_utilisateur}'")
print(f"Domaine : '{domaine}'")

Ligne 1 : Variable pointant vers la string brute avec espaces et majuscules.

Ligne 3 : .strip() cree une nouvelle string sans espaces. .lower() cree une autre string
en minuscules. On chaine les appels : le resultat de strip() est l'objet sur lequel on
appelle lower().

Ligne 4 : .split("@") retourne une LISTE de deux elements ["[Link]",

"[Link]"]. [0] accede au premier element (index 0).

Ligne 5 : [1] accede au deuxieme element (index 1).

Lignes 7-10 : Affichage avec F-strings pour voir les transformations.

3. CODE A ANALYSER ET CORRIGER (EXERCICE GUIDE)

- L'Enonce : Un systeme recoit une reference produit mal formatee : " REF-12345-
ABC ". Nettoie-la, mets-la en minuscules, extrais le numero (12345) et le code (abc).
Affiche chaque partie separement.

- Le Code de la Solution :

reference = " REF-12345-ABC "

propre = [Link]().lower().replace("ref-", "")

parties = [Link]("-")

numero = parties[0]

code = parties[1]

print(f"Reference nettoyee : {propre}")

print(f"Numero : {numero}")

print(f"Code : {code}")
- L'Analyse : .strip() supprime les espaces. .lower() passe en minuscules.
.replace("ref-", "") supprime le prefixe en creat une nouvelle string. .split("-") decoupe
au tiret et retourne une liste. On accede par index. Le piege evite : si on oublie
.strip(), les espaces restent au debut et faussent le split. Si on oublie .lower(), le
remplacement de "ref-" echoue car c'est "REF-".

4. DEFI AUTONOME (ACTIVE RECALL)

Tu recois une adresse : " 42 Rue de la Paix, PARIS 75002 ". Sans creer de nouvelle
variable pour l'original, nettoie cette adresse, passe le nom de la ville en majuscules,
garde le reste en minuscules, et extrais le code postal dans une variable separee.
Affiche l'adresse formatee et le code postal. Indice : pense a la methode .find() ou
.split().

---

JOUR 3 : LOGIQUE BOOLEENNE ET EMBRANCHEMENTS DE CONTROLE

1. LA LOGIQUE PROFONDE (FIRST PRINCIPLES)

Un programme qui s'execute ligne par ligne sans deviation est un train sur un rail
droit. Les embranchements (if/elif/else) sont des AIGUILLAGES. Python evalue la
condition a l'interieur du if : si le resultat est True, il execute le bloc indenté. Si False,
il saute au bloc suivant. Les operateurs de comparaison (==, !=, >, <, >=, <=)
retournent toujours un booleen. elif signifie "sinon si" : il ne teste SA CONDITION
QUE SI toutes les conditions precedentes etaient False. else est le "tout le reste". La
regle d'or : Python execute UN SEUL bloc par structure if/elif/else, celui dont la
condition est True en premier.

2. LE CODE EN ACTION (PARETO)

note = 14

if note >= 16:

mention = "Tres Bien"
elif note >= 14:

mention = "Bien"

elif note >= 12:

mention = "Assez Bien"

elif note >= 10:

mention = "Passable"
else:

mention = "Insuffisant"

print(f"Note : {note} - Mention : {mention}")

Ligne 1 : Variable note = 14.

Ligne 3 : Python teste 14 >= 16 ? False. Il saute.

Ligne 5 : Python teste 14 >= 14 ? True. Il execute ce bloc, assigne "Bien" a mention,
et IGNORE TOUT LE RESTE (elif et else).

Lignes 7-11 : Ne sont pas executes car un bloc True a deja ete trouve.

Ligne 13 : Affiche le resultat.

3. CODE A ANALYSER ET CORRIGER (EXERCICE GUIDE)

- L'Enonce : Un magasin applique des reductions : si le montant est superieur a

100€, reduction de 10%. Sinon si superieur a 50€, reduction de 5%. Sinon, pas de
reduction. Calcule et affiche le prix final.

- Le Code de la Solution :

montant = 75

if montant > 100:

reduction = 0.10
elif montant > 50:

reduction = 0.05

else:
reduction = 0

prix_final = montant * (1 - reduction)

print(f"Montant initial : {montant}€")

print(f"Reduction : {reduction * 100}%")

print(f"Prix final : {prix_final}€")

- L'Analyse : Avec montant = 75, la premiere condition est False. La deuxieme est
True (75 > 50), donc reduction = 0.05. Le else est ignore. Le calcul prix_final utilise 1
- 0.05 = 0.95, donc 75 * 0.95 = 71.25. Le piege evite : si on ecrivait if montant > 50
AVANT if montant > 100, un montant de 120 prendrait 5% au lieu de 10%. L'ordre
des conditions est crucial car Python s'arrete au premier True.

4. DEFI AUTONOME (ACTIVE RECALL)

Cree un systeme de categorisation d'age : moins de 13 ans = "Enfant", 13 a 17 ans =

"Adolescent", 18 a 64 ans = "Adulte", 65 ans et plus = "Senior". Ecris un programme
qui demande (simule avec une variable) un age et affiche la categorie. Attention : un
age de 17.5 doit etre traite comme Adolescent, pas Adulte. Utilise des conditions
strictement logiques.

---

JOUR 4 : AUTOMATISATION PAR BOUCLE CONDITIONNELLE (WHILE)

1. LA LOGIQUE PROFONDE (FIRST PRINCIPLES)

Une boucle while est une REPETITION CONDITIONNELLE. Avant chaque tour,
Python evalue la condition. Si elle est True, il execute le bloc et REVIENT AU DEBUT
pour reevaluer. Si elle est False, il sort. C'est un mecanisme de controle de flux qui
peut tourner INFINIMENT si la condition ne devient jamais False. Le compteur est
une variable qui evolue a chaque iteration pour garantir la sortie. break est un ordre
d'evacuation immediat : il casse la boucle et sort, peu importe la condition. La regle
d'or : while = "tant que", donc il faut TOUJOURS s'assurer que la condition peut
devenir False, sinon le programme plante ou boucle infiniment.

2. LE CODE EN ACTION (PARETO)

stock = 5

ventes = 0

while stock > 0:

ventes = ventes + 1
stock = stock - 1

print(f"Vente {ventes} effectuee. Stock restant : {stock}")

print("Stock epuise.")

Ligne 1-2 : Initialisation. stock = 5, ventes = 0.

Ligne 4 : Python verifie stock > 0 (5 > 0 = True). Entre dans la boucle.

Ligne 5 : ventes devient 1 (0 + 1).

Ligne 6 : stock devient 4 (5 - 1).

Ligne 7 : Affiche.

Ligne 4 (tour 2) : stock = 4, True. Continue.

...

Ligne 4 (tour 5) : stock = 1, True. Continue.

Ligne 4 (tour 6) : stock = 0, 0 > 0 est False. SORTIE. Execute la ligne 9.

3. CODE A ANALYSER ET CORRIGER (EXERCICE GUIDE)

- L'Enonce : Un utilisateur a 3 essais pour deviner un code secret (42). A chaque

essai, decremente le compteur. Si le code est trouve avant epuisement, affiche
"Acces autorise" et sors immediatement. Sinon, affiche "Acces refuse".

- Le Code de la Solution :

code_secret = 42

essais_restant = 3

devine = 25

while essais_restant > 0:

if devine == code_secret:

print("Acces autorise.")

break

essais_restant = essais_restant - 1

if essais_restant > 0:

print(f"Essai incorrect. Il reste {essais_restant} essai(s).")

devine = 17

else:

print("Acces refuse.")

- L'Analyse : essais_restant = 3. Premier tour : devine (25) != 42, donc on

decremente a 2, on affiche le message. Deuxieme tour : devine (17) != 42,
decremente a 1, affiche. Troisieme tour : devine (17) != 42, decremente a 0, else
s'execute car essais_restant > 0 est False, affiche "Acces refuse." et la boucle se
termine naturellement (condition 0 > 0 = False). Le break est pret a s'activer si devine
== code_secret. Le piege evite : si on mettait le decrementation AVANT le test de
victoire, on perdrait un essai inutilement. L'ordre des operations dans la boucle est
strategique.

4. DEFI AUTONOME (ACTIVE RECALL)

Cree un programme de saisie de mot de passe avec while. L'utilisateur a 5

tentatives. Le mot de passe correct est "Python2024". A chaque echec, affiche le
nombre de tentatives restantes. Si l'utilisateur entre "quit", il peut abandonner
immediatement (utilise break). Si le mot de passe est correct, affiche "Bienvenue" et
sors. Si les 5 tentatives sont epuisees, affiche "Compte bloque". Simule les entrees
avec des variables.

---

JOUR 5 : ITERATION ET CONTROLE DES FLUX (BOUCLE FOR ET RANGE)

1. LA LOGIQUE PROFONDE (FIRST PRINCIPLES)

La boucle for en Python n'est PAS une boucle a compteur comme en C ou Java.
C'est un ITERATEUR qui parcourt une SEQUENCE d'elements un par un. range()
est une fonction qui genere une SEQUENCE de nombres a la demande (optimisation
memoire). range(5) produit 0, 1, 2, 3, 4. range(2, 10, 2) produit 2, 4, 6, 8 (debut, fin
exclusive, pas). La boucle for assigne chaque element a la variable de tour, execute
le bloc, puis passe au suivant. La regle d'or : for = "pour chaque element dans", pas
"tant que i est inferieur a". C'est une iteration sur une sequence, pas une condition.

2. LE CODE EN ACTION (PARETO)

produits = ["Clavier", "Souris", "Ecran", "Casque"]

for index in range(len(produits)):

print(f"Produit {index + 1} : {produits[index]}")
print("---")

for produit in produits:

print(f"Article : {produit}")

Ligne 1 : Liste de produits.

Ligne 3 : range(len(produits)) = range(4) = 0, 1, 2, 3. len(produits) retourne 4.

Ligne 4 : Premier tour : index = 0, produits[0] = "Clavier". index + 1 = 1. Affiche
"Produit 1 : Clavier".
Deuxieme tour : index = 1, "Souris". Etc.

Ligne 8 : Deuxieme boucle. produit prend directement la valeur de chaque element.

Premier tour : "Clavier". Pas besoin d'index.

3. CODE A ANALYSER ET CORRIGER (EXERCICE GUIDE)

- L'Enonce : Calcule la somme des nombres pairs de 2 a 20 inclus. Utilise range()

avec un pas adapte. Affiche chaque nombre additionne et le total final.

- Le Code de la Solution :

total = 0

for nombre in range(2, 21, 2):

total = total + nombre

print(f"Addition de {nombre}, total intermediaire : {total}")

print(f"Somme finale : {total}")

- L'Analyse : range(2, 21, 2) genere 2, 4, 6, 8, 10, 12, 14, 16, 18, 20. La fin (21) est
EXCLUSIVE, donc 20 est inclus mais 21 ne l'est pas. Le pas de 2 saute les impairs.
total accumule : 0+2=2, 2+4=6, 6+6=12... jusqu'a 110. Le piege evite : range(2, 20, 2)
s'arreterait a 18. Il faut 21 pour inclure 20. L'accumulateur total doit etre initialise a 0
AVANT la boucle.

4. DEFI AUTONOME (ACTIVE RECALL)

Ecris un programme qui affiche la table de multiplication de 7 (de 1 a 10) avec une
boucle for et range(). Le format doit etre : "7 x 1 = 7", "7 x 2 = 14", etc. Ensuite,
calcule la somme de tous ces resultats et affiche-la. Utilise une seule boucle pour
tout faire.

---

JOUR 6 : LES LISTES (INDEXATION, MODIFICATION DYNAMIQUE)

1. LA LOGIQUE PROFONDE (FIRST PRINCIPLES)

Une liste en Python est un TABLEAU DYNAMIQUE. Contrairement aux strings, les
listes sont MUTABLES. Tu peux modifier, ajouter, supprimer des elements sans creer
une nouvelle liste. En arriere-plan, Python alloue un bloc de memoire avec une
marge (over-allocation) pour permettre les ajouts rapides. L'indexation commence a
0 (le premier element est a l'index 0). Les index negatifs comptent depuis la fin (-1 =
dernier element). .append() ajoute a la fin en O(1) (temps constant). .pop() supprime
le dernier element (ou a un index donne). La regle d'or : les listes sont des
sequences mutables ordonnees. L'ordre est preserve. L'index est la position.

2. LE CODE EN ACTION (PARETO)

panier = ["Pomme", "Pain", "Lait"]

[Link]("Fromage")

[Link](1, "Oeufs")

dernier = [Link]()
print(f"Panier : {panier}")
print(f"Article retire : {dernier}")

print(f"Premier article : {panier[0]}")

print(f"Dernier article : {panier[-1]}")

print(f"Nombre d'articles : {len(panier)}")

Ligne 1 : Liste initiale de 3 elements. Index 0="Pomme", 1="Pain", 2="Lait".

Ligne 3 : .append("Fromage") ajoute a la fin. Liste = ["Pomme", "Pain", "Lait",
"Fromage"].
Ligne 4 : .insert(1, "Oeufs") insere "Oeufs" a l'index 1. Liste = ["Pomme", "Oeufs",
"Pain", "Lait", "Fromage"].
Ligne 5 : .pop() sans argument supprime le DERNIER element ("Fromage") et le
retourne. Liste = ["Pomme", "Oeufs", "Pain", "Lait"].

Lignes 7-11 : Affichages avec F-strings. panier[-1] est "Lait".

3. CODE A ANALYSER ET CORRIGER (EXERCICE GUIDE)

- L'Enonce : Une liste de temperatures est fournie : [23, 25, 22, 28, 24]. Ajoute la
temperature de demain (30) a la fin. Corrige la troisieme temperature (index 2) qui
est erronee : elle devrait etre 26, pas 22. Supprime la temperature la plus basse (22
n'existe plus, donc c'est 23). Affiche la liste finale, sa longueur, et la moyenne.

- Le Code de la Solution :

temperatures = [23, 25, 22, 28, 24]

[Link](30)
temperatures[2] = 26

[Link](0)

somme = 0
for temp in temperatures:
somme = somme + temp

moyenne = somme / len(temperatures)

print(f"Liste finale : {temperatures}")

print(f"Nombre de jours : {len(temperatures)}")

print(f"Moyenne : {moyenne}°C")

- L'Analyse : .append(30) ajoute a la fin. Liste = [23, 25, 22, 28, 24, 30].
temperatures[2] = 26 modifie directement l'element a l'index 2. Liste = [23, 25, 26, 28,
24, 30]. [Link](0) supprime l'element a l'index 0 (23). Liste = [25, 26, 28,
24, 30]. La boucle for calcule la somme (133). moyenne = 133 / 5 = 26.6. Le piege
evite : pop() sans argument supprime le dernier (30), pas le premier. Il faut pop(0)
pour le premier. L'index 2 est le troisieme element, pas le deuxieme.

4. DEFI AUTONOME (ACTIVE RECALL)

Tu geres une file d'attente de clients (liste). Les clients arrivent : "Alice", "Bob",
"Charlie", "Diana". Alice est servie et sort (supprime la premiere). Ensuite, "Eve"
arrive en urgence et doit etre inseree juste apres le premier client restant. Enfin,
Charlie se desiste et sort (trouve son index et supprime-le). Affiche l'etat de la file
apres chaque operation et a la fin. Utilise uniquement les methodes de liste.

---

JOUR 7 : LES DICTIONNAIRES (STRUCTURE CLE/VALEUR)

1. LA LOGIQUE PROFONDE (FIRST PRINCIPLES)

Un dictionnaire est une TABLE DE HACHAGE. Au lieu d'acceder par position (index
0, 1, 2...), on accede par CLE. Python hache la cle (la transforme en nombre unique)
pour trouver instantanement la valeur en memoire. C'est pourquoi la recherche par
cle est ultra-rapide (O(1)), meme avec des millions d'entrees. Les cles doivent etre
IMMUABLES (string, int, tuple) car Python doit pouvoir les hacher de maniere fiable.
Les valeurs peuvent etre n'importe quoi (meme des listes ou d'autres dictionnaires).
La regle d'or : dictionnaire = association cle -> valeur. Pas d'ordre garanti (avant
Python 3.7), mais insertion preservee depuis 3.7+.

2. LE CODE EN ACTION (PARETO)

client = {

"nom": "Martin",
"age": 34,

"ville": "Lyon",
"abonne": True

client["email"] = "martin@[Link]"

client["age"] = 35

print(f"Nom : {client['nom']}")

print(f"Age : {client['age']}")

print(f"Cles disponibles : {list([Link]())}")

print(f"Valeurs : {list([Link]())}")

for cle, valeur in [Link]():

print(f"{cle} -> {valeur}")

Ligne 1-6 : Dictionnaire initialise avec 4 paires cle/valeur.

Ligne 8 : Ajout d'une nouvelle paire. Si la cle existe deja, elle est ecrasee.

Ligne 9 : Modification de la valeur associee a "age".

Ligne 11-12 : Acces direct par cle avec crochets [].

Ligne 13-14 : .keys() retourne les cles, .values() les valeurs. list() les convertit en
liste.

Ligne 16 : .items() retourne les paires (cle, valeur). La boucle for les destructure en
cle et valeur.

3. CODE A ANALYSER ET CORRIGER (EXERCICE GUIDE)

- L'Enonce : Un catalogue de produits est stocke en dictionnaire. Ajoute un nouveau

produit "Tablette" avec prix 299. Modifie le prix du "Laptop" a 899. Supprime le
"Smartphone" du catalogue. Affiche le prix du "Laptop" et le nombre total de produits.

- Le Code de la Solution :

catalogue = {

"Laptop": 999,
"Smartphone": 699,

"Casque": 149

catalogue["Tablette"] = 299

catalogue["Laptop"] = 899

del catalogue["Smartphone"]

print(f"Prix Laptop : {catalogue['Laptop']}€")

print(f"Nombre de produits : {len(catalogue)}")

for produit, prix in [Link]():

print(f"{produit} : {prix}€")

- L'Analyse : Ajout avec nouvelle cle "Tablette". Modification avec cle existante
"Laptop" (ecrasement). del supprime la paire cle/valeur "Smartphone". len() compte
les paires restantes (3). La boucle affiche chaque produit. Le piege evite : si on
essayait d'acceder a catalogue["Smartphone"] apres le del, Python leverait une
KeyError. Il faut toujours verifier l'existence ou utiliser .get() pour eviter les plantages.

4. DEFI AUTONOME (ACTIVE RECALL)

Cree un dictionnaire qui represente un etudiant avec ces cles : "nom",

"matiere_preferee", "notes" (qui est une LISTE de 3 notes). Affiche la moyenne de
ses notes en accedant a la liste dans le dictionnaire. Ensuite, ajoute une nouvelle cle
"moyenne" qui stocke cette moyenne. Si la moyenne est superieure ou egale a 15,
ajoute une cle "mention" avec valeur "Bien". Sinon, "mention" = "Passable". Affiche le
dictionnaire final.

---

JOUR 8 : LES FONCTIONS - PARTIE 1 (DEF, PARAMETRES, ARGUMENTS)

1. LA LOGIQUE PROFONDE (FIRST PRINCIPLES)

Une fonction est un BLOC DE CODE REUTILISABLE. Quand Python rencontre def,
il ne execute PAS le code a l'interieur. Il le stocke en memoire comme un OBJET
FONCTION. Quand tu appelles la fonction (nom()), Python cree un CADRE
D'EXECUTION (frame) local, y copie les arguments dans les parametres, execute le
bloc, puis detruit le cadre. Les parametres sont les variables dans la definition de la
fonction. Les arguments sont les valeurs passees lors de l'appel. La regle d'or : def
definit, l'appel execute. Les parametres sont locaux a la fonction.

2. LE CODE EN ACTION (PARETO)

def calculer_ttc(prix_ht, taux_tva):

tva = prix_ht * taux_tva

prix_ttc = prix_ht + tva

return prix_ttc
montant_1 = calculer_ttc(100, 0.20)

montant_2 = calculer_ttc(250, 0.055)

print(f"Produit 1 TTC : {montant_1}€")

print(f"Produit 2 TTC : {montant_2}€")

Ligne 1-4 : Definition de la fonction. parametres : prix_ht et taux_tva. La fonction

calcule la TVA et retourne le prix TTC.
Ligne 6 : Appel avec arguments 100 et 0.20. Python cree un cadre local, prix_ht =
100, taux_tva = 0.20. Execute. Retourne 120.0. Detruit le cadre. montant_1 recoit
120.0.

Ligne 7 : Deuxieme appel, nouveau cadre local. prix_ht = 250, taux_tva = 0.055.
Retourne 263.75.

Lignes 9-10 : Affichage.

3. CODE A ANALYSER ET CORRIGER (EXERCICE GUIDE)

- L'Enonce : Cree une fonction qui calcule le perimetre d'un rectangle. Elle prend la
longueur et la largeur en parametres. Si les deux sont egaux, c'est un carre : affiche
un message specifique. Retourne toujours le perimetre.

- Le Code de la Solution :

def perimetre(longueur, largeur):

resultat = 2 * (longueur + largeur)

if longueur == largeur:

print("C'est un carre.")

return resultat
p1 = perimetre(5, 3)

p2 = perimetre(4, 4)

print(f"Perimetre 1 : {p1}")

print(f"Perimetre 2 : {p2}")

- L'Analyse : Les parametres longueur et largeur sont locaux. Le calcul 2 * (longueur

+ largeur) est la formule du perimetre. Le if teste l'egalite. return envoie la valeur a
l'appelant. p1 recoit 16, p2 recoit 16 aussi mais avec le message "C'est un carre."
affiche. Le piege evite : si on mettait return avant le if, le message ne s'afficherait
jamais car return termine la fonction immediatement. L'ordre compte.

4. DEFI AUTONOME (ACTIVE RECALL)

Cree une fonction calculer_reduction(prix, pourcentage) qui applique une reduction a

un prix. Le pourcentage est un nombre entre 0 et 100. La fonction doit retourner le
prix final ET le montant de la reduction. Retourne les deux valeurs (indice : Python
peut retourner plusieurs valeurs). Teste avec un prix de 200€ et une reduction de
15%. Affiche les resultats de maniere claire.

---

JOUR 9 : LES FONCTIONS - PARTIE 2 (RETURN ET PORTEE DES VARIABLES)

1. LA LOGIQUE PROFONDE (FIRST PRINCIPLES)

return est l'INSTRUCTION DE SORTIE d'une fonction. Quand Python atteint return, il
arrete immediatement l'execution de la fonction, detruit le cadre local, et renvoie la
valeur a l'appelant. Une fonction sans return explicite retourne None. La portee
(scope) determine ou une variable est visible. Les variables creees dans une fonction
sont LOCALES : elles n'existent que pendant l'appel. Les variables creees en dehors
sont GLOBALES : accessibles partout, mais MODIFIABLES dans une fonction
uniquement avec le mot-cle global (a eviter). La regle d'or : return = sortie avec
valeur. Local vs Global = contexte de vie de la variable. Une fonction doit etre une
boite noire : elle recoit des entrees, retourne une sortie, sans effet de bord sur le
global.

2. LE CODE EN ACTION (PARETO)

def statistiques(nombres):

total = 0

for n in nombres:

total = total + n

moyenne = total / len(nombres)

return total, moyenne

donnees = [10, 20, 30, 40]

somme, moy = statistiques(donnees)

print(f"Somme : {somme}")

print(f"Moyenne : {moy}")

Ligne 1-8 : Definition. Le parametre nombres est une liste. total est local. La boucle
calcule la somme. moyenne est calculee. return renvoie un TUPLE (total, moyenne).

Ligne 10 : Appel avec la liste donnees. somme recoit 100, moy recoit 25.0.
Lignes 12-13 : Affichage. Les variables total et moyenne n'existent plus, elles etaient
locales.

3. CODE A ANALYSER ET CORRIGER (EXERCICE GUIDE)

- L'Enonce : Une fonction doit verifier si un mot de passe est valide (minimum 8
caracteres). Elle retourne True ou False. Une autre fonction affiche un message
selon le resultat. Ne modifie pas de variable globale.
- Le Code de la Solution :

def verifier_mot_de_passe(mdp):
if len(mdp) >= 8:

return True

else:
return False

def afficher_resultat(mdp):

valide = verifier_mot_de_passe(mdp)

if valide:

return "Mot de passe accepte."

else:

return "Mot de passe trop court."

message = afficher_resultat("Python42")

print(message)

message_2 = afficher_resultat("abc")

print(message_2)

- L'Analyse : verifier_mot_de_passe est pure : elle recoit un argument, retourne un

booleen. Pas de global. afficher_resultat appelle la premiere fonction et retourne un
message. return False dans le else est explicite. On aurait pu ecrire return len(mdp)
>= 8 directement. Le piege evite : ne pas utiliser de variable globale pour stocker le
resultat. Chaque appel est independant. La fonction retourne une valeur, elle
n'affiche pas directement (separation des responsabilites).

4. DEFI AUTONOME (ACTIVE RECALL)

Cree une fonction analyser_liste(nombres) qui retourne trois valeurs : la somme, la
valeur maximale, et la valeur minimale de la liste. Utilise uniquement des boucles et
des variables locales, PAS les fonctions built-in sum(), max(), min(). Ensuite, appelle
cette fonction avec une liste de 5 nombres et affiche les trois resultats. La fonction
doit etre totalement autonome et retourner un tuple.

---

JOUR 10 : SECURISATION DU CODE (TRY ET EXCEPT)

1. LA LOGIQUE PROFONDE (FIRST PRINCIPLES)

Un programme qui plante (crash) s'arrete brutalement. try/except est un

MECANISME DE SURVIE. Python execute le bloc try normalement. Si une ERREUR
(exception) survient, il interrompt le bloc try et cherche un except correspondant. Si
trouve, il execute le bloc except et CONTINUE le programme. Si pas trouve, le
plantage persiste. C'est comme un filet de securite. Les exceptions sont des objets
(ValueError, TypeError, IndexError, KeyError...). La regle d'or : try = "essaie ceci",
except = "si ca plante, fais cela". Ne jamais masquer les erreurs silencieusement :
intercepte specifiquement, traite, et informe.

2. LE CODE EN ACTION (PARETO)

def diviser(a, b):

try:

resultat = a / b
return resultat

except ZeroDivisionError:
return "Erreur : division par zero impossible."

except TypeError:

return "Erreur : types incompatibles."

print(diviser(10, 2))
print(diviser(10, 0))

print(diviser(10, "a"))

Ligne 1-8 : Definition. try contient l'operation risquee.

Ligne 3 : 10 / 2 = 5.0. Pas d'erreur. return 5.0.

Ligne 4 : 10 / 0 leve ZeroDivisionError. Python saute a l'except ZeroDivisionError.

Ligne 6 : 10 / "a" leve TypeError. Python saute a l'except TypeError.

Lignes 10-12 : Trois appels testant les trois scenarios.

3. CODE A ANALYSER ET CORRIGER (EXERCICE GUIDE)

- L'Enonce : Un programme demande l'age d'un utilisateur. L'entree doit etre un

nombre entier positif. Si l'utilisateur entre du texte, un nombre negatif, ou zero, le
programme doit gerer l'erreur et redemander. Simule avec une liste d'entrees ["vingt",
"0", "-5", "25"].

- Le Code de la Solution :

entrees = ["vingt", "0", "-5", "25"]

for tentative in entrees:

try:

age = int(tentative)

if age <= 0:
raise ValueError("L'age doit etre positif.")

print(f"Age valide : {age} ans.")

break
 except ValueError as erreur:

print(f"Entree invalide '{tentative}' : {erreur}")

- L'Analyse : int("vingt") leve ValueError. Intercepte, affiche le message. int("0")

reussit, mais le if leve manuellement ValueError avec raise. Intercepte. int("-5")
reussit, raise ValueError. Intercepte. int("25") reussit, if False, affiche l'age valide,
break sort de la boucle. Le piege evite : ne pas mettre break dans le except, sinon on
sortirait meme sur erreur. Le raise permet de creer nos propres conditions d'erreur.
Le except ValueError capture a la fois les erreurs de conversion et les erreurs levees
manuellement.

4. DEFI AUTONOME (ACTIVE RECALL)

Cree un programme qui accede a un dictionnaire de clients. Le programme tente

d'afficher l'email d'un client dont le nom est donne. Si le client n'existe pas
(KeyError), affiche "Client non trouve". Si l'email existe mais est vide (string vide),
leve une exception personnalisee avec raise et intercepte-la pour afficher "Email
manquant". Simule avec un dictionnaire contenant {"Alice": "alice@[Link]", "Bob":
""} et teste avec "Alice", "Bob", et "Charlie". Utilise try/except/else/finally si possible.

---

Tu as maintenant les 10 premiers jours. Ecris "v" pour recevoir les jours 11 a 20.