5 эффективных методов копирования файлов в Python: полное руководство

import shutil

# Простое копирование содержимого файла
shutil.copyfile('source.txt', 'destination.txt')

# Копирование файла с сохранением режима доступа
shutil.copy('source.txt', 'destination.txt')

# Копирование файла в директорию, сохраняя исходное имя
shutil.copy('source.txt', '/path/to/directory/')

try:
shutil.copy('source.txt', 'destination.txt')
except FileNotFoundError:
print("Исходный файл не найден")
except PermissionError:
print("Недостаточно прав для копирования")
except shutil.SameFileError:
print("Исходный и целевой файлы совпадают")
except Exception as e:
print(f"Произошла ошибка: {e}")

import os
import shutil

source_file = 'source.txt'
destination_file = 'destination.txt'

if os.path.exists(source_file):
if os.path.exists(destination_file):
print("Целевой файл будет перезаписан!")
shutil.copy(source_file, destination_file)
print("Файл успешно скопирован")
else:
print("Исходный файл не существует")

import shutil

# Копирование с сохранением всех метаданных
result = shutil.copy2('config.json', 'config.backup.json')
print(f"Файл скопирован в: {result}")

# Рекурсивное копирование директории
shutil.copytree('source_dir', 'backup_dir')

# Копирование с игнорированием определенных файлов
shutil.copytree('source_dir', 'backup_dir', ignore=shutil.ignore_patterns('*.pyc', '*.tmp', '.git'))

# Python 3.8+ – копирование в существующую директорию
shutil.copytree('source_dir', 'existing_dir', dirs_exist_ok=True)

import shutil
import os

target_dir = 'backup_dir'
if os.path.exists(target_dir):
shutil.rmtree(target_dir)
shutil.copytree('source_dir', target_dir)

def custom_copy(src, dst):
try:
return shutil.copy2(src, dst)
except PermissionError:
print(f"Пропускаю файл с ограниченными правами: {src}")
return dst

# Копирование с использованием кастомной функции
shutil.copytree('source_dir', 'backup_dir', copy_function=custom_copy)

def manual_copy(source, destination, buffer_size=1024*1024):
"""
Копирует файл с указанным размером буфера

Args:
source: путь к исходному файлу
destination: путь к целевому файлу
buffer_size: размер буфера в байтах (по умолчанию 1MB)
"""
with open(source, 'rb') as src:
with open(destination, 'wb') as dst:
while True:
buffer = src.read(buffer_size)
if not buffer:
break
dst.write(buffer)

# Использование
manual_copy('large_file.dat', 'large_file_copy.dat')

def manual_copy_with_progress(source, destination, buffer_size=1024*1024):
file_size = os.path.getsize(source)
copied = 0

with open(source, 'rb') as src:
with open(destination, 'wb') as dst:
while True:
buffer = src.read(buffer_size)
if not buffer:
break
dst.write(buffer)
copied += len(buffer)
percent = int(copied * 100 / file_size)
print(f"\rПрогресс: {percent}% [{copied}/{file_size} байт]", end="")
print() # Новая строка после завершения

from pathlib import Path

def pathlib_copy(source, destination):
source_path = Path(source)
dest_path = Path(destination)

# Чтение исходного файла целиком и запись в целевой
dest_path.write_bytes(source_path.read_bytes())

# Копирование атрибутов файла (опционально)
os.chmod(destination, os.stat(source).st_mode)

# Использование
pathlib_copy('config.ini', 'config_copy.ini')

from pathlib import Path

def pathlib_buffered_copy(source, destination, buffer_size=1024*1024):
source_path = Path(source)
dest_path = Path(destination)

with source_path.open('rb') as src:
with dest_path.open('wb') as dst:
while True:
buffer = src.read(buffer_size)
if not buffer:
break
dst.write(buffer)

from pathlib import Path
import os
import shutil
import time

