import gzip
import shutil

def basic_gzip_operations():
    """基礎(chǔ)GZIP文件操作"""
    # 創(chuàng)建測試數(shù)據(jù)
    original_data = "這是原始數(shù)據(jù)內(nèi)容\n" * 1000
    print(f"原始數(shù)據(jù)大小: {len(original_data)} 字節(jié)")
    
    # 寫入GZIP文件
    with gzip.open('example.gz', 'wt', encoding='utf-8') as f:
        f.write(original_data)
    print("GZIP文件寫入完成")
    
    # 讀取GZIP文件
    with gzip.open('example.gz', 'rt', encoding='utf-8') as f:
        decompressed_data = f.read()
    
    print(f"解壓后數(shù)據(jù)大小: {len(decompressed_data)} 字節(jié)")
    print(f"數(shù)據(jù)一致性: {original_data == decompressed_data}")
    
    # 檢查壓縮文件信息
    compressed_size = os.path.getsize('example.gz')
    compression_ratio = len(original_data) / compressed_size
    print(f"壓縮文件大小: {compressed_size} 字節(jié)")
    print(f"壓縮比: {compression_ratio:.2f}:1")
    
    # 二進(jìn)制模式讀寫
    binary_data = original_data.encode('utf-8')
    with gzip.open('binary_example.gz', 'wb') as f:
        f.write(binary_data)
    
    with gzip.open('binary_example.gz', 'rb') as f:
        restored_binary = f.read()
        restored_text = restored_binary.decode('utf-8')
    
    print(f"二進(jìn)制模式一致性: {original_data == restored_text}")

# 執(zhí)行示例
basic_gzip_operations()

def multiple_compression_formats():
    """多格式壓縮文件操作"""
    import bz2
    import lzma
    
    test_data = "測試數(shù)據(jù)內(nèi)容" * 500
    print(f"測試數(shù)據(jù)大小: {len(test_data)} 字節(jié)")
    
    # 定義壓縮格式處理器
    compressors = {
        'gzip': {
            'module': gzip,
            'extension': '.gz',
            'description': 'GZIP格式'
        },
        'bzip2': {
            'module': bz2,
            'extension': '.bz2',
            'description': 'BZIP2格式'
        },
        'lzma': {
            'module': lzma,
            'extension': '.xz',
            'description': 'LZMA格式'
        }
    }
    
    results = {}
    
    for name, config in compressors.items():
        # 寫入壓縮文件
        filename = f'example{config["extension"]}'
        
        with config['module'].open(filename, 'wt', encoding='utf-8') as f:
            f.write(test_data)
        
        # 讀取并驗(yàn)證
        with config['module'].open(filename, 'rt', encoding='utf-8') as f:
            decompressed = f.read()
        
        compressed_size = os.path.getsize(filename)
        ratio = len(test_data) / compressed_size
        
        results[name] = {
            'compressed_size': compressed_size,
            'ratio': ratio,
            'consistent': test_data == decompressed
        }
        
        print(f"{config['description']}:")
        print(f"  壓縮大小: {compressed_size} 字節(jié)")
        print(f"  壓縮比: {ratio:.2f}:1")
        print(f"  數(shù)據(jù)一致: {test_data == decompressed}")
    
    # 性能比較
    best_compression = max(results.items(), key=lambda x: x[1]['ratio'])
    print(f"\n最佳壓縮: {best_compression[0]} (壓縮比 {best_compression[1]['ratio']:.2f}:1)")
    
    # 清理文件
    for config in compressors.values():
        filename = f'example{config["extension"]}'
        if os.path.exists(filename):
            os.remove(filename)

# 執(zhí)行示例
multiple_compression_formats()

def compression_level_tuning():
    """壓縮級別性能調(diào)優(yōu)"""
    # 生成測試數(shù)據(jù)
    large_data = "重復(fù)數(shù)據(jù)壓縮測試\n" * 10000
    binary_data = large_data.encode('utf-8')
    
    print(f"原始數(shù)據(jù)大小: {len(binary_data)} 字節(jié)")
    
    # 測試不同壓縮級別
    compression_levels = [1, 6, 9]  # 1=最快, 6=默認(rèn), 9=最佳壓縮
    
    results = []
    
    for level in compression_levels:
        start_time = time.time()
        
        # 使用指定壓縮級別
        with gzip.open(f'level_{level}.gz', 'wb', compresslevel=level) as f:
            f.write(binary_data)
        
        compress_time = time.time() - start_time
        compressed_size = os.path.getsize(f'level_{level}.gz')
        ratio = len(binary_data) / compressed_size
        
        results.append({
            'level': level,
            'size': compressed_size,
            'ratio': ratio,
            'time': compress_time
        })
        
        print(f"級別 {level}: {compressed_size} 字節(jié), 壓縮比 {ratio:.2f}:1, 耗時 {compress_time:.3f}秒")
    
    # 繪制性能圖表
    import matplotlib.pyplot as plt
    
    fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(10, 8))
    
    # 壓縮比圖表
    levels = [r['level'] for r in results]
    ratios = [r['ratio'] for r in results]
    ax1.bar(levels, ratios, color='skyblue')
    ax1.set_xlabel('壓縮級別')
    ax1.set_ylabel('壓縮比')
    ax1.set_title('壓縮級別 vs 壓縮比')
    
    # 耗時圖表
    times = [r['time'] for r in results]
    ax2.bar(levels, times, color='lightcoral')
    ax2.set_xlabel('壓縮級別')
    ax2.set_ylabel('耗時 (秒)')
    ax2.set_title('壓縮級別 vs 耗時')
    
    plt.tight_layout()
    plt.savefig('compression_performance.png')
    print("性能圖表已保存為 compression_performance.png")
    
    # 推薦策略
    best_ratio = max(results, key=lambda x: x['ratio'])
    best_speed = min(results, key=lambda x: x['time'])
    
    print(f"\n最佳壓縮: 級別 {best_ratio['level']} (壓縮比 {best_ratio['ratio']:.2f}:1)")
    print(f"最快壓縮: 級別 {best_speed['level']} (耗時 {best_speed['time']:.3f}秒)")
    
    # 清理文件
    for level in compression_levels:
        filename = f'level_{level}.gz'
        if os.path.exists(filename):
            os.remove(filename)

# 執(zhí)行示例
compression_level_tuning()

