21 Scripts Python Simples Qui Automatiseront Vos Tâches Quotidiennes

En tant que personne ayant passé plus d’une décennie dans le monde de la programmation, j’ai appris que l’automatisation des tâches répétitives peut faire gagner un temps et un effort considérables.

Python, avec sa syntaxe simple et ses bibliothèques puissantes, est l’un des meilleurs langages de programmation pour créer des scripts d’automatisation. Que vous soyez un programmeur ou une personne cherchant à faciliter les tâches quotidiennes, Python dispose d’outils qui peuvent vous aider.

Dans cet article, je vais partager 21 scripts Python que j’ai utilisés pour automatiser diverses tâches. Ces scripts sont parfaits pour quiconque souhaite gagner du temps et améliorer l’efficacité de sa routine de travail.

1. Renommer des fichiers en masse

Renommer des fichiers un par un peut être une tâche chronophage, mais avec Python, vous pouvez facilement automatiser cela en utilisant le module os.

Voici un script simple qui renomme plusieurs fichiers dans un dossier en fonction d’un modèle donné :

import os

def bulk_rename(folder_path, old_name_part, new_name_part):
    for filename in os.listdir(folder_path):
        if old_name_part in filename:
            new_filename = filename.replace(old_name_part, new_name_part)
            os.rename(os.path.join(folder_path, filename), os.path.join(folder_path, new_filename))
            print(f"Renamed {filename} to {new_filename}")

folder = '/path/to/your/folder' bulk_rename(folder, 'old_part', 'new_part')

Ce script recherche les fichiers contenant old_name_part dans leurs noms et le remplace par new_name_part.

2. Sauvegarde automatique des fichiers

Nous savons tous à quel point il est important de sauvegarder régulièrement des fichiers, et cette tâche peut être facilement automatisée en utilisant le module shutil de Python.

Ce script copiera tous les fichiers d’un répertoire à un autre à des fins de sauvegarde :

import shutil
import os

def backup_files(src_dir, dest_dir):
    if not os.path.exists(dest_dir):
        os.makedirs(dest_dir)
    for file in os.listdir(src_dir):
        full_file_name = os.path.join(src_dir, file)
        if os.path.isfile(full_file_name):
            shutil.copy(full_file_name, dest_dir)
            print(f"Backed up {file} to {dest_dir}")

source = '/path/to/source/directory' destination = '/path/to/destination/directory' backup_files(source, destination)

Vous pouvez programmer ce script pour qu’il s’exécute quotidiennement en utilisant des outils de planification de tâches comme cron (Linux) ou Planificateur de tâches (Windows).

3. Téléchargement de fichiers depuis Internet

Si vous téléchargez fréquemment des fichiers depuis Internet, vous pouvez automatiser cette tâche en utilisant la bibliothèque aiohttp.

Voici un script simple pour télécharger des fichiers à partir d’URL :

import aiohttp
import asyncio
import aiofiles

async def download_file(url, filename):
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            async with aiofiles.open(filename, 'wb') as file:
                await file.write(await response.read())
            print(f"Downloaded {filename}")

urls = {
    'https://example.com/file1.zip': 'file1.zip',
    'https://example.com/file2.zip': 'file2.zip'
}

async def download_all():
    tasks = [download_file(url, filename) for url, filename in urls.items()]
    await asyncio.gather(*tasks)

asyncio.run(download_all())

Ce script télécharge le fichier à partir de l’URL spécifiée et l’enregistre dans le dossier que vous avez spécifié.

4. Automatisation des rapports par email

Si vous devez envoyer des rapports par email régulièrement, vous pouvez l’automatiser en utilisant la bibliothèque smtplib, qui vous permet d’envoyer des emails facilement depuis un compte Gmail :

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

def send_email(subject, body, to_email):
    sender_email = '[email protected]'
    sender_password = 'yourpassword'
    receiver_email = to_email

    msg = MIMEMultipart()
    msg['From'] = sender_email
    msg['To'] = receiver_email
    msg['Subject'] = subject
    msg.attach(MIMEText(body, 'plain'))

    try:
        server = smtplib.SMTP('smtp.gmail.com', 587)
        server.starttls()
        server.login(sender_email, sender_password)
        server.sendmail(sender_email, receiver_email, msg.as_string())
        server.quit()
        print("Email sent successfully!")
    except Exception as e:
        print(f"Failed to send email: {e}")

