{
"cells": [
{
"cell_type": "markdown",
"id": "cc3a69f4-f804-4564-a0df-b6baa1551386",
"metadata": {},
"source": [
"# Pontificia Universidad Católica del Ecuador\n",
"## Maestría Virtual en Biología Computacional\n",
"### Programación para las ciencias biológicas\n",
"#### BASH\n",
"Charles Escobar\n",
"2024\n",
"\n",
"**Nombre del estudiante:** "
]
},
{
"cell_type": "markdown",
"id": "2a6deee2-1f5b-4183-baba-c286cdbdf353",
"metadata": {},
"source": [
"# **\"Biología Computacional con BASH\"**\n",
"## Uso avanzado del terminal BASH\n",
"\n",
"En este cuaderno, vamos a explorar cómo utilizar la herramienta de línea de comandos BASH (Bourne Again SHell) para realizar tareas avanzadas en el terminal para analizar archivos biológicos. Recordemos que BASH permite automatizar tareas, trabajar con archivos y datos, y obtener resultados rápidos y precisos.\n",
"\n",
"**¿BASH para el análisis bioinformático?**\n",
"\n",
"Para realizar tareas de análisis bioinformático con Bash, se pueden utilizar herramientas estándar como `grep`, `awk`, `sed`, `cut`, etc., en combinación con otros programas bioinformáticos como SAMTools, BWA, Bowtie, GATK, etc.\n",
"\n",
"Algunas de las tareas que se pueden realizar con Bash y herramientas \n",
"bioinformáticas son:\n",
"\n",
"1. La extracción de secuencias específicas de un archivo FASTA utilizando `grep` o `awk`.\n",
"2. La alineación de secuencias de ADN utilizando algoritmos como BWA, Bowtie o ClustalW.\n",
"3. El procesamiento de secuencias de RNA para la detección de variantes y el análisis de expresión genética utilizando herramientas como GATK, VarScan2 o Cufflinks.\n",
"4. La manipulación de datos de Secuenciación por PCR (PCR-Seq) utilizando SAMTools o BCFtools.\n",
"5. El análisis de colectas de secuencias para la detección y caracterización de especies utilizando herramientas como MEGAN, QIIME o USEARCH.\n",
"6. La extracción y procesamiento de datos de Secuenciación por Solexa (Illumina) utilizando herramientas como CASAVA o Trimmomatic.\n",
"7. El análisis de la calidad de los archivos de secuencias utilizando FastQC.\n",
"8. La manipulación de archivos VCF para la detección y anotación de variantes y el análisis del impacto en las proteínas utilizando herramientas como BCFtools o ANNOVAR.\n",
"9. El análisis de datos de Secuenciación por masa de iones (IonTorrent) utilizando TOFCaller o VarScan2.\n",
"\n",
"Es importante tener en cuenta que para realizar estas tareas es necesario tener conocimientos básicos de bioinformática y un buen dominio del lenguaje Bash, así como una comprensión de los algoritmos utilizados por cada herramienta.\n",
"\n",
"En esta parte del curso nos centraremos en el dominio de BASH dejando el uso de algoritmos especializados para cursos posteriores.\n",
"\n",
"\n",
"**¿Qué esperamos aprender en esta libreta?**\n",
"\n",
"En esta libreta de trabajo, vamos a explorar los siguientes temas:\n",
"\n",
"* Uso avanzado de BASH: tuberías y redireccionamiento\n",
"* Trabajar con `AWK` y `BIOAWK`\n",
"* Trabajo con archivos de secuencias y datos en Bash\n",
"* Análisis estadístico y comparación de secuencias\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "538053a0-2093-4aa9-9bc6-1e3ecca20393",
"metadata": {},
"source": [
"## Tuberías\n",
"\n",
"Las tuberías en Bash son una característica de los sistemas Unix y Linux que permite la redirección del flujo de datos entre dos comandos. Las tuberías se crean utilizando el operador `|` (pipe).\n",
"\n",
"Cuando se ejecuta un comando en Bash, su salida está dirigida al dispositivo estándar de salida por defecto, normalmente la consola. La tubería permite redirigir este flujo de datos de la salida de uno a la entrada de otro comando sin tener que guardarlo en un archivo intermedio.\n",
"\n",
"En general, se puede expresar una tubería como:\n",
"```bash\n",
"comando1 | comando2\n",
"```\n",
"Aquí, `comando1` es el comando que produce la salida y `comando2` es el comando que recibe la salida de `comando1`. La tubería permite ejecutar estos dos comandos en una sola línea de comandos.\n",
"\n",
"Un ejemplo práctico podría ser:\n",
"```bash\n",
"ls -l | grep \".txt\"\n",
"```\n",
"Aquí, el primer comando `ls -l` lista los archivos y directorios actuales en formato largo (detallado). El segundo comando `grep \".txt\"` busca las líneas que contienen la extensión .txt. La tubería permite redirigir la salida de `ls -l` a la entrada de `grep`.\n",
"\n",
"Existen también otros operadores de redirección de flujo en Bash, como `>`, `>>`, `<`, etc., que permiten manipular el flujo de datos de una manera más específica.\n"
]
},
{
"cell_type": "markdown",
"id": "6db21097-4db6-4d91-ba65-ca12eab6d98f",
"metadata": {},
"source": [
"Para comenzar a trabajar, listemos los archivos de nuestra carpeta de trabajo"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "5eba0013-ac21-464d-bbbe-7cdb8579e2bd",
"metadata": {},
"outputs": [],
"source": [
"ls -l"
]
},