L'automatisation est l'un des domaines où Python excelle le plus. Grâce à sa simplicité et à ses nombreuses bibliothèques, Python permet d'automatiser une multitude de tâches répétitives, vous faisant gagner un temps précieux et réduisant les erreurs humaines. Découvrez comment transformer votre productivité avec l'automatisation Python.
Pourquoi Automatiser avec Python ?
Python offre des avantages uniques pour l'automatisation :
- Simplicité de code : Syntaxe claire qui permet de créer rapidement des scripts
- Bibliothèques riches : Outils spécialisés pour chaque type d'automatisation
- Multi-plateforme : Fonctionne sur Windows, macOS et Linux
- Intégration facile : Se connecte facilement à d'autres outils et services
- Communauté active : Solutions disponibles pour presque tous les cas d'usage
Automatisation des Fichiers et Dossiers
Commençons par les tâches de gestion de fichiers, souvent chronophages au quotidien :
Organisation Automatique de Fichiers
import os
import shutil
from pathlib import Path
def organiser_fichiers(dossier_source):
"""Organise les fichiers par extension dans des sous-dossiers"""
# Définition des catégories par extension
categories = {
'images': ['.jpg', '.jpeg', '.png', '.gif', '.bmp', '.svg'],
'documents': ['.pdf', '.doc', '.docx', '.txt', '.rtf'],
'feuilles_calcul': ['.xls', '.xlsx', '.csv'],
'videos': ['.mp4', '.avi', '.mkv', '.mov', '.wmv'],
'audio': ['.mp3', '.wav', '.flac', '.m4a'],
'archives': ['.zip', '.rar', '.7z', '.tar', '.gz']
}
dossier = Path(dossier_source)
for fichier in dossier.iterdir():
if fichier.is_file():
extension = fichier.suffix.lower()
# Trouver la catégorie du fichier
categorie_trouvee = None
for categorie, extensions in categories.items():
if extension in extensions:
categorie_trouvee = categorie
break
if categorie_trouvee:
# Créer le dossier de destination s'il n'existe pas
dossier_dest = dossier / categorie_trouvee
dossier_dest.mkdir(exist_ok=True)
# Déplacer le fichier
nouveau_chemin = dossier_dest / fichier.name
# Gérer les doublons
compteur = 1
while nouveau_chemin.exists():
nom_base = fichier.stem
nouveau_chemin = dossier_dest / f"{nom_base}_{compteur}{extension}"
compteur += 1
shutil.move(str(fichier), str(nouveau_chemin))
print(f"Fichier déplacé : {fichier.name} → {categorie_trouvee}/")
# Utilisation
organiser_fichiers("/path/to/downloads")Nettoyage Automatique de Fichiers Temporaires
import os
import time
from datetime import datetime, timedelta
def nettoyer_fichiers_anciens(dossier, jours_limite=30, extensions_ciblees=None):
"""Supprime les fichiers plus anciens que la limite spécifiée"""
if extensions_ciblees is None:
extensions_ciblees = ['.tmp', '.log', '.cache', '.old']
limite_temps = time.time() - (jours_limite * 24 * 60 * 60)
fichiers_supprimes = 0
espace_libere = 0
for racine, dossiers, fichiers in os.walk(dossier):
for fichier in fichiers:
chemin_fichier = os.path.join(racine, fichier)
# Vérifier l'extension
_, extension = os.path.splitext(fichier)
if extension.lower() in extensions_ciblees:
# Vérifier l'âge du fichier
if os.path.getmtime(chemin_fichier) < limite_temps:
try:
taille = os.path.getsize(chemin_fichier)
os.remove(chemin_fichier)
fichiers_supprimes += 1
espace_libere += taille
print(f"Supprimé : {chemin_fichier}")
except OSError as e:
print(f"Erreur lors de la suppression de {chemin_fichier}: {e}")
print(f"\nNettoyage terminé :")
print(f"Fichiers supprimés : {fichiers_supprimes}")
print(f"Espace libéré : {espace_libere / (1024*1024):.2f} MB")
# Planification avec schedule
import schedule
def job_nettoyage():
nettoyer_fichiers_anciens("/tmp", jours_limite=7)
nettoyer_fichiers_anciens("/var/log", jours_limite=30, extensions_ciblees=['.log'])
# Programmer le nettoyage chaque dimanche à 2h du matin
schedule.every().sunday.at("02:00").do(job_nettoyage)Web Scraping et Extraction de Données
Automatisez la collecte d'informations depuis le web :
Extraction de Prix de Produits
import requests
from bs4 import BeautifulSoup
import csv
from datetime import datetime
import time
class SurveilleursePrix:
def __init__(self):
self.session = requests.Session()
self.session.headers.update({
'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
})
def extraire_prix_amazon(self, url_produit):
"""Extrait le prix d'un produit Amazon"""
try:
response = self.session.get(url_produit)
soup = BeautifulSoup(response.content, 'html.parser')
# Sélecteurs pour différents formats de prix Amazon
selecteurs_prix = [
'.a-price-whole',
'.a-offscreen',
'#priceblock_dealprice',
'#priceblock_ourprice'
]
for selecteur in selecteurs_prix:
element_prix = soup.select_one(selecteur)
if element_prix:
prix_text = element_prix.get_text().strip()
# Nettoyer et extraire le nombre
prix = ''.join(c for c in prix_text if c.isdigit() or c == '.')
return float(prix) if prix else None
return None
except Exception as e:
print(f"Erreur lors de l'extraction du prix : {e}")
return None
def surveiller_produits(self, liste_produits, fichier_sortie='prix_surveillance.csv'):
"""Surveille une liste de produits et enregistre les prix"""
with open(fichier_sortie, 'a', newline='', encoding='utf-8') as csvfile:
writer = csv.writer(csvfile)
# En-têtes si le fichier est vide
if csvfile.tell() == 0:
writer.writerow(['Date', 'Produit', 'URL', 'Prix', 'Devise'])
for produit in liste_produits:
nom = produit['nom']
url = produit['url']
print(f"Vérification du prix pour : {nom}")
prix = self.extraire_prix_amazon(url)
if prix:
writer.writerow([
datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
nom,
url,
prix,
'EUR'
])
print(f"Prix trouvé : {prix}€")
else:
print("Prix non trouvé")
# Pause pour éviter le blocage
time.sleep(2)
# Utilisation
surveilleur = SurveilleursePrix()
produits_a_surveiller = [
{
'nom': 'Ordinateur Portable Dell XPS 13',
'url': 'https://amazon.fr/dp/EXAMPLE123'
},
{
'nom': 'iPhone 14 Pro',
'url': 'https://amazon.fr/dp/EXAMPLE456'
}
]
surveilleur.surveiller_produits(produits_a_surveiller)Automatisation des Réseaux Sociaux
# Exemple avec l'API Twitter (nécessite tweepy)
import tweepy
import schedule
import random
class GestionnaireTwitter:
def __init__(self, api_key, api_secret, access_token, access_token_secret):
auth = tweepy.OAuthHandler(api_key, api_secret)
auth.set_access_token(access_token, access_token_secret)
self.api = tweepy.API(auth)
def publier_tweet_programme(self, messages):
"""Publie des tweets programmés"""
message = random.choice(messages)
try:
self.api.update_status(message)
print(f"Tweet publié : {message[:50]}...")
except Exception as e:
print(f"Erreur lors de la publication : {e}")
def surveiller_mentions(self, mots_cles):
"""Surveille les mentions et répond automatiquement"""
for mention in tweepy.Cursor(self.api.search_tweets,
q=' OR '.join(mots_cles),
result_type='recent').items(10):
if not mention.favorited:
# Liker le tweet
mention.favorite()
# Répondre si approprié
if 'question' in mention.text.lower():
reponse = f"@{mention.user.screen_name} Merci pour votre question ! Notre équipe vous répondra bientôt."
self.api.update_status(reponse, in_reply_to_status_id=mention.id)
# Configuration et planification
messages_marketing = [
"🐍 Découvrez Python avec nos formations expertes ! #Python #Formation",
"💡 Astuce Python du jour : Utilisez les list comprehensions pour un code plus lisible !",
"🚀 La data science vous intéresse ? Python est votre meilleur allié ! #DataScience"
]
# twitter_bot = GestionnaireTwitter(api_key, api_secret, access_token, access_token_secret)
# schedule.every().day.at("09:00").do(twitter_bot.publier_tweet_programme, messages_marketing)Automatisation de Rapports et Emails
Générez et envoyez automatiquement des rapports :
import smtplib
from email.mime.multipart import MIMEMultipart
from email.mime.text import MIMEText
from email.mime.base import MIMEBase
from email import encoders
import pandas as pd
import matplotlib.pyplot as plt
from datetime import datetime
class GenerateurRapports:
def __init__(self, smtp_server, smtp_port, email, password):
self.smtp_server = smtp_server
self.smtp_port = smtp_port
self.email = email
self.password = password
def generer_rapport_ventes(self, donnees_ventes):
"""Génère un rapport de ventes avec graphiques"""
# Analyse des données
df = pd.DataFrame(donnees_ventes)
total_ventes = df['montant'].sum()
ventes_par_produit = df.groupby('produit')['montant'].sum()
# Création du graphique
plt.figure(figsize=(10, 6))
ventes_par_produit.plot(kind='bar')
plt.title('Ventes par Produit')
plt.ylabel('Montant (€)')
plt.xticks(rotation=45)
plt.tight_layout()
plt.savefig('rapport_ventes.png')
plt.close()
# Génération du rapport HTML
html_rapport = f"""
Rapport de Ventes - {datetime.now().strftime('%B %Y')}
Résumé
- Ventes totales : {total_ventes:,.2f}€
- Nombre de transactions : {len(df)}
- Panier moyen : {df['montant'].mean():.2f}€
Top 5 des Produits
Produit Ventes (€) {produit} {montant:,.2f}€
Voir le graphique en pièce jointe.
"""
return html_rapport
def envoyer_rapport(self, destinataires, sujet, contenu_html, pieces_jointes=None):
"""Envoie le rapport par email"""
msg = MIMEMultipart()
msg['From'] = self.email
msg['To'] = ', '.join(destinataires)
msg['Subject'] = sujet
# Ajouter le contenu HTML
msg.attach(MIMEText(contenu_html, 'html'))
# Ajouter les pièces jointes
if pieces_jointes:
for fichier in pieces_jointes:
with open(fichier, "rb") as attachment:
part = MIMEBase('application', 'octet-stream')
part.set_payload(attachment.read())
encoders.encode_base64(part)
part.add_header(
'Content-Disposition',
f'attachment; filename= {fichier}',
)
msg.attach(part)
# Envoi de l'email
try:
server = smtplib.SMTP(self.smtp_server, self.smtp_port)
server.starttls()
server.login(self.email, self.password)
text = msg.as_string()
server.sendmail(self.email, destinataires, text)
server.quit()
print("Rapport envoyé avec succès !")
except Exception as e:
print(f"Erreur lors de l'envoi : {e}")
# Données d'exemple
donnees_ventes = [
{'produit': 'Formation Python', 'montant': 299.00, 'date': '2025-01-01'},
{'produit': 'Formation Data Science', 'montant': 399.00, 'date': '2025-01-02'},
{'produit': 'Formation Django', 'montant': 349.00, 'date': '2025-01-03'},
]
# Utilisation
generateur = GenerateurRapports('smtp.gmail.com', 587, '[email protected]', 'votre_mot_de_passe')
rapport_html = generateur.generer_rapport_ventes(donnees_ventes)
generateur.envoyer_rapport(
['[email protected]'],
'Rapport de Ventes Mensuel',
rapport_html,
['rapport_ventes.png']
)Automatisation avec APIs et Services Web
Synchronisation avec Google Sheets
import gspread
from oauth2client.service_account import ServiceAccountCredentials
import pandas as pd
class SyncGoogleSheets:
def __init__(self, chemin_credentials):
scope = ['https://spreadsheets.google.com/feeds',
'https://www.googleapis.com/auth/drive']
creds = ServiceAccountCredentials.from_json_keyfile_name(chemin_credentials, scope)
self.client = gspread.authorize(creds)
def importer_donnees(self, nom_sheet, nom_feuille='Sheet1'):
"""Importe des données depuis Google Sheets"""
sheet = self.client.open(nom_sheet).worksheet(nom_feuille)
donnees = sheet.get_all_records()
return pd.DataFrame(donnees)
def exporter_donnees(self, df, nom_sheet, nom_feuille='Sheet1'):
"""Exporte des données vers Google Sheets"""
sheet = self.client.open(nom_sheet).worksheet(nom_feuille)
# Vider la feuille
sheet.clear()
# Ajouter les en-têtes
sheet.append_row(df.columns.tolist())
# Ajouter les données
for index, row in df.iterrows():
sheet.append_row(row.tolist())
def mettre_a_jour_automatique(self, source_csv, nom_sheet):
"""Met à jour automatiquement Google Sheets depuis un CSV"""
df = pd.read_csv(source_csv)
self.exporter_donnees(df, nom_sheet)
print(f"Google Sheets '{nom_sheet}' mis à jour avec {len(df)} lignes")
# Utilisation
# sync = SyncGoogleSheets('path/to/credentials.json')
# sync.mettre_a_jour_automatique('ventes_du_jour.csv', 'Rapport Ventes')Planification et Monitoring
Système de Planification Avancé
import schedule
import logging
from datetime import datetime
import functools
# Configuration du logging
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s - %(levelname)s - %(message)s',
handlers=[
logging.FileHandler('automation.log'),
logging.StreamHandler()
]
)
def log_execution(func):
"""Décorateur pour logger l'exécution des tâches"""
@functools.wraps(func)
def wrapper(*args, **kwargs):
start_time = datetime.now()
logging.info(f"Début de {func.__name__}")
try:
result = func(*args, **kwargs)
duration = datetime.now() - start_time
logging.info(f"{func.__name__} terminé en {duration.total_seconds():.2f}s")
return result
except Exception as e:
logging.error(f"Erreur dans {func.__name__}: {e}")
raise
return wrapper
class PlanificateurTaches:
def __init__(self):
self.taches = []
@log_execution
def sauvegarde_base_donnees(self):
"""Sauvegarde automatique de la base de données"""
import subprocess
import os
timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
nom_sauvegarde = f"backup_{timestamp}.sql"
# Commande de sauvegarde (exemple PostgreSQL)
commande = f"pg_dump -h localhost -U username database_name > {nom_sauvegarde}"
try:
subprocess.run(commande, shell=True, check=True)
logging.info(f"Sauvegarde créée : {nom_sauvegarde}")
# Nettoyer les anciennes sauvegardes (garder les 7 dernières)
sauvegardes = sorted([f for f in os.listdir('.') if f.startswith('backup_')])
for ancienne in sauvegardes[:-7]:
os.remove(ancienne)
logging.info(f"Ancienne sauvegarde supprimée : {ancienne}")
except subprocess.CalledProcessError as e:
logging.error(f"Erreur lors de la sauvegarde : {e}")
@log_execution
def verification_systeme(self):
"""Vérification de l'état du système"""
import psutil
# Vérifier l'utilisation CPU
cpu_usage = psutil.cpu_percent(interval=1)
if cpu_usage > 80:
logging.warning(f"Utilisation CPU élevée : {cpu_usage}%")
# Vérifier l'utilisation mémoire
memory = psutil.virtual_memory()
if memory.percent > 85:
logging.warning(f"Utilisation mémoire élevée : {memory.percent}%")
# Vérifier l'espace disque
disk = psutil.disk_usage('/')
if disk.percent > 90:
logging.warning(f"Espace disque faible : {disk.percent}%")
logging.info("Vérification système terminée")
def programmer_taches(self):
"""Programme toutes les tâches automatiques"""
# Sauvegardes quotidiennes à 2h du matin
schedule.every().day.at("02:00").do(self.sauvegarde_base_donnees)
# Vérification système toutes les heures
schedule.every().hour.do(self.verification_systeme)
# Nettoyage de fichiers chaque dimanche
schedule.every().sunday.at("01:00").do(nettoyer_fichiers_anciens, "/tmp")
# Rapport de ventes chaque lundi
schedule.every().monday.at("08:00").do(self.generer_rapport_hebdomadaire)
logging.info("Toutes les tâches ont été programmées")
def executer_planificateur(self):
"""Exécute le planificateur en continu"""
self.programmer_taches()
logging.info("Planificateur démarré")
while True:
schedule.run_pending()
time.sleep(60) # Vérifier chaque minute
# Utilisation
if __name__ == "__main__":
planificateur = PlanificateurTaches()
planificateur.executer_planificateur()Bonnes Pratiques d'Automatisation
- Gestion des erreurs : Toujours prévoir des try/except et des logs détaillés
- Configuration externe : Utilisez des fichiers de configuration pour les paramètres
- Tests réguliers : Testez vos scripts d'automatisation régulièrement
- Monitoring : Surveillez l'exécution et les performances de vos scripts
- Sécurité : Protégez les credentials et utilisez des environnements sécurisés
- Documentation : Documentez vos scripts pour faciliter la maintenance
Outils Complémentaires
Pour enrichir vos capacités d'automatisation :
- Selenium : Automatisation des navigateurs web
- Celery : Traitement asynchrone de tâches
- Apache Airflow : Orchestration de workflows complexes
- Docker : Conteneurisation de vos scripts
- GitHub Actions : Automatisation CI/CD
Conclusion
L'automatisation avec Python ouvre un monde de possibilités pour optimiser votre productivité. Que ce soit pour la gestion de fichiers, l'extraction de données, la génération de rapports ou la surveillance système, Python offre les outils nécessaires pour automatiser pratiquement n'importe quelle tâche répétitive.
Commencez petit avec des scripts simples, puis développez progressivement des systèmes d'automatisation plus sophistiqués. L'investissement en temps pour créer ces automatisations sera rapidement rentabilisé par les heures économisées et la réduction des erreurs.
Automatisez Votre Travail Efficacement
Apprenez à créer des solutions d'automatisation sur mesure avec notre formation spécialisée. Nos experts vous guideront dans la création de scripts pratiques adaptés à vos besoins professionnels.
Découvrir la Formation