Ressources Python

Choisissez le niveau qui vous intéresse et parcourez les différentes parties du cours.


  • Introduction et Configuration

  • Structures de Contrôle

  • Listes et Structures de Données

  • Fonctions

  • Dictionnaires et Ensembles

  • Manipulation de Fichiers

  • Bases de la POO

  • Programmation Orientée Objet (POO)

  • Gestion Avancée des Données

  • Gestion des Fichiers et Formats de Données

  • Bibliothèques pour l'Analyse de Données

  • Programmation Fonctionnelle et Avancée

  • Développement Web avec Flask

Sélectionnez une partie du cours pour commencer

Partie 1 : Théorie - Introduction à Python

Qu'est-ce que Python ?

Python est un langage de programmation :

  • Simple : Facile à lire et à écrire, idéal pour les débutants.
  • Polyvalent : Utilisé pour le développement web, l'analyse de données, l'intelligence artificielle, etc.
  • Populaire : Utilisé par des entreprises comme Google, NASA et Netflix.

Configuration de l'environnement

  1. Installer Python :
    • Téléchargez Python (version 3.8 ou supérieure) sur python.org.
    • Suivez les instructions pour votre système (Windows, macOS, Linux).
    • Cochez "Add Python to PATH" lors de l'installation sur Windows.
  2. Vérifier l'installation :
    • Ouvrez un terminal (Command Prompt, Terminal) et tapez python --version.
    • Vous devriez voir la version installée (ex. : Python 3.10.0).
  3. Choisir un éditeur de code :
    • IDLE : Livré avec Python, simple pour débuter.
    • VS Code : Gratuit, puissant, avec extensions Python.
    • PyCharm Community : Gratuit, spécialisé pour Python.
  4. Tester votre premier programme :
    • Créez un fichier bonjour.py et écrivez :
    📷 Code dans un éditeur :

    print("Bonjour, Python !")

    print("Bonjour, Python !")
    • Exécutez-le avec python bonjour.py dans le terminal.

Concepts de base

  • Variables : Stockent des données (comme un nom ou un nombre).
  • Types de données :
    • int : Nombres entiers (ex. : 42).
    • float : Nombres décimaux (ex. : 3.14).
    • str : Chaînes de caractères (ex. : "Bonjour").
    • bool : Vrai ou Faux (True, False).
  • Fonction print() : Affiche du texte ou des valeurs dans la console.
  • Commentaires : Lignes commençant par # pour expliquer le code.
  • Indentation : Espaces au début des lignes pour structurer le code (4 espaces par niveau).

Partie 2 : Exemple de Code

1. Utilisation de print() et variables

📷 Code dans un éditeur :

# Définir des variables
nom = "Alice" # str
age = 25 # int
taille = 1.75 # float
est_etudiant = True # bool

# Afficher les variables
print("Nom :", nom)
print("Âge :", age)
print("Taille :", taille, "m")
print("Étudiant ?", est_etudiant)

# Définir des variables
nom = "Alice" # str
age = 25 # int
taille = 1.75 # float
est_etudiant = True # bool

# Afficher les variables
print("Nom :", nom)
print("Âge :", age)
print("Taille :", taille, "m")
print("Étudiant ?", est_etudiant)

Résultat dans la console :

Nom : Alice
Âge : 25
Taille : 1.75 m
Étudiant ? True

2. Opérations de base

📷 Code dans un éditeur :

# Calculs avec des nombres
a = 10
b = 5

somme = a + b
difference = a - b
produit = a * b
division = a / b

print("Somme :", somme) # Affiche : Somme : 15
print("Différence :", difference) # Affiche : Différence : 5
print("Produit :", produit) # Affiche : Produit : 50
print("Division :", division) # Affiche : Division : 2.0

# Calculs avec des nombres
a = 10
b = 5

somme = a + b
difference = a - b
produit = a * b
division = a / b

print("Somme :", somme) # Affiche : Somme : 15
print("Différence :", difference) # Affiche : Différence : 5
print("Produit :", produit) # Affiche : Produit : 50
print("Division :", division) # Affiche : Division : 2.0

3. Entrée utilisateur avec input()

📷 Code dans un éditeur :

# Demander des informations à l'utilisateur
nom = input("Entrez votre nom : ")
age = int(input("Entrez votre âge : "))

print("Bonjour,", nom, "! Vous avez", age, "ans.")

# Demander des informations à l'utilisateur
nom = input("Entrez votre nom : ")
age = int(input("Entrez votre âge : "))

print("Bonjour,", nom, "! Vous avez", age, "ans.")

Exemple d'exécution :

Entrez votre nom : Bob
Entrez votre âge : 30
Bonjour, Bob ! Vous avez 30 ans.

Partie 1 : Théorie - Structures de Contrôle

Conditions (if, elif, else)

Les conditions permettent d'exécuter du code en fonction de critères :

  • if : Exécute un bloc de code si une condition est vraie.
  • elif : Vérifie une autre condition si la précédente est fausse.
  • else : Exécute un bloc si aucune condition précédente n'est vraie.

Syntaxe :

📷 Syntaxe des conditions :

if condition:
    # Code à exécuter
elif autre_condition:
    # Autre code
else:
    # Code par défaut

if condition:
# Code à exécuter
elif autre_condition:
# Autre code
else:
# Code par défaut

Opérateurs

  • Comparaison : == (égal), != (différent), < (inférieur), > (supérieur), <=, >=.
  • Logiques :
    • and : Vrai si les deux conditions sont vraies.
    • or : Vrai si au moins une condition est vraie.
    • not : Inverse une condition.

Boucles

  • for : Parcourt une séquence (par exemple, une liste ou range()).
    • Exemple : for i in range(5): parcourt les nombres de 0 à 4.
  • while : Répète tant qu'une condition est vraie.
    • Exemple : while x < 5: répète jusqu'à ce que x atteigne 5.
  • Contrôle des boucles :
    • break : Arrête la boucle immédiatement.
    • continue : Passe à l'itération suivante.

Partie 2 : Exemple de Code

1. Conditions avec if

📷 Code dans un éditeur :

# Vérifier si un nombre est positif, négatif ou zéro
nombre = int(input("Entrez un nombre : "))

if nombre > 0:
    print("Le nombre est positif.")
elif nombre < 0:
    print("Le nombre est négatif.")
else:
    print("Le nombre est zéro.")

# Vérifier si un nombre est positif, négatif ou zéro
nombre = int(input("Entrez un nombre : "))

if nombre > 0:
print("Le nombre est positif.")
elif nombre < 0: print("Le nombre est négatif.") else: print("Le nombre est zéro.")

2. Utilisation des opérateurs logiques

📷 Code dans un éditeur :

# Vérifier si une personne peut voter
age = int(input("Entrez votre âge : "))
nationalite = input("Êtes-vous français (oui/non) ? ")

if age >= 18 and nationalite.lower() == "oui":
    print("Vous pouvez voter !")
else:
    print("Vous ne pouvez pas voter.")

