Synchronisation de fichiers entre deux répertoires à l'aide de Python

La synchronisation des fichiers entre les répertoires est une tâche courante pour gérer les sauvegardes, garantir la cohérence entre plusieurs emplacements de stockage ou simplement garder les données organisées.

Bien qu'il existe de nombreux outils disponibles pour ce faire, la création d'un script Python pour gérer la synchronisation d'annuaire offre flexibilité et contrôle.

Ce guide vous guidera à travers un script Python conçu pour synchroniser des fichiers entre deux répertoires.

---

Introduction au scénario

Le script commence par importer plusieurs bibliothèques Python essentielles.

Ceux-ci incluent os pour interagir avec le système d'exploitation,shutilpour les opérations sur les fichiers de haut niveau, filecmppour comparer les fichiers, argparsepour analyser les arguments de ligne de commande et tqdmpour afficher les barres de progression lors d'opérations longues.

Ces bibliothèques fonctionnent ensemble pour créer une solution robuste pour la synchronisation d'annuaires.

import os
import shutil
import filecmp
import argparse
from tqdm import tqdm

Les scripts utilisent principalement des modules intégrés Python, mais pour la barre de progression, ils utilisent la bibliothèque tqdmlibrary, qui doit être installée avec :

pip install tqdm

---

Vérification et préparation des répertoires

Avant de démarrer la synchronisation, le script doit vérifier si le répertoire source existe.

Si le répertoire de destination n'existe pas, le script le créera.

Cette étape est importante pour garantir que le processus de synchronisation peut se dérouler sans problème, sans aucun problème causé par des répertoires manquants.

# Function to check if the source and destination directories exist
def check_directories(src_dir, dst_dir):
    # Check if the source directory exists
    if not os.path.exists(src_dir):
        print(f"\nSource directory '{src_dir}' does not exist.")
        return False
    # Create the destination directory if it does not exist
    if not os.path.exists(dst_dir):
        os.makedirs(dst_dir)
        print(f"\nDestination directory '{dst_dir}' created.")
    return True

La fonction check_directories garantit que les répertoires source et de destination sont prêts pour la synchronisation. Voici comment cela fonctionne :

• La fonction utilise os.path.exists() pour vérifier si les répertoires existent.
• Si le répertoire source est manquant, le script en informe l'utilisateur et arrête de s'exécuter.
• Si le répertoire de destination est manquant, le script le crée automatiquement à l'aide de os.makedirs(). Cela garantit que la structure de répertoires nécessaire est en place.

---

Synchronisation de fichiers entre répertoires

La tâche principale du script est de synchroniser les fichiers entre les répertoires source et de destination.

La fonction sync_directories gère cette tâche en parcourant d'abord le répertoire source pour rassembler une liste de tous les fichiers et sous-répertoires.

La fonction os.walk aide en générant des noms de fichiers dans l'arborescence des répertoires, permettant au script de capturer chaque fichier et dossier du répertoire source.

# Function to synchronize files between two directories
def sync_directories(src_dir, dst_dir, delete=False):
    # Get a list of all files and directories in the source directory
    files_to_sync = []
    for root, dirs, files in os.walk(src_dir):
        for directory in dirs:
            files_to_sync.append(os.path.join(root, directory))
        for file in files:
            files_to_sync.append(os.path.join(root, file))

    # Iterate over each file in the source directory with a progress bar
    with tqdm(total=len(files_to_sync), desc="Syncing files", unit="file") as pbar:
        # Iterate over each file in the source directory
        for source_path in files_to_sync:
            # Get the corresponding path in the replica directory
            replica_path = os.path.join(dst_dir, os.path.relpath(source_path, src_dir))

            # Check if path is a directory and create it in the replica directory if it does not exist
            if os.path.isdir(source_path):
                if not os.path.exists(replica_path):
                    os.makedirs(replica_path)
            # Copy all files from the source directory to the replica directory
            else:
                # Check if the file exists in the replica directory and if it is different from the source file
                if not os.path.exists(replica_path) or not filecmp.cmp(source_path, replica_path, shallow=False):
                    # Set the description of the progress bar and print the file being copied
                    pbar.set_description(f"Processing '{source_path}'")
                    print(f"\nCopying {source_path} to {replica_path}")

                    # Copy the file from the source directory to the replica directory
                    shutil.copy2(source_path, replica_path)

            # Update the progress bar
            pbar.update(1)

Une fois la liste des fichiers et répertoires compilée, le script utilise une barre de progression fournie par tqdm pour donner un retour à l'utilisateur sur le processus de synchronisation.

Pour chaque fichier et répertoire de la source, le script calcule le chemin correspondant dans la destination.

Si le chemin est un répertoire, le script s'assure qu'il existe dans la destination.

Si le chemin est un fichier, le script vérifie si le fichier existe déjà dans la destination et s'il est identique au fichier source.

Si le fichier est manquant ou différent, le script le copie vers la destination.

De cette façon, le script maintient le répertoire de destination à jour avec le répertoire source.

---

Nettoyer des fichiers supplémentaires

Le script dispose également d'une fonctionnalité facultative permettant de supprimer les fichiers du répertoire de destination qui ne se trouvent pas dans le répertoire source.

Ceci est contrôlé par un indicateur --delete que l'utilisateur peut définir.

Si cet indicateur est utilisé, le script parcourt le répertoire de destination et compare chaque fichier et dossier à la source.

S'il trouve quelque chose dans la destination qui ne figure pas dans la source, le script le supprime.

Cela garantit que le répertoire de destination est une copie exacte du répertoire source.

# Clean up files in the destination directory that are not in the source directory, if delete flag is set
    if delete:
        # Get a list of all files in the destination directory
        files_to_delete = []
        for root, dirs, files in os.walk(dst_dir):
            for directory in dirs:
                files_to_delete.append(os.path.join(root, directory))
            for file in files:
                files_to_delete.append(os.path.join(root, file))

        # Iterate over each file in the destination directory with a progress bar
        with tqdm(total=len(files_to_delete), desc="Deleting files", unit="file") as pbar:
            # Iterate over each file in the destination directory
            for replica_path in files_to_delete:
                # Check if the file exists in the source directory
                source_path = os.path.join(src_dir, os.path.relpath(replica_path, dst_dir))
                if not os.path.exists(source_path):
                    # Set the description of the progress bar
                    pbar.set_description(f"Processing '{replica_path}'")
                    print(f"\nDeleting {replica_path}")

                    # Check if the path is a directory and remove it
                    if os.path.isdir(replica_path):
                        shutil.rmtree(replica_path)
                    else:
                        # Remove the file from the destination directory
                        os.remove(replica_path)

                # Update the progress bar
                pbar.update(1)

Cette partie du script utilise des techniques similaires à celles du processus de synchronisation.

Il utilise os.walk() pour rassembler des fichiers et des répertoires et tqdm pour montrer la progression.
La fonction shutdown.rmtree() est utilisée pour supprimer des répertoires, tandis que os.remove() gère les fichiers individuels.

---

Exécuter le script

Le script est conçu pour être exécuté depuis la ligne de commande, avec des arguments spécifiant les répertoires source et de destination.

Le module argparse facilite la gestion de ces arguments, permettant aux utilisateurs de fournir simplement les chemins et options nécessaires lors de l'exécution du script.

# Main function to parse command line arguments and synchronize directories
if __name__ == "__main__":
    # Parse command line arguments
    parser = argparse.ArgumentParser(description="Synchronize files between two directories.")
    parser.add_argument("source_directory", help="The source directory to synchronize from.")
    parser.add_argument("destination_directory", help="The destination directory to synchronize to.")
    parser.add_argument("-d", "--delete", action="store_true",
                        help="Delete files in destination that are not in source.")
    args = parser.parse_args()

    # If the delete flag is set, print a warning message
    if args.delete:
        print("\nExtraneous files in the destination will be deleted.")

    # Check the source and destination directories
    if not check_directories(args.source_directory, args.destination_directory):
        exit(1)

    # Synchronize the directories
    sync_directories(args.source_directory, args.destination_directory, args.delete)
    print("\nSynchronization complete.")

La fonction principale rassemble tout.

Il traite les arguments de la ligne de commande, vérifie les répertoires, puis effectue la synchronisation.

Si l'indicateur --delete est défini, il gère également le nettoyage des fichiers supplémentaires.

---

Exemples

Voyons quelques exemples de la façon d'exécuter le script avec les différentes options.

De la source à la destination

python file_sync.py d:\sync d:\sync_copy 

Destination directory 'd:\sync2' created.
Processing 'd:\sync\video.mp4':   0%|                                                                                                   | 0/5 [00:00<?, ?file/s]
Copying d:\sync\video.mp4 to d:\sync2\video.mp4
Processing 'd:\sync\video_final.mp4':  20%|██████████████████▌                                                                          | 1/5 [00:00<?, ?file/s] 
Copying d:\sync\video_final.mp4 to d:\sync2\video_final.mp4
Processing 'd:\sync\video_single - Copy (2).mp4':  40%|████████████████████████████████▍                                                | 2/5 [00:00<?, ?file/s] 
Copying d:\sync\video_single - Copy (2).mp4 to d:\sync2\video_single - Copy (2).mp4
Processing 'd:\sync\video_single - Copy.mp4':  60%|█████████████████████████████████████████████▌                              | 3/5 [00:00<00:00, 205.83file/s]
Copying d:\sync\video_single - Copy.mp4 to d:\sync2\video_single - Copy.mp4
Processing 'd:\sync\video_single.mp4':  80%|██████████████████████████████████████████████████████████████████▍                | 4/5 [00:00<00:00, 274.44file/s] 
Copying d:\sync\video_single.mp4 to d:\sync2\video_single.mp4
Processing 'd:\sync\video_single.mp4': 100%|███████████████████████████████████████████████████████████████████████████████████| 5/5 [00:00<00:00, 343.05file/s] 

Synchronization complete.

Source to Destination with Cleanup of Extra Files

python file_sync.py d:\sync d:\sync_copy -d

Extraneous files in the destination will be deleted.
Syncing files: 100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5/5 [00:00<00:00, 63.29file/s]
Deleting files: 100%|███████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 5/5 [00:00<?, ?file/s] 

Synchronization complete.

---

Conclusion

This Python script offers a powerful and flexible way to synchronize files between two directories.

It uses key libraries like os, shutil, and filecmp, and enhances the user experience with tqdm for tracking progress.

This ensures that your data is consistently and efficiently synchronized.
Whether you're maintaining backups or ensuring consistency across storage locations, this script can be a valuable tool in your toolkit.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!