Python pour l'automatisation : 10 scripts qui changent tout

Tu passes encore 2 heures par jour à faire des trucs qu’un script Python ferait en 3 minutes ? Tu renommes des fichiers à la main, tu copies-colles des données d’un onglet à l’autre, tu envoies les mêmes rapports à la même équipe chaque lundi ? Stop. Tu es en 2026, et chaque heure perdue sur de la répétition pure est une heure que tes concurrents utilisent pour réfléchir, créer, vendre. Dans cet article, je te file 10 scripts Python que j’utilise quasi quotidiennement chez moi ou chez mes clients. Pas du code théorique, pas du “Hello World” à la noix. Du code production, prêt à copier-coller, qui fait gagner du temps réel. Tu n’as pas besoin d’être ingénieur pour les faire tourner : si tu sais installer Python et lancer une commande, tu sais tout faire.

Pourquoi Python plutôt que n8n ou Make pour certaines choses

Avant qu’on commence, mettons les choses au clair. Je suis un grand fan des outils no-code comme n8n et Make pour 80% des automatisations. Mais il reste 20% de cas où un script Python pur est tout simplement la meilleure option :

• Quand le volume est massif (>10 000 actions par heure) : Python tient la charge, les plateformes no-code rament
• Quand la logique est complexe : conditions imbriquées, parsing custom, transformations lourdes
• Quand tu manipules des fichiers locaux : un script s’exécute sur ton poste, pas besoin de monter un VPS
• Quand tu veux du contrôle absolu : pas de boîte noire, tu vois exactement ce qui se passe
• Quand tu veux gratuit : zéro coût de licence, ton CPU et ton temps suffisent

Pour comparer les options no-code entre elles, va lire mon comparatif n8n vs Make vs Zapier 2026. Mais pour les cas ci-dessous, Python est ton meilleur ami.

Script 1 : nettoyer et trier 10 000 fichiers en 5 minutes

Le cas typique : tu reçois un dossier de 10 000 photos ou documents nommés n’importe comment. Tu veux les renommer selon une convention et les trier en sous-dossiers par date.

from pathlib import Path
from datetime import datetime
import shutil

source = Path("./inbox")
target = Path("./trie")
target.mkdir(exist_ok=True)

for file in source.iterdir():
    if not file.is_file():
        continue
    mtime = datetime.fromtimestamp(file.stat().st_mtime)
    folder = target / mtime.strftime("%Y-%m")
    folder.mkdir(exist_ok=True)
    new_name = f"{mtime.strftime('%Y%m%d_%H%M%S')}_{file.name}"
    shutil.move(str(file), str(folder / new_name))
    print(f"Déplacé: {file.name} -> {folder.name}/{new_name}")

Tu lances python tri.py et en 30 secondes tes 10 000 fichiers sont organisés. Pour un photographe ou un documentaliste, c’est la fin d’une corvée mensuelle de 4-5 heures. Tu peux étendre avec OCR automatique, détection de doublons, ou hashing pour intégrité.

Script 2 : envoyer un rapport quotidien depuis tes données

Tu veux envoyer chaque matin à 8h un rapport synthétique avec les ventes de la veille, le top 3 produits, et un graphique. En 50 lignes de Python, c’est fait.

import pandas as pd
import smtplib
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from email.mime.image import MIMEImage
import matplotlib.pyplot as plt

# Lecture des données (depuis ton ERP, ta DB, ou un export)
df = pd.read_csv("ventes.csv")
df["date"] = pd.to_datetime(df["date"])
hier = df[df["date"].dt.date == pd.Timestamp.now().date()]

# Calculs
ca_total = hier["montant"].sum()
top_produits = hier.groupby("produit")["montant"].sum().nlargest(3)

# Génération du graphique
plt.figure(figsize=(8, 4))
top_produits.plot(kind="bar")
plt.title("Top 3 produits hier")
plt.tight_layout()
plt.savefig("top3.png")