subject = 'Monthly Report'
body = 'Here is the monthly report.'
send_email(subject, body, '[email protected]')

Ce script enverra un email simple avec un objet et un corps à un destinataire spécifié. Assurez-vous d’activer les applications moins sécurisées dans Gmail si vous utilisez cette méthode.

5. Planificateur de tâches (Automatisation des tâches)

La planification des tâches peut être effectuée facilement en utilisant la bibliothèque schedule, qui vous permet d’automatiser des tâches comme l’envoi d’un email ou l’exécution d’un script de sauvegarde à des moments spécifiques :

import schedule
import time

def job():
    print("Running scheduled task!")

# Schedule the task to run every day at 10:00 AM
schedule.every().day.at("10:00").do(job)

while True:
    schedule.run_pending()
    time.sleep(1)

Ce script continuera à s’exécuter et déclenchera des tâches à l’heure spécifiée, dans ce cas, 10h00 chaque jour.

6. Collecte de données par web scraping

Utiliser aiohttp pour des requêtes HTTP asynchrones au lieu de la bibliothèque synchrone requests peut rendre le web scraping plus efficace.

Cet exemple récupère plusieurs pages en parallèle.

import aiohttp
import asyncio
from bs4 import BeautifulSoup

async def fetch(session, url):
    async with session.get(url) as response:
        return await response.text()

async def scrape(urls):
    async with aiohttp.ClientSession() as session:
        tasks = [fetch(session, url) for url in urls]
        html_pages = await asyncio.gather(*tasks)
        for html in html_pages:
            soup = BeautifulSoup(html, 'html.parser')
            print(soup.title.string)

urls = ['https://example.com/page1', 'https://example.com/page2'] asyncio.run(scrape(urls))

7. Automatisation des publications sur les réseaux sociaux

Si vous gérez des comptes de réseaux sociaux, vous pouvez automatiser la publication en utilisant des bibliothèques comme Tweepy (pour Twitter) et Instagram-API (pour Instagram) qui vous permettent de publier automatiquement.

Voici un exemple utilisant la bibliothèque Tweepy pour publier un tweet :

import tweepy

def tweet(message):
    consumer_key = 'your_consumer_key'
    consumer_secret = 'your_consumer_secret'
    access_token = 'your_access_token'
    access_token_secret = 'your_access_token_secret'

    auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
    auth.set_access_token(access_token, access_token_secret)

    api = tweepy.API(auth)

    api.update_status(message)
    print("Tweet sent successfully!")

tweet("Hello, world!")

Ce script publie un tweet avec le message “Hello, world!” sur votre compte Twitter.

8. Automatisation de la génération de factures

Si vous générez des factures régulièrement, vous pouvez l’automatiser en utilisant des bibliothèques comme Fpdf, qui créera des factures PDF :

from fpdf import FPDF

def create_invoice(client_name, amount):
    pdf = FPDF()
    pdf.add_page()
    pdf.set_font("Arial", size=12)
    pdf.cell(200, 10, txt="Invoice", ln=True, align='C')
    pdf.cell(200, 10, txt=f"Client: {client_name}", ln=True, align='L')
    pdf.cell(200, 10, txt=f"Amount: ${amount}", ln=True, align='L')
    pdf.output(f"{client_name}_invoice.pdf")
    print(f"Invoice for {client_name} created successfully!")

create_invoice('John Doe', 500)

Ce script crée une facture simple et l’enregistre en tant que PDF.

9. Surveillance de la disponibilité des sites web

Python peut être utilisé pour automatiser la surveillance de la disponibilité des sites web en utilisant la bibliothèque requests, qui peut vérifier périodiquement si un site web est en ligne ou non :

import requests
import time

def check_website(url):
    try:
        response = requests.get(url)
        if response.status_code == 200:
            print(f"Website {url} is up!")
        else:
            print(f"Website {url} returned a status code {response.status_code}")
    except requests.exceptions.RequestException as e:
        print(f"Error checking website {url}: {e}")

url = 'https://example.com' while True: check_website(url) time.sleep(3600) # Check every hour

Ce script vérifie si le site web est en ligne et imprime le code de statut.

10. Réponse automatique aux e-mails

Si vous recevez souvent des e-mails et souhaitez configurer une réponse automatique, utilisez les bibliothèques imaplib et smtplib pour répondre automatiquement aux e-mails :

import imaplib
import smtplib
from email.mime.text import MIMEText

def auto_reply():
    # Connect to email server
    mail = imaplib.IMAP4_SSL("imap.gmail.com")
    mail.login('[email protected]', 'yourpassword')
    mail.select('inbox')

    # Search for unread emails
    status, emails = mail.search(None, 'UNSEEN')

    if status == "OK":
        for email_id in emails[0].split():
            status, email_data = mail.fetch(email_id, '(RFC822)')
            email_msg = email_data[0][1].decode('utf-8')

            # Send auto-reply
            send_email("Auto-reply", "Thank you for your email. I'll get back to you soon.", '[email protected]')

def send_email(subject, body, to_email):
    sender_email = '[email protected]'
    sender_password = 'yourpassword'
    receiver_email = to_email

    msg = MIMEText(body)
    msg['From'] = sender_email
    msg['To'] = receiver_email
    msg['Subject'] = subject

    with smtplib.SMTP_SSL('smtp.gmail.com', 465) as server:
        server.login(sender_email, sender_password)
        server.sendmail(sender_email, receiver_email, msg.as_string())

auto_reply()

Ce script répond automatiquement aux e-mails non lus avec un message prédéfini.

11. Nettoyage de fichiers

Python offre un moyen efficace d’automatiser le nettoyage des fichiers, en particulier pour supprimer ou déplacer des fichiers anciens afin de maintenir des répertoires organisés.

Voici un script simple qui supprime les fichiers de plus d’un certain nombre de jours en utilisant les modules os et time.

import aiofiles
import os
import asyncio
import time

async def clean_up(folder_path, days_old):
    now = time.time()
    cutoff_time = now - (days_old * 86400)
    for filename in os.listdir(folder_path):
        file_path = os.path.join(folder_path, filename)
        if os.path.getmtime(file_path) < cutoff_time:
            await aiofiles.os.remove(file_path)
            print(f"Deleted {filename}")

folder = '/path/to/your/folder'
asyncio.run(clean_up(folder, 30))

12. Génération Automatique de Mots de Passe

Créer des mots de passe forts et uniques est essentiel pour la sécurité, et Python peut aider à automatiser ce processus en utilisant le module random.

Voici un script simple qui génère des mots de passe aléatoires d’une longueur spécifiée, incorporant des lettres, des chiffres et des caractères spéciaux pour améliorer la sécurité.

import random
import asyncio
import string

async def generate_password(length=12):
    characters = string.ascii_letters + string.digits + string.punctuation
    password = ''.join(random.choice(characters) for _ in range(length))
    return password

async def generate_multiple_passwords(n, length=12):
    tasks = [generate_password(length) for _ in range(n)]
    passwords = await asyncio.gather(*tasks)
    print(passwords)

asyncio.run(generate_multiple_passwords(5))

13. Suivi de Tâches/Rappel

Créer un système de suivi de tâches ou de rappels en Python peut être réalisé en utilisant les modules datetime et asyncio.

import asyncio
from datetime import datetime

async def task_reminder(task_name, interval):
    while True:
        print(f"Reminder: {task_name} - {datetime.now()}")
        await asyncio.sleep(interval)

async def main():
    await asyncio.gather(
        task_reminder("Drink Water", 7200),  # Remind every 2 hours
        task_reminder("Take a Break", 3600)  # Remind every 1 hour
    )

asyncio.run(main())

Ce script envoie un rappel concernant la tâche à un moment prévu.

14. Génération Automatique de Rapports Quotidiens

Automatisez les rapports quotidiens en utilisant Python pour collecter des données et les formater en rapport :

import datetime
import aiofiles
import asyncio

async def generate_report(data):
    today = datetime.date.today()
    filename = f"daily_report_{today}.txt"
    async with aiofiles.open(filename, 'w') as file:
        await file.write(f"Report for {today}\n")
        await file.write("\n".join(data))
    print(f"Report generated: {filename}")

data = ["Task 1: Completed", "Task 2: Pending", "Task 3: Completed"]
asyncio.run(generate_report(data))

15. Surveiller les Ressources Système

Si vous êtes administrateur système, vous pouvez utiliser Python pour surveiller les ressources de votre système comme l’utilisation du CPU et de la mémoire, avec l’aide de la bibliothèque psutil.

import psutil

def monitor_resources():
    cpu_usage = psutil.cpu_percent(interval=1)
    memory_usage = psutil.virtual_memory().percent
    print(f"CPU Usage: {cpu_usage}%")
    print(f"Memory Usage: {memory_usage}%")

