効率的なPythonファイルコピーの実装方法についてのススメ

import shutil

# 元のファイルパスとコピー先のパスを指定
source_file = "original.txt"
destination_file = "copied.txt"

# ファイルをコピー
shutil.copy(source_file, destination_file)

print(f"{source_file}を{destination_file}にコピーしました。")

import shutil
import os

# 元のディレクトリパスとコピー先のパスを指定
source_dir = "original_folder"
destination_dir = "copied_folder"

# ディレクトリが存在しない場合は作成
if not os.path.exists(source_dir):
    os.makedirs(source_dir)

# サンプルファイルを作成
with open(os.path.join(source_dir, "sample.txt"), "w") as f:
    f.write("This is a sample file.")

# ディレクトリをコピー
shutil.copytree(source_dir, destination_dir)

print(f"{source_dir}を{destination_dir}にコピーしました。")

import shutil
import os

# 元のファイルパスとコピー先のパスを指定（新しい名前を含む）
source_file = "original.txt"
destination_file = "new_folder/renamed_file.txt"

# サンプルファイルを作成
with open(source_file, "w") as f:
    f.write("This is the original file.")

# コピー先のディレクトリが存在しない場合は作成
os.makedirs(os.path.dirname(destination_file), exist_ok=True)

# ファイルをコピーし、同時にリネーム
shutil.copy(source_file, destination_file)

print(f"{source_file}を{destination_file}にコピーし、リネームしました。")

import os
import shutil

# 元のディレクトリとコピー先ディレクトリを指定
source_dir = "source_folder"
destination_dir = "destination_folder"

# コピー先ディレクトリが存在しない場合は作成
if not os.path.exists(destination_dir):
    os.makedirs(destination_dir)

# ソースディレクトリ内のファイルを走査
for filename in os.listdir(source_dir):
    # テキストファイルのみを対象とする
    if filename.endswith(".txt"):
        source_file = os.path.join(source_dir, filename)
        destination_file = os.path.join(destination_dir, filename)
        # ファイルをコピー
        shutil.copy2(source_file, destination_file)
        print(f"{filename}をコピーしました。")

print("すべてのテキストファイルのコピーが完了しました。")

file1.txtをコピーしました。
file2.txtをコピーしました。
file3.txtをコピーしました。
すべてのテキストファイルのコピーが完了しました。

import os
import shutil

def safe_copy(source, destination):
    # コピー先のファイル名を生成
    base_name = os.path.basename(source)
    name, ext = os.path.splitext(base_name)
    counter = 1
    new_name = base_name

    # 同名ファイルが存在する場合、番号を付けて新しい名前を生成
    while os.path.exists(os.path.join(destination, new_name)):
        new_name = f"{name}_{counter}{ext}"
        counter += 1

    # 安全にコピー
    shutil.copy2(source, os.path.join(destination, new_name))
    return new_name

# 使用例
source_file = "original.txt"
destination_dir = "copied_files"

if not os.path.exists(destination_dir):
    os.makedirs(destination_dir)

copied_name = safe_copy(source_file, destination_dir)
print(f"{source_file}を{copied_name}としてコピーしました。")

import glob
import shutil
import os

def wildcard_copy(source_pattern, destination_dir):
    # コピー先ディレクトリが存在しない場合は作成
    if not os.path.exists(destination_dir):
        os.makedirs(destination_dir)

    # ワイルドカードパターンに一致するファイルを取得
    matching_files = glob.glob(source_pattern)

    # 一致したファイルをコピー
    for file in matching_files:
        file_name = os.path.basename(file)
        destination_path = os.path.join(destination_dir, file_name)
        shutil.copy2(file, destination_path)
        print(f"{file}を{destination_path}にコピーしました。")

    return len(matching_files)

# 使用例
source_pattern = "data/*.csv"  # dataフォルダ内のすべてのCSVファイル
destination_dir = "copied_csv_files"

copied_count = wildcard_copy(source_pattern, destination_dir)
print(f"合計{copied_count}個のファイルをコピーしました。")

data/file1.csvをcopied_csv_files/file1.csvにコピーしました。
data/file2.csvをcopied_csv_files/file2.csvにコピーしました。
data/file3.csvをcopied_csv_files/file3.csvにコピーしました。
合計3個のファイルをコピーしました。

import os
import shutil
import time

def copy_with_buffer(source, destination, buffer_size):
    with open(source, 'rb') as src, open(destination, 'wb') as dst:
        shutil.copyfileobj(src, dst, buffer_size)

def benchmark_copy(source, destination, buffer_sizes):
    for size in buffer_sizes:
        start_time = time.time()
        copy_with_buffer(source, destination, size)
        end_time = time.time()
        print(f"バッファサイズ {size} バイト: {end_time - start_time:.4f} 秒")

        # コピーしたファイルを削除（次のテストのため）
        os.remove(destination)