# Email
msg = MIMEMultipart()
msg["Subject"] = f"Rapport ventes - {pd.Timestamp.now():%Y-%m-%d}"
msg["From"] = "bot@mondomaine.fr"
msg["To"] = "team@mondomaine.fr"

body = f"""<h2>Rapport quotidien</h2>
<p>CA hier: {ca_total:,.2f} euros</p>
<p>Voir graphique ci-dessous.</p>
<img src="cid:top3"/>"""
msg.attach(MIMEText(body, "html"))

with open("top3.png", "rb") as f:
    img = MIMEImage(f.read())
    img.add_header("Content-ID", "<top3>")
    msg.attach(img)

with smtplib.SMTP_SSL("smtp.gmail.com", 465) as srv:
    srv.login("bot@gmail.com", "MOT_DE_PASSE_APPLICATION")
    srv.send_message(msg)

Tu programmes ça dans un cron Linux ou Task Scheduler Windows à 8h chaque matin, et ton équipe reçoit son rapport avant son premier café. Économie : 15-30 minutes par jour pour celui qui faisait le rapport manuellement, soit 5-10 heures par mois.

Script 3 : scraper un site web et stocker les données

Tu veux suivre les prix d’un concurrent, les annonces immobilières d’un secteur, ou les avis d’un produit. Voici un scraper propre :

import requests
from bs4 import BeautifulSoup
import csv
from datetime import datetime
import time

URL = "https://www.example-shop.com/categorie/electronique"
HEADERS = {"User-Agent": "Mozilla/5.0 ..."}

response = requests.get(URL, headers=HEADERS)
soup = BeautifulSoup(response.content, "html.parser")

produits = []
for card in soup.select(".product-card"):
    nom = card.select_one(".name").text.strip()
    prix = card.select_one(".price").text.strip()
    dispo = "En stock" in card.text
    produits.append({
        "date": datetime.now().isoformat(),
        "nom": nom,
        "prix": prix,
        "en_stock": dispo
    })

with open("scraping.csv", "a", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=produits[0].keys())
    if f.tell() == 0:
        writer.writeheader()
    writer.writerows(produits)

print(f"Scrapé: {len(produits)} produits")

Tu lances ça toutes les heures via un cron, et tu construis un historique de prix en quelques jours. Avec ces données, tu peux faire des alertes de baisse de prix, des analyses concurrentielles, ou nourrir un dashboard.

Attention au scraping : respecte les robots.txt, n’envoie pas des centaines de requêtes par seconde, et n’utilise pas les données scrapées de manière à enfreindre les conditions d’utilisation. Si tu veux faire ça à grande échelle, passe par des services pros comme Bright Data ou Apify.

Script 4 : convertir tous tes PDF en texte recherchable

Tu as un dossier de 500 PDF scannés que tu ne peux pas chercher dedans ? Avec pytesseract et pdf2image, tu rends tout le corpus full-text searchable en quelques minutes.

from pdf2image import convert_from_path
import pytesseract
from pathlib import Path

source = Path("./pdfs_scannes")
target = Path("./textes_extraits")
target.mkdir(exist_ok=True)

for pdf_path in source.glob("*.pdf"):
    print(f"Traitement: {pdf_path.name}")
    images = convert_from_path(str(pdf_path), dpi=200)
    full_text = ""
    for i, img in enumerate(images):
        text = pytesseract.image_to_string(img, lang="fra")
        full_text += f"\n\n--- Page {i+1} ---\n\n{text}"
    
    output = target / (pdf_path.stem + ".txt")
    output.write_text(full_text, encoding="utf-8")

Tu peux ensuite indexer ces textes avec Elasticsearch, Whoosh, ou même un simple grep sur le dossier. Pour des cabinets juridiques, comptables ou des archivistes, c’est un changement de paradigme : on passe d’une recherche manuelle de 1h à une recherche de 2 secondes.

Si tu veux pousser plus loin avec une approche IA, lis aussi mon article sur Anthropic Files API qui combine OCR et compréhension sémantique.

Script 5 : monitor un site web et alerter en cas de panne

