import functools

RECORD_SIZE = 32 # 假設(shè)每條記錄固定為32字節(jié)

# 以二進制模式打開文件
with open('data.bin', 'rb') as f:
    # 創(chuàng)建一個可調(diào)用對象，每次調(diào)用f.read(RECORD_SIZE)
    reader = functools.partial(f.read, RECORD_SIZE)
    
    # 創(chuàng)建迭代器，直到讀取到空字節(jié)串（b''）為止
    for record in iter(reader, b''):
        process_record(record) # 處理每一條記錄

with open('data.bin', 'rb') as f:
    data = f.read() # 危險！如果文件很大，會消耗大量內(nèi)存
    records = [data[i:i+RECORD_SIZE] for i in range(0, len(data), RECORD_SIZE)]
    for record in records:
        process_record(record)

with open('data.bin', 'rb') as f:
    while True:
        record = f.read(RECORD_SIZE)
        if not record: # 如果記錄為空，則跳出循環(huán)
            break
        process_record(record)

import functools
import struct

RECORD_FORMAT = 'i20sdi' # 定義結(jié)構(gòu)格式：int, 20byte string, double, int
RECORD_SIZE = struct.calcsize(RECORD_FORMAT) # 動態(tài)計算記錄大?。?6字節(jié)）

def process_employee_record(record_binary):
    """解析并處理單條員工記錄"""
    # 解包二進制數(shù)據(jù)
    emp_id, name_bytes, salary, department = struct.unpack(RECORD_FORMAT, record_binary)
    # 解碼姓名，并去除填充的空字節(jié)(\x00)
    name = name_bytes.decode('utf-8').rstrip('\x00')
    
    # 接下來可以進行任何處理，例如打印、計算、存入數(shù)據(jù)庫等
    print(f"ID: {emp_id:4d}, Name: {name:20s}, Salary: {salary:8.2f}, Dept: {department:2d}")
    # 或者返回一個字典
    return {'id': emp_id, 'name': name, 'salary': salary, 'dept': department}

# 主處理循環(huán)
with open('employees.dat', 'rb') as f:
    # 創(chuàng)建記錄讀取器
    record_reader = functools.partial(f.read, RECORD_SIZE)
    # 使用迭代器處理所有記錄
    for binary_record in iter(record_reader, b''):
        if len(binary_record) < RECORD_SIZE:
            print(f"Warning: Incomplete record of size {len(binary_record)} found at end of file.")
            break # 處理文件末尾可能不完整的記錄
        employee_data = process_employee_record(binary_record)
        # ... 其他業(yè)務(wù)邏輯

RECORD_FORMAT = '2s5i2s'
RECORD_SIZE = struct.calcsize(RECORD_FORMAT)

with open('complex_data.bin', 'rb') as f:
    for binary_record in iter(functools.partial(f.read, RECORD_SIZE), b''):
        header, num1, num2, num3, num4, num5, footer = struct.unpack(RECORD_FORMAT, binary_record)
        number_array = [num1, num2, num3, num4, num5]
        # 處理header, number_array, footer...

RECORD_SIZE = 40 # 40個字符

with open('data.txt', 'r') as f:
    # 注意：文本模式下的哨兵是空字符串('')，不是空字節(jié)串(b'')
    for line in iter(functools.partial(f.read, RECORD_SIZE), ''):
        if len(line) < RECORD_SIZE:
            # 處理最后一行可能不完整的情況
            continue 
        record_id = line[0:10].strip()
        name = line[10:30].strip()
        amount = float(line[30:40].strip())
        print(f"ID: {record_id}, Name: {name}, Amount: {amount}")

RECORD_SIZE = 40
ID_SLICE = slice(0, 10)
NAME_SLICE = slice(10, 30)
AMOUNT_SLICE = slice(30, 40)

with open('data.txt', 'r') as f:
    for line in iter(functools.partial(f.read, RECORD_SIZE), ''):
        record_id = line[ID_SLICE].strip()
        name = line[NAME_SLICE].strip()
        amount = line[AMOUNT_SLICE].strip() # 轉(zhuǎn)換為float的操作可以放在錯誤處理中
        # ...

import socket
import functools
import struct

HEADER_FORMAT = '>H I d H' # 使用網(wǎng)絡(luò)字節(jié)序（大端序）
HEADER_SIZE = struct.calcsize(HEADER_FORMAT)

def read_packet_header(sock):
    """從套接字讀取固定大小的協(xié)議頭"""
    header_reader = functools.partial(sock.recv, HEADER_SIZE)
    # MSG_WAITALL 標(biāo)志會嘗試recv直到收滿HEADER_SIZE指定的字節(jié)數(shù)
    # 但請注意，在網(wǎng)絡(luò)編程中，必須處理接收不全和超時等情況
    header_data = sock.recv(HEADER_SIZE, socket.MSG_WAITALL)
    if len(header_data) < HEADER_SIZE:
        raise ConnectionError("Failed to receive complete header")
    return struct.unpack(HEADER_FORMAT, header_data)

# 在服務(wù)器循環(huán)中
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
    s.bind(('localhost', 12345))
    s.listen()
    conn, addr = s.accept()
    with conn:
        while True:
            try:
                pkt_type, seq_num, timestamp, data_length = read_packet_header(conn)
                # 現(xiàn)在根據(jù)data_length讀取可變長度的負載數(shù)據(jù)
                payload = conn.recv(data_length, socket.MSG_WAITALL)
                process_packet(pkt_type, seq_num, timestamp, payload)
            except ConnectionError:
                break

from PIL import Image
import numpy as np

def process_image_blocks(image_path, block_size=8):
    """將圖像劃分為固定大小的塊進行處理"""
    with Image.open(image_path) as img:
        img_array = np.array(img) # 將圖像轉(zhuǎn)換為numpy數(shù)組
        
        height, width, channels = img_array.shape
        # 計算需要迭代的塊數(shù)
        blocks_vertical = height // block_size
        blocks_horizontal = width // block_size
        
        # 迭代每個塊
        for i in range(blocks_vertical):
            for j in range(blocks_horizontal):
                # 提取當(dāng)前塊
                block = img_array[i*block_size:(i+1)*block_size,
                                  j*block_size:(j+1)*block_size, :]
                # 對塊進行處理，例如計算DCT、提取特征等
                process_block(block) 
                
        # 處理可能剩余的、不完整的邊緣塊（此處略過）
        # ...

def process_block(block):
    """處理單個圖像塊（示例：計算塊內(nèi)平均值）"""
    average_value = np.mean(block, axis=(0, 1))
    # ... 其他操作
    return average_value

from itertools import islice

# 僅處理前100條記錄
with open('data.bin', 'rb') as f:
    first_100_records = islice(iter(functools.partial(f.read, RECORD_SIZE), b''), 100)
    for record in first_100_records:
        process_record(record)