BioPython II — Archivos biológicos y Entrez
BioPython II — Archivos biológicos y Entrez
En el capítulo anterior aprendiste a manipular secuencias in-memory con Seq y SeqRecord. En la práctica real, las secuencias viven en archivos: FASTA descargados de NCBI, GenBank con anotaciones, Fastq con lecturas de Illumina, archivos de alineamientos. BioPython ofrece el módulo Bio.SeqIO para leerlos y escribirlos de forma unificada, y el módulo Bio.Entrez para acceder por red a las bases de datos del NCBI.
En este capítulo aprenderás a parsear archivos multi-FASTA, a leer un GenBank y acceder a sus features, a extraer CDS y exportarlos, a convertir entre formatos, y a descargar registros desde NCBI con Entrez.esearch y Entrez.efetch respetando las normas de uso.
Importar SeqIO
from Bio import SeqIOSeqIO es el módulo central de lectura/escritura. Acepta decenas de formatos mediante el parámetro format. La filosofía es la misma siempre: un iterador devuelve objetos SeqRecord.
Formatos soportados
Algunos de los más usados en biología:
| Extensión | format= |
Uso típico |
|---|---|---|
.fasta |
"fasta" |
Secuencias de referencia, ensamblajes |
.gb |
"genbank" |
Anotaciones completas (features, CDS) |
.fastq |
"fastq" |
Lecturas de NGS con calidad Phred |
.fq.gz |
"fastq" (gzip) |
Lecturas comprimidas |
.embl |
"embl" |
Banco europeo |
.gbk |
"genbank" |
Variante de GenBank |
.pdb |
"pdb-atom" |
Estructuras 3D |
.afn |
"fasta" |
Múltiples alineamientos |
.nex |
"nexus" |
Filogenia |
Puedes ver la lista completa con:
import Bio.SeqIO as SeqIO
print(SeqIO.format_to_extension.keys() if hasattr(SeqIO, "format_to_extension") else
"ver documentación en https://biopython.org/wiki/SeqIO")SeqIO.parse() — múltiples secuencias
from Bio import SeqIO
# Archivo multi-FASTA con N secuencias
ruta = "secuencias.fasta"
# parse devuelve un ITERADOR: eficiente en memoria
for registro in SeqIO.parse(ruta, "fasta"):
print(registro.id, len(registro.seq))SeqIO.parse() devuelve un iterador: una vez recorrido se agota. Si necesitas acceder varias veces a las secuencias, conviértelo en lista: registros = list(SeqIO.parse(ruta, "fasta")). Para archivos enormes (GB), mantén el iterador y procésalo de una sola pasada.
SeqIO.read() — una sola secuencia
Cuando un archivo contiene exactamente una secuencia:
from Bio import SeqIO
registro = SeqIO.read("un_gen.gb", "genbank")
print(registro.id, registro.description)
print(registro.seq[:50])
print(len(registro.seq))read() lanza excepciones
Si el archivo tiene cero secuencias, lanza ValueError: No records found. Si tiene más de una, lanza ValueError: More than one record found. Úsalo solo cuando estás seguro del contenido.
Conversión entre formatos: SeqIO.convert()
from Bio import SeqIO
# Convertir un GenBank a FASTA en una sola línea
n = SeqIO.convert("un_gen.gb", "genbank",
"un_gen.fasta", "fasta")
print(f"Secuencias convertidas: {n}")convert() es eficiente (no construye la lista completa en memoria). Útil para pipelines ad hoc.
Escritura: SeqIO.write()
from Bio import SeqIO
from Bio.Seq import Seq
from Bio.SeqRecord import SeqRecord
registros = [
SeqRecord(Seq("ATGGCAGTGAAACTGCTGTTGAA"), id="gen1",
description="gen de prueba 1"),
SeqRecord(Seq("ATGCGTACGTACGTACGTACGTA"), id="gen2",
description="gen de prueba 2"),
SeqRecord(Seq("ATGCGTACGTACGTACGTACGTT"), id="gen3",
description="gen de prueba 3"),
]
# FASTA
SeqIO.write(registros, "salida.fasta", "fasta")
# GenBank (requiere molecule_type en annotations)
for r in registros:
r.annotations["molecule_type"] = "DNA"
SeqIO.write(registros, "salida.gb", "genbank")Análisis básico de un FASTA
from Bio import SeqIO
from Bio.SeqUtils import gc_fraction
ruta = "secuencias.fasta"
resumen = []
for r in SeqIO.parse(ruta, "fasta"):
resumen.append({
"id": r.id,
"length": len(r.seq),
"gc": gc_fraction(r.seq),
"desc": r.description
})
# Guardar resumen como CSV
import csv
with open("resumen.csv", "w", newline="") as fh:
w = csv.DictWriter(fh, fieldnames=["id","length","gc","desc"])
w.writeheader()
w.writerows(resumen)
print(f"{len(resumen)} secuencias procesadas.")Archivos GenBank: anotaciones, features, qualifiers
Un GenBank es un FASTA enriquecido con metadatos estructurados: organismo, fecha, topología, y features (genes, CDS, exones, dominios) cada uno con su location y qualifiers (gene, locus_tag, product, translation…).
from Bio import SeqIO
registro = SeqIO.read("un_gen.gb", "genbank")
# Metadatos globales
print("ID: ", registro.id)
print("Nombre: ", registro.name)
print("Desc: ", registro.description)
print("Organismo: ", registro.annotations.get("organism"))
print("Topología: ", registro.annotations.get("topology"))
print("Fecha: ", registro.annotations.get("date"))
# Iterar features
for feat in registro.features:
print(feat.type, "→", feat.location)Acceder a qualifiers
for feat in registro.features:
if feat.type == "CDS":
gene = feat.qualifiers.get("gene", ["?"])[0]
locus = feat.qualifiers.get("locus_tag", ["?"])[0]
product = feat.qualifiers.get("product", ["?"])[0]
protein_id = feat.qualifiers.get("protein_id", ["?"])[0]
translation = feat.qualifiers.get("translation", ["?"])[0]
print(f"CDS: {gene} ({locus}) - {product}")
print(f" protein_id: {protein_id}")
print(f" long. proteína: {len(translation)} aa")Los qualifiers de un SeqFeature son listas (aunque tengan un único elemento). Por eso siempre se indexa con [0] tras get. Si el qualifier no existe, get(key, ["default"]) evita el KeyError.
Extracción de CDS desde un GenBank
from Bio import SeqIO
from Bio.SeqRecord import SeqRecord
registro = SeqIO.read("un_gen.gb", "genbank")
cds_records = []
for feat in registro.features:
if feat.type == "CDS":
# Extraer la subsecuencia usando la ubicación
seq_cds = feat.extract(registro.seq)
gene = feat.qualifiers.get("gene", ["unknown"])[0]
prot = feat.qualifiers.get("translation", [""])[0]
rec = SeqRecord(
seq_cds,
id=f"{registro.id}_{gene}_cds",
description=f"CDS de {gene}; proteína {len(prot)} aa"
)
cds_records.append(rec)
# Guardar todos los CDS en un FASTA
SeqIO.write(cds_records, "cds_extraidos.fasta", "fasta")
print(f"{len(cds_records)} CDS extraídos.")feat.extract(seq) es listo
No es un slicing simple: respeta la hebra (feature.location.strand), los joins (exones dispersos se concatenan) y los gaps. Por eso siempre se usa feat.extract() en vez de seq[start:end].
Bio.Entrez: acceso a NCBI
El NCBI expone una API web (Entrez Programming Utilities, E-utilities) que BioPython envuelve en Bio.Entrez. Permite buscar y descargar registros de GenBank, PubMed, Protein, etc.
from Bio import Entrez
import time
# OBLIGATORIO: identificar al usuario con un email válido
Entrez.email = "tu_correo@institucion.edu"- Identifícate con
Entrez.email. NCBI puede bloquear IPs anónimas. - Máximo 3 peticiones por segundo sin clave API. Usa
time.sleep(0.34)entre llamadas. - Con clave API (pide una gratis en mi cuenta NCBI): hasta 10 peticiones/segundo; configura con
Entrez.api_key = "...". - Para descargas masivas usa datasets o Entrez Direct (edirect), no un bucle enorme en Python.
Entrez.esearch — buscar
from Bio import Entrez
import time
Entrez.email = "tu_correo@institucion.edu"
# Buscar "Homo sapiens BRCA1" en la base nucleotide
handle = Entrez.esearch(db="nucleotide",
term="Homo sapiens BRCA1",
retmax=5)
resultado = Entrez.read(handle)
handle.close()
print("Conteo total: ", resultado["Count"])
print("IDs devueltos: ", resultado["IdList"])
ids = resultado["IdList"]Entrez.efetch — descargar registros
# Descargar los primeros resultados en formato FASTA
time.sleep(0.34) # rate limit respetuoso
handle = Entrez.efetch(db="nucleotide",
id=",".join(ids[:3]),
rettype="fasta",
retmode="text")
fasta_texto = handle.read()
handle.close()
# Guardar en disco
with open("brca1_resultados.fasta", "w") as f:
f.write(fasta_texto)Para GenBank completo (con features):
handle = Entrez.efetch(db="nucleotide",
id=ids[0],
rettype="gbwithparts",
retmode="text")
gb_texto = handle.read()
handle.close()
with open("brca1.gb", "w") as f:
f.write(gb_texto)Entrez.read — parsear la respuesta XML
# esummary: metadatos sin secuencia
handle = Entrez.esummary(db="nucleotide", id=ids[0])
summary = Entrez.read(handle)
handle.close()
print(summary[0]["Title"], "|", summary[0]["TaxId"])
# elink: enlaces entre bases (p. ej. nucleotide → pubmed)
handle = Entrez.elink(dbfrom="nucleotide", id=ids[0], linkname="nuccore_pubmed")
links = Entrez.read(handle)
handle.close()Bio.ExPASy (mención breve)
from Bio import ExPASy
# Acceso a Prosite y SwissProt
# handle = ExPASy.get_prosite_raw("PS50001")
# print(handle.read())Bio.ExPASy está algo en desuso: para SIB/ExPASy moderno conviene acceder por REST directamente con requests. ExPASy sigue siendo útil para Prosite documentado y SwissProt viejo.
Pipeline mini: NCBI → FASTA proteica
from Bio import Entrez, SeqIO
from io import StringIO
import time
Entrez.email = "tu_correo@institucion.edu"
# 1. Buscar gen
h = Entrez.esearch(db="nucleotide", term="Homo sapiens BRCA1 mRNA", retmax=1)
ids = Entrez.read(h)["IdList"]
h.close()
# 2. Descargar en GenBank
time.sleep(0.34)
h = Entrez.efetch(db="nucleotide", id=ids[0], rettype="gb", retmode="text")
gb_texto = h.read()
h.close()
# 3. Leer con SeqIO (desde string con StringIO)
registro = SeqIO.read(StringIO(gb_texto), "genbank")
# 4. Extraer CDS y traducir
for feat in registro.features:
if feat.type == "CDS":
proteina = feat.qualifiers["translation"][0]
print(f"BRCA1: {len(proteina)} aa")
# 5. Guardar proteína en FASTA
from Bio.Seq import Seq
from Bio.SeqRecord import SeqRecord
prot_rec = SeqRecord(Seq(proteina),
id=f"{registro.id}_prot",
description=f"BRCA1 protein from {registro.id}")
SeqIO.write([prot_rec], "brca1_prot.fasta", "fasta")Ejercicios
Ejercicio 1
Crea con código un archivo multi-FASTA con 3 secuencias (id1, id2, id3) cada una con secuencias distintas. Léelo con SeqIO.parse() y construye un diccionario {id: longitud}.
Ejercicio 2
Escribe una función estadisticas_fasta(ruta) que reciba la ruta de un FASTA, lea las secuencias con SeqIO.parse() y devuelva para cada una: id, longitud y %GC. Pruébala con el archivo del Ejercicio 1.
Ejercicio 3
Escribe el código completo para buscar en NCBI "Homo sapiens BRCA1" con Entrez.esearch y descargar los 3 primeros resultados con Entrez.efetch en formato FASTA. Muestra el id y la longitud de cada secuencia. Incluye Entrez.email y time.sleep(0.34) entre llamadas.
El código del Ejercicio 3 debe ser correcto aunque para ejecutarlo necesites conexión real a NCBI. En el laboratorio funcionará tal cual.
Soluciones
Solución 1
from Bio import SeqIO
from Bio.Seq import Seq
from Bio.SeqRecord import SeqRecord
# 1) Definir tres secuencias distintas
registros = [
SeqRecord(Seq("ATGGCAGTGAAACTGCTGTTGAAAGCGCAGAAGTTTAA"),
id="id1", description="seq uno"),
SeqRecord(Seq("ATGCGTACGTACGTACGTACGTACGTACGTACGTAA"),
id="id2", description="seq dos"),
SeqRecord(Seq("ATGAAACCCGGGTTTAAACCCGGGTTTAAACCCGGG"),
id="id3", description="seq tres"),
]
# 2) Escribir el archivo multi-FASTA
ruta = "mis_secuencias.fasta"
SeqIO.write(registros, ruta, "fasta")
print(f"Archivo '{ruta}' creado con {len(registros)} secuencias.")
# 3) Leer con SeqIO.parse() y construir diccionario {id: longitud}
longitudes = {}
for rec in SeqIO.parse(ruta, "fasta"):
longitudes[rec.id] = len(rec.seq)
print("Diccionario id → longitud:")
for k, v in longitudes.items():
print(f" {k}: {v} nt")Comentario: el flujo crear → escribir → leer → procesar es exactamente el que usarás cuando recibas un lote de secuencias de un assembler o de un colaborador. El diccionario id → longitud es la estructura más simple y útil para un informe rápido.
Solución 2
from Bio import SeqIO
from Bio.SeqUtils import gc_fraction
def estadisticas_fasta(ruta):
"""
Recibe la ruta de un FASTA y devuelve una lista de diccionarios
con id, longitud y %GC de cada secuencia.
"""
resultados = []
for rec in SeqIO.parse(ruta, "fasta"):
resultados.append({
"id": rec.id,
"longitud": len(rec.seq),
"gc": round(gc_fraction(rec.seq) * 100, 2)
})
return resultados
# Prueba con el archivo del Ejercicio 1
ruta = "mis_secuencias.fasta"
stats = estadisticas_fasta(ruta)
print(f"{'ID':<8}{'Longitud':<10}{'%GC':<8}")
for s in stats:
print(f"{s['id']:<8}{s['longitud']:<10}{s['gc']:<8}")Comentario: gc_fraction devuelve un valor entre 0 y 1; lo multiplicamos por 100 para tener porcentaje. La función devuelve una lista de dicts, fácil de convertir a pandas.DataFrame:
import pandas as pd
df = pd.DataFrame(estadisticas_fasta(ruta))
print(df)
print("Longitud media:", df["longitud"].mean())
print("%GC medio: ", df["gc"].mean())Solución 3
from Bio import Entrez, SeqIO
from io import StringIO
import time
# 1) IDENTIFICACIÓN OBLIGATORIA: usar email institucional válido
Entrez.email = "tu_correo@institucion.edu"
# 2) Buscar "Homo sapiens BRCA1" en la base nucleotide
# retmax=3 → solo los 3 primeros resultados
search_handle = Entrez.esearch(
db="nucleotide",
term="Homo sapiens BRCA1",
retmax=3
)
search_result = Entrez.read(search_handle)
search_handle.close()
ids = search_result["IdList"]
print(f"Total de coincidencias: {search_result['Count']}")
print(f"IDs a descargar: {ids}")
# 3) RESPETAR RATE LIMIT de NCBI: dormir 0.34 s (= 3 req/s)
time.sleep(0.34)
# 4) Descargar los 3 registros en formato FASTA (rettype=fasta, retmode=text)
# Pasamos los IDs separados por coma a un único efetch
fetch_handle = Entrez.efetch(
db="nucleotide",
id=",".join(ids),
rettype="fasta",
retmode="text"
)
fasta_data = fetch_handle.read()
fetch_handle.close()
# 5) Guardar a disco para preservar las secuencias
with open("brca1_ncbi.fasta", "w") as f:
f.write(fasta_data)
print("Sequences guardadas en 'brca1_ncbi.fasta'.")
# 6) Leer las secuencias descargadas con SeqIO (desde string con StringIO)
# y mostrar id + longitud de cada una
time.sleep(0.34) # respetuoso si hiciéramos otra llamada a continuación
registros = list(SeqIO.parse(StringIO(fasta_data), "fasta"))
print(f"\n{'ID':<20}{'Longitud (nt)':<15}")
print("-" * 35)
for r in registros:
print(f"{r.id:<20}{len(r.seq):<15}")Comentario del flujo:
Entrez.emailes obligatorio. NCBI bloquea peticiones anónimas y, en caso de abuso, contacta al responsable de ese email.esearchdevuelve una lista de IDs en la base elegida; no descarga las secuencias, solo sus identificadores internos.time.sleep(0.34)entre llamadas garantiza ≤3 peticiones/segundo, el límite sin clave API. Con unaEntrez.api_keypodrías bajarlo a 0.1 s (10 req/s).efetchconrettype="fasta"yretmode="text"devuelve el FASTA como string; lo guardamos en disco y lo releemos conSeqIO.parse()para inspeccionarlo.StringIOactúa como “archivo en memoria”: permite pasar un string a funciones que esperan un file handle, evitando leer/escribir en disco dos veces.
Si no tienes conexión o vas a probar el pipeline sin red, descarga un GenBank desde la web (p. ej. https://www.ncbi.nlm.nih.gov/nuccore/NM_007294 → Send to → File → *GenBank) y sustituye el bloqueesearch + efetchporSeqIO.read(“NM_007294.gb”, “genbank”)`. El resto del código es idéntico.
Cierre del curso
Con este capítulo finalizas un recorrido completo: desde la sintaxis básica de Python (capítulos 1–3) hasta las estructuras de datos (4–7), el manejo de archivos y excepciones (8–9), el cálculo numérico con NumPy (10), el análisis tabular con pandas (11), la visualización con Matplotlib (12) y Seaborn (13), la estadística con SciPy (14) y la biología molecular computacional con BioPython (15–16).
Tienes ahora una caja de herramientas lista para:
- Procesar datos experimentales (absorbancias, conteos, morfometrías).
- Visualizarlos de forma profesional para tesis y papers.
- Aplicar las pruebas estadísticas correctas con criterio.
- Manipular secuencias biológicas y calcularles %GC, Tm, peso molecular.
- Descargar y anotar secuencias desde NCBI.
Los siguientes pasos naturales son scikit-learn (aprendizaje automático), statsmodels (modelos estadísticos avanzados), scanpy / AnnData (single-cell RNA-seq), pysam (archivos BAM/VCF) y snakemake / nextflow (pipelines reproducibles). Pero el andamiaje que has construido aquí es el suelo sobre el que todo lo demás se construye.
¡Feliz hacking biológico!