def streaming_compression():
    """流式壓縮處理大型數(shù)據(jù)"""
    def generate_large_data(num_records=100000):
        """生成大型測試數(shù)據(jù)"""
        for i in range(num_records):
            yield f"記錄 {i}: 這是測試數(shù)據(jù)內(nèi)容 " * 5 + "\n"
    
    # 流式壓縮寫入
    def stream_compress(filename, data_generator, compression_class=gzip):
        """流式壓縮數(shù)據(jù)"""
        with compression_class.open(filename, 'wt', encoding='utf-8') as f:
            for record in data_generator:
                f.write(record)
                if f.tell() % 1000000 < len(record):  # 每約1MB輸出進(jìn)度
                    print(f"已寫入 {f.tell()} 字節(jié)")
    
    # 流式解壓讀取
    def stream_decompress(filename, compression_class=gzip):
        """流式解壓數(shù)據(jù)"""
        with compression_class.open(filename, 'rt', encoding='utf-8') as f:
            for line in f:
                yield line
    
    # 測試流式處理
    print("開始流式壓縮...")
    start_time = time.time()
    
    # 流式壓縮
    stream_compress('stream_data.gz', generate_large_data(50000))
    compress_time = time.time() - start_time
    
    # 獲取壓縮文件信息
    compressed_size = os.path.getsize('stream_data.gz')
    print(f"壓縮完成: {compressed_size} 字節(jié), 耗時 {compress_time:.2f}秒")
    
    # 流式解壓和處理
    print("開始流式解壓和處理...")
    start_time = time.time()
    
    record_count = 0
    for line in stream_decompress('stream_data.gz'):
        record_count += 1
        # 模擬數(shù)據(jù)處理
        if record_count % 10000 == 0:
            print(f"已處理 {record_count} 條記錄")
    
    decompress_time = time.time() - start_time
    print(f"解壓完成: {record_count} 條記錄, 耗時 {decompress_time:.2f}秒")
    
    # 內(nèi)存使用對比
    print("\n內(nèi)存使用對比:")
    print("流式處理: 恒定低內(nèi)存使用")
    print("全量處理: 需要加載全部數(shù)據(jù)到內(nèi)存")
    
    # 性能統(tǒng)計(jì)
    total_data_size = sum(len(record) for record in generate_large_data(50000))
    print(f"總數(shù)據(jù)量: {total_data_size} 字節(jié)")
    print(f"壓縮比: {total_data_size / compressed_size:.2f}:1")
    print(f"總處理時間: {compress_time + decompress_time:.2f}秒")
    
    # 清理文件
    if os.path.exists('stream_data.gz'):
        os.remove('stream_data.gz')

# 執(zhí)行示例
streaming_compression()

import zipfile

def zip_file_operations():
    """ZIP文件操作"""
    # 創(chuàng)建測試文件
    test_files = {
        'document.txt': "這是文本文檔內(nèi)容\n第二行內(nèi)容\n",
        'data.json': '{"name": "測試", "value": 123, "active": true}',
        'config.ini': "[settings]\nversion=1.0\nenabled=true\n"
    }
    
    for filename, content in test_files.items():
        with open(filename, 'w', encoding='utf-8') as f:
            f.write(content)
        print(f"創(chuàng)建測試文件: {filename}")
    
    # 創(chuàng)建ZIP歸檔
    with zipfile.ZipFile('example.zip', 'w', compression=zipfile.ZIP_DEFLATED) as zipf:
        for filename in test_files.keys():
            zipf.write(filename)
            print(f"添加到ZIP: {filename}")
    
    # 查看ZIP文件信息
    with zipfile.ZipFile('example.zip', 'r') as zipf:
        print(f"\nZIP文件信息:")
        print(f"文件數(shù)量: {len(zipf.namelist())}")
        print(f"壓縮方法: {zipf.compression}")
        
        for info in zipf.infolist():
            print(f"  {info.filename}: {info.file_size} -> {info.compress_size} 字節(jié) "
                  f"(壓縮比 {info.file_size/(info.compress_size or 1):.1f}:1)")
    
    # 提取ZIP文件
    extract_dir = 'extracted'
    os.makedirs(extract_dir, exist_ok=True)
    
    with zipfile.ZipFile('example.zip', 'r') as zipf:
        zipf.extractall(extract_dir)
        print(f"\n文件提取到: {extract_dir}/")
    
    # 驗(yàn)證提取的文件
    for filename in test_files.keys():
        extracted_path = os.path.join(extract_dir, filename)
        if os.path.exists(extracted_path):
            with open(extracted_path, 'r', encoding='utf-8') as f:
                content = f.read()
            print(f"驗(yàn)證 {filename}: {'成功' if content == test_files[filename] else '失敗'}")
    
    # 創(chuàng)建帶密碼的ZIP
    with zipfile.ZipFile('secure.zip', 'w', compression=zipfile.ZIP_DEFLATED) as zipf:
        zipf.setpassword(b'secret123')
        for filename in test_files.keys():
            zipf.write(filename)
        print("\n創(chuàng)建加密ZIP: secure.zip")
    
    # 清理測試文件
    for filename in test_files.keys():
        if os.path.exists(filename):
            os.remove(filename)
    
    shutil.rmtree(extract_dir, ignore_errors=True)

# 執(zhí)行示例
zip_file_operations()