def smart_copy(source, destination, preserve_metadata=True, 
buffer_size=4*1024*1024, overwrite=True):
"""
Умное копирование файла с контролем метаданных и буферизацией

Args:
source: путь к исходному файлу
destination: путь к целевому файлу
preserve_metadata: сохранять ли метаданные файла
buffer_size: размер буфера для копирования
overwrite: перезаписывать ли существующий файл
"""
src_path = Path(source)
dst_path = Path(destination)

# Проверка существования исходного файла
if not src_path.exists():
raise FileNotFoundError(f"Исходный файл не найден: {source}")

# Проверка на перезапись
if dst_path.exists() and not overwrite:
raise FileExistsError(f"Целевой файл уже существует: {destination}")

# Проверка, что это не один и тот же файл
if os.path.samefile(src_path, dst_path):
raise shutil.SameFileError("Исходный и целевой файлы идентичны")

# Создание промежуточных директорий
dst_path.parent.mkdir(parents=True, exist_ok=True)

# Копирование содержимого с буферизацией
start_time = time.time()

with src_path.open('rb') as src:
with dst_path.open('wb') as dst:
while True:
buffer = src.read(buffer_size)
if not buffer:
break
dst.write(buffer)

# Копирование метаданных, если требуется
if preserve_metadata:
src_stat = os.stat(src_path)
os.utime(dst_path, (src_stat.st_atime, src_stat.st_mtime))
os.chmod(dst_path, src_stat.st_mode)

duration = time.time() – start_time
size_mb = src_path.stat().st_size / (1024 * 1024)
speed_mbps = size_mb / duration if duration > 0 else 0

return {
"source": str(src_path),
"destination": str(dst_path),
"size_mb": size_mb,
"time_seconds": duration,
"speed_mbps": speed_mbps
}

import shutil
import glob
import os

def copy_files_by_pattern(source_dir, dest_dir, pattern="*.txt"):
"""
Копирует все файлы, соответствующие шаблону, из исходной директории в целевую
"""
# Создаем целевую директорию, если не существует
os.makedirs(dest_dir, exist_ok=True)

# Получаем список файлов по шаблону
matched_files = glob.glob(os.path.join(source_dir, pattern))

# Копируем каждый файл
for file_path in matched_files:
filename = os.path.basename(file_path)
destination = os.path.join(dest_dir, filename)
shutil.copy2(file_path, destination)
print(f"Скопирован файл: {filename}")

return len(matched_files)

# Пример использования
count = copy_files_by_pattern("./data", "./backup", "*.csv")
print(f"Всего скопировано файлов: {count}")

import os
import shutil
import datetime

def advanced_batch_copy(source_dir, dest_dir, 
file_types=None, 
date_after=None,
min_size=None,
max_size=None,
rename_pattern=None,
recursive=False):
"""
Расширенное копирование файлов с фильтрацией по типу, размеру, дате и возможностью переименования

Args:
source_dir: исходная директория
dest_dir: целевая директория
file_types: список расширений файлов для копирования (например, ['.jpg', '.png'])
date_after: копировать файлы, созданные после указанной даты (datetime объект)
min_size: минимальный размер файла в байтах
max_size: максимальный размер файла в байтах
rename_pattern: шаблон для переименования (например, 'backup_{filename}')
recursive: рекурсивное копирование вложенных директорий
"""
copied_count = 0

# Создаем целевую директорию
os.makedirs(dest_dir, exist_ok=True)

# Функция для обработки каждого файла
def process_file(file_path, relative_path=""):
nonlocal copied_count

# Получаем информацию о файле
filename = os.path.basename(file_path)
file_stat = os.stat(file_path)
file_size = file_stat.st_size
file_mtime = datetime.datetime.fromtimestamp(file_stat.st_mtime)
file_ext = os.path.splitext(filename)[1].lower()

# Проверяем соответствие фильтрам
if file_types and file_ext not in file_types:
return

if min_size and file_size < min_size:
return

if max_size and file_size > max_size:
return

if date_after and file_mtime < date_after:
return

