Percepatkan `shutil.copytree` !

Bincangkan mempercepatkan shutil.copytree

Tulis di sini

Ini ialah perbincangan tentang , lihat: https://discuss.python.org/t/speed-up-shutil-copytree/62078. Jika anda mempunyai sebarang idea, sila hantar kepada saya!

Latar belakang

shutil ialah moudle yang sangat berguna dalam Python. Anda boleh menemuinya dalam github: https://github.com/python/cpython/blob/master/Lib/shutil.py

shutil.copytree ialah fungsi yang menyalin folder ke folder lain.

Dalam fungsi ini, ia memanggil fungsi _copytree untuk menyalin.

Apa yang _copytree lakukan ?

1. Mengabaikan fail/direktori yang ditentukan.
2. Mencipta direktori destinasi.
3. Menyalin fail atau direktori sambil mengendalikan pautan simbolik.
4. Mengumpul dan akhirnya menimbulkan ralat yang dihadapi (mis., isu kebenaran).
5. Mereplikasi metadata direktori sumber kepada direktori destinasi.

Masalah

_copytree kelajuan tidak begitu pantas apabila bilangan fail besar atau saiz fail besar.

Uji di sini:

import os
import shutil

os.mkdir('test')
os.mkdir('test/source')

def bench_mark(func, *args):
    import time
    start = time.time()
    func(*args)
    end = time.time()
    print(f'{func.__name__} takes {end - start} seconds')
    return end - start

# write in 3000 files
def write_in_5000_files():
    for i in range(5000):
        with open(f'test/source/{i}.txt', 'w') as f:
            f.write('Hello World' + os.urandom(24).hex())
            f.close()

bench_mark(write_in_5000_files)

def copy():
    shutil.copytree('test/source', 'test/destination')

bench_mark(copy)

Hasilnya ialah:

tulis_dalam_5000_fail mengambil masa 4.084963083267212 saat
salinan mengambil masa 27.12768316268921 saat

Apa yang saya lakukan

Multithreading

Saya menggunakan multithread untuk mempercepatkan proses penyalinan. Dan saya menamakan semula fungsi _copytree_single_threaded menambah fungsi baharu _copytree_multithreaded. Berikut ialah copytree_multithreaded:

def _copytree_multithreaded(src, dst, symlinks=False, ignore=None, copy_function=shutil.copy2,
                            ignore_dangling_symlinks=False, dirs_exist_ok=False, max_workers=4):
    """Recursively copy a directory tree using multiple threads."""
    sys.audit("shutil.copytree", src, dst)

    # get the entries to copy
    entries = list(os.scandir(src))

    # make the pool
    with ThreadPoolExecutor(max_workers=max_workers) as executor:
        # submit the tasks
        futures = [
            executor.submit(_copytree_single_threaded, entries=[entry], src=src, dst=dst,
                            symlinks=symlinks, ignore=ignore, copy_function=copy_function,
                            ignore_dangling_symlinks=ignore_dangling_symlinks,
                            dirs_exist_ok=dirs_exist_ok)
            for entry in entries
        ]

        # wait for the tasks
        for future in as_completed(futures):
            try:
                future.result()
            except Exception as e:
                print(f"Failed to copy: {e}")
                raise

Saya menambah pertimbangan untuk memilih menggunakan multithread atau tidak.

if len(entries) >= 100 or sum(os.path.getsize(entry.path) for entry in entries) >= 100*1024*1024:
        # multithreaded version
        return _copytree_multithreaded(src, dst, symlinks=symlinks, ignore=ignore,
                                        copy_function=copy_function,
                                        ignore_dangling_symlinks=ignore_dangling_symlinks,
                                        dirs_exist_ok=dirs_exist_ok)

else:
    # single threaded version
    return _copytree_single_threaded(entries=entries, src=src, dst=dst,
                                        symlinks=symlinks, ignore=ignore,
                                        copy_function=copy_function,
                                        ignore_dangling_symlinks=ignore_dangling_symlinks,
                                        dirs_exist_ok=dirs_exist_ok)

Ujian

Saya menulis 50000 fail dalam folder sumber. Tanda Aras:

def bench_mark(func, *args):
    import time
    start = time.perf_counter()
    func(*args)
    end = time.perf_counter()
    print(f"{func.__name__} costs {end - start}s")

Tulis dalam:

import os
os.mkdir("Test")
os.mkdir("Test/source")

