Guide d'initiation à Python

Tu veux apprendre à programmer ? Bonne nouvelle : tu as choisi le bon langage. Python est celui que tu utilises en SNT (Seconde) et en NSI (Première et Terminale), mais c'est aussi un outil utilisé chaque jour par des développeurs, des chercheurs, des créateurs de jeux et des scientifiques du monde entier.

Ce guide t'accompagne de A à Z : on commence par comprendre ce qu'est Python (avec quelques anecdotes étonnantes), puis on installe tout ce qu'il faut sur Windows, et enfin on écrit de vrais programmes ensemble.

💡 Comment lire ce guide ?

Pas besoin de tout faire d'un coup. Les parties 1 et 2 se lisent tranquillement, la partie 3 (installation) prend environ 20 minutes, et les parties suivantes peuvent être découvertes au fil des semaines.

---

Partie 1 : C'est quoi, Python ? {: .partie }

Un langage de programmation, c'est quoi ? {: .sous-partie }

Un ordinateur est très puissant… mais il ne comprend qu'une chose : des suites de 0 et de 1. Écrire directement en 0 et en 1, ce serait l'enfer. Un langage de programmation sert d'intermédiaire : tu écris des instructions dans un langage proche de l'anglais, et un programme se charge de les traduire pour la machine.

Python, un langage « interprété » {: .sous-partie }

Python est un langage interprété. Concrètement, un programme appelé l'interpréteur lit ton fichier ligne par ligne, de haut en bas, et exécute chaque instruction au fur et à mesure.

Imagine un traducteur simultané à l'ONU : il traduit chaque phrase dès qu'elle est prononcée, sans attendre la fin du discours. C'est exactement ce que fait l'interpréteur Python avec ton code.

Pourquoi Python est parfait pour débuter {: .sous-partie }

• Il est lisible. Un programme Python ressemble presque à des phrases en anglais. Par exemple, if note >= 10: se lit « si la note est supérieure ou égale à 10 ».
• Il est gratuit et libre. Tout le monde peut l'installer, l'utiliser et même voir comment il est fabriqué.
• Il sert à tout. Sites web, intelligence artificielle, analyse de données, robotique, jeux, automatisation de tâches répétitives…
• La communauté est énorme. Quelle que soit ta question, quelqu'un l'a déjà posée (et quelqu'un y a déjà répondu).

---

Partie 2 : Un peu d'histoire (et des anecdotes) {: .partie }

Un projet né pendant les vacances de Noël {: .sous-partie }

Fin décembre 1989, un programmeur néerlandais nommé Guido van Rossum travaille au CWI, un centre de recherche d'Amsterdam. Les bureaux sont fermés pour les fêtes, et il cherche un projet pour s'occuper pendant les vacances. Il décide alors de créer son propre langage de programmation, simple à lire et agréable à utiliser.

La première version publique de Python sort en février 1991. Plus de 35 ans plus tard, c'est l'un des langages les plus utilisés au monde.

Les grandes dates {: .sous-partie }

🎭 Anecdote n°1 : rien à voir avec le serpent ! {: .sous-partie }

Malgré le logo avec deux serpents, le nom Python ne vient pas de l'animal. Guido était fan des Monty Python, un groupe d'humoristes britanniques des années 1970, et il voulait un nom court, un peu mystérieux et rigolo.

Cet héritage se retrouve partout : dans la documentation officielle de Python, les exemples utilisent souvent les mots spam et eggs (« jambon en boîte » et « œufs ») au lieu de noms banals, en hommage à un célèbre sketch des Monty Python. On y voit un restaurant qui met du Spam (une marque de jambon en conserve) dans absolument tous ses plats, pendant qu'un groupe de clients chante « Spam, spam, spam ! » à tue-tête, au point qu'on n'entend plus rien d'autre.

📧 Le savais-tu ? Le « spam » de ta boîte mail vient du même sketch !

Ce n'est pas lié au langage Python, mais c'est une belle preuve de l'influence des Monty Python sur la culture des premiers informaticiens. Dans les années 1980 et 1990, les utilisateurs des premiers forums et jeux en ligne ont commencé à appeler « spam » les messages répétés et envahissants qui noyaient les vraies conversations, exactement comme les chants du sketch. Le mot est resté, et il désigne aujourd'hui tous les messages indésirables. Le nom « Python » et le mot « spam » sont donc deux héritages différents de la même troupe d'humoristes.

Le clin d'œil va encore plus loin avec IDLE, le petit éditeur de code fourni gratuitement avec Python. Officiellement, son nom est un acronyme : Integrated Development and Learning Environment (« environnement intégré de développement et d'apprentissage »). Mais ce n'est pas un hasard s'il s'écrit exactement comme le nom d'Eric Idle, l'un des membres des Monty Python ! Les programmeurs adorent ce genre de jeu de mots : on trouve d'abord le nom qui fait sourire, puis on invente une signification sérieuse pour aller avec.

💡 Le savais-tu ?

IDLE est installé en même temps que Python. Pour le lancer, tape py -m idlelib dans l'invite de commandes. Il est très simple, mais parfait pour faire de petits tests. Dans ce guide, on utilisera plutôt VS Code, plus complet.

👑 Anecdote n°2 : le « dictateur bienveillant à vie » {: .sous-partie }

Pendant près de 30 ans, Guido van Rossum avait le dernier mot sur toutes les décisions concernant Python. La communauté lui avait donné un titre officiel et plein d'humour : BDFL, pour Benevolent Dictator For Life (« dictateur bienveillant à vie »). En 2018, il a laissé sa place, et Python est désormais dirigé par un conseil de cinq personnes élues.

🥧 Anecdote n°3 : le « Pi » du Raspberry Pi {: .sous-partie }

Tu connais peut-être le Raspberry Pi, ce petit ordinateur pas plus grand qu'une carte bancaire, très utilisé dans les lycées et les clubs de robotique. Le « Pi » de son nom fait référence à Python : dès le départ, ses créateurs voulaient que ce soit le langage principal pour programmer dessus.

🌌 Anecdote n°4 : Python a aidé à photographier un trou noir {: .sous-partie }

En 2019, des scientifiques ont dévoilé la toute première image d'un trou noir. Pour traiter les énormes quantités de données récoltées par des télescopes répartis sur toute la planète, ils ont utilisé, entre autres outils, des bibliothèques Python.

🥚 Anecdote n°5 : les « œufs de Pâques » cachés dans Python {: .sous-partie }

En informatique, un « œuf de Pâques » (en anglais easter egg) est une surprise cachée volontairement par les développeurs dans un programme, un site ou un jeu : une blague, un message secret, un mini-jeu… On l'appelle ainsi parce qu'il faut le chercher, comme les œufs en chocolat qu'on cache dans le jardin à Pâques.

🕹️ Le tout premier easter egg célèbre

En 1979, chez Atari, les créateurs de jeux vidéo n'avaient pas le droit de signer leurs œuvres : leur nom n'apparaissait nulle part. Le programmeur Warren Robinett a alors caché son nom dans une salle secrète de son jeu Adventure, accessible seulement en trouvant un minuscule point gris presque invisible. Quand un joueur l'a découvert, Atari a décidé de le garder, et un responsable de l'entreprise l'a comparé à une chasse aux œufs de Pâques. Le nom est resté !

Depuis, les easter eggs sont partout : des personnages secrets dans les jeux, des niveaux cachés, des clins d'œil entre studios… Même les applications sérieuses en contiennent. Par exemple, tape « do a barrel roll » dans le moteur de recherche Google : la page fait un tonneau !

Les développeurs de Python ont, eux aussi, caché quelques surprises dans le langage. Une fois Python installé (on y arrive !), tu pourras les tester :

• import this affiche le Zen de Python, un petit poème de 19 règles qui résume la philosophie du langage. Par exemple : « Simple vaut mieux que complexe ».
• import antigravity ouvre ton navigateur sur une bande dessinée (en anglais) où un personnage s'envole… grâce à Python.
• from __future__ import braces est une blague : les accolades { } utilisées par d'autres langages pour délimiter les blocs de code ne seront jamais ajoutées à Python. Essaie, et lis bien la réponse !

🌍 Qui utilise Python ? {: .sous-partie }

Python est utilisé par des entreprises et organisations que tu connais forcément : YouTube, Instagram, Netflix, Spotify, la NASA… C'est aussi le langage numéro un pour l'intelligence artificielle : la grande majorité des outils d'IA modernes sont développés avec Python.

---

Partie 3 : Installer Python sur Windows 🛠️ {: .partie }

Pour programmer, tu as besoin de deux outils :

1. Python : l'interpréteur qui lit et exécute ton code.
2. Visual Studio Code (ou VS Code) : un éditeur de code, c'est-à-dire un traitement de texte spécialement conçu pour écrire des programmes.

⚠️ Avant de commencer

Si tu utilises un ordinateur du lycée ou un ordinateur familial, demande l'autorisation à la personne qui s'en occupe. L'installation peut nécessiter un mot de passe administrateur.

Étape 1 : Installer Python avec le « Python install manager » {: .sous-partie }

Depuis peu, la méthode officielle pour installer Python sur Windows est un petit outil appelé Python install manager (le gestionnaire d'installation de Python). Son gros avantage : il installe Python correctement et le met à jour tout seul. Il fonctionne sur Windows 10 et Windows 11.

Méthode A : depuis le Microsoft Store (la plus simple)

1. Ouvre l'application Microsoft Store (l'icône du sac de courses dans la barre des tâches).
2. Dans la barre de recherche, tape Python install manager.
3. Vérifie que l'éditeur est bien la Python Software Foundation, puis clique sur Obtenir (ou Installer).

Méthode B : depuis le site officiel

1. Rends-toi sur python.org/downloads.
2. Clique sur le gros bouton jaune de téléchargement pour Windows.
3. Ouvre le fichier téléchargé et suis les instructions.

Ensuite, dans les deux cas : la configuration

1. Ouvre le menu Démarrer, tape cmd et appuie sur Entrée. Une fenêtre noire s'ouvre : c'est l'invite de commandes (on l'appelle aussi « terminal »).
2. Tape la commande suivante, puis appuie sur Entrée :

```text
py install --configure
```

1. L'outil te pose quelques questions. Pour chacune, réponds Y (pour Yes) puis Entrée. Il va notamment proposer de configurer Windows pour qu'il retrouve Python facilement, et d'installer la dernière version de Python.
2. Patiente pendant le téléchargement, puis ferme la fenêtre une fois que c'est terminé.

💡 Astuce : vérifie que tout fonctionne

Ouvre une nouvelle invite de commandes (c'est important, l'ancienne ne voit pas encore les changements) et tape :

python --version

Si tu vois s'afficher quelque chose comme Python 3.14.7 ou Python 3.15.0, c'est gagné ! 🎉

🆘 Ça ne marche pas ?

Si le Microsoft Store s'ouvre quand tu tapes python, ou si Windows te répond que la commande est introuvable : redémarre ton ordinateur, puis relance py install --configure et réponds bien Y à toutes les questions.

📝 Et l'ancien installateur ?

Tu trouveras peut-être d'anciens tutoriels qui parlent d'un fichier .exe et d'une case « Add python.exe to PATH » à cocher absolument. Cette méthode existe encore pour les versions actuelles, mais elle va disparaître avec Python 3.16. Le gestionnaire d'installation fait ce travail pour toi, sans case à cocher.

Étape 2 : Installer Visual Studio Code {: .sous-partie }

1. Rends-toi sur code.visualstudio.com.
2. Télécharge la version pour Windows et installe-la en laissant les options par défaut. Si l'installateur te propose de cocher « Ajouter l'action Ouvrir avec Code », coche-la : c'est très pratique.
3. Lance VS Code.

💡 Astuce : VS Code en français

VS Code s'affiche en anglais au départ. Pour le passer en français, clique sur l'icône Extensions à gauche (les quatre petits carrés), cherche French Language Pack, installe-le, puis redémarre VS Code quand il te le propose.

Étape 3 : Installer l'extension Python dans VS Code {: .sous-partie }

1. Dans VS Code, clique sur l'icône Extensions dans la barre de gauche (les quatre petits carrés).
2. Dans la barre de recherche, tape Python.
3. Installe l'extension Python publiée par Microsoft (vérifie bien le nom de l'éditeur, il y a beaucoup d'imitations).

Cette extension ajoute la coloration du code, des suggestions pendant que tu tapes, la détection d'erreurs et le fameux bouton pour lancer tes programmes.

Plan B : Thonny, l'éditeur tout-en-un {: .sous-partie }

Si l'installation te pose trop de problèmes, ou si VS Code te paraît trop chargé, il existe une alternative pensée pour les débutants : Thonny (thonny.org). Il s'installe en un clic, contient déjà Python, et affiche les choses très simplement. Beaucoup de lycées l'utilisent. Tu pourras toujours passer à VS Code plus tard.

---

Partie 4 : Ton premier programme 🚀 {: .partie }

Préparer ton espace de travail {: .sous-partie }

1. Crée un dossier vide sur ton bureau et nomme-le Code_Python.
2. Dans VS Code, va dans le menu Fichier > Ouvrir le dossier… et choisis ton dossier Code_Python.
3. Si VS Code te demande si tu fais confiance aux auteurs des fichiers, réponds Oui (c'est toi l'auteur !).
4. Dans la colonne de gauche, clique sur l'icône Nouveau fichier et nomme-le bonjour.py.

💡 Pourquoi .py ?

L'extension .py indique à l'ordinateur (et à VS Code) que ce fichier contient du code Python. Sans elle, VS Code ne saurait pas comment l'exécuter.

⚠️ Règle pour nommer tes fichiers

Pas d'espaces, pas d'accents, pas de caractères spéciaux. Écris calcul_moyenne.py plutôt que Calcul de la moyenne.py. Et surtout, ne donne jamais à ton fichier le nom d'un module Python existant, comme random.py ou turtle.py : ton programme se mettrait à planter de façon incompréhensible !

Écrire et lancer ton premier code {: .sous-partie }

Tape (ou copie-colle) cette ligne dans bonjour.py :

```python
print("Bonjour, je suis en train d'apprendre Python !")
```

Pour l'exécuter :

1. Enregistre ton fichier avec Ctrl + S. Un petit rond blanc à côté du nom du fichier signifie qu'il n'est pas enregistré.
2. Clique sur le bouton ▷ (Play) en haut à droite de la fenêtre.
3. Un terminal s'ouvre en bas de l'écran et affiche :

```text
Bonjour, je suis en train d'apprendre Python !
```

Bravo, tu viens d'écrire ton premier programme ! 🎉

🆘 Le bouton ▷ n'apparaît pas, ou VS Code dit qu'il ne trouve pas Python ?

Appuie sur Ctrl + Maj + P, tape Python: Select Interpreter (« Sélectionner l'interpréteur »), puis choisis la version de Python que tu as installée dans la liste.

Le mode interactif : la calculatrice géante {: .sous-partie }

Python possède aussi un mode interactif, parfait pour tester rapidement une idée. Dans le terminal de VS Code (ou dans l'invite de commandes), tape python puis Entrée. Tu vois apparaître trois chevrons >>> : Python attend tes ordres !

```text

>> 2 + 3

5

>> 7 * 6

42

>> 2 ** 10

1024

>> "ha" * 5

'hahahahaha'
```

C'est le moment idéal pour tester les œufs de Pâques de la partie 2 : tape import this et regarde ce qui se passe.

Pour quitter le mode interactif, tape exit() puis Entrée.

---

Partie 5 : Les bases du langage 📝 {: .partie }

Les commentaires {: .sous-partie }

Tout ce qui suit un dièse # est un commentaire : Python l'ignore complètement. Les commentaires servent à expliquer ton code aux humains (y compris à toi-même dans trois mois !).

```python

Ceci est un commentaire : Python ne le lit pas.

print("Ceci, par contre, est exécuté.") # Un commentaire peut aussi se placer en fin de ligne.
```

Les variables : des boîtes avec une étiquette {: .sous-partie }

Une variable est comme une boîte sur laquelle tu colles une étiquette. Tu ranges une valeur dedans, et tu peux la retrouver plus tard grâce à son nom.

```python
prenom = "Lucas" # Du texte : on l'appelle une « chaîne de caractères » (type str)
age = 15 # Un nombre entier (type int)
taille = 1.72 # Un nombre à virgule (type float) : attention, on utilise un POINT !
est_en_seconde = True # Vrai ou faux : un « booléen » (type bool)

print(prenom)
print(age + 1)
```

💡 Astuce : bien nommer ses variables

Choisis des noms qui veulent dire quelque chose : note_maths est bien plus clair que n ou x2. En Python, on sépare les mots par des tirets bas : c'est le style snake_case (le style « serpent », forcément 🐍).

Afficher du texte avec print() et les f-strings {: .sous-partie }

La fonction print() affiche du texte dans le terminal. Pour mélanger du texte et des variables, la méthode la plus pratique est la f-string : on met un f devant les guillemets, et les variables entre accolades { }.

```python
prenom = "Inès"
score = 1250

print(f"Bravo {prenom}, tu as marqué {score} points !")
```

Demander quelque chose à l'utilisateur avec input() {: .sous-partie }

La fonction input() affiche une question et attend que l'utilisateur tape une réponse.

```python
prenom = input("Comment t'appelles-tu ? ")
print(f"Enchanté, {prenom} !")
```

⚠️ Piège classique

input() renvoie toujours du texte, même si l'utilisateur tape un nombre. Pour faire des calculs, il faut convertir ce texte avec int() (nombre entier) ou float() (nombre à virgule) :

age = int(input("Quel âge as-tu ? "))

Les conditions : if, elif, else {: .sous-partie }

Les conditions permettent à ton programme de prendre des décisions.

```python
note = float(input("Quelle est ta note ? "))

if note >= 16:
print("Excellent travail ! 🌟")
elif note >= 10:
print("Bravo, tu as la moyenne !")
else:
print("Courage, avec un peu de révision ça va le faire.")
```

Les opérateurs de comparaison à connaître :

⚠️ Ne confonds pas = et == !

Un seul = sert à ranger une valeur dans une variable. Deux == servent à comparer deux valeurs.

⭐ La règle d'or : l'indentation {: .sous-partie }

C'est LA particularité de Python. Beaucoup d'autres langages utilisent des accolades { } ou des mots comme end pour indiquer où commence et où finit un bloc de code. Python, lui, utilise le décalage vers la droite : on appelle ça l'indentation.

```python
if note >= 10:
print("Cette ligne fait partie du if.") # décalée : dans le bloc
print("Celle-ci aussi.") # décalée : dans le bloc
print("Celle-ci est exécutée dans tous les cas.") # pas décalée : hors du bloc
```

Les règles à retenir :

• Une ligne qui se termine par deux-points : annonce toujours un bloc indenté juste en dessous.
• L'indentation standard est de 4 espaces. Dans VS Code, la touche Tab insère automatiquement ces 4 espaces.
• Toutes les lignes d'un même bloc doivent avoir exactement le même décalage.

💡 Astuce VS Code

Sélectionne plusieurs lignes et appuie sur Tab pour les décaler toutes d'un coup vers la droite, ou sur Maj + Tab pour les décaler vers la gauche.

Les boucles : répéter sans se fatiguer {: .sous-partie }

La boucle for répète une action un nombre de fois connu à l'avance.

```python

range(5) produit les nombres 0, 1, 2, 3, 4 (le 5 est exclu !)

for i in range(5):
print(f"Le carré de {i} est {i * i}")
```

La boucle while (« tant que ») répète une action tant qu'une condition est vraie.

```python
compteur = 10
while compteur > 0:
print(compteur)
compteur = compteur - 1
print("Décollage ! 🚀")
```

🆘 Ton programme ne s'arrête plus ?

Tu as sans doute créé une boucle infinie (une condition qui reste toujours vraie). Pas de panique : clique dans le terminal et appuie sur Ctrl + C pour arrêter le programme.

Les listes : ranger plusieurs valeurs {: .sous-partie }

Une liste permet de stocker plusieurs valeurs dans une seule variable, entre crochets [ ].

```python
jeux = ["Minecraft", "Mario Kart", "Rocket League"]

print(jeux[0]) # Affiche "Minecraft" : on compte à partir de 0 !
jeux.append("Tetris") # Ajoute un élément à la fin
print(len(jeux)) # Affiche 4 : le nombre d'éléments

for jeu in jeux:
print(f"J'aime jouer à {jeu}")
```

Les dictionnaires : ranger des valeurs avec une étiquette {: .sous-partie }

Une liste range des valeurs dans l'ordre, et on les retrouve par leur position (0, 1, 2…). Mais parfois, on veut plutôt retrouver une valeur par son nom. Pour ça, Python a le dictionnaire : il range des paires clé : valeur, entre accolades { }.

C'est comme un vrai dictionnaire : on cherche un mot (la clé) pour trouver sa définition (la valeur). Ou comme la fiche d'un personnage de jeu vidéo, avec une ligne pour le pseudo, une pour le niveau, une pour les points de vie…

```python
joueur = {
"pseudo": "Shadow_Fox",
"niveau": 12,
"points_de_vie": 87.5,
"premium": False,
}

print(joueur["pseudo"]) # Shadow_Fox : on retrouve une valeur grâce à sa clé
joueur["niveau"] = 13 # on modifie une valeur existante
joueur["guilde"] = "Les Canards" # on ajoute une nouvelle paire clé : valeur

print(joueur.get("arme", "aucune")) # aucune : la clé n'existe pas, on obtient la valeur par défaut

for cle, valeur in joueur.items(): # parcourir toutes les paires
print(f"{cle} → {valeur}")
```

⚠️ Piège classique

Si tu demandes une clé qui n'existe pas, par exemple joueur["arme"], Python plante avec une KeyError. Pour éviter ça, utilise joueur.get("arme"), qui renvoie None (ou la valeur par défaut que tu choisis) au lieu de planter.

Le format JSON : garder tes données après la fermeture du programme {: .sous-partie }

Quand un programme se termine, tout ce qu'il avait en mémoire disparaît. Pour garder des données (une sauvegarde de jeu, des réglages, des scores), il faut les écrire dans un fichier. Le format le plus pratique pour ça s'appelle JSON (JavaScript Object Notation).

Bonne nouvelle : un fichier JSON ressemble presque trait pour trait à un dictionnaire Python ! C'est d'ailleurs le format utilisé par énormément d'applications, de jeux et de sites web pour échanger et stocker des informations. Le module json, livré avec Python, fait la traduction dans les deux sens :

• json.dump() écrit un dictionnaire dans un fichier ;
• json.load() lit le fichier et redonne un dictionnaire.

Voici un petit système de sauvegarde de partie (sauvegarde.py) :

```python
import json

1. Un dictionnaire qui contient des valeurs de tous les types

partie = {
"pseudo": "Shadow_Fox",
"niveau": 13,
"or": 2450.75,
"mode_difficile": True,
"familier": None,
"inventaire": ["épée", "potion", "potion", "carte"],
"position": {"monde": "Forêt", "x": 120, "y": -34},
}

2. Sauvegarder le dictionnaire dans un fichier JSON

with open("sauvegarde.json", "w", encoding="utf-8") as fichier:
json.dump(partie, fichier, ensure_ascii=False, indent=2)
print("Partie sauvegardée !")

3. Plus tard (même après avoir fermé le programme), on recharge la partie

with open("sauvegarde.json", encoding="utf-8") as fichier:
partie_chargee = json.load(fichier)

print(f"Bon retour, {partie_chargee['pseudo']} ! Tu es niveau {partie_chargee['niveau']}.")
print(f"Tu es dans la zone : {partie_chargee['position']['monde']}")
print(f"Nombre de potions : {partie_chargee['inventaire'].count('potion')}")
```

Lance le script, puis ouvre le fichier sauvegarde.json qui vient d'apparaître dans ton dossier, dans VS Code :

```json
{
"pseudo": "Shadow_Fox",
"niveau": 13,
"or": 2450.75,
"mode_difficile": true,
"familier": null,
"inventaire": [
"épée",
"potion",
"potion",
"carte"
],
"position": {
"monde": "Forêt",
"x": 120,
"y": -34
}
}
```

Ce qu'on peut mettre dans un fichier JSON :

On peut imbriquer tout ça autant qu'on veut : des listes dans des dictionnaires, des dictionnaires dans des listes… C'est ce qui rend JSON si pratique.

⚠️ Ce que JSON ne sait pas faire

- Les clés d'un objet JSON sont toujours du texte : si tu utilises un nombre comme clé, il revient sous forme de texte (1 devient "1").

- Les tuples deviennent des listes, et les ensembles (set) ou les dates ne peuvent pas être sauvegardés directement : il faut d'abord les convertir (une date en texte, par exemple).

- JSON est fait pour les données, pas pour le code : on ne peut pas y ranger une fonction.

💡 Pourquoi ensure_ascii=False et indent=2 ?

ensure_ascii=False garde les accents lisibles (épée au lieu de \u00e9p\u00e9e), et indent=2 met le fichier en forme avec des retraits, pour qu'il soit facile à lire par un humain.

Les fonctions : créer tes propres commandes {: .sous-partie }

Une fonction est un morceau de code auquel tu donnes un nom, pour pouvoir le réutiliser autant de fois que tu veux. On la crée avec le mot-clé def.

```python
def dire_bonjour(prenom):
print(f"Salut {prenom}, bienvenue dans le club Python !")

def carre(nombre):
return nombre * nombre # return renvoie un résultat

dire_bonjour("Emma")
dire_bonjour("Yanis")
print(carre(7)) # Affiche 49
```

---

Partie 6 : Comprendre les messages d'erreur 🐞 {: .partie }

Faire des erreurs, c'est normal. Même les développeurs professionnels en font toute la journée ! Le secret, c'est de savoir lire les messages d'erreur. Ils font peur au début, mais ils sont là pour t'aider.

💡 La méthode pour lire une erreur

1. Regarde la dernière ligne du message : elle donne le type d'erreur et une explication.

2. Cherche la mention line 12 (par exemple) : elle t'indique la ligne où Python s'est arrêté.

3. Vérifie cette ligne et celle juste au-dessus : l'erreur vient souvent de la ligne précédente (une parenthèse oubliée, par exemple).

Les erreurs les plus fréquentes :

Exemple : ce code contient une erreur.

```python
age = 15
print("Tu as " + age + " ans")
```

Python répond :

```text
TypeError: can only concatenate str (not "int") to str
```

Traduction : « je ne peux coller que du texte à du texte, pas un nombre ». La solution ? Utiliser une f-string : print(f"Tu as {age} ans").

🆘 Toujours bloqué ?

Copie la dernière ligne du message d'erreur et colle-la dans un moteur de recherche. Tu tomberas presque toujours sur quelqu'un qui a eu exactement le même problème.

---

Partie 7 : Des scripts à tester 💻 {: .partie }

Crée un nouveau fichier .py pour chaque exemple, copie le code, enregistre et lance-le. Ensuite, modifie-le : c'est en bidouillant qu'on apprend le mieux !

Script 1 : Calculer ton âge {: .sous-partie }

```python
from datetime import date

annee_naissance = int(input("En quelle année es-tu né(e) ? "))
annee_actuelle = date.today().year # Python récupère l'année en cours tout seul

age = annee_actuelle - annee_naissance
print(f"En {annee_actuelle}, tu as ou tu vas avoir {age} ans !")
```

Ce que tu apprends : utiliser input(), convertir avec int(), et importer un module (ici datetime, qui gère les dates).

Script 2 : Calculer ta moyenne {: .sous-partie }

```python
notes = [] # Une liste vide qu'on va remplir

nombre_de_notes = int(input("Combien de notes veux-tu entrer ? "))

for i in range(nombre_de_notes):
saisie = input(f"Note n°{i + 1} : ")
saisie = saisie.replace(",", ".") # Accepte 12,5 comme 12.5
notes.append(float(saisie))

moyenne = sum(notes) / len(notes)

print(f"Ta moyenne est de {moyenne:.2f} / 20") # .2f = deux chiffres après la virgule
print(f"Ta meilleure note : {max(notes)}")
print(f"Ta moins bonne note : {min(notes)}")
```

Ce que tu apprends : les listes, la boucle for, et les fonctions toutes prêtes sum(), len(), max() et min().

Script 3 : Le jeu du nombre mystère {: .sous-partie }

```python
import random

nombre_mystere = random.randint(1, 100) # Un nombre au hasard entre 1 et 100
essais = 0
trouve = False

print("J'ai choisi un nombre entre 1 et 100. À toi de le deviner !")

while not trouve:
proposition = int(input("Ta proposition : "))
essais = essais + 1

if proposition nombre_mystere:
print("C'est moins ! ⬇️")
else:
trouve = True

print(f"Bravo ! Tu as trouvé {nombre_mystere} en {essais} essais. 🎉")
```

Ce que tu apprends : le module random, la boucle while et les conditions avec elif.

Script 4 : Le lanceur de dés {: .sous-partie }

```python
import random

def lancer_de(faces):
return random.randint(1, faces)

nombre_de_des = int(input("Combien de dés veux-tu lancer ? "))
faces = int(input("Combien de faces par dé (6, 20…) ? "))

resultats = []
for i in range(nombre_de_des):
resultats.append(lancer_de(faces))

print(f"Résultats : {resultats}")
print(f"Total : {sum(resultats)}")
```

Ce que tu apprends : créer ta propre fonction avec def et return.

Script 5 : Dessiner avec la tortue 🐢 {: .sous-partie }

Python contient un module appelé turtle : une petite tortue se déplace à l'écran et trace un trait derrière elle. Parfait pour créer des dessins avec du code !

```python
import turtle

tortue = turtle.Turtle()
tortue.speed(0) # 0 = vitesse maximale

couleurs = ["red", "orange", "yellow", "green", "blue", "purple"]

for i in range(120):
tortue.pencolor(couleurs[i % 6]) # % donne le reste de la division : 0, 1, 2, 3, 4, 5, 0, 1…
tortue.forward(i * 2) # avance
tortue.left(59) # tourne à gauche de 59 degrés

turtle.done() # garde la fenêtre ouverte à la fin
```

Une fenêtre s'ouvre et une spirale multicolore se dessine sous tes yeux. Essaie de changer l'angle 59 en 90, 120 ou 144 pour voir ce qui se passe !

⚠️ Rappel important

Ne nomme surtout pas ce fichier turtle.py ! Python chercherait le module dans ton propre fichier au lieu du vrai module, et rien ne fonctionnerait. Appelle-le plutôt dessin_spirale.py.

Script 6 : Le générateur de mots de passe 🔐 {: .sous-partie }

Ce script est un vrai outil que tu pourras garder et utiliser ! Il propose deux façons de protéger tes comptes :

• un mot de passe complexe de 15 caractères ou plus, qui mélange minuscules, majuscules, chiffres et caractères spéciaux (par exemple y$d8BSSouQ3w3rL*EBC6) ;
• une phrase de passe, c'est-à-dire plusieurs mots tirés au hasard et reliés par le caractère de ton choix (par exemple ecureuil_kagami_shiro_kitsune_pan_lutin_kame_microbe_96). C'est plus long, mais beaucoup plus facile à retenir. Les mots peuvent être piochés en français, en anglais, en japonais écrit en lettres latines, ou dans un mélange des trois.

Le programme est plus long que les précédents, mais il est découpé en fonctions : chacune fait une seule petite tâche. Lis-les une par une, les commentaires sont là pour t'aider. Nomme ton fichier generateur_mdp.py.

```python
import math
import secrets
import string

Les caractères spéciaux autorisés (certains sites refusent les plus exotiques)

SYMBOLES = "!@#$%&*?-_+=.:;"

Les caractères faciles à confondre à l'œil : l, I, 1, O, 0, o

AMBIGUS = "lI1O0o"

Les listes de mots pour les phrases de passe (sans accents, pour éviter les soucis de clavier)

MOTS_FRANCAIS = [
"abeille", "abricot", "acrobate", "agenda", "aigle", "aiguille", "album", "alpaga", "ampoule", "ananas",
"ancre", "antenne", "aquarium", "arbre", "arcenciel", "argent", "armoire", "artichaut", "asperge", "asteroide",
"astre", "atelier", "autruche", "aventure", "avion", "badminton", "bagage", "baguette", "balcon", "baleine",
"balle", "bambou", "banane", "banquise", "barbecue", "basilic", "bateau", "batterie", "bijou", "biscotte",
"biscuit", "bison", "blaireau", "bobsleigh", "boomerang", "bouclier", "bougie", "boulanger", "boussole", "bracelet",
"branche", "brioche", "brocoli", "buffle", "cabane", "cacahuete", "cactus", "cahier", "calamar", "camion",
"canape", "canard", "canyon", "capitaine", "caramel", "carnaval", "carotte", "cascade", "casque", "castor",
"cerfvolant", "cerise", "chameau", "chandelle", "chantier", "chapeau", "chaton", "chocolat", "cigogne", "citron",
"citrouille", "clavier", "clementine", "coccinelle", "cocotier", "colibri", "comete", "concert", "coquillage", "corsaire",
"couronne", "crayon", "crevette", "crocodile", "cuisine", "cyclone", "cymbale", "dauphin", "desert", "detective",
"diamant", "dinosaure", "dirigeable", "domino", "dragon", "echarpe", "echelle", "eclair", "ecureuil", "elephant",
"epouvantail", "escargot", "etoile", "explorateur", "falaise", "fanfare", "fantome", "farandole", "fenetre", "feutre",
"flamant", "fleuve", "flocon", "flute", "fourmi", "fromage", "fusee", "galaxie", "gaufre", "geyser",
"girafe", "glacier", "gondole", "gorille", "goudron", "grenouille", "griffon", "grillon", "guitare", "hamac",
"harmonica", "herisson", "hibou", "hippocampe", "hirondelle", "horloge", "igloo", "iguane", "jaguar", "jardin",
"jongleur", "jonquille", "kangourou", "kayak", "kiwi", "koala", "lagune", "lampion", "lanterne", "lapin",
"lasagne", "lavande", "libellule", "licorne", "limonade", "lionne", "lucarne", "lutin", "magicien", "mammouth",
"mandarine", "manege", "marelle", "marmotte", "marteau", "medaille", "melodie", "meringue", "meteore", "microbe",
"mosaique", "moustique", "mouton", "musique", "narval", "navette", "noisette", "nuage", "oasis", "ocean",
"omelette", "orange", "orchidee", "oregano", "origami", "ouragan", "palmier", "panache", "panda", "papillon",
"parapluie", "pastille", "pelican", "pelouse", "perroquet", "phare", "pieuvre", "pinceau", "pingouin", "pirate",
"pistache", "planete", "planeur", "plume", "poisson", "poivron", "pommade", "pompier", "potiron", "puzzle",
"pyramide", "quartz", "radis", "raquette", "raton", "reglisse", "renard", "requin", "rhinoceros", "robot",
"rocher", "roulotte", "sablier", "salade", "sapin", "sardine", "satellite", "saxophone", "scarabee", "serpent",
"sirene", "sirop", "soleil", "sorbet", "sorcier", "spatule", "tabouret", "tambour", "tapir", "telescope",
"tempete", "tigre", "tipi", "toboggan", "tomate", "tortue", "toucan", "tracteur", "trampoline", "trompette",
"tulipe", "tunnel", "ukulele", "valise", "vampire", "vanille", "velo", "ventilateur", "violon", "vitrail",
"volcan", "voyage", "wagon", "xylophone", "yaourt", "yeti", "zebre", "zeppelin",
]

MOTS_ANGLAIS = [
"acorn", "actor", "admiral", "alarm", "album", "alien", "anchor", "angel", "apple", "archer",
"arrow", "artist", "astronaut", "autumn", "avocado", "badge", "bakery", "balloon", "bamboo", "banana",
"banjo", "barrel", "basket", "beacon", "beaver", "blanket", "blizzard", "blossom", "bonfire", "bottle",
"bracelet", "breeze", "bridge", "bubble", "bucket", "buffalo", "butter", "button", "cabin", "cactus",
"camera", "candle", "canoe", "canyon", "captain", "carpet", "castle", "cattle", "cherry", "chimney",
"circus", "cliff", "clock", "cloud", "clover", "coconut", "comet", "compass", "cookie", "copper",
"cottage", "cowboy", "crayon", "cricket", "crystal", "cupcake", "curtain", "daisy", "desert", "diamond",
"dolphin", "donkey", "dragon", "drum", "eagle", "echo", "engine", "falcon", "feather", "fiddle",
"firefly", "flag", "flute", "forest", "fossil", "fountain", "fox", "galaxy", "garden", "giant",
"ginger", "glacier", "goblin", "gravel", "guitar", "hammer", "harbor", "harvest", "helmet", "honey",
"horizon", "island", "jacket", "jelly", "jungle", "kettle", "kingdom", "kitten", "ladder", "lantern",
"lemon", "lighthouse", "lizard", "lobster", "magnet", "maple", "marble", "meadow", "meteor", "mirror",
"monkey", "mountain", "muffin", "needle", "nugget", "ocean", "octopus", "orbit", "orchard", "otter",
"owl", "paddle", "pancake", "parrot", "peanut", "pebble", "pencil", "pepper", "piano", "pickle",
"pillow", "pirate", "planet", "plum", "pocket", "pony", "popcorn", "potato", "puzzle", "quilt",
"rabbit", "rainbow", "raven", "river", "robot", "rocket", "saddle", "sailor", "salmon", "sandwich",
"scarf", "shadow", "shark", "shield", "silver", "skate", "sparrow", "spider", "squirrel", "stable",
"starfish", "storm", "sugar", "summer", "sunset", "swan", "teapot", "thunder", "ticket", "tiger",
"timber", "toast", "tomato", "tractor", "treasure", "trumpet", "tulip", "turtle", "umbrella", "valley",
"velvet", "violin", "volcano", "wagon", "walrus", "wizard", "yogurt", "zebra", "zipper",
]

Des mots japonais écrits en caractères latins (on appelle ça le « rōmaji »)

MOTS_JAPONAIS = [
"aisu", "akai", "ame", "arashi", "asa", "ashi", "bara", "benkyo", "budo", "bunko",
"chawan", "chikyu", "chizu", "daikon", "denwa", "dojo", "ebi", "eki", "enpitsu", "fude",
"fuji", "fune", "furin", "fuyu", "geta", "gohan", "hachi", "hai", "hana", "hanabi",
"haru", "hashi", "hata", "hebi", "hikari", "hikouki", "hiyoko", "hon", "hoshi", "ichigo",
"ika", "inu", "ishi", "ito", "jinja", "kabuki", "kaeru", "kagami", "kaki", "kame",
"kami", "kaminari", "kappa", "kasa", "kawa", "kaze", "keki", "kemuri", "kiku", "kinoko",
"kitsune", "koban", "kodama", "koi", "koma", "kuma", "kumo", "kuri", "kuruma", "kusa",
"maguro", "matsuri", "mikan", "mimi", "mizu", "mochi", "momiji", "momo", "mori", "mushi",
"nabe", "neko", "niji", "ninja", "nori", "nuno", "obake", "ocha", "onigiri", "origami",
"oyama", "pan", "raamen", "ringo", "sakana", "sakura", "samurai", "sato", "sensu", "shiro",
"sora", "sumo", "sushi", "suzu", "takara", "tako", "tamago", "tanuki", "tengu", "tenki",
"tera", "tofu", "tokei", "tomodachi", "tora", "tori", "tsuki", "tsuru", "umi", "unagi",
"usagi", "wasabi", "yama", "yuki", "yume", "zori",
]

def demander_nombre(question, minimum, defaut):
"""Pose une question et redemande tant que la réponse n'est pas valide."""
while True:
reponse = input(f"{question} ({minimum} minimum, Entrée = {defaut}) : ")
if reponse == "":
return defaut
if reponse.isdigit() and int(reponse) >= minimum:
return int(reponse)
print(f"⚠️ Entre un nombre entier supérieur ou égal à {minimum}.")

def demander_oui_non(question):
"""Renvoie True si l'utilisateur répond o (oui), False sinon."""
reponse = input(f"{question} (o/n) : ")
return reponse.lower() == "o"

def retirer(texte, a_retirer):
"""Renvoie le texte sans les caractères de a_retirer."""
resultat = ""
for caractere in texte:
if caractere not in a_retirer:
resultat = resultat + caractere
return resultat

def generer_mot_de_passe(longueur, sans_ambigus):
"""Fabrique un mot de passe avec au moins un caractère de chaque famille."""
minuscules = string.ascii_lowercase # abcdefghijklmnopqrstuvwxyz
majuscules = string.ascii_uppercase # ABCDEFGHIJKLMNOPQRSTUVWXYZ
chiffres = string.digits # 0123456789

if sans_ambigus:
minuscules = retirer(minuscules, AMBIGUS)
majuscules = retirer(majuscules, AMBIGUS)
chiffres = retirer(chiffres, AMBIGUS)

familles = [minuscules, majuscules, chiffres, SYMBOLES]
tous_les_caracteres = minuscules + majuscules + chiffres + SYMBOLES

# 1. On pioche un caractère dans chaque famille : il y en aura forcément de chaque sorte
caracteres = []
for famille in familles:
caracteres.append(secrets.choice(famille))

# 2. On complète au hasard jusqu'à la longueur demandée
while len(caracteres) ⚠️ Pourquoi secrets et pas random ?

Le module random, utilisé dans le jeu du nombre mystère, est parfait pour les jeux… mais pas pour la sécurité. Ses tirages suivent une formule mathématique : avec assez d'informations, quelqu'un de très malin pourrait prédire les suivants. Le module secrets puise son hasard dans le système d'exploitation et a été conçu exactement pour ça : fabriquer des mots de passe, des codes et des clés impossibles à deviner.

💡 C'est quoi, ces « bits » ?

La force d'un mot de passe se mesure en bits. Chaque bit en plus double le nombre d'essais nécessaires pour le trouver au hasard. Un mot de passe de 20 caractères tirés parmi 77 symboles possibles donne environ 125 bits : même avec tous les ordinateurs de la planète, il faudrait bien plus que l'âge de l'Univers pour le trouver ! Pour une phrase de passe, la force dépend du nombre de mots et de la taille de la liste dans laquelle on pioche. Avec la liste japonaise seule (126 mots), chaque mot apporte environ 7 bits. Avec le mélange des trois langues (588 mots), chaque mot en apporte plus de 9 : c'est pour ça que le mélange donne les phrases les plus solides ! Les vrais générateurs utilisent des listes de plusieurs milliers de mots.

🆘 Les règles d'or pour tes mots de passe

- Un mot de passe différent pour chaque compte. Si un site se fait pirater, tes autres comptes restent protégés.

- Ne partage jamais un mot de passe, même avec un ami.

- Pour tous les retenir, utilise un gestionnaire de mots de passe (comme Bitwarden ou KeePassXC, gratuits). Il te suffit alors de retenir un seul mot de passe principal : une bonne phrase de passe est parfaite pour ça !

- Active la double authentification (un code reçu sur ton téléphone) quand un site le propose.

Script 7 : Le chiffre de César 🏛️ {: .sous-partie }

Le principe. Le chiffre de César est l'une des plus anciennes méthodes pour cacher un message. L'idée est toute simple : on remplace chaque lettre par celle qui se trouve un certain nombre de rangs plus loin dans l'alphabet. Ce nombre s'appelle la clé. Avec une clé de 3, le A devient D, le B devient E, le C devient F… Arrivé au bout, on recommence au début : X devient A, Y devient B et Z devient C, comme si l'alphabet était écrit sur une roue.

Ainsi, SALUT devient VDOXW. Pour déchiffrer, il suffit de faire le chemin inverse : reculer de 3 rangs.

Un peu d'histoire. Cette méthode doit son nom à Jules César, le célèbre général romain du Ier siècle avant J.-C. D'après l'historien romain Suétone, il l'utilisait pour sa correspondance secrète, notamment avec ses généraux pendant ses campagnes militaires, avec un décalage de 3. Suétone raconte aussi que son successeur, l'empereur Auguste, utilisait une version encore plus simple, avec un décalage de 1.

À l'époque, c'était efficace, car la plupart des ennemis de Rome ne savaient pas lire, ou ne pensaient pas qu'un message pouvait être codé. Mais au IXe siècle, le savant arabe Al-Kindi, qui travaillait à Bagdad, décrit une méthode redoutable : l'analyse des fréquences. Dans chaque langue, certaines lettres reviennent plus souvent que d'autres (en français, c'est le E). Il suffit donc de repérer la lettre la plus fréquente dans le message chiffré pour deviner la clé. Le chiffre de César était cassé pour toujours.

🎮 Le savais-tu ?

Le chiffre de César n'a pas complètement disparu. Sur Internet, on utilise encore le ROT13 (un décalage de 13) pour cacher les réponses d'une énigme ou les révélations d'un film (les spoilers). Avec un alphabet de 26 lettres, un décalage de 13 a une propriété amusante : appliquer ROT13 deux fois redonne le message de départ !

Nomme ton fichier chiffre_cesar.py :

```python
import unicodedata

ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"

def enlever_accents(texte):
"""Transforme « Éléphant » en « Elephant » : le chiffre de César ne connaît que 26 lettres."""
decompose = unicodedata.normalize("NFD", texte) # sépare « é » en « e » + accent
resultat = ""
for caractere in decompose:
if unicodedata.category(caractere) != "Mn": # "Mn" = les accents isolés, on les jette
resultat = resultat + caractere
return resultat

def decaler_lettre(lettre, decalage):
"""Décale une seule lettre dans l'alphabet, en revenant au début après le Z."""
if lettre.upper() not in ALPHABET:
return lettre # espaces, chiffres, ponctuation : on ne touche à rien

position = ALPHABET.index(lettre.upper()) # A → 0, B → 1, … Z → 25
nouvelle_position = (position + decalage) % 26 # % 26 fait « tourner » l'alphabet
nouvelle_lettre = ALPHABET[nouvelle_position]

if lettre.islower(): # on garde les minuscules en minuscules
nouvelle_lettre = nouvelle_lettre.lower()
return nouvelle_lettre

def cesar(texte, decalage):
"""Chiffre (décalage positif) ou déchiffre (décalage négatif) un texte entier."""
texte = enlever_accents(texte)
resultat = ""
for lettre in texte:
resultat = resultat + decaler_lettre(lettre, decalage)
return resultat

def demander_cle():
"""Demande une clé entre 1 et 25 (3 par défaut, comme Jules César)."""
while True:
reponse = input("Clé de décalage (1 à 25, Entrée = 3) : ")
if reponse == "":
return 3
if reponse.isdigit() and 1 💡 Le secret du modulo %

% donne le reste d'une division. Comme 28 % 26 vaut 2, la lettre en position 25 (Z) décalée de 3 arrive en position 2 (C). Le modulo est l'outil idéal dès que quelque chose doit « faire le tour » : les heures d'une horloge, les jours de la semaine, les lettres de l'alphabet…

⚠️ Pourquoi il ne faut pas l'utiliser pour de vrai

Il n'existe que 25 clés possibles. Comme le montre l'option 3 du script, un ordinateur les teste toutes en une fraction de seconde. Le chiffre de César est parfait pour comprendre les bases de la cryptographie, ou pour s'amuser à échanger des messages secrets entre amis, mais il ne protège rien. Aujourd'hui, tes messages et tes achats en ligne sont protégés par des méthodes mathématiques bien plus solides, comme l'AES.

Script 8 : Le générateur de Fibonacci 🐇 {: .sous-partie }

Le principe. La suite de Fibonacci est une suite de nombres qui se construit avec une seule règle : chaque nombre est la somme des deux précédents. On commence par 0 et 1, puis :

• 0 + 1 = 1
• 1 + 1 = 2
• 1 + 2 = 3
• 2 + 3 = 5
• 3 + 5 = 8, et ainsi de suite.

On obtient : 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144… La suite est infinie, et ses nombres grandissent très vite. En mathématiques, on la note avec une formule : F(n) = F(n − 1) + F(n − 2). On dit que c'est une suite récurrente, parce que chaque terme se calcule à partir des précédents.

Un peu d'histoire. Cette suite porte le nom de Leonardo de Pise, surnommé Fibonacci, un mathématicien italien né vers 1170. Fils d'un marchand, il a grandi en partie en Afrique du Nord, où il a découvert les chiffres indo-arabes (0, 1, 2… 9). En 1202, il publie le Liber Abaci (« le livre du calcul »), qui fait connaître ces chiffres en Europe, où l'on utilisait encore les chiffres romains.

Dans ce livre, il pose un petit problème de lapins : on place un couple de lapins dans un enclos. Chaque mois, chaque couple adulte donne naissance à un nouveau couple, qui devient adulte au bout d'un mois. Combien de couples y aura-t-il au bout d'un an ? En comptant mois après mois, on obtient… la suite de Fibonacci ! Le modèle n'est pas très réaliste (les lapins ne meurent jamais), mais la suite qu'il a fait naître est devenue célèbre.

🌍 Le savais-tu ?

Fibonacci n'est pas le premier à avoir découvert cette suite ! Des savants indiens la connaissaient déjà plusieurs siècles avant lui, en étudiant les rythmes de la poésie en sanskrit (notamment Virahanka, vers le VIIe siècle, puis Hemachandra au XIIe siècle). Et le nom « suite de Fibonacci » ne lui a été donné qu'au XIXe siècle, par le mathématicien français Édouard Lucas.

La suite de Fibonacci dans la nature. Ces nombres apparaissent très souvent dans le monde vivant. Compte les spirales sur le cœur d'un tournesol, d'une pomme de pin ou d'un ananas : tu trouveras le plus souvent deux nombres voisins de la suite, comme 21 et 34, ou 34 et 55. Beaucoup de fleurs ont aussi 3, 5, 8 ou 13 pétales. Ce n'est pas magique : c'est la façon la plus efficace pour une plante de ranger ses graines sans laisser d'espace vide.

Le lien avec le nombre d'or. Si tu divises un nombre de la suite par celui qui le précède (par exemple 89 ÷ 55), tu obtiens un résultat de plus en plus proche de 1,618…, le célèbre nombre d'or, noté φ (la lettre grecque « phi »). L'option 4 du script te permet de le vérifier toi-même.

Nomme ton fichier fibonacci.py :

```python
def fibonacci(n):
"""Renvoie la liste des n premiers termes de la suite de Fibonacci."""
termes = [0, 1] # on part des deux premiers termes
while len(termes) 8} / {termes[i - 1]:= minimum:
return int(reponse)
print(f"⚠️ Entre un nombre entier supérieur ou égal à {minimum}.")

def menu():
print("=== 🐇 Le générateur de Fibonacci ===")
while True:
print()
print("1. Afficher les premiers termes de la suite")
print("2. Afficher tous les termes jusqu'à une limite")
print("3. Tester si un nombre appartient à la suite")
print("4. Découvrir le nombre d'or")
print("5. Quitter")
choix = input("Ton choix : ")

if choix == "1":
n = demander_nombre("Combien de termes ?", 1)
termes = fibonacci(n)
for i in range(len(termes)):
print(f"F({i}) = {termes[i]}")

elif choix == "2":
limite = demander_nombre("Jusqu'à quel nombre ?", 0)
termes = fibonacci_jusqua(limite)
print(", ".join(str(t) for t in termes))
print(f"➡️ {len(termes)} termes trouvés.")

elif choix == "3":
nombre = demander_nombre("Quel nombre veux-tu tester ?", 0)
if est_fibonacci(nombre):
print(f"✅ {nombre} fait partie de la suite de Fibonacci !")
else:
print(f"❌ {nombre} ne fait pas partie de la suite.")

elif choix == "4":
n = demander_nombre("Combien de quotients veux-tu calculer ?", 1)
nombre_d_or(n)

elif choix == "5":
print("Arrivederci ! (« Au revoir » en italien, la langue de Fibonacci) 👋")
break

else:
print("⚠️ Tape un nombre entre 1 et 5.")

menu()
```

Exemple d'utilisation :

```text
Ton choix : 4
Combien de quotients veux-tu calculer ? 8

1 / 1 = 1.0000000000
2 / 1 = 2.0000000000
3 / 2 = 1.5000000000
5 / 3 = 1.6666666667
8 / 5 = 1.6000000000
13 / 8 = 1.6250000000
21 / 13 = 1.6153846154
34 / 21 = 1.6190476190

👀 Les quotients se rapprochent de 1,6180339887… : c'est le nombre d'or !
```

Ce que tu apprends : construire une suite avec une boucle, accéder aux derniers éléments d'une liste avec [-1] et [-2], affecter deux variables en même temps avec a, b = b, a + b, et aligner joliment des nombres dans un affichage avec :>8.

💡 Python ne connaît pas de limite !

Demande les 100 premiers termes avec l'option 1. Le dernier, F(99), vaut 218 922 995 834 555 169 026, un nombre à 21 chiffres ! Beaucoup de langages de programmation plantent ou donnent un résultat faux avec des nombres aussi grands. Python, lui, gère des entiers aussi grands que la mémoire de ton ordinateur le permet.

---

Partie 8 : Défis pour t'entraîner 🧩 {: .partie }

À toi de jouer ! Chaque défi est accompagné d'un indice pour t'aider à démarrer.

1. Le convertisseur de température. Demande une température en degrés Celsius et affiche-la en degrés Fahrenheit.

Indice : la formule est fahrenheit = celsius * 9 / 5 + 32.

1. La table de multiplication. Demande un nombre à l'utilisateur et affiche sa table de multiplication de 1 à 10.

Indice : une boucle for avec range(1, 11).

1. Pair ou impair ? Demande un nombre et indique s'il est pair ou impair.

Indice : un nombre est pair si le reste de sa division par 2 vaut 0, soit nombre % 2 == 0.

1. Le nombre mystère amélioré. Reprends le script 3 et limite le joueur à 7 essais. S'il échoue, révèle le nombre.

Indice : ajoute une condition sur essais dans le while.

1. Le dessin d'une étoile. Avec turtle, dessine une étoile à 5 branches.

Indice : répète 5 fois « avancer de 200, tourner de 144 degrés ».

1. Le générateur de mots de passe renforcé. Ajoute une trentaine de mots de ton choix à l'une des listes du script 6 (ou crée une liste dans une quatrième langue !), puis observe comment la force estimée évolue. Combien de mots faut-il dans une phrase pour atteindre 80 bits ?

Indice : chaque mot apporte math.log2(len(liste)) bits. Tu peux le calculer dans le mode interactif.

1. Le message secret. Chiffre un message avec le script 7 et envoie-le à un ami avec la clé. Puis envoie-lui un message sans la clé : arrive-t-il à le casser ?

Pour aller plus loin : ajoute une option qui compte combien de fois apparaît chaque lettre dans un message chiffré, comme le faisait Al-Kindi. Un dictionnaire {} sera ton meilleur allié.

1. La spirale de Fibonacci. Avec turtle, dessine des quarts de cercle dont les rayons suivent la suite de Fibonacci (1, 1, 2, 3, 5, 8…) : tu obtiendras la célèbre spirale qui ressemble à une coquille d'escargot.

Indice : tortue.circle(rayon * 10, 90) trace un quart de cercle.

---

Partie 9 : Astuces et raccourcis utiles ⌨️ {: .partie }

Les raccourcis VS Code à connaître {: .sous-partie }

Les bonnes habitudes du programmeur {: .sous-partie }

• Avance petit à petit. Écris quelques lignes, teste, puis continue. Si tu écris 50 lignes d'un coup et que ça plante, bon courage pour trouver le problème !
• Utilise print() pour enquêter. Si ton programme ne fait pas ce que tu veux, ajoute des print() pour afficher le contenu de tes variables à différents moments. C'est la technique de débogage la plus utilisée au monde.
• Commente ton code. Explique les parties compliquées avec des #.
• Lis le message d'erreur en entier avant de paniquer. La réponse y est souvent.
• Ne copie-colle pas sans comprendre. Prends le temps de retaper le code des exemples : tes doigts mémorisent mieux que tes yeux.

---

Partie 10 : Pour aller plus loin 📚 {: .partie }

Voici des ressources gratuites et fiables pour continuer ton apprentissage :

• 🧩 France-IOI : la référence des lycées français. Des centaines d'exercices progressifs, corrigés automatiquement, pour apprendre la logique de programmation pas à pas.
• 🏴‍☠️ Py-rates : un jeu en ligne où tu diriges un pirate en écrivant du code Python. Idéal pour s'entraîner en s'amusant.
• 🎓 OpenClassrooms : le cours Apprenez les bases du langage Python est clair et se suit à ton rythme.
• 📖 Le tutoriel officiel en français : un peu plus technique, mais c'est la référence pour vérifier le fonctionnement précis d'une instruction.

---

🐍 Le mot de la fin

Personne ne devient programmeur en un jour. Les erreurs font partie du chemin, et chaque bug corrigé te rend meilleur. Le plus important, c'est d'être curieux, de tester, de casser des choses et de recommencer. Bon code !