Модуль shutil в Python: мощные инструменты для работы с файлами

import shutil

# Теперь все функции доступны через префикс shutil
shutil.copy('source.txt', 'destination.txt')

import shutil
import os

# Простое копирование файла
shutil.copy('document.txt', 'backup/document.txt')

# Копирование с сохранением метаданных
shutil.copy2('important_log.txt', 'archive/important_log_backup.txt')

# Копирование только содержимого
shutil.copyfile('data.csv', 'processed/data_copy.csv')

# Копирование прав доступа к файлу
shutil.copymode('executable.py', 'scripts/new_executable.py')

# Копирование только статусной информации
shutil.copystat('reference.json', 'output/reference_new.json')

# Перемещение файла в новое расположение
shutil.move('project_draft.docx', 'completed_projects/')

# Перемещение с переименованием
shutil.move('temp_file.txt', 'organized/renamed_file.txt')

# Перемещение нескольких файлов в цикле
files_to_move = ['data1.csv', 'data2.csv', 'data3.csv']
for file in files_to_move:
destination = os.path.join('archive', f'processed_{file}')
shutil.move(file, destination)
print(f"Переместил {file} в {destination}")

import shutil
import os
import glob

# Копирование всех .txt файлов из директории
for file in glob.glob('source_dir/*.txt'):
filename = os.path.basename(file)
shutil.copy2(file, f'destination_dir/{filename}')

# Перемещение файлов с определенным префиксом
for file in os.listdir('temp_files'):
if file.startswith('report_'):
shutil.move(f'temp_files/{file}', f'reports/{file}')

with open('large_file.bin', 'rb') as fsrc:
with open('large_file_copy.bin', 'wb') as fdst:
shutil.copyfileobj(fsrc, fdst, length=1024*1024) # Копирование с буфером 1MB

import shutil
import os

# Копирование всей директории со всем содержимым
shutil.copytree('project_v1', 'project_v1_backup')

# Копирование с игнорированием определённых файлов
def ignore_pyc_files(dir, files):
return [f for f in files if f.endswith('.pyc') or f.endswith('.tmp')]

shutil.copytree('source_code', 'source_code_clean', ignore=ignore_pyc_files)

# Копирование директории с сохранением символических ссылок
shutil.copytree('linked_project', 'linked_project_copy', symlinks=True)

# Удаление директории со всем содержимым
try:
shutil.rmtree('temp_files')
print("Директория успешно удалена")
except FileNotFoundError:
print("Директория не существует")
except PermissionError:
print("Недостаточно прав для удаления")

# Удаление с дополнительной обработкой ошибок
def handle_remove_readonly(func, path, exc):
import stat
if func in (os.rmdir, os.remove, os.unlink) and exc[1].errno == 13:
os.chmod(path, stat.S_IWRITE)
func(path)
else:
raise exc[1]

shutil.rmtree('locked_directory', onerror=handle_remove_readonly)

# Создание архива из директории
shutil.make_archive('project_backup', 'zip', 'project_dir')

# Создание сжатого tar-архива
shutil.make_archive('data_backup', 'gztar', 'data_dir')

# Распаковка архива
shutil.unpack_archive('project_backup.zip', 'unpacked_project')

# Проверка доступных форматов архивов
print(shutil.get_archive_formats())

import shutil
import os
import datetime

# Создание резервной копии с временной меткой
timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
backup_dir = f"backup_{timestamp}"
os.makedirs(backup_dir, exist_ok=True)

# Копирование только новых или измененных файлов
def selective_copy(src, dst):
for item in os.listdir(src):
src_path = os.path.join(src, item)
dst_path = os.path.join(dst, item)

if os.path.isdir(src_path):
if not os.path.exists(dst_path):
os.makedirs(dst_path)
selective_copy(src_path, dst_path)
else:
if not os.path.exists(dst_path) or \
os.path.getmtime(src_path) > os.path.getmtime(dst_path):
shutil.copy2(src_path, dst_path)
print(f"Копирую: {src_path} -> {dst_path}")

selective_copy('project_files', backup_dir)

# Архивирование результата
shutil.make_archive(f"backup_{timestamp}", 'zip', backup_dir)
shutil.rmtree(backup_dir) # Удаление временной директории

# Получение информации о диске
total, used, free = shutil.disk_usage('/')

print(f"Всего: {total // (2**30)} ГБ")
print(f"Использовано: {used // (2**30)} ГБ")
print(f"Свободно: {free // (2**30)} ГБ")

# Проверка перед операциями с большими файлами
if free < 1 * (2**30): # Меньше 1 ГБ
print("Недостаточно места на диске!")
else:
shutil.copytree('large_project', 'large_project_backup')

import shutil
import os
import time

# Оптимизированное копирование больших файлов
def optimized_copy(src, dst, buffer_size=10*1024*1024): # 10MB буфер
start = time.time()
with open(src, 'rb') as fsrc:
with open(dst, 'wb') as fdst:
shutil.copyfileobj(fsrc, fdst, buffer_size)
duration = time.time() – start
size_mb = os.path.getsize(src) / (1024 * 1024)
print(f"Скопировано {size_mb:.2f} MB за {duration:.2f} секунд ({size_mb/duration:.2f} MB/s)")