def advanced_zip_operations():
    """高級ZIP文件操作"""
    # 創(chuàng)建大型測試數(shù)據(jù)
    def create_large_file(filename, size_mb=1):
        """創(chuàng)建大型測試文件"""
        chunk_size = 1024 * 1024  # 1MB
        with open(filename, 'w', encoding='utf-8') as f:
            for i in range(size_mb):
                chunk = "x" * chunk_size
                f.write(chunk)
                print(f"寫入 {i+1} MB")
    
    create_large_file('large_file.txt', 2)  # 2MB文件
    
    # 分卷壓縮（模擬）
    def split_zip_archive(source_file, chunk_size_mb=1):
        """分卷壓縮文件"""
        chunk_size = chunk_size_mb * 1024 * 1024
        
        part_num = 1
        with open(source_file, 'rb') as src:
            while True:
                chunk_data = src.read(chunk_size)
                if not chunk_data:
                    break
                
                zip_filename = f'archive_part{part_num:03d}.zip'
                with zipfile.ZipFile(zip_filename, 'w', compression=zipfile.ZIP_DEFLATED) as zipf:
                    # 使用StringIO模擬文件寫入
                    with io.BytesIO(chunk_data) as buffer:
                        zipf.writestr('chunk.dat', buffer.getvalue())
                
                print(f"創(chuàng)建分卷: {zip_filename} ({len(chunk_data)} 字節(jié))")
                part_num += 1
        
        return part_num - 1
    
    # 測試分卷壓縮
    print("開始分卷壓縮...")
    num_parts = split_zip_archive('large_file.txt', 1)  # 1MB分卷
    print(f"創(chuàng)建了 {num_parts} 個分卷")
    
    # 合并分卷
    def merge_zip_parts(output_file, num_parts):
        """合并分卷文件"""
        with open(output_file, 'wb') as out:
            for i in range(1, num_parts + 1):
                part_file = f'archive_part{i:03d}.zip'
                if os.path.exists(part_file):
                    with zipfile.ZipFile(part_file, 'r') as zipf:
                        # 讀取分卷數(shù)據(jù)
                        with zipf.open('chunk.dat') as chunk_file:
                            chunk_data = chunk_file.read()
                            out.write(chunk_data)
                    print(f"合并分卷: {part_file}")
    
    # 測試分卷合并
    print("開始分卷合并...")
    merge_zip_parts('restored_file.txt', num_parts)
    
    # 驗(yàn)證文件完整性
    original_size = os.path.getsize('large_file.txt')
    restored_size = os.path.getsize('restored_file.txt')
    print(f"原始大小: {original_size} 字節(jié)")
    print(f"恢復(fù)大小: {restored_size} 字節(jié)")
    print(f"完整性檢查: {'成功' if original_size == restored_size else '失敗'}")
    
    # ZIP文件注釋和元數(shù)據(jù)
    with zipfile.ZipFile('metadata.zip', 'w', compression=zipfile.ZIP_DEFLATED) as zipf:
        zipf.writestr('test.txt', '測試內(nèi)容')
        
        # 添加注釋
        zipf.comment = '這是ZIP文件注釋'.encode('utf-8')
        
        # 設(shè)置文件注釋
        for info in zipf.infolist():
            info.comment = '文件注釋'.encode('utf-8')
        
        print("添加ZIP注釋和元數(shù)據(jù)")
    
    # 讀取注釋和元數(shù)據(jù)
    with zipfile.ZipFile('metadata.zip', 'r') as zipf:
        print(f"ZIP注釋: {zipf.comment.decode('utf-8')}")
        for info in zipf.infolist():
            print(f"文件 {info.filename} 注釋: {info.comment.decode('utf-8')}")
    
    # 清理文件
    for file in ['large_file.txt', 'restored_file.txt', 'metadata.zip']:
        if os.path.exists(file):
            os.remove(file)
    
    for i in range(1, num_parts + 1):
        part_file = f'archive_part{i:03d}.zip'
        if os.path.exists(part_file):
            os.remove(part_file)

# 執(zhí)行示例
advanced_zip_operations()

def http_compression_transfer():
    """HTTP壓縮傳輸示例"""
    import requests
    from http.server import HTTPServer, BaseHTTPRequestHandler
    import threading
    import gzip
    
    # HTTP壓縮處理器
    class CompressionHandler(BaseHTTPRequestHandler):
        def do_GET(self):
            """處理GET請求"""
            if self.path == '/compressed':
                # 生成大量數(shù)據(jù)
                large_data = "壓縮傳輸測試數(shù)據(jù)\n" * 1000
                compressed_data = gzip.compress(large_data.encode('utf-8'))
                
                self.send_response(200)
                self.send_header('Content-Type', 'text/plain')
                self.send_header('Content-Encoding', 'gzip')
                self.send_header('Content-Length', str(len(compressed_data)))
                self.end_headers()
                
                self.wfile.write(compressed_data)
                print("發(fā)送壓縮數(shù)據(jù)響應(yīng)")
            
            else:
                self.send_error(404)
        
        def do_POST(self):
            """處理POST請求（接收壓縮數(shù)據(jù)）"""
            if self.path == '/upload':
                content_encoding = self.headers.get('Content-Encoding', '')
                content_length = int(self.headers.get('Content-Length', 0))
                
                if content_encoding == 'gzip':
                    # 接收壓縮數(shù)據(jù)
                    compressed_data = self.rfile.read(content_length)
                    try:
                        decompressed_data = gzip.decompress(compressed_data)
                        received_text = decompressed_data.decode('utf-8')
                        
                        self.send_response(200)
                        self.send_header('Content-Type', 'text/plain')
                        self.end_headers()
                        
                        response = f"接收成功: {len(received_text)} 字符"
                        self.wfile.write(response.encode('utf-8'))
                        print(f"接收并解壓數(shù)據(jù): {len(received_text)} 字符")
                    
                    except Exception as e:
                        self.send_error(500, f"解壓錯誤: {e}")
                else:
                    self.send_error(400, "需要gzip編碼")
    
    def start_server():
        """啟動HTTP服務(wù)器"""
        server = HTTPServer(('localhost', 8080), CompressionHandler)
        print("HTTP服務(wù)器啟動在端口 8080")
        server.serve_forever()
    
    # 啟動服務(wù)器線程
    server_thread = threading.Thread(target=start_server)
    server_thread.daemon = True
    server_thread.start()
    
    # 等待服務(wù)器啟動
    time.sleep(0.1)
    
    # 客戶端測試
    def test_client():
        """測試HTTP客戶端"""
        # 測試壓縮數(shù)據(jù)下載
        response = requests.get('http://localhost:8080/compressed')
        print(f"下載響應(yīng): {response.status_code}")
        print(f"內(nèi)容編碼: {response.headers.get('Content-Encoding')}")
        print(f"內(nèi)容長度: {response.headers.get('Content-Length')}")
        
        if response.headers.get('Content-Encoding') == 'gzip':
            # 手動解壓
            decompressed = gzip.decompress(response.content)
            text_content = decompressed.decode('utf-8')
            print(f"解壓后內(nèi)容: {len(text_content)} 字符")
        
        # 測試壓縮數(shù)據(jù)上傳
        large_data = "上傳壓縮測試數(shù)據(jù)\n" * 500
        compressed_data = gzip.compress(large_data.encode('utf-8'))
        
        headers = {
            'Content-Encoding': 'gzip',
            'Content-Type': 'text/plain'
        }
        
        response = requests.post('http://localhost:8080/upload', 
                               data=compressed_data, 
                               headers=headers)
        
        print(f"上傳響應(yīng): {response.status_code}")
        print(f"上傳結(jié)果: {response.text}")
    
    # 運(yùn)行測試
    test_client()

# 執(zhí)行示例
http_compression_transfer()

