Exercices Python

# Demander les nombres à l'utilisateur
a = float(input("Entrez le premier nombre : "))
b = float(input("Entrez le second nombre : "))

# Calculs
somme = a + b
difference = a - b
produit = a * b
quotient = a / b if b != 0 else "Division par zéro impossible"

# Affichage des résultats
print(f"Somme : {somme}")
print(f"Différence : {difference}")
print(f"Produit : {produit}")
print(f"Quotient : {quotient}")
                        

def celsius_vers_fahrenheit(celsius):
    return (celsius * 9/5) + 32

def fahrenheit_vers_celsius(fahrenheit):
    return (fahrenheit - 32) * 5/9

# Exemples d'utilisation
temp_c = 25
temp_f = celsius_vers_fahrenheit(temp_c)
print(f"{temp_c}°C = {temp_f}°F")

temp_f = 77
temp_c = fahrenheit_vers_celsius(temp_f)
print(f"{temp_f}°F = {temp_c}°C")
                        

def est_premier(n):
    """Vérifie si un nombre est premier"""
    if n < 2:
        return False
    for i in range(2, int(n**0.5) + 1):
        if n % i == 0:
            return False
    return True

# Test de la fonction
for i in range(1, 21):
    if est_premier(i):
        print(f"{i} est un nombre premier")
                        

def tri_bulles(liste):
    """Tri à bulles"""
    n = len(liste)
    for i in range(n):
        for j in range(0, n-i-1):
            if liste[j] > liste[j+1]:
                liste[j], liste[j+1] = liste[j+1], liste[j]
    return liste

# Test
nombres = [64, 34, 25, 12, 22, 11, 90]
print("Liste originale :", nombres)
tri_bulles(nombres)
print("Liste triée :", nombres)
                        

class CompteBancaire:
    def __init__(self, titulaire, solde_initial=0):
        self.titulaire = titulaire
        self.solde = solde_initial
    
    def deposer(self, montant):
        if montant > 0:
            self.solde += montant
            print(f"Dépôt de {montant}€ effectué. Nouveau solde : {self.solde}€")
        else:
            print("Le montant doit être positif")
    
    def retirer(self, montant):
        if 0 < montant <= self.solde:
            self.solde -= montant
            print(f"Retrait de {montant}€ effectué. Nouveau solde : {self.solde}€")
        else:
            print("Montant invalide ou solde insuffisant")
    
    def consulter_solde(self):
        print(f"Solde du compte de {self.titulaire} : {self.solde}€")

# Utilisation
compte = CompteBancaire("Alice", 1000)
compte.consulter_solde()
compte.deposer(500)
compte.retirer(200)
                        

def fibonacci(n):
    """Générateur de nombres de Fibonacci"""
    a, b = 0, 1
    for _ in range(n):
        yield a
        a, b = b, a + b

# Utilisation
print("Premiers 10 nombres de Fibonacci :")
for i, num in enumerate(fibonacci(10)):
    print(f"F({i}) = {num}")

# Création d'une liste avec les 15 premiers nombres
fib_liste = list(fibonacci(15))
print(f"\nListe des 15 premiers nombres : {fib_liste}")
                        

class GestionnaireTaches:
    def __init__(self):
        self.taches = []
    
    def ajouter_tache(self, description):
        tache = {
            'id': len(self.taches) + 1,
            'description': description,
            'complete': False
        }
        self.taches.append(tache)
        print(f"Tâche ajoutée : {description}")
    
    def lister_taches(self):
        if not self.taches:
            print("Aucune tâche à afficher")
            return
        
        for tache in self.taches:
            status = "✓" if tache['complete'] else "○"
            print(f"[{status}] {tache['id']}. {tache['description']}")
    
    def completer_tache(self, id_tache):
        for tache in self.taches:
            if tache['id'] == id_tache:
                tache['complete'] = True
                print(f"Tâche {id_tache} marquée comme complète")
                return
        print(f"Tâche {id_tache} non trouvée")
    
    def supprimer_tache(self, id_tache):
        for i, tache in enumerate(self.taches):
            if tache['id'] == id_tache:
                del self.taches[i]
                print(f"Tâche {id_tache} supprimée")
                return
        print(f"Tâche {id_tache} non trouvée")

# Utilisation
gestionnaire = GestionnaireTaches()
gestionnaire.ajouter_tache("Apprendre Python")
gestionnaire.ajouter_tache("Faire les courses")
gestionnaire.lister_taches()
gestionnaire.completer_tache(1)
gestionnaire.lister_taches()
                        

import re
from collections import Counter

class AnalyseurTexte:
    def __init__(self, texte):
        self.texte = texte
        self.mots = re.findall(r'\b[a-zA-Z]+\b', texte.lower())
    
    def nombre_mots(self):
        return len(self.mots)
    
    def nombre_phrases(self):
        phrases = re.split(r'[.!?]+', self.texte)
        return len([p for p in phrases if p.strip()])
    
    def mots_frequents(self, n=5):
        compteur = Counter(self.mots)
        return compteur.most_common(n)
    
    def longueur_moyenne_mots(self):
        if not self.mots:
            return 0
        total_longueur = sum(len(mot) for mot in self.mots)
        return total_longueur / len(self.mots)
    
    def generer_rapport(self):
        print("=== RAPPORT D'ANALYSE ===")
        print(f"Nombre de mots : {self.nombre_mots()}")
        print(f"Nombre de phrases : {self.nombre_phrases()}")
        print(f"Longueur moyenne des mots : {self.longueur_moyenne_mots():.2f} caractères")
        print("\nMots les plus fréquents :")
        for mot, frequence in self.mots_frequents():
            print(f"  {mot} : {frequence} fois")

