Управление ZIP-архивами в Python: работа с модулем zipfile

import zipfile

import zipfile
print(f"Используется zipfile версии {zipfile.__version__}")

import zipfile

# Создание нового архива
with zipfile.ZipFile('example.zip', 'w') as zip_file:
# Здесь будем добавлять файлы в архив
pass

import zipfile

with zipfile.ZipFile('example.zip', 'w') as zip_file:
# Добавление одного файла
zip_file.write('document.txt')

# Добавление файла с другим именем внутри архива
zip_file.write('config.ini', arcname='settings/config.ini')

import zipfile

with zipfile.ZipFile('compressed.zip', 'w', compression=zipfile.ZIP_DEFLATED, compresslevel=9) as zip_file:
zip_file.write('large_file.txt')

# Для файлов, которые уже сжаты (изображения, видео)
with zipfile.ZipFile('media.zip', 'w', compression=zipfile.ZIP_STORED) as zip_file:
zip_file.write('video.mp4')

import os
import zipfile

def zip_directory(path, zip_handle):
# Перебираем все файлы и папки
for root, dirs, files in os.walk(path):
for file in files:
# Формируем полный путь к файлу
file_path = os.path.join(root, file)
# Вычисляем относительный путь для сохранения структуры
arcname = os.path.relpath(file_path, os.path.dirname(path))
# Добавляем файл в архив
zip_handle.write(file_path, arcname)

# Пример использования
with zipfile.ZipFile('project_backup.zip', 'w', compression=zipfile.ZIP_DEFLATED) as zip_file:
zip_directory('my_project', zip_file)

import zipfile

with zipfile.ZipFile('generated.zip', 'w') as zip_file:
# Добавление строки как файл
zip_file.writestr('hello.txt', 'Hello, world!')

# Добавление данных с использованием ZipInfo для указания метаданных
info = zipfile.ZipInfo('timestamp.txt')
info.date_time = (2023, 10, 15, 12, 30, 0) # Установка даты и времени
info.compress_type = zipfile.ZIP_DEFLATED
zip_file.writestr(info, 'Generated at 12:30')

import zipfile

with zipfile.ZipFile('example.zip', 'r') as zip_file:
# Получение списка всех файлов и директорий в архиве
file_list = zip_file.namelist()
print(f"В архиве содержится {len(file_list)} элементов:")
for filename in file_list:
print(f" – {filename}")

# Получение подробной информации о файле
info = zip_file.getinfo('document.txt')
print(f"Размер до сжатия: {info.file_size} байт")
print(f"Сжатый размер: {info.compress_size} байт")
ratio = (info.file_size – info.compress_size) / info.file_size * 100
print(f"Степень сжатия: {ratio:.1f}%")
print(f"Дата изменения: {info.date_time}")

import zipfile

with zipfile.ZipFile('example.zip', 'r') as zip_file:
# Извлечение всех файлов в текущую директорию
zip_file.extractall()

# Извлечение в указанную директорию
zip_file.extractall('extracted_files')

# Извлечение только определённых файлов
zip_file.extractall(members=['document.txt', 'images/photo.jpg'])

# Извлечение с обработкой паролей
zip_file.extractall(pwd=b'secret_password')

import zipfile

with zipfile.ZipFile('example.zip', 'r') as zip_file:
# Извлечение одного файла в текущую директорию
zip_file.extract('document.txt')

# Извлечение файла в указанную директорию
zip_file.extract('document.txt', 'output')

# Извлечение зашифрованного файла
zip_file.extract('secure_data.dat', pwd=b'secret_password')

import zipfile

with zipfile.ZipFile('example.zip', 'r') as zip_file:
# Чтение текстового файла
text_data = zip_file.read('document.txt').decode('utf-8')
print(f"Содержимое document.txt: {text_data[:50]}...")

# Чтение зашифрованного файла
secure_data = zip_file.read('secure_data.dat', pwd=b'secret_password')

# Открытие файла как файлоподобного объекта
with zip_file.open('config.ini') as config_file:
for line in config_file:
print(line.decode('utf-8').strip())