def socket_compression_transfer():
    """Socket壓縮傳輸示例"""
    import socket
    import threading
    import zlib
    
    # 壓縮協(xié)議處理器
    class CompressionProtocol:
        def __init__(self):
            self.compress_obj = zlib.compressobj()
            self.decompress_obj = zlib.decompressobj()
        
        def compress_data(self, data):
            """壓縮數(shù)據(jù)"""
            compressed = self.compress_obj.compress(data)
            compressed += self.compress_obj.flush(zlib.Z_FULL_FLUSH)
            return compressed
        
        def decompress_data(self, data):
            """解壓數(shù)據(jù)"""
            decompressed = self.decompress_obj.decompress(data)
            return decompressed
        
        def reset(self):
            """重置壓縮狀態(tài)"""
            self.compress_obj = zlib.compressobj()
            self.decompress_obj = zlib.decompressobj()
    
    # 服務(wù)器線程
    def server_thread():
        """Socket服務(wù)器"""
        server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        server_socket.bind(('localhost', 9999))
        server_socket.listen(1)
        
        print("Socket服務(wù)器啟動，等待連接...")
        conn, addr = server_socket.accept()
        print(f"連接來自: {addr}")
        
        protocol = CompressionProtocol()
        
        try:
            # 接收數(shù)據(jù)
            received_data = b''
            while True:
                chunk = conn.recv(4096)
                if not chunk:
                    break
                received_data += chunk
            
            # 解壓數(shù)據(jù)
            decompressed = protocol.decompress_data(received_data)
            text_data = decompressed.decode('utf-8')
            
            print(f"接收并解壓數(shù)據(jù): {len(text_data)} 字符")
            
            # 發(fā)送響應(yīng)
            response = f"接收成功: {len(text_data)} 字符".encode('utf-8')
            compressed_response = protocol.compress_data(response)
            conn.sendall(compressed_response)
            
        finally:
            conn.close()
            server_socket.close()
    
    # 客戶端函數(shù)
    def client_example():
        """Socket客戶端示例"""
        # 等待服務(wù)器啟動
        time.sleep(0.1)
        
        client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        client_socket.connect(('localhost', 9999))
        
        protocol = CompressionProtocol()
        
        # 準(zhǔn)備發(fā)送數(shù)據(jù)
        large_data = "Socket壓縮傳輸測試數(shù)據(jù)\n" * 1000
        compressed_data = protocol.compress_data(large_data.encode('utf-8'))
        
        print(f"原始數(shù)據(jù): {len(large_data)} 字符")
        print(f"壓縮數(shù)據(jù): {len(compressed_data)} 字節(jié)")
        print(f"壓縮比: {len(large_data.encode('utf-8')) / len(compressed_data):.2f}:1")
        
        # 發(fā)送數(shù)據(jù)
        client_socket.sendall(compressed_data)
        client_socket.shutdown(socket.SHUT_WR)  # 發(fā)送完成
        
        # 接收響應(yīng)
        response_data = b''
        while True:
            chunk = client_socket.recv(4096)
            if not chunk:
                break
            response_data += chunk
        
        # 解壓響應(yīng)
        decompressed_response = protocol.decompress_data(response_data)
        response_text = decompressed_response.decode('utf-8')
        
        print(f"服務(wù)器響應(yīng): {response_text}")
        
        client_socket.close()
    
    # 啟動服務(wù)器線程
    server = threading.Thread(target=server_thread)
    server.start()
    
    # 運(yùn)行客戶端
    client_example()
    server.join()

# 執(zhí)行示例
socket_compression_transfer()

def log_compression_system():
    """日志壓縮歸檔系統(tǒng)"""
    import logging
    from logging.handlers import RotatingFileHandler
    import datetime
    
    class CompressedRotatingFileHandler(RotatingFileHandler):
        """支持壓縮的循環(huán)文件處理器"""
        def __init__(self, filename, **kwargs):
            # 確保目錄存在
            os.makedirs(os.path.dirname(os.path.abspath(filename)), exist_ok=True)
            super().__init__(filename, **kwargs)
        
        def doRollover(self):
            """重寫滾動方法，添加壓縮功能"""
            if self.stream:
                self.stream.close()
                self.stream = None
            
            # 獲取需要滾動的文件
            dfn = self.rotation_filename(self.baseFilename)
            
            if os.path.exists(dfn):
                os.remove(dfn)
            
            self.rotate(self.baseFilename, dfn)
            
            # 壓縮舊日志文件
            if self.backupCount > 0:
                for i in range(self.backupCount - 1, 0, -1):
                    sfn = self.rotation_filename(self.baseFilename + f".{i}.gz")
                    dfn = self.rotation_filename(self.baseFilename + f".{i+1}.gz")
                    
                    if os.path.exists(sfn):
                        if os.path.exists(dfn):
                            os.remove(dfn)
                        os.rename(sfn, dfn)
                
                # 壓縮當(dāng)前滾動文件
                sfn = self.rotation_filename(self.baseFilename + ".1")
                dfn = self.rotation_filename(self.baseFilename + ".1.gz")
                
                if os.path.exists(sfn):
                    # 使用GZIP壓縮
                    with open(sfn, 'rb') as f_in:
                        with gzip.open(dfn, 'wb') as f_out:
                            shutil.copyfileobj(f_in, f_out)
                    os.remove(sfn)
            
            if not self.delay:
                self.stream = self._open()
    
    def setup_logging():
        """設(shè)置日志系統(tǒng)"""
        log_dir = 'logs'
        os.makedirs(log_dir, exist_ok=True)
        
        # 主日志文件
        main_log = os.path.join(log_dir, 'application.log')
        
        # 配置日志處理器
        handler = CompressedRotatingFileHandler(
            main_log,
            maxBytes=1024 * 1024,  # 1MB
            backupCount=5,
            encoding='utf-8'
        )
        
        # 配置日志格式
        formatter = logging.Formatter(
            '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
        )
        handler.setFormatter(formatter)
        
        # 配置根日志器
        root_logger = logging.getLogger()
        root_logger.setLevel(logging.INFO)
        root_logger.addHandler(handler)
        
        return root_logger
    
    def generate_log_data():
        """生成測試日志數(shù)據(jù)"""
        logger = setup_logging()
        
        # 生成大量日志
        for i in range(1000):
            logger.info(f"測試日志消息 {i}: 這是詳細(xì)的日志內(nèi)容用于測試壓縮效果")
            
            if i % 100 == 0:
                logger.error(f"錯誤日志 {i}: 模擬錯誤情況")
        
        print("日志生成完成")
        
        # 查看生成的日志文件
        log_dir = 'logs'
        if os.path.exists(log_dir):
            files = os.listdir(log_dir)
            print(f"日志文件: {files}")
            
            # 檢查壓縮文件
            compressed_files = [f for f in files if f.endswith('.gz')]
            if compressed_files:
                print(f"壓縮日志文件: {compressed_files}")
                
                # 查看壓縮文件信息
                for comp_file in compressed_files:
                    filepath = os.path.join(log_dir, comp_file)
                    size = os.path.getsize(filepath)
                    print(f"  {comp_file}: {size} 字節(jié)")
    
    # 運(yùn)行日志系統(tǒng)測試
    generate_log_data()
    
    # 日志分析功能
    def analyze_compressed_logs():
        """分析壓縮日志"""
        log_dir = 'logs'
        if not os.path.exists(log_dir):
            print("日志目錄不存在")
            return
        
        compressed_files = [f for f in os.listdir(log_dir) if f.endswith('.gz')]
        
        for comp_file in compressed_files:
            filepath = os.path.join(log_dir, comp_file)
            print(f"\n分析壓縮日志: {comp_file}")
            
            # 讀取壓縮日志
            with gzip.open(filepath, 'rt', encoding='utf-8') as f:
                line_count = 0
                error_count = 0
                
                for line in f:
                    line_count += 1
                    if 'ERROR' in line:
                        error_count += 1
                
                print(f"  總行數(shù): {line_count}")
                print(f"  錯誤數(shù): {error_count}")
                print(f"  錯誤比例: {(error_count/line_count*100 if line_count > 0 else 0):.1f}%")
    
    # 分析日志
    analyze_compressed_logs()
    
    # 清理測試文件
    if os.path.exists('logs'):
        shutil.rmtree('logs')