# Utilisation
texte = """
Python est un langage de programmation puissant et facile à apprendre. 
Il dispose de structures de données efficaces et d'une approche simple 
de la programmation orientée objet. Python est idéal pour les débutants 
et les experts en programmation.
"""

analyseur = AnalyseurTexte(texte)
analyseur.generer_rapport()
                        

Étape 1 : Comprendre la structure du projet

Le projet RAG contient trois fichiers principaux :

• core.md : Liste des dépendances nécessaires
• mod1.md : Concepts avancés de Python et exercices
• rag.py : Code principal du moteur de recherche documentaire

Étape 2 : Concepts clés à maîtriser

Avant d'aborder le code complet, concentrez-vous sur ces concepts :

# 1. Programmation orientée objet - Classes de base
class Document:
    def __init__(self, nom, contenu):
        self.nom = nom
        self.contenu = contenu

# 2. Gestion de fichiers avec context manager
def lire_fichier(nom_fichier):
    try:
        with open(nom_fichier, 'r', encoding='utf-8') as f:
            return f.read()
    except FileNotFoundError:
        print(f"Fichier {nom_fichier} non trouvé")
        return ""

# 3. List comprehensions (compréhensions de liste)
nombres = [1, 2, 3, 4, 5]
carres = [x**2 for x in nombres]  # [1, 4, 9, 16, 25]
pairs = [x for x in nombres if x % 2 == 0]  # [2, 4]

# 4. Utilisation de bibliothèques externes
import os
from pathlib import Path

# Créer un chemin
chemin = Path("documents/test.txt")

# Vérifier si le fichier existe
if chemin.exists():
    print("Le fichier existe")
                        

Étape 3 : Exercices progressifs

Pratiquez ces exercices pour vous familiariser avec les concepts :

# Objectif : Créer une fonction qui peut lire différents types de fichiers
def lire_document(chemin_fichier):
    """
    Lit un fichier et retourne son contenu
    Supporte : .txt, .md
    """
    chemin = Path(chemin_fichier)
    
    if not chemin.exists():
        return "Fichier non trouvé"
    
    # Vérifier l'extension
    if chemin.suffix in ['.txt', '.md']:
        try:
            with open(chemin, 'r', encoding='utf-8') as f:
                return f.read()
        except Exception as e:
            return f"Erreur de lecture : {e}"
    else:
        return "Type de fichier non supporté"

# Test
# contenu = lire_document("exemple.txt")
# print(contenu)
                        

# Objectif : Extraire le texte d'un document HTML
from bs4 import BeautifulSoup

def extraire_texte_html(contenu_html):
    """
    Extrait le texte brut d'un document HTML
    """
    try:
        soup = BeautifulSoup(contenu_html, 'html.parser')
        
        # Supprimer les balises script et style
        for script in soup(["script", "style"]):
            script.decompose()
            
        # Extraire le texte
        texte = soup.get_text()
        
        # Nettoyer les espaces multiples
        lignes = (ligne.strip() for ligne in texte.splitlines())
        paragraphes = (phrase.strip() for ligne in lignes for phrase in ligne.split("  "))
        texte_nettoye = ' '.join(paragraphe for paragraphe in paragraphes if paragraphe)
        
        return texte_nettoye
    except Exception as e:
        return f"Erreur d'extraction : {e}"

# Test
# html_sample = "<html><body><h1>Titre</h1><p>Contenu du paragraphe.</p></body></html>"
# texte = extraire_texte_html(html_sample)
# print(texte)
                        

# Objectif : Découper un long texte en morceaux plus petits
def decouper_texte(texte, taille_max=500):
    """
    Découpe un texte en morceaux de taille maximale donnée
    """
    mots = texte.split()
    morceaux = []
    morceau_courant = []
    longueur_courante = 0
    
    for mot in mots:
        # +1 pour l'espace
        if longueur_courante + len(mot) + 1 <= taille_max or not morceau_courant:
            morceau_courant.append(mot)
            longueur_courante += len(mot) + 1
        else:
            # Sauvegarder le morceau courant
            morceaux.append(" ".join(morceau_courant))
            # Commencer un nouveau morceau
            morceau_courant = [mot]
            longueur_courante = len(mot)
    
    # Ne pas oublier le dernier morceau
    if morceau_courant:
        morceaux.append(" ".join(morceau_courant))
    
    return morceaux

# Test
# long_texte = "Python est un langage de programmation..." * 100  # Texte long
# morceaux = decouper_texte(long_texte, 100)
# print(f"Nombre de morceaux : {len(morceaux)}")
# for i, morceau in enumerate(morceaux[:3]):  # Afficher les 3 premiers
#     print(f"Morceau {i+1} : {morceau[:50]}...")
                        

Étape 4 : Explorer le code RAG

Une fois ces concepts maîtrisés, vous pouvez explorer le fichier rag.py :

1. Commencez par lire les commentaires et docstrings
2. Identifiez les différentes classes et leurs responsabilités
3. Exécutez le programme avec des fichiers de test simples
4. Modifiez progressivement le code pour comprendre son fonctionnement