Biopython is a comprehensive set of freely available Python tools for biological computation — sequence manipulation, file I/O, database access, structural bioinformatics, and phylogenetics. USE WHEN parsing FASTA/GenBank or other bio file formats, querying NCBI/Entrez, or running sequence/structure/phylogenetic analysis in Python.
Installer avec Codex ou Claude Copiez ce prompt, collez-le dans Codex, Claude ou un autre assistant, puis laissez-le vérifier la page du skill et l'installer pour vous.
Une commande directe contourne le prompt de vérification. Examinez la source avant de l'exécuter.
Biopython is a comprehensive set of freely available Python tools for biological computation — sequence manipulation, file I/O, database access, structural bioinformatics, and phylogenetics. USE WHEN parsing FASTA/GenBank or other bio file formats, querying NCBI/Entrez, or running sequence/structure/phylogenetic analysis in Python.
license
Unknown
metadata
{"skill-author":"K-Dense Inc."}
risk
unknown
source
https://github.com/biopython/biopython
cluster
databases-data
version
1.0.0
origin
antigravity-awesome-skills (MIT)
Biopython: Computational Molecular Biology in Python
Overview
Biopython is a comprehensive set of freely available Python tools for biological computation. It provides functionality for sequence manipulation, file I/O, database access, structural bioinformatics, phylogenetics, and many other bioinformatics tasks. The current version is Biopython 1.85 (released January 2025), which supports Python 3 and requires NumPy.
When to Use This Skill
Use this skill when:
Working with biological sequences (DNA, RNA, or protein)
Biopython is organized into modular sub-packages, each addressing specific bioinformatics domains:
Sequence Handling - Bio.Seq and Bio.SeqIO for sequence manipulation and file I/O
Alignment Analysis - Bio.Align and Bio.AlignIO for pairwise and multiple sequence alignments
Database Access - Bio.Entrez for programmatic access to NCBI databases
BLAST Operations - Bio.Blast for running and parsing BLAST searches
Structural Bioinformatics - Bio.PDB for working with 3D protein structures
Phylogenetics - Bio.Phylo for phylogenetic tree manipulation and visualization
Advanced Features - Motifs, population genetics, sequence utilities, and more
Installation and Setup
Install Biopython using pip (requires Python 3 and NumPy):
uv pip install biopython
For NCBI database access, always set your email address (required by NCBI):
from Bio import Entrez
Entrez.email = "your.email@example.com"
Entrez.api_key =
# Optional: API key for higher rate limits (10 req/s instead of 3 req/s)
"your_api_key_here"
Using This Skill
This skill provides comprehensive documentation organized by functionality area. When working on a task, consult the relevant reference documentation:
1. Sequence Handling (Bio.Seq & Bio.SeqIO)
Reference:references/sequence_io.md
Use for:
Creating and manipulating biological sequences
Reading and writing sequence files (FASTA, GenBank, FASTQ, etc.)
Converting between file formats
Extracting sequences from large files
Sequence translation, transcription, and reverse complement
Working with SeqRecord objects
Quick example:
from Bio import SeqIO
# Read sequences from FASTA filefor record in SeqIO.parse("sequences.fasta", "fasta"):
print(f"{record.id}: {len(record.seq)} bp")
# Convert GenBank to FASTA
SeqIO.convert("input.gb", "genbank", "output.fasta", "fasta")
2. Alignment Analysis (Bio.Align & Bio.AlignIO)
Reference:references/alignment.md
Use for:
Pairwise sequence alignment (global and local)
Reading and writing multiple sequence alignments
Using substitution matrices (BLOSUM, PAM)
Calculating alignment statistics
Customizing alignment parameters
Quick example:
from Bio import Align
# Pairwise alignment
aligner = Align.PairwiseAligner()
aligner.mode = 'global'
alignments = aligner.align("ACCGGT", "ACGGT")
print(alignments[0])
Reading and writing phylogenetic trees (Newick, NEXUS, phyloXML)
Building trees from distance matrices or alignments
Tree manipulation (pruning, rerooting, ladderizing)
Calculating phylogenetic distances
Creating consensus trees
Visualizing trees
Quick example:
from Bio import Phylo
# Read and visualize tree
tree = Phylo.read("tree.nwk", "newick")
Phylo.draw_ascii(tree)
# Calculate distance
distance = tree.distance("Species_A", "Species_B")
print(f"Distance: {distance:.3f}")
7. Advanced Features
Reference:references/advanced.md
Use for:
Sequence motifs (Bio.motifs) - Finding and analyzing motif patterns
Population genetics (Bio.PopGen) - GenePop files, Fst calculations, Hardy-Weinberg tests
Clustering (Bio.Cluster) - K-means and hierarchical clustering
Genome diagrams (GenomeDiagram) - Visualizing genomic features
Quick example:
from Bio.SeqUtils import gc_fraction, molecular_weight
from Bio.Seq import Seq
seq = Seq("ATCGATCGATCG")
print(f"GC content: {gc_fraction(seq):.2%}")
print(f"Molecular weight: {molecular_weight(seq, seq_type='DNA'):.2f} g/mol")
General Workflow Guidelines
Reading Documentation
When a user asks about a specific Biopython task:
Identify the relevant module based on the task description
Read the appropriate reference file using the Read tool
Extract relevant code patterns and adapt them to the user's specific needs
Combine multiple modules when the task requires it
Example search patterns for reference files:
# Find information about specific functions
grep -n "SeqIO.parse" references/sequence_io.md
# Find examples of specific tasks
grep -n "BLAST" references/blast.md
# Find information about specific concepts
grep -n "alignment" references/alignment.md
Writing Biopython Code
Follow these principles when writing Biopython code:
Import modules explicitly
from Bio import SeqIO, Entrez
from Bio.Seq import Seq
Set Entrez email when using NCBI databases
Entrez.email = "your.email@example.com"
Use appropriate file formats - Check which format best suits the task
# Common formats: "fasta", "genbank", "fastq", "clustal", "phylip"
Handle files properly - Close handles after use or use context managers
withopen("file.fasta") as handle:
records = SeqIO.parse(handle, "fasta")
Use iterators for large files - Avoid loading everything into memory
for record in SeqIO.parse("large_file.fasta", "fasta"):
# Process one record at a time
Handle errors gracefully - Network operations and file parsing can fail
from Bio import Entrez, SeqIO
Entrez.email = "your.email@example.com"# Fetch sequence
handle = Entrez.efetch(db="nucleotide", id="EU490707", rettype="gb", retmode="text")
record = SeqIO.read(handle, "genbank")
handle.close()
print(f"Description: {record.description}")
print(f"Sequence length: {len(record.seq)}")
Pattern 2: Sequence Analysis Pipeline
from Bio import SeqIO
from Bio.SeqUtils import gc_fraction
for record in SeqIO.parse("sequences.fasta", "fasta"):
# Calculate statistics
gc = gc_fraction(record.seq)
length = len(record.seq)
# Find ORFs, translate, etc.
protein = record.seq.translate()
print(f"{record.id}: {length} bp, GC={gc:.2%}")
Pattern 3: BLAST and Fetch Top Hits
from Bio.Blast import NCBIWWW, NCBIXML
from Bio import Entrez, SeqIO
Entrez.email = "your.email@example.com"# Run BLAST
result_handle = NCBIWWW.qblast("blastn", "nt", sequence)
blast_record = NCBIXML.read(result_handle)
# Get top hit accessions
accessions = [aln.accession for aln in blast_record.alignments[:5]]
# Fetch sequencesfor acc in accessions:
handle = Entrez.efetch(db="nucleotide", id=acc, rettype="fasta", retmode="text")
record = SeqIO.read(handle, "fasta")
handle.close()
print(f">{record.description}")
Pattern 4: Build Phylogenetic Tree from Sequences
from Bio import AlignIO, Phylo
from Bio.Phylo.TreeConstruction import DistanceCalculator, DistanceTreeConstructor
# Read alignment
alignment = AlignIO.read("alignment.fasta", "fasta")
# Calculate distances
calculator = DistanceCalculator("identity")
dm = calculator.get_distance(alignment)
# Build tree
constructor = DistanceTreeConstructor()
tree = constructor.nj(dm)
# Visualize
Phylo.draw_ascii(tree)
Best Practices
Always read relevant reference documentation before writing code
Use grep to search reference files for specific functions or examples
Validate file formats before parsing
Handle missing data gracefully - Not all records have all fields
Cache downloaded data - Don't repeatedly download the same sequences
Respect NCBI rate limits - Use API keys and proper delays
Test with small datasets before processing large files
Keep Biopython updated to get latest features and bug fixes
Use appropriate genetic code tables for translation
Document analysis parameters for reproducibility
Troubleshooting Common Issues
Issue: "No handlers could be found for logger 'Bio.Entrez'"
Solution: This is just a warning. Set Entrez.email to suppress it.
Issue: "HTTP Error 400" from NCBI
Solution: Check that IDs/accessions are valid and properly formatted.
Issue: "ValueError: EOF" when parsing files
Solution: Verify file format matches the specified format string.
Issue: Alignment fails with "sequences are not the same length"
Solution: Ensure sequences are aligned before using AlignIO or MultipleSeqAlignment.
Issue: BLAST searches are slow
Solution: Use local BLAST for large-scale searches, or cache results.
Issue: PDB parser warnings
Solution: Use PDBParser(QUIET=True) to suppress warnings, or investigate structure quality.
To locate information in reference files, use these search patterns:
# Search for specific functions
grep -n "function_name" references/*.md
# Find examples of specific tasks
grep -n "example" references/sequence_io.md
# Find all occurrences of a module
grep -n "Bio.Seq" references/*.md
Summary
Biopython provides comprehensive tools for computational molecular biology. When using this skill:
Identify the task domain (sequences, alignments, databases, BLAST, structures, phylogenetics, or advanced)
Consult the appropriate reference file in the references/ directory
Adapt code examples to the specific use case
Combine multiple modules when needed for complex workflows
Follow best practices for file handling, error checking, and data management
The modular reference documentation ensures detailed, searchable information for every major Biopython capability.
Limitations
Use this skill only when the task clearly matches the scope described above.
Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.