import zipfile

try:
with zipfile.ZipFile('example.zip', 'r') as zip_file:
# Проверка всех файлов в архиве
test_result = zip_file.testzip()

if test_result is not None:
print(f"Архив поврежден. Проблемный файл: {test_result}")
else:
print("Архив не содержит ошибок.")
# Продолжаем извлечение или чтение
except zipfile.BadZipFile:
print("Файл не является ZIP-архивом или сильно поврежден.")

import zipfile
import os

with zipfile.ZipFile('example.zip', 'r') as zip_file:
# Получаем список всех файлов
all_files = zip_file.namelist()

# Фильтруем только текстовые файлы
text_files = [f for f in all_files if f.endswith('.txt')]

# Фильтруем файлы по директории
image_files = [f for f in all_files if f.startswith('images/')]

# Извлекаем только текстовые файлы
zip_file.extractall(members=text_files, path='text_only')

import zipfile
import os

def create_self_extracting_script(zip_path, output_script):
"""Создаёт Python-скрипт для автоматической распаковки архива"""
script_content = f'''
import zipfile
import os
import sys

def extract():
zip_path = os.path.join(os.path.dirname(sys.argv[0]), "{os.path.basename(zip_path)}")
extract_dir = input("Введите путь для распаковки [текущая директория]: ").strip()

if not extract_dir:
extract_dir = os.getcwd()

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

print(f"Распаковка архива {zip_path} в {extract_dir}...")

try:
with zipfile.ZipFile(zip_path, 'r') as zip_file:
zip_file.extractall(extract_dir)
print("Распаковка завершена успешно!")
except Exception as e:
print(f"Ошибка распаковки: {{e}}")

if __name__ == "__main__":
extract()
'''

with open(output_script, 'w') as f:
f.write(script_content)

print(f"Скрипт самораспаковки создан: {output_script}")

# Пример использования
create_self_extracting_script('project_data.zip', 'extract_project.py')

import zipfile

# Чтение многотомного архива
with zipfile.ZipFile('archive.zip.001', 'r') as zip_file:
# zipfile автоматически объединяет тома
print(zip_file.namelist())

# Извлечение как обычно
zip_file.extractall('extracted')

import zipfile

# Добавление комментария к архиву
with zipfile.ZipFile('commented.zip', 'w') as zip_file:
zip_file.comment = b"Архив создан с помощью Python zipfile"

# Добавление файла с комментарием
info = zipfile.ZipInfo('data.txt')
info.comment = b"Важные данные"
zip_file.writestr(info, "Содержимое файла")

# Чтение комментариев
with zipfile.ZipFile('commented.zip', 'r') as zip_file:
print(f"Комментарий архива: {zip_file.comment.decode('utf-8')}")

for filename in zip_file.namelist():
file_info = zip_file.getinfo(filename)
if file_info.comment:
print(f"Комментарий к {filename}: {file_info.comment.decode('utf-8')}")

import zipfile
import time
import datetime

# Создаем ZipInfo объект с настраиваемыми атрибутами
info = zipfile.ZipInfo('custom_file.txt')

# Устанавливаем время создания (год, месяц, день, час, минута, секунда)
info.date_time = datetime.datetime.now().timetuple()[:6]

# Устанавливаем права доступа к файлу (для Unix/Linux)
# 0o644 соответствует rw-r--r--
info.external_attr = 0o644 << 16 

# Устанавливаем метод сжатия
info.compress_type = zipfile.ZIP_DEFLATED
info.compress_size = 0 # Будет обновлено автоматически

with zipfile.ZipFile('metadata_example.zip', 'w') as zip_file:
# Добавляем файл с настроенными метаданными
zip_file.writestr(info, "Содержимое файла с настроенными метаданными")

import zipfile
import os

def process_large_zip(zip_path, process_function, chunk_size=8192):
"""
Обрабатывает большие файлы в ZIP-архиве с минимальным использованием памяти.

:param zip_path: путь к ZIP-архиву
:param process_function: функция для обработки содержимого файла
:param chunk_size: размер читаемого блока данных
"""
with zipfile.ZipFile(zip_path, 'r') as zip_file:
for filename in zip_file.namelist():
# Пропускаем директории
if filename.endswith('/'):
continue

