Version Compatibility
Reference examples tested with: BioPython 1.83+
Before using code patterns, verify installed versions match. If versions differ:
- Python:
pip show biopython then help(module.function) to check signatures
If code throws ImportError, AttributeError, or TypeError, introspect the installed
package and adapt the example to match the actual API rather than retrying.
Read Sequences
Read biological sequence data from files using Biopython's Bio.SeqIO module.
"Read sequences from a file" → Parse file into a collection of SeqRecord objects with IDs, sequences, and annotations accessible.
- Python:
SeqIO.parse() or SeqIO.read() (BioPython)
- R:
readDNAStringSet() or readAAStringSet() (Biostrings)
Required Import
Core import
from Bio import SeqIO
Core Functions
SeqIO.parse() - Multiple Records
Use for files with one or more sequences. Returns an iterator of SeqRecord objects.
for record in SeqIO.parse('sequences.fasta', 'fasta'):
print(record.id, len(record.seq))
Important: Always specify the format explicitly as the second argument.
SeqIO.read() - Single Record
Use when file contains exactly one sequence. Raises error if zero or multiple records.
record = SeqIO.read('single.fasta', 'fasta')
SeqIO.to_dict() - Load All Into Memory
Use for random access by record ID. Loads entire file into memory.
records = SeqIO.to_dict(SeqIO.parse('sequences.fasta', 'fasta'))
seq = records['sequence_id'].seq
SeqIO.index() - Large File Random Access
Use for large files when random access is needed without loading everything into memory.
records = SeqIO.index('large.fasta', 'fasta')
seq = records['sequence_id'].seq
records.close()
SeqIO.index_db() - SQLite-Backed Indexing
Use for very large files or multiple files. Creates persistent SQLite index.
# Create index (first time - parses file)
records = SeqIO.index_db('index.sqlite', 'large.fasta', 'fasta')
seq = records['sequence_id'].seq
records.close()
# Reuse existing index (instant load)
records = SeqIO.index_db('index.sqlite')
# Index multiple files together
records = SeqIO.index_db('combined.sqlite', ['file1.fasta', 'file2.fasta'], 'fasta')
Advantages over index():
- Persistent index survives program restarts
- Can index multiple files as one database
- Lower memory for extremely large files
- SQLite file can be shared across processes
High-Performance Parsing
For maximum throughput on large files, use low-level parsers (3-6x faster than SeqIO.parse):
SimpleFastaParser
Goal: Parse large FASTA files at maximum speed without SeqRecord overhead.
Approach: Use low-level tuple-based parser returning (title, sequence) strings.
Reference (BioPython 1.83+):
from Bio.SeqIO.FastaIO import SimpleFastaParser
with open('large.fasta') as handle:
for title, sequence in SimpleFastaParser(handle):
if len(sequence) > 1000:
print(title.split()[0]) # First word is usually ID
Returns (title, sequence) tuples as strings (no SeqRecord overhead).
FastqGeneralIterator
Goal: Parse large FASTQ files at maximum speed.
Approach: Use low-level tuple-based parser returning (title, sequence, quality_string) strings.
Reference (BioPython 1.83+):
from Bio.SeqIO.QualityIO import FastqGeneralIterator
with open('reads.fastq') as handle:
for title, sequence, quality in FastqGeneralIterator(handle):
avg_qual = sum(ord(c) - 33 for c in quality) / len(quality)
Returns (title, sequence, quality_string) tuples.
Common Formats
| Format | String | Typical Extension | Notes |
|---|
| FASTA | 'fasta' | .fasta, .fa, .fna, .faa | Most common |
| FASTA 2-line | 'fasta-2line' | .fasta | One line per sequence (no wrapping) |
| FASTQ | 'fastq' | .fastq, .fq | With quality scores |
| FASTQ Solexa | 'fastq-solexa' | .fastq | Old Solexa/Illumina (pre-1.3) |
| FASTQ Illumina | 'fastq-illumina' | .fastq | Illumina 1.3-1.7 |
| GenBank | 'genbank' or 'gb' | .gb, .gbk | With features/annotations |
| EMBL | 'embl' | .embl | European format with features |
| Swiss-Prot | 'swiss' | .dat | UniProt format |
Specialized Formats
| Format | String | Use Case |
|---|
| ABI | 'abi' | Sanger sequencing trace files (.ab1) |
| ABI Trimmed | 'abi-trim' | ABI with low-quality ends trimmed |
| SFF | 'sff' | 454/Ion Torrent flowgram data |
| SFF Trimmed | 'sff-trim' | SFF with adapter/quality trimming |
| QUAL | 'qual' | Quality scores file (pairs with FASTA) |
| PHD | 'phd' | Phred/Phrap/Consed output |
| ACE | 'ace' | Assembly format (Consed) |
| PDB SEQRES | 'pdb-seqres' | Protein sequences from PDB files |
| PDB ATOM | 'pdb-atom' | Sequences from ATOM records in PDB |
| SnapGene | 'snapgene' | SnapGene .dna files |
| GCK | 'gck' | Gene Construction Kit files |
| XDNA | 'xdna' | DNA Strider / SerialCloner files |
Reading ABI Trace Files
# Read Sanger sequencing trace with quality
record = SeqIO.read('sample.ab1', 'abi')
print(f'Sequence: {record.seq}')
qualities = record.letter_annotations['phred_quality']
# Auto-trim low quality ends
record_trimmed = SeqIO.read('sample.ab1', 'abi-trim')
Reading 454/Ion Torrent SFF
for record in SeqIO.parse('reads.sff', 'sff'):
print(record.id, len(record.seq))
# With trimming applied
for record in SeqIO.parse('reads.sff', 'sff-trim'):
print(record.id, len(record.seq))
Reading PDB Sequences
# Get sequences from SEQRES records
for record in SeqIO.parse('structure.pdb', 'pdb-seqres'):
print(f'Chain {record.id}: {record.seq}')
# Get sequences from ATOM coordinates
for record in SeqIO.parse('structure.pdb', 'pdb-atom'):
print(f'Chain {record.id}: {record.seq}')
Alignment Formats (Read-Only)
| Format | String | Notes |
|---|
| PHYLIP | 'phylip' | Interleaved phylip |
| PHYLIP Sequential | 'phylip-sequential' | Sequential phylip |
| PHYLIP Relaxed | 'phylip-relaxed' | Longer names allowed |
| Clustal | 'clustal' | ClustalW output |
| Stockholm | 'stockholm' | Rfam/Pfam alignments |
| NEXUS | 'nexus' | PAUP/MrBayes format |
| MAF | 'maf' | Multiple Alignment Format |
SeqRecord Object Attributes
After parsing, each record has these key attributes:
record.id # Sequence identifier (string)
record.name # Sequence name (string)
record.description # Full description line (string)
record.seq # Sequence data (Seq object)
record.features # List of SeqFeature objects (GenBank/EMBL)
record.annotations # Dictionary of annotations
record.letter_annotations # Per-letter annotations (quality scores)
record.dbxrefs # Database cross-references
Code Patterns
Collect All Sequences Into a List
records = list(SeqIO.parse('sequences.fasta', 'fasta'))
Count Records Without Loading All
count = sum(1 for _ in SeqIO.parse('sequences.fasta', 'fasta'))
Fast Count (FASTA only)
from Bio.SeqIO.FastaIO import SimpleFastaParser
with open('sequences.fasta') as f:
count = sum(1 for _ in SimpleFastaParser(f))
Get Sequence IDs Only
ids = [record.id for record in SeqIO.parse('sequences.fasta', 'fasta')]
Read GenBank with Features
for record in SeqIO.parse('sequence.gb', 'genbank'):
for feature in record.features:
if feature.type == 'CDS':
print(feature.qualifiers.get('product', ['Unknown'])[0])
cds_seq = feature.extract(record.seq) # Get feature sequence
Access FASTQ Quality Scores
for record in SeqIO.parse('reads.fastq', 'fastq'):
qualities = record.letter_annotations['phred_quality']
avg_quality = sum(qualities) / len(qualities)
Read From File Handle
with open('sequences.fasta', 'r') as handle:
for record in SeqIO.parse(handle, 'fasta'):
print(record.id)
Custom ID Function for Indexing
def get_accession(identifier):
return identifier.split('.')[0] # Remove version
records = SeqIO.index('sequences.fasta', 'fasta', key_function=get_accession)
Common Errors
| Error | Cause | Solution |
|---|
ValueError: More than one record | Used read() on multi-record file | Use parse() instead |
ValueError: No records found | Used read() on empty file | Check file exists and has content |
ValueError: unknown format | Typo in format string | Check format string spelling |
UnicodeDecodeError | Binary file or wrong encoding | Open with encoding='latin-1' or check file |
sqlite3.OperationalError | index_db file locked | Close other connections first |
Decision Tree
Need to read sequences?
├── Single record in file?
│ └── Use SeqIO.read()
├── Multiple records?
│ ├── Need all in memory at once?
│ │ └── Use list(SeqIO.parse()) or SeqIO.to_dict()
│ ├── Process one at a time (memory efficient)?
│ │ └── Use SeqIO.parse() iterator
│ ├── Large file, need random access by ID?
│ │ ├── Single session? → Use SeqIO.index()
│ │ └── Persistent/multi-file? → Use SeqIO.index_db()
│ └── Maximum throughput needed?
│ └── Use SimpleFastaParser or FastqGeneralIterator
├── Sanger sequencing trace?
│ └── Use 'abi' or 'abi-trim' format
├── 454/Ion Torrent data?
│ └── Use 'sff' or 'sff-trim' format
└── Protein from structure?
└── Use 'pdb-seqres' or 'pdb-atom' format
Related Skills
- write-sequences - Write parsed sequences to new files
- filter-sequences - Filter sequences by criteria after reading
- format-conversion - Convert between formats
- compressed-files - Read gzip/bzip2/BGZF compressed sequence files
- sequence-manipulation/seq-objects - Work with parsed SeqRecord objects
- database-access - Fetch sequences from NCBI instead of local files
- alignment-files - For SAM/BAM/CRAM alignment files, use samtools/pysam