# テスト用の大きなファイルを作成
source_file = "large_file.bin"
with open(source_file, 'wb') as f:
    f.write(os.urandom(100 * 1024 * 1024))  # 100MBのランダムデータ

destination_file = "copied_large_file.bin"

# 異なるバッファサイズでテスト
buffer_sizes = [4096, 65536, 1048576, 4194304]
benchmark_copy(source_file, destination_file, buffer_sizes)

# テスト用ファイルを削除
os.remove(source_file)

バッファサイズ 4096 バイト: 0.5623 秒
バッファサイズ 65536 バイト: 0.0982 秒
バッファサイズ 1048576 バイト: 0.0754 秒
バッファサイズ 4194304 バイト: 0.0721 秒

import asyncio
import aiofiles
import os
import time

async def async_copy(source, destination):
    async with aiofiles.open(source, 'rb') as src, aiofiles.open(destination, 'wb') as dst:
        await dst.write(await src.read())

async def copy_files(file_pairs):
    tasks = [async_copy(src, dst) for src, dst in file_pairs]
    await asyncio.gather(*tasks)

def create_sample_files(num_files, size_mb):
    os.makedirs("source_files", exist_ok=True)
    for i in range(num_files):
        with open(f"source_files/file_{i}.bin", 'wb') as f:
            f.write(os.urandom(size_mb * 1024 * 1024))

def prepare_copy_list(num_files):
    os.makedirs("destination_files", exist_ok=True)
    return [
        (f"source_files/file_{i}.bin", f"destination_files/file_{i}.bin")
        for i in range(num_files)
    ]

# メイン処理
async def main():
    num_files = 10
    file_size_mb = 10

    print(f"{num_files}個の{file_size_mb}MBファイルを作成中...")
    create_sample_files(num_files, file_size_mb)

    file_pairs = prepare_copy_list(num_files)

    print("非同期コピーを開始...")
    start_time = time.time()
    await copy_files(file_pairs)
    end_time = time.time()

    print(f"非同期コピー完了！ 処理時間: {end_time - start_time:.4f} 秒")

# 非同期処理の実行
asyncio.run(main())

10個の10MBファイルを作成中...
非同期コピーを開始...
非同期コピー完了！ 処理時間: 0.8765 秒

import os

# 1. raw文字列を使用する方法
raw_path = r"C:\Users\YourName\Documents\file.txt"
print(f"raw文字列を使用したパス: {raw_path}")

# 2. フォワードスラッシュを使用する方法
forward_slash_path = "C:/Users/YourName/Documents/file.txt"
print(f"フォワードスラッシュを使用したパス: {forward_slash_path}")

# 3. os.pathモジュールを使用する方法
os_path = os.path.join("C:", "Users", "YourName", "Documents", "file.txt")
print(f"os.pathモジュールを使用したパス: {os_path}")

# パスの正規化
normalized_path = os.path.normpath(forward_slash_path)
print(f"正規化されたパス: {normalized_path}")

raw文字列を使用したパス: C:\Users\YourName\Documents\file.txt
フォワードスラッシュを使用したパス: C:/Users/YourName/Documents/file.txt
os.pathモジュールを使用したパス: C:\Users\YourName\Documents\file.txt
正規化されたパス: C:\Users\YourName\Documents\file.txt

import os
import winreg

def enable_long_paths():
    try:
        with winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, r"SYSTEM\CurrentControlSet\Control\FileSystem",
                            0, winreg.KEY_ALL_ACCESS) as key:
            winreg.SetValueEx(key, "LongPathsEnabled", 0, winreg.REG_DWORD, 1)
        print("長いパスのサポートが有効化されました。システムの再起動が必要です。")
    except Exception as e:
        print(f"長いパスの有効化に失敗しました: {e}")

def create_long_path_file():
    base_path = "C:\\temp"
    long_path = base_path + "\\a" * 250 + "\\long_file.txt"

    try:
        os.makedirs(os.path.dirname(long_path), exist_ok=True)
        with open(long_path, 'w') as f:
            f.write("This is a file with a very long path.")
        print(f"長いパスのファイルが作成されました: {long_path}")
    except OSError as e:
        print(f"ファイルの作成に失敗しました: {e}")

# 長いパスのサポートを有効化
enable_long_paths()

# 長いパスのファイルを作成
create_long_path_file()

長いパスのサポートが有効化されました。システムの再起動が必要です。
長いパスのファイルが作成されました: C:\temp\aaaaa...(中略)...aaaaa\long_file.txt

import os
import shutil
import time