monitor_resources()

16. Redimensionnement d’Images par Lots

Si vous devez redimensionner des images en masse, Python facilite cela avec la bibliothèque Pillow.

from PIL import Image
import os
import asyncio
from concurrent.futures import ProcessPoolExecutor

def resize_image(filename, width, height):
    img = Image.open(filename)
    img = img.resize((width, height))
    img.save(f"resized_{filename}")
    return f"Resized {filename}"

async def resize_images(folder_path, width, height):
    with ProcessPoolExecutor() as executor:
        loop = asyncio.get_event_loop()
        tasks = []
        for filename in os.listdir(folder_path):
            if filename.endswith('.jpg'):
                tasks.append(loop.run_in_executor(
                    executor, resize_image, os.path.join(folder_path, filename), width, height))
        results = await asyncio.gather(*tasks)
        print(results)

folder = '/path/to/your/images'
asyncio.run(resize_images(folder, 800, 600))

Ce script redimensionne toutes les images .jpg dans un dossier aux dimensions spécifiées.

17. Automatisation de la sauvegarde des données vers le cloud

L’automatisation des sauvegardes vers des services cloud comme Google Drive est rendue possible avec Python en utilisant des bibliothèques telles que pydrive.

from pydrive.auth import GoogleAuth
from pydrive.drive import GoogleDrive

def backup_to_google_drive(file_path):
    gauth = GoogleAuth()
    gauth.LocalWebserverAuth()
    drive = GoogleDrive(gauth)
    file = drive.CreateFile({'title': 'backup_file.txt'})
    file.Upload()
    print("Backup uploaded successfully!")

file = '/path/to/your/file.txt' backup_to_google_drive(file)

18. Création de rappels quotidiens

Définir des rappels quotidiens est facile avec le module time, qui vous rappellera de boire de l’eau toutes les 2 heures :

import time

def water_reminder():
    while True:
        print("Time to drink water!")
        time.sleep(7200)  # Remind every 2 hours

water_reminder()

19. Automatisation de la saisie de données dans Excel

Si vous entrez fréquemment des données dans Excel, Python peut aider à automatiser cette tâche avec la bibliothèque openpyxl :

from openpyxl import Workbook

def create_excel(data):
    wb = Workbook()
    ws = wb.active
    for row in data:
        ws.append(row)
    wb.save('data.xlsx')
    print("Excel file created successfully!")

data = [
    ["Name", "Age", "City"],
    ["John", 30, "New York"],
    ["Anna", 25, "London"],
]
create_excel(data)

20. Automatisation du nettoyage des données

Si vous travaillez avec de grands ensembles de données, Python peut automatiser les tâches de nettoyage des données, ce qui supprimera les lignes vides d’un fichier CSV :

import csv

def clean_csv(file_path):
    with open(file_path, 'r') as infile:
        reader = csv.reader(infile)
        rows = [row for row in reader if any(row)]
    
    with open(file_path, 'w', newline='') as outfile:
        writer = csv.writer(outfile)
        writer.writerows(rows)
    
    print("Empty rows removed from CSV")

file = '/path/to/your/data.csv' clean_csv(file)

21. Extraction de texte à partir d’images

Python peut être utilisé pour extraire du texte à partir d’images en utilisant la bibliothèque pytesseract, ce qui peut être utile lorsque vous devez numériser du contenu imprimé ou extraire du texte de documents numérisés.

from PIL import Image
import pytesseract

def extract_text_from_image(image_path):
    # Open the image file
    img = Image.open(image_path)
    
    # Use pytesseract to extract text
    text = pytesseract.image_to_string(img)
    
    return text

image_path = 'path_to_your_image.jpg'
extracted_text = extract_text_from_image(image_path)
print("Extracted Text:\n", extracted_text)

Conclusion

Ce ne sont là que quelques exemples de ce que Python peut faire pour automatiser vos tâches quotidiennes. Avec sa syntaxe simple et ses bibliothèques puissantes, Python peut gérer presque toutes les tâches que vous lui confiez.

Que vous gériez des fichiers, envoyiez des e-mails ou génériez des rapports, Python peut vous faire gagner du temps et améliorer votre productivité. Alors, commencez dès aujourd’hui avec l’automatisation Python et laissez-le s’occuper de vos tâches quotidiennes !