print(f"Обработка {filename}...")

# Открываем файл в архиве
with zip_file.open(filename) as file:
# Обрабатываем данные блоками
while True:
chunk = file.read(chunk_size)
if not chunk:
break

# Применяем функцию обработки к блоку данных
process_function(filename, chunk)

# Пример функции обработки
def count_bytes(filename, data):
print(f"Обработан блок данных из {filename}: {len(data)} байт")

# Использование
process_large_zip('large_archive.zip', count_bytes)

import zipfile
import io

# Создаем объект BytesIO для хранения архива в памяти
memory_zip = io.BytesIO()

# Создаем ZIP-архив в памяти
with zipfile.ZipFile(memory_zip, 'w', zipfile.ZIP_DEFLATED) as zip_file:
# Добавляем файлы в архив
zip_file.writestr('file1.txt', 'Содержимое первого файла')
zip_file.writestr('file2.txt', 'Содержимое второго файла')

# Добавляем данные из файла
with open('data.csv', 'rb') as f:
zip_file.writestr('data_copy.csv', f.read())

# Получаем содержимое архива как байты
memory_zip.seek(0)
zip_bytes = memory_zip.getvalue()

# Можно теперь использовать zip_bytes для отправки через API,
# сохранения в базу данных или для других целей

# Пример: сохранение в файл
with open('memory_generated.zip', 'wb') as f:
f.write(zip_bytes)

import zipfile
import os
import concurrent.futures
import time

def compress_file(file_path, compression_type, compression_level):
"""Сжимает отдельный файл с указанными параметрами и возвращает итоговый размер"""
archive_name = f"{os.path.basename(file_path)}.zip"

start_time = time.time()
with zipfile.ZipFile(archive_name, 'w', compression=compression_type, 
compresslevel=compression_level) as zip_file:
zip_file.write(file_path, os.path.basename(file_path))

compression_time = time.time() – start_time
compressed_size = os.path.getsize(archive_name)
original_size = os.path.getsize(file_path)

compression_ratio = (original_size – compressed_size) / original_size * 100

return {
'file': file_path,
'original_size': original_size,
'compressed_size': compressed_size,
'ratio': compression_ratio,
'time': compression_time
}

# Сравнение разных методов сжатия
files_to_compress = ['large_text.txt', 'image.jpg', 'database.db']
compression_types = [
(zipfile.ZIP_STORED, 0, "Без сжатия"),
(zipfile.ZIP_DEFLATED, 1, "Быстрое сжатие"),
(zipfile.ZIP_DEFLATED, 9, "Максимальное сжатие"),
(zipfile.ZIP_BZIP2, 9, "BZIP2"),
(zipfile.ZIP_LZMA, 9, "LZMA")
]

for file_path in files_to_compress:
if os.path.exists(file_path):
print(f"Сравнение методов сжатия для файла: {file_path}")
for comp_type, comp_level, comp_name in compression_types:
try:
result = compress_file(file_path, comp_type, comp_level)
print(f" {comp_name}: {result['ratio']:.1f}% сжатие, {result['time']:.3f} сек")
except Exception as e:
print(f" {comp_name}: ошибка – {str(e)}")

import zipfile
import os

# Создание зашифрованного архива
def create_encrypted_zip(source_dir, zip_name, password):
with zipfile.ZipFile(zip_name, 'w', zipfile.ZIP_DEFLATED) as zip_file:
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, os.path.dirname(source_dir))
# Устанавливаем пароль для шифрования файла
zip_file.write(file_path, arcname)
# Для проверки защищенности
zip_file.setpassword(password)

# Извлечение зашифрованного архива
def extract_encrypted_zip(zip_name, extract_dir, password):
with zipfile.ZipFile(zip_name, 'r') as zip_file:
try:
# Проверяем целостность архива с паролем
bad_file = zip_file.testzip()
if bad_file:
print(f"Обнаружен поврежденный файл: {bad_file}")
return False

