{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "8d7113e4",
   "metadata": {},
   "source": [
    "# Programación para las ciencias biológicas\n",
    "## Python\n",
    "**Docente:**  Charles Escobar  \n",
    "2025"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b180836f",
   "metadata": {},
   "source": [
    "**Nombre del estudiante:**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a4a50ff",
   "metadata": {},
   "source": [
    "Ingrese aquí su nombre"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2504bfe-f22f-457c-9cf9-03a1d26497bd",
   "metadata": {},
   "source": [
    "# **Bibliotecas Especializadas para Bioinformática en R y Python**\n",
    "\n",
    "**¿Qué esperamos aprender en esta libreta?**\n",
    "\n",
    "En esta libreta de trabajo, vamos a explorar los siguientes temas:\n",
    "\n",
    "* Trabajar con BioPython  \n",
    "* Importar Secuencias biológicas\n",
    "* Usar librerías especializadas para trabajar con secuencias biológicas"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "16f6400d-9031-4cfe-b8fb-39544d3ae568",
   "metadata": {},
   "source": [
    "# BioPython\n",
    "proyecto de código abierto que proporciona herramientas y módulos de Python para el análisis de datos en biología computacional y bioinformática. Diseñado para manejar datos biológicos como secuencias de ADN/ARN, estructuras proteicas o información genómica, incluye funcionalidades para manipulación de secuencias, lectura/escritura de formatos de archivo comunes (FASTA, GenBank, PDB), acceso a bases de datos biológicas (NCBI, UniProt) y ejecución de algoritmos como alineamientos, análisis filogenéticos o modelado estructural."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90766b50-2187-4948-9918-dc066137aa6d",
   "metadata": {},
   "source": [
    "## Instalación\n",
    "\n",
    "pip install biopython"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "58aa52bd-5b62-480d-bc62-8a0bfbc2829e",
   "metadata": {},
   "outputs": [],
   "source": [
    "pip install biopython"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "859a7246-a2ce-42f3-835c-23955b33d948",
   "metadata": {},
   "source": [
    "# Leer secuencias biológicas\n",
    "**SeqIO** (Sequential Input/Output) es un módulo de **Biopython** diseñado para leer, escribir y manipular archivos de secuencias biológicas en múltiples formatos (FASTA, GenBank, FASTQ, etc.). Su funcionamiento se basa en tres operaciones clave:  \n",
    "\n",
    "1. **Lectura de secuencias**:  \n",
    "   - Usa `SeqIO.parse(archivo, formato)` para leer archivos con múltiples registros (p. ej., un archivo FASTA con varias secuencias). Retorna un **iterador** que permite acceder a cada registro (objeto `SeqRecord`) secuencialmente.  \n",
    "   - `SeqIO.read(archivo, formato)` se emplea para archivos con un **único registro**, retornando directamente un objeto `SeqRecord`.  \n",
    "\n",
    "2. **Estructura de datos**:  \n",
    "   - Cada `SeqRecord` contiene:  \n",
    "     - `seq`: Objeto `Seq` con la secuencia (ADN, ARN, proteína).  \n",
    "     - `id`: Identificador único.  \n",
    "     - `description`: Descripción opcional.  \n",
    "     - `annotations`: Metadatos (p. ej., especie, taxonomía).  \n",
    "\n",
    "3. **Escritura de secuencias**:  \n",
    "   - `SeqIO.write(secuencias, archivo_salida, formato)` guarda registros en un formato específico. Admite listas de `SeqRecord` o generadores.  \n",
    "\n",
    "\n",
    "**Formatos soportados**: Incluye >30 formatos (ej: `fasta`, `genbank`, `fastq`, `phylip`). Es clave especificar el formato correcto al leer/escribir.  \n",
    "\n",
    "**Nota**: Para archivos grandes, el uso de iteradores evita cargar todos los datos en memoria,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5352fd1e-5093-4a9b-a797-3b8cb606da8b",
   "metadata": {},
   "outputs": [],
   "source": [
    "from Bio import SeqIO"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1a817be-3cb2-4ee2-90e0-d541bafd3e68",
   "metadata": {},
   "source": [
    "# Leer un archivo FASTA:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4b1a8e7a-2506-4aa0-a912-706797c3e2ff",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "for record in SeqIO.parse(\"sampledata/t-coffee/sproteases_small_dna.fasta\", \"fasta\"):\n",
    "    print(f\">{record.id}\")\n",
    "    print(record.seq)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "77271cee-6dcb-476f-9cc9-b6b8dbbe7b7c",
   "metadata": {},
   "source": [
    "# Leer el archivo FASTA y almacenar todas las secuencias en una lista"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2311992f-3be7-41cb-85fb-38444d37edf1",
   "metadata": {},
   "outputs": [],
   "source": [
    "registros = list(SeqIO.parse(\"sampledata/t-coffee/sproteases_small_dna.fasta\", \"fasta\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "99be35db-5ba7-4f20-9cc7-107ae05633ff",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(registros)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "77f1fa0e-bdf6-49c4-b828-37772de37559",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(registros[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4e45bcac-948f-4595-a757-e11396469866",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Almacenar la primera secuencia en una variable separada\n",
    "primera_secuencia = registros[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "43100309-9d2a-4454-a3f8-4048c106a814",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Verificar la información básica de la primera secuencia\n",
    "print(f\"ID primera secuencia: {primera_secuencia.id}\")\n",
    "print(f\"Longitud: {len(primera_secuencia.seq)} nucleótidos\")\n",
    "print(f\"Primeros 10 nucleótidos: {primera_secuencia.seq[:10]}\")\n",
    "print(f\"Últimos 20 nucleótidos: {primera_secuencia.seq[-20:]}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2ab07f73-797b-4d35-a807-9d40124693b2",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Primeros 10 nucleótidos:\", primera_secuencia.seq[:10])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "61615a19-cfa8-422e-87b4-d996b810fc84",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "primera_secuencia.seq[:10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ccf0fffa-5bf2-4dfc-b52f-82ae5063bba7",
   "metadata": {},
   "outputs": [],
   "source": [
    "primera_secuencia.seq[:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "04a96e84-9ecc-463b-9d4f-40a99c7c741b",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "primera_secuencia.id"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b3a0cb71-d4f2-4fb0-869f-a979ed389e7a",
   "metadata": {},
   "source": [
    "# Iterar sobre todas las secuencias"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a9cf4663-9c17-4415-833d-d79604e97bc1",
   "metadata": {},
   "outputs": [],
   "source": [
    "i=0\n",
    "for secuencia in registros:\n",
    "    print(f\"{i}: >{secuencia.id}: {len(secuencia.seq)} bp\")\n",
    "    i +=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e3da8932-837f-434e-bd38-5a2e9d55b918",
   "metadata": {},
   "outputs": [],
   "source": [
    "registros[0].seq.upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "039f977c-203c-437a-946c-fca57047c2de",
   "metadata": {},
   "outputs": [],
   "source": [
    "registros[18].id"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3061e110-0629-48ca-8e72-7ada2e1a6f7e",
   "metadata": {},
   "source": [
    "El siguiente código identifica si se trata de la hevra codificante o molde:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "74142d0f-c53d-4cae-9fae-f1cfaebede71",
   "metadata": {},
   "outputs": [],
   "source": [
    "registros[18].seq[-20:]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b33291a1-1f14-4dbe-b791-a6c71c2de731",
   "metadata": {},
   "source": [
    "# Transcripción: ADN → ARNm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a37acd1c-ed96-404c-8a01-a1055716bf03",
   "metadata": {},
   "outputs": [],
   "source": [
    "arnm = registros[0].seq.transcribe()\n",
    "print(f\"\\nSecuencia ID: {registros[0].id}\")\n",
    "print(f\"\\nARNm: {arnm}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "503ce405-6fcb-4e47-ab00-bf57fea59a4a",
   "metadata": {},
   "source": [
    "Podemos ubicar el codón AUG de inicio del transcrito:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c6ff268-bb42-45dd-bfcd-90cf1ba8b91c",
   "metadata": {},
   "source": [
    "`registros[0].seq`: Accede a la secuencia de ADN almacenada en el objeto SeqRecord.\n",
    "\n",
    "`.transcribe()`: Convierte la secuencia de ADN en ARNm. En Biopython, esto simplemente cambia la base T (timina) por U (uracilo)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bd335035-7255-4533-90f2-965b56ada985",
   "metadata": {},
   "outputs": [],
   "source": [
    "arnm.find('aug')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a822d884-ae2d-420e-b139-7a3b8230fcf0",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Indice AUG: \",arnm.find('aug'))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f08df1f-41c4-4c3c-a25b-9a6f862d09f2",
   "metadata": {},
   "source": [
    "# Traducción: ARNm → Proteína"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "74619df3-e85b-4a5e-943e-3f70ed59a2ca",
   "metadata": {},
   "outputs": [],
   "source": [
    "proteina = arnm.translate()\n",
    "print(f\"\\nSecuencia ID: {registros[0].id}\")\n",
    "print(f\"Proteína: {proteina}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b19d2cc-51b5-461a-b78a-1854909f8f59",
   "metadata": {},
   "source": [
    "`.translate()`: Convierte la secuencia de ARNm en una secuencia de proteínas utilizando el código genético estándar. Cada codón (3 nucleótidos) se traduce a un aminoácido."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1080c3fb-222b-4242-9830-0503162b0c79",
   "metadata": {},
   "source": [
    "##  Problemas comunes en la traducción\n",
    "**a) Cadena complementaria**  \n",
    "Biopython asume que la secuencia de ADN proporcionada está en la cadena sentido (la que se transcribe directamente a ARNm). Si la secuencia está en la cadena complementaria (la hebra opuesta), la traducción será incorrecta. Para corregir esto, se debe obtener la cadena complementaria antes de transcribir:\n",
    "\n",
    "**b) Codones de inicio y parada**  \n",
    "* **Codón de inicio:** En la traducción, el codón de inicio (AUG en ARNm) marca el comienzo de la proteína. Si la secuencia no comienza con un codón de inicio, la traducción puede comenzar en una posición incorrecta.\n",
    "\n",
    "* **Codón de parada:** La traducción se detiene al encontrar un codón de parada (UAA, UAG o UGA en ARNm). Si la secuencia no tiene un codón de parada, la traducción continuará hasta el final.\n",
    "\n",
    "**c) Marcos de lectura**  \n",
    "Las secuencias de ADN pueden traducirse en tres marcos de lectura (forward) y tres más si se considera la cadena complementaria (reverse). Si no se especifica el marco correcto, la traducción puede no coincidir con la proteína esperada. Para traducir en un marco específico:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3fd88b2a-4a97-4e48-85e8-bf2051559e94",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "### **1. ¿Qué son los marcos de lectura?**\n",
    "\n",
    "En genética, un **marco de lectura** es una forma de dividir la secuencia de nucleótidos de un gen en codones (grupos de 3 nucleótidos) para su traducción a proteínas. Dado que el código genético se basa en tripletes (codones), la forma en que agrupamos los nucleótidos determina la secuencia de aminoácidos resultante.\n",
    "\n",
    "---\n",
    "\n",
    "### **2. ¿Por qué hay múltiples marcos de lectura?**\n",
    "\n",
    "El ADN es una molécula de doble hebra, y cada hebra puede traducirse en tres marcos de lectura diferentes. Esto se debe a que la traducción puede comenzar en cualquier posición de la secuencia, siempre que se respete el agrupamiento en tripletes. Por lo tanto, para una sola hebra de ADN, existen tres marcos de lectura posibles:\n",
    "\n",
    "1. **Marco 0**: Comienza en el primer nucleótido.\n",
    "2. **Marco 1**: Comienza en el segundo nucleótido.\n",
    "3. **Marco 2**: Comienza en el tercer nucleótido.\n",
    "\n",
    "Además, si consideramos la **hebra complementaria** (la otra hebra del ADN), también hay tres marcos de lectura adicionales. En total, hay **seis marcos de lectura posibles** para una secuencia de ADN.\n",
    "\n",
    "---\n",
    "\n",
    "### **3. Ejemplo práctico**\n",
    "\n",
    "Supongamos que tenemos la siguiente secuencia de ADN:\n",
    "```\n",
    "ADN: ATGCCGATACGTAG\n",
    "```\n",
    "\n",
    "#### **Marcos de lectura en la hebra sentido (forward):**\n",
    "1. **Marco 0**: Comienza en el primer nucleótido.\n",
    "   ```\n",
    "   ATG | CCG | ATA | CGT | AG\n",
    "   ```\n",
    "   - Codones: ATG, CCG, ATA, CGT\n",
    "   - Traducción: Metionina (M), Prolina (P), Isoleucina (I), Arginina (R)\n",
    "\n",
    "2. **Marco 1**: Comienza en el segundo nucleótido.\n",
    "   ```\n",
    "   A | TGC | CGA | TAC | GTA | G\n",
    "   ```\n",
    "   - Codones: TGC, CGA, TAC, GTA\n",
    "   - Traducción: Cisteína (C), Arginina (R), Tirosina (Y), Valina (V)\n",
    "\n",
    "3. **Marco 2**: Comienza en el tercer nucleótido.\n",
    "   ```\n",
    "   AT | GCC | GAT | ACG | TAG\n",
    "   ```\n",
    "   - Codones: GCC, GAT, ACG, TAG\n",
    "   - Traducción: Alanina (A), Ácido aspártico (D), Treonina (T), Stop (*)\n",
    "\n",
    "#### **Marcos de lectura en la hebra complementaria (reverse):**\n",
    "La hebra complementaria de la secuencia anterior sería:\n",
    "```\n",
    "Complementaria: TACGGCTATGCATC\n",
    "```\n",
    "\n",
    "1. **Marco 0**: Comienza en el primer nucleótido.\n",
    "   ```\n",
    "   TAC | GGC | TAT | GCA | TC\n",
    "   ```\n",
    "   - Codones: TAC, GGC, TAT, GCA\n",
    "   - Traducción: Tirosina (Y), Glicina (G), Tirosina (Y), Alanina (A)\n",
    "\n",
    "2. **Marco 1**: Comienza en el segundo nucleótido.\n",
    "   ```\n",
    "   T | ACG | GCT | ATG | CAT | C\n",
    "   ```\n",
    "   - Codones: ACG, GCT, ATG, CAT\n",
    "   - Traducción: Treonina (T), Alanina (A), Metionina (M), Histidina (H)\n",
    "\n",
    "3. **Marco 2**: Comienza en el tercer nucleótido.\n",
    "   ```\n",
    "   TA | CGG | CTA | TGC | ATC\n",
    "   ```\n",
    "   - Codones: CGG, CTA, TGC, ATC\n",
    "   - Traducción: Arginina (R), Leucina (L), Cisteína (C), Isoleucina (I)\n",
    "\n",
    "---\n",
    "\n",
    "### **4. ¿Por qué es importante el marco de lectura correcto?**\n",
    "\n",
    "El marco de lectura correcto es crucial porque determina la secuencia de aminoácidos de la proteína. Si se elige un marco incorrecto, la traducción puede generar una proteína completamente diferente o incluso sin sentido biológico. Por ejemplo:\n",
    "- Un **desplazamiento de marco** (frameshift) puede ocurrir si hay una inserción o deleción de nucleótidos que no sea múltiplo de 3, lo que cambia el marco de lectura y altera toda la secuencia de aminoácidos.\n",
    "\n",
    "---\n",
    "\n",
    "### **5. Cómo identificar el marco de lectura correcto**\n",
    "\n",
    "1. **Buscar el codón de inicio (AUG)**: En la mayoría de los casos, la traducción comienza con el codón de inicio AUG (que codifica para Metionina, M). Este codón marca el inicio del marco de lectura correcto.\n",
    "2. **Verificar la longitud de la proteína**: La proteína traducida debe tener una longitud biológicamente plausible.\n",
    "3. **Comparar con secuencias conocidas**: Si la secuencia de ADN proviene de un gen conocido, puedes comparar la traducción con la secuencia de proteína reportada en bases de datos como UniProt.\n",
    "\n",
    "---\n",
    "\n",
    "### **6. Implementación en Biopython**\n",
    "\n",
    "En Biopython, puedes traducir una secuencia en los tres marcos de lectura de la siguiente manera:\n",
    "\n",
    "```python\n",
    "from Bio.Seq import Seq\n",
    "\n",
    "# Secuencia de ADN\n",
    "secuencia_adn = Seq(\"ATGCCGATACGTAG\")\n",
    "\n",
    "# Traducción en los tres marcos de lectura\n",
    "for marco in range(3):\n",
    "    proteina = secuencia_adn[marco:].translate()\n",
    "    print(f\"Marco {marco}: {proteina}\")\n",
    "```\n",
    "\n",
    "**Salida:**\n",
    "```\n",
    "Marco 0: MPIR*\n",
    "Marco 1: CRYV\n",
    "Marco 2: ADT*\n",
    "```\n",
    "\n",
    "---\n",
    "\n",
    "Los marcos de lectura son esenciales para traducir correctamente una secuencia de ADN a proteína. Elegir el marco correcto asegura que la secuencia de aminoácidos sea biológicamente relevante. En la práctica, es común probar los tres marcos de lectura (y los tres de la hebra complementaria) para identificar la traducción correcta, especialmente cuando no se conoce el marco de inicio exacto. Biopython facilita este proceso con funciones integradas para la traducción en diferentes marcos."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "05cd2035-deaa-4bb6-a09c-0fc280a275bd",
   "metadata": {},
   "source": [
    "# Cálculo del porcentaje de nucleótidos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ed46e8cc-b62c-4fb6-86f9-83cf37f23aa1",
   "metadata": {},
   "outputs": [],
   "source": [
    "longitud_secuencia = len(registros[0].seq)\n",
    "\n",
    "porcentaje_A = (registros[0].seq.count(\"a\") / longitud_secuencia) * 100\n",
    "porcentaje_T = (registros[0].seq.count(\"t\") / longitud_secuencia) * 100\n",
    "porcentaje_C = (registros[0].seq.count(\"c\") / longitud_secuencia) * 100\n",
    "porcentaje_G = (registros[0].seq.count(\"g\") / longitud_secuencia) * 100\n",
    "\n",
    "print(f\"Porcentaje de A: {porcentaje_A:.2f}%\")\n",
    "print(f\"Porcentaje de T: {porcentaje_T:.2f}%\")\n",
    "print(f\"Porcentaje de C: {porcentaje_C:.2f}%\")\n",
    "print(f\"Porcentaje de G: {porcentaje_G:.2f}%\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d4bfcd8-cd8a-401d-91a1-35ec6d51c827",
   "metadata": {},
   "source": [
    "### Cálculo %CG"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "62659cfe-2af0-4640-86e9-bd469b56a3cf",
   "metadata": {},
   "source": [
    "El contenido de CG es la cantidad de citosina y guanina en una secuencia de ADN. El contenido de CG está relacionado con la temperatura de fusión del ADN y otras propiedades físicas (PYTHON FOR BIOINFORMATICS, Sebastián Bassi, 2018):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "de8b6b72-3fd7-4f25-b5e9-a2f5c0daabea",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from Bio.SeqUtils import gc_fraction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2612400f-a80a-4c61-ae28-b30f507538cd",
   "metadata": {},
   "outputs": [],
   "source": [
    "contenido_GC = gc_fraction(registros[0].seq)\n",
    "print(f\"Contenido de GC: {contenido_GC*100:.2f}%\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4b888e4-a669-43de-8bf5-1f9298893287",
   "metadata": {},
   "source": [
    "# Importación de archivos desde bases de datos"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "010e705c-6d6e-45e0-93f3-4a94f9171a92",
   "metadata": {},
   "source": [
    "Para descargar el archivo FASTA de una secuencia en NCBI (como por ejemplo: https://www.ncbi.nlm.nih.gov/nuccore/NG_006323.3), se puede usar la URL de descarga directa de NCBI o utilizar herramientas como Bio.Entrez de Biopython para obtener el archivo FASTA de manera programática. Aquí te explico ambos métodos:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68a6b5ad-1dc2-4c12-890a-4d6e1461f79f",
   "metadata": {},
   "source": [
    "##  Importar archivos directamente desde la URL de NCBI"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bef64fcb-72bf-4696-9ac0-70f2ead2fea6",
   "metadata": {},
   "source": [
    "La URL de descarga directa para un archivo FASTA en NCBI sigue este formato:\n",
    "\n",
    "https://www.ncbi.nlm.nih.gov/sviewer/viewer.cgi?tool=portal&save=file&log$=seqview&db=nuccore&report=fasta&id=ID_DE_LA_SECUENCIA"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2414e17-ce98-4743-a39c-9a5cf9b1d32f",
   "metadata": {},
   "source": [
    "Para (NG_006323.3), la URL sería:\n",
    "\n",
    "https://www.ncbi.nlm.nih.gov/sviewer/viewer.cgi?tool=portal&save=file&log$=seqview&db=nuccore&report=fasta&id=NG_006323.3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "91815de5-1aaa-4435-a911-5242f615c179",
   "metadata": {},
   "outputs": [],
   "source": [
    "from Bio import SeqIO\n",
    "import requests\n",
    "from io import StringIO"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "675fe0f0-ae6c-4c47-8470-7ee0fbf6cc32",
   "metadata": {},
   "outputs": [],
   "source": [
    "# URL de descarga directa\n",
    "url = \"https://www.ncbi.nlm.nih.gov/sviewer/viewer.cgi?tool=portal&save=file&log$=seqview&db=nuccore&report=fasta&id=NG_006323.3\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eda7f6b0-7524-4402-9928-b6228cfc4ab7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Descargar el contenido del archivo FASTA\n",
    "response = requests.get(url)\n",
    "response.raise_for_status()  # Verificar que la descarga fue exitosa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "eaa7e073-7eaa-4d24-86b4-e958741add9e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convertir el contenido descargado en un objeto \"StringIO\" para que Biopython pueda leerlo\n",
    "fasta_content = StringIO(response.text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d744dd83-40a2-48e3-aee9-659de5b6ee75",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Leer la secuencia usando SeqIO.read()\n",
    "secuencia = SeqIO.read(fasta_content, \"fasta\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d0fcb8fb-cd16-4530-b532-7efc1ca2a63c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Mostrar la información de la secuencia\n",
    "print(f\"ID de la secuencia: {secuencia.id}\")\n",
    "print(f\"Descripción de la secuencia: {secuencia.description}\")\n",
    "print(f\"Longitud de la secuencia: {len(secuencia)}\")\n",
    "print(f\"Secuencia de ADN (primeros 60 nucleótidos): {secuencia.seq[:60]}...\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0a8716a0-4c81-4582-a4a2-bc5964376b30",
   "metadata": {},
   "source": [
    "## Importar archivos con Bio.Entrez"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "58260b09-1a7e-4365-987b-b7db9d2e488f",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from Bio import Entrez, SeqIO\n",
    "from io import StringIO"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "be45c4da-4404-43ac-9823-67fc4eb7603e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Configurar tu correo electrónico (obligatorio para usar Entrez)\n",
    "Entrez.email = \"correo_usuario@correo.com\"  # Reemplaza con tu correo electrónico"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "74d115c6-461b-46b7-9ba2-dda508455154",
   "metadata": {},
   "outputs": [],
   "source": [
    "# ID de la secuencia en NCBI\n",
    "id_secuencia = \"NG_006323.3\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "964e4744-9914-4260-87c9-155905f63f45",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Descargar la secuencia en formato FASTA usando Entrez.efetch\n",
    "with Entrez.efetch(db=\"nuccore\", id=id_secuencia, rettype=\"fasta\", retmode=\"text\") as handle:\n",
    "    fasta_data = handle.read()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dd3a1cb6-4d92-478d-911e-fadfdc1f76f7",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Convertir el contenido descargado en un objeto \"StringIO\" para que Biopython pueda leerlo\n",
    "fasta_content = StringIO(fasta_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0cb5f1f4-d40e-4cb9-92e7-f326884a9013",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Leer la secuencia usando SeqIO.read()\n",
    "secuencia = SeqIO.read(fasta_content, \"fasta\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "feaad445-6d30-4354-a58f-96127b32edea",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Mostrar la información de la secuencia\n",
    "print(f\"ID de la secuencia: {secuencia.id}\")\n",
    "print(f\"Descripción de la secuencia: {secuencia.description}\")\n",
    "print(f\"Longitud de la secuencia: {len(secuencia)}\")\n",
    "print(f\"Secuencia de ADN (primeros 60 nucleótidos): {secuencia.seq[:60]}...\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c131bc45-6e89-415b-ab47-5f1bf8f27116",
   "metadata": {},
   "outputs": [],
   "source": [
    "len(secuencia.seq)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f1bd6369-e499-4e6b-9b35-393d1607e258",
   "metadata": {},
   "outputs": [],
   "source": [
    "secuencia.seq.transcribe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "96996575-9f30-4c83-b2d1-cacd07e261aa",
   "metadata": {},
   "outputs": [],
   "source": [
    "len(secuencia.seq.transcribe())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5131052-272a-43b7-8a40-1b25ae1421f2",
   "metadata": {},
   "source": [
    "Codón de inicio AUG/ATG"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dbafc654-36f5-493c-a025-71c11f5e3bd6",
   "metadata": {},
   "outputs": [],
   "source": [
    "secuencia.seq.find(\"ATG\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "080e1171-458d-4ddc-93ff-a13149da5da8",
   "metadata": {},
   "outputs": [],
   "source": [
    "inicio=secuencia.seq.find(\"ATG\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "491fbd82-b2bf-46f3-8a24-1b96b9abb2e2",
   "metadata": {},
   "source": [
    "Codones de parada:\n",
    "* UAA/TAA\n",
    "* UAG/TAG\n",
    "* UGA/TGA"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e118078e-41dc-493f-91d8-3713b8aa3ae2",
   "metadata": {},
   "outputs": [],
   "source": [
    "secuencia.seq.find(\"TAA\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0f66289c-412a-4f8f-937d-8b26d1459a61",
   "metadata": {},
   "outputs": [],
   "source": [
    "len(secuencia.seq)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e0b432ea-737b-4121-9b28-66f553fd5ced",
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(inicio, len(secuencia.seq) - 2, 3):\n",
    "    codon = secuencia.seq[i:i+3]\n",
    "    if codon in [\"TAA\", \"TAG\", \"TGA\"]:\n",
    "        parada = i\n",
    "        print(\"parada: \", i, \"codón: \", codon)\n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6e155c7d-c59e-4fc0-9089-7de1f0d07754",
   "metadata": {},
   "outputs": [],
   "source": [
    "secuencia.seq.find(\"TGA\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ba0a6344-aa15-4b21-a63a-913901c9a22b",
   "metadata": {},
   "source": [
    "# Código para transcribir entre el codón de inicio y el primer codón de parada"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "54b25516-07d4-4af4-bca4-c3d2e9d03f02",
   "metadata": {},
   "outputs": [],
   "source": [
    "from Bio import SeqIO\n",
    "from Bio.Seq import Seq\n",
    "\n",
    "secuencia_adn=secuencia\n",
    "\n",
    "# Convertir la secuencia a una cadena de ADN\n",
    "adn = secuencia_adn.seq\n",
    "\n",
    "# Encontrar el primer codón de inicio (ATG)\n",
    "inicio = adn.find(\"ATG\")\n",
    "\n",
    "if inicio == -1:\n",
    "    print(\"No se encontró un codón de inicio (ATG).\")\n",
    "else:\n",
    "    # Buscar el primer codón de parada (TAA, TAG o TGA) después del codón de inicio\n",
    "    parada = -1\n",
    "    for i in range(inicio, len(adn) - 2, 3):\n",
    "        codon = adn[i:i+3]\n",
    "        if codon in [\"TAA\", \"TAG\", \"TGA\"]:\n",
    "            parada = i\n",
    "            break\n",
    "\n",
    "    if parada == -1:\n",
    "        print(\"No se encontró un codón de parada después del codón de inicio.\")\n",
    "    else:\n",
    "        # Extraer la secuencia entre el codón de inicio y el codón de parada\n",
    "        secuencia_extraida = adn[inicio:parada+3]\n",
    "\n",
    "        # Transcribir la secuencia extraída (convertir T → U)\n",
    "        secuencia_arn = secuencia_extraida.transcribe()\n",
    "\n",
    "        # Mostrar los resultados\n",
    "        print(f\"Secuencia de ADN extraída: {secuencia_extraida}\")\n",
    "        print(f\"Secuencia de ARN transcrita: {secuencia_arn}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dfe51c82-a75e-4545-a443-44fa16a1401a",
   "metadata": {},
   "outputs": [],
   "source": [
    "len(secuencia_extraida)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a573cdc-da29-469a-a604-80a06e9d3b60",
   "metadata": {},
   "source": [
    "## Traducción de la secuencia extraída"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ba72f129-579c-4897-a04f-43368711a842",
   "metadata": {},
   "outputs": [],
   "source": [
    "secuencia_arn.translate()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c123bd03-2a61-47fb-ba7e-1d9b368a797a",
   "metadata": {},
   "source": [
    "## Tarea \n",
    "\n",
    "### 1. Práctica\n",
    "Usando `python` con biopython, en la siguiente secuencia HQ287898.1 extraiga:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a808c9f9-8cf1-4d56-a36b-dd825c2062b3",
   "metadata": {},
   "source": [
    "* La longitud de la secuencia"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ab269be1-736c-4f8d-8493-0d7be28b8ab8",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "e93de2eb-bcc5-4e83-9543-e24b75a47614",
   "metadata": {},
   "source": [
    "* El porcentaje de cada uno de los nucléotidos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ad3861fa-a315-42dd-8912-cf3182695d34",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "aeb0a3d4-e809-4d97-9313-eabacf104ba4",
   "metadata": {},
   "source": [
    "* Contenido GC de la secuencia"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8054368e-f0ad-4913-9966-bd788b0529a6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "b47324c6-f3d3-4f14-b1c2-170431d1a1ec",
   "metadata": {},
   "source": [
    "* La transcripción entre el primer codón de inicio y el primer codón de parada"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b809e5d7-5c4f-47b3-85d3-4c3e9d835e37",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "52b1799d-bb32-4120-a747-5c2987c0ee0f",
   "metadata": {},
   "source": [
    "### 2. Cuestionario\n",
    "\n",
    "Conteste las siguientes preguntas"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54b45a3a-2bfb-4f86-9e0d-9f90cdcdd502",
   "metadata": {},
   "source": [
    "#### 2.1. ¿Cómo se importa una secuencia desde NCBI con `Bio.Entrez`?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "701221f7-3e26-4671-aadc-4fa2afe3dc53",
   "metadata": {},
   "source": [
    "ponga aquí su respuesta"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "732ca0b0-65b0-47ff-9cd0-76ba2bb6258b",
   "metadata": {},
   "source": [
    "#### 2.2. ¿Cómo se hace el proceso de traducción partiendo de una secuencia de adn con `BioPython`?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc2e174d-ace0-4421-94b8-5e74d5c3b14f",
   "metadata": {},
   "source": [
    "ponga aquí su respuesta"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "852e3bf6-ec1e-4fd1-8299-4864b67d4309",
   "metadata": {},
   "source": [
    "#### 2.2. ¿Cómo se hace el componente GC de una secuencia usando `biopython`?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6a4ea1e-7bf1-42a8-9023-8d0a945e57f0",
   "metadata": {},
   "source": [
    "ponga aquí su respuesta"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d81031c",
   "metadata": {},
   "source": [
    "# Conclusiones y Recomendaciones\n",
    "\n",
    "Una vez ejecutado este cuaderno de trabajo y seguido las instrucciones que en el se detallan, desarrolle por lo menos tres conclusiones y recomendaciones delimitadas exclusivamente a las actividades ejecutadas en este cuaderno de trabajo."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70716aa1",
   "metadata": {},
   "source": [
    "## Conclusiones\n",
    "1. Conclusión 1\n",
    "2. Conclusión 2\n",
    "3. Conclusión 3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ad4beef-6416-44b6-b7a4-630d7fbce4fb",
   "metadata": {},
   "source": [
    "## Recomendaciones\n",
    "1. Recomendación 1\n",
    "2. Recomendación 2\n",
    "3. Recomendación 3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d771607-06b1-4069-a551-01ff59e9c7c3",
   "metadata": {},
   "source": [
    "|RÚBRICA Y CRITERIOS DE EVALUACIÓN |||||\n",
    "|:-|:-:|:-:|:-:|:-|\n",
    "|PARÁMETROS|100%|50%|0%|Total parcial|\n",
    "|Desempeño en el desarrollo del cuaderno de trabajo (toma de datos, realización de cálculos, ejecución de comandos, realización de programas, obtención de resultados, obtención de un producto, aplicación de una herramienta, realización de un procedimiento para experimento, etc.)|El estudiantes demuestra solvencia al desempeñarse  durante la práctica|El estudiante demuestra parcialmente solvencia al desempeñarse durante la práctica |El estudiante no demuestra solvencia al desempeñarse durante la práctica |40%|\n",
    "|Cuestionario|El estudiante contesta el cuestionario de forma correcta |El estudiante contesta la mitad del cuestionario de forma correcta|El estudiante contesta el cuestionario de forma incorrecta|30%|\n",
    "|Conclusiones y Recomendaciones|Todas las conclusiones son adecuadas, objetivas y aplicables exclusivamente a la práctica|Las conclusiones son parcialmente adecuadas, objetivas y aplicables|Las conclusiones no son adecuadas, objetivas y aplicables|30%|\n",
    "|TOTAL||||100%|"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cb7389af-6892-494b-a3cb-4ffbd65a68a9",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}