Ton site est-il vraiment online en permanence ? Tes services tournent-ils ? Voici un health check tout simple avec alerte Slack :

import requests
import time

SITES = [
    "https://workflowpro.fr",
    "https://api.monservice.fr/health",
    "https://admin.monservice.fr/login"
]
SLACK_WEBHOOK = "https://hooks.slack.com/services/XXX/YYY/ZZZ"

def check(url):
    try:
        r = requests.get(url, timeout=10)
        return r.status_code, r.elapsed.total_seconds()
    except Exception as e:
        return None, str(e)

def alert(message):
    requests.post(SLACK_WEBHOOK, json={"text": f"ALERTE: {message}"})

for site in SITES:
    status, info = check(site)
    if status is None or status >= 400:
        alert(f"{site} renvoie {status} ({info})")
    elif info > 3:
        alert(f"{site} répond lentement: {info:.2f}s")
    else:
        print(f"OK: {site} ({status}, {info:.2f}s)")

Tu lances ça toutes les 2 minutes en cron, et tu es alerté avant tes utilisateurs en cas de problème. Pour des sites critiques, c’est un must. Tu peux étendre avec des checks plus profonds : vérifier qu’une page contient un mot précis, qu’une API renvoie un JSON valide, qu’une base de données répond.

Script 6 : nettoyer ta boîte mail Gmail automatiquement

Tu as 25 000 mails dans ta boîte ? Voici un script qui archive ou supprime selon des règles métier :

from imap_tools import MailBox, AND
from datetime import datetime, timedelta

EMAIL = "moi@gmail.com"
PASSWORD = "MOT_DE_PASSE_APPLICATION"

with MailBox("imap.gmail.com").login(EMAIL, PASSWORD, "INBOX") as mailbox:
    # Archiver les newsletters de plus de 30 jours
    limite = datetime.now() - timedelta(days=30)
    for mail in mailbox.fetch(AND(date_lt=limite.date())):
        if "unsubscribe" in mail.text.lower():
            mailbox.move(mail.uid, "Archives/Newsletters")
            print(f"Archivé: {mail.subject}")
    
    # Supprimer les notifs GitHub anciennes (>7 jours)
    limite_courte = datetime.now() - timedelta(days=7)
    for mail in mailbox.fetch(AND(from_="notifications@github.com", date_lt=limite_courte.date())):
        mailbox.delete(mail.uid)

Tu lances ça une fois par semaine, et ta boîte reste propre toute seule. Tu peux affiner avec des règles métier : factures rangées dans un dossier dédié, tickets clients flagués, etc. C’est mieux que les filtres natifs Gmail parce que tu peux mettre toute la logique que tu veux.

Script 7 : générer des rapports Word/PDF programmatiquement

Tu envoies chaque mois un rapport client en Word ou PDF ? Génère-le automatiquement avec python-docx ou WeasyPrint.

from docx import Document
from datetime import datetime

doc = Document("template.docx")  # Ton template avec placeholders

# Remplacer les placeholders
data = {
    "{CLIENT}": "Société Dupont",
    "{MOIS}": "Avril 2026",
    "{CA}": "47 250 euros",
    "{COMMANDES}": "238"
}

for paragraph in doc.paragraphs:
    for key, value in data.items():
        if key in paragraph.text:
            for run in paragraph.runs:
                if key in run.text:
                    run.text = run.text.replace(key, value)

# Tableau de produits dynamique
table = doc.tables[0]
produits = [("Produit A", 120, 14400), ("Produit B", 85, 10200)]
for nom, qte, montant in produits:
    row = table.add_row().cells
    row[0].text = nom
    row[1].text = str(qte)
    row[2].text = f"{montant} euros"

doc.save(f"rapport_{datetime.now():%Y%m}.docx")

Tu génères 100 rapports clients personnalisés en 30 secondes là où ton équipe passait 3 jours. C’est un classique chez mes clients agences ou cabinets : on remplace 2 jours de travail mensuel par un cron Python.

Script 8 : synchroniser deux Google Sheets ou Airtable

