# 創(chuàng)建bytearray的幾種方式
data = bytearray(b'Hello World')  # 從bytes對象創(chuàng)建
empty_buf = bytearray(10)         # 創(chuàng)建長度為10的空緩沖區(qū)，初始化為0
from_list = bytearray([65, 66, 67])  # 從整數(shù)列表創(chuàng)建，值為ASCII的A,B,C

# 修改內(nèi)容
data[0] = 104  # 將'H' (72) 改為 'h' (104)
print(data)    # 輸出: bytearray(b'hello World')

# 支持切片操作
data[6:11] = b'Python'
print(data)    # 輸出: bytearray(b'hello Python')

# 創(chuàng)建memoryview
data = bytearray(b'Hello World')
mv = memoryview(data)

# 通過視圖訪問和修改數(shù)據(jù)
mv[0] = 104  # 修改第一個字節(jié)
print(data)  # 輸出: bytearray(b'hello World')

# 切片操作也不會復(fù)制數(shù)據(jù)
slice_mv = mv[6:11]
slice_mv[0] = 80  # 'P'的ASCII碼
print(data)       # 輸出: bytearray(b'hello Python')

with open('binary_file.bin', 'rb') as f:
    # 方法1: 讀取整個文件到bytearray
    data = bytearray(f.read())
    
    # 修改數(shù)據(jù)
    data[0:4] = b'NEW_'
    
    # 寫回文件（如果需要）
    with open('modified_file.bin', 'wb') as out_f:
        out_f.write(data)

CHUNK_SIZE = 4096  # 4KB塊大小

with open('large_file.bin', 'rb') as f:
    with open('output_file.bin', 'wb') as out_f:
        while True:
            # 讀取一塊數(shù)據(jù)到bytearray
            chunk = bytearray(f.read(CHUNK_SIZE))
            if not chunk:
                break
                
            # 處理當前塊
            process_chunk(chunk)
            
            # 寫入處理后的塊
            out_f.write(chunk)

import mmap
import os

def modify_binary_file(filename):
    with open(filename, 'r+b') as f:
        # 創(chuàng)建內(nèi)存映射
        with mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_WRITE) as mm:
            # 現(xiàn)在可以通過索引直接修改文件內(nèi)容
            mm[0:4] = b'TEST'
            
            # 使用memoryview進行更復(fù)雜的操作
            mv = memoryview(mm)
            process_memoryview(mv)
            
            # 修改會自動寫回文件，無需顯式寫入操作

import struct
import mmap

def modify_struct_data(filename):
    with open(filename, 'r+b') as f:
        with mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_WRITE) as mm:
            # 假設(shè)文件包含多個相同結(jié)構(gòu)的記錄
            RECORD_SIZE = 12
            NUM_RECORDS = len(mm) // RECORD_SIZE
            
            for i in range(NUM_RECORDS):
                start = i * RECORD_SIZE
                end = start + RECORD_SIZE
                
                # 使用memoryview切片處理每個記錄
                record_view = memoryview(mm)[start:end]
                
                # 解包記錄
                # 假設(shè)格式: 4字節(jié)整數(shù) + 8字節(jié)雙精度浮點數(shù)
                int_val, double_val = struct.unpack('id', record_view)
                
                # 修改值
                new_int = int_val + 1
                new_double = double_val * 1.1
                
                # 打包并寫回
                packed_data = struct.pack('id', new_int, new_double)
                record_view[:] = packed_data

import struct
import socket

def build_custom_packet(header_fields, payload):
    """構(gòu)建自定義協(xié)議數(shù)據(jù)包"""
    # 創(chuàng)建可變緩沖區(qū)
    # 包頭格式: 2字節(jié)魔術(shù)字 + 2字節(jié)版本 + 4字節(jié)數(shù)據(jù)長度
    HEADER_FORMAT = 'HHI'
    HEADER_SIZE = struct.calcsize(HEADER_FORMAT)
    
    # 創(chuàng)建足夠大的緩沖區(qū)容納包頭和負載
    packet_size = HEADER_SIZE + len(payload)
    packet = bytearray(packet_size)
    
    # 創(chuàng)建memoryview以便高效操作
    mv = memoryview(packet)
    
    # 打包頭部數(shù)據(jù)
    header_data = struct.pack(HEADER_FORMAT, *header_fields)
    
    # 將頭部數(shù)據(jù)復(fù)制到緩沖區(qū)前部
    mv[0:HEADER_SIZE] = header_data
    
    # 復(fù)制負載數(shù)據(jù)
    mv[HEADER_SIZE:HEADER_SIZE+len(payload)] = payload
    
    return packet