# Определяем имя файла в целевой директории
if rename_pattern:
new_filename = rename_pattern.format(
filename=filename,
basename=os.path.splitext(filename)[0],
ext=file_ext,
date=file_mtime.strftime('%Y%m%d'),
size=file_size
)
else:
new_filename = filename

# Создаем целевую структуру директорий при рекурсивном копировании
if recursive and relative_path:
target_dir = os.path.join(dest_dir, relative_path)
os.makedirs(target_dir, exist_ok=True)
dest_path = os.path.join(target_dir, new_filename)
else:
dest_path = os.path.join(dest_dir, new_filename)

# Копируем файл
shutil.copy2(file_path, dest_path)
copied_count += 1
print(f"Скопирован: {file_path} -> {dest_path}")

# Обход директорий
if recursive:
for root, dirs, files in os.walk(source_dir):
relative_path = os.path.relpath(root, source_dir)
if relative_path == '.':
relative_path = ''

for filename in files:
file_path = os.path.join(root, filename)
process_file(file_path, relative_path)
else:
for filename in os.listdir(source_dir):
file_path = os.path.join(source_dir, filename)
if os.path.isfile(file_path):
process_file(file_path)

return copied_count

# Копирование только изображений
advanced_batch_copy('./photos', './backup/images', 
file_types=['.jpg', '.png', '.gif'])

# Копирование файлов больше 1MB, созданных за последнюю неделю
week_ago = datetime.datetime.now() – datetime.timedelta(days=7)
advanced_batch_copy('./documents', './recent_large_docs', 
min_size=1024*1024,
date_after=week_ago)

# Рекурсивное копирование с переименованием
advanced_batch_copy('./project', './backup/project_files', 
recursive=True,
rename_pattern='backup_{date}_{filename}')

import shutil
import os
from tqdm import tqdm

def copy_with_progress(source_dir, dest_dir, pattern="*"):
"""
Копирование файлов с отображением прогресса
"""
import glob

# Получаем список файлов
files = glob.glob(os.path.join(source_dir, pattern))

# Создаем директорию назначения
os.makedirs(dest_dir, exist_ok=True)

# Копируем с отображением прогресса
for file_path in tqdm(files, desc="Копирование файлов", unit="файл"):
filename = os.path.basename(file_path)
dest_path = os.path.join(dest_dir, filename)
shutil.copy2(file_path, dest_path)

return len(files)

import schedule
import time
import os
import datetime
import shutil

def daily_backup():
"""Ежедневное резервное копирование важных данных"""
today = datetime.datetime.now().strftime('%Y%m%d')
backup_dir = f"./backups/daily_{today}"

print(f"Запуск ежедневного резервного копирования в {backup_dir}...")
# Здесь используем любую функцию копирования из примеров выше
copy_files_by_pattern("./important_data", backup_dir)

# Очистка старых бэкапов (оставляем только за последние 7 дней)
cleanup_old_backups("./backups", 7)

def cleanup_old_backups(backup_root, keep_days):
"""Удаляет старые резервные копии, оставляя только за указанное количество дней"""
cutoff_date = datetime.datetime.now() – datetime.timedelta(days=keep_days)

for item in os.listdir(backup_root):
item_path = os.path.join(backup_root, item)
if os.path.isdir(item_path) and item.startswith('daily_'):
try:
# Извлекаем дату из имени директории
date_str = item.replace('daily_', '')
backup_date = datetime.datetime.strptime(date_str, '%Y%m%d')

# Удаляем старые резервные копии
if backup_date < cutoff_date:
print(f"Удаление устаревшей резервной копии: {item}")
shutil.rmtree(item_path)
except (ValueError, Exception) as e:
print(f"Ошибка при обработке {item}: {e}")

# Настройка расписания
schedule.every().day.at("23:00").do(daily_backup)

# Запуск планировщика
print("Планировщик резервного копирования запущен...")
while True:
schedule.run_pending()
time.sleep(60)