Tu as deux outils qui doivent rester en phase ? Pas besoin de Zapier à 30 dollars par mois, fais-le toi-même :

import gspread
from oauth2client.service_account import ServiceAccountCredentials
import requests

# Auth Google Sheets
scope = ["https://spreadsheets.google.com/feeds", "https://www.googleapis.com/auth/drive"]
creds = ServiceAccountCredentials.from_json_keyfile_name("creds.json", scope)
client = gspread.authorize(creds)

sheet = client.open("Master CRM").sheet1
records = sheet.get_all_records()

# Push vers Airtable
AIRTABLE_API = "patXXX"
AIRTABLE_BASE = "appXXX"
AIRTABLE_TABLE = "Leads"

for record in records:
    payload = {"fields": record}
    requests.post(
        f"https://api.airtable.com/v0/{AIRTABLE_BASE}/{AIRTABLE_TABLE}",
        headers={"Authorization": f"Bearer {AIRTABLE_API}", "Content-Type": "application/json"},
        json=payload
    )

print(f"Synchronisé: {len(records)} records")

Tu lances ça toutes les heures, et tes outils sont en phase. À grande échelle, on enrichit avec de la détection de changements (delta sync) pour ne pas écraser les modifications locales.

Script 9 : assistant Slack qui répond depuis ta doc

Combiner Python + API Anthropic + Slack, ça donne un assistant interne ultra rapide à déployer.

from slack_sdk import WebClient
from slack_sdk.errors import SlackApiError
import anthropic
import os

slack = WebClient(token=os.environ["SLACK_TOKEN"])
claude = anthropic.Anthropic()

# Charge ta doc interne (concat de fichiers Markdown par exemple)
with open("docs_internes.md") as f:
    KNOWLEDGE_BASE = f.read()

def respond_to_mention(question, channel, thread_ts):
    response = claude.messages.create(
        model="claude-sonnet-4-7",
        max_tokens=1500,
        system=f"Tu es l'assistant interne de notre société. Réponds en te basant sur cette doc:\n\n{KNOWLEDGE_BASE}",
        messages=[{"role": "user", "content": question}]
    )
    answer = response.content[0].text
    slack.chat_postMessage(channel=channel, text=answer, thread_ts=thread_ts)

# Écoute des mentions (avec Socket Mode ou Events API)
# ... boucle d'écoute Slack ...

Tes équipes peuvent poser des questions sur ton onboarding, tes process, ta doc tech depuis Slack et recevoir une réponse en 2 secondes. C’est un cas d’usage à fort impact perçu par les équipes : tout le monde adore. Et le coût mensuel : 10-30 dollars d’API Claude pour une équipe de 50 personnes.

Si tu veux pousser ce genre d’agent avec accès web, lis aussi mon article Web Search Anthropic.

Script 10 : générer des images en masse avec une API

Tu as 200 produits sans visuel et tu veux générer des images d’illustration ? OpenAI DALL-E ou Replicate Flux te permettent de tout faire en script :

import requests
import os
import time

OPENAI_KEY = os.environ["OPENAI_KEY"]

produits = [
    "Cafetière inox 12 tasses",
    "Casque audio sans fil Bluetooth",
    "Sac à dos pour ordinateur 15 pouces",
    # ... 200 lignes
]

for i, produit in enumerate(produits):
    prompt = f"Photo studio professionnelle de {produit}, fond blanc, éclairage doux, haute qualité"
    response = requests.post(
        "https://api.openai.com/v1/images/generations",
        headers={"Authorization": f"Bearer {OPENAI_KEY}"},
        json={"model": "dall-e-3", "prompt": prompt, "size": "1024x1024", "n": 1}
    )
    img_url = response.json()["data"][0]["url"]
    img_data = requests.get(img_url).content
    with open(f"produits/{i:03d}_{produit[:20]}.png", "wb") as f:
        f.write(img_data)
    print(f"Généré: {produit}")
    time.sleep(2)  # Respect du rate limiting