def copy_with_retry(src, dst, max_attempts=5, delay=1):
    for attempt in range(max_attempts):
        try:
            shutil.copy2(src, dst)
            print(f"ファイルのコピーに成功しました: {src} → {dst}")
            return
        except PermissionError as e:
            print(f"試行 {attempt + 1}/{max_attempts}: アクセス権限エラーが発生しました。再試行します...")
            time.sleep(delay)

    print(f"ファイルのコピーに失敗しました: {src}")
    print("対処法:")
    print("1. ファイルが他のプログラムで開かれていないか確認してください。")
    print("2. 管理者権限でスクリプトを実行してみてください。")
    print("3. ファイルとディレクトリの権限設定を確認してください。")

# 使用例
source_file = "example.txt"
destination_file = "copied_example.txt"

# サンプルファイルの作成
with open(source_file, "w") as f:
    f.write("This is a test file.")

copy_with_retry(source_file, destination_file)

# クリーンアップ
os.remove(source_file)
os.remove(destination_file)

試行 1/5: アクセス権限エラーが発生しました。再試行します...
試行 2/5: アクセス権限エラーが発生しました。再試行します...
試行 3/5: アクセス権限エラーが発生しました。再試行します...
試行 4/5: アクセス権限エラーが発生しました。再試行します...
試行 5/5: アクセス権限エラーが発生しました。再試行します...
ファイルのコピーに失敗しました: example.txt
対処法:
1. ファイルが他のプログラムで開かれていないか確認してください。
2. 管理者権限でスクリプトを実行してみてください。
3. ファイルとディレクトリの権限設定を確認してください。

import os
import shutil

def safe_copy(src, dst):
    try:
        shutil.copy2(src, dst)
        print(f"ファイルのコピーに成功しました: {src} → {dst}")
    except FileNotFoundError as e:
        print(f"エラー: ファイルが見つかりません - {e}")
        print("対処法:")
        print("1. ファイルパスが正しいか確認してください。")
        print("2. ファイルが実際に存在するか確認してください。")
        print("3. 現在の作業ディレクトリを確認してください。")
        print(f"現在の作業ディレクトリ: {os.getcwd()}")

# 使用例
source_file = "non_existent_file.txt"
destination_file = "copied_file.txt"

safe_copy(source_file, destination_file)

エラー: ファイルが見つかりません - [Errno 2] No such file or directory: 'non_existent_file.txt'
対処法:
1. ファイルパスが正しいか確認してください。
2. ファイルが実際に存在するか確認してください。
3. 現在の作業ディレクトリを確認してください。
現在の作業ディレクトリ: /home/user/projects

import os
import shutil

def check_disk_space(path, required_space):
    total, used, free = shutil.disk_usage(path)
    return free > required_space

def copy_with_space_check(src, dst):
    try:
        file_size = os.path.getsize(src)
        if not check_disk_space(os.path.dirname(dst), file_size):
            print(f"警告: ディスク容量が不足しています。必要な空き容量: {file_size} バイト")
            print("対処法:")
            print("1. 不要なファイルを削除して空き容量を確保してください。")
            print("2. 別のディスクにコピーすることを検討してください。")
            print("3. ファイルを圧縮してからコピーすることを検討してください。")
            return

        shutil.copy2(src, dst)
        print(f"ファイルのコピーに成功しました: {src} → {dst}")
    except Exception as e:
        print(f"エラーが発生しました: {e}")

# 使用例
source_file = "large_file.bin"
destination_file = "copied_large_file.bin"

# サンプルの大きなファイルを作成
with open(source_file, "wb") as f:
    f.write(os.urandom(1024 * 1024 * 100))  # 100MBのランダムデータ

copy_with_space_check(source_file, destination_file)

# クリーンアップ
os.remove(source_file)
if os.path.exists(destination_file):
    os.remove(destination_file)

警告: ディスク容量が不足しています。必要な空き容量: 104857600 バイト
対処法:
1. 不要なファイルを削除して空き容量を確保してください。
2. 別のディスクにコピーすることを検討してください。
3. ファイルを圧縮してからコピーすることを検討してください。

import os
import shutil
import datetime

def create_backup(source_dir, backup_dir):
    # バックアップ先のディレクトリ名を作成（現在の日時を使用）
    timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
    backup_path = os.path.join(backup_dir, f"backup_{timestamp}")

    try:
        # ディレクトリ全体をコピー
        shutil.copytree(source_dir, backup_path)
        print(f"バックアップが正常に作成されました: {backup_path}")

        # バックアップサイズの計算
        total_size = sum(os.path.getsize(os.path.join(dirpath, filename))
                         for dirpath, dirnames, filenames in os.walk(backup_path)
                         for filename in filenames)

        print(f"バックアップサイズ: {total_size / (1024 * 1024):.2f} MB")

    except Exception as e:
        print(f"バックアップ作成中にエラーが発生しました: {e}")