# 執(zhí)行示例
log_compression_system()

def database_backup_compression():
    """數(shù)據(jù)庫備份壓縮系統(tǒng)"""
    import sqlite3
    import json
    
    # 創(chuàng)建示例數(shù)據(jù)庫
    def create_sample_database():
        """創(chuàng)建示例數(shù)據(jù)庫"""
        if os.path.exists('sample.db'):
            os.remove('sample.db')
        
        conn = sqlite3.connect('sample.db')
        cursor = conn.cursor()
        
        # 創(chuàng)建表
        cursor.execute('''
            CREATE TABLE users (
                id INTEGER PRIMARY KEY,
                name TEXT NOT NULL,
                email TEXT UNIQUE,
                created_at DATETIME DEFAULT CURRENT_TIMESTAMP
            )
        ''')
        
        cursor.execute('''
            CREATE TABLE orders (
                id INTEGER PRIMARY KEY,
                user_id INTEGER,
                amount REAL,
                status TEXT,
                created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
                FOREIGN KEY (user_id) REFERENCES users (id)
            )
        ''')
        
        # 插入示例數(shù)據(jù)
        users = [
            ('張三', 'zhangsan@example.com'),
            ('李四', 'lisi@example.com'),
            ('王五', 'wangwu@example.com')
        ]
        
        cursor.executemany(
            'INSERT INTO users (name, email) VALUES (?, ?)',
            users
        )
        
        orders = [
            (1, 100.50, 'completed'),
            (1, 200.75, 'pending'),
            (2, 50.25, 'completed'),
            (3, 300.00, 'shipped')
        ]
        
        cursor.executemany(
            'INSERT INTO orders (user_id, amount, status) VALUES (?, ?, ?)',
            orders
        )
        
        conn.commit()
        conn.close()
        
        print("示例數(shù)據(jù)庫創(chuàng)建完成")
    
    create_sample_database()
    
    # 數(shù)據(jù)庫備份函數(shù)
    def backup_database(db_path, backup_path, compression_format='gzip'):
        """備份數(shù)據(jù)庫到壓縮文件"""
        # 讀取數(shù)據(jù)庫內(nèi)容
        conn = sqlite3.connect(db_path)
        cursor = conn.cursor()
        
        # 獲取所有表
        cursor.execute("SELECT name FROM sqlite_master WHERE type='table'")
        tables = [row[0] for row in cursor.fetchall()]
        
        backup_data = {}
        
        for table in tables:
            # 獲取表結(jié)構(gòu)
            cursor.execute(f"SELECT sql FROM sqlite_master WHERE type='table' AND name=?", (table,))
            schema = cursor.fetchone()[0]
            
            # 獲取表數(shù)據(jù)
            cursor.execute(f"SELECT * FROM {table}")
            rows = cursor.fetchall()
            
            # 獲取列名
            column_names = [description[0] for description in cursor.description]
            
            backup_data[table] = {
                'schema': schema,
                'columns': column_names,
                'data': rows
            }
        
        conn.close()
        
        # 序列化備份數(shù)據(jù)
        serialized_data = json.dumps(backup_data, ensure_ascii=False, default=str)
        
        # 壓縮備份
        if compression_format == 'gzip':
            with gzip.open(backup_path, 'wt', encoding='utf-8') as f:
                f.write(serialized_data)
        elif compression_format == 'bz2':
            import bz2
            with bz2.open(backup_path, 'wt', encoding='utf-8') as f:
                f.write(serialized_data)
        else:
            raise ValueError(f"不支持的壓縮格式: {compression_format}")
        
        print(f"數(shù)據(jù)庫備份完成: {backup_path}")
        
        # 顯示備份信息
        original_size = os.path.getsize(db_path)
        compressed_size = os.path.getsize(backup_path)
        print(f"原始大小: {original_size} 字節(jié)")
        print(f"壓縮大小: {compressed_size} 字節(jié)")
        print(f"壓縮比: {original_size/compressed_size:.2f}:1")
    
    # 執(zhí)行備份
    backup_database('sample.db', 'backup.json.gz')
    
    # 數(shù)據(jù)庫恢復(fù)函數(shù)
    def restore_database(backup_path, db_path, compression_format='gzip'):
        """從壓縮備份恢復(fù)數(shù)據(jù)庫"""
        if os.path.exists(db_path):
            os.remove(db_path)
        
        # 解壓并讀取備份
        if compression_format == 'gzip':
            with gzip.open(backup_path, 'rt', encoding='utf-8') as f:
                backup_data = json.load(f)
        elif compression_format == 'bz2':
            import bz2
            with bz2.open(backup_path, 'rt', encoding='utf-8') as f:
                backup_data = json.load(f)
        else:
            raise ValueError(f"不支持的壓縮格式: {compression_format}")
        
        # 恢復(fù)數(shù)據(jù)庫
        conn = sqlite3.connect(db_path)
        cursor = conn.cursor()
        
        # 按順序恢復(fù)表（處理外鍵約束）
        table_order = ['users', 'orders']  # 根據(jù)外鍵依賴排序
        
        for table in table_order:
            if table in backup_data:
                # 創(chuàng)建表
                cursor.execute(backup_data[table]['schema'])
                
                # 插入數(shù)據(jù)
                if backup_data[table]['data']:
                    columns = backup_data[table]['columns']
                    placeholders = ', '.join(['?'] * len(columns))
                    
                    insert_sql = f"INSERT INTO {table} ({', '.join(columns)}) VALUES ({placeholders})"
                    cursor.executemany(insert_sql, backup_data[table]['data'])
        
        conn.commit()
        conn.close()
        
        print(f"數(shù)據(jù)庫恢復(fù)完成: {db_path}")
        
        # 驗(yàn)證恢復(fù)結(jié)果
        conn = sqlite3.connect(db_path)
        cursor = conn.cursor()
        
        cursor.execute("SELECT COUNT(*) FROM users")
        user_count = cursor.fetchone()[0]
        
        cursor.execute("SELECT COUNT(*) FROM orders")
        order_count = cursor.fetchone()[0]
        
        conn.close()
        
        print(f"恢復(fù)用戶數(shù): {user_count}")
        print(f"恢復(fù)訂單數(shù): {order_count}")
    
    # 執(zhí)行恢復(fù)
    restore_database('backup.json.gz', 'restored.db')
    
    # 增量備份示例
    def incremental_backup(db_path, backup_dir):
        """增量備份示例"""
        os.makedirs(backup_dir, exist_ok=True)
        
        # 獲取當(dāng)前時間戳
        timestamp = datetime.datetime.now().strftime('%Y%m%d_%H%M%S')
        backup_file = os.path.join(backup_dir, f'backup_{timestamp}.json.gz')
        
        # 執(zhí)行備份
        backup_database(db_path, backup_file)
        
        # 清理舊備份（保留最近5個）
        backup_files = sorted([f for f in os.listdir(backup_dir) if f.startswith('backup_')])
        if len(backup_files) > 5:
            for old_file in backup_files[:-5]:
                os.remove(os.path.join(backup_dir, old_file))
                print(f"刪除舊備份: {old_file}")
    
    # 創(chuàng)建增量備份
    incremental_backup('sample.db', 'backups')
    
    # 列出備份文件
    if os.path.exists('backups'):
        backup_files = os.listdir('backups')
        print(f"\n備份文件列表: {backup_files}")
        
        # 顯示備份信息
        for backup_file in backup_files:
            filepath = os.path.join('backups', backup_file)
            size = os.path.getsize(filepath)
            print(f"  {backup_file}: {size} 字節(jié)")
    
    # 清理測試文件
    for file in ['sample.db', 'restored.db', 'backup.json.gz']:
        if os.path.exists(file):
            os.remove(file)
    
    if os.path.exists('backups'):
        shutil.rmtree('backups')