Tu pars te chercher un café, et 30 minutes plus tard tu as 200 visuels produits prêts pour ton catalogue. Coût total : environ 8 dollars d’API. Compare avec un photographe (200 produits × 30 euros = 6000 euros), tu vois la différence.

Bonus : packaging et déploiement de tes scripts

Tes scripts sont sympas, mais s’ils ne tournent que sur ton laptop, ils ne servent que toi. Voici comment passer en production :

Option 1 : cron sur ton serveur. Tu loues un VPS à 5 euros par mois (Hetzner, OVH, Scaleway), tu installes Python, tu déploies tes scripts, et tu mets en place des crons. C’est solide et pas cher.

Option 2 : GitHub Actions. Pour des scripts qui tournent peu (1 fois par jour ou moins), tu peux utiliser GitHub Actions comme cron gratuit. Tu pushes ton code, tu mets un workflow .github/workflows/cron.yml, et tu as un runner gratuit qui exécute ton script.

Option 3 : Docker + Kubernetes. Pour des setups industriels avec haute dispo et orchestration. C’est overkill pour de petits scripts, mais utile quand tu as 50 scripts différents à monitorer.

Option 4 : Cloud Functions ou Lambdas. Pour des scripts événementiels (déclenchés par un webhook par exemple). Tu paies à la requête, sans serveur à maintenir.

Pour la majorité de mes clients, l’option 1 (VPS + cron) reste la plus simple et la plus rentable. Je détaille la mise en place dans mon guide self-hoster n8n sur un VPS qui couvre les mêmes principes appliqués à n8n.

Comment apprendre à coder en Python si tu n’as jamais touché

Si tu as lu jusqu’ici et que tu te dis “ça a l’air cool mais je ne sais pas coder”, voici la roadmap que je recommande :

1. Installer Python depuis python.org (Windows) ou via brew (Mac)
2. Installer VS Code comme éditeur, avec l’extension Python
3. Faire 5-10 heures de tuto : Automate the Boring Stuff with Python est gratuit en ligne et excellent
4. Copier-coller un script de cet article et le faire tourner
5. Modifier le script pour ton cas précis
6. Itérer : tu apprendras 80% du Python utile en 20 heures pratiquées

Le seuil d’entrée est bien plus bas qu’il y a 10 ans. Avec Claude ou GitHub Copilot, tu peux générer du Python correct même sans le maîtriser parfaitement. L’IA agit comme un mentor disponible 24/7.

L’erreur que je vois trop souvent

L’erreur classique : on automatise des tâches qu’on devrait simplement supprimer. Avant d’écrire un script, demande-toi : est-ce que cette tâche a vraiment besoin d’exister ? Souvent, 30% des “automatisations” qu’on me demande sont en réalité des process à supprimer.

L’autre erreur : on automatise un process cassé. Un mauvais process automatisé reste un mauvais process, juste plus rapide. Avant de scripter, prends 30 minutes pour challenger le process lui-même. Tu gagneras parfois plus en simplifiant qu’en automatisant.

Conclusion : Python, le couteau suisse de la productivité

Python n’est pas qu’un langage de programmation. C’est un multiplicateur de productivité personnelle et d’équipe. 10 scripts bien choisis peuvent te faire gagner 2 jours par semaine pendant des années. Avec un investissement initial de 20-50 heures d’apprentissage.

Si tu n’as pas le temps ou l’envie d’apprendre, c’est exactement le genre de projets que je livre chez Workflowpro. Mon offre workflow simple couvre les automatisations d’1 à 3 jours. Pour des besoins plus complexes (intégration multi-systèmes, IA, monitoring), regarde workflow avancé ou architecture complète.

Le plus important : commence aujourd’hui. Prends un script de cet article, fais-le tourner sur ta machine, modifie-le pour ton cas. Une heure de pratique vaut 10 heures de lecture. L’automatisation, c’est comme la course à pied : la seule difficulté, c’est de mettre ses baskets.

Pour aller plus loin, lis aussi mon comparatif n8n vs Make vs Zapier si tu te demandes quand utiliser du Python pur vs une plateforme no-code.