# Vérifier si une personne peut voter
age = int(input("Entrez votre âge : "))
nationalite = input("Êtes-vous français (oui/non) ? ")

if age >= 18 and nationalite.lower() == "oui":
print("Vous pouvez voter !")
else:
print("Vous ne pouvez pas voter.")

3. Boucle for

📷 Code dans un éditeur :

# Afficher les nombres de 1 à 5
for i in range(1, 6):
    print(i) # Affiche : 1, 2, 3, 4, 5

# Afficher les nombres de 1 à 5
for i in range(1, 6):
print(i) # Affiche : 1, 2, 3, 4, 5

4. Boucle while avec break et continue

📷 Code dans un éditeur :

# Compter jusqu'à 10, mais s'arrêter à 5
nombre = 1

while nombre <= 10:
    if nombre == 5:
        break # Arrête la boucle
    if nombre % 2 == 0:
        nombre += 1
        continue # Passe à l'itération suivante
    print(nombre)
    nombre += 1

# Affiche : 1, 3

# Compter jusqu'à 10, mais s'arrêter à 5
nombre = 1

while nombre <= 10: if nombre == 5: break # Arrête la boucle if nombre % 2 == 0: nombre += 1 continue # Passe à l'itération suivante print(nombre) nombre += 1 # Affiche : 1, 3

Partie 1 : Théorie - Listes et Structures de Données

Listes

Une liste est une collection ordonnée et modifiable de données.

  • Création : ma_liste = [1, 2, 3] ou ma_liste = ["pomme", "banane"].
  • Indexation : Accéder à un élément avec ma_liste[0] (premier élément).
  • Slicing : Extraire une sous-liste, par exemple ma_liste[1:3].
  • Méthodes courantes :
    • append(item) : Ajoute un élément à la fin.
    • remove(item) : Supprime un élément.
    • pop(index) : Supprime et retourne l'élément à l'index donné.
    • len(ma_liste) : Retourne la longueur de la liste.

Tuples

Un tuple est similaire à une liste, mais immuable (non modifiable).

  • Création : mon_tuple = (1, 2, 3).
  • Utilisation : Idéal pour des données fixes (par exemple, coordonnées).

Boucles avec listes

  • Utilisez une boucle for pour parcourir chaque élément : for item in ma_liste:.
  • Utilisez range() pour parcourir les indices : for i in range(len(ma_liste)):.

Partie 2 : Exemple de Code

1. Création et manipulation de listes

📷 Code dans un éditeur :

# Créer une liste
fruits = ["pomme", "banane", "orange"]

# Ajouter un élément
fruits.append("fraise")
print(fruits) # Affiche : ['pomme', 'banane', 'orange', 'fraise']

# Supprimer un élément
fruits.remove("banane")
print(fruits) # Affiche : ['pomme', 'orange', 'fraise']

# Accéder à un élément
print(fruits[0]) # Affiche : pomme

# Slicing
print(fruits[1:3]) # Affiche : ['orange', 'fraise']

# Créer une liste
fruits = ["pomme", "banane", "orange"]

# Ajouter un élément
fruits.append("fraise")
print(fruits) # Affiche : ['pomme', 'banane', 'orange', 'fraise']

# Supprimer un élément
fruits.remove("banane")
print(fruits) # Affiche : ['pomme', 'orange', 'fraise']

# Accéder à un élément
print(fruits[0]) # Affiche : pomme

# Slicing
print(fruits[1:3]) # Affiche : ['orange', 'fraise']

2. Parcourir une liste avec une boucle

📷 Code dans un éditeur :

# Afficher chaque élément
fruits = ["pomme", "banane", "orange"]

for fruit in fruits:
    print(fruit)

# Affiche :
# pomme
# banane
# orange

# Parcourir avec les indices
for i in range(len(fruits)):
    print(f"Index {i} : {fruits[i]}")

# Affiche :
# Index 0 : pomme
# Index 1 : banane
# Index 2 : orange

# Afficher chaque élément
fruits = ["pomme", "banane", "orange"]

for fruit in fruits:
print(fruit)

# Affiche :
# pomme
# banane
# orange

# Parcourir avec les indices
for i in range(len(fruits)):
print(f"Index {i} : {fruits[i]}")

# Affiche :
# Index 0 : pomme
# Index 1 : banane
# Index 2 : orange

3. Tuples

📷 Code dans un éditeur :

# Créer un tuple
coordonnees = (10, 20)
print(coordonnees[0]) # Affiche : 10

# Les tuples sont immuables
# coordonnees[0] = 15 # Erreur : les tuples ne peuvent pas être modifiés

# Créer un tuple
coordonnees = (10, 20)
print(coordonnees[0]) # Affiche : 10

# Les tuples sont immuables
# coordonnees[0] = 15 # Erreur : les tuples ne peuvent pas être modifiés

Partie 1 : Théorie - Fonctions

Qu'est-ce qu'une fonction ?

Une fonction est un bloc de code réutilisable qui effectue une tâche spécifique.

  • Définition : Utilise le mot-clé def suivi du nom de la fonction et de parenthèses.
  • Paramètres : Valeurs que la fonction accepte comme entrées.
  • Retour : Une fonction peut renvoyer une valeur avec return.
  • Appel : Exécuter la fonction en utilisant son nom suivi de parenthèses.

Syntaxe

📷 Syntaxe d'une fonction :

def nom_fonction(parametre1, parametre2):
    # Code à exécuter
    return resultat

def nom_fonction(parametre1, parametre2):
# Code à exécuter
return resultat

Portée des variables

  • Locale : Variables définies à l'intérieur d'une fonction, accessibles uniquement dans cette fonction.
  • Globale : Variables définies en dehors des fonctions, accessibles partout (mais évitez de les modifier dans une fonction).

Fonctions intégrées

  • len(objet) : Retourne la longueur d'une liste ou d'une chaîne.
  • max(liste) : Retourne l'élément maximum.
  • min(liste) : Retourne l'élément minimum.
  • sum(liste) : Retourne la somme des éléments d'une liste.

Partie 2 : Exemple de Code

1. Définir et appeler une fonction

📷 Code dans un éditeur :

def saluer(nom):
    message = f"Bonjour, {nom} !"
    return message

# Appeler la fonction
print(saluer("Alice")) # Affiche : Bonjour, Alice !
print(saluer("Bob")) # Affiche : Bonjour, Bob !

def saluer(nom):
message = f"Bonjour, {nom} !"
return message

# Appeler la fonction
print(saluer("Alice")) # Affiche : Bonjour, Alice !
print(saluer("Bob")) # Affiche : Bonjour, Bob !

2. Fonction avec plusieurs paramètres

📷 Code dans un éditeur :

def addition(a, b):
    return a + b

# Appeler la fonction
resultat = addition(5, 3)
print(resultat) # Affiche : 8

def addition(a, b):
return a + b

# Appeler la fonction
resultat = addition(5, 3)
print(resultat) # Affiche : 8

3. Portée des variables

📷 Code dans un éditeur :

x = 10 # Variable globale

