{
 "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": "16f6400d-9031-4cfe-b8fb-39544d3ae568",
   "metadata": {},
   "source": [
    "# Python\n",
    "Python, pertenece al grupo de los lenguajes de programación y puede ser clasificado como un lenguaje interpretado, de alto nivel, multiplataforma, de tipado dinámico y multiparadigma. A diferencia de la mayoría de los lenguajes de programación, Python nos provee de reglas de estilos, a fin de poder escribir código fuente más legible y de manera estandarizada. Estas reglas de estilo, son definidas a través de la Python Enhancement Proposal Nº 8 (PEP 8) (Curso Python para Principiantes– Eugenia Bahit, 20212)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f45feb9-4df7-46cf-81f1-87539facf484",
   "metadata": {},
   "source": [
    "\n",
    "Python es un lenguaje de programación creado por Guido van Rossum a principios de los años 90 cuyo nombre está inspirado en el grupo de cómicos ingleses “Monty Python”. Es un lenguaje similar a Perl, pero con una sintaxis muy limpia y que favorece un código legible. Se trata de un lenguaje interpretado o de script, con tipado dinámico,fuertemente tipado, multiplataforma y orientado a objetos. (Python para todos, R. González,2008)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d2a9ef8-b726-4df8-9a7a-13cc7c4503a2",
   "metadata": {},
   "source": [
    "## Tipado dinámico\n",
    "\n",
    "La característica de tipado dinámico se refiere a que no es necesario declarar el tipo de dato que va a contener una determinada variable, sino que su tipo se determinará en tiempo de ejecución según el tipo del valor al que se asigne, y el tipo de esta variable puede cambiar si se le asigna un valor de otro tipo. (Python para todos, R. González,2008)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "abb916fd-2273-478e-bacc-9a720325ea0f",
   "metadata": {},
   "source": [
    "## Fuertemente tipado\n",
    "\n",
    "No se permite tratar a una variable como si fuera de un tipo distinto al que tiene, es necesario convertir de forma explícita dicha variable al nuevo tipo previamente. Por ejemplo, si tenemos una variable que contiene un texto (variable de tipo cadena o string) no podremos tratarla como un número (sumar la cadena “9” y el número 8 ). En otros lenguajes el tipo de la variable cambiaría para adaptarse al al comportamiento esperado, aunque esto es más propenso a errores.(Python para todos, R. González,2008)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9fdc4fa8-af8d-47fc-9103-f493898f164c",
   "metadata": {},
   "source": [
    "## Orientado a objetos\n",
    "\n",
    "La orientación a objetos es un paradigma de programación en el que los conceptos del mundo real relevantes para nuestro problema se trasladan a clases y objetos en nuestro programa. La ejecución del programa consiste en una serie de interacciones entre los objetos.\n",
    "\n",
    "Python también permite la programación imperativa, programación funcional y programación orientada a aspectos."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a2d42826-089e-4bfd-8dc4-10e6ef1fa604",
   "metadata": {},
   "source": [
    "## Documentación de Pyhton\n",
    "Existe una amplia documentación alrededor de esta herramienta que puede ser fácilmente accedida por los usuarios, sin embargo debe percatarse que la documentación corresponda a la versión de Python 3 y no a versiones previas.;\n",
    "\n",
    "Non-Programmer’s Tutorial for Python 3\n",
    "https://upload.wikimedia.org/wikipedia/commons/1/1d/Non-Programmer%27s_Tutorial_for_Python_3.pdf\n",
    "\n",
    "Revíselo y practique en Spyder en su máquina virtual del curso o instálese directamente en su sistema operativo."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "da552dd4-e54c-481f-9e78-c2e0d3c87e8d",
   "metadata": {},
   "source": [
    "## Python como soporte a Bioinformática\n",
    "Dado que python es un lenguaje muy versatil y ampliamente usada, una nutrida comunidad alrededor de el colabora desarrollando herramientas para distintos campos de la ciencia, como referencia puede revisar el libro PYTHON FOR BIOINFORMATICS, de Sebastián Bassi, 2018\n",
    "\n",
    "http://englishonlineclub.com/pdf/Python%20for%20Bioinformatics%20(Second%20Edition)%20[EnglishOnlineClub.com].pdf\n",
    "\n",
    "Existe una gran oferta de textos en este campo de las ciencias."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ec4d3750-1fe5-44b0-bf8f-b29daa422ac8",
   "metadata": {},
   "source": [
    "## Mas documentación de Python\n",
    "También puede revisar el texto “Python para todos, Explorando la información con Python 3” de Charles R. Severance, 2020\n",
    "\n",
    "Este texto está registrado bajo una Licencia Creative Commons Attribution NonCommercial-ShareAlike 3.0 Unported License y lo puede desacrgar desde la plataforma del curso y lo usaremos como referencia en varias secciones de este curso"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b3afd8b5-43db-4c1a-904f-57473ba4fa91",
   "metadata": {},
   "source": [
    "# Python - Variables, expresiones y sentencias"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0cbda5de-69ab-4b83-9bed-5f822e0279a7",
   "metadata": {},
   "source": [
    "## Variables en Python\n",
    "En Python los nombres de las variables pueden ser arbitrariamente largos. Pueden contener tanto letras como números, pero no pueden comenzar con un número. Se pueden usar letras mayúsculas, pero es buena idea comenzar los nombres de las variables con una letras minúscula.\n",
    "\n",
    "El carácter guión-bajo (_) puede utilizarse en un nombre. A menudo se utiliza en nombres con múltiples palabras, como en mi_nombre o velocidad_de_golondrina_sin_carga. Los nombres de las variables pueden comenzar con un carácter guión-bajo, pero generalmente se evita usarlo así a menos que se esté escribiendo código para librerías que luego utilizarán otros. (“Explorando la información con Python 3”, Charles R. Severance, 2020)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "664def52-3b6c-4da0-9c23-f41e2ad04fde",
   "metadata": {},
   "source": [
    "Los tipos básicos de variables en Python se pueden clasificar de manera general en:\n",
    "\n",
    "* Números\n",
    "    * Enteros\n",
    "    * De coma flotante\n",
    "    * Complejos\n",
    "* Cadenas de texto\n",
    "* Valores booleanos\n",
    "\n",
    "(Python para todos, R. González,2008)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6f169b14-9d29-47af-8dd9-9a0ba9f73ad8",
   "metadata": {},
   "source": [
    "En Python también es posible trabajar con colecciones de datos, entre ellas:\n",
    "\n",
    "* Listas\n",
    "* Tuplas\n",
    "* Diccionarios\n",
    "* Dataframes\n",
    "\n",
    "(Python para todos, R. González,2008)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6fbfb551-9103-44b5-bbb6-b2a0ccd26a38",
   "metadata": {},
   "source": [
    "## Sentencias en Python\n",
    "Una sentencia es una unidad de código que el intérprete de Python puede ejecutar, por ejemplo print(). Cuando se escribe una sentencia en modo interactivo, el intérprete la ejecuta y muestra el resultado, si es que lo hay.\n",
    "\n",
    "Un script normalmente contiene una secuencia de sentencias. Si hay más de una sentencia, los resultados aparecen de uno en uno según se van ejecutando las sentencias. (“Explorando la información con Python 3”, Charles R. Severance, 2020)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ee0d020-fffb-4421-928a-97d92c34602c",
   "metadata": {},
   "source": [
    "## Expresiones en Python\n",
    "Una expresión es una combinación de valores, variables y operadores. Un valor por si mismo se considera una expresión, y también lo es una variable, así que las siguientes expresiones son todas válidas (asumiendo que la variable x tenga un valor asignado):\n",
    "\n",
    "17 \n",
    "x = 17  \n",
    "x + 17  \n",
    "\n",
    "(Explorando la información con Python 3, Charles R. Severance, 2020)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6905368d-3e6c-44a8-b5cd-47cedc950067",
   "metadata": {},
   "source": [
    "## Orden de las operaciones en Python\n",
    "Cuando en una expresión aparece más de un operador, el orden de evaluación depende de las reglas de precedencia. Para los operadores matemáticos, Python sigue las convenciones matemáticas. El acrónimo PEMDSR resulta útil para recordar esas reglas (Paréntesis, Exponenciación, M ultiplicación y División, Suma y Resta)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90766b50-2187-4948-9918-dc066137aa6d",
   "metadata": {},
   "source": [
    "## Comentarios\n",
    "A medida que los programas se van volviendo más grandes y complicados, se vuelven más difíciles de leer. Los lenguajes formales son densos, y a menudo es complicado mirar un trozo de código e imaginarse qué es lo que hace, o por qué. Por eso es buena idea añadir notas a los programas, para explicar en un lenguaje normal qué es lo que el programa está haciendo. Estas notas reciben el nombre de comentarios, y en Python comienzan con el símbolo #:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "58aa52bd-5b62-480d-bc62-8a0bfbc2829e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Este es un comentario\n",
    "print(\"Hola mundo\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8f84950-8724-4325-8775-b77e1e7017dd",
   "metadata": {},
   "source": [
    "## Entorno de Python\n",
    "Con Python se puede trabajar con varios entornos de trabajo, entre ellos\n",
    "\n",
    "* Consola de python\n",
    "* IDE Spyder\n",
    "* IDE Jupyter\n",
    "\n",
    "Las dos primeras están instaladas en la máquina virtual de este curso, mientras que la tercera se puede acceder a través de la nube o instalarla con el entorno de programación Anaconda."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "301e5a3a-34e8-452b-b8a9-25c3e0b5cafc",
   "metadata": {},
   "source": [
    "## La Consola (terminal) de Python\n",
    "\n",
    "La consola (terminal) de Python es un entorno interactivo que permite a los usuarios ejecutar comandos y scripts de Python directamente en tiempo real. A través de esta interfaz, es posible escribir y ejecutar código línea por línea, lo que facilita la experimentación, depuración y aprendizaje del lenguaje. Es una herramienta fundamental para desarrolladores, ya que proporciona retroalimentación inmediata y acceso a las funcionalidades básicas de Python sin necesidad de un entorno de desarrollo complejo."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71f5f296-c153-4fcc-a47c-4b11098ccca7",
   "metadata": {},
   "source": [
    "## Programación Básica: Tipos de Datos\n",
    "En Python, los tipos de datos son las categorías que definen cómo se puede manipular y operar con una variable. Algunos tipos comunes incluyen **int** (números \n",
    "enteros), **float** (números decimales), **bool** (valores booleanos: True/False), **str** (cadena de texto), **list**, **tuple**, **set**, y **dict**. Entre \n",
    "ellos, las **cadenas (strings)** son especialmente importantes en bioinformática, ya que se usan para representar secuencias biológicas como DNA, RNA o \n",
    "proteínas. Las cadenas son objetos inmutables que pueden contener texto, y operaciones comunes incluyen concatenación, rebanado y métodos específicos para \n",
    "manipular texto y secuencias. Dada su versatilidad, las cadenas son esenciales en el análisis de datos biológicos, desde la manipulación de secuencias hasta el \n",
    "procesamiento de archivos como FASTA o GenBank.\n",
    "\n",
    "### Cadenas en Python\n",
    "En Python, las cadenas (o strings) son secuencias inmutables de caracteres utilizadas para representar texto. Se definen mediante comillas simples (' '), dobles (\" \") o triples (''' ''' o \"\"\" \"\"\"), y permiten almacenar y manipular datos como palabras, frases o cualquier contenido textual. Las cadenas admiten operaciones como concatenación, slicing (corte), búsqueda, formato y más, además de ser compatibles con métodos integrados para transformaciones, como convertir a mayúsculas, minúsculas o dividir en subcadenas. Su inmutabilidad significa que, al modificarlas, se crea una nueva cadena en lugar de alterar la original.\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f168ea37-1fd9-4ad1-9d3f-be1f3abb5814",
   "metadata": {},
   "source": [
    "# Manipulación de Cadenas en Python\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d5c6cc54-c4a1-4c6f-b9eb-ad6cf46550d2",
   "metadata": {},
   "source": [
    "Un péptido señal (signal peptide) es una secuencia corta de aminoácidos al inicio de una proteína que dirige la proteína hacia el retículo endoplasmático en células eucariotas o hacia la membrana plasmática en procariotas. Estas secuencias suelen tener entre 15 y 30 aminoácidos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "99be35db-5ba7-4f20-9cc7-107ae05633ff",
   "metadata": {},
   "outputs": [],
   "source": [
    "signal_peptide = 'MKTIIALSYIFCLVFAD'\n",
    "signal_peptide_lower=signal_peptide.lower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "77f1fa0e-bdf6-49c4-b828-37772de37559",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"singal_petide:\",signal_peptide)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "43100309-9d2a-4454-a3f8-4048c106a814",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"singanl_peptide_lower:\",signal_peptide_lower)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eec7450c-d5ba-4754-b38d-ef9000ed0a15",
   "metadata": {},
   "source": [
    "El siguiente código abre el archivo de secuencias `sproteases_small_dna.fasta` y muestra su contenido con una descripción de \"Identificador\" y \"Secuencia\" para cada una de las líneas del archivo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "61615a19-cfa8-422e-87b4-d996b810fc84",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "with open(\"sampledata/t-coffee/sproteases_small_dna.fasta\", \"r\") as archivo:\n",
    "    for linea in archivo:\n",
    "        if linea.startswith(\">\"):\n",
    "            print(\"Identificador:\", linea.strip())\n",
    "        else:\n",
    "            print(\"Secuencia:\", linea.strip())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "86be3f6d-127d-4163-a6dc-7a4227c5f375",
   "metadata": {},
   "source": [
    "## Extracción de secuencias"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25b7b4ee-1a9f-4f00-8dcf-8e0204c481f6",
   "metadata": {},
   "source": [
    "El siguiente código extrae solo la primera secuencia del archivo fasta:\n",
    "1. Abre el archivo FASTA: Lee todas las líneas.\n",
    "2. Busca el primer encabezado (>): Guarda el encabezado de la primera secuencia.\n",
    "3. Acumula la secuencia: Combina las líneas de la secuencia hasta que encuentra otro encabezado o llega al final.\n",
    "4. Imprime el resultado: Muestra el encabezado y la secuencia correspondiente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "04a96e84-9ecc-463b-9d4f-40a99c7c741b",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def read_fasta(filepath):\n",
    "    with open(filepath, 'r') as file:\n",
    "        lines = file.readlines()\n",
    "\n",
    "    header = None\n",
    "    sequence = []\n",
    "    for line in lines:\n",
    "        line = line.strip()\n",
    "        if line.startswith('>'):\n",
    "            if header:  # Si ya encontramos la primera secuencia, salimos\n",
    "                break\n",
    "            header = line\n",
    "        else:\n",
    "            sequence.append(line)\n",
    "    \n",
    "    return header, ''.join(sequence)\n",
    "\n",
    "# Ruta al archivo FASTA\n",
    "fasta_file = 'sampledata/t-coffee/sproteases_small_dna.fasta'\n",
    "\n",
    "# Leer la primera secuencia\n",
    "header, sequence = read_fasta(fasta_file)\n",
    "\n",
    "print(f'Identificador: {header}')\n",
    "print(f'Secuencia: {sequence}')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "76cb5483-d927-4184-8cfc-779898d3159d",
   "metadata": {},
   "source": [
    "Dado que es necesario poder extraer cualquiera de las secuencias de los archivos fasta, el siguiente código extrae cualquiera de las secuencias de acuerdo al índice de su ubicación\n",
    "\n",
    "Este código:\n",
    "1. `read_fasta(filepath)`:\n",
    "    * Lee todas las secuencias del archivo y las guarda en una lista de tuplas (header, sequence).\n",
    "2. `get_sequence(filepath, index)`:\n",
    "    * Permite extraer cualquier secuencia especificando el índice.\n",
    "    * Si el índice está fuera del rango, lanza un error.\n",
    "3. Selecciona la secuencia:\n",
    "    * Cambia la variable sequence_index para extraer la secuencia que se desee."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a9cf4663-9c17-4415-833d-d79604e97bc1",
   "metadata": {},
   "outputs": [],
   "source": [
    "def read_fasta(filepath):\n",
    "    sequences = []\n",
    "    with open(filepath, 'r') as file:\n",
    "        lines = file.readlines()\n",
    "\n",
    "    header = None\n",
    "    sequence = []\n",
    "    for line in lines:\n",
    "        line = line.strip()\n",
    "        if line.startswith('>'):\n",
    "            if header:  # Guarda la secuencia anterior antes de empezar una nueva\n",
    "                sequences.append((header, ''.join(sequence)))\n",
    "                sequence = []\n",
    "            header = line\n",
    "        else:\n",
    "            sequence.append(line)\n",
    "\n",
    "    # Guarda la última secuencia si existe\n",
    "    if header:\n",
    "        sequences.append((header, ''.join(sequence)))\n",
    "\n",
    "    return sequences\n",
    "\n",
    "def get_sequence(filepath, index):\n",
    "    sequences = read_fasta(filepath)\n",
    "    if index < 0 or index >= len(sequences):\n",
    "        raise IndexError(\"Índice fuera de rango. Verifique el número de secuencias en el archivo.\")\n",
    "    return sequences[index]\n",
    "\n",
    "# Ruta al archivo FASTA\n",
    "fasta_file = 'sampledata/t-coffee/sproteases_small_dna.fasta'\n",
    "\n",
    "# Índice de la secuencia que quieres extraer (0 para la primera, 1 para la segunda, etc.)\n",
    "sequence_index = 1  # Cambia este número para obtener diferentes secuencias\n",
    "\n",
    "# Extraer la secuencia\n",
    "header, sequence = get_sequence(fasta_file, sequence_index)\n",
    "\n",
    "print(f'Encabezado: {header}')\n",
    "print(f'Secuencia: {sequence}')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e3da8932-837f-434e-bd38-5a2e9d55b918",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(sequence.upper())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "23a6e682-b58f-4d71-9789-604fc6f613c4",
   "metadata": {},
   "source": [
    "### Métodos asociados con cadenas\n",
    "|Método\t|Operación|\n",
    "|:--|:--|\n",
    "|replace(old,new[,count])\t|Permite reemplazar una parte de una cadena (old ) por otra (new ). Si se usa el argumento opcional count, solo se reemplazarán las primeras ocurrencias de recuento anteriores|\n",
    "|count(sub[, start[, end]])\t|Cuenta cuántas veces aparece la subcadena sub, entre las posiciones inicial y final (si está disponible).|\n",
    "|find(sub[,start[,end]])\t|Devuelve la posición de la subcadena sub, entre las posiciones inicial y final (si está disponible). Si la subcadena no se encuentra en la cadena, este método devuelve el valor -1|\n",
    "|index(sub[,start[,end]])\t|Funciona como find(). La diferencia es que el índice generará una excepción ValueError cuando no se encuentre la subcadena. Se recomienda este método sobre find() porque el valor -1 podría interpretarse como un valor válido.|\n",
    "|split([sep [,maxsplit]])\t|Separa las “palabras” de una cadena y las devuelve en una lista. Si no se especifica un separador (sep), el separador predeterminado será un espacio en blanco|\n",
    "|join(seq)\t|Une la secuencia usando una cadena como un “carácter adhesivo”, es la función inversa de split() es join()|\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2960b128-7897-4245-9602-5eb96dcee460",
   "metadata": {},
   "source": [
    "### Transcripción de ADN a ARNm usando las librerías estándar de python\n",
    "\n",
    "De manera ilustrativa realizaremos el proceso de conversión de ADN a ARNm, para ello se buscará identificar si se trata de la hebra molde o codificante.\n",
    "\n",
    "1. Identificación de la Hebra Codificante (5' → 3') vs. Hebra Molde (3' → 5')\n",
    "   \n",
    "**Hebra codificante (5' → 3'):** También llamada hebra sentido o no molde. Esta secuencia es casi idéntica al ARNm resultante, excepto que el ADN tiene timina (T) en lugar de uracilo (U).\n",
    "\n",
    "Ejemplo:\n",
    "\n",
    "ADN: 5' - ATGCGT - 3'  \n",
    "ARNm: 5' - AUGCGU - 3'  \n",
    "\n",
    "**Hebra molde (3' → 5'):** Esta es la hebra que se transcribe. La ARN polimerasa la lee en dirección 3' → 5' para sintetizar el ARNm en dirección 5' → 3'. El ARNm será complementario a esta hebra.\n",
    "\n",
    "Ejemplo:\n",
    " \n",
    "ADN molde: 3' - TACGCA - 5'  \n",
    "ARNm: 5' - AUGCGU - 3'  \n",
    "\n",
    "2. Orientación de la Secuencia\n",
    "   \n",
    "**Secuencia dada sin contexto:** Si no se especifica, normalmente se asume que la secuencia está en dirección 5' → 3' y representa la hebra codificante.\n",
    "\n",
    "**Presencia de un codón de inicio (AUG):** Se puede buscar el codón de inicio (ATG en ADN). Si aparece en la secuencia tal como está, es probable que sea la hebra codificante. Si no lo encuentra, puede que tenga la hebra molde o esté en la dirección 3' → 5'.\n",
    "\n",
    "3. Aplicar a la secuencia\n",
    "Si la secuencia empieza con algo como ATG (que codifica para Metionina), probablemente sea la hebra codificante en dirección 5' → 3'."
   ]
  },
  {
   "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": [
    "# Secuencia de ADN proporcionada\n",
    "dna_sequence = sequence.upper()\n",
    "\n",
    "# Función para obtener la hebra complementaria (cambiando A <-> T, C <-> G)\n",
    "def complement(seq):\n",
    "    complement_map = str.maketrans('ATGC', 'TACG')\n",
    "    return seq.translate(complement_map)[::-1]  # También la invertimos para obtener el 5' -> 3'\n",
    "\n",
    "# Verificar si la secuencia tiene un codón de inicio (ATG)\n",
    "if \"ATG\" in dna_sequence:\n",
    "    print(\"La secuencia proporcionada contiene un codón de inicio (ATG). Es probable que sea la hebra codificante (5' → 3').\")\n",
    "else:\n",
    "    # Obtener la hebra complementaria\n",
    "    complement_seq = complement(dna_sequence)\n",
    "    if \"ATG\" in complement_seq:\n",
    "        print(\"La secuencia proporcionada no contiene un codón de inicio (ATG).\")\n",
    "        print(\"La hebra complementaria contiene un codón de inicio, por lo que es probable que la secuencia original sea la hebra molde (3' → 5').\")\n",
    "    else:\n",
    "        print(\"Ninguna de las hebras contiene un codón de inicio (ATG). Podría tratarse de una región no codificante o incompleta.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b33291a1-1f14-4dbe-b791-a6c71c2de731",
   "metadata": {},
   "source": [
    "El siguiente código realiza el proceso de transcripción:\n",
    "\n",
    "1. Detecta si la secuencia es la hebra codificante o la hebra molde.\n",
    "2. Transcribe la secuencia a ARNm:\n",
    "    * Si es la hebra codificante (5' → 3'), simplemente reemplaza T por U.\n",
    "    * Si es la hebra molde (3' → 5'), genera la hebra complementaria, invierte la secuencia para obtener el sentido 5' → 3', y luego reemplaza T por U."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a37acd1c-ed96-404c-8a01-a1055716bf03",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Secuencia de ADN proporcionada\n",
    "dna_sequence = sequence.upper()\n",
    "\n",
    "# Función para obtener la hebra complementaria (A <-> T, C <-> G)\n",
    "def complement(seq):\n",
    "    complement_map = str.maketrans('ATGC', 'TACG')\n",
    "    return seq.translate(complement_map)[::-1]  # También invertimos para obtener 5' → 3'\n",
    "\n",
    "# Función para transcribir ADN a ARNm (reemplazando T por U)\n",
    "def transcribe(seq):\n",
    "    return seq.replace(\"T\", \"U\")\n",
    "\n",
    "# Verificar si la secuencia tiene un codón de inicio (ATG)\n",
    "if \"ATG\" in dna_sequence:\n",
    "    print(\"La secuencia proporcionada contiene un codón de inicio (ATG).\")\n",
    "    print(\"Es probable que sea la hebra codificante (5' → 3').\")\n",
    "    \n",
    "    # Transcripción directa\n",
    "    mrna_sequence = transcribe(dna_sequence)\n",
    "    print(\"\\nSecuencia de ARNm transcrita:\")\n",
    "    print(mrna_sequence)\n",
    "\n",
    "else:\n",
    "    # Obtener la hebra complementaria\n",
    "    complement_seq = complement(dna_sequence)\n",
    "    \n",
    "    if \"ATG\" in complement_seq:\n",
    "        print(\"La secuencia proporcionada no contiene un codón de inicio (ATG).\")\n",
    "        print(\"La hebra complementaria contiene un codón de inicio, por lo que es probable que la secuencia original sea la hebra molde (3' → 5').\")\n",
    "        \n",
    "        # Transcripción de la hebra complementaria\n",
    "        mrna_sequence = transcribe(complement_seq)\n",
    "        print(\"\\nSecuencia de ARNm transcrita:\")\n",
    "        print(mrna_sequence)\n",
    "        \n",
    "    else:\n",
    "        print(\"Ninguna de las hebras contiene un codón de inicio (ATG).\")\n",
    "        print(\"Podría tratarse de una región no codificante o incompleta.\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "503ce405-6fcb-4e47-ab00-bf57fea59a4a",
   "metadata": {},
   "source": [
    "Podemos ubicar el codón AUG de inicio del transcrito:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bd335035-7255-4533-90f2-965b56ada985",
   "metadata": {},
   "outputs": [],
   "source": [
    "mrna_sequence.find('AUG')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a822d884-ae2d-420e-b139-7a3b8230fcf0",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Indice AUG: \",mrna_sequence.find('AUG'))"
   ]
  },
  {
   "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": [
    "dna_seq = sequence.upper()\n",
    "a = dna_seq.count(\"A\")/len(dna_seq)*100\n",
    "t = dna_seq.count(\"T\")/len(dna_seq)*100\n",
    "c = dna_seq.count(\"C\")/len(dna_seq)*100\n",
    "g = dna_seq.count(\"G\")/len(dna_seq)*100\n",
    "print(\"Porcentaje A:\",a)\n",
    "print(\"Porcentaje T:\",t)\n",
    "print(\"Porcentaje C:\",c)\n",
    "print(\"Porcentaje G:\",g)\n",
    "print(a+t+c+g)"
   ]
  },
  {
   "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": "2612400f-a80a-4c61-ae28-b30f507538cd",
   "metadata": {},
   "outputs": [],
   "source": [
    "dna_seq = sequence.upper()\n",
    "c = dna_seq.count(\"C\")\n",
    "g = dna_seq.count(\"G\")\n",
    "porc = (c+g)/len(dna_seq)*100\n",
    "print(\"Porcentaje CG\",porc)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "59745209-8042-4fa6-b97f-adc2c70866d9",
   "metadata": {},
   "source": [
    "## Ejemplos con split y join:\n",
    "\n",
    "* Método split([sep [,maxsplit]])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "815c73f5-6a6b-4e42-80bb-13df1790b6e5",
   "metadata": {},
   "outputs": [],
   "source": [
    "arn_sec_desc = 'MN908947.3 Severe acute respiratory syndrome coronavirus 2 isolate Wuhan-Hu-1, complete genome'\n",
    "arn_sec_desc_list=arn_sec_desc.split()\n",
    "print(\"arn_sec_desc_list: \",arn_sec_desc_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6f60b66f-65a4-43d1-9ffa-3c298272e2a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(arn_sec_desc_list[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "18c6dd11-9acc-41d5-ab4b-0a2515ea4b82",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(arn_sec_desc_list[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "522065d8-4ebe-45fa-9f19-288aa48e6350",
   "metadata": {},
   "source": [
    "* Método join(seq)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6fc1de4c-9378-4e8e-bf31-f40b70ae86de",
   "metadata": {},
   "outputs": [],
   "source": [
    "arn_sec_join=\" \".join(arn_sec_desc_list)\n",
    "print(arn_sec_join)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2d12ae6f",
   "metadata": {},
   "source": [
    "# Ejemplos de manipulación de cadenas (Strings)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ac0bec6-acf0-40e0-a44e-9495b901f334",
   "metadata": {},
   "source": [
    "## Caracteres especiales\n",
    "\n",
    "|Secuencia de escape\t|Significado|\n",
    "|:--|:--|\n",
    "|\\\\\t|Backslash|\n",
    "|'\t|Comilla simple|\n",
    "|\"\t|Comilla doble|\n",
    "|\\\\n\t|Nueva línea|\n",
    "|\\\\t\t|Tab|"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c85d2cc-8b4d-40f6-b321-29ddd904bea0",
   "metadata": {
    "scrolled": true
   },
   "source": [
    "## Accesando a caracteres simples"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8fc6d85-8643-46ca-9ee2-2b2f95cba527",
   "metadata": {},
   "source": [
    "El operador `*` con matrices en R realiza una multiplicación elemento a elemento (no es multiplicación de matrices)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "30c20b92-5d1a-485f-afcb-585772956a76",
   "metadata": {},
   "outputs": [],
   "source": [
    "secuencia=sequence.upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8f40ae09-4523-4782-9bdc-2ef12fab564e",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(secuencia)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bcd25d60-8efa-42bc-8162-16bde6715284",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(secuencia[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dd8cb871",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(secuencia[2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a1d15d93-fe8e-4375-a33e-17f3a991b126",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(secuencia[-3])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b3ab041-54a2-414c-9cfb-999a36d732e8",
   "metadata": {},
   "source": [
    "## Accesando a subcadenas (Slicing)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "04d4307b-28fe-48db-9d65-ab8b8182a035",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print(secuencia[:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5734f661-6472-4548-9320-fb8819ebf06a",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(secuencia[0:3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1cc89e10-8359-421e-8165-fd8ae071e761",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(secuencia[:3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "11921c1a-2f69-47ec-a4b7-11ea2aed36f5",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(secuencia[3:5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fa26b839-a84b-47ea-9775-2f1537e4649b",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(secuencia[4:])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b57e705f-dedf-420a-87eb-b4b86c0ee73d",
   "metadata": {},
   "source": [
    "## Funcionalidad de cadenas  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c599382a-3b12-4a12-92fa-f9c914ae2d6a",
   "metadata": {},
   "outputs": [],
   "source": [
    "len(secuencia)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2373067e-f142-4956-8c1a-fd00d587feb6",
   "metadata": {},
   "outputs": [],
   "source": [
    "secuencia.count('A')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "84e57e7b-37c8-4713-8e14-8bac885f9d41",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(secuencia)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "17cd6611",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print(secuencia[:3]+secuencia[3:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5d169246-7c84-454f-a057-dd4f11bb97a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(secuencia[:3]*10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9dba1ebf-3132-4c54-b016-3b791edd721f",
   "metadata": {},
   "outputs": [],
   "source": [
    "len(secuencia[:3]*10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fd0ee172-0f7a-4a4f-8873-b1a23e3f0420",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "subsecuencia=secuencia[3:10]\n",
    "print(subsecuencia)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1585f186-779b-4616-8c48-242e708eebee",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"ATTA\" in secuencia"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0ab90823-e0bb-451d-9822-f4b921f9d473",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"GTTG\" in secuencia"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cb0c7d55-9e98-4659-bc8c-af6886593c30",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"TTTT\" in secuencia"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1a5a31c2-9947-4dc2-8224-9950f8498128",
   "metadata": {},
   "outputs": [],
   "source": [
    "\"TTTTT\" in secuencia"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a5d3e9ba-11b0-46be-86a4-5d680c310334",
   "metadata": {},
   "outputs": [],
   "source": [
    "secuencia.startswith('ATT')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a4d0e1c7-9cd7-4454-8ed9-0b6da8c43124",
   "metadata": {},
   "outputs": [],
   "source": [
    "secuencia.startswith('ATG')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2e35488c-6683-4e96-8ac6-08db723a5ed1",
   "metadata": {},
   "outputs": [],
   "source": [
    "secuencia.lower()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b968b10d-03a1-44f6-9c40-8f9ce20e11c1",
   "metadata": {},
   "outputs": [],
   "source": [
    "secuencia.lower().upper()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07ef1fff-e1ce-44a9-a387-df561aedcae8",
   "metadata": {},
   "source": [
    "### Resumen Operaciones básicas:\n",
    "|Operación|Acción|\n",
    "|-|-|\n",
    "| S = “AATTGG” | Asignación de una cadena|\n",
    "| s1 + s2 | Concatena|\n",
    "| s2 * 3 | Repite|\n",
    "| s2\\[i\\] | Caracter de la posición i|\n",
    "| s2\\[x:y\\] | Subcadena entr x y y|\n",
    "| len(S) | Longitud de un string|\n",
    "| int(S) | Convierte un string en un entero|\n",
    "| float(S) | Convierte un string en un número flotante|"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d05a97f",
   "metadata": {},
   "source": [
    "### Resumen de métodos con cadena\n",
    "|Método|\n",
    "|-|\n",
    "|S.upper()|\n",
    "|S.lower()|\n",
    "|S.count(substring)|\n",
    "|S.replace(old,new)|\n",
    "|S.find(substring)|\n",
    "|S.startswith(substring)|\n",
    "|S. endswith(substring)|"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c90bb42-4185-4590-8a1e-37e2d0ebd680",
   "metadata": {},
   "source": [
    "## Listas en Python\n",
    "\n",
    "En Python, las listas son una estructura de datos muy flexible y útil que permite almacenar múltiples elementos en una sola variable. Los elementos de una lista pueden ser de cualquier tipo de datos (números, cadenas, booleanos, otras listas, etc.) y la lista puede contener una combinación de estos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5681a5bc-4a04-4f4b-9868-01476cef3813",
   "metadata": {},
   "outputs": [],
   "source": [
    "first_list = [1, 2, 3, 4, 5]\n",
    "other_list = [1, 'two', 3, 4, 'last']\n",
    "nested_list = [1, 'two', first_list, 4, 'last']\n",
    "empty_list = []\n",
    "print(\"first_list: \", first_list,\"\\nother_list: \", other_list,\"\\nnested_list: \", nested_list,\"\\nempty_list: \", empty_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad8ea6d9-06d7-4cb0-b5ae-bdaf75f3867e",
   "metadata": {},
   "source": [
    "### Accesando los Elementos de las Listas en Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4811f20e-5695-4ead-93ce-99e4dc5477e3",
   "metadata": {},
   "outputs": [],
   "source": [
    "first_list = [1, 2, 3, 4, 5]\n",
    "\n",
    "print(\"first_list[0]: \", first_list[0],\"\\nfirst_list[1]: \", first_list[1],\"\\nfirst_list[2]: \", first_list[2],\"\\nfirst_list[3]: \", first_list[3],\"\\nfirst_list[-1]: \", first_list[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "712618cb-eba2-467a-98d1-672e8ecfd07f",
   "metadata": {},
   "source": [
    "## Función list()\n",
    "La función list() en Python se utiliza para convertir un objeto iterable (como una cadena, tupla, conjunto, o incluso un rango) en una lista. Cuando se pasa un iterable como argumento a list(), la función crea una nueva lista que contiene todos los elementos del iterable en el mismo orden. Si se llama a list() sin argumentos, crea una lista vacía. Esta función es útil cuando se necesita convertir otros tipos de colecciones en listas para aprovechar las operaciones y métodos específicos de las listas en Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "df4302a2-25fb-4f23-a9a8-4c83e1ebfd47",
   "metadata": {},
   "outputs": [],
   "source": [
    "secuencia"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "79a4792e-2635-4964-86c3-7106ada07d7d",
   "metadata": {},
   "outputs": [],
   "source": [
    "aseq_list=list(secuencia)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "71819b37-8001-43de-97d1-15ffe5b3a2a9",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print(\"aseq_list: \",aseq_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "617d77af-2c25-4ccc-a33a-725be8259185",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(aseq_list[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cc3ab67f-5bc5-4981-b709-64e7c422979e",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(aseq_list[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "12a6791f-1de4-4e7b-851a-7e47f8afdfaa",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(aseq_list[-3])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff237c15-1811-4de1-8a6c-e92deb949937",
   "metadata": {},
   "source": [
    "## Listas con elementos repetidos\n",
    "Para una lista con un mismo elemento repetido varias veces se puede usar el operador *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aa031e59-6099-40f0-863a-36849d7fb6a9",
   "metadata": {},
   "outputs": [],
   "source": [
    "A4=['A']*4\n",
    "print(A4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ba0f8649-b5b2-41e8-95ba-0ebde2c35b1d",
   "metadata": {},
   "outputs": [],
   "source": [
    "V4=[None] * 4\n",
    "print(V4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b9329f8-29ac-4570-aa3f-b9343f63458f",
   "metadata": {},
   "source": [
    "Operaciones con listas\n",
    "\n",
    "|Método|Descripción|\n",
    "|-|-|\n",
    "|l.append(x)| Agrega el elemento x a la lista l |\n",
    "|l.count(x) | Cuenta cuantas veces x está en la lista l|\n",
    "|l.index(x) | Devuelve la posición de x en la lista l|\n",
    "|l.remove(x) | Remueve el elemento x de la lista l|\n",
    "|l.reverse() | Invierte la lista l|\n",
    "|l.sort() | Ordena la lista l|"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "696a243b-1212-4677-b799-9eaf2f595b35",
   "metadata": {},
   "source": [
    "## Diccionarios\n",
    "Los diccionarios son un tipo de datos especial que no están presente en todos los lenguajes de programación. La característica principal de un diccionario es que almacena tipos de datos desordenados e indexados en estructuras clave-valor de manera arbitraria."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8e0ba9d0-470e-4480-a217-73f0e2b3a939",
   "metadata": {},
   "outputs": [],
   "source": [
    "DNA={'T':'Thimina','A':'Adenina','G':'Guanina','C':'Citosina'}\n",
    "print(DNA['A'],'\\n',DNA['C'],'\\n',DNA['G'],'\\n',DNA['T'])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac4eeba8-360b-4b12-a420-988ab6d67759",
   "metadata": {},
   "source": [
    "No todos los objetos se pueden usar como una clave de diccionario. Solo los objetos inmutables como: cadenas, tuplas y números pueden ser usados como claves. Si la tupla contiene cualquier objeto mutable, no se puede usar como clave. \n",
    "\n",
    "También se puede crear un diccionario a partir de una secuencia con dict:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4af8080a-c5f9-4b5d-8cdd-f2a3af34d40e",
   "metadata": {},
   "outputs": [],
   "source": [
    "rgb = dict(red='ff0000', green='00ff00', blue='0000ff')\n",
    "print(rgb)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ff7e762-d6cb-4c24-9e32-12e6d27a33d3",
   "metadata": {},
   "source": [
    "Otra forma de inicializar un diccionario es crear un diccionario vacío y agregar los elementos cuando sea necesario:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7faed313-eead-4386-82a4-2335bfd62964",
   "metadata": {},
   "outputs": [],
   "source": [
    "rgb = {}\n",
    "rgb['red'] = 'ff0000'\n",
    "rgb['green'] = '00ff00'\n",
    "print(rgb)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7078664-8644-4489-8756-f66440bad325",
   "metadata": {},
   "source": [
    "### Métodos asociados con diccionarios\n",
    "\n",
    "|Propiedades | Descripción|  \n",
    "|-|-|\n",
    "|len(d) | Número de elementos de d  |\n",
    "|d[k] | El elemento de d que tiene una clave k  |\n",
    "|d[k] = v | Establecer d[k] a v  |\n",
    "|del d[k] | Eliminar d[k] de d  |\n",
    "|d.clear() | Eliminar todos los elementos de d  |\n",
    "|d.copy() | Copiar d  |\n",
    "|k in d | Verdadero si d tiene una clave k, si no Falso  |\n",
    "|k not in d | Equivalente a no k en d  |\n",
    "|d.has_key(k) | Equivalente a k en d, usar esa forma en el nuevo código |\n",
    "|d.items() | Una copia de la lista de pares de (clave, valor) de d.  |\n",
    "|d.keys() | Una copia de la lista de claves de d  |\n",
    "|Propiedades | Descripción  |\n",
    "|d.update([b]) | Actualiza (y sobrescribe) pares de clave / valor de b  |\n",
    "|d.fromkeys(seq[, valor]) | Crea diccionario con claves de seq y valores de value  |\n",
    "|d.values() | Una copia de la lista de valores de d  |\n",
    "|d.get(k[, x]) | d[k], si k en d, sino x  |\n",
    "|d.setdefault(k[, x]) –> d[k], si k en d, sino x (también configurándolo)  |\n",
    "|d.pop(k[, x]) | d[k] si k en d, sino x (y eliminar k)  |\n",
    "|d.popitem() | Eliminar y devolver un par arbitrario (clave, valor)  |"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c123bd03-2a61-47fb-ba7e-1d9b368a797a",
   "metadata": {},
   "source": [
    "## Tarea \n",
    "\n",
    "### 1. Práctica\n",
    "Usando `python` con sus librerías estándar, en la siguiente secuencia https://seracademia.com/academia/Bio_Info/M5/ASM1888508v1/ncbi_dataset/data/GCA_018885085.1/GCA_018885085.1_ASM1888508v1_genomic.fna extraiga:\n",
    "\n",
    "* El nombre de la secuencia\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f88abc5c-8b07-423a-b429-84052b92fcc4",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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": "52b1799d-bb32-4120-a747-5c2987c0ee0f",
   "metadata": {},
   "source": [
    "### 2. Cuestionario\n",
    "\n",
    "Conteste las siguientes preguntas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "80c0d0c3-9859-4493-ac26-8f60804b0719",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "54b45a3a-2bfb-4f86-9e0d-9f90cdcdd502",
   "metadata": {},
   "source": [
    "#### 2.1. ¿Cómo se hace el análisis exploratio de archivos  en python?"
   ]
  },
  {
   "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.3. ¿cuál es la difernecia entre listas y diciconarios en `python`?"
   ]
  },
  {
   "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 la transcripción a ARNm con las librerías estandar de `python`?"
   ]
  },
  {
   "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
}