# Извлекаем файлы с использованием пароля
zip_file.extractall(path=extract_dir, pwd=password)
return True
except RuntimeError as e:
if "Bad password" in str(e):
print("Неверный пароль для архива")
else:
print(f"Ошибка при извлечении: {e}")
return False
except Exception as e:
print(f"Неожиданная ошибка: {e}")
return False

# Примеры использования
password = b'secret_password123' # Пароль должен быть в байтовом формате
create_encrypted_zip('confidential_data', 'protected.zip', password)
success = extract_encrypted_zip('protected.zip', 'extracted_files', password)

import zipfile
import os

def safe_extract(zip_path, extract_dir, max_size=1024*1024*100, max_files=1000):
"""Безопасное извлечение с проверкой размера и количества файлов"""
with zipfile.ZipFile(zip_path, 'r') as zip_file:
# Проверяем количество файлов
file_list = zip_file.namelist()
if len(file_list) > max_files:
raise ValueError(f"Слишком много файлов в архиве: {len(file_list)} > {max_files}")

# Проверяем потенциальный размер распакованных данных
total_size = sum(info.file_size for info in zip_file.infolist())
if total_size > max_size:
raise ValueError(f"Потенциальный размер распакованных данных превышает лимит: {total_size} > {max_size}")

# Проверяем коэффициент сжатия на подозрительность
compressed_size = sum(info.compress_size for info in zip_file.infolist() if info.compress_type != zipfile.ZIP_STORED)
if compressed_size > 0 and total_size / compressed_size > 1000:
raise ValueError(f"Подозрительно высокий коэффициент сжатия: {total_size/compressed_size:.2f}")

# Если все проверки прошли успешно, извлекаем архив
zip_file.extractall(extract_dir)
return True

# Пример использования
try:
safe_extract('suspicious.zip', 'safe_extract')
print("Архив успешно и безопасно распакован")
except ValueError as e:
print(f"Предотвращена потенциально опасная операция: {e}")

import zipfile
import os
import logging

# Настройка логирования
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s – %(name)s – %(levelname)s – %(message)s',
filename='zip_operations.log'
)
logger = logging.getLogger('zip_handler')

def robust_zip_operation(operation_func, *args, **kwargs):
"""Обертка для надежного выполнения операций с ZIP-архивами"""
try:
return operation_func(*args, **kwargs)
except zipfile.BadZipFile:
logger.error(f"Файл не является ZIP-архивом или поврежден: {args[0] if args else ''}")
return {"status": "error", "message": "Файл не является ZIP-архивом или поврежден"}
except zipfile.LargeZipFile:
logger.error(f"ZIP-файл превышает поддерживаемый размер: {args[0] if args else ''}")
return {"status": "error", "message": "ZIP-файл слишком большой, используйте ZIP64 формат"}
except RuntimeError as e:
if "Bad password" in str(e):
logger.error("Неверный пароль для зашифрованного архива")
return {"status": "error", "message": "Неверный пароль для архива"}
logger.error(f"Ошибка выполнения: {str(e)}")
return {"status": "error", "message": f"Ошибка выполнения: {str(e)}"}
except PermissionError:
logger.error("Недостаточно прав для работы с файлом")
return {"status": "error", "message": "Недостаточно прав для работы с файлом"}
except OSError as e:
logger.error(f"Ошибка операционной системы: {str(e)}")
return {"status": "error", "message": f"Ошибка операционной системы: {str(e)}"}
except Exception as e:
logger.error(f"Непредвиденная ошибка: {str(e)}")
return {"status": "error", "message": f"Непредвиденная ошибка: {str(e)}"}

# Пример использования
def extract_zip(zip_path, extract_path):
with zipfile.ZipFile(zip_path, 'r') as zip_file:
zip_file.extractall(extract_path)
return {"status": "success", "message": "Архив успешно распакован"}

# Надежное извлечение
result = robust_zip_operation(extract_zip, "example.zip", "extracted_files")
print(result)