
{
"cell_type": "markdown",
"id": "05ba740a-a0e9-4d42-953a-4b56a6eccc67",
"metadata": {},
"source": [
"### Comando `grep`\n",
"\n",
"Como vimos en el cuaderno de trabajo previo, `grep` es una herramienta de línea de comandos que sirve para buscar patrones específicos en archivos o flujo de texto.\n",
"\n",
"#### Sintaxis básica\n",
"```markdown\n",
"grep [OPCIONES] PATRÓN ARCHIVO\n",
"```\n",
"\n",
"#### Opciónes\n",
"\n",
"| Opciones | Descripción |\n",
"| --- | --- |\n",
"| `-i` | Ignora mayúsculas y minúsculas (case-insensitive) |\n",
"| `-r` | Busca en todos los archivos dentro de un directorio especificado \n",
"|\n",
"| `-v` | Muestra las líneas que no coinciden con el patrón buscado |\n",
"| `-n` | Imprime la línea número en lugar del texto (line number) |\n",
"| `-c` | Sólo muestra cuantas coincidencias hay |\n",
"\n",
"#### Ejemplos de uso\n",
"```bash\n",
"# Busca la palabra \"error\" en un archivo llamado \"archivo.txt\"\n",
"$ grep \"error\" archivo.txt\n",
"\n",
"# Busca en todo el directorio actual la palabra \"warning\"\n",
"$ grep -r \"warning\" .\n",
"\n",
"# Muestra todas las líneas de \"archivo.txt\" que no contengan \"error\"\n",
"$ grep -v \"error\" archivo.txt\n",
"\n",
"# Imprime solo el número de la línea con coincidencias\n",
"$ grep -n \"error\" archivo.txt\n",
"\n",
"# Sólo muestra cuantas veces se encuentra la palabra \"error\" en \n",
"\"archivo.txt\"\n",
"$ grep -c \"error\" archivo.txt\n",
"```\n",
"-------------------------------\n"
]
},
{
"cell_type": "markdown",
"id": "ed134c9a-19dc-4601-b183-de848825094b",
"metadata": {},
"source": [
"Con el uso de las tuberías y `grep` podemos filtrar solo aquellos archivos cuya extensdión es `ipynb` y que corresponden a cuadernos de trabajo jupyter"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "2fb39049-abb7-47eb-b4c7-3a4ca345fb64",
"metadata": {},
"outputs": [],
"source": [
"ls -l | grep ipynb"
]
},
{
"cell_type": "markdown",
"id": "787e5234-a07e-4900-92c8-2bdeee9165d8",
"metadata": {},
"source": [
"Dado que estamos trabajando con la carpeta **t-coffe** de **sampledata**, con la ayuda de tuberías y el comando `grep`,podemos filtrar solo aquellos archivos cuya extensión sea *.fasta* "
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "27564a5e-16d0-4f5f-ac4c-5b7196b0a297",
"metadata": {},
"outputs": [],
"source": [
"ls sampledata/t-coffee|grep -i fasta"
]
},
{
"cell_type": "markdown",
"id": "bfb6eeb7-0204-435f-8406-dfe12d3d22cb",
"metadata": {},
"source": [
"De este grupo podemos filtrar solo aquellos cuyos nombres hagan referencia a *dna*"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "405d7019-c992-4c1c-87d4-631280a68c09",
"metadata": {
"scrolled": true
},
"outputs": [],
"source": [
"ls sampledata/t-coffee|grep -i fasta|grep dna"
]
},
{
"cell_type": "markdown",
"id": "cece266e-07f3-4b44-a37e-ea23564d5824",
"metadata": {},
"source": [
"Veamos el contenido de *sampledata/t-coffee/sproteases_small_dna.fasta*"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "883a5b35-fdd9-47de-861a-9ea303691d84",
"metadata": {
"scrolled": true
},
"outputs": [],
"source": [
"cat sampledata/t-coffee/sproteases_small_dna.fasta"
]
},
{
"cell_type": "markdown",
"id": "b3dcd84f-3c5d-46d5-868f-9a7beff4a48a",
"metadata": {},
"source": [
"Podemos ver que la primera secuencia tien 17 líneas, por lo que con la ayuda del comando `head` podemos extraer solo esas lineas"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "15e0e06c-3e82-45a2-855a-45a163f46f6a",
"metadata": {},
"outputs": [],
"source": [
"head sampledata/t-coffee/sproteases_small_dna.fasta -n17"
]
},
{
"cell_type": "markdown",
"id": "bb2ab609-3d70-4f66-a8e0-9452d716fc54",
"metadata": {},
"source": [
"### Comando `awk`\n",
"\n",
"#### Descripción\n",
"\n",
"La herramienta de línea de comandos `awk` es una utilidad de procesamiento \n",
"de texto que se utiliza para procesar y manipular archivos de datos en \n",
"formato tabular.\n",
"\n",
"#### Sintaxis básica\n",
"```markdown\n",
"awk [OPCIONES] 'SCRIPT' ARCHIVO\n",
"```\n",
"\n",
"#### Opciones\n",
"\n",
"| Opción | Descripción |\n",
"| --- | --- |\n",
"| `-F` (Separador de campos) | Establece el separador de campos en lugar \n",
"del tabulador (default: tab). |\n",
"| `-v VAR=VALOR` (Variable global) | Establece una variable global con un \n",
"valor especificado. |\n",
"| `-f SCRIPT` (Script externo) | Ejecuta el script en un archivo separado. \n",
"|\n",
"| `-m` (Múltiples reglas) | Utiliza múltiples reglas de patrón para \n",
"seleccionar las líneas a procesar. |\n",
"| `-p` (Regla por línea) | Selecciona una sola línea para ser procesada. |\n",
"\n",
"#### Reglas de patrón\n",
"\n",
"Las reglas de patrón se definen dentro de corchetes (`{}`) y pueden \n",
"utilizar las siguientes acciones:\n",
"\n",
"| Acción | Descripción |\n",
"| --- | --- |\n",
"| `{pattern}` | Selecciona solo las líneas que contienen el patrón. |\n",
"| `{ /regex/ }` | Selecciona solo las líneas que coincidan con la \n",
"expresión regular (regex). |\n",
"| `{NF} / Número de campos en la línea actual` | Selecciona solo las \n",
"líneas con un determinado número de campos. |\n",
"| `{NR%n} / n` | Selecciona cada n-ésimo registro (línea). |\n",
"\n",
"#### Ejemplos de uso\n",
"\n",
"##### Procesar un archivo por línea\n",
"\n",
"```bash\n",
"# Muestra las primeras 5 columnas de un archivo llamado \"archivo.txt\"\n",
"$ awk '{print $1,$2,$3,$4,$5}' archivo.txt\n",
"\n",
"# Muestra la cuarta columna de todos los archivos dentro del directorio \n",
"actual\n",
"$ awk -F':' '{print $NF}' *\n",
"\n",
"# Muestra solo las líneas que contengan la palabra \"error\" en un archivo \n",
"llamado \"archivo.txt\"\n",
"$ awk '/error/' archivo.txt\n",
"```\n",
"##### Utilizar variables en el script\n",
"```bash\n",
"# Definimos una variable global con un valor especificado\n",
"$ awk -v pi=3.14 '{print \"El área del círculo es: \"pi*($2/2)^2}' \n",
"archivo.txt\n",
"```\n",
"##### Utilizar múltiples reglas de patrón para seleccionar las líneas a procesar\n",
"```bash\n",
"# Muestra la primera y tercera columna de las líneas que contengan la \n",
"palabra \"error\" en un archivo llamado \"archivo.txt\"\n",
"$ awk -F':' '/error/{print $1,$3}' archivo.txt\n",
"```\n",
"##### Seleccionar una sola línea para ser procesada\n",
"```bash\n",
"# Muestra la primera columna de la tercera línea en un archivo llamado \n",
"\"archivo.txt\"\n",
"$ awk -F':' 'NR==3{print $1}' archivo.txt\n",
"```\n",
"-------------------------------\n"
]
},
{
"cell_type": "markdown",
"id": "db201203-cefd-4e51-a1f0-2870d6ab668c",
"metadata": {},
"source": [
"un ejemplo sencillo con `awk` puede sr convertir un texto amayúsculas o viceversa, en este caso podemor convertir la cadena a mayúsculas con `awk '{print toupper($0)}'`, lo contrario sería; `awk '{print tolower($0)}'`:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "95b199b0-a538-4166-b9c3-bd92e7eb38f1",
"metadata": {
"scrolled": true
},
"outputs": [],
"source": [
"head sampledata/t-coffee/sproteases_small_dna.fasta -n17|awk '{print toupper($0)}'"
]
},
{
"cell_type": "markdown",
"id": "27a2b8af-1e97-4c87-9ad6-532a7dd14a2b",
"metadata": {},
"source": [
"Los archivos con la extensión `.pdb` (Protein Data Bank) son archivos de \n",
"datos genómicos que contienen información detallada sobre la estructura \n",
"tridimensional de moléculas proteicas y complejos macromoleculares. Estos \n",
"archivos se utilizan comúnmente en bioquímica, biología molecular y \n",
"computacional para modelar y analizar las estructuras de proteínas.\n",
"\n",
"Los archivos `.pdb` contienen información sobre la posición espacial de \n",
"cada átomo de la molécula, así como detalles sobre las interacciones \n",
"químicas que tienen lugar entre los átomos. Además, también pueden incluir \n",
"información adicional sobre el contexto físico y funcional de la molécula, \n",
"tales como su lugar en una célula o un organismo vivo.\n",
"\n",
"Los archivos `.pdb` son utilizados en una amplia variedad de aplicaciones, \n",
"desde el diseño de drogas para medicamentos a la investigación de \n",
"enfermedades genéticas y el desarrollo de modelos computacionales de \n",
"moléculas proteicas. La información contenida en estos archivos es crucial \n",
"para entender cómo las moléculas funcionan en sus diferentes estados y \n",
"para diseñar terapias eficaces basadas en la estructura molecular.\n"
]
},
{
"cell_type": "markdown",
"id": "8a188723-9d78-400e-97af-c7d21e7a64c1",
"metadata": {},
"source": [
"De manera ilustrativa podemos ver las primeras el archivo `head sampledata/t-coffee/struc1.pdb` para con la ayuda de `awk` extraer información "
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d3b962b8-6a04-4504-a2c0-64d061c2dff8",
"metadata": {},
"outputs": [],
"source": [
"head sampledata/t-coffee/struc1.pdb -n 20"
]
},
{
"cell_type": "markdown",
"id": "20a9e4b0-bca6-46ec-8069-3a95c6a6699d",
"metadata": {},
"source": [
"Veamos ahora las últimas líneas:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "baaee3b6-6c2d-477f-9440-265b08b87281",
"metadata": {},
"outputs": [],
"source": [
"tail sampledata/t-coffee/struc1.pdb -n 20"
]
},
{
"cell_type": "markdown",
"id": "0a247c9d-f7ac-4fca-8197-a5aae93314d7",
"metadata": {},
"source": [
"Estas últimas líneas corresponden describen la estructura tridimensional de moléculas, generalmente proteínas y ácidos nucleicos. Cada línea describe un átomo específico de la molécula, proporcionando información sobre su ubicación y otras propiedades. \n",
"\n",
"El formato específico de cada línea es el siguiente:\n",
"\n",
"- **ATOM**: Identifica que la línea describe un átomo en una molécula.\n",
"- **Número (2510, 2511, etc.)**: Número secuencial del átomo en el modelo estructural.\n",
"- **Nombre del átomo (O, CB, CG, etc.)**: Identifica el átomo (por ejemplo, O para oxígeno, CB para carbono beta, etc.).\n",
"- **Residuo**: El nombre del residuo (en este caso, GLN para glutamina, TYR para tirosina, TRP para triptófano).\n",
"- **Número del residuo**: El número del residuo en la secuencia de la cadena de proteínas (por ejemplo, 189 para GLN, 190 para TYR, etc.).\n",
"- **Coordenadas (X, Y, Z)**: Las coordenadas tridimensionales (en angstroms) del átomo en el espacio.\n",
"- **Factor de ocupación (1.00)**: Indica la ocupación del átomo, que generalmente es 1.00 en estructuras completas.\n",
"- **Factor B (15.55, 18.95, etc.)**: Factor de temperatura, que describe la movilidad del átomo en la estructura.\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "f17084ff-6675-4c69-ac08-915d88cfb66c",
"metadata": {},
"source": [
"La línea de la secuencia 2506 describe:\n",
"\n",
"```\n",
"ATOM 2506 O ILE 323 24.921 39.645 13.475 1.00 35.99\n",
"```\n",
"\n",
"corresponde a un átomo en un archivo PDB (Protein Data Bank) y describe lo siguiente:\n",
"\n",
"- **ATOM**: Indica que es una línea que describe un átomo de la estructura.\n",
" \n",
"- **2506**: El número secuencial del átomo en la estructura. Es el número único que identifica a este átomo dentro de la estructura en el archivo PDB.\n",
"\n",
"- **O**: El nombre del átomo. En este caso, es el átomo de oxígeno (\"O\").\n",
"\n",
"- **ILE**: El nombre del residuo. \"ILE\" es el código de tres letras para el aminoácido **isoleucina**.\n",
"\n",
"- **323**: El número del residuo en la cadena de proteínas. Esto indica que este átomo pertenece al residuo número 323 de la secuencia de la proteína.\n",
"\n",
"- **24.921, 39.645, 13.475**: Las coordenadas tridimensionales (X, Y, Z) del átomo en el espacio. Estas son las posiciones del átomo de oxígeno en la estructura 3D de la molécula (en unidades de Ångströms, Å).\n",
"\n",
"- **1.00**: El factor de ocupación. Este valor indica que el átomo está completamente ocupado en la estructura, es decir, está presente en esa posición con una probabilidad del 100%.\n",
"\n",
"- **35.99**: El **B-factor** o factor de temperatura, que refleja la movilidad o el grado de flexibilidad del átomo. Un valor más alto generalmente indica mayor movimiento o incertidumbre en la posición del átomo. En este caso, el átomo tiene un B-factor de 35.99, lo que sugiere cierta flexibilidad o imprecisión en su localización.\n",
"\n",
"En resumen, esta línea describe un átomo de oxígeno (O) de un residuo de isoleucina (ILE) en la posición 323 de la secuencia de la proteína, con las coordenadas (24.921, 39.645, 13.475) en el espacio tridimensional, un factor de ocupación de 1.00 y un B-factor de 35.99."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "121f25a6-9a3d-40bd-89a1-600372f94a94",
"metadata": {},
"outputs": [],
"source": [
"con aWK podemos extraer la descxripción, nombre del átomo, numero secuecial y coordenadas del fichero:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "e4ce7658-ec8a-45c9-a3ba-6c15b3cdbc85",
"metadata": {},
"outputs": [],
"source": [
"tail sampledata/t-coffee/struc1.pdb -n 20|awk -F\" \" '{print $1\" \"$2\" \"$3\" \"$6\" \"$7\" \"$8}'"
]
},
{
"cell_type": "markdown",
"id": "45fa819f-45e3-4f1c-9e40-0b9ab67fbca3",
"metadata": {},
"source": [
"Con la ayuda de `grep` podemos filtrar solo aquellos que correspondan a Oxígeno"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "18828920-b7f9-4e83-bed8-78e04c278825",
"metadata": {
"scrolled": true
},
"outputs": [],
"source": [
"cat sampledata/t-coffee/struc1.pdb|awk -F\" \" '{print $1\" \"$2\" \"$3\" \"$6\" \"$7\" \"$8}'|grep -w \"O\""
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cec316e2-1981-4e38-ad8f-059e99b0e8d6",
"metadata": {},
"outputs": [],
"source": [
"cat sampledata/t-coffee/struc1.pdb|awk -F\" \" '{print $1\" \"$2\" \"$3\" \"$6\" \"$7\" \"$8}'|grep -w \"O\"|wc -l"
]
},
{
"cell_type": "markdown",
"id": "24a637d7-abdb-4fb4-a333-728cf533a249",
"metadata": {},
"source": [
"Del cual vemos 323 ocurrencias.\n",
"\n",
"Veamos que ocurre con el nitrógeno e hidrógeno"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "1ed032b2-1287-4aa0-9afa-8eeff9f49c50",
"metadata": {},
"outputs": [],
"source": [
"cat sampledata/t-coffee/struc1.pdb|awk -F\" \" '{print $1\" \"$2\" \"$3\" \"$6\" \"$7\" \"$8}'|grep -w \"N\"|wc -l"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cb4c1359-d461-455b-a947-d19d72b4b41b",
"metadata": {},
"outputs": [],
"source": [
"cat sampledata/t-coffee/struc1.pdb|awk -F\" \" '{print $1\" \"$2\" \"$3\" \"$6\" \"$7\" \"$8}'|grep -w \"H\"|wc -l"
]
},
{
"cell_type": "markdown",
"id": "358aa461-94f1-47b4-a9b4-1d345bafd897",
"metadata": {},
"source": [
"En este caso vemos el mismo número de átomos de nitrógeno per no se muestra Hidrógeno, lo cual puede deberse a son difíciles de resolver con precisión en los datos experimentales."
]
},
{
"cell_type": "markdown",
"id": "9a2a3600-1c27-4380-81fe-70f250863039",
"metadata": {},
"source": [
"### bioawk\n",
"`bioawk` es una herramienta de línea de comandos basada en `awk` \n",
"específicamente diseñada para procesar archivos de datos genómicos, tales \n",
"como archivos `.pdb`, archivos de secuencia de ADN y otros formatos \n",
"relacionados con la bioinformática.\n",
"\n",
"El software `bioawk` fue desarrollado originalmente por el proyecto OpenMS \n",
"(Open Microscopy Software) en 2010 y actualmente es mantenido por el \n",
"proyecto Bioconductor, que es un conjunto de herramientas de código \n",
"abierto para la análisis y visualización de datos genómicos.\n",
"\n",
"`bioawk` cuenta con una serie de características únicas que lo distinguen \n",
"de otras herramientas de procesamiento de texto como `awk`. Algunas de \n",
"estas características son:\n",
"\n",
"* Soporte de tipos de datos específicos para la bioinformática, tales como \n",
"enteros, flotantes y strings.\n",
"* Compatibilidad con archivos genómicos comunes, como archivos `.fasta`, \n",
"archivos `.pdb` y archivos `.bed`.\n",
"* Integración de lenguajes de programación como Perl y Python para la \n",
"extensibilidad del software.\n",
"* Posibilidad de cargar archivos de reglas separados, lo que permite a los \n",
"usuarios especificar una serie de operaciones sobre los datos genómicos.\n",
"* Integración con otros paquetes de bioinformática populares, como el \n",
"paquete R.\n",
"\n",
"El software `bioawk` es gratuito y está disponible para descargar en la \n",
"página web oficial del proyecto Bioconductor \n",
"(). Además, hay una amplia comunidad de \n",
"usuarios y desarrolladores que pueden brindar ayuda y solucionar problemas \n",
"a los nuevos usuarios del software.\n"
]
},
{
"cell_type": "markdown",
"id": "321eef76-869f-4100-ab0b-8e2cc9cbb22b",
"metadata": {},
"source": [
"Para nuestro caso podemos instalar `bioawk` desde nuestro terminal, recuerde que no es buena idea ejecutar este comando desde el cuaderno de jupyter.\n",
"\n",
"Abra un terminal y ejecute:\n",
"\n",
"```bash\n",
"sudo apt install bioawk\n",
"```"
]
},
{
"cell_type": "markdown",
"id": "640b3b8c-10d1-4311-9359-066989818ec1",
"metadata": {},
"source": [
"Una vez instalado bioawk podemos ver la longitude de la cadena de ADN que habíamos revisado previamente.\n",
"\n",
"Dado que bioawk es una extensión de awk, podemos realizar la misma consulta, pero con bioawk\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "14cbe58d-4d72-429b-9a45-fd89d7f886ae",
"metadata": {},
"outputs": [],
"source": [
"head sampledata/t-coffee/sproteases_small_dna.fasta -n17|bioawk '{print toupper($0)}'"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "90f8bac1",
"metadata": {},
"outputs": [],
"source": [
"head sampledata/t-coffee/sproteases_small_dna.fasta -n17|bioawk '{print toupper($0)}'|bioawk -c fastx '{print length($seq)}'"
]
},
{
"cell_type": "markdown",
"id": "1b140e20-6f15-4f04-bf30-1589bcb5de87",
"metadata": {},
"source": [
"aquí las opciones:\n",
"* -c fastx: Especifica que la entrada es en formato FASTA o FASTQ.\n",
"* length($seq): Calcula la longitud de la secuencia.\n",
"* | : Alimenta el comando a través de la tubería. Otra forma de hacerlo era con `bioawk -c fastx '{print length($seq)}' archivo.fasta`"
]
},
{
"cell_type": "markdown",
"id": "272fa3ae-39a7-4f79-86d3-edb46d0b6536",
"metadata": {},
"source": [
"También podemos contar la cantidad de veces que aparece cada una de las bases nitrogenadas A, G, T y C"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b822c0f3-042d-432e-839e-1e23b3957dd3",
"metadata": {},
"outputs": [],
"source": [
"head sampledata/t-coffee/sproteases_small_dna.fasta -n17|bioawk '{print toupper($0)}'|bioawk -c fastx '{count=0; for(i=1; i<=length($seq); i++) if(substr($seq,i,1)==\"A\") count++; print count}'\n"
]
},
{
"cell_type": "markdown",
"id": "4fc1696e-0c3d-4d2f-ac6f-0180a28481d6",
"metadata": {},
"source": [
"en este caso:\n",
"+ substr($seq,i,1): Extrae una letra de la secuencia en la posición i.\n",
"+ count++: Aumenta el contador si la letra es \"A\"."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "fb3acd87",
"metadata": {},
"outputs": [],
"source": [
"head sampledata/t-coffee/sproteases_small_dna.fasta -n17|bioawk '{print toupper($0)}'|bioawk -c fastx '{count=0; for(i=1; i<=length($seq); i++) if(substr($seq,i,1)==\"G\") count++; print count}'\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "a174a394",
"metadata": {},
"outputs": [],
"source": [
"head sampledata/t-coffee/sproteases_small_dna.fasta -n17|bioawk '{print toupper($0)}'|bioawk -c fastx '{count=0; for(i=1; i<=length($seq); i++) if(substr($seq,i,1)==\"T\") count++; print count}'\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d0fd103a",
"metadata": {},
"outputs": [],
"source": [
"head sampledata/t-coffee/sproteases_small_dna.fasta -n17|bioawk '{print toupper($0)}'|bioawk -c fastx '{count=0; for(i=1; i<=length($seq); i++) if(substr($seq,i,1)==\"C\") count++; print count}'\n"
]
},
{
"cell_type": "markdown",
"id": "5470450b-3bac-4c69-9ac9-fcbb36741e52",
"metadata": {},
"source": [
"La suma de la cantidad de veces de cada una de las bases nitrogenadas nos dan la longitud que previamente habíamos encontrado"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "74d41828-a4e9-4f49-8364-da4dc3bed945",
"metadata": {},
"outputs": [],
"source": [
"echo $((199+209+186+168))"
]
},
{
"cell_type": "markdown",
"id": "8e912c12-20df-4555-9fa1-bbbaf82fb684",
"metadata": {},
"source": [
"Si se quiere obtener un fragmento de la secuencia, como las primeras 150 bases, se puede usar el siguiente comando:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "a9aa0f0f-0a6e-4144-a8c5-e1648c01ad32",
"metadata": {},
"outputs": [],
"source": [
"head sampledata/t-coffee/sproteases_small_dna.fasta -n17|bioawk '{print toupper($0)}'|bioawk -c fastx '{print substr($seq, 1, 150)}' "
]
},
{
"cell_type": "markdown",
"id": "c9cae0a1-f2e4-447d-bbe9-06f90aba252b",
"metadata": {},
"source": [
"+ substr($seq, 1, 150): Extrae las primeras 150 bases de la secuencia."
]
},
{
"cell_type": "markdown",
"id": "1c713687-8283-4bd3-8b74-6cc1a672a42d",
"metadata": {},
"source": [
"Si se desea mostrar el descriptor de la secuencia:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "62b087fd-f293-4dd6-a209-55401b5de742",
"metadata": {},
"outputs": [],
"source": [
"head sampledata/t-coffee/sproteases_small_dna.fasta -n17|bioawk -c fastx '{print $name}'"
]
},
{
"cell_type": "markdown",
"id": "ee6f5de2-1076-4c80-88d9-17a9dfd3bd26",
"metadata": {},
"source": [
"+ $name: Contiene el identificador de la secuencia (el encabezado de la línea que comienza con >)."
]
},
{
"cell_type": "markdown",
"id": "6dd2de9c-b0ac-4ea7-8b75-b6a2a34d05b7",
"metadata": {},
"source": [
"Con esto también podemos extrar solo los descriptores de todo el archivo:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c48e9235-58f8-46b5-8a2c-7ea3dade5539",
"metadata": {},
"outputs": [],
"source": [
"cat sampledata/t-coffee/sproteases_small_dna.fasta|bioawk -c fastx '{print $name}'"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "ee7d8015-29ca-4860-a683-07a20a5ef519",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "code",
"execution_count": null,
"id": "30c9809c-2a94-4611-9d5e-1d472ccaacc0",
"metadata": {},
"outputs": [],
"source": [
"head sampledata/t-coffee/sproteases_small_dna.fasta -n17|bioawk '{print toupper($0)}'|bioawk -c fastx '{A=0; T=0; G=0; C=0; for(i=1; i<=length($seq); i++) {if(substr($seq,i,1)==\"A\") A++; if(substr($seq,i,1)==\"T\") T++; if(substr($seq,i,1)==\"G\") G++; if(substr($seq,i,1)==\"C\") C++} print \"A: \" A \" T: \" T \" G: \" G \" C: \" C}' "
]
},
{
"cell_type": "markdown",
"id": "56e049f9-0ec5-4f2f-aacc-8fddabb2f2f3",
"metadata": {},
"source": [
"De manera detallada esta instrucción utiliza **`bioawk`**, como extensión de **`awk`** para trabajar con secuencias biológicas, como en este caso de una secuencia **FASTA**. Esta orden cuenta la cantidad de bases nitrogenadas (A, T, G, C) en una secuencia de ADN.\n",
"\n",
"Veamos como se desglosa la instrucción:\n",
"\n",
"```bash\n",
"head sampledata/t-coffee/sproteases_small_dna.fasta -n17|bioawk -c fastx '{A=0; T=0; G=0; C=0; for(i=1; i<=length($seq); i++) {if(substr($seq,i,1)==\"A\") A++; if(substr($seq,i,1)==\"T\") T++; if(substr($seq,i,1)==\"G\") G++; if(substr($seq,i,1)==\"C\") C++} print \"A: \" A \" T: \" T \" G: \" G \" C: \" C}'\n",
"```\n",
"\n",
"### Desglose de la instrucción:\n",
"\n",
"\n",
"1. **`head sampledata/t-coffee/sproteases_small_dna.fasta -n17|`**:\n",
" - Esta instrucción extrae la secuencia en formato FASTA del archivo `sproteases_small_dna.fasta`. En este caso, el segmento contiene una secuencia de ADN con su correspondiente encabezado, que corresponden a las 17 primeras líneas de ese archivo. La salida de esta tubería alimentará al comando bioawk\n",
"2. **`bioawk -c fastx`**:\n",
" - **`bioawk`**: Este es el comando que ejecuta la herramienta `bioawk`, la cual está diseñada para manejar secuencias biológicas.\n",
" - **`-c fastx`**: Este parámetro le indica a `bioawk` que los datos de entrada están en formato FASTA o FASTQ (en este caso, se asume que la silda de la tubería está en formato FASTA). Este formato incluye una línea de encabezado (que comienza con `>`) seguida por la secuencia de nucleótidos (en este caso, A, T, G, C para ADN). Si el archivo fuera FASTQ, también incluiría una calidad de lectura, pero aquí trabajamos solo con la secuencia.\n",
"\n",
"3. **`{A=0; T=0; G=0; C=0;`**:\n",
" - **`A=0; T=0; G=0; C=0;`**: Inicializa las variables **`A`**, **`T`**, **`G`**, y **`C`** en 0. Estas variables se utilizarán para contar la cantidad de veces que cada base nitrogenada (adenina, timina, guanina y citosina) aparecen en la secuencia de ADN.\n",
" \n",
"4. **`for(i=1; i<=length($seq); i++)`**:\n",
" - **`for(i=1; i<=length($seq); i++)`**: Este es un bucle **for** que recorre cada carácter de la secuencia de ADN, desde el primero hasta el último. \n",
" - **`$seq`**: En `bioawk`, **`$seq`** es una variable especial que contiene la secuencia de nucleótidos de cada entrada en el archivo FASTA. Así que este bucle recorre toda la secuencia de nucleótidos base por base.\n",
" - **`length($seq)`**: Esta función devuelve la longitud total de la secuencia de ADN. El bucle se ejecuta tantas veces como el número de caracteres en la secuencia (es decir, el número total de bases).\n",
"\n",
"5. **`{if(substr($seq,i,1)==\"A\") A++;`**:\n",
" - **`substr($seq, i, 1)`**: Esta función toma un **substr** (subcadena) de la secuencia **`$seq`**. En este caso, toma un solo carácter (de longitud 1) comenzando en la posición **`i`**.\n",
" - **`if(substr($seq,i,1)==\"A\") A++;`**: Si el carácter en la posición **`i`** es una **adenina** (`\"A\"`), entonces se incrementa el contador **`A`** en 1. Lo mismo se repite para las bases **T**, **G** y **C** con las siguientes líneas:\n",
" - **`if(substr($seq,i,1)==\"T\") T++;`**: Si el carácter es timina (T), incrementa el contador **`T`**.\n",
" - **`if(substr($seq,i,1)==\"G\") G++;`**: Si el carácter es guanina (G), incrementa el contador **`G`**.\n",
" - **`if(substr($seq,i,1)==\"C\") C++;`**: Si el carácter es citosina (C), incrementa el contador **`C`**.\n",
"\n",
"6. **`print \"A: \" A \" T: \" T \" G: \" G \" C: \" C`**:\n",
" - **`print \"A: \" A \" T: \" T \" G: \" G \" C: \" C`**: Una vez que el bucle ha terminado de recorrer toda la secuencia, este comando imprime el número de ocurrencias de cada base (A, T, G, C). \n",
" - El **`print`** muestra el resultado en la pantalla o terminal.\n",
" - En este caso:\n",
" ```\n",
" A: 199 T: 186 G: 209 C: 168\n",
" ```\n",
" Donde **199**, **186**, **209**, y **168** son los números de veces que **A**, **T**, **G**, y **C** aparecen en la secuencia.\n",
"\n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "aa53add9-2202-4dde-9285-03d3f351fad7",
"metadata": {},
"source": [
"También podemos ver ese resuldado en porcentajes:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "99475cd5-12e1-4a79-8744-147a90e93576",
"metadata": {},
"outputs": [],
"source": [
"head sampledata/t-coffee/sproteases_small_dna.fasta -n17|bioawk '{print toupper($0)}'|bioawk -c fastx '{A=0; T=0; G=0; C=0; for(i=1; i<=length($seq); i++) {if(substr($seq,i,1)==\"A\") A++; if(substr($seq,i,1)==\"T\") T++; if(substr($seq,i,1)==\"G\") G++; if(substr($seq,i,1)==\"C\") C++} print \"A: \" 100*A/length($seq) \"% T: \" 100*T/length($seq) \"% G: \" 100*G/length($seq) \"% C: \" 100*C/length($seq)\"%\"}' "
]
},