Python File Copy and Renaming Strategy: Intelligent Methods for Handling Duplicate Files in Directories

Problem Background and Requirements Analysis

In practical file management applications, there is often a need to copy files from one directory to another while handling potential同名 files in the target directory. Direct use of shutil.copy results in silent file overwriting, which may lead to data loss. Therefore, an intelligent renaming mechanism is required that can automatically add numerical suffixes to files when filename conflicts are detected.

Core Implementation Principles

The core of the solution lies in combining os.walk for source directory traversal, os.path.exists for file existence checks, and循环incremental numerical suffix renaming logic. When a target file is found to already exist, the program attempts to add suffixes like _1, _2, etc., until a non-conflicting filename is found.

Complete Code Implementation

Below is the complete implementation code, optimized and thoroughly commented:

import os
import shutil

# Define source and target directories
movdir = r"C:\Scans"
basedir = r"C:\Links"

# Traverse all files in the source directory
for root, dirs, files in os.walk(movdir):
    for filename in files:
        # Construct the full path of the file
        old_name = os.path.join(os.path.abspath(root), filename)
        
        # Separate filename and extension
        base, extension = os.path.splitext(filename)
        
        # Check if the target folder exists
        target_folder = os.path.join(basedir, base)
        if not os.path.exists(target_folder):
            print(f"Target folder {target_folder} not found, skipping file {filename}")
            continue
        
        # Build initial target file path
        new_name = os.path.join(basedir, base, filename)
        
        # If target file does not exist, copy directly
        if not os.path.exists(new_name):
            shutil.copy(old_name, new_name)
            print(f"Copied {old_name} to {new_name}")
        else:
            # File exists, start incremental renaming
            ii = 1
            while True:
                # Construct new filename with numerical suffix
                new_name = os.path.join(basedir, base, f"{base}_{ii}{extension}")
                if not os.path.exists(new_name):
                    shutil.copy(old_name, new_name)
                    print(f"Copied {old_name} as {new_name}")
                    break
                ii += 1

Key Technologies and Detailed Analysis

Directory Traversal and Path Handling: Using os.walk enables recursive traversal of directory trees, ensuring all files in subdirectories are processed. os.path.join and os.path.splitext provide cross-platform path and filename handling capabilities.

Existence Checking and Renaming Logic: os.path.exists accurately determines file existence. When conflicts are detected, a while loop increments numerical suffixes until an available filename is found. This implementation avoids filename conflicts while maintaining filename readability.

Error Handling and Logging: The code includes appropriate print statements for debugging and monitoring the copy process. In production environments, consider adding more comprehensive error handling and logging mechanisms.

Comparison with Other Methods

Compared to timestamp-based renaming approaches, the numerical suffix方案maintains semantic consistency in filenames, facilitating subsequent file search and management. Simple shutil.copy without handling duplicates risks data overwriting and is unsuitable for production use.

Best Practice Recommendations

When deploying in practice, it is advisable to add additional security measures such as file permission checks and disk space verification. For large-scale file operations, consider incorporating progress indicators and interrupt recovery features. Additionally, ensure proper handling of filenames with special characters to avoid path parsing errors.