Tu veux apprendre Python mais t'es submergé par tous ces tutoriels de 50 heures qui commencent par l'histoire de l'informatique depuis 1945 ? 😵
T'as juste besoin de coder maintenant, pas dans 3 semaines après avoir lu 500 pages de théorie ?
Bonne nouvelle : Tu n'as pas besoin de tout connaître pour commencer à être productif. 20% des concepts Python couvrent 80% des besoins quotidiens.
Ce guide, c'est le minimum vital : ce que tu dois absolument savoir pour écrire du code Python fonctionnel dès aujourd'hui. Pas de blabla, pas de détails inutiles pour débuter. Juste l'essentiel, expliqué simplement, avec des exemples concrets.
Ce que tu vas apprendre :
-
Installer Python et écrire ton premier programme
-
Les variables et types de données de base
-
Les conditions et boucles (if, for, while)
-
Les fonctions (créer et utiliser)
-
Les listes et dictionnaires (structures de données essentielles)
-
Lire et écrire des fichiers
-
Gérer les erreurs sans planter
-
Les modules et packages (réutiliser du code)
Après cet article, tu pourras :
-
Écrire des scripts utiles
-
Automatiser des tâches
-
Commencer à développer des vraies applications
-
Comprendre le code Python que tu lis
Allez, on arrête de procrastiner et on code ! 🚀
Partie 0 : Installation et premier programme
Installer Python
Vérifier si Python est déjà installé :
python3 --version
# ou sur Windows :
python --version
Si tu vois Python 3.x.x, t'es prêt ! Sinon...
Linux (Alma, Ubuntu, Debian) :
sudo dnf install python3 python3-pip # Alma/Rocky/RHEL
sudo apt install python3 python3-pip # Ubuntu/Debian
macOS :
# Avec Homebrew (recommandé)
brew install python3
# Ou télécharger depuis python.org
Windows :
-
Télécharger depuis https://python.org
-
IMPORTANT : Cocher "Add Python to PATH" pendant l'installation
-
Installer
Ton premier programme (le fameux Hello World)
Méthode 1 : Dans le terminal (mode interactif)
python3
>>> print("Hello World!")
Hello World!
>>> exit()
Méthode 2 : Dans un fichier (la vraie méthode)
Crée un fichier hello.py :
print("Hello World!")
Exécute-le :
python3 hello.py
Félicitations ! 🎉 Tu viens d'écrire ton premier programme Python !
Éditeur de code recommandé
Pour débuter :
-
VS Code (gratuit, excellent support Python)
-
PyCharm Community (gratuit, très complet)
-
Sublime Text ou nano (si t'aimes la simplicité)
Installe l'extension Python dans VS Code pour l'autocomplétion et le debugging.
Partie 1 : Variables et types de données
Les variables (boîtes pour stocker des valeurs)
Les variables sont des conteneurs qui stockent des informations. Pense-les comme des boîtes étiquetées où tu ranges tes données. En Python, tu n'as pas besoin de déclarer le type à l'avance : Python le détecte automatiquement selon la valeur que tu assignes.
# Nombres entiers (int)
age = 25
nombre_utilisateurs = 1000
# Nombres décimaux (float)
prix = 19.99
temperature = -5.5
# Texte (string / str)
nom = "Alice"
message = 'Bonjour le monde'
multiline = """
Ceci est
un texte
sur plusieurs lignes
"""
# Booléens (True/False)
est_connecte = True
a_paye = False
# Rien / Vide (None)
resultat = None
Afficher des valeurs :
print(nom) # Alice
print("J'ai", age, "ans") # J'ai 25 ans
print(f"J'ai {age} ans") # J'ai 25 ans (f-string, recommandé)
Règles pour nommer les variables :
-
✅
age,nom_utilisateur,prix_total -
❌
2age(ne commence pas par un chiffre) -
❌
nom-utilisateur(pas de tirets, utilise_) -
❌
class(mot réservé Python)
Les opérations de base
Les opérateurs permettent d'effectuer des calculs et des transformations sur tes données. Python supporte tous les opérateurs mathématiques classiques, plus quelques autres utiles.
# Mathématiques
a = 10
b = 3
print(a + b) # 13 (addition)
print(a - b) # 7 (soustraction)
print(a * b) # 30 (multiplication)
print(a / b) # 3.333... (division)
print(a // b) # 3 (division entière)
print(a % b) # 1 (modulo / reste)
print(a ** b) # 1000 (puissance)
# Incrémenter
compteur = 0
compteur += 1 # compteur = compteur + 1
compteur -= 1 # compteur = compteur - 1
compteur *= 2 # compteur = compteur * 2
Manipulation de texte (strings) :
prenom = "Alice"
nom = "Dupont"
# Concaténation
nom_complet = prenom + " " + nom # Alice Dupont
nom_complet = f"{prenom} {nom}" # Alice Dupont (mieux)
# Méthodes utiles
print(prenom.upper()) # ALICE
print(prenom.lower()) # alice
print(prenom.capitalize()) # Alice
print(len(prenom)) # 5 (longueur)
print("ice" in prenom) # True (contient?)
print(prenom.replace("A", "E")) # Elice
print(prenom.split("l")) # ['A', 'ice'] (découper)
Conversion de types :
# String → int
age_text = "25"
age_int = int(age_text) # 25
# Int → string
nombre = 42
nombre_text = str(nombre) # "42"
# String → float
prix_text = "19.99"
prix_float = float(prix_text) # 19.99
# Float → int (arrondi vers le bas)
prix = 19.99
prix_entier = int(prix) # 19
Input : Demander à l'utilisateur
La fonction input() permet à ton programme de poser des questions à l'utilisateur et d'attendre sa réponse. C'est essentiel pour créer des programmes interactifs.
nom = input("Quel est ton nom ? ")
print(f"Bonjour {nom} !")
# ATTENTION : input() retourne toujours un string !
age = input("Quel âge as-tu ? ")
age = int(age) # Conversion nécessaire pour les calculs
print(f"Dans 10 ans, tu auras {age + 10} ans")
Exemple complet :
# Calculateur simple
print("=== Calculateur ===")
nombre1 = float(input("Premier nombre : "))
nombre2 = float(input("Deuxième nombre : "))
resultat = nombre1 + nombre2
print(f"{nombre1} + {nombre2} = {resultat}")
Partie 2 : Conditions (if, else, elif)
Les conditions permettent à ton code de prendre des décisions. Au lieu d'exécuter toujours les mêmes instructions, tu peux faire en sorte que certaines parties du code ne s'exécutent que si une condition est vraie.
If basique
age = 18
if age >= 18:
print("T'es majeur")
⚠️ INDENTATION IMPORTANTE ! Python utilise l'indentation (4 espaces) pour délimiter les blocs.
If / Else
age = 16
if age >= 18:
print("T'es majeur")
else:
print("T'es mineur")
If / Elif / Else
note = 15
if note >= 16:
print("Excellent !")
elif note >= 14:
print("Bien")
elif note >= 10:
print("Passable")
else:
print("Insuffisant")
Opérateurs de comparaison
Pour créer des conditions, t'as besoin de comparer des valeurs. Ces opérateurs retournent toujours True ou False.
a = 10
b = 5
a == b # False (égal à)
a != b # True (différent de)
a > b # True (supérieur)
a < b # False (inférieur)
a >= b # True (supérieur ou égal)
a <= b # False (inférieur ou égal)
Opérateurs logiques (AND, OR, NOT)
Ces opérateurs permettent de combiner plusieurs conditions pour créer des logiques plus complexes.
age = 25
a_permis = True
# AND (et) - les deux doivent être vrais
if age >= 18 and a_permis:
print("Peux conduire")
# OR (ou) - au moins un doit être vrai
est_weekend = True
est_ferie = False
if est_weekend or est_ferie:
print("Pas de travail !")
# NOT (non) - inverse
est_connecte = False
if not est_connecte:
print("Connecte-toi d'abord")
Conditions imbriquées
Tu peux imbriquer des conditions les unes dans les autres pour des logiques plus élaborées. Chaque niveau supplémentaire augmente l'indentation.
age = 25
a_billet = True
if age >= 18:
if a_billet:
print("Entre, c'est bon !")
else:
print("Achète un billet d'abord")
else:
print("T'es trop jeune")
Exemple pratique : Authentification simple
username_correct = "admin"
password_correct = "1234"
username = input("Username: ")
password = input("Password: ")
if username == username_correct and password == password_correct:
print("✅ Connexion réussie !")
else:
print("❌ Identifiants incorrects")
Partie 3 : Boucles (for et while)
Les boucles permettent de répéter un bloc de code plusieurs fois, soit un nombre de fois défini (for), soit tant qu'une condition est vraie (while). Elles sont essentielles pour éviter la répétition de code.
Boucle for (nombre de fois connu)
La boucle for est idéale quand tu sais combien de fois tu veux répéter quelque chose, ou quand tu veux parcourir une collection d'éléments.
# Répéter 5 fois
for i in range(5):
print(f"Itération {i}")
# 0, 1, 2, 3, 4
# De 1 à 5 (inclus)
for i in range(1, 6):
print(i)
# 1, 2, 3, 4, 5
# De 0 à 10 par pas de 2
for i in range(0, 11, 2):
print(i)
# 0, 2, 4, 6, 8, 10
# Parcourir du texte
for lettre in "Python":
print(lettre)
# P, y, t, h, o, n
Exemple pratique : Table de multiplication
nombre = int(input("Table de multiplication de : "))
for i in range(1, 11):
resultat = nombre * i
print(f"{nombre} x {i} = {resultat}")
Boucle while (tant que condition vraie)
La boucle while s'exécute aussi longtemps qu'une condition reste vraie. Elle est utile quand tu ne sais pas d'avance combien de fois tu dois répéter, comme dans un menu ou un jeu.
compteur = 0
while compteur < 5:
print(f"Compteur : {compteur}")
compteur += 1
# Attention à la boucle infinie !
# while True: # Ne jamais s'arrête (sauf avec break)
# print("Infini")
Exemple pratique : Deviner un nombre
nombre_secret = 42
trouve = False
while not trouve:
essai = int(input("Devinez le nombre : "))
if essai == nombre_secret:
print("🎉 Bravo !")
trouve = True
elif essai < nombre_secret:
print("Plus grand !")
else:
print("Plus petit !")
Break et Continue
Ces deux mots-clés te permettent de contrôler plus finement le flux de tes boucles.
# break : sortir de la boucle
for i in range(10):
if i == 5:
break # Arrête la boucle
print(i)
# 0, 1, 2, 3, 4
# continue : passer à l'itération suivante
for i in range(10):
if i % 2 == 0:
continue # Saute les pairs
print(i)
# 1, 3, 5, 7, 9
Exemple pratique : Menu avec boucle
while True:
print("\n=== MENU ===")
print("1. Dire bonjour")
print("2. Afficher l'heure")
print("3. Quitter")
choix = input("Ton choix : ")
if choix == "1":
nom = input("Ton nom : ")
print(f"Bonjour {nom} !")
elif choix == "2":
import datetime
print(datetime.datetime.now())
elif choix == "3":
print("Au revoir !")
break
else:
print("Choix invalide")
Partie 4 : Fonctions (réutiliser du code)
Les fonctions permettent de regrouper du code et de le réutiliser plusieurs fois. Au lieu de réécrire le même code partout, tu le mets dans une fonction et l'appelles quand t'en as besoin. C'est l'essence de la programmation DRY (Don't Repeat Yourself).
Créer une fonction basique
def dire_bonjour():
print("Bonjour !")
# Appeler la fonction
dire_bonjour() # Bonjour !
dire_bonjour() # Bonjour ! (réutilisable)
Fonction avec paramètres
Les paramètres permettent à une fonction d'accepter des données et de les traiter de manière différente selon ce qu'on lui passe.
def dire_bonjour(nom):
print(f"Bonjour {nom} !")
dire_bonjour("Alice") # Bonjour Alice !
dire_bonjour("Bob") # Bonjour Bob !
Fonction avec plusieurs paramètres
def additionner(a, b):
resultat = a + b
print(f"{a} + {b} = {resultat}")
additionner(5, 3) # 5 + 3 = 8
additionner(10, 20) # 10 + 20 = 30
Fonction qui retourne une valeur (return)
Le mot-clé return permet à une fonction de renvoyer un résultat. C'est ainsi que tu peux utiliser le résultat d'une fonction ailleurs dans ton code.
def additionner(a, b):
return a + b # Retourne la valeur
resultat = additionner(5, 3)
print(resultat) # 8
# Utiliser directement
total = additionner(10, 20) + additionner(5, 5)
print(total) # 40
Paramètres par défaut
Tu peux donner des valeurs par défaut à tes paramètres. Si l'utilisateur ne passe pas ce paramètre, la valeur par défaut sera utilisée.
def saluer(nom, formule="Bonjour"):
print(f"{formule} {nom} !")
saluer("Alice") # Bonjour Alice !
saluer("Bob", "Salut") # Salut Bob !
saluer("Charlie", "Hey") # Hey Charlie !
Fonction qui retourne plusieurs valeurs
Une fonction peut retourner plusieurs valeurs sous forme de tuple (collection).
def calculer(a, b):
somme = a + b
produit = a * b
return somme, produit
s, p = calculer(5, 3)
print(f"Somme: {s}, Produit: {p}") # Somme: 8, Produit: 15
Exemples pratiques :
# Vérifier si un nombre est pair
def est_pair(nombre):
return nombre % 2 == 0
print(est_pair(4)) # True
print(est_pair(7)) # False
# Calculer une moyenne
def moyenne(notes):
total = sum(notes)
return total / len(notes)
mes_notes = [15, 12, 18, 14]
print(f"Moyenne: {moyenne(mes_notes)}") # 14.75
# Valider un email (simple)
def est_email_valide(email):
return "@" in email and "." in email
print(est_email_valide("test@example.com")) # True
print(est_email_valide("testexample.com")) # False
Partie 5 : Listes (collections ordonnées)
Les listes sont des collections qui stockent plusieurs valeurs dans une seule variable. Contrairement aux variables simples qui ne contiennent qu'une valeur, une liste peut contenir des centaines d'éléments et tu peux les traiter ensemble.
Créer et utiliser des listes
# Créer une liste
fruits = ["pomme", "banane", "orange"]
nombres = [1, 2, 3, 4, 5]
mixte = ["texte", 42, True, 3.14] # Types différents OK
# Accéder aux éléments (index commence à 0)
print(fruits[0]) # pomme
print(fruits[1]) # banane
print(fruits[-1]) # orange (dernier élément)
print(fruits[-2]) # banane (avant-dernier)
# Modifier un élément
fruits[0] = "fraise"
print(fruits) # ['fraise', 'banane', 'orange']
# Longueur de la liste
print(len(fruits)) # 3
Ajouter et supprimer des éléments
Les listes en Python sont flexibles et dynamiques : tu peux ajouter ou supprimer des éléments à tout moment.
fruits = ["pomme", "banane"]
# Ajouter à la fin
fruits.append("orange")
print(fruits) # ['pomme', 'banane', 'orange']
# Insérer à une position
fruits.insert(1, "kiwi")
print(fruits) # ['pomme', 'kiwi', 'banane', 'orange']
# Supprimer par valeur
fruits.remove("kiwi")
print(fruits) # ['pomme', 'banane', 'orange']
# Supprimer par index
del fruits[0]
print(fruits) # ['banane', 'orange']
# Supprimer le dernier et le récupérer
dernier = fruits.pop()
print(dernier) # orange
print(fruits) # ['banane']
# Vider la liste
fruits.clear()
print(fruits) # []
Parcourir une liste
Pour traiter chaque élément d'une liste, tu dois la parcourir. Python offre plusieurs façons de le faire.
fruits = ["pomme", "banane", "orange"]
# Méthode 1 : par élément
for fruit in fruits:
print(fruit)
# Méthode 2 : avec index
for i in range(len(fruits)):
print(f"{i}: {fruits[i]}")
# Méthode 3 : avec enumerate (la meilleure)
for index, fruit in enumerate(fruits):
print(f"{index}: {fruit}")
Opérations sur les listes
Python fournit de nombreuses méthodes utiles pour travailler avec les listes.
nombres = [1, 2, 3, 4, 5]
# Vérifier si un élément existe
print(3 in nombres) # True
print(10 in nombres) # False
# Trouver l'index d'un élément
print(nombres.index(3)) # 2
# Compter les occurrences
nombres = [1, 2, 2, 3, 2]
print(nombres.count(2)) # 3
# Trier
nombres = [5, 2, 8, 1, 9]
nombres.sort()
print(nombres) # [1, 2, 5, 8, 9]
# Inverser
nombres.reverse()
print(nombres) # [9, 8, 5, 2, 1]
# Somme, min, max
nombres = [1, 2, 3, 4, 5]
print(sum(nombres)) # 15
print(min(nombres)) # 1
print(max(nombres)) # 5
Slicing (découper une liste)
Le slicing permet d'extraire une partie d'une liste en spécifiant un intervalle d'indices.
nombres = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(nombres[2:5]) # [2, 3, 4] (de l'index 2 à 4)
print(nombres[:5]) # [0, 1, 2, 3, 4] (du début à 4)
print(nombres[5:]) # [5, 6, 7, 8, 9] (de 5 à la fin)
print(nombres[::2]) # [0, 2, 4, 6, 8] (tous les 2)
print(nombres[::-1]) # [9, 8, 7, 6, 5, 4, 3, 2, 1, 0] (inverse)
Exemples pratiques :
# Liste de courses
courses = []
while True:
print("\n1. Ajouter article")
print("2. Voir la liste")
print("3. Supprimer article")
print("4. Quitter")
choix = input("Choix : ")
if choix == "1":
article = input("Article : ")
courses.append(article)
print(f"✅ {article} ajouté")
elif choix == "2":
print("\n📝 Liste de courses:")
for i, article in enumerate(courses, 1):
print(f"{i}. {article}")
elif choix == "3":
article = input("Article à supprimer : ")
if article in courses:
courses.remove(article)
print(f"✅ {article} supprimé")
else:
print("❌ Article non trouvé")
elif choix == "4":
break
# Calculer moyenne de notes
def calculer_moyenne_et_stats(notes):
if not notes:
return None
moyenne = sum(notes) / len(notes)
note_min = min(notes)
note_max = max(notes)
return {
"moyenne": moyenne,
"min": note_min,
"max": note_max
}
notes = [15, 12, 18, 14, 16]
stats = calculer_moyenne_et_stats(notes)
print(f"Moyenne: {stats['moyenne']}")
print(f"Min: {stats['min']}, Max: {stats['max']}")
Partie 6 : Dictionnaires (clé-valeur)
Les dictionnaires stockent des paires clé-valeur, comme un vrai dictionnaire où chaque mot (clé) correspond à une définition (valeur). Contrairement aux listes où on accède par numéro d'index, dans un dictionnaire on accède par une clé.
Créer et utiliser des dictionnaires
# Créer un dictionnaire
personne = {
"nom": "Dupont",
"prenom": "Alice",
"age": 25,
"ville": "Paris"
}
# Accéder aux valeurs
print(personne["nom"]) # Dupont
print(personne["age"]) # 25
# Modifier une valeur
personne["age"] = 26
print(personne["age"]) # 26
# Ajouter une clé
personne["email"] = "alice@example.com"
print(personne)
# Vérifier si une clé existe
if "email" in personne:
print(personne["email"])
Méthodes des dictionnaires
Les dictionnaires fournissent plusieurs méthodes pour explorer et manipuler leurs données.
personne = {"nom": "Dupont", "prenom": "Alice", "age": 25}
# Obtenir toutes les clés
print(personne.keys()) # dict_keys(['nom', 'prenom', 'age'])
# Obtenir toutes les valeurs
print(personne.values()) # dict_values(['Dupont', 'Alice', 25])
# Obtenir les paires clé-valeur
print(personne.items()) # dict_items([('nom', 'Dupont'), ...])
# Get avec valeur par défaut (safe)
print(personne.get("email", "Non renseigné")) # Non renseigné
# Supprimer une clé
del personne["age"]
print(personne)
# Pop (supprimer et récupérer)
prenom = personne.pop("prenom")
print(prenom) # Alice
Parcourir un dictionnaire
Tu peux parcourir un dictionnaire de plusieurs façons selon si tu veux les clés, les valeurs, ou les deux.
personne = {"nom": "Dupont", "prenom": "Alice", "age": 25}
# Parcourir les clés
for cle in personne:
print(cle)
# Parcourir les valeurs
for valeur in personne.values():
print(valeur)
# Parcourir clés ET valeurs (recommandé)
for cle, valeur in personne.items():
print(f"{cle}: {valeur}")
Exemples pratiques :
# Annuaire téléphonique
annuaire = {
"Alice": "0601020304",
"Bob": "0605060708",
"Charlie": "0609101112"
}
nom = input("Chercher : ")
if nom in annuaire:
print(f"📞 {annuaire[nom]}")
else:
print("❌ Contact non trouvé")
# Compter les occurrences
texte = "bonjour le monde bonjour"
mots = texte.split()
compteur = {}
for mot in mots:
if mot in compteur:
compteur[mot] += 1
else:
compteur[mot] = 1
print(compteur) # {'bonjour': 2, 'le': 1, 'monde': 1}
# Configuration d'application
config = {
"app_name": "MonApp",
"version": "1.0",
"debug": True,
"database": {
"host": "localhost",
"port": 5432,
"name": "mydb"
}
}
print(config["database"]["host"]) # localhost
Partie 7 : Fichiers (lire et écrire)
Manipuler des fichiers texte te permet de sauvegarder et charger des données, de traiter des informations stockées, ou d'automatiser la gestion de fichiers. C'est une compétence fondamentale pour tout programmeur.
Écrire dans un fichier
# Mode "w" = write (écrase le contenu)
file = open("test.txt", "w")
file.write("Hello World!\n")
file.write("Deuxième ligne\n")
file.close()
# Méthode recommandée (with, ferme automatiquement)
with open("test.txt", "w") as file:
file.write("Hello World!\n")
file.write("Deuxième ligne\n")
# Fichier fermé automatiquement ici
Lire un fichier
# Lire tout le contenu
with open("test.txt", "r") as file:
contenu = file.read()
print(contenu)
# Lire ligne par ligne
with open("test.txt", "r") as file:
for ligne in file:
print(ligne.strip()) # strip() enlève les \n
# Lire toutes les lignes dans une liste
with open("test.txt", "r") as file:
lignes = file.readlines()
print(lignes) # Liste de lignes
Ajouter à un fichier (append)
# Mode "a" = append (ajoute à la fin)
with open("test.txt", "a") as file:
file.write("Nouvelle ligne\n")
Vérifier si un fichier existe
import os
if os.path.exists("test.txt"):
print("Le fichier existe")
else:
print("Le fichier n'existe pas")
Exemples pratiques :
# Journal / Log simple
import datetime
def ecrire_log(message):
timestamp = datetime.datetime.now()
with open("log.txt", "a") as file:
file.write(f"[{timestamp}] {message}\n")
ecrire_log("Application démarrée")
ecrire_log("Utilisateur connecté")
ecrire_log("Erreur: fichier non trouvé")
# Carnet d'adresses persistant
def sauvegarder_contacts(contacts):
with open("contacts.txt", "w") as file:
for nom, numero in contacts.items():
file.write(f"{nom}:{numero}\n")
def charger_contacts():
contacts = {}
if os.path.exists("contacts.txt"):
with open("contacts.txt", "r") as file:
for ligne in file:
nom, numero = ligne.strip().split(":")
contacts[nom] = numero
return contacts
# Utilisation
contacts = charger_contacts()
contacts["Alice"] = "0601020304"
sauvegarder_contacts(contacts)
# Compter les mots dans un fichier
with open("texte.txt", "r") as file:
contenu = file.read()
mots = contenu.split()
print(f"Nombre de mots: {len(mots)}")
Partie 8 : Gestion des erreurs (try/except)
Même le meilleur code peut planter si quelque chose d'inattendu se produit. La gestion des erreurs te permet d'anticiper ces problèmes et de les gérer élégamment au lieu de laisser ton programme s'arrêter brutalement.
Try / Except basique
# Sans gestion d'erreur (CRASH)
# age = int(input("Âge : ")) # Si l'utilisateur tape "abc" → BOOM
# Avec gestion d'erreur (SAFE)
try:
age = int(input("Âge : "))
print(f"T'as {age} ans")
except:
print("❌ Erreur : rentre un nombre")
Capturer des erreurs spécifiques
Au lieu de capturer toutes les erreurs (ce qui n'est pas recommandé), tu peux capturer des types d'erreurs spécifiques pour mieux les gérer.
try:
nombre = int(input("Nombre : "))
resultat = 10 / nombre
print(f"Résultat : {resultat}")
except ValueError:
print("❌ Ce n'est pas un nombre valide")
except ZeroDivisionError:
print("❌ Division par zéro impossible")
Try / Except / Else / Finally
Ces blocs additionnels te permettent de contrôler précisément ce qui se passe en cas de succès ou en toute fin.
try:
fichier = open("data.txt", "r")
contenu = fichier.read()
except FileNotFoundError:
print("❌ Fichier non trouvé")
else:
print(f"✅ Fichier lu : {len(contenu)} caractères")
finally:
print("🔄 Nettoyage...")
# S'exécute TOUJOURS, erreur ou pas
Exemples pratiques :
# Saisie sécurisée d'un nombre
def demander_nombre(message):
while True:
try:
return int(input(message))
except ValueError:
print("❌ Erreur : rentre un nombre valide")
age = demander_nombre("Quel âge as-tu ? ")
print(f"T'as {age} ans")
# Lecture de fichier sécurisée
def lire_fichier(nom_fichier):
try:
with open(nom_fichier, "r") as file:
return file.read()
except FileNotFoundError:
print(f"❌ Fichier {nom_fichier} introuvable")
return None
except PermissionError:
print(f"❌ Pas de permission pour lire {nom_fichier}")
return None
contenu = lire_fichier("data.txt")
if contenu:
print(contenu)
Partie 9 : Modules et imports (réutiliser du code)
Python est livré avec des milliers de modules intégrés, et il existe encore des millions de packages externes que tu peux installer. Les modules te permettent de réutiliser du code sans l'écrire toi-même.
Modules intégrés essentiels
# Math
import math
print(math.sqrt(16)) # 4.0
print(math.pi) # 3.14159...
print(math.ceil(4.2)) # 5 (arrondi sup)
print(math.floor(4.8)) # 4 (arrondi inf)
# Random (nombres aléatoires)
import random
print(random.randint(1, 10)) # Entier entre 1 et 10
print(random.choice(["A", "B", "C"])) # Élément aléatoire
random.shuffle([1, 2, 3, 4, 5]) # Mélanger une liste
# Datetime
import datetime
maintenant = datetime.datetime.now()
print(maintenant)
print(maintenant.year)
print(maintenant.strftime("%d/%m/%Y"))
# OS (système d'exploitation)
import os
print(os.getcwd()) # Dossier actuel
os.mkdir("nouveau_dossier") # Créer un dossier
os.listdir(".") # Lister fichiers
# Time
import time
print("Attends 2 secondes...")
time.sleep(2)
print("Fini !")
Différentes façons d'importer
Il existe plusieurs syntaxes pour importer selon ce que tu veux faire.
# Méthode 1 : Importer tout le module
import math
print(math.sqrt(16))
# Méthode 2 : Importer seulement ce dont t'as besoin
from math import sqrt, pi
print(sqrt(16))
print(pi)
# Méthode 3 : Importer avec alias
import datetime as dt
maintenant = dt.datetime.now()
# Méthode 4 : Tout importer (déconseillé)
from math import *
print(sqrt(16)) # Fonctionne mais pollue le namespace
Installer des packages externes (pip)
# Installer un package
pip install requests
# Installer plusieurs packages
pip install flask pandas numpy
# Voir les packages installés
pip list
# Désinstaller
pip uninstall requests
Exemples de packages populaires :
# Requests (HTTP requests)
import requests
response = requests.get("https://api.github.com")
print(response.status_code) # 200
print(response.json())
# Flask (web framework)
from flask import Flask
app = Flask(__name__)
@app.route('/')
def home():
return "Hello World!"
# Pandas (data analysis)
import pandas as pd
data = pd.read_csv("data.csv")
print(data.head())
Créer ton propre module
Tu peux créer tes propres modules pour organiser et réutiliser ton code.
Fichier utils.py :
def saluer(nom):
return f"Bonjour {nom} !"
def calculer_moyenne(nombres):
return sum(nombres) / len(nombres)
PI = 3.14159
Fichier main.py :
import utils
print(utils.saluer("Alice"))
print(utils.calculer_moyenne([10, 12, 15]))
print(utils.PI)
Partie 10 : Comprehensions de liste (bonus)
Les comprehensions de listes offrent une syntaxe compacte et élégante pour créer des listes basées sur d'autres listes. C'est une fonctionnalité très Python et très efficace.
# Méthode classique
carres = []
for i in range(10):
carres.append(i ** 2)
# List comprehension (équivalent)
carres = [i ** 2 for i in range(10)]
print(carres) # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
# Avec condition
pairs = [i for i in range(20) if i % 2 == 0]
print(pairs) # [0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
# Transformer une liste
noms = ["alice", "bob", "charlie"]
majuscules = [nom.upper() for nom in noms]
print(majuscules) # ['ALICE', 'BOB', 'CHARLIE']
# Dict comprehension
carres_dict = {i: i**2 for i in range(5)}
print(carres_dict) # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
Pour approfondir, va voir mon article sur la compréhension de listes
Mini-projets pour pratiquer
Projet 1 : Gestionnaire de tâches
# todo.py
import json
import os
FICHIER = "taches.json"
def charger_taches():
if os.path.exists(FICHIER):
with open(FICHIER, "r") as f:
return json.load(f)
return []
def sauvegarder_taches(taches):
with open(FICHIER, "w") as f:
json.dump(taches, f, indent=2)
def afficher_taches(taches):
if not taches:
print("📝 Aucune tâche")
return
print("\n📝 Tes tâches:")
for i, tache in enumerate(taches, 1):
statut = "✅" if tache["fait"] else "⬜"
print(f"{i}. {statut} {tache['texte']}")
def menu():
taches = charger_taches()
while True:
print("\n=== TODO LIST ===")
print("1. Voir tes tâches")
print("2. Ajouter une tâche")
print("3. Marquer comme fait")
print("4. Supprimer une tâche")
print("5. Quitter")
choix = input("\nChoix : ")
if choix == "1":
afficher_taches(taches)
elif choix == "2":
texte = input("Nouvelle tâche : ")
taches.append({"texte": texte, "fait": False})
sauvegarder_taches(taches)
print("✅ Tâche ajoutée")
elif choix == "3":
afficher_taches(taches)
num = int(input("Numéro : ")) - 1
if 0 <= num < len(taches):
taches[num]["fait"] = True
sauvegarder_taches(taches)
print("✅ Marquée comme fait")
elif choix == "4":
afficher_taches(taches)
num = int(input("Numéro : ")) - 1
if 0 <= num < len(taches):
taches.pop(num)
sauvegarder_taches(taches)
print("✅ Tâche supprimée")
elif choix == "5":
print("Au revoir !")
break
if __name__ == "__main__":
menu()
Projet 2 : Générateur de mots de passe
# password_generator.py
import random
import string
def generer_mot_de_passe(
longueur=12,
inclure_majuscules=True,
inclure_chiffres=True,
inclure_symboles=True
):
caracteres = string.ascii_lowercase
if inclure_majuscules:
caracteres += string.ascii_uppercase
if inclure_chiffres:
caracteres += string.digits
if inclure_symboles:
caracteres += string.punctuation
mot_de_passe = ''.join(random.choice(caracteres) for _ in range(longueur))
return mot_de_passe
def main():
print("=== GÉNÉRATEUR DE MOTS DE PASSE ===\n")
longueur = int(input("Longueur (défaut 12) : ") or 12)
maj = input("Inclure majuscules ? (o/n) : ").lower() == 'o'
chiffres = input("Inclure chiffres ? (o/n) : ").lower() == 'o'
symboles = input("Inclure symboles ? (o/n) : ").lower() == 'o'
mot_de_passe = generer_mot_de_passe(longueur, maj, chiffres, symboles)
print(f"\n🔐 Ton mot de passe : {mot_de_passe}")
if __name__ == "__main__":
main()
Projet 3 : Calculatrice simple
# calculatrice.py
def calculer(a, operation, b):
if operation == "+":
return a + b
elif operation == "-":
return a - b
elif operation == "*":
return a * b
elif operation == "/":
if b == 0:
return "Erreur: division par zéro"
return a / b
else:
return "Opération invalide"
def main():
print("=== CALCULATRICE ===\n")
while True:
try:
a = float(input("Premier nombre (ou 'q' pour quitter) : "))
operation = input("Opération (+, -, *, /) : ")
b = float(input("Deuxième nombre : "))
resultat = calculer(a, operation, b)
print(f"\n{a} {operation} {b} = {resultat}\n")
except ValueError:
print("Au revoir !")
break
except Exception as e:
print(f"Erreur : {e}")
if __name__ == "__main__":
main()
Ressources pour continuer
Prochaines étapes
-
Pratique quotidiennement : 30 min/jour > 5h une fois/semaine
-
Fais des projets : Apprendre en construisant
-
Lis du code : GitHub, projets open source
-
Suis des tutoriels : Real Python, Corey Schafer sur YouTube
-
Rejoins des communautés : Reddit r/learnpython, Discord Python
Concepts avancés à apprendre ensuite
-
POO (Programmation Orientée Objet) : Classes, objets, héritage
-
Décorateurs : Modifier le comportement des fonctions
-
Generators : Itérateurs efficaces en mémoire
-
Context managers :
withstatement personnalisés -
Async/Await : Programmation asynchrone
-
Web frameworks : Flask, Django, FastAPI
-
Data Science : NumPy, Pandas, Matplotlib
-
APIs : Requests, création d'APIs REST
Livres recommandés
-
"Automate the Boring Stuff with Python" (gratuit en ligne)
-
"Python Crash Course" par Eric Matthes
-
"Fluent Python" pour le niveau avancé
Sites web
-
python.org/docs : Documentation officielle
-
realpython.com : Tutoriels de qualité
-
stackoverflow.com : Questions/réponses
-
exercism.org : Exercices avec mentoring
-
codewars.com : Défis de code
Conclusion : T'es prêt à coder !
Félicitations ! Tu connaîs maintenant les fondamentaux de Python.
Ce qu'on a couvert :
-
Variables et types de données
-
Conditions et boucles
-
Fonctions
-
Listes et dictionnaires
-
Fichiers
-
Gestion d'erreurs
-
Modules et packages
Avec ces connaissances, tu peux :
-
Automatiser des tâches répétitives
-
Créer des scripts utiles
-
Manipuler des données
-
Construire de petites applications
-
Lire et comprendre du code Python
Les commandements du Pythonista :
-
Lisible > Clever (code clair avant code intelligent)
-
Commente ton code (toi plus tard tu diras merci)
-
Teste ton code (ça marchait hier ≠ ça marche aujourd'hui)
-
Google tes erreurs (t'es jamais le premier à galérer)
-
Pratique régulièrement (la constance > l'intensité)
-
N'aie pas peur de faire des erreurs
-
Lis du code des autres
-
Partage tes connaissances
Rappelle-toi :
-
Tout le monde a été débutant
-
Personne ne connaît Python par cœur
-
Les erreurs sont normales et utiles
-
La documentation est ton amie
-
La communauté Python est bienveillante
Prochaines étapes concrètes :
-
Choisis un des 3 mini-projets et code-le
-
Modifie-le, ajoute des fonctionnalités
-
Crée TON propre projet (même petit)
-
Partage-le (GitHub, montre à des potes)
-
Recommence avec un projet plus ambitieux
N'attends pas d'être "prêt" pour commencer. T'es déjà prêt. Lance-toi !
T'as des questions sur Python ? Un concept qui te bloque ? Partage en commentaire ! Et si ce guide t'a aidé, partage-le avec d'autres personnes qui veulent apprendre Python. 😉
Articles connexes :
Laisser un commentaire