{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "8610cf01-7eb3-4091-b22a-d5c6af085f34",
   "metadata": {},
   "source": [
    "\n",
    "# <center>Pontificia Universidad Católica del Ecuador</center>\n",
    "## <center>Maestría Virtual en Biología Computacional</center>\n",
    "### <center>Programación para las ciencias biológicas</center>\n",
    "#### <center>BASH</center>\n",
    "<center>Charles Escobar</center>\n",
    "<center>2024</center>\n",
    "\n",
    "**Nombre del estudiante:**  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d71be93-b16b-4a9b-92a9-572df6de30ee",
   "metadata": {},
   "source": [
    "# **\"Biología Computacional con BASH\"**\n",
    "## Uso 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 computacionales en biología. La programación en Bash permite automatizar tareas, trabajar con archivos y datos, y obtener resultados rápidos y precisos.\n",
    "\n",
    "**¿Qué es BASH?**\n",
    "\n",
    "BASH es un entorno de línea de comandos (shell) que permite interactuar con el sistema operativo para realizar una amplia variedad de tareas. Es especialmente útil en entornos de laboratorio, donde se necesita trabajar rápidamente y eficientemente con datos y archivos.\n",
    "\n",
    "**¿Por qué utilizar BASH en biología computacional?**\n",
    "\n",
    "La programación en Bash permite:\n",
    "\n",
    "* **Automatizar tareas**: crear scripts para realizar tareas repetitivas, como la creación de árboles de secuencias o el procesamiento de imágenes.\n",
    "* **Trabajar con archivos de secuencias y datos**: manejar archivos de texto plano, como las secuencias biológicas, imágenes, audio y video, y realizar operaciones en ellos.\n",
    "* **Obtener resultados rápidos y precisos**: utilizar herramientas y bibliotecas para realizar análisis estadísticos, comparar secuencias y más.\n",
    "\n",
    "**¿Qué esperamos aprender en esta libreta?**\n",
    "\n",
    "En esta libreta de trabajo, vamos a explorar los siguientes temas:\n",
    "\n",
    "* Introducción a BASH: conceptosy básicos de uso\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": "f00c5667-618b-4e38-ae11-936b16951bb0",
   "metadata": {},
   "source": [
    "## Estructura de comandos en GNU/Linux\n",
    "* La estructura de comandos en GNU/Linux se basa en la convención de \n",
    "utilizar un comando como primer término, seguido de opciones y luego el \n",
    "objetivo o archivo que se desea trabajar. Por ejemplo, el comando `ls` es \n",
    "el comando principal, mientras que las opciones `-l`, `-a` y `-d` se \n",
    "utilizan para especificar cómo se deben mostrar los archivos. En este \n",
    "caso, el comando sería: `ls -l -a -d /path/to/directory`.\n",
    "\n",
    "* La estructura de comandos en GNU/Linux también permite utilizar la \n",
    "sintaxis de parámetros secuenciales, donde se pueden colocar varios \n",
    "objetivos o argumentos dentro del comando principal. Por ejemplo, el \n",
    "comando `rm` puede ser utilizado para eliminar archivos individuales, \n",
    "directorios y carpetas con la sintaxis: `rm archivo1 archivo2 \n",
    "/path/to/directory`. En este caso, el comando sería: `rm archivo1 archivo2 \n",
    "/path/to/directory`.\n",
    "\n",
    "Algunos ejemplos de comandos en GNU/Linux y su estructura son:\n",
    "\n",
    "* `cp -r /source /destination` (copiar directorio y contenido)\n",
    "* `mv archivo original archivoNuevo` (movir archivo)\n",
    "* `tar -xvf archivo.tar.gz` (descomprimir archivo comprimido)\n",
    "\n",
    "En general, la estructura de comandos en GNU/Linux es flexible y se puede \n",
    "adaptar a las necesidades específicas del usuario.\n",
    "\n",
    "Algunos de los comandos que usaremos en esta parte del curso son:\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6fbd65c6-ca2e-47c4-afd0-8cc3fd3981a4",
   "metadata": {},
   "source": [
    "### Comando `hostname`\n",
    "\n",
    "* El comando `hostname` muestra la nombre de host actual del sistema.\n",
    "* La sintaxis básica es `hostname`.\n",
    "* Puede ser utilizado para obtener información sobre el sistema, como la \n",
    "identidad de usuario o el número de procesador."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f4b1f409-6fb5-4058-94be-12113b40394a",
   "metadata": {},
   "outputs": [],
   "source": [
    "hostname"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d10c3576-861f-4ef6-a10b-708b3a6b0673",
   "metadata": {},
   "source": [
    "### Comando `uname`\n",
    "\n",
    "* El comando `uname` muestra información sobre el sistema operativo y \n",
    "hardware del sistema.\n",
    "* La sintaxis básica es `uname -a`, que muestra una lista detallada de los \n",
    "detalles del sistema.\n",
    "* También se pueden utilizar opciones como `-s` para mostrar la versión de \n",
    "kernel, `-r` para mostrar la versión de sistema, `-o` para mostrar el \n",
    "nombre de usuario y `-n` para mostrar el nombre de host."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9fb4bb0d-9b42-4f01-9a3e-9bdd1408cddc",
   "metadata": {},
   "outputs": [],
   "source": [
    "uname -a"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9a5c2a3-8ebf-4058-8839-f6b30176cd6a",
   "metadata": {},
   "source": [
    "### Comando `lsb_release`\n",
    "\n",
    "* El comando `lsb_release -a` muestra información sobre el sistema \n",
    "operativo y las distribuciones que se pueden instalar en el sistema.\n",
    "* La sintaxis básica es `lsb_release -a`.\n",
    "* Puede ser utilizado para verificar la versión de Linux y obtener \n",
    "información sobre los paquetes disponibles en el repositorio."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8a8ea579-77a4-4506-b2e3-e5b3bf04a08f",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "lsb_release -a"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4b840bb-4ec9-498c-933d-fc126c96beab",
   "metadata": {},
   "source": [
    "### Comando `df`\n",
    "\n",
    "* El comando `df` muestra información sobre el espacio disponible en los \n",
    "dispositivos de almacenamiento del sistema.\n",
    "* La sintaxis básica es `df -h`, que muestra una lista detallada de los \n",
    "dispositivos y su capacidad disponible.\n",
    "* Puede ser utilizado para verificar la cantidad de espacio libre en el \n",
    "disco duro y planificar la gestión de almacenamiento."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5c26e2d6-0de4-4e5c-9b76-473c92d8cdf1",
   "metadata": {},
   "outputs": [],
   "source": [
    "df -h"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a837ca51-0a0a-4fa1-8098-bc856901e784",
   "metadata": {},
   "outputs": [],
   "source": [
    "id"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b52060ce-f9e6-4f15-9fdc-ad805226dc83",
   "metadata": {},
   "source": [
    "### Comando `free`\n",
    "\n",
    "* El comando `free` muestra información sobre el uso del memoria física y \n",
    "virtual del sistema.\n",
    "* La sintaxis básica es `free -m`, que muestra una lista detallada de los \n",
    "detalles de memoria disponible.\n",
    "* Puede ser utilizado para verificar la cantidad de memoria libre y \n",
    "planificar la gestión de recursos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b1e3cc24-7102-4832-8d89-b11cbd7509ae",
   "metadata": {},
   "outputs": [],
   "source": [
    "free"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "844be4f1-b9f2-4350-bb73-d131abd4645d",
   "metadata": {},
   "outputs": [],
   "source": [
    "free -m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7646287d-d79e-479f-a74d-b3da50a8dc0a",
   "metadata": {},
   "outputs": [],
   "source": [
    "free -mh"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e28b407-c069-4bc3-ad12-678e13e0fdc3",
   "metadata": {},
   "source": [
    "### Comando `w`\n",
    "\n",
    "* El comando `w` muestra información sobre el tiempo actual y las sesiones \n",
    "actuales del sistema.\n",
    "* La sintaxis básica es `w`.\n",
    "* Puede ser utilizado para verificar el tiempo actual y obtener \n",
    "información sobre los usuarios conectados al sistema."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e992bb1d-fa81-4783-9bee-ccca557a00bc",
   "metadata": {},
   "outputs": [],
   "source": [
    "w"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6aef7bf1-a6e0-4d5a-bdfe-faa369ee1d94",
   "metadata": {},
   "source": [
    "### Comando `touch`\n",
    "\n",
    "* El comando `touch` crea un archivo vacío con la fecha y hora actuales.\n",
    "* La sintaxis básica es `touch archivo.txt`, que crea un archivo llamado \n",
    "`archivo.txt`.\n",
    "* Puede ser utilizado para crear archivos temporales o de prueba sin \n",
    "contenido."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a92cdd63-331f-4a30-bff0-ee6eaba53e14",
   "metadata": {},
   "outputs": [],
   "source": [
    "touch archivo.txt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "19f87969-04ca-4bf0-9893-84a49edc3de8",
   "metadata": {},
   "source": [
    "### Comando `ls`\n",
    "\n",
    "* El comando `ls` (siglas de \"listar\") es utilizado para mostrar la lista de archivos y directorios en un determinado directorio.\n",
    "* La sintaxis básica es `ls [opciones] [directorio]`, donde:\n",
    " + `[opciones]`: puede incluir opciones como `-a` para mostrar todos los archivos, incluso los ocultos; `-l` para mostrar una lista \n",
    "detallada con información adicional sobre cada archivo; y `-r` para mostrar el contenido de directorios en profundidad.\n",
    " + `[directorio]`: es el directorio que se desea listar. Si no se proporciona, el comando funciona en la carpeta actual.\n",
    "\n",
    "**Ejemplos:**\n",
    "\n",
    "* `ls`: muestra la lista de archivos y directorios en la carpeta actual.\n",
    "* `ls -l`: muestra una lista detallada con información adicional sobre cada archivo.\n",
    "* `ls -a`: muestra todos los archivos, incluyendo los ocultos.\n",
    "* `ls -r`: muestra el contenido de directorios en profundidad.\n",
    "\n",
    "**Opciones adicionales:**\n",
    "\n",
    "* `-A`: ignora los archivos y directorios que comienzan con un punto (`.`).\n",
    "* `-i`: no muestría mensajes de confirmación antes de eliminar archivos o directorios.\n",
    "* `-l`: muestra una lista detallada con información adicional sobre cada archivo.\n",
    "* `-p`: muestra el tiempo de modificación del archivo.\n",
    "* `-R`: muestra el contenido de directorios en profundidad.\n",
    "\n",
    "**Comandos relacionados:**\n",
    "\n",
    "* `cd [directorio]`: cambia a un directorio específico.\n",
    "* `mkdir [nombre_directorio]`: crea un nuevo directorio.\n",
    "* `rm [archivo]`: elimina un archivo o directorio.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ed55733d-1645-4c1e-8869-f0a6f9afe087",
   "metadata": {},
   "outputs": [],
   "source": [
    "ls -l archivo.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "42caaf93-2d5b-42be-a7f3-588efa7b30f7",
   "metadata": {},
   "outputs": [],
   "source": [
    "ls -l"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4b21c84a-832f-474e-af8b-251c2b6ef9ec",
   "metadata": {},
   "source": [
    "### Comando `cp`\n",
    "\n",
    "* El comando `cp` copia un archivo o directorio desde una ubicación \n",
    "destino a otra.\n",
    "* La sintaxis básica es `cp archivo origen destino`, que copia el archivo \n",
    "`archivo` desde la ubicación original `origen` a la ubicación destino \n",
    "`destino`.\n",
    "* Puede ser utilizado para copiar archivos y directorios."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2fa4f416-0948-4afd-aee4-e044e0db4990",
   "metadata": {},
   "outputs": [],
   "source": [
    "cp archivo.txt archivo2.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7a60e6fc-ce92-43be-8a3e-a58a02386fa8",
   "metadata": {},
   "outputs": [],
   "source": [
    "ls -l archivo*"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "369b9d7f-5e2c-4b56-98a3-a2dabc34fc84",
   "metadata": {},
   "source": [
    "### Comando `rm`\n",
    "\n",
    "* El comando `rm` elimina un archivo o directorio de la ubicación del \n",
    "sistema.\n",
    "* La sintaxis básica es `rm archivo`, que elimina el archivo `archivo`.\n",
    "* Puede ser utilizado para eliminar archivos y directorios, pero con \n",
    "precaución para evitar pérdidas de datos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3d993d30-0a3b-4037-a195-5567514c1bdf",
   "metadata": {},
   "outputs": [],
   "source": [
    "rm archivo2.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b1490439-155d-4f51-a338-0f20a5e5c999",
   "metadata": {},
   "outputs": [],
   "source": [
    "ls -l archivo*"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8a91deb-492c-48bd-a47b-cf455fb3846c",
   "metadata": {},
   "source": [
    "### Comando `mv`\n",
    "\n",
    "* El comando `mv` renombra o mueve un archivo o directorio desde una \n",
    "ubicación destino a otra.\n",
    "* La sintaxis básica es `mv archivo origen destino`, que renomba el \n",
    "archivo `archivo` a la ubicación `origen` y lo mueve a la ubicación \n",
    "`destino`.\n",
    "* Puede ser utilizado para renombrar archivos, mover archivos y \n",
    "directorios."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3846dab4-70bf-4d0c-85a1-877cd96d18c8",
   "metadata": {},
   "outputs": [],
   "source": [
    "mv archivo.txt archivo0.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c9a92e25-c29e-4a9b-b4e9-6c1a86834941",
   "metadata": {},
   "outputs": [],
   "source": [
    "ls -l archivo*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e9eaa015-99da-4a2c-ab94-872c0dea2a68",
   "metadata": {},
   "outputs": [],
   "source": [
    "cat archivo0.txt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe767e4d-c120-4565-9981-c60602f30c31",
   "metadata": {},
   "source": [
    "### Comando `pwd`\n",
    "* Este comando permite obtener la ruta del sistema actual, generalmente se \n",
    "utiliza para navegar por directorios y archivos. La sintaxis básica es \n",
    "`pwd` (o `ls -d ..`) que muestra el camino completo de la ubicación de \n",
    "usuario."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f110265c-e0ec-4b01-9679-220ada8bca70",
   "metadata": {},
   "outputs": [],
   "source": [
    "pwd"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b702cf8-00c4-4b99-be43-98cf36a60d5f",
   "metadata": {},
   "source": [
    "### Comando `wget`\n",
    "* `wget` es una herramienta de línea de comandos utilizada para \n",
    "descargar archivos desde Internet. Puede ser utilizada para obtener \n",
    "archivos, páginas web, incluso sitios enteros. La sintaxis básica es `wget \n",
    "URL`, donde `URL` es la dirección del archivo o sitio que se desea \n",
    "descargar."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "21d33582-021f-469d-80bf-47bf1988225c",
   "metadata": {},
   "source": [
    "Ahora, vamos a descargar el archivo `sampledata.tar.gz` ubicado en \n",
    "[https://www.seracademia.com/academia/Bio_Info/sampledata.tar.gz](https://w[https:/www.seracademia.com/academia/Bio_Info/sampledata.tar.gz](https://www.seracademia.com/academia/Bio_Info/sampledata.tar.gz) para trabajar con \n",
    "este curso de BASH. El contenido del archivo contiene secuencias \n",
    "biológicas que nos servirán como datos de prueba y ejemplo en nuestros \n",
    "ejercicios prácticos. Después de descargar el archivo, podemos \n",
    "descomprimirlo utilizando la comando `tar -xvf sampledata.tar.gz` para \n",
    "acceder a los archivos y datos contenidos dentro del archivo comprimido.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9b0b6cc2-591f-4ea6-89c0-b5da68e0f91e",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "wget -c https://www.seracademia.com/academia/Bio_Info/sampledata.tar.gz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "afd003eb-63d2-402a-98af-1d0804a61385",
   "metadata": {},
   "outputs": [],
   "source": [
    "ls -l sampledata.tar.gz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a963f79d-bdc8-4995-af18-1ac8efe4226c",
   "metadata": {},
   "outputs": [],
   "source": [
    "ls -lh"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7fcce17-3623-486f-ad55-5637d75957d3",
   "metadata": {},
   "source": [
    "### Comando `tar`\n",
    "El comando `tar` es una herramienta fundamental en Linux para trabajar \n",
    "con archivos comprimidos y descomprimirlos. Permite realizar acciones como \n",
    "crear, editar y descomprimir archivos comprimidos, así como agregar o \n",
    "eliminar archivos de un conjunto de archivos comprimidos. La sintaxis \n",
    "básica del comando es `tar [-options] archivo[tipo].[extensión]`, donde se \n",
    "pueden utilizar opciones como `-xvf` para descomprimir, `-z` para \n",
    "comprimir en gzip y `-j` para comprimir en bzip2. También permite crear \n",
    "copias de seguridad con el comando `-cf`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1d9b2f31-b8ba-498f-bb6b-e567a1973afe",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "tar -zxvf sampledata.tar.gz"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f0c22f8a-d0e8-4e45-8760-4094f0e27431",
   "metadata": {},
   "source": [
    "para ver el contenido de esta carpeta podemos usar le comando `ls`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a757f211-cbec-4c71-96f8-a4715785ba40",
   "metadata": {},
   "outputs": [],
   "source": [
    "ls sampledata"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d94b7da-1e0c-45e4-8f23-1cccb2d39d5e",
   "metadata": {},
   "source": [
    "### Comando `cat`\n",
    "\n",
    "* El comando `cat` muestra el contenido de un archivo o archivo estándar.\n",
    "* La sintaxis básica es `cat archivo`, que muestra el contenido del \n",
    "archivo `archivo`.\n",
    "* Puede ser utilizado para leer y mostrar contenido de archivos.\n",
    "\n",
    "Podemos usarlo para ver el contenido del archivo sampledata/t-coffee/sproteases_small.fasta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "59e9b275-cb26-434d-b9fd-4f59979c301c",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "cat sampledata/t-coffee/sproteases_small.fasta"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e66cc432-37e2-4a2b-b9e5-02f5d6e7a465",
   "metadata": {},
   "source": [
    "### comando `wc` \n",
    "* El comando `wc` (siglas de \"word count\" o \"cuenta de palabras\") es utilizado para contar el número de palabras, líneas y caracteres en un \n",
    "texto o archivo. La sintaxis básica es `wc [opciones] [archivo]`, donde:\n",
    " + `[opciones]`: puede incluir opciones como `-l` para mostrar solo la cuenta de líneas, `-w` para mostrar solo la cuenta de palabras, o \n",
    "`-c` para mostrar solo la cuenta de caracteres.\n",
    " + `[archivo]`: es el archivo que se desea contar. Si no se proporciona, el comando funciona en la entrada estándar del teclado.\n",
    "\n",
    "**Ejemplos:**\n",
    "\n",
    "* `wc`: muestra la cuenta total de palabras, líneas y caracteres en la entrada estándar del teclado.\n",
    "* `wc -l`: muestra solo la cuenta de líneas.\n",
    "* `wc -w`: muestra solo la cuenta de palabras.\n",
    "* `wc -c`: muestra solo la cuenta de caracteres.\n",
    "\n",
    "**Comandos relacionados:**\n",
    "\n",
    "* `cat [archivo]`: muestra el contenido de un archivo.\n",
    "* `grep [patrón] [archivo]`: busca y muestra una coincidencia de patrón en un archivo.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6cec0da1-2473-43d0-b8fb-525bfd94837f",
   "metadata": {},
   "source": [
    "Con `wc` podemos conocer el número de líneas que tiene este archivo de secuencias"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6810c6de-b95f-4763-8d9b-0511fbbc38eb",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "wc -l sampledata/t-coffee/sproteases_small.fasta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5ab35106-7520-4db1-8c79-8bf5d4ffe91b",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "ls sampledata/t-coffee"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "14f93882-7599-41d3-b45c-1a6d50366853",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "ls sampledata/t-coffee|wc -l"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f96d1b5d-67c6-4236-aa30-b7168264dedd",
   "metadata": {},
   "source": [
    "#### Comando `grep`\n",
    "\n",
    "El comando `grep` es un utilitario de línea de comandos (CLI) en Unix-like que busca \n",
    "una cadena especificada en uno o varios archivos y muestra las líneas que contienen esa \n",
    "cadena. Puede ser útil para encontrar información específica dentro de un archivo \n",
    "grande sin necesidad de leerlo por completo.\n",
    "\n",
    "##### Opciones más importantes\n",
    "\n",
    "- `-r`: Este parámetro hace que el comando `grep` busque la cadena en todos los \n",
    "archivos y subarchivos dentro de un directorio especificado. Por ejemplo, `grep \n",
    "\"palabra\" .` buscaría en todas las entradas del directorio actual.\n",
    "\n",
    "- `-i`: Este parámetro hace que el comando `grep` ignore case, buscando la cadena \n",
    "independientemente de mayúsculas y minúsculas. Por ejemplo, `grep -i \"palabra\" \n",
    "archivo.txt` buscaría \"palabra\", \"Palabra\", etc.\n",
    "\n",
    "- `-v`: Este parámetro hace que el comando `grep` muestre solo las líneas que no \n",
    "contengan la cadena especificada. Por ejemplo, `grep -v \"palabra\" archivo.txt` \n",
    "mostraría todas las líneas que no contengan la palabra \"palabra\".\n",
    "\n",
    "- `-n`: Este parámetro muestra el número de línea en cada línea que contiene la cadena \n",
    "buscada. Por ejemplo, `grep -n \"palabra\" archivo.txt` mostraría la línea en que aparece \n",
    "la palabra \"palabra\" en el archivo.\n",
    "\n",
    "- `-c`: Este parámetro muestra solo el número de líneas que contienen la cadena \n",
    "buscada. Por ejemplo, `grep -c \"palabra\" archivo.txt` mostraría el número de líneas que \n",
    "contienen la palabra \"palabra\" en el archivo.\n",
    "\n",
    "- `-A` NUM: Muestra NUM líneas después de la línea que contiene la coincidencia.\n",
    "- `-B` NUM: Muestra NUM líneas antes de la línea que contiene la coincidencia.\n",
    "\n",
    "##### Ejemplos de uso\n",
    "\n",
    "- Buscar una cadena específica en un archivo: `grep \"palabra\" archivo.txt`\n",
    "- Buscar una cadena independientemente de mayúsculas y minúsculas: `grep -i \"palabra\" \n",
    "archivo.txt`\n",
    "- Buscar todas las líneas que no contengan una cadena específica: `grep -v \"palabra\" \n",
    "archivo.txt`\n",
    "- Mostrar solo el número de línea en que aparece la cadena buscada: `grep -n \"palabra\" \n",
    "archivo.txt`\n",
    "- Mostrar solo el número de líneas que contienen la cadena buscada: `grep -c \"palabra\" \n",
    "archivo.txt`\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "77183d6f-909f-44f9-9804-9e050810fed1",
   "metadata": {},
   "outputs": [],
   "source": [
    "cat sampledata/t-coffee/sproteases_small.fasta|grep \">\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3a0e12c6-fe12-4387-82c4-d80e192116d8",
   "metadata": {},
   "outputs": [],
   "source": [
    "cat sampledata/t-coffee/sproteases_small.fasta|grep \">\"|wc -l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "24ecd558-af6b-4f70-9768-f87ae6fec2c2",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "cat sampledata/t-coffee/sproteases_small.fasta|grep \">\"|grep -i \"human\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c962cbd5-a4b5-43bf-9f7c-2f552d3ab66b",
   "metadata": {},
   "outputs": [],
   "source": [
    "cat sampledata/t-coffee/sproteases_small.fasta|grep \">\"|grep -i \"human\"|wc -l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6112d175-cada-4190-a5cb-e05391b989af",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "cat sampledata/t-coffee/sproteases_large.fasta|grep \">\"|grep -i \"human\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "61ca6c3b-0deb-4f97-8634-4c860998517b",
   "metadata": {},
   "outputs": [],
   "source": [
    "cat sampledata/t-coffee/sproteases_large.fasta|grep \">\"|grep -i \"human\"|wc -l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "75e92c6b-c458-47aa-835e-9c4e1b548878",
   "metadata": {},
   "outputs": [],
   "source": [
    "cat sampledata/t-coffee/sproteases_large.fasta|wc -l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f5bf1f71-c616-4115-8209-eafe6b0861cf",
   "metadata": {},
   "outputs": [],
   "source": [
    "cat sampledata/t-coffee/sproteases_large.fasta|grep -i \"CATG_HUMAN Cathepsin G precursor (EC 3.4.21.20) (CG) - Homo sapiens (Human)\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ecacddcc-2f3c-4fdb-8dd1-4571848bcfd5",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "cat sampledata/t-coffee/sproteases_large.fasta|grep -i \"CATG_HUMAN Cathepsin G precursor (EC 3.4.21.20) (CG) - Homo sapiens (Human)\" -B10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "035fa26f-8071-46b0-ab38-f2443fff8baf",
   "metadata": {},
   "outputs": [],
   "source": [
    "head sampledata/t-coffee/sproteases_large.fasta -n 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c949bc12-6dcd-4c45-9c08-cf16b35b36a4",
   "metadata": {},
   "outputs": [],
   "source": [
    "tail sampledata/t-coffee/sproteases_large.fasta -n5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5ce5848c-f736-40a4-8701-ff9fc57d53e7",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "cat sampledata/t-coffee/sproteases_large.fasta|grep -i \"CATG_HUMAN Cathepsin G precursor (EC 3.4.21.20) (CG) - Homo sapiens (Human)\" -A5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7bf4d396-9c29-41e7-a13d-7f8f193f5418",
   "metadata": {},
   "outputs": [],
   "source": [
    "cat sampledata/t-coffee/sproteases_large.fasta|grep -i \"CATG_HUMAN Cathepsin G precursor (EC 3.4.21.20) (CG) - Homo sapiens (Human)\" -A5 > P08311.fasta "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "71ddd1e5-cb7e-49c2-915e-87671557adf0",
   "metadata": {},
   "outputs": [],
   "source": [
    "ls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8f9dfe25-2d38-4885-acb0-85d3b19a673d",
   "metadata": {},
   "outputs": [],
   "source": [
    "cat P08311.fasta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ca130e28-fae0-4f35-8568-6643d83930a0",
   "metadata": {},
   "outputs": [],
   "source": [
    "cat P08311.fasta|tail -n1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c65e401d-8769-4e8f-9122-b09245659a7b",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "cat P08311.fasta|tail -n5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6febe40d-df21-478e-b76b-cd3cf785f576",
   "metadata": {},
   "outputs": [],
   "source": [
    "head -n1 P08311.fasta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "acd6b3d6-8d3f-4ab6-8e17-12fd645530a7",
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "head -n2 P08311.fasta|tail -n1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d115e848-5eb4-4347-938c-99b60b5768e4",
   "metadata": {},
   "outputs": [],
   "source": [
    "head -n3 P08311.fasta|tail -n1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fda22c41-efe4-4dfa-bff8-a867bad4aa88",
   "metadata": {},
   "outputs": [],
   "source": [
    "head -n4 P08311.fasta|tail -n1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "86820431-2c00-48d8-ab56-d229fe74b406",
   "metadata": {},
   "outputs": [],
   "source": [
    "head -n5 P08311.fasta|tail -n1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c4aafc2f-2e24-44e3-9739-7a61c56ebec4",
   "metadata": {},
   "outputs": [],
   "source": [
    "head -n6 P08311.fasta|tail -n1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fcdbfc48-d39a-4fe5-a447-3023a9d9fe30",
   "metadata": {},
   "outputs": [],
   "source": [
    "head -n6 P08311.fasta|tail -n1|grep -o \"L\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5621443f-2528-4f3a-b51f-e24767851848",
   "metadata": {},
   "outputs": [],
   "source": [
    "head -n6 P08311.fasta|tail -n1|grep -o \"L\"|wc -l"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a37c367c-3b4a-4c88-87c9-f60a29b6e835",
   "metadata": {},
   "source": [
    "### Comando `tr` \n",
    "\n",
    "El comando `tr` (abreviatura de *translate*) se utiliza para realizar transformaciones en un flujo de texto, como reemplazar, eliminar o traducir caracteres.\n",
    "\n",
    "### Sintaxis\n",
    "```bash\n",
    "tr [opciones] SET1 [SET2]\n",
    "```\n",
    "\n",
    "| Opción  | Descripción                                           | Ejemplo                                |\n",
    "|---------|-------------------------------------------------------|----------------------------------------|\n",
    "| `-d`    | Elimina los caracteres de SET1                        | `tr -d 'aeiou'`                        |\n",
    "| `-s`    | Suprime caracteres repetidos                         | `tr -s ' '`                            |\n",
    "| `-c`    | Complementa SET1 (actúa sobre los caracteres no en SET1) | `tr -c 'a-z' 'A-Z'`                   |\n",
    "| `-t`    | Trunca SET2 si tiene más caracteres que SET1          | `tr -t 'a-z' 'A-Z'`                   |\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3fc8aad4-b581-4e95-86bb-08960800e1ed",
   "metadata": {},
   "outputs": [],
   "source": [
    "head -n2 P08311.fasta|tail -n1|tr -d '\\n'|wc -c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f57fcc2a-4ab2-441e-ae3d-34c80a031b12",
   "metadata": {},
   "outputs": [],
   "source": [
    "head -n3 P08311.fasta|tail -n1|tr -d '\\n'|wc -c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0494b3c3-9227-4f8d-b1c2-f295f3b8413b",
   "metadata": {},
   "outputs": [],
   "source": [
    "head -n4 P08311.fasta|tail -n1|tr -d '\\n'|wc -c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "30d9319f-faef-4211-92ed-e65d85628015",
   "metadata": {},
   "outputs": [],
   "source": [
    "head -n5 P08311.fasta|tail -n1|tr -d '\\n'|wc -c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7edaea70-e0e0-4a99-97e5-05221d0d7d18",
   "metadata": {},
   "outputs": [],
   "source": [
    "head -n6 P08311.fasta|tail -n1|tr -d '\\n'|wc -c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7722c062-a677-421c-8d4e-c77839146a7f",
   "metadata": {},
   "outputs": [],
   "source": [
    "tail -n5 P08311.fasta|tr -d '\\n'|wc -c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9aac5222-ed94-4686-9299-0bfb71ba158f",
   "metadata": {},
   "outputs": [],
   "source": [
    "echo \"scale=1;(60*4)+15\"|bc"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7106aa08-215a-49f9-abf3-975f56738144",
   "metadata": {},
   "source": [
    "El comando `bc` (Basic Calculator) es un utilitario de línea de comandos (CLI) en GNU/Linux que permite hacer cálculos matemáticos de precisión arbitraria. Puede ser útil para realizar cálculos más complejos en la Shell de Bash que no puedan ser realizados con los operadores aritméticos básicos de la Shell.\n",
    "\n",
    "El comando `bc` se invoca desde la línea de comandos y espera una serie de expresiones matemáticas separadas por un carácter newline (`\\n`). Estas expresiones pueden ser variables, constantes, operadores aritméticos, funciones, etc.\n",
    "\n",
    "Algunas características de `bc` incluyen:\n",
    "\n",
    "- Alta precisión numérica\n",
    "- Capacidad para trabajar con varias bases numéricas (por ejemplo, 10, 8, y 2)\n",
    "- Soporte para funciones matemáticas integradas (por ejemplo, logaritmos, potencias, senos, cosenos, etc.)\n",
    "- Soporte para definir tus propias funciones y variables\n",
    "\n",
    "Algunos ejemplos de uso del comando `bc` incluyen:\n",
    "\n",
    "```bash\n",
    "echo \"scale=2; (1 + 2) * 3\" | bc\n",
    "5.00\n",
    "echo \"sqrt(9)\" | bc\n",
    "3.00\n",
    "echo \"exp(1)\" | bc\n",
    "e\n",
    "```\n",
    "\n",
    "En estos ejemplos, `scale` se utiliza para controlar la precisión numérica del resultado, mientras que el resto de las líneas son expresiones matemáticas que se evalúan en el comando `bc`.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56f0c689-23d1-4611-a9ef-370ad5de92dc",
   "metadata": {},
   "source": [
    "### Comando fold\n",
    "El comando `fold` permite dividir una cadena de caracteres en bloques especificados, añadiendo \n",
    "automáticamente una línea de salto al final de cada bloque. Esto puede ser \n",
    "útil para ajustar la longitud de las líneas de un archivo sin utilizar \n",
    "otros editores de texto.\n",
    "\n",
    "#### Opciones más importantes\n",
    "\n",
    "- `-w <número>`: Este es el parámetro más importante del comando `fold`, \n",
    "donde `<número>` es la anchura deseada para cada línea resultante. Por \n",
    "ejemplo, `fold -w 70 archivo.txt` dividiría las líneas en el archivo \n",
    "`archivo.txt` con una longitud de 70 caracteres.\n",
    "\n",
    "- `-s`: Este parámetro es similar al anterior, pero la anchura se basa en \n",
    "el ancho del terminal por defecto en lugar de un valor específico. Esto \n",
    "puede ser útil si no sabemos la anchura deseada para las líneas \n",
    "resultantes y queremos que las líneas se ajusten a la anchura del \n",
    "terminal.\n",
    "\n",
    "- `-b`: Este parámetro especifica un separador de bloque para dividir las \n",
    "líneas en el archivo, en lugar de utilizar el tamaño de línea \n",
    "predeterminado. Por ejemplo, `fold -w 70 -b '\\n\\n' archivo.txt` dividiría \n",
    "cada sección del archivo en dos líneas y las ajustaría a la anchura \n",
    "deseada de 70 caracteres.\n",
    "\n",
    "- `-sp`: Este parámetro es una combinación de `-s` y `-b`, donde cada \n",
    "sección se divide en bloques con un separador de línea definido y se \n",
    "ajustan automáticamente a la anchura del terminal.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c7d05154-be34-4c68-ba85-1392a77d7df1",
   "metadata": {},
   "outputs": [],
   "source": [
    "tail -n5 P08311.fasta| fold -w1 | sort | uniq "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d020b92c-35ae-43b9-bfa0-1cce24a4ea1e",
   "metadata": {},
   "outputs": [],
   "source": [
    "tail -n5 P08311.fasta| fold -w1 | sort | uniq |wc -l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "33afe835-f0f0-4fc7-8d88-eff1682c4356",
   "metadata": {},
   "outputs": [],
   "source": [
    "tail -n5 P08311.fasta| fold -w1 | sort | uniq -c | sort -nr"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d31eb16-aa64-4cfc-a951-9c1b23cffaab",
   "metadata": {},
   "source": [
    "El comando `sort` es un utilitario de línea de comandos (CLI) en GNU/Linux que ordena archivos y listas de entrada. Puede ser útil para organizar \n",
    "archivos o datos en una lista de entrada en función de determinados criterios, como el campo delimitado por un carácter específico o la comparación de \n",
    "valores numéricos.\n",
    "\n",
    "Algunas características del comando `sort` incluyen:\n",
    "\n",
    "- Ordenar archivos y listas de entrada en orden ascendente o descendente\n",
    "- Capacidad para ordenar los elementos por campo (separado por un carácter específico)\n",
    "- Capacidad para ignorar ciertos caracteres al ordenar los archivos\n",
    "- Soporte para comparar valores numéricos en diferentes bases (por ejemplo, 10, 8, y 2)\n",
    "- Soporte para combinar el comando `uniq` para eliminar líneas duplicadas al ordenar los archivos\n",
    "\n",
    "Algunos ejemplos de uso del comando `sort` incluyen:\n",
    "\n",
    "```bash\n",
    "sort -o output.txt input.txt\n",
    "sort -k2 input.txt > output.txt\n",
    "sort -n -r input.txt > output.txt\n",
    "sort -u input.txt > output.txt\n",
    "```\n",
    "\n",
    "En estos ejemplos, `input.txt` es el archivo a ordenar, mientras que `output.txt` es el nombre del archivo de salida. Los diferentes opciones \n",
    "especificadas (como `-o`, `-k`, `-n`, y `-r`) controlan cómo se realiza la ordenación de los elementos en función de los criterios mencionados \n",
    "anteriormente.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c90a54f5-a3ac-4aa0-befd-8f0ab6e95c99",
   "metadata": {},
   "source": [
    "### Resumen"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7125c54a-e94c-403a-8a68-43b00f74137a",
   "metadata": {},
   "source": [
    "A través de este cuaderno hemos trabajado con la la Shell de BASH como herramienta para  bioinformática o análisis genético, enfocándonos en:\n",
    "* conceptos y usos básicos\n",
    "* exploración de archivos de secuencias\n",
    "* manipulación de archivos de secuencias\n",
    "* extracción de información de archivos de secuencias\n",
    "* Redirección de la salida estándar a un archivo"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bbccd681-ac2d-4a12-a768-99331044b74d",
   "metadata": {},
   "source": [
    "## Tarea \n",
    "\n",
    "### 1. Práctica\n",
    "#### 1.1 Con el archivo `sampledata/t-coffee/sproteases_large.fasta` extraiga la secuencia del descriptor *\">sp|Q7RTY8|TMPS7_HUMAN Transmembrane protease, serine 7 precursor (EC 3.4.21.-) - Homo sapiens (Human).\"* y redirecciónela a un archivo llamado `Q7RTY8.fasta`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1c45b7fc-2962-49a0-8dd7-5f0c9edefd30",
   "metadata": {},
   "outputs": [],
   "source": [
    "#  Código y respuesta"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cdc6360f-48d8-4491-bec7-10cb478f026e",
   "metadata": {},
   "source": [
    "#### 1.2 Muestre el número de aminoácidos por línea en esta secuencia"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "78e22758-8bd9-4de9-a48f-a61163ed8ac1",
   "metadata": {},
   "outputs": [],
   "source": [
    "#  Código y respuesta"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4f05bd5-0734-4ce3-89be-ac6a76aa811d",
   "metadata": {},
   "source": [
    "#### 1.3 Muestre el número total de aminoácidos que tiene esta secuencia "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7bacf058-98e3-42f6-ad15-29f6a4932d9b",
   "metadata": {},
   "outputs": [],
   "source": [
    "#  Código y respuesta"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff383e40-1411-4b88-bee5-0cf0550498b3",
   "metadata": {},
   "source": [
    "#### 1.4 Muestre el número de veces que cada aminoácidos está presente en esta secuencia"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "77f84615-c795-4b17-9603-96c886c4c562",
   "metadata": {},
   "outputs": [],
   "source": [
    "#  Código y respuesta"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff94e66e-053a-4af0-aed9-e7888581484c",
   "metadata": {},
   "source": [
    "### 2. Cuestionario\n",
    "\n",
    "Conteste las siguientes preguntas:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bdb7eb6d-313b-4099-91a8-e96a2394e746",
   "metadata": {},
   "source": [
    "#### 2.1 ¿Cómo utilizaría el comando hostname en BASH para identificar el nombre del equipo en el que está trabajando y por qué es importante este dato en un entorno de servidores?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "83ba2bf4-0f86-484e-9315-9bfb70718c4d",
   "metadata": {
    "scrolled": true
   },
   "source": [
    "ponga aquí su respuesta"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ae3cb17-52f9-4772-bb38-82854f1ef9b2",
   "metadata": {},
   "source": [
    "#### 2.2 Explique ¿cómo podría realizar un análisis estadístico básico sobre un conjunto de datos en BASH, utilizando comandos como cat, wc y grep, para obtener información como el número total de líneas, palabras o caracteres en un archivo?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd6d19b2-2246-4ad2-85b7-bdec419848f2",
   "metadata": {},
   "source": [
    "ponga aquí su respuesta"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e9e7e623-10a0-4a45-b7fd-20ae1244b5e1",
   "metadata": {},
   "source": [
    "#### 2.3 ¿De qué manera podría utilizar grep en conjunto con otros comandos de BASH para comparar secuencias de ADN almacenadas en archivos y encontrar patrones comunes o diferencias significativas entre ellas?"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "706047ad-fbef-4e9d-9354-06883a8201cf",
   "metadata": {},
   "source": [
    "ponga aquí su respuesta"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2431d455-df1c-4dea-8233-b40f96ba4228",
   "metadata": {},
   "source": [
    "#### 2.4 Si tiene un archivo de texto con secuencias de datos en múltiples líneas. ¿Cómo usaría el comando tr para modificar el formato de estas secuencias, por ejemplo, para convertir todas las letras a mayúsculas o minúsculas? (revise la documentación de `tr`)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3b843237-fd1e-4147-aaa3-4c88e32a3ab5",
   "metadata": {},
   "source": [
    "ponga aquí su respuesta"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fe97d03f-68d2-4274-9558-f735741102b3",
   "metadata": {},
   "source": [
    "#### 2.5 En un archivo que contiene grandes secuencias de datos biológicos, ¿cómo emplearía los comandos wc, fold y cat para contar el número de bases nitrogenadas o aminoácidos de una secuencia? Como ejemplo cuente las bases nitrogenadas de la secuencia 3; `>seq3` del archivo `sampledata/t-coffee/sample_dnaseq1.fasta`"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "897f5c10-8dfe-4f55-ae65-909abeda5951",
   "metadata": {},
   "source": [
    "ponga aquí su respuesta"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06415e02-2519-4a59-a984-6ade9c61d08a",
   "metadata": {},
   "source": [
    "código y respuesta"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9adc23ab-93dc-420c-9ef4-1735f9a35238",
   "metadata": {},
   "source": [
    "#### 2.6 Si necesita obtener información sobre el sistema operativo en un servidor remoto, ¿Qué comandos utilizaría para obtener detalles sobre la versión del sistema operativo y la distribución que se está utilizando? muestre el resultado del servidor con el que está trabajando"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d78da21-a01a-467f-9cac-916e8d454d42",
   "metadata": {},
   "source": [
    "ponga aquí su respuesta"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b89f31f9-89af-40dc-8ca1-3b239a2e6543",
   "metadata": {},
   "source": [
    "código y respuesta"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "119b4c00-7770-4202-99e5-5a5fa7058b65",
   "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": "aa6dce82-df3e-40c4-baa3-21d694107ab4",
   "metadata": {},
   "source": [
    "## Conclusiones\n",
    "1. Conclusión 1\n",
    "2. Conclusión 2\n",
    "3. Conclusión 3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f0b78225-0ea3-41b1-8890-28b8d3307be5",
   "metadata": {},
   "source": [
    "## Recomendaciones\n",
    "1. Recomendación 1\n",
    "2. Recomendación 2\n",
    "3. Recomendación 3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5bc7e66a-34f3-4b85-995f-c047a271d059",
   "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": "7949ea36-9354-4e89-b14f-5bdb0800233b",
   "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
}