def modifier_valeur():
    x = 5 # Variable locale
    print("Dans la fonction, x =", x)

modifier_valeur() # Affiche : Dans la fonction, x = 5
print("En dehors, x =", x) # Affiche : En dehors, x = 10

x = 10 # Variable globale

def modifier_valeur():
x = 5 # Variable locale
print("Dans la fonction, x =", x)

modifier_valeur() # Affiche : Dans la fonction, x = 5
print("En dehors, x =", x) # Affiche : En dehors, x = 10

4. Utilisation des fonctions intégrées

📷 Code dans un éditeur :

nombres = [1, 4, 2, 8, 5]

print("Longueur :", len(nombres)) # Affiche : Longueur : 5
print("Maximum :", max(nombres)) # Affiche : Maximum : 8
print("Minimum :", min(nombres)) # Affiche : Minimum : 1
print("Somme :", sum(nombres)) # Affiche : Somme : 20

nombres = [1, 4, 2, 8, 5]

print("Longueur :", len(nombres)) # Affiche : Longueur : 5
print("Maximum :", max(nombres)) # Affiche : Maximum : 8
print("Minimum :", min(nombres)) # Affiche : Minimum : 1
print("Somme :", sum(nombres)) # Affiche : Somme : 20

Partie 1 : Théorie - Dictionnaires et Ensembles

Dictionnaires

Un dictionnaire est une structure de données qui stocke des paires clé-valeur.

  • Création : mon_dict = {"clé": "valeur"} (par exemple, {"nom": "Alice", "âge": 25}).
  • Accès : Utilisez la clé pour récupérer la valeur, par exemple mon_dict["nom"].
  • Modification : Ajoutez ou modifiez une paire avec mon_dict["clé"] = valeur.
  • Méthodes courantes :
    • keys() : Retourne les clés.
    • values() : Retourne les valeurs.
    • items() : Retourne les paires clé-valeur.
    • get(clé, défaut) : Récupère une valeur avec une valeur par défaut si la clé n'existe pas.

Ensembles