# Пример использования
optimized_copy('large_dataset.bin', 'backup/large_dataset_copy.bin')

import shutil
import os
import sys

def copy_with_progress(src, dst):
total_size = os.path.getsize(src)
copied = 0

with open(src, 'rb') as fsrc:
with open(dst, 'wb') as fdst:
while True:
buf = fsrc.read(1024 * 1024) # 1MB буфер
if not buf:
break
fdst.write(buf)
copied += len(buf)
percent = int(copied * 100 / total_size)
sys.stdout.write(f"\rПрогресс: [{('=' * (percent // 5)).ljust(20)}] {percent}%")
sys.stdout.flush()
print("\nКопирование завершено!")

# Использование
copy_with_progress('video_file.mp4', 'backup/video_file_copy.mp4')

import shutil
import os
import concurrent.futures
import time

def copy_file(src_dst_tuple):
src, dst = src_dst_tuple
try:
shutil.copy2(src, dst)
return (True, src, dst, "Успешно скопировано")
except Exception as e:
return (False, src, dst, str(e))

def parallel_copy(file_list, max_workers=4):
start = time.time()
with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
results = list(executor.map(copy_file, file_list))

success = [r for r in results if r[0]]
failures = [r for r in results if not r[0]]

print(f"Копирование завершено за {time.time() – start:.2f} секунд")
print(f"Успешно: {len(success)}, Ошибок: {len(failures)}")

if failures:
print("\nОшибки копирования:")
for _, src, dst, error in failures:
print(f"{src} -> {dst}: {error}")

return success, failures

# Пример использования
files_to_copy = [
('docs/doc1.pdf', 'backup/doc1.pdf'),
('docs/doc2.pdf', 'backup/doc2.pdf'),
# ... больше файлов
]

parallel_copy(files_to_copy, max_workers=8)

import shutil
import os
import zipfile
import py7zr

# Создание ZIP-архива с паролем
def create_protected_zip(source_dir, output_zip, password):
with zipfile.ZipFile(output_zip, 'w', zipfile.ZIP_DEFLATED) as zipf:
for root, dirs, files in os.walk(source_dir):
for file in files:
file_path = os.path.join(root, file)
arcname = os.path.relpath(file_path, source_dir)
zipf.write(file_path, arcname=arcname)

# Применение пароля (требует установки библиотеки pyzipper)
# import pyzipper
# with pyzipper.AESZipFile(...) as zipf:
# zipf.setpassword(password.encode())

print(f"Создан защищенный архив: {output_zip}")

# Создание сильно сжатого 7z архива
def create_7z_archive(source_dir, output_file):
with py7zr.SevenZipFile(output_file, 'w') as archive:
archive.writeall(source_dir)
print(f"Создан 7z архив: {output_file}")

# Пример использования
create_protected_zip('confidential_data', 'confidential_data.zip', 'strong_password123')
create_7z_archive('large_dataset', 'large_dataset_compressed.7z')

import shutil
import os
import tempfile
import contextlib

@contextlib.contextmanager
def safe_edit_file(filepath):
"""Контекстный менеджер для безопасного редактирования файлов."""
# Создаем временную директорию
temp_dir = tempfile.mkdtemp()
temp_path = os.path.join(temp_dir, os.path.basename(filepath))

try:
# Копируем файл во временное место
if os.path.exists(filepath):
shutil.copy2(filepath, temp_path)

# Предоставляем временный путь для редактирования
yield temp_path

# Если не было исключений, копируем обратно
shutil.copy2(temp_path, filepath)
finally:
# Всегда очищаем временную директорию
shutil.rmtree(temp_dir)

# Пример использования
with safe_edit_file('important_config.json') as temp_file:
# Редактирование файла без риска повреждения оригинала
with open(temp_file, 'w') as f:
f.write('{"updated": true, "version": 2}')
# При выходе из блока изменения безопасно применятся

import shutil
import os
import logging
import time

# Настройка логирования
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s – %(name)s – %(levelname)s – %(message)s',
handlers=[
logging.FileHandler('file_operations.log'),
logging.StreamHandler()
]
)
logger = logging.getLogger('shutil_operations')

def monitored_copytree(src, dst, **kwargs):
"""Функция копирования директории с мониторингом и логированием."""
start_time = time.time()
total_size = 0
file_count = 0

for root, _, files in os.walk(src):
for file in files:
total_size += os.path.getsize(os.path.join(root, file))
file_count += 1

logger.info(f"Начинаю копирование {src} -> {dst}")
logger.info(f"Всего файлов: {file_count}, общий размер: {total_size/(1024*1024):.2f} MB")

try:
shutil.copytree(src, dst, **kwargs)
duration = time.time() – start_time
logger.info(f"Копирование завершено успешно за {duration:.2f} секунд")
logger.info(f"Средняя скорость: {total_size/(1024*1024*duration):.2f} MB/s")
return True
except Exception as e:
logger.error(f"Ошибка копирования: {str(e)}")
return False

# Использование
monitored_copytree('project_data', 'backup/project_data', dirs_exist_ok=True)