# write in 50000 files
def write_in_file():
    for i in range(50000):
         with open(f"Test/source/{i}.txt", 'w') as f:
             f.write(f"{i}")
             f.close()

Dua membandingkan:

def copy1():
    import shutil
    shutil.copytree('test/source', 'test/destination1')

def copy2():
    import my_shutil
    my_shutil.copytree('test/source', 'test/destination2')

• "my_shutil" ialah versi shutil saya yang diubah suai.

kos salinan1 173.04780609999943s
kos copy2 155.81321870000102s

copy2 lebih cepat daripada copy1 banyak. Anda boleh berlari banyak kali.

Kelebihan & Kekurangan

Gunakan multithread boleh mempercepatkan proses penyalinan. Tetapi ia akan meningkatkan penggunaan memori. Tetapi kita tidak perlu menulis semula berbilang benang dalam kod.

Async

Terima kasih kepada "Barry Scott". Saya akan mengikut cadangan beliau :

Anda mungkin mendapat peningkatan yang sama untuk kurang overhed dengan menggunakan I/O tak segerak.

Saya menulis kod ini:

import os
import shutil
import asyncio
from concurrent.futures import ThreadPoolExecutor
import time


# create directory
def create_target_directory(dst):
    os.makedirs(dst, exist_ok=True)

# copy 1 file
async def copy_file_async(src, dst):
    loop = asyncio.get_event_loop()
    await loop.run_in_executor(None, shutil.copy2, src, dst)

# copy directory
async def copy_directory_async(src, dst, symlinks=False, ignore=None, dirs_exist_ok=False):
    entries = os.scandir(src)
    create_target_directory(dst)

    tasks = []
    for entry in entries:
        src_path = entry.path
        dst_path = os.path.join(dst, entry.name)

        if entry.is_dir(follow_symlinks=not symlinks):
            tasks.append(copy_directory_async(src_path, dst_path, symlinks, ignore, dirs_exist_ok))
        else:
            tasks.append(copy_file_async(src_path, dst_path))

    await asyncio.gather(*tasks)
# choose copy method
def choose_copy_method(entries, src, dst, **kwargs):
    if len(entries) >= 100 or sum(os.path.getsize(entry.path) for entry in entries) >= 100 * 1024 * 1024:
        # async version
        asyncio.run(copy_directory_async(src, dst, **kwargs))
    else:
        # single thread version
        shutil.copytree(src, dst, **kwargs)
# test function
def bench_mark(func, *args):
    start = time.perf_counter()
    func(*args)
    end = time.perf_counter()
    print(f"{func.__name__} costs {end - start:.2f}s")

# write in 50000 files
def write_in_50000_files():
    for i in range(50000):
        with open(f"Test/source/{i}.txt", 'w') as f:
            f.write(f"{i}")

def main():
    os.makedirs('Test/source', exist_ok=True)
    write_in_50000_files()

    # 单线程复制
    def copy1():
        shutil.copytree('Test/source', 'Test/destination1')

    def copy2():
        shutil.copytree('Test/source', 'Test/destination2')

    # async
    def copy3():
        entries = list(os.scandir('Test/source'))
        choose_copy_method(entries, 'Test/source', 'Test/destination3')

    bench_mark(copy1)
    bench_mark(copy2)
    bench_mark(copy3)

    shutil.rmtree('Test')

if __name__ == "__main__":
    main()

Output:

copy1 berharga 187.21s
copy2 berharga 244.33s
copy3 berharga 111.27s

Anda dapat melihat bahawa versi async adalah lebih pantas daripada versi urutan tunggal. Tetapi versi benang tunggal lebih pantas daripada versi berbilang benang. ( Mungkin persekitaran ujian saya tidak begitu baik, anda boleh mencuba dan menghantar keputusan anda sebagai balasan kepada saya )

Terima kasih Barry Scott !

Kelebihan & Kekurangan

Async ialah pilihan yang baik. Tetapi tiada penyelesaian yang sempurna. Jika anda menemui masalah, anda boleh menghantar saya sebagai balasan.

tamat

Ini adalah kali pertama saya menulis perbincangan di python.org. Jika ada sebarang masalah, sila beritahu saya. Terima kasih.

Github Saya: https://github.com/mengqinyuan
Dev.to Saya: https://dev.to/mengqinyuan

Atas ialah kandungan terperinci Percepatkan `shutil.copytree` !. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!