分段读取文件脚本适配咨询：原处理两行的脚本需适配行数变更

Looks like your file has outgrown its original two-line structure, and you need to adapt your script to handle segmented reading instead of just grabbing the first two lines. Let's walk through a few practical, Pythonic solutions that fit different use cases, while fixing up some best practices along the way.

Solution 1: Process Fixed-Size Line Chunks #

If you want to handle groups of lines (e.g., pairs, batches of 5, etc.), a generator function is a clean way to yield segments without loading the entire file into memory. This works great for files of any length:

def read_file_in_chunks(file_path, chunk_size=2):
    """Yield chunks of lines from a file, each of the specified size."""
    with open(file_path, 'r') as file:
        chunk = []
        for line in file:
            cleaned_line = line.strip()  # Remove newlines/extra whitespace (adjust if needed)
            chunk.append(cleaned_line)
            if len(chunk) == chunk_size:
                yield chunk
                chunk = []
        # Yield any remaining lines if the file doesn't end on a chunk boundary
        if chunk:
            yield chunk

# Usage example
for segment in read_file_in_chunks(myfile, chunk_size=2):
    # Pass the segment to your existing calculation functions
    process_segment(segment)

Pro tip: Using with open(...) ensures the file is automatically closed, even if an error occurs—this is way more reliable than your original try block without proper cleanup.

Solution 2: Segment-Specific Logic (Preserve Original First-Line Handling) #

If your original logic still needs the first two lines for setup, and the rest of the file is additional data to process in segments, you can split the workflow:

with open(myfile, 'r') as file:
    # Handle the first two lines (your original core logic)
    try:
        first_line = next(file).strip()
        second_line = next(file).strip()
        process_initial_lines(first_line, second_line)
    except StopIteration:
        # Handle case where file has fewer than two lines now
        print("Warning: File has fewer than two lines.")
    
    # Process remaining lines in batches (adjust chunk_size as needed)
    chunk_size = 5
    data_chunk = []
    for line in file:
        data_chunk.append(line.strip())
        if len(data_chunk) == chunk_size:
            process_data_chunk(data_chunk)
            data_chunk = []
    # Process any leftover lines in the final partial chunk
    if data_chunk:
        process_data_chunk(data_chunk)

This keeps your original logic intact for the first two lines while adding flexible segmented processing for the rest of the file.

Solution 3: Stream Processing for Extra-Large Files #

If your file is massive (too big to fit in memory), you can process lines one at a time while tracking segments (e.g., every 10 lines trigger a calculation flush):

with open(myfile, 'r') as file:
    # Handle initial two lines
    first_line = next(file).strip()
    second_line = next(file).strip()
    process_initial_lines(first_line, second_line)
    
    # Stream remaining lines, processing in segments as needed
    processed_lines = 0
    batch = []
    for line in file:
        batch.append(line.strip())
        processed_lines += 1
        # Flush batch every 10 lines (adjust to your needs)
        if processed_lines % 10 == 0:
            process_batch(batch)
            batch = []
    # Flush the final partial batch
    if batch:
        process_batch(batch)

Key Best Practices #

• Always use with statements for file handling to avoid resource leaks.
• Add try-except blocks (like the StopIteration check above) to handle edge cases (e.g., files shorter than expected).
• Clean lines with strip() unless you explicitly need to preserve whitespace/newlines.

内容的提问来源于stack exchange，提问作者Nauman Shahid