
{
"cell_type": "markdown",
"id": "83967b31-88d6-4f60-b2fc-e7e6b599b11c",
"metadata": {},
"source": [
"### Resumen\n",
"\n",
"En esta práctica hemos podifo trabajar con `tuberías`. `awk` y `bioawk` dónde hemos visto que es posible:\n",
"+ Conectar la salida de un comando a otro a atrvés de tuberías\n",
"+ Contar bases o aminoácidos específicos.\n",
"+ Obtener estadísticas como la longitud de la secuencia.\n",
"+ Modificar la secuencia (convertir a mayúsculas/minúsculas).\n",
"+ Extraer fragmentos de la secuencia.\n",
"+ Filtrar o mostrar identificadores de las secuencias.\n",
"+ Calcular la composición de la secuencia."
]
},
{
"cell_type": "markdown",
"id": "16eb7afe-725e-41b2-bfeb-8949113102b6",
"metadata": {},
"source": [
"## Tarea \n",
"\n",
"### 1. Práctica\n",
"Con el mismo archivo que estamos trabajando extraiga la secuencia del descriptor *\"sp|P21844|MCPT5_MOUSE\"* y muestre:"
]
},
{
"cell_type": "markdown",
"id": "5c0bc554-92a7-4e7c-a72d-d1c69243377c",
"metadata": {},
"source": [
"#### 1. La longitud de esta secuencia"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "512a7034-95e5-4919-90f1-3c663a9fbb93",
"metadata": {},
"outputs": [],
"source": [
"# Código y respuesta"
]
},
{
"cell_type": "markdown",
"id": "31248ff0-7681-4f46-b021-db15994112ae",
"metadata": {},
"source": [
"#### 2. Las primeras 60 bases nitrogenadas de la secuencia"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "6e11cb35-5716-4f14-a5b3-62901ab34fc4",
"metadata": {},
"outputs": [],
"source": [
"# Código y respuesta"
]
},
{
"cell_type": "markdown",
"id": "1b2aa979-8921-45ab-9995-4d1bb422e736",
"metadata": {},
"source": [
"#### 3. La cantidad de veces de cada una de las bases nitrogenadas"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "9b7f1340-0584-48d9-82a1-fcc36909c8d8",
"metadata": {},
"outputs": [],
"source": [
"# Código y respuesta"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "6d310042-af76-423a-920d-ce8b186ac8b6",
"metadata": {},
"outputs": [],
"source": [
"#### 4. El porcentaje de cada una de las bases nitrogenadas\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "6556343f-c6aa-4045-8b61-309ffc12022d",
"metadata": {},
"outputs": [],
"source": [
"# Código y respuesta"
]
},
{
"cell_type": "markdown",
"id": "8dc2cde3-5fb1-4f81-b08b-57be9aed9d72",
"metadata": {},
"source": [
"### 2. Cuestionario\n",
"\n",
"Conteste las siguientes preguntas"
]
},
{
"cell_type": "markdown",
"id": "cd6ee19e-f1bd-48c2-9a09-96d96d9a80a4",
"metadata": {},
"source": [
"#### 2.1. ¿Cómo podría utilizar grep para buscar una secuencia específica de nucleótidos dentro de un archivo FASTA que contiene varias secuencias de ADN? (Revise la práctica anterior)"
]
},
{
"cell_type": "markdown",
"id": "eafb90a2-e69f-40e4-aa9f-3e9fffc26f3c",
"metadata": {},
"source": [
"ponga aquí su respuesta"
]
},
{
"cell_type": "markdown",
"id": "183f4dba-97a8-414d-b1d5-0db21a6674c2",
"metadata": {},
"source": [
"#### 2.2. ¿Cómo convertiría una secuencia biológica de mayúsculas a minúsculas usando bioawk?. cómo ejemplo aplíquelo al archivo \"sample_aln2.fasta\" de la carpeta t-coffe"
]
},
{
"cell_type": "markdown",
"id": "ce5ad841-dd44-4c9f-8b62-78130f37f054",
"metadata": {},
"source": [
"ponga aquí su respuesta"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "06a6d8c3-60fd-4427-b26d-811a20d6f14f",
"metadata": {},
"outputs": [],
"source": [
"# Código y respuesta"
]
},
{
"cell_type": "markdown",
"id": "1be86755-0a3e-40bf-b3bf-bdf436b5eb4d",
"metadata": {},
"source": [
"#### 2.3. ¿Cómo podría usar bioawk para extraer los nombres de las secuencias y sus longitudes en un archivo FASTA?"
]
},
{
"cell_type": "markdown",
"id": "97593c57-351a-4869-b504-4933c0e81afd",
"metadata": {},
"source": [
"ponga aquí su respuesta"
]
},
{
"cell_type": "markdown",
"id": "059d0f2e-003c-4c7c-9318-e08f01c71e04",
"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": "f794f0d0-b583-42a8-ab0b-3caf6c58860f",
"metadata": {},
"source": [
"## Conclusiones\n",
"1. Conclusión 1\n",
"2. Conclusión 2\n",
"3. Conclusión 3"
]
},
{
"cell_type": "markdown",
"id": "b300a9e8-dfb2-47f1-b2b4-5768889dcefd",
"metadata": {},
"source": [
"## Recomendaciones\n",
"1. Recomendación 1\n",
"2. Recomendación 2\n",
"3. Recomendación 3"
]
},
{
"cell_type": "markdown",
"id": "b66302a9-89cb-464e-873d-d6f94bd23c85",
"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": "474ae391-09f8-4218-883f-2edb696b0f00",
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Bash",
"language": "bash",
"name": "bash"
},
"language_info": {
"codemirror_mode": "shell",
"file_extension": ".sh",
"mimetype": "text/x-sh",
"name": "bash"
}
},
"nbformat": 4,
"nbformat_minor": 5
}