Un ensemble est une collection non ordonnée d'éléments uniques.

  • Création : mon_ensemble = {1, 2, 3} ou mon_ensemble = set([1, 2, 2]) (supprime les doublons).
  • Opérations :
    • add(élément) : Ajoute un élément.
    • remove(élément) : Supprime un élément (erreur si absent).
    • discard(élément) : Supprime un élément (pas d'erreur si absent).
    • Opérations d'ensemble : union, intersection, difference.

Utilisation avec des boucles

  • Pour un dictionnaire : Parcourez les clés (for clé in mon_dict), valeurs (for valeur in mon_dict.values()) ou paires (for clé, valeur in mon_dict.items()).
  • Pour un ensemble : Parcourez les éléments avec for élément in mon_ensemble.

Partie 2 : Exemple de Code

1. Manipulation de dictionnaires

📷 Code dans un éditeur :

# Créer un dictionnaire
personne = {"nom": "Alice", "âge": 25, "ville": "Paris"}

# Accéder à une valeur
print(personne["nom"]) # Affiche : Alice

# Ajouter/modifier une paire
personne["profession"] = "Étudiante"
personne["âge"] = 26
print(personne) # Affiche : {'nom': 'Alice', 'âge': 26, 'ville': 'Paris', 'profession': 'Étudiante'}

# Utiliser get()
print(personne.get("pays", "Inconnu")) # Affiche : Inconnu

# Parcourir un dictionnaire
for clé, valeur in personne.items():
    print(f"{clé} : {valeur}")

# Affiche :
# nom : Alice
# âge : 26
# ville : Paris
# profession : Étudiante

# Créer un dictionnaire
personne = {"nom": "Alice", "âge": 25, "ville": "Paris"}

# Accéder à une valeur
print(personne["nom"]) # Affiche : Alice

# Ajouter/modifier une paire
personne["profession"] = "Étudiante"
personne["âge"] = 26
print(personne) # Affiche : {'nom': 'Alice', 'âge': 26, 'ville': 'Paris', 'profession': 'Étudiante'}

# Utiliser get()
print(personne.get("pays", "Inconnu")) # Affiche : Inconnu

# Parcourir un dictionnaire
for clé, valeur in personne.items():
print(f"{clé} : {valeur}")

# Affiche :
# nom : Alice
# âge : 26
# ville : Paris
# profession : Étudiante

2. Manipulation d'ensembles

📷 Code dans un éditeur :

# Créer un ensemble
nombres = {1, 2, 3, 3} # Les doublons sont supprimés
print(nombres) # Affiche : {1, 2, 3}

# Ajouter et supprimer
nombres.add(4)
nombres.discard(2)
print(nombres) # Affiche : {1, 3, 4}

# Opérations d'ensemble
ensemble1 = {1, 2, 3}
ensemble2 = {2, 3, 4}

print(ensemble1.union(ensemble2)) # Affiche : {1, 2, 3, 4}
print(ensemble1.intersection(ensemble2)) # Affiche : {2, 3}

# Créer un ensemble
nombres = {1, 2, 3, 3} # Les doublons sont supprimés
print(nombres) # Affiche : {1, 2, 3}

# Ajouter et supprimer
nombres.add(4)
nombres.discard(2)
print(nombres) # Affiche : {1, 3, 4}

# Opérations d'ensemble
ensemble1 = {1, 2, 3}
ensemble2 = {2, 3, 4}

print(ensemble1.union(ensemble2)) # Affiche : {1, 2, 3, 4}
print(ensemble1.intersection(ensemble2)) # Affiche : {2, 3}

3. Combiner dictionnaires et boucles

📷 Code dans un éditeur :

# Compter les occurrences de lettres
phrase = "bonjour"
compteur = {}

for lettre in phrase:
    compteur[lettre] = compteur.get(lettre, 0) + 1

print(compteur) # Affiche : {'b': 1, 'o': 2, 'n': 1, 'j': 1, 'u': 1, 'r': 1}

# Compter les occurrences de lettres
phrase = "bonjour"
compteur = {}

for lettre in phrase:
compteur[lettre] = compteur.get(lettre, 0) + 1

print(compteur) # Affiche : {'b': 1, 'o': 2, 'n': 1, 'j': 1, 'u': 1, 'r': 1}

Partie 1 : Théorie - Manipulation de Fichiers

Fichiers en Python

Python permet de manipuler des fichiers pour stocker ou lire des données.

  • Lecture : Récupérer le contenu d'un fichier.
  • Écriture : Ajouter ou remplacer le contenu d'un fichier.
  • Modes de fichier :
    • "r" : Lecture (erreur si le fichier n'existe pas).
    • "w" : Écriture (crée ou remplace le fichier).
    • "a" : Ajout (ajoute à la fin du fichier).
  • Gestion avec with : Ouvre un fichier et le ferme automatiquement après usage.

Gestion des erreurs

Utilisez try/except pour gérer les erreurs, comme :

  • FileNotFoundError : Fichier introuvable.
  • PermissionError : Accès refusé.

Types de fichiers

  • Fichiers texte : Contiennent du texte brut (par exemple, .txt).
  • Fichiers structurés : Comme JSON ou CSV (introduits plus tard dans un cours intermédiaire).

Partie 2 : Exemple de Code

1. Écrire dans un fichier

📷 Code dans un éditeur :

# Écrire du texte dans un fichier
with open("mon_fichier.txt", "w") as fichier:
    fichier.write("Bonjour, Python !\\\\n")
    fichier.write("Ceci est une deuxième ligne.")

# Écrire du texte dans un fichier
with open("mon_fichier.txt", "w") as fichier:
fichier.write("Bonjour, Python !\\\\n")
fichier.write("Ceci est une deuxième ligne.")

Crée (ou remplace) un fichier mon_fichier.txt avec deux lignes de texte.

2. Lire un fichier

📷 Code dans un éditeur :

# Lire le contenu d'un fichier
with open("mon_fichier.txt", "r") as fichier:
    contenu = fichier.read()
    print(contenu)

# Affiche :
# Bonjour, Python !
# Ceci est une deuxième ligne.

# Lire le contenu d'un fichier
with open("mon_fichier.txt", "r") as fichier:
contenu = fichier.read()
print(contenu)

# Affiche :
# Bonjour, Python !
# Ceci est une deuxième ligne.

3. Lire ligne par ligne

📷 Code dans un éditeur :

# Lire ligne par ligne
with open("mon_fichier.txt", "r") as fichier:
    for ligne in fichier:
        print(ligne.strip()) # strip() enlève les sauts de ligne

# Affiche :
# Bonjour, Python !
# Ceci est une deuxième ligne.

# Lire ligne par ligne
with open("mon_fichier.txt", "r") as fichier:
for ligne in fichier:
print(ligne.strip()) # strip() enlève les sauts de ligne

# Affiche :
# Bonjour, Python !
# Ceci est une deuxième ligne.

4. Gestion des erreurs

📷 Code dans un éditeur :

try:
    with open("fichier_inexistant.txt", "r") as fichier:
        contenu = fichier.read()
        print(contenu)
except FileNotFoundError:
    print("Erreur : Le fichier n'existe pas.")

# Affiche : Erreur : Le fichier n'existe pas.

try:
with open("fichier_inexistant.txt", "r") as fichier:
contenu = fichier.read()
print(contenu)
except FileNotFoundError:
print("Erreur : Le fichier n'existe pas.")

# Affiche : Erreur : Le fichier n'existe pas.

5. Ajouter du texte

📷 Code dans un éditeur :

# Ajouter du texte à la fin d'un fichier
with open("mon_fichier.txt", "a") as fichier:
    fichier.write("\\\\nAjout d'une nouvelle ligne.")

# Ajouter du texte à la fin d'un fichier
with open("mon_fichier.txt", "a") as fichier:
fichier.write("\\\\nAjout d'une nouvelle ligne.")

Partie 1 : Théorie - Programmation Orientée Objet

Qu'est-ce que la POO ?

La programmation orientée objet (POO) est une façon d'organiser le code en regroupant les données et les comportements associés dans des objets.

  • Classe : Un modèle ou plan pour créer des objets (comme une recette).
  • Objet : Une instance d'une classe (comme un gâteau préparé à partir de la recette).
  • Attributs : Les données stockées dans un objet (par exemple, le nom ou l'âge d'une personne).
  • Méthodes : Les fonctions définies dans une classe qui agissent sur les attributs de l'objet.

Syntaxe de base

  • Définir une classe avec class NomClasse:.
  • Créer un objet avec objet = NomClasse().
  • Utiliser __init__ pour initialiser les attributs d'un objet.
  • Définir des méthodes pour ajouter des comportements.

Concepts clés

  • Encapsulation : Regrouper les données (attributs) et les comportements (méthodes) dans une classe.
  • Attributs d'instance : Données spécifiques à un objet (par exemple, nom d'un étudiant).
  • Méthodes : Fonctions qui appartiennent à la classe et manipulent ses attributs.

Partie 2 : Exemple de Code

1. Créer une classe et un objet

📷 Code dans un éditeur :

class Etudiant:
    def __init__(self, nom, age):
        self.nom = nom # Attribut
        self.age = age

    def se_presenter(self): # Méthode
        return f"Je m'appelle {self.nom} et j'ai {self.age} ans."

# Créer un objet
etudiant1 = Etudiant("Alice", 20)
print(etudiant1.se_presenter()) # Affiche : Je m'appelle Alice et j'ai 20 ans.

class Etudiant:
def __init__(self, nom, age):
self.nom = nom # Attribut
self.age = age

def se_presenter(self): # Méthode
return f"Je m'appelle {self.nom} et j'ai {self.age} ans."

# Créer un objet
etudiant1 = Etudiant("Alice", 20)
print(etudiant1.se_presenter()) # Affiche : Je m'appelle Alice et j'ai 20 ans.

2. Ajouter des méthodes

📷 Code dans un éditeur :

class Etudiant:
    def __init__(self, nom, age):
        self.nom = nom
        self.age = age
        self.notes = []

    def ajouter_note(self, note):
        self.notes.append(note)

    def moyenne(self):
        if not self.notes:
            return 0
        return sum(self.notes) / len(self.notes)

# Créer un objet et utiliser les méthodes
etudiant = Etudiant("Bob", 22)
etudiant.ajouter_note(15)
etudiant.ajouter_note(18)

print(f"Moyenne de {etudiant.nom} : {etudiant.moyenne()}") # Affiche : Moyenne de Bob : 16.5

class Etudiant:
def __init__(self, nom, age):
self.nom = nom
self.age = age
self.notes = []

def ajouter_note(self, note):
self.notes.append(note)

def moyenne(self):
if not self.notes:
return 0
return sum(self.notes) / len(self.notes)

# Créer un objet et utiliser les méthodes
etudiant = Etudiant("Bob", 22)
etudiant.ajouter_note(15)
etudiant.ajouter_note(18)

print(f"Moyenne de {etudiant.nom} : {etudiant.moyenne()}") # Affiche : Moyenne de Bob : 16.5

3. Manipuler plusieurs objets

📷 Code dans un éditeur :

class Etudiant:
    def __init__(self, nom, age):
        self.nom = nom
        self.age = age

    def se_presenter(self):
        return f"Je m'appelle {self.nom} et j'ai {self.age} ans."

# Créer plusieurs objets
etudiants = [
    Etudiant("Alice", 20),
    Etudiant("Bob", 22),
    Etudiant("Charlie", 19)
]

# Parcourir les objets
for etudiant in etudiants:
    print(etudiant.se_presenter())

# Affiche :
# Je m'appelle Alice et j'ai 20 ans.
# Je m'appelle Bob et j'ai 22 ans.
# Je m'appelle Charlie et j'ai 19 ans.

class Etudiant:
def __init__(self, nom, age):
self.nom = nom
self.age = age

def se_presenter(self):
return f"Je m'appelle {self.nom} et j'ai {self.age} ans."

# Créer plusieurs objets
etudiants = [
Etudiant("Alice", 20),
Etudiant("Bob", 22),
Etudiant("Charlie", 19)
]

# Parcourir les objets
for etudiant in etudiants:
print(etudiant.se_presenter())

# Affiche :
# Je m'appelle Alice et j'ai 20 ans.
# Je m'appelle Bob et j'ai 22 ans.
# Je m'appelle Charlie et j'ai 19 ans.

Partie 1 : Théorie - Introduction à la POO

Qu'est-ce que la POO ?

La programmation orientée objet est un paradigme qui organise le code autour d'objets plutôt que de fonctions ou de procédures. Un objet est une entité qui combine des données (attributs) et des comportements (méthodes).

  • Classe : Un modèle ou blueprint pour créer des objets.
  • Objet : Une instance d'une classe.
  • Attributs : Données associées à un objet (ex. : nom, âge).
  • Méthodes : Fonctions définies dans une classe qui décrivent le comportement des objets.

Concepts clés

  1. Encapsulation : Regrouper les données et les méthodes dans une classe, en contrôlant l'accès (public, privé).
  2. Héritage : Permettre à une classe d'hériter des attributs et méthodes d'une autre.
  3. Polymorphisme : Permettre à différentes classes de partager une interface commune.
  4. Méthodes spéciales : Méthodes prédéfinies (ex. __init__, __str__) pour personnaliser le comportement des objets.

Partie 2 : Exemple de Code

1. Création d'une classe et d'un objet

📷 Code dans un éditeur :

class Voiture:
    def __init__(self, marque, modele):
        self.marque = marque # Attribut
        self.modele = modele # Attribut
        self.vitesse = 0 # Attribut par défaut

    def demarrer(self): # Méthode
        return f"La {self.marque} {self.modele} démarre !"

    def accelerer(self, increment):
        self.vitesse += increment
        return f"La vitesse est maintenant de {self.vitesse} km/h."

# Création d'un objet
ma_voiture = Voiture("Toyota", "Corolla")
print(ma_voiture.demarrer()) # Affiche : La Toyota Corolla démarre !
print(ma_voiture.accelerer(50)) # Affiche : La vitesse est maintenant de 50 km/h.

class Voiture:
def __init__(self, marque, modele):
self.marque = marque # Attribut
self.modele = modele # Attribut
self.vitesse = 0 # Attribut par défaut

def demarrer(self): # Méthode
return f"La {self.marque} {self.modele} démarre !"

def accelerer(self, increment):
self.vitesse += increment
return f"La vitesse est maintenant de {self.vitesse} km/h."

# Création d'un objet
ma_voiture = Voiture("Toyota", "Corolla")
print(ma_voiture.demarrer()) # Affiche : La Toyota Corolla démarre !
print(ma_voiture.accelerer(50)) # Affiche : La vitesse est maintenant de 50 km/h.

2. Héritage

📷 Code dans un éditeur :

class Vehicule:
    def __init__(self, marque):
        self.marque = marque

    def klaxonner(self):
        return "Bip bip !"

class Voiture(Vehicule): # Hérite de Vehicule
    def __init__(self, marque, modele):
        super().__init__(marque) # Appelle le constructeur de la classe parent
        self.modele = modele

    def demarrer(self):
        return f"La {self.marque} {self.modele} démarre !"

# Création d'un objet
ma_voiture = Voiture("Honda", "Civic")
print(ma_voiture.klaxonner()) # Affiche : Bip bip ! (hérité)
print(ma_voiture.demarrer()) # Affiche : La Honda Civic démarre !

class Vehicule:
def __init__(self, marque):
self.marque = marque

def klaxonner(self):
return "Bip bip !"

class Voiture(Vehicule): # Hérite de Vehicule
def __init__(self, marque, modele):
super().__init__(marque) # Appelle le constructeur de la classe parent
self.modele = modele

def demarrer(self):
return f"La {self.marque} {self.modele} démarre !"

# Création d'un objet
ma_voiture = Voiture("Honda", "Civic")
print(ma_voiture.klaxonner()) # Affiche : Bip bip ! (hérité)
print(ma_voiture.demarrer()) # Affiche : La Honda Civic démarre !

3. Méthode spéciale __str__

📷 Code dans un éditeur :

class Voiture:
    def __init__(self, marque, modele):
        self.marque = marque
        self.modele = modele

    def __str__(self): # Personnalise l'affichage de l'objet
        return f"Voiture : {self.marque} {self.modele}"

# Création et affichage
ma_voiture = Voiture("Tesla", "Model 3")
print(ma_voiture) # Affiche : Voiture : Tesla Model 3

class Voiture:
def __init__(self, marque, modele):
self.marque = marque
self.modele = modele

def __str__(self): # Personnalise l'affichage de l'objet
return f"Voiture : {self.marque} {self.modele}"

# Création et affichage
ma_voiture = Voiture("Tesla", "Model 3")
print(ma_voiture) # Affiche : Voiture : Tesla Model 3

Partie 1 : Théorie - Gestion Avancée des Données

Compréhensions

Les compréhensions permettent de créer des listes, dictionnaires ou ensembles de manière concise et lisible.

  • Liste : [expression for item in iterable if condition]
  • Dictionnaire : {key: value for item in iterable if condition}
  • Ensemble : {expression for item in iterable if condition}

Module collections

Le module collections fournit des structures de données optimisées :

  • deque : Liste à double extrémité pour des opérations rapides en début/fin.
  • defaultdict : Dictionnaire avec une valeur par défaut pour les clés manquantes.
  • Counter : Compte les occurrences d'éléments dans une collection.

Algorithmes de base

  • Tri : Utiliser sorted() ou .sort() pour trier des listes.
  • Recherche binaire : Algorithme efficace pour trouver un élément dans une liste triée.

Partie 2 : Exemple de Code

1. Compréhensions

📷 Code dans un éditeur :

# Liste : carrés des nombres pairs de 1 à 10
carres_pairs = [x**2 for x in range(1, 11) if x % 2 == 0]
print(carres_pairs) # Affiche : [4, 16, 36, 64, 100]

# Dictionnaire : associer chaque nombre à son carré
carres_dict = {x: x**2 for x in range(1, 6)}
print(carres_dict) # Affiche : {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# Ensemble : lettres uniques d'une phrase
phrase = "bonjour python"
lettres_uniques = {lettre for lettre in phrase if lettre.isalpha()}
print(lettres_uniques) # Affiche : {'b', 'o', 'n', 'j', 'u', 'r', 'p', 'y', 't', 'h'}

# Liste : carrés des nombres pairs de 1 à 10
carres_pairs = [x**2 for x in range(1, 11) if x % 2 == 0]
print(carres_pairs) # Affiche : [4, 16, 36, 64, 100]

# Dictionnaire : associer chaque nombre à son carré
carres_dict = {x: x**2 for x in range(1, 6)}
print(carres_dict) # Affiche : {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# Ensemble : lettres uniques d'une phrase
phrase = "bonjour python"
lettres_uniques = {lettre for lettre in phrase if lettre.isalpha()}
print(lettres_uniques) # Affiche : {'b', 'o', 'n', 'j', 'u', 'r', 'p', 'y', 't', 'h'}

2. Module collections

📷 Code dans un éditeur :

from collections import deque, defaultdict, Counter

# deque : file d'attente
file = deque(['tâche1', 'tâche2'])
file.append('tâche3') # Ajout à droite
file.appendleft('tâche0') # Ajout à gauche
print(file) # Affiche : deque(['tâche0', 'tâche1', 'tâche2', 'tâche3'])

# defaultdict : compter des catégories
categories = defaultdict(int)
categories['pommes'] += 1
categories['oranges'] += 2
print(categories) # Affiche : defaultdict(<class 'int'>, {'pommes': 1, 'oranges': 2})

# Counter : compter les occurrences
mots = ['chat', 'chien', 'chat', 'oiseau']
compteur = Counter(mots)
print(compteur) # Affiche : Counter({'chat': 2, 'chien': 1, 'oiseau': 1})

from collections import deque, defaultdict, Counter

# deque : file d'attente
file = deque(['tâche1', 'tâche2'])
file.append('tâche3') # Ajout à droite
file.appendleft('tâche0') # Ajout à gauche
print(file) # Affiche : deque(['tâche0', 'tâche1', 'tâche2', 'tâche3'])

# defaultdict : compter des catégories
categories = defaultdict(int)
categories['pommes'] += 1
categories['oranges'] += 2
print(categories) # Affiche : defaultdict(, {'pommes': 1, 'oranges': 2})

# Counter : compter les occurrences
mots = ['chat', 'chien', 'chat', 'oiseau']
compteur = Counter(mots)
print(compteur) # Affiche : Counter({'chat': 2, 'chien': 1, 'oiseau': 1})

3. Recherche binaire

📷 Code dans un éditeur :

def recherche_binaire(liste, cible):
    gauche, droite = 0, len(liste) - 1
    while gauche <= droite:
        milieu = (gauche + droite) // 2
        if liste[milieu] == cible:
            return milieu
        elif liste[milieu] < cible:
            gauche = milieu + 1
        else:
            droite = milieu - 1
    return -1

# Test
liste_triee = [1, 3, 5, 7, 9, 11]
print(recherche_binaire(liste_triee, 7)) # Affiche : 3
print(recherche_binaire(liste_triee, 8)) # Affiche : -1

def recherche_binaire(liste, cible):
gauche, droite = 0, len(liste) - 1
while gauche <= droite: milieu = (gauche + droite) // 2 if liste[milieu] == cible: return milieu elif liste[milieu] < cible: gauche = milieu + 1 else: droite = milieu - 1 return -1 # Test liste_triee = [1, 3, 5, 7, 9, 11] print(recherche_binaire(liste_triee, 7)) # Affiche : 3 print(recherche_binaire(liste_triee, 8)) # Affiche : -1

Partie 1 : Théorie - Gestion des Fichiers et Formats de Données

JSON

Le format JSON (JavaScript Object Notation) est utilisé pour stocker et échanger des données structurées. En Python, le module json permet de :

  • Écrire : Convertir un dictionnaire/liste en JSON avec json.dump ou json.dumps.
  • Lire : Charger un fichier JSON dans un objet Python avec json.load ou json.loads.

CSV

Le format CSV (Comma-Separated Values) est idéal pour les données tabulaires. Python propose :

  • Le module csv pour des manipulations simples.
  • La bibliothèque pandas pour des analyses avancées (DataFrames).

Pathlib

Le module pathlib offre une interface moderne pour manipuler les chemins de fichiers :

  • Portable entre systèmes d'exploitation (Windows, Linux, macOS).
  • Méthodes pour créer, lire, lister ou supprimer des fichiers/dossiers.

Partie 2 : Exemple de Code

1. Manipulation de fichiers JSON

📷 Code dans un éditeur :

import json

# Créer un dictionnaire
data = {
    "nom": "Alice",
    "age": 25,
    "cours": ["Maths", "Python"]
}

# Écrire dans un fichier JSON
with open("donnees.json", "w") as fichier:
    json.dump(data, fichier, indent=4)

# Lire depuis un fichier JSON
with open("donnees.json", "r") as fichier:
    data_lue = json.load(fichier)

print(data_lue) # Affiche : {'nom': 'Alice', 'age': 25, 'cours': ['Maths', 'Python']}

import json

# Créer un dictionnaire
data = {
"nom": "Alice",
"age": 25,
"cours": ["Maths", "Python"]
}

# Écrire dans un fichier JSON
with open("donnees.json", "w") as fichier:
json.dump(data, fichier, indent=4)

# Lire depuis un fichier JSON
with open("donnees.json", "r") as fichier:
data_lue = json.load(fichier)

print(data_lue) # Affiche : {'nom': 'Alice', 'age': 25, 'cours': ['Maths', 'Python']}

2. Manipulation de fichiers CSV avec csv

📷 Code dans un éditeur :

import csv

# Écrire dans un fichier CSV
with open("etudiants.csv", "w", newline="") as fichier:
    writer = csv.writer(fichier)
    writer.writerow(["ID", "Nom", "Note"])
    writer.writerow([1, "Alice", 15])
    writer.writerow([2, "Bob", 18])

# Lire un fichier CSV
with open("etudiants.csv", "r") as fichier:
    reader = csv.reader(fichier)
    for ligne in reader:
        print(ligne)

# Affiche :
# ['ID', 'Nom', 'Note']
# ['1', 'Alice', '15']
# ['2', 'Bob', '18']

import csv

# Écrire dans un fichier CSV
with open("etudiants.csv", "w", newline="") as fichier:
writer = csv.writer(fichier)
writer.writerow(["ID", "Nom", "Note"])
writer.writerow([1, "Alice", 15])
writer.writerow([2, "Bob", 18])

# Lire un fichier CSV
with open("etudiants.csv", "r") as fichier:
reader = csv.reader(fichier)
for ligne in reader:
print(ligne)

# Affiche :
# ['ID', 'Nom', 'Note']
# ['1', 'Alice', '15']
# ['2', 'Bob', '18']

3. Manipulation de CSV avec pandas

📷 Code dans un éditeur :

import pandas as pd

# Lire un fichier CSV
df = pd.read_csv("etudiants.csv")
print(df) # Affiche un DataFrame

print("Moyenne des notes :", df["Note"].mean()) # Affiche : 16.5

# Écrire un DataFrame dans un CSV
df["Note"] += 1 # Augmenter toutes les notes de 1
df.to_csv("etudiants_modifies.csv", index=False)

import pandas as pd

# Lire un fichier CSV
df = pd.read_csv("etudiants.csv")
print(df) # Affiche un DataFrame

print("Moyenne des notes :", df["Note"].mean()) # Affiche : 16.5

# Écrire un DataFrame dans un CSV
df["Note"] += 1 # Augmenter toutes les notes de 1
df.to_csv("etudiants_modifies.csv", index=False)

4. Utilisation de pathlib

📷 Code dans un éditeur :

from pathlib import Path

# Créer un dossier
dossier = Path("mon_dossier")
dossier.mkdir(exist_ok=True)

# Lister les fichiers dans un dossier
for fichier in dossier.iterdir():
    print(fichier.name)

# Vérifier si un fichier existe
fichier = Path("donnees.json")
if fichier.exists():
    print(f"Le fichier {fichier} existe.")

from pathlib import Path

# Créer un dossier
dossier = Path("mon_dossier")
dossier.mkdir(exist_ok=True)

# Lister les fichiers dans un dossier
for fichier in dossier.iterdir():
print(fichier.name)

# Vérifier si un fichier existe
fichier = Path("donnees.json")
if fichier.exists():
print(f"Le fichier {fichier} existe.")

Partie 1 : Théorie - Analyse de Données avec Python

NumPy

NumPy est une bibliothèque pour les calculs numériques, idéale pour manipuler des tableaux multidimensionnels.

  • Tableaux : Structures similaires aux listes, mais optimisées pour les calculs.
  • Opérations : Opérations vectorisées (addition, multiplication, etc.) sans boucles.
  • Fonctions : Calculs statistiques (moyenne, écart-type), algèbre linéaire, etc.

Pandas

Pandas est une bibliothèque pour l'analyse de données tabulaires.

  • DataFrame : Structure en tableau 2D (comme une feuille de calcul).
  • Séries : Colonnes individuelles d'un DataFrame.
  • Fonctionnalités : Filtrage, regroupement, fusion de données.

Matplotlib

Matplotlib permet de créer des visualisations de données.

  • Graphiques : Lignes, barres, histogrammes, nuages de points.
  • Personnalisation : Titres, étiquettes, légendes.

Partie 2 : Exemple de Code

1. NumPy : Manipulation de tableaux

📷 Code dans un éditeur :

import numpy as np

# Créer un tableau
tableau = np.array([1, 2, 3, 4, 5])
print(tableau) # Affiche : [1 2 3 4 5]

# Opérations vectorisées
tableau_carre = tableau ** 2
print(tableau_carre) # Affiche : [ 1 4 9 16 25]

# Calculs statistiques
moyenne = np.mean(tableau)
ecart_type = np.std(tableau)
print(f"Moyenne : {moyenne}, Écart-type : {ecart_type}") # Affiche : Moyenne : 3.0, Écart-type : 1.4142135623730951

import numpy as np

# Créer un tableau
tableau = np.array([1, 2, 3, 4, 5])
print(tableau) # Affiche : [1 2 3 4 5]

# Opérations vectorisées
tableau_carre = tableau ** 2
print(tableau_carre) # Affiche : [ 1 4 9 16 25]

# Calculs statistiques
moyenne = np.mean(tableau)
ecart_type = np.std(tableau)
print(f"Moyenne : {moyenne}, Écart-type : {ecart_type}") # Affiche : Moyenne : 3.0, Écart-type : 1.4142135623730951

2. Pandas : Manipulation de DataFrames

📷 Code dans un éditeur :

import pandas as pd

# Créer un DataFrame
data = {
    "Nom": ["Alice", "Bob", "Charlie"],
    "Age": [25, 30, 22],
    "Note": [15, 18, 12]
}

df = pd.DataFrame(data)
print(df)

# Affiche :
# Nom Age Note
# 0 Alice 25 15
# 1 Bob 30 18
# 2 Charlie 22 12

# Filtrer les données
jeunes = df[df["Age"] < 30]
print(jeunes)

# Affiche :
# Nom Age Note
# 0 Alice 25 15
# 2 Charlie 22 12

# Calculer la moyenne des notes
print("Moyenne des notes :", df["Note"].mean()) # Affiche : 15.0

import pandas as pd

# Créer un DataFrame
data = {
"Nom": ["Alice", "Bob", "Charlie"],
"Age": [25, 30, 22],
"Note": [15, 18, 12]
}

df = pd.DataFrame(data)
print(df)

# Affiche :
# Nom Age Note
# 0 Alice 25 15
# 1 Bob 30 18
# 2 Charlie 22 12

# Filtrer les données
jeunes = df[df["Age"] < 30] print(jeunes) # Affiche : # Nom Age Note # 0 Alice 25 15 # 2 Charlie 22 12 # Calculer la moyenne des notes print("Moyenne des notes :", df["Note"].mean()) # Affiche : 15.0

3. Matplotlib : Visualisations

📷 Code dans un éditeur :

import matplotlib.pyplot as plt

# Données
ages = df["Age"]
notes = df["Note"]

# Créer un graphique en nuage de points
plt.scatter(ages, notes, color="blue", label="Étudiants")
plt.xlabel("Âge")
plt.ylabel("Note")
plt.title("Relation entre l'âge et la note")
plt.legend()
plt.grid(True)
plt.show() # Affiche un graphique

import matplotlib.pyplot as plt

# Données
ages = df["Age"]
notes = df["Note"]

# Créer un graphique en nuage de points
plt.scatter(ages, notes, color="blue", label="Étudiants")
plt.xlabel("Âge")
plt.ylabel("Note")
plt.title("Relation entre l'âge et la note")
plt.legend()
plt.grid(True)
plt.show() # Affiche un graphique

Partie 1 : Théorie - Programmation Fonctionnelle et Avancée

Programmation Fonctionnelle

La programmation fonctionnelle favorise l'utilisation de fonctions pures (sans effets secondaires) et évite les modifications d'état.

  • Fonctions Lambda : Fonctions anonymes définies en une ligne.
  • map : Applique une fonction à chaque élément d'un itérable.
  • filter : Sélectionne les éléments d'un itérable selon une condition.
  • reduce : Combine les éléments d'un itérable en une seule valeur.

Décorateurs

Les décorateurs sont des fonctions qui modifient le comportement d'autres fonctions ou méthodes.

  • Syntaxe : Utilise @nom_décorateur au-dessus d'une fonction.
  • Utilisations : Mesurer le temps d'exécution, ajouter des vérifications, journaliser.

Générateurs

Les générateurs permettent de produire des valeurs une à une, économisant la mémoire (évaluation paresseuse).

  • Utilise le mot-clé yield au lieu de return.
  • Idéal pour traiter de grandes quantités de données.

Partie 2 : Exemple de Code

1. Fonctions Lambda, map, filter, reduce

📷 Code dans un éditeur :

from functools import reduce

# Lambda : Doubler un nombre
doubler = lambda x: x * 2
print(doubler(5)) # Affiche : 10

# map : Appliquer une fonction à une liste
nombres = [1, 2, 3, 4]
carres = list(map(lambda x: x**2, nombres))
print(carres) # Affiche : [1, 4, 9, 16]

# filter : Sélectionner les nombres pairs
pairs = list(filter(lambda x: x % 2 == 0, nombres))
print(pairs) # Affiche : [2, 4]

# reduce : Calculer la somme d'une liste
somme = reduce(lambda x, y: x + y, nombres)
print(somme) # Affiche : 10

from functools import reduce

# Lambda : Doubler un nombre
doubler = lambda x: x * 2
print(doubler(5)) # Affiche : 10

# map : Appliquer une fonction à une liste
nombres = [1, 2, 3, 4]
carres = list(map(lambda x: x**2, nombres))
print(carres) # Affiche : [1, 4, 9, 16]

# filter : Sélectionner les nombres pairs
pairs = list(filter(lambda x: x % 2 == 0, nombres))
print(pairs) # Affiche : [2, 4]

# reduce : Calculer la somme d'une liste
somme = reduce(lambda x, y: x + y, nombres)
print(somme) # Affiche : 10

2. Décorateurs

📷 Code dans un éditeur :

import time

def mesure_temps(fonction):
    def wrapper(*args, **kwargs):
        debut = time.time()
        resultat = fonction(*args, **kwargs)
        fin = time.time()
        print(f"Temps d'exécution de {fonction.__name__} : {fin - debut:.4f} secondes")
        return resultat
    return wrapper

@mesure_temps
def calcul_lent(n):
    return sum(i * i for i in range(n))

# Test
print(calcul_lent(1000000)) # Affiche le résultat et le temps d'exécution

import time

def mesure_temps(fonction):
def wrapper(*args, **kwargs):
debut = time.time()
resultat = fonction(*args, **kwargs)
fin = time.time()
print(f"Temps d'exécution de {fonction.__name__} : {fin - debut:.4f} secondes")
return resultat
return wrapper

@mesure_temps
def calcul_lent(n):
return sum(i * i for i in range(n))

# Test
print(calcul_lent(1000000)) # Affiche le résultat et le temps d'exécution

3. Générateurs

📷 Code dans un éditeur :

def fibonacci(n):
    a, b = 0, 1
    for _ in range(n):
        yield a
        a, b = b, a + b

# Utiliser le générateur
for nombre in fibonacci(10):
    print(nombre, end=" ") # Affiche : 0 1 1 2 3 5 8 13 21 34

def fibonacci(n):
a, b = 0, 1
for _ in range(n):
yield a
a, b = b, a + b

# Utiliser le générateur
for nombre in fibonacci(10):
print(nombre, end=" ") # Affiche : 0 1 1 2 3 5 8 13 21 34

Partie 1 : Théorie - Développement Web avec Flask

Qu'est-ce que Flask ?

Flask est un micro-framework web Python qui permet de créer des applications web rapidement.

  • Routes : Associent une URL à une fonction Python.
  • Templates : Fichiers HTML avec des placeholders pour des données dynamiques (utilise Jinja2).
  • Requêtes HTTP : GET (récupérer des données) et POST (envoyer des données via formulaires).
  • Flask : Léger, flexible, idéal pour des applications simples ou des prototypes.

Concepts clés

  • Configuration : Créer une application Flask et définir des routes.
  • Templates : Utiliser Jinja2 pour générer du contenu dynamique.
  • Formulaires : Gérer les données utilisateur via des requêtes POST.
  • Structure : Organiser le code avec des fichiers Python et des dossiers pour les templates.

Partie 2 : Exemple de Code

1. Création d'une application Flask de base

📷 Code dans un éditeur :

from flask import Flask

app = Flask(__name__)

@app.route('/')
def accueil():
    return "Bienvenue sur mon site Flask !"

@app.route('/salut/<nom>')
def saluer(nom):
    return f"Salut, {nom} !"

if __name__ == '__main__':
    app.run(debug=True)

from flask import Flask

app = Flask(__name__)

@app.route('/')
def accueil():
return "Bienvenue sur mon site Flask !"

@app.route('/salut/')
def saluer(nom):
return f"Salut, {nom} !"

if __name__ == '__main__':
app.run(debug=True)

Instructions :

  • Sauvegardez ce code dans un fichier app.py.
  • Exécutez-le avec python app.py.
  • Visitez http://127.0.0.1:5000/ pour voir "Bienvenue sur mon site Flask !".
  • Visitez http://127.0.0.1:5000/salut/Alice pour voir "Salut, Alice !".

2. Utilisation de templates

Créez un dossier templates et un fichier index.html :

📷 Fichier templates/index.html :

<!DOCTYPE html>
<html>
<head>
    <title>Mon Site Flask</title>
</head>
<body>
    <h1>Bienvenue, {{ nom }} !</h1>
    <p>Ceci est une page dynamique rendue avec Flask et Jinja2.</p>
</body>
</html>




Mon Site Flask

Bienvenue, {{ nom }} !

Ceci est une page dynamique rendue avec Flask et Jinja2.


Code Python pour rendre le template :

📷 Code dans un éditeur :

from flask import Flask, render_template

app = Flask(__name__)

@app.route('/accueil/<nom>')
def accueil(nom):
    return render_template('index.html', nom=nom)

if __name__ == '__main__':
    app.run(debug=True)

from flask import Flask, render_template

app = Flask(__name__)

@app.route('/accueil/')
def accueil(nom):
return render_template('index.html', nom=nom)

if __name__ == '__main__':
app.run(debug=True)

Visitez http://127.0.0.1:5000/accueil/Alice pour voir la page rendue avec "Bienvenue, Alice !".

3. Gestion d'un formulaire

Créez un fichier templates/formulaire.html :

📷 Fichier templates/formulaire.html :

<!DOCTYPE html>
<html>
<head>
    <title>Formulaire</title>
</head>
<body>
    <h1>Ajouter une tâche</h1>
    <form method="POST" action="/ajouter">
        <input type="text" name="tache" placeholder="Entrez une tâche">
        <input type="submit" value="Ajouter">
    </form>

    <h2>Tâches :</h2>
    <ul>
    {% for tache in taches %}
        <li>{{ tache }}</li>
    {% endfor %}
    </ul>
</body>
</html>




Formulaire

Ajouter une tâche



Tâches :

    {% for tache in taches %}

  • {{ tache }}

    • {% endfor %}


Code Python pour gérer le formulaire :

📷 Code dans un éditeur :

from flask import Flask, render_template, request

app = Flask(__name__)

taches = []

@app.route('/')
def accueil():
    return render_template('formulaire.html', taches=taches)

@app.route('/ajouter', methods=['POST'])
def ajouter_tache():
    tache = request.form['tache']
    taches.append(tache)
    return render_template('formulaire.html', taches=taches)

if __name__ == '__main__':
    app.run(debug=True)

from flask import Flask, render_template, request

app = Flask(__name__)

taches = []

@app.route('/')
def accueil():
return render_template('formulaire.html', taches=taches)

@app.route('/ajouter', methods=['POST'])
def ajouter_tache():
tache = request.form['tache']
taches.append(tache)
return render_template('formulaire.html', taches=taches)

if __name__ == '__main__':
app.run(debug=True)

Instructions :

  • Visitez http://127.0.0.1:5000/ pour voir le formulaire.
  • Saisissez une tâche et soumettez pour l'ajouter à la liste.