# 執(zhí)行示例
database_backup_compression()

def compression_performance_optimization():
    """壓縮性能優(yōu)化策略"""
    import pandas as pd
    import numpy as np
    
    # 生成測試數(shù)據(jù)
    def generate_test_data():
        """生成多種類型的測試數(shù)據(jù)"""
        # 文本數(shù)據(jù)
        text_data = "重復(fù)文本內(nèi)容 " * 10000
        
        # 數(shù)值數(shù)據(jù)
        numeric_data = np.random.rand(10000).tolist()
        
        # 混合數(shù)據(jù)
        mixed_data = []
        for i in range(5000):
            mixed_data.append({
                'id': i,
                'name': f'Item_{i}',
                'value': np.random.rand(),
                'timestamp': datetime.datetime.now().isoformat()
            })
        
        return {
            'text': text_data,
            'numeric': numeric_data,
            'mixed': mixed_data
        }
    
    test_datasets = generate_test_data()
    
    # 測試不同壓縮格式的性能
    def test_compression_performance(data, data_name):
        """測試壓縮性能"""
        results = []
        
        # 序列化數(shù)據(jù)
        if isinstance(data, (list, dict)):
            serialized_data = json.dumps(data, ensure_ascii=False)
        else:
            serialized_data = str(data)
        
        binary_data = serialized_data.encode('utf-8')
        print(f"{data_name} 數(shù)據(jù)大小: {len(binary_data)} 字節(jié)")
        
        # 測試不同壓縮格式
        compressors = [
            ('gzip', gzip.compress),
            ('bz2', bz2.compress),
            ('lzma', lzma.compress),
            ('zlib', zlib.compress)
        ]
        
        for name, compress_func in compressors:
            # 測試壓縮
            start_time = time.time()
            compressed_data = compress_func(binary_data)
            compress_time = time.time() - start_time
            
            # 測試解壓
            start_time = time.time()
            if name == 'gzip':
                decompressed = gzip.decompress(compressed_data)
            elif name == 'bz2':
                decompressed = bz2.decompress(compressed_data)
            elif name == 'lzma':
                decompressed = lzma.decompress(compressed_data)
            elif name == 'zlib':
                decompressed = zlib.decompress(compressed_data)
            
            decompress_time = time.time() - start_time
            
            # 驗(yàn)證數(shù)據(jù)完整性
            original_restored = decompressed.decode('utf-8')
            if isinstance(data, (list, dict)):
                data_restored = json.loads(original_restored)
                is_valid = data == data_restored
            else:
                is_valid = data == original_restored
            
            results.append({
                'format': name,
                'original_size': len(binary_data),
                'compressed_size': len(compressed_data),
                'compression_ratio': len(binary_data) / len(compressed_data),
                'compress_time': compress_time,
                'decompress_time': decompress_time,
                'total_time': compress_time + decompress_time,
                'is_valid': is_valid
            })
        
        return results
    
    # 運(yùn)行性能測試
    all_results = {}
    
    for data_name, data in test_datasets.items():
        print(f"\n測試 {data_name} 數(shù)據(jù):")
        results = test_compression_performance(data, data_name)
        all_results[data_name] = results
        
        for result in results:
            print(f"  {result['format']}: {result['compressed_size']} 字節(jié), "
                  f"壓縮比 {result['compression_ratio']:.2f}:1, "
                  f"總耗時 {result['total_time']:.3f}秒")
    
    # 生成性能報(bào)告
    def generate_performance_report(results):
        """生成性能報(bào)告"""
        report_data = []
        
        for data_type, compression_results in results.items():
            for result in compression_results:
                report_data.append({
                    'data_type': data_type,
                    'format': result['format'],
                    'compression_ratio': result['compression_ratio'],
                    'total_time': result['total_time'],
                    'compress_time': result['compress_time'],
                    'decompress_time': result['decompress_time']
                })
        
        df = pd.DataFrame(report_data)
        
        # 總結(jié)報(bào)告
        print("\n性能總結(jié):")
        summary = df.groupby(['data_type', 'format']).agg({
            'compression_ratio': 'mean',
            'total_time': 'mean'
        }).round(2)
        
        print(summary)
        
        # 最佳選擇推薦
        best_choices = {}
        for data_type in results.keys():
            type_results = [r for r in results[data_type]]
            best_ratio = max(type_results, key=lambda x: x['compression_ratio'])
            best_speed = min(type_results, key=lambda x: x['total_time'])
            
            best_choices[data_type] = {
                'best_compression': best_ratio['format'],
                'best_speed': best_speed['format']
            }
        
        print("\n推薦選擇:")
        for data_type, choices in best_choices.items():
            print(f"  {data_type}:")
            print(f"    最佳壓縮: {choices['best_compression']}")
            print(f"    最快速度: {choices['best_speed']}")
    
    generate_performance_report(all_results)
    
    # 內(nèi)存使用優(yōu)化
    def memory_efficient_compression():
        """內(nèi)存高效的壓縮處理"""
        large_data = "大型數(shù)據(jù)內(nèi)容 " * 1000000
        print(f"大型數(shù)據(jù)大小: {len(large_data)} 字符")
        
        # 傳統(tǒng)方法（內(nèi)存密集型）
        start_time = time.time()
        compressed = gzip.compress(large_data.encode('utf-8'))
        traditional_time = time.time() - start_time
        traditional_memory = len(compressed)
        
        # 流式方法（內(nèi)存友好）
        start_time = time.time()
        with io.BytesIO() as buffer:
            with gzip.GzipFile(fileobj=buffer, mode='wb') as gz:
                # 分塊處理
                chunk_size = 1024 * 1024  # 1MB
                for i in range(0, len(large_data), chunk_size):
                    chunk = large_data[i:i + chunk_size]
                    gz.write(chunk.encode('utf-8'))
            
            stream_compressed = buffer.getvalue()
        
        stream_time = time.time() - start_time
        stream_memory = len(stream_compressed)
        
        print(f"傳統(tǒng)方法: {traditional_time:.3f}秒, 內(nèi)存使用: {traditional_memory} 字節(jié)")
        print(f"流式方法: {stream_time:.3f}秒, 內(nèi)存使用: {stream_memory} 字節(jié)")
        print(f"壓縮比: {len(large_data.encode('utf-8')) / traditional_memory:.2f}:1")
        print(f"性能差異: {traditional_time/stream_time:.2f}倍")
    
    memory_efficient_compression()