# 使用例
source_directory = "important_files"
backup_directory = "backups"

# サンプルファイルの作成
os.makedirs(source_directory, exist_ok=True)
with open(os.path.join(source_directory, "document1.txt"), "w") as f:
    f.write("This is an important document.")

# バックアップの実行
create_backup(source_directory, backup_directory)

バックアップが正常に作成されました: backups/backup_20230724_123456
バックアップサイズ: 0.00 MB

import os
import shutil

def organize_files(source_dir):
    # ファイルの拡張子とそれに対応するディレクトリのマッピング
    extension_dirs = {
        ".txt": "documents",
        ".docx": "documents",
        ".pdf": "documents",
        ".jpg": "images",
        ".png": "images",
        ".mp3": "music",
        ".mp4": "videos"
    }

    # 分類されたファイルの数を追跡
    organized_count = 0

    for filename in os.listdir(source_dir):
        # ファイルの完全なパスを取得
        file_path = os.path.join(source_dir, filename)

        # ディレクトリの場合はスキップ
        if os.path.isdir(file_path):
            continue

        # ファイルの拡張子を取得
        file_extension = os.path.splitext(filename)[1].lower()

        # 拡張子に基づいて適切なディレクトリを決定
        if file_extension in extension_dirs:
            destination_dir = os.path.join(source_dir, extension_dirs[file_extension])
        else:
            destination_dir = os.path.join(source_dir, "others")

        # 移動先ディレクトリが存在しない場合は作成
        os.makedirs(destination_dir, exist_ok=True)

        # ファイルを移動
        destination_path = os.path.join(destination_dir, filename)
        shutil.move(file_path, destination_path)
        organized_count += 1

        print(f"移動しました: {filename} → {destination_dir}")

    print(f"合計 {organized_count} 個のファイルを整理しました。")

# 使用例
source_directory = "messy_directory"

# サンプルファイルの作成
os.makedirs(source_directory, exist_ok=True)
open(os.path.join(source_directory, "document.txt"), "w").close()
open(os.path.join(source_directory, "image.jpg"), "w").close()
open(os.path.join(source_directory, "song.mp3"), "w").close()

# ファイル整理の実行
organize_files(source_directory)

移動しました: document.txt → messy_directory/documents
移動しました: image.jpg → messy_directory/images
移動しました: song.mp3 → messy_directory/music
合計 3 個のファイルを整理しました。

import os
import shutil
import hashlib
import time

def calculate_checksum(file_path, chunk_size=8192):
    sha256_hash = hashlib.sha256()
    with open(file_path, "rb") as f:
        for byte_block in iter(lambda: f.read(chunk_size), b""):
            sha256_hash.update(byte_block)
    return sha256_hash.hexdigest()

def copy_large_file(src, dst, chunk_size=1024*1024):
    total_size = os.path.getsize(src)
    copied_size = 0
    start_time = time.time()

    with open(src, 'rb') as fsrc, open(dst, 'wb') as fdst:
        while True:
            chunk = fsrc.read(chunk_size)
            if not chunk:
                break
            fdst.write(chunk)
            copied_size += len(chunk)
            progress = (copied_size / total_size) * 100
            elapsed_time = time.time() - start_time
            speed = copied_size / (1024 * 1024 * elapsed_time)
            print(f"\r進捗: {progress:.2f}% ({copied_size}/{total_size} バイト) "
                  f"速度: {speed:.2f} MB/s", end="", flush=True)

    print("\nコピー完了")

    # チェックサムの検証
    src_checksum = calculate_checksum(src)
    dst_checksum = calculate_checksum(dst)

    if src_checksum == dst_checksum:
        print("チェックサム検証成功：ファイルは正常にコピーされました。")
    else:
        print("チェックサム検証失敗：ファイルのコピー中にエラーが発生した可能性があります。")

# 使用例
source_file = "large_file.bin"
destination_file = "copied_large_file.bin"

# サンプルの大きなファイルを作成
file_size = 100 * 1024 * 1024  # 100MB
with open(source_file, "wb") as f:
    f.write(os.urandom(file_size))

print(f"{file_size/(1024*1024):.2f}MBのファイルを作成しました。")
print("大規模ファイル転送を開始します...")

copy_large_file(source_file, destination_file)

# クリーンアップ
os.remove(source_file)
os.remove(destination_file)

100.00MBのファイルを作成しました。
大規模ファイル転送を開始します...
進捗: 100.00% (104857600/104857600 バイト) 速度: 56.23 MB/s
コピー完了
チェックサム検証成功：ファイルは正常にコピーされました。