Dateien zwischen zwei Verzeichnissen mit Python synchronisieren

Das Synchronisieren von Dateien zwischen Verzeichnissen ist eine häufige Aufgabe zur Verwaltung von Backups, zur Gewährleistung der Konsistenz über mehrere Speicherorte hinweg oder einfach zur Organisation der Daten.

Obwohl dafür viele Tools verfügbar sind, bietet die Erstellung eines Python-Skripts zur Verwaltung der Verzeichnissynchronisierung Flexibilität und Kontrolle.

Diese Anleitung führt Sie durch ein Python-Skript, das zum Synchronisieren von Dateien zwischen zwei Verzeichnissen entwickelt wurde.

---

Einführung in das Drehbuch

Das Skript beginnt mit dem Import mehrerer wichtiger Python-Bibliotheken.

Dazu gehören „os“ für die Interaktion mit dem Betriebssystem, „shutil“ für Dateivorgänge auf hoher Ebene, „filecmp“ für den Vergleich von Dateien, „argparse“ für das Parsen von Befehlszeilenargumenten und „tqdm“ für die Anzeige von Fortschrittsbalken bei längeren Vorgängen.

Diese Bibliotheken arbeiten zusammen, um eine robuste Lösung für die Verzeichnissynchronisierung zu schaffen.

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

Die Skripte verwenden hauptsächlich integrierte Python-Module, aber für den Fortschrittsbalken wird die tqdmlibrary verwendet, die installiert werden muss mit:

pip install tqdm

---

Verzeichnisse prüfen und vorbereiten

Bevor die Synchronisierung gestartet wird, muss das Skript prüfen, ob das Quellverzeichnis vorhanden ist.

Wenn das Zielverzeichnis nicht existiert, wird es vom Skript erstellt.

Dieser Schritt ist wichtig, um sicherzustellen, dass der Synchronisierungsprozess reibungslos ablaufen kann, ohne dass Probleme durch fehlende Verzeichnisse verursacht werden.

# 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

Die Funktion check_directories stellt sicher, dass sowohl das Quell- als auch das Zielverzeichnis für die Synchronisierung bereit sind. So funktioniert es:

• Die Funktion verwendet os.path.exists() , um zu prüfen, ob die Verzeichnisse vorhanden sind.
• Wenn das Quellverzeichnis fehlt, teilt das Skript dem Benutzer mit und stoppt die Ausführung.
• Wenn das Zielverzeichnis fehlt, erstellt das Skript es automatisch mit os.makedirs(). Dadurch wird sichergestellt, dass die erforderliche Verzeichnisstruktur vorhanden ist.

---

Dateien zwischen Verzeichnissen synchronisieren

Die Hauptaufgabe des Skripts besteht darin, Dateien zwischen den Quell- und Zielverzeichnissen zu synchronisieren.

Die Funktion sync_directories übernimmt diese Aufgabe, indem sie zunächst das Quellverzeichnis durchsucht, um eine Liste aller Dateien und Unterverzeichnisse zu sammeln.

Die Funktion os.walk hilft, indem sie Dateinamen im Verzeichnisbaum generiert, sodass das Skript jede Datei und jeden Ordner im Quellverzeichnis erfassen kann.

# 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)

Sobald die Liste der Dateien und Verzeichnisse kompiliert ist, verwendet das Skript einen von tqdm bereitgestellten Fortschrittsbalken, um dem Benutzer Feedback zum Synchronisierungsprozess zu geben.

Für jede Datei und jedes Verzeichnis in der Quelle berechnet das Skript den entsprechenden Pfad im Ziel.

Wenn der Pfad ein Verzeichnis ist, stellt das Skript sicher, dass es im Ziel vorhanden ist.

Wenn es sich beim Pfad um eine Datei handelt, prüft das Skript, ob die Datei bereits im Ziel vorhanden ist und mit der Quelldatei identisch ist.

Wenn die Datei fehlt oder anders ist, kopiert das Skript sie an das Ziel.

Auf diese Weise hält das Skript das Zielverzeichnis mit dem Quellverzeichnis auf dem neuesten Stand.

---

Bereinigen zusätzlicher Dateien

Das Skript verfügt außerdem über eine optionale Funktion zum Löschen von Dateien im Zielverzeichnis, die sich nicht im Quellverzeichnis befinden.

Dies wird durch ein --delete-Flag gesteuert, das der Benutzer setzen kann.

Wenn dieses Flag verwendet wird, durchläuft das Skript das Zielverzeichnis und vergleicht jede Datei und jeden Ordner mit der Quelle.

Wenn es im Ziel etwas findet, das nicht in der Quelle enthalten ist, löscht das Skript es.

Dadurch wird sichergestellt, dass das Zielverzeichnis eine exakte Kopie des Quellverzeichnisses ist.

# 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)

Dieser Teil des Skripts verwendet ähnliche Techniken wie der Synchronisierungsprozess.

Es verwendet os.walk(), um Dateien und Verzeichnisse zu sammeln, und tqdm, um den Fortschritt anzuzeigen.
Die Funktion „shutil.rmtree()“ wird zum Entfernen von Verzeichnissen verwendet, während „os.remove()“ einzelne Dateien verarbeitet.

---

Ausführen des Skripts

Das Skript ist so konzipiert, dass es über die Befehlszeile ausgeführt werden kann, wobei Argumente die Quell- und Zielverzeichnisse angeben.

Das argparse-Modul erleichtert die Handhabung dieser Argumente und ermöglicht es Benutzern, beim Ausführen des Skripts einfach die erforderlichen Pfade und Optionen anzugeben.

# 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.")

Die Hauptfunktion bringt alles zusammen.

Es verarbeitet die Befehlszeilenargumente, überprüft die Verzeichnisse und führt dann die Synchronisierung durch.

Wenn das Flag --delete gesetzt ist, übernimmt es auch die Bereinigung zusätzlicher Dateien.

---

Beispiele

Sehen wir uns einige Beispiele an, wie das Skript mit den verschiedenen Optionen ausgeführt wird.

Von der Quelle zum Ziel

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.

Das obige ist der detaillierte Inhalt vonDateien zwischen zwei Verzeichnissen mit Python synchronisieren. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!