32 exemples d’applications Python projets concrets avec code

def calculer(a, b, operateur):
    operations = {
        "+": lambda x, y: x + y,
        "-": lambda x, y: x - y,
        "*": lambda x, y: x * y,
        "/": lambda x, y: x / y if y != 0 else None
    }
    if operateur not in operations:
        raise ValueError(f"Opérateur non reconnu : {operateur}")
    resultat = operations[operateur](a, b)
    if resultat is None:
        raise ZeroDivisionError("Division par zéro")
    return resultat

while True:
    try:
        a = float(input("Premier nombre : "))
        op = input("Opérateur (+, -, *, /) : ")
        b = float(input("Second nombre : "))
        print(f"Résultat : {calculer(a, b, op)}")
    except (ValueError, ZeroDivisionError) as e:
        print(f"Erreur : {e}")
    except KeyboardInterrupt:
        break

import secrets
import string

def generer_mot_de_passe(longueur=16, chiffres=True, symboles=True):
    alphabet = string.ascii_letters
    if chiffres:
        alphabet += string.digits
    if symboles:
        alphabet += string.punctuation

    # secrets.choice est cryptographiquement sûr, contrairement à random.choice
    mot_de_passe = "".join(secrets.choice(alphabet) for _ in range(longueur))
    return mot_de_passe

print(generer_mot_de_passe(longueur=20, symboles=True))
# Exemple de sortie : P$k9#mQ2!vR7&nL4@xW1

import json
import os

FICHIER = "taches.json"

def charger_taches():
    if os.path.exists(FICHIER):
        with open(FICHIER, "r", encoding="utf-8") as f:
            return json.load(f)
    return []

def sauvegarder(taches):
    with open(FICHIER, "w", encoding="utf-8") as f:
        json.dump(taches, f, ensure_ascii=False, indent=2)

taches = charger_taches()

while True:
    print(f"\n{len(taches)} tâche(s) en cours.")
    commande = input("Commande (ajouter/liste/terminer/quitter) : ").strip()

    if commande == "ajouter":
        tache = input("Tâche : ")
        taches.append({"titre": tache, "fait": False})
        sauvegarder(taches)
    elif commande == "liste":
        for i, t in enumerate(taches):
            etat = "✓" if t["fait"] else "○"
            print(f"  {i + 1}. [{etat}] {t['titre']}")
    elif commande == "terminer":
        idx = int(input("Numéro : ")) - 1
        taches[idx]["fait"] = True
        sauvegarder(taches)
    elif commande == "quitter":
        break

import random

MOTS = ["python", "application", "algorithme", "variable", "fonction", "bibliotheque"]
MAX_ERREURS = 6

mot = random.choice(MOTS)
trouve = set()
erreurs = 0

while erreurs < MAX_ERREURS:
    affichage = " ".join(c if c in trouve else "_" for c in mot)
    print(f"\n{affichage}  (erreurs : {erreurs}/{MAX_ERREURS})")

    if "_" not in affichage:
        print("Gagné !")
        break

    lettre = input("Lettre : ").lower().strip()
    if lettre in mot:
        trouve.add(lettre)
    else:
        erreurs += 1
        print(f"Raté. Il reste {MAX_ERREURS - erreurs} essai(s).")
else:
    print(f"Perdu. Le mot était : {mot}")

conversions = {
    "km_en_miles":              lambda x: x * 0.621371,
    "miles_en_km":              lambda x: x * 1.60934,
    "celsius_en_fahrenheit":    lambda x: (x * 9/5) + 32,
    "fahrenheit_en_celsius":    lambda x: (x - 32) * 5/9,
    "kg_en_livres":             lambda x: x * 2.20462,
    "livres_en_kg":             lambda x: x * 0.453592,
}

print("Conversions disponibles :")
for cle in conversions:
    print(f"  - {cle}")

choix = input("\nConversion : ")
if choix in conversions:
    valeur = float(input("Valeur : "))
    print(f"Résultat : {conversions[choix](valeur):.4f}")
else:
    print("Conversion non reconnue.")

import random

questions = [
    {"question": "Quelle librairie Python sert à l'analyse de données ?", "reponse": "pandas"},
    {"question": "Quel mot-clé définit une fonction en Python ?", "reponse": "def"},
    {"question": "Quelle extension ont les fichiers Python ?", "reponse": ".py"},
    {"question": "Quel framework Python est utilisé pour le web ?", "reponse": "django"},
]