# 執(zhí)行示例
compression_performance_optimization()

def compression_error_handling():
    """壓縮錯誤處理與恢復(fù)"""
    class SafeCompression:
        """安全的壓縮處理類"""
        def __init__(self):
            self.error_log = []
        
        def safe_compress(self, data, compression_format='gzip'):
            """安全壓縮數(shù)據(jù)"""
            try:
                if compression_format == 'gzip':
                    compressed = gzip.compress(data)
                elif compression_format == 'bz2':
                    compressed = bz2.compress(data)
                elif compression_format == 'lzma':
                    compressed = lzma.compress(data)
                else:
                    raise ValueError(f"不支持的壓縮格式: {compression_format}")
                
                return compressed
                
            except Exception as e:
                self.error_log.append(f"壓縮錯誤: {e}")
                # 回退到不壓縮
                return data
        
        def safe_decompress(self, data, compression_format='auto'):
            """安全解壓數(shù)據(jù)"""
            try:
                # 自動檢測壓縮格式
                if compression_format == 'auto':
                    if data.startswith(b'\x1f\x8b'):  # GZIP魔數(shù)
                        return gzip.decompress(data)
                    elif data.startswith(b'BZh'):  # BZIP2魔數(shù)
                        return bz2.decompress(data)
                    elif data.startswith(b'\xfd7zXZ'):  # XZ魔數(shù)
                        return lzma.decompress(data)
                    else:
                        # 假設(shè)未壓縮
                        return data
                else:
                    if compression_format == 'gzip':
                        return gzip.decompress(data)
                    elif compression_format == 'bz2':
                        return bz2.decompress(data)
                    elif compression_format == 'lzma':
                        return lzma.decompress(data)
                    else:
                        raise ValueError(f"不支持的壓縮格式: {compression_format}")
                        
            except Exception as e:
                self.error_log.append(f"解壓錯誤: {e}")
                # 嘗試其他格式或返回原始數(shù)據(jù)
                try:
                    return gzip.decompress(data)
                except:
                    try:
                        return bz2.decompress(data)
                    except:
                        try:
                            return lzma.decompress(data)
                        except:
                            return data  # 最終回退
        
        def get_errors(self):
            """獲取錯誤日志"""
            return self.error_log
        
        def clear_errors(self):
            """清除錯誤日志"""
            self.error_log = []
    
    # 使用安全壓縮類
    compressor = SafeCompression()
    
    # 測試正常壓縮
    test_data = "正常測試數(shù)據(jù)".encode('utf-8')
    compressed = compressor.safe_compress(test_data, 'gzip')
    decompressed = compressor.safe_decompress(compressed, 'auto')
    
    print(f"正常測試: {test_data == decompressed}")
    print(f"錯誤日志: {compressor.get_errors()}")
    compressor.clear_errors()
    
    # 測試錯誤情況
    invalid_data = b"無效壓縮數(shù)據(jù)"
    try:
        # 故意觸發(fā)錯誤
        decompressed = compressor.safe_decompress(invalid_data, 'gzip')
        print(f"錯誤處理測試: 成功恢復(fù), 結(jié)果長度: {len(decompressed)}")
    except Exception as e:
        print(f"錯誤處理測試: 捕獲異常 {e}")
    
    print(f"錯誤日志: {compressor.get_errors()}")
    
    # 文件壓縮錯誤處理
    def safe_file_compression(input_file, output_file, compression_format='gzip'):
        """安全的文件壓縮"""
        try:
            # 檢查輸入文件
            if not os.path.exists(input_file):
                raise FileNotFoundError(f"輸入文件不存在: {input_file}")
            
            # 檢查輸出目錄
            output_dir = os.path.dirname(output_file)
            if output_dir and not os.path.exists(output_dir):
                os.makedirs(output_dir, exist_ok=True)
            
            # 讀取輸入文件
            with open(input_file, 'rb') as f_in:
                original_data = f_in.read()
            
            # 壓縮數(shù)據(jù)
            if compression_format == 'gzip':
                compressed_data = gzip.compress(original_data)
            elif compression_format == 'bz2':
                compressed_data = bz2.compress(original_data)
            elif compression_format == 'lzma':
                compressed_data = lzma.compress(original_data)
            else:
                raise ValueError(f"不支持的壓縮格式: {compression_format}")
            
            # 寫入輸出文件
            with open(output_file, 'wb') as f_out:
                f_out.write(compressed_data)
            
            # 驗(yàn)證壓縮
            with open(output_file, 'rb') as f_check:
                check_data = f_check.read()
            
            if compression_format == 'gzip':
                decompressed_check = gzip.decompress(check_data)
            # ... 其他格式類似
            
            if decompressed_check != original_data:
                raise ValueError("壓縮驗(yàn)證失敗: 數(shù)據(jù)不一致")
            
            return True
            
        except Exception as e:
            print(f"文件壓縮錯誤: {e}")
            # 錯誤恢復(fù): 嘗試其他壓縮格式或創(chuàng)建備份
            try:
                backup_file = output_file + '.backup'
                shutil.copy2(input_file, backup_file)
                print(f"創(chuàng)建備份文件: {backup_file}")
                return False
            except Exception as backup_error:
                print(f"備份創(chuàng)建也失敗: {backup_error}")
                return False
    
    # 測試文件壓縮
    test_content = "文件壓縮測試內(nèi)容".encode('utf-8')
    with open('test_input.txt', 'wb') as f:
        f.write(test_content)
    
    success = safe_file_compression('test_input.txt', 'test_output.gz')
    print(f"文件壓縮結(jié)果: {'成功' if success else '失敗'}")
    
    # 清理測試文件
    for file in ['test_input.txt', 'test_output.gz']:
        if os.path.exists(file):
            os.remove(file)

