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.
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
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 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.
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.
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.
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.
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!
Comment résoudre l'erreur 443
Quels sont les logiciels pour apprendre python ?
utilisation du tracker de vitesse
Comment réparer la passerelle par défaut de l'ordinateur n'est pas disponible
Comment réinstaller le système informatique
Solution au blocage de Gmail
Outils d'évaluation des talents
Utilisation de la classe Snoopy en php
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