random.shuffle(questions)
score = 0

for i, q in enumerate(questions):
    rep = input(f"\nQuestion {i+1}/{len(questions)} : {q['question']}\nVotre réponse : ").strip().lower()
    if rep == q["reponse"]:
        print("Correct.")
        score += 1
    else:
        print(f"Incorrect. Réponse : {q['reponse']}")

print(f"\nScore final : {score}/{len(questions)}")

from pathlib import Path

dossier = Path("./photos")
prefixe = "2026_osmova_"

for i, fichier in enumerate(sorted(dossier.iterdir())):
    if fichier.is_file():
        nouveau_nom = dossier / f"{prefixe}{i+1:03d}{fichier.suffix}"
        fichier.rename(nouveau_nom)
        print(f"{fichier.name} -> {nouveau_nom.name}")

# Avant : photo1.jpg, image.jpg, shot.jpg
# Après : 2026_osmova_001.jpg, 2026_osmova_002.jpg, 2026_osmova_003.jpg

import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart

EXPEDITEUR  = "votre.email@gmail.com"
MOT_DE_PASSE = "xxxx xxxx xxxx xxxx"  # Mot de passe d'application Google
DESTINATAIRE = "client@exemple.com"

message = MIMEMultipart()
message["From"]    = EXPEDITEUR
message["To"]      = DESTINATAIRE
message["Subject"] = "Rapport hebdomadaire"

corps = "Bonjour,\n\nVeuillez trouver ci-joint le rapport.\n\nCordialement"
message.attach(MIMEText(corps, "plain"))

with smtplib.SMTP_SSL("smtp.gmail.com", 465) as serveur:
    serveur.login(EXPEDITEUR, MOT_DE_PASSE)
    serveur.sendmail(EXPEDITEUR, DESTINATAIRE, message.as_string())
    print("Email envoyé.")

import requests
from bs4 import BeautifulSoup
import csv

URL = "https://books.toscrape.com/"  # Site de démonstration légal

reponse = requests.get(URL, timeout=10)
reponse.raise_for_status()

soupe = BeautifulSoup(reponse.text, "html.parser")
livres = soupe.select("article.product_pod")