# 執(zhí)行示例
compression_error_handling()

def professional_compression_template():
    """
    專業(yè)壓縮處理模板
    包含錯誤處理、性能優(yōu)化、資源管理等最佳實(shí)踐
    """
    class ProfessionalCompressor:
        def __init__(self, default_format='gzip', default_level=6):
            self.default_format = default_format
            self.default_level = default_level
            self.error_log = []
            self.performance_stats = {
                'compress_operations': 0,
                'decompress_operations': 0,
                'total_bytes_processed': 0
            }
        
        def compress(self, data, format=None, level=None):
            """安全壓縮數(shù)據(jù)"""
            format = format or self.default_format
            level = level or self.default_level
            
            try:
                start_time = time.time()
                
                if format == 'gzip':
                    compressed = gzip.compress(data, compresslevel=level)
                elif format == 'bz2':
                    compressed = bz2.compress(data, compresslevel=level)
                elif format == 'lzma':
                    compressed = lzma.compress(data, preset=level)
                else:
                    raise ValueError(f"不支持的壓縮格式: {format}")
                
                process_time = time.time() - start_time
                
                # 更新統(tǒng)計(jì)
                self.performance_stats['compress_operations'] += 1
                self.performance_stats['total_bytes_processed'] += len(data)
                
                return compressed
                
            except Exception as e:
                self.error_log.append({
                    'time': datetime.now().isoformat(),
                    'operation': 'compress',
                    'format': format,
                    'error': str(e)
                })
                raise
        
        def decompress(self, data, format='auto'):
            """安全解壓數(shù)據(jù)"""
            try:
                start_time = time.time()
                
                if format == 'auto':
                    # 自動檢測格式
                    if data.startswith(b'\x1f\x8b'):
                        result = gzip.decompress(data)
                    elif data.startswith(b'BZh'):
                        result = bz2.decompress(data)
                    elif data.startswith(b'\xfd7zXZ'):
                        result = lzma.decompress(data)
                    else:
                        result = data  # 未壓縮數(shù)據(jù)
                else:
                    if format == 'gzip':
                        result = gzip.decompress(data)
                    elif format == 'bz2':
                        result = bz2.decompress(data)
                    elif format == 'lzma':
                        result = lzma.decompress(data)
                    else:
                        raise ValueError(f"不支持的壓縮格式: {format}")
                
                process_time = time.time() - start_time
                
                # 更新統(tǒng)計(jì)
                self.performance_stats['decompress_operations'] += 1
                self.performance_stats['total_bytes_processed'] += len(data)
                
                return result
                
            except Exception as e:
                self.error_log.append({
                    'time': datetime.now().isoformat(),
                    'operation': 'decompress',
                    'format': format,
                    'error': str(e)
                })
                raise
        
        def get_stats(self):
            """獲取統(tǒng)計(jì)信息"""
            return self.performance_stats.copy()
        
        def get_errors(self):
            """獲取錯誤信息"""
            return self.error_log.copy()
        
        def clear_stats(self):
            """清除統(tǒng)計(jì)信息"""
            self.performance_stats = {
                'compress_operations': 0,
                'decompress_operations': 0,
                'total_bytes_processed': 0
            }
        
        def clear_errors(self):
            """清除錯誤信息"""
            self.error_log = []
    
    # 使用示例
    compressor = ProfessionalCompressor(default_format='gzip', default_level=6)
    
    try:
        # 測試數(shù)據(jù)
        test_data = "專業(yè)壓縮測試數(shù)據(jù)".encode('utf-8')
        
        # 壓縮
        compressed = compressor.compress(test_data)
        print(f"壓縮后大小: {len(compressed)} 字節(jié)")
        
        # 解壓
        decompressed = compressor.decompress(compressed)
        print(f"解壓成功: {test_data == decompressed}")
        
        # 查看統(tǒng)計(jì)
        stats = compressor.get_stats()
        print(f"操作統(tǒng)計(jì): {stats}")
        
    except Exception as e:
        print(f"壓縮操作失敗: {e}")
        errors = compressor.get_errors()
        print(f"錯誤信息: {errors}")

# 執(zhí)行示例
professional_compression_template()