Python匹配指定模式并打印模式及后续N行的实现方案咨询

Got it, let's work through this. You've got a huge FASTA file (10k+ sequences, 98k+ lines) and need a Python script to hunt down a specific pattern, then print that matching line plus the next N lines. Here are a couple of efficient ways to do this without cramming the entire file into memory—super important for such large datasets.

Option 1: Pure Python (No Third-Party Libraries) #

This approach reads the file line-by-line, so it won't bog down your system with memory issues. We'll cover two common use cases:

Case 1: Match FASTA Headers (Lines Starting with >) #

If you're targeting specific sequence IDs (like >DILT_0000000001-mRNA-1), this script will find the header and print it plus the next N lines of sequence:

def print_pattern_and_next_lines(file_path, target_pattern, num_lines_after):
    with open(file_path, 'r') as fasta_file:
        match_active = False
        collected_lines = []
        line_counter = 0

        for raw_line in fasta_file:
            line = raw_line.rstrip('\n')  # Keep original formatting, just remove newline
            
            # Check if we found our target pattern
            if not match_active and target_pattern in line:
                match_active = True
                collected_lines.append(line)
                line_counter = 1
                continue
            
            # Collect subsequent lines if we're in a match
            if match_active:
                collected_lines.append(line)
                line_counter += 1
                
                # Once we have all the lines we need, print and reset
                if line_counter > num_lines_after:
                    print('\n'.join(collected_lines))
                    # Remove the line below if you want to find ALL matches, not just the first
                    break
                    match_active = False
                    collected_lines = []

# Example usage
if __name__ == "__main__":
    YOUR_FILE = "path/to/your/large_file.fasta"
    TARGET_PATTERN = ">DILT_0000000001"  # Adjust to your pattern
    LINES_TO_PRINT = 5  # Adjust to how many lines after the match you want
    print_pattern_and_next_lines(YOUR_FILE, TARGET_PATTERN, LINES_TO_PRINT)

Case 2: Match Any Line (Including Sequence Data) #

If you need to hunt for a pattern within the amino acid sequences themselves (like MKVVKICSKLR), use this slightly adjusted script:

def print_match_and_following(file_path, target_pattern, num_lines_after):
    with open(file_path, 'r') as fasta_file:
        match_active = False
        collected_lines = []
        line_counter = 0

        for raw_line in fasta_file:
            line = raw_line.rstrip('\n')
            
            if not match_active:
                # Trigger match if pattern is found in the current line
                if target_pattern in line:
                    match_active = True
                    collected_lines.append(line)
                    line_counter = 1
            else:
                collected_lines.append(line)
                line_counter += 1
                
                if line_counter > num_lines_after:
                    print('\n'.join(collected_lines))
                    # Remove break to find all matches
                    break
                    match_active = False
                    collected_lines = []

# Example usage
if __name__ == "__main__":
    YOUR_FILE = "path/to/your/large_file.fasta"
    TARGET_PATTERN = "MKVVKICSKLR"  # Amino acid sequence pattern
    LINES_TO_PRINT = 3
    print_match_and_following(YOUR_FILE, TARGET_PATTERN, LINES_TO_PRINT)

Option 2: Use Biopython (For FASTA-Specific Handling) #

If you don't mind installing a dedicated bioinformatics library, Biopython makes this even cleaner. It parses FASTA entries properly, so you don't have to worry about line breaks in sequences:

First, install Biopython if you haven't:

pip install biopython

Then use this script:

from Bio import SeqIO

def find_fasta_record_and_print(file_path, target_id, num_seq_lines=None):
    for record in SeqIO.parse(file_path, "fasta"):
        # Match against the sequence ID or full description
        if target_id in record.id or target_id in record.description:
            # Print the header
            print(f">{record.id} {record.description}")
            # Format the sequence into standard FASTA line lengths (60 chars per line)
            sequence = str(record.seq)
            seq_lines = [sequence[i:i+60] for i in range(0, len(sequence), 60)]
            
            if num_seq_lines:
                # Print only the first N sequence lines
                print('\n'.join(seq_lines[:num_seq_lines]))
            else:
                # Print the entire sequence
                print('\n'.join(seq_lines))
            # Remove break to find all matching records
            break

# Example usage
if __name__ == "__main__":
    YOUR_FILE = "path/to/your/large_file.fasta"
    TARGET_ID = "DILT_0000000001-mRNA-1"
    NUM_LINES = 5
    find_fasta_record_and_print(YOUR_FILE, TARGET_ID, NUM_LINES)

Key Notes #

• Both approaches process the file line-by-line, so they're memory-efficient for huge files.
• If you want to find all occurrences of the pattern instead of just the first, remove the break statement in the loops.
• For exact matches (not just "contains"), replace target_pattern in line with line == target_pattern (just make sure to handle newlines correctly with rstrip('\n')).

内容的提问来源于stack exchange，提问作者Tiago Minuzzi