with open("livres.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.writer(f)
    writer.writerow(["Titre", "Prix"])
    for livre in livres:
        titre = livre.h3.a["title"]
        prix  = livre.select_one(".price_color").text.strip()
        writer.writerow([titre, prix])
        print(f"{titre} - {prix}")

print(f"\n{len(livres)} livres extraits dans livres.csv")

import fitz  # PyMuPDF : pip install pymupdf

def extraire_texte_pdf(chemin_pdf, chemin_sortie):
    document = fitz.open(chemin_pdf)
    texte_complet = []

    for numero, page in enumerate(document):
        texte = page.get_text()
        texte_complet.append(f"--- Page {numero + 1} ---\n{texte}")

    document.close()

    with open(chemin_sortie, "w", encoding="utf-8") as f:
        f.write("\n".join(texte_complet))

    print(f"{len(document)} page(s) extraite(s) dans {chemin_sortie}")

extraire_texte_pdf("rapport.pdf", "rapport_texte.txt")

import time
from plyer import notification

def envoyer_notification(titre, message, duree=10):
    notification.notify(title=titre, message=message, timeout=duree)

# Rappel toutes les 25 minutes (technique Pomodoro)
intervalle = 25 * 60
cycle = 1
print("Minuteur Pomodoro lancé. Ctrl+C pour arrêter.")

try:
    while True:
        time.sleep(intervalle)
        envoyer_notification(
            titre=f"Pomodoro #{cycle} terminé",
            message="Temps de faire une pause de 5 minutes."
        )
        cycle += 1
except KeyboardInterrupt:
    print("Minuteur arrêté.")

import csv
from datetime import date
from collections import defaultdict

depenses = []
totaux   = defaultdict(float)
print("Suivi de dépenses — saisissez 'fin' pour terminer.")

while True:
    description = input("\nDépense (ou 'fin') : ")
    if description.lower() == "fin":
        break
    categorie = input("Catégorie (alimentation/transport/logement/autre) : ")
    montant   = float(input("Montant (€) : "))
    depenses.append({"date": date.today().isoformat(), "description": description,
                     "categorie": categorie, "montant": montant})
    totaux[categorie] += montant

print("\nRécapitulatif par catégorie :")
for cat, total in sorted(totaux.items()):
    print(f"  {cat} : {total:.2f} €")
print(f"  Total : {sum(totaux.values()):.2f} €")

with open("depenses.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=["date", "description", "categorie", "montant"])
    writer.writeheader()
    writer.writerows(depenses)
print("\nExport enregistré dans depenses.csv")

from flask import Flask, jsonify, request

app = Flask(__name__)

produits = [
    {"id": 1, "nom": "Clavier mécanique", "prix": 89.99},
    {"id": 2, "nom": "Souris ergonomique", "prix": 54.99},
]

@app.route("/produits", methods=["GET"])
def lister_produits():
    return jsonify(produits)

@app.route("/produits/<int:produit_id>", methods=["GET"])
def obtenir_produit(produit_id):
    produit = next((p for p in produits if p["id"] == produit_id), None)
    if produit is None:
        return jsonify({"erreur": "Produit non trouvé"}), 404
    return jsonify(produit)

@app.route("/produits", methods=["POST"])
def ajouter_produit():
    data   = request.get_json()
    nouveau = {"id": len(produits) + 1, **data}
    produits.append(nouveau)
    return jsonify(nouveau), 201

if __name__ == "__main__":
    app.run(debug=True)
# Accès : http://localhost:5000/produits

import streamlit as st
import pandas as pd
import matplotlib.pyplot as plt

st.title("Tableau de bord des ventes")

df = pd.DataFrame({
    "Mois":    ["Jan", "Fév", "Mar", "Avr", "Mai", "Jun"],
    "Ventes":  [12500, 18200, 15800, 22100, 19400, 25600],
    "Objectif":[15000, 15000, 18000, 20000, 20000, 24000]
})

col1, col2 = st.columns(2)
col1.metric("Ventes totales", f"{df.Ventes.sum():,.0f} €")
col2.metric("Meilleur mois", df.loc[df.Ventes.idxmax(), "Mois"])

fig, ax = plt.subplots()
ax.bar(df["Mois"], df["Ventes"], label="Ventes réelles")
ax.plot(df["Mois"], df["Objectif"], color="red", label="Objectif")
ax.legend()
st.pyplot(fig)

# Lancer avec : streamlit run dashboard.py

import discord
from discord.ext import commands

intents = discord.Intents.default()
intents.message_content = True
bot = commands.Bot(command_prefix="!", intents=intents)

@bot.event
async def on_ready():
    print(f"Bot connecté en tant que {bot.user}")

@bot.command()
async def bonjour(ctx):
    await ctx.send(f"Bonjour {ctx.author.mention} !")

@bot.command()
async def info(ctx):
    await ctx.send(f"Serveur : {ctx.guild.name} | Membres : {ctx.guild.member_count}")

# TOKEN disponible sur https://discord.com/developers/applications
bot.run("VOTRE_TOKEN_ICI")

# models.py (Django)
from django.db import models
from django.contrib.auth.models import User

class Patient(models.Model):
    utilisateur    = models.OneToOneField(User, on_delete=models.CASCADE)
    date_naissance = models.DateField()
    numero_secu    = models.CharField(max_length=15, blank=True)

class RendezVous(models.Model):
    patient    = models.ForeignKey(Patient, on_delete=models.CASCADE)
    medecin    = models.CharField(max_length=100)
    date_heure = models.DateTimeField()
    motif      = models.TextField()
    confirme   = models.BooleanField(default=False)

    class Meta:
        ordering = ["date_heure"]

    def __str__(self):
        return f"{self.patient} - {self.medecin} - {self.date_heure}"

import numpy as np
from scipy.spatial.distance import cdist

# Coordonnées GPS (latitude, longitude)
points = np.array([
    [43.6047, 1.4442],  # Toulouse centre (dépôt)
    [43.6108, 1.4533],  # Livraison 1
    [43.5986, 1.4318],  # Livraison 2
    [43.6215, 1.4401],  # Livraison 3
    [43.5921, 1.4589],  # Livraison 4
])

def plus_proche_voisin(points, depart=0):
    n = len(points)
    distances = cdist(points, points)
    visite = [False] * n
    chemin = [depart]
    visite[depart] = True

    for _ in range(n - 1):
        actuel = chemin[-1]
        distances[actuel][visite] = np.inf
        suivant = np.argmin(distances[actuel])
        chemin.append(suivant)
        visite[suivant] = True

    return chemin

ordre = plus_proche_voisin(points)
print("Ordre optimisé :", " -> ".join(f"Point {i}" for i in ordre))

import pandas as pd

df = pd.read_csv("ventes.csv", parse_dates=["date"])

print(f"Lignes : {len(df)}, colonnes : {len(df.columns)}")
print(f"Valeurs manquantes :\n{df.isnull().sum()}")
df.dropna(subset=["montant", "categorie"], inplace=True)

analyse = df.groupby("categorie").agg(
    total_ventes=("montant", "sum"),
    nombre_commandes=("montant", "count"),
    panier_moyen=("montant", "mean")
).round(2)

print("\nAnalyse par catégorie :")
print(analyse.sort_values("total_ventes", ascending=False))

df["mois"] = df["date"].dt.to_period("M")
mensuel = df.groupby("mois")["montant"].sum()
print(f"\nMeilleur mois : {mensuel.idxmax()} ({mensuel.max():.2f} €)")

import matplotlib.pyplot as plt
import pandas as pd

df = pd.read_csv("ventes.csv", parse_dates=["date"])
df["mois"] = df["date"].dt.to_period("M")

fig, axes = plt.subplots(1, 3, figsize=(15, 5))
fig.suptitle("Rapport de ventes", fontsize=14, fontweight="bold")

df.groupby("mois")["montant"].sum().plot(ax=axes[0], title="Ventes par mois")
axes[0].set_ylabel("€")

df.groupby("categorie")["montant"].sum().plot.pie(
    ax=axes[1], autopct="%1.0f%%", title="Par catégorie")

df["montant"].hist(bins=30, ax=axes[2])
axes[2].set_title("Distribution des montants")
axes[2].set_xlabel("€")

plt.tight_layout()
plt.savefig("rapport_ventes.png", dpi=150, bbox_inches="tight")
print("Graphiques sauvegardés dans rapport_ventes.png")

from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer

analyser = SentimentIntensityAnalyzer()

avis = [
    "Excellent produit, livraison rapide, je recommande vivement !",
    "Déçu par la qualité, ne correspond pas à la description.",
    "Correct sans plus, ni bon ni mauvais.",
    "Service client très réactif, problème résolu en 2h.",
    "Emballage abîmé à la réception, produit inutilisable.",
]

print(f"{'Avis':<55} | Sentiment")
print("-" * 70)
for texte in avis:
    scores   = analyser.polarity_scores(texte)
    compound = scores["compound"]
    if compound >= 0.05:
        sentiment = "Positif"
    elif compound <= -0.05:
        sentiment = "Négatif"
    else:
        sentiment = "Neutre"
    print(f"{texte[:53]:<55} | {sentiment} ({compound:+.2f})")

import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LinearRegression
from sklearn.metrics import mean_absolute_error, r2_score

df = pd.DataFrame({
    "surface": [45, 60, 75, 90, 120, 35, 55, 80, 100, 65],
    "pieces":  [2,  3,  3,  4,  5,   1,  2,  3,  4,   3],
    "etage":   [1,  3,  2,  5,  4,   0,  2,  6,  3,   1],
    "prix":    [180000, 240000, 285000, 360000, 480000,
                140000, 220000, 320000, 400000, 260000]
})

X = df[["surface", "pieces", "etage"]]
y = df["prix"]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

modele = LinearRegression()
modele.fit(X_train, y_train)
predictions = modele.predict(X_test)

print(f"Erreur absolue moyenne : {mean_absolute_error(y_test, predictions):.0f} €")
print(f"Score R² : {r2_score(y_test, predictions):.2f}")

nouveau = pd.DataFrame([{"surface": 70, "pieces": 3, "etage": 4}])
print(f"Prix estimé : {modele.predict(nouveau)[0]:.0f} €")

import plotly.express as px
import pandas as pd

df = pd.DataFrame({
    "Mois":      ["Jan", "Fév", "Mar", "Avr", "Mai", "Jun"],
    "Ventes":    [12500, 18200, 15800, 22100, 19400, 25600],
    "Catégorie": ["A", "B", "A", "B", "A", "B"]
})

fig = px.bar(
    df, x="Mois", y="Ventes", color="Catégorie",
    title="Ventes mensuelles par catégorie",
    labels={"Ventes": "Chiffre d'affaires (€)"},
    text_auto=True
)
fig.update_layout(bargap=0.2)
fig.write_html("rapport_interactif.html")
print("Rapport interactif généré : rapport_interactif.html")

import tensorflow as tf
from tensorflow.keras.applications import MobileNetV2
from tensorflow.keras.applications.mobilenet_v2 import preprocess_input, decode_predictions
from tensorflow.keras.preprocessing import image
import numpy as np

modele = MobileNetV2(weights="imagenet")

def classifier_image(chemin):
    img      = image.load_img(chemin, target_size=(224, 224))
    tableau  = image.img_to_array(img)
    tableau  = np.expand_dims(tableau, axis=0)
    tableau  = preprocess_input(tableau)

    predictions = modele.predict(tableau)
    resultats   = decode_predictions(predictions, top=3)[0]

    print(f"\nClassification de : {chemin}")
    for rang, (_, label, confiance) in enumerate(resultats, 1):
        print(f"  {rang}. {label} ({confiance*100:.1f}%)")

classifier_image("photo.jpg")

from transformers import pipeline

generateur = pipeline("text-generation", model="dbddv01/gpt2-french-small")
prompt     = "Le développement Python permet de"

resultats = generateur(
    prompt,
    max_new_tokens=80,
    num_return_sequences=2,
    temperature=0.8,
    do_sample=True,
    pad_token_id=50256
)

print(f"Prompt : {prompt}\n")
for i, r in enumerate(resultats, 1):
    print(f"Variante {i} : {r['generated_text']}\n")

from ultralytics import YOLO

modele = YOLO("yolov8n.pt")  # Modèle nano : 6 Mo, rapide

def detecter_image(chemin):
    resultats = modele(chemin)
    for r in resultats:
        print(f"Objets détectés : {len(r.boxes)}")
        for boite in r.boxes:
            classe    = modele.names[int(boite.cls)]
            confiance = float(boite.conf)
            print(f"  - {classe} ({confiance*100:.0f}%)")
    resultats[0].save("detection_resultat.jpg")
    print("Image annotée sauvegardée.")

detecter_image("photo.jpg")

import numpy as np
import pandas as pd
from sklearn.metrics.pairwise import cosine_similarity

notes = pd.DataFrame({
    "Python Crash Course": [5, 4, 0, 1, 0],
    "Flask Web Dev":       [4, 0, 5, 0, 3],
    "Data Science Python": [0, 5, 4, 0, 4],
    "Deep Learning":       [1, 0, 3, 5, 0],
    "Automate the Boring": [5, 4, 0, 0, 5],
}, index=["Alice", "Bob", "Carole", "David", "Emma"])

def recommander(utilisateur, top_n=2):
    sim = pd.DataFrame(cosine_similarity(notes), index=notes.index, columns=notes.index)
    poids = sim[utilisateur].drop(utilisateur)
    poids = poids / poids.sum()
    scores = notes.drop(utilisateur).T.dot(poids)
    deja_note = notes.loc[utilisateur][notes.loc[utilisateur] > 0].index
    return scores.drop(deja_note).nlargest(top_n)

print("Recommandations pour Alice :")
print(recommander("Alice"))

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.metrics.pairwise import cosine_similarity
import numpy as np

base = {
    "horaires": {
        "questions": ["quels sont vos horaires", "vous êtes ouverts quand"],
        "reponse":   "Nous sommes ouverts du lundi au vendredi de 9h à 18h."
    },
    "tarifs": {
        "questions": ["combien ça coûte", "quels sont vos tarifs", "prix"],
        "reponse":   "Nos tarifs démarrent à 1 200 € pour un site vitrine."
    },
    "contact": {
        "questions": ["comment vous contacter", "numéro de téléphone"],
        "reponse":   "Contactez-nous au 04 11 78 90 73 ou via le formulaire."
    }
}

corpus, labels, reponses = [], [], {}
for intention, data in base.items():
    for q in data["questions"]:
        corpus.append(q)
        labels.append(intention)
    reponses[intention] = data["reponse"]

vec     = TfidfVectorizer()
matrice = vec.fit_transform(corpus)

def repondre(question):
    v = vec.transform([question])
    sims = cosine_similarity(v, matrice)[0]
    best = np.argmax(sims)
    if sims[best] < 0.1:
        return "Je n'ai pas compris. Pouvez-vous reformuler ?"
    return reponses[labels[best]]

while True:
    q = input("\nVous : ")
    if q.lower() == "quitter":
        break
    print(f"Bot : {repondre(q)}")

import pygame, random, sys

pygame.init()
TAILLE, GRILLE = 20, 20
ecran  = pygame.display.set_mode((TAILLE * GRILLE, TAILLE * GRILLE))
horloge = pygame.time.Clock()

serpent    = [(10, 10)]
direction  = (1, 0)
nourriture = (random.randint(0, GRILLE-1), random.randint(0, GRILLE-1))
score = 0

while True:
    for event in pygame.event.get():
        if event.type == pygame.QUIT: sys.exit()
        if event.type == pygame.KEYDOWN:
            if event.key == pygame.K_UP    and direction != (0,  1): direction = (0, -1)
            elif event.key == pygame.K_DOWN  and direction != (0, -1): direction = (0,  1)
            elif event.key == pygame.K_LEFT  and direction != (1,  0): direction = (-1, 0)
            elif event.key == pygame.K_RIGHT and direction != (-1, 0): direction = (1,  0)

    tete = ((serpent[0][0] + direction[0]) % GRILLE, (serpent[0][1] + direction[1]) % GRILLE)
    if tete in serpent:
        print(f"Partie terminée. Score : {score}")
        sys.exit()
    serpent.insert(0, tete)
    if tete == nourriture:
        score += 1
        nourriture = (random.randint(0, GRILLE-1), random.randint(0, GRILLE-1))
    else:
        serpent.pop()

    ecran.fill((20, 20, 20))
    for seg in serpent:
        pygame.draw.rect(ecran, (0, 200, 80), (seg[0]*TAILLE, seg[1]*TAILLE, TAILLE-1, TAILLE-1))
    pygame.draw.rect(ecran, (220, 50, 50), (nourriture[0]*TAILLE, nourriture[1]*TAILLE, TAILLE, TAILLE))
    pygame.display.set_caption(f"Snake - Score : {score}")
    pygame.display.flip()
    horloge.tick(10)

import tkinter as tk
import json, os

FICHIER = "contacts.json"
contacts = json.load(open(FICHIER)) if os.path.exists(FICHIER) else []

def sauvegarder():
    with open(FICHIER, "w") as f: json.dump(contacts, f)

def ajouter():
    nom, email = entry_nom.get().strip(), entry_email.get().strip()
    if nom and email:
        contacts.append({"nom": nom, "email": email})
        sauvegarder()
        rafraichir()
        entry_nom.delete(0, tk.END)
        entry_email.delete(0, tk.END)

def rafraichir():
    liste.delete(0, tk.END)
    for c in contacts:
        liste.insert(tk.END, f"{c['nom']} - {c['email']}")

fenetre = tk.Tk()
fenetre.title("Carnet de contacts")
fenetre.geometry("400x500")
tk.Label(fenetre, text="Nom").pack()
entry_nom = tk.Entry(fenetre, width=40); entry_nom.pack(pady=4)
tk.Label(fenetre, text="Email").pack()
entry_email = tk.Entry(fenetre, width=40); entry_email.pack(pady=4)
tk.Button(fenetre, text="Ajouter", command=ajouter).pack(pady=8)
liste = tk.Listbox(fenetre, width=55, height=20); liste.pack(padx=10)
rafraichir()
fenetre.mainloop()

import tkinter as tk
from tkinter import filedialog

class Editeur:
    def __init__(self, root):
        root.title("Éditeur Python")
        root.geometry("800x600")
        self.texte = tk.Text(root, wrap=tk.WORD, font=("Courier", 12), undo=True)
        self.texte.pack(fill=tk.BOTH, expand=True)
        self.texte.bind("<KeyRelease>", self.compter_mots)
        barre   = tk.Menu(root)
        fichier = tk.Menu(barre, tearoff=0)
        fichier.add_command(label="Ouvrir",       command=self.ouvrir)
        fichier.add_command(label="Sauvegarder",  command=self.sauvegarder)
        barre.add_cascade(label="Fichier", menu=fichier)
        edition = tk.Menu(barre, tearoff=0)
        edition.add_command(label="Rechercher/Remplacer", command=self.rechercher)
        barre.add_cascade(label="Édition", menu=edition)
        root.config(menu=barre)
        self.statut = tk.Label(root, text="0 mot(s)", anchor=tk.W)
        self.statut.pack(fill=tk.X)

    def ouvrir(self):
        p = filedialog.askopenfilename(filetypes=[("Texte", "*.txt")])
        if p:
            with open(p, "r", encoding="utf-8") as f:
                self.texte.delete(1.0, tk.END); self.texte.insert(tk.END, f.read())

    def sauvegarder(self):
        p = filedialog.asksaveasfilename(defaultextension=".txt")
        if p:
            with open(p, "w", encoding="utf-8") as f:
                f.write(self.texte.get(1.0, tk.END))

    def compter_mots(self, event=None):
        self.statut.config(text=f"{len(self.texte.get(1.0, tk.END).split())} mot(s)")

    def rechercher(self):
        w = tk.Toplevel()
        tk.Label(w, text="Rechercher :").grid(row=0, column=0)
        e_r = tk.Entry(w, width=30); e_r.grid(row=0, column=1)
        tk.Label(w, text="Remplacer :").grid(row=1, column=0)
        e_m = tk.Entry(w, width=30); e_m.grid(row=1, column=1)
        def remplacer():
            contenu = self.texte.get(1.0, tk.END)
            self.texte.delete(1.0, tk.END)
            self.texte.insert(tk.END, contenu.replace(e_r.get(), e_m.get()))
        tk.Button(w, text="Remplacer tout", command=remplacer).grid(row=2, columnspan=2)

fenetre = tk.Tk()
Editeur(fenetre)
fenetre.mainloop()

import sqlite3

conn = sqlite3.connect("bibliotheque.db")
c = conn.cursor()
c.execute("""CREATE TABLE IF NOT EXISTS livres (
    id         INTEGER PRIMARY KEY AUTOINCREMENT,
    titre      TEXT NOT NULL,
    auteur     TEXT NOT NULL,
    isbn       TEXT UNIQUE,
    disponible INTEGER DEFAULT 1
)""")
conn.commit()

def ajouter_livre(titre, auteur, isbn):
    c.execute("INSERT INTO livres (titre, auteur, isbn) VALUES (?, ?, ?)", (titre, auteur, isbn))
    conn.commit()
    print(f"Ajouté : {titre}")

def emprunter(livre_id):
    c.execute("UPDATE livres SET disponible = 0 WHERE id = ? AND disponible = 1", (livre_id,))
    if c.rowcount:
        conn.commit(); print(f"Livre {livre_id} emprunté.")
    else:
        print("Livre indisponible ou introuvable.")

def rechercher(terme):
    c.execute("SELECT * FROM livres WHERE titre LIKE ? OR auteur LIKE ?",
              (f"%{terme}%", f"%{terme}%"))
    for row in c.fetchall():
        dispo = "Disponible" if row[4] else "Emprunté"
        print(f"#{row[0]} - {row[1]} par {row[2]} [{dispo}]")

ajouter_livre("Python Crash Course", "Eric Matthes", "978-1-59327-928-5")
ajouter_livre("Automate the Boring Stuff", "Al Sweigart", "978-1-59327-599-8")
rechercher("python")

import requests
import pandas as pd
import time

def get_prix(symbole="BTCUSDT", intervalle="1h", limite=50):
    url    = "https://api.binance.com/api/v3/klines"
    params = {"symbol": symbole, "interval": intervalle, "limit": limite}
    data   = requests.get(url, params=params).json()
    df     = pd.DataFrame(data, columns=[
        "timestamp", "open", "high", "low", "close", "volume",
        "close_time", "qav", "num_trades", "tb_base", "tb_quote", "ignore"
    ])
    df["close"] = df["close"].astype(float)
    return df

def strategie_mm(df, courte=7, longue=21):
    df["mm_c"] = df["close"].rolling(courte).mean()
    df["mm_l"] = df["close"].rolling(longue).mean()
    d, a = df.iloc[-1], df.iloc[-2]
    if a["mm_c"] < a["mm_l"] and d["mm_c"] > d["mm_l"]: return "ACHAT"
    if a["mm_c"] > a["mm_l"] and d["mm_c"] < d["mm_l"]: return "VENTE"
    return "ATTENTE"

print("Bot trading simulation - BTC/USDT")
while True:
    df     = get_prix()
    signal = strategie_mm(df)
    prix   = df["close"].iloc[-1]
    print(f"Prix : {prix:.2f} $ | Signal : {signal}")
    time.sleep(60)