# 使用示例
magic = 0xABCD
version = 0x0001
data_length = 100
payload = b'x' * 100  # 模擬100字節(jié)負載

packet = build_custom_packet((magic, version, data_length), payload)

def parse_and_modify_packet(packet_data):
    """解析并修改網(wǎng)絡(luò)數(shù)據(jù)包"""
    # 創(chuàng)建memoryview以實現(xiàn)零拷貝訪問
    mv = memoryview(packet_data)
    
    # 解析包頭
    HEADER_FORMAT = 'HHI'
    HEADER_SIZE = struct.calcsize(HEADER_FORMAT)
    
    magic, version, length = struct.unpack(HEADER_FORMAT, mv[0:HEADER_SIZE])
    
    # 修改包頭中的某些字段
    new_version = 0x0002
    # 重新打包頭部字段
    new_header = struct.pack(HEADER_FORMAT, magic, new_version, length)
    
    # 將新頭部復(fù)制回緩沖區(qū)
    mv[0:HEADER_SIZE] = new_header
    
    # 修改負載數(shù)據(jù)
    payload_view = mv[HEADER_SIZE:HEADER_SIZE+length]
    # 例如，將負載中的所有字節(jié)加1
    for i in range(len(payload_view)):
        payload_view[i] = (payload_view[i] + 1) % 256
    
    return packet_data

def invert_image_pixels(image_path, output_path):
    """反轉(zhuǎn)圖像像素值"""
    from PIL import Image
    import numpy as np
    
    # 打開圖像并轉(zhuǎn)換為numpy數(shù)組
    img = Image.open(image_path)
    img_array = np.array(img)
    
    # 創(chuàng)建memoryview以便直接操作像素數(shù)據(jù)
    mv = memoryview(img_array.data)
    
    # 反轉(zhuǎn)所有像素值
    for i in range(len(mv)):
        mv[i] = 255 - mv[i]
    
    # 保存修改后的圖像
    Image.fromarray(img_array).save(output_path)

class ImageBuffer:
    def __init__(self, image_path):
        self.img = Image.open(image_path)
        self.array = np.array(self.img)
        self.buffer = memoryview(self.array.data)
        self.height, self.width, self.channels = self.array.shape
        
    def get_pixel(self, x, y):
        """獲取指定位置的像素值"""
        offset = (y * self.width + x) * self.channels
        return tuple(self.buffer[offset:offset+self.channels])
    
    def set_pixel(self, x, y, values):
        """設(shè)置指定位置的像素值"""
        offset = (y * self.width + x) * self.channels
        self.buffer[offset:offset+self.channels] = values
        
    def apply_filter(self, filter_func):
        """應(yīng)用濾鏡函數(shù)到所有像素"""
        for y in range(self.height):
            for x in range(self.width):
                current = self.get_pixel(x, y)
                new_value = filter_func(current)
                self.set_pixel(x, y, new_value)
                
    def save(self, output_path):
        """保存圖像"""
        Image.fromarray(self.array).save(output_path)

# 使用示例
def grayscale_filter(rgb):
    """將RGB轉(zhuǎn)換為灰度"""
    gray = int(0.299 * rgb[0] + 0.587 * rgb[1] + 0.114 * rgb[2])
    return (gray, gray, gray)

image = ImageBuffer('input.jpg')
image.apply_filter(grayscale_filter)
image.save('output.jpg')

def safe_buffer_operation(filename):
    try:
        with open(filename, 'r+b') as f:
            with mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_WRITE) as mm:
                mv = memoryview(mm)
                # 進行操作
                # ...
    except FileNotFoundError:
        print(f"文件 {filename} 不存在")
    except PermissionError:
        print(f"沒有權(quán)限修改文件 {filename}")
    except Exception as e:
        print(f"處理文件時發(fā)生錯誤: {e}")