{
"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",
"## Script Bash para bioinformática.\n",
"* Transcribir ADN a ARN \n",
"* Extraer porcentaje GC de múltiples archivos\n",
" \n",
"**¿Qué esperamos aprender en esta libreta?**\n",
"\n",
"En esta libreta de trabajo, vamos a explorar los siguientes temas:\n",
"\n",
"* Desarrollar scripts en BASH \n",
"* Usar las estructuras de programación en BASH\n",
"* Aplicar buenas prácticas y documentar el script\n",
"\n",
"El programa transcripción.sh es un script en Bash diseñado para transcribir cadenas de ADN a ARN a partir de un archivo en formato FASTA. A continuación, se explica paso a paso su funcionamiento:\n",
"\n",
"\n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "538053a0-2093-4aa9-9bc6-1e3ecca20393",
"metadata": {
"jp-MarkdownHeadingCollapsed": true
},
"source": [
"## Script transcripción.sh\n",
"\n",
"```bash\n",
"#!/bin/bash \n",
"# PROGRAMA: transcripción.sh \n",
"# Objetivo: transcribir las cadenas de ADN en ARN del archivo\n",
"# sproteases_small_dna.fasta\n",
"# Entradas: El usuario de be ingresar el número de cadena que le interese transcribir\n",
"# Salidas: Secuencia resultado de la transcripción\n",
"# Autor: Nombre del autor\n",
"# Fecha: 15/11/2021\n",
"# Licencia: GNU/GPL v3\n",
"\n",
"# Para que el usuario pueda elegir la cadena de ADN a transcribir se le mostrará un\n",
"# menú que contenga todas las líneas descriptivas de las cadenas de ARN.\n",
"\n",
"# Para ello se imprimirán las líneas que inicien por \">\"\n",
"\n",
"archivo=\"sampledata/t-coffee/sproteases_small_dna.fasta\"\n",
"total=`wc -l $archivo|cut -d \" \" -f 1`\n",
"\n",
"cat $archivo |grep \">\" -n\n",
"\n",
"# El comando read permite leer argumentos desde el terminal que son ingresados por el \n",
"# usuario\n",
"\n",
"read -p \"Ingrese el número que corresponda a la cadena que desee transcribir: \" inicio\n",
"\n",
"# Validamos si el número ingresado consta en el listado\n",
"\n",
"valido=`cat $archivo |grep \">\" -n|awk -F\":\" '{ print $1 }'|grep -w $inicio`\n",
"\n",
"if [[ $valido = \"\" ]]; then\n",
"\techo \"El valor ingresado no consta en el listado mostrado\"\n",
"\techo \"Adios\"\n",
"\texit 0\n",
"fi\n",
"\n",
"# Determinamos la línea final de conversión\n",
"final=`cat $archivo |grep \">\" -n|awk -F\":\" '{ print $1 }'|grep -w $inicio -A1|tail -n1`\n",
"final=$(($final -1))\n",
"\n",
"if [[ $final -le $inicio ]]; then\n",
"\tfinal=$total\n",
"fi\n",
"\n",
"echo -e \"inicio: $inicio final: $final\\n\"\n",
"\n",
"# Transcripción\n",
"\n",
"# Impresión del archivo original\n",
"\n",
"echo -e \"Cadena Original\\n\"\n",
"\n",
"for i in `seq $inicio $final`; do\n",
"\t#echo $i\n",
"\tif [[ $i = $inicio ]]; then\n",
"\t\tsed -n $i'p' $archivo\n",
"\telse\n",
"\t\tsed -n $i'p' $archivo|awk '{ print toupper($0)}'\n",
"\tfi\n",
"done\n",
"\n",
"# Impresión del archivo convertido\n",
"\n",
"echo -e \"\\nCadena Convertida a ARN\\n\"\n",
"\n",
"for i in `seq $inicio $final`; do\n",
"\t#echo $i\n",
"\tif [[ $i = $inicio ]]; then\n",
"\t\tsed -n $i'p' $archivo\n",
"\telse\n",
"\t\tsed -n $i'p' $archivo|awk '{ print toupper($0)}'|sed 's/T/a/g;s/A/u/g;s/C/g/g;s/G/c/g'|awk '{ print toupper($0)}'\n",
"\tfi\n",
"done\n",
"\n",
"echo -e \"\\nCadena Convertida a ARN en reversa\\n\"\n",
"sed -n $inicio'p' $archivo\n",
"for i in `seq $inicio $final|sort -nr`; do\n",
"\t#echo $i\n",
"\tif [[ $i = $inicio ]]; then\n",
"\ta=0\n",
"\telse\n",
"\t\tsed -n $i'p' $archivo|awk '{ print toupper($0)}'|sed 's/T/a/g;s/A/u/g;s/C/g/g;s/G/c/g'|awk '{ print toupper($0)}'|rev\n",
"\tfi\n",
"\t\t\n",
"done\n",
"```"
]
},
{
"cell_type": "markdown",
"id": "6db21097-4db6-4d91-ba65-ca12eab6d98f",
"metadata": {},
"source": [
"---\n",
"\n",
"1. **Encabezado y descripción del programa**\n",
"\n",
"* La primera línea muestra el El shebang (también llamado hashbang) que es una línea especial al comienzo de un script en sistemas Unix/Linux que indica al sistema operativo qué intérprete debe usar para ejecutar el script. Se compone de los caracteres #! seguidos de la ruta al intérprete, en este caso `#!/bin/bash`.\n",
"* A continuación, el encabezado describe el propósito de este scritp, entradas, salidas, autor, fecha y licencia. \n",
"* El objetivo principal es transcribir cadenas de ADN a ARN a partir de un archivo llamado sproteases_small_dna.fasta.\n",
"\n",
"```bash\n",
"#!/bin/bash \n",
"# PROGRAMA: transcripción.sh \n",
"# Objetivo: transcribir las cadenas de ADN en ARN del archivo\n",
"# sproteases_small_dna.fasta\n",
"# Entradas: El usuario debe ingresar el número de cadena que le interese transcribir\n",
"# Salidas: Secuencia resultado de la transcripción\n",
"# Autor: Nombre del autor\n",
"# Fecha: 15/11/2021\n",
"# Licencia: GNU/GPL v3\n",
"\n",
"# Para que el usuario pueda elegir la cadena de ADN a transcribir se le mostrará un\n",
"# menú que contenga todas las líneas descriptivas de las cadenas de ARN.\n",
"\n",
"# Para ello se imprimirán las líneas que inicien por \">\"\n",
"```\n",
"\n",
"---\n",
"\n",
"2. Definición del archivo de entrada\n",
"* La variable archivo almacena la ruta del archivo FASTA que contiene las cadenas de ADN.\n",
"* La variable total calcula el número total de líneas en el archivo usando wc -l y cut.\n",
"\n",
"```bash\n",
"archivo=\"sampledata/t-coffee/sproteases_small_dna.fasta\"\n",
"total=`wc -l $archivo|cut -d \" \" -f 1`\n",
"```\n",
"\n",
"---\n",
"\n",
"3. Mostrar un menú de cadenas disponibles\n",
"* El comando cat $archivo | grep \">\" -n muestra todas las líneas del archivo que comienzan con > (que son las cabeceras de las secuencias de ADN) junto con su número de línea.\n",
"* Esto permite al usuario elegir una cadena específica para transcribir.\n",
"\n",
"```bash\n",
"cat $archivo |grep \">\" -n\n",
"```\n",
"---\n",
"\n",
"4. Solicitar al usuario que elija una cadena\n",
"* El comando read -p solicita al usuario que ingrese el número de la cadena que desea transcribir.\n",
"* El número ingresado se almacena en la variable inicio.\n",
"\n",
"```bash\n",
"# El comando read permite leer argumentos desde el terminal que son ingresados por el \n",
"# usuario\n",
"\n",
"read -p \"Ingrese el número que corresponda a la cadena que desee transcribir: \" inicio\n",
"```\n",
"---\n",
"\n",
"5. Validar la entrada del usuario\n",
"* El script verifica si el número ingresado por el usuario corresponde a una cadena válida.\n",
"* Si el número no es válido (es decir, no coincide con ninguna cabecera), el programa muestra un mensaje de error y termina.\n",
"\n",
"```bash\n",
"# Validamos si el número ingresado consta en el listado\n",
"\n",
"valido=`cat $archivo |grep \">\" -n|awk -F\":\" '{ print $1 }'|grep -w $inicio`\n",
"\n",
"if [[ $valido = \"\" ]]; then\n",
"\techo \"El valor ingresado no consta en el listado mostrado\"\n",
"\techo \"Adios\"\n",
"\texit 0\n",
"fi\n",
"\n",
"```\n",
"---\n",
"\n",
"6. Determinar el rango de líneas para la transcripción\n",
"* El script calcula la línea final (final) de la secuencia seleccionada.\n",
"* Si la secuencia seleccionada es la última en el archivo, final se establece como el total de líneas del archivo.\n",
"\n",
"```bash\n",
"# Determinamos la línea final de conversión\n",
"final=`cat $archivo |grep \">\" -n|awk -F\":\" '{ print $1 }'|grep -w $inicio -A1|tail -n1`\n",
"final=$(($final -1))\n",
"\n",
"if [[ $final -le $inicio ]]; then\n",
"\tfinal=$total\n",
"fi\n",
"\n",
"echo -e \"inicio: $inicio final: $final\\n\"\n",
"```\n",
"---\n",
"\n",
"7. Transcripción de ADN a ARN\n",
"* El script imprime primero la cadena original de ADN.\n",
"* Luego, realiza la transcripción a ARN reemplazando las bases nitrogenadas:\n",
" * T (Timina) se reemplaza por A (Adenina en ARN).\n",
" * A (Adenina) se reemplaza por U (Uracilo en ARN).\n",
" * C (Citosina) se reemplaza por G (Guanina en ARN).\n",
" * G (Guanina) se reemplaza por C (Citosina en ARN).\n",
"* La transcripción se realiza utilizando el comando sed para reemplazar las bases y awk para convertir el resultado a mayúsculas.\n",
"\n",
"```bash\n",
"# Transcripción\n",
"\n",
"# Impresión del archivo original\n",
"\n",
"echo -e \"Cadena Original\\n\"\n",
"\n",
"for i in `seq $inicio $final`; do\n",
"\t#echo $i\n",
"\tif [[ $i = $inicio ]]; then\n",
"\t\tsed -n $i'p' $archivo\n",
"\telse\n",
"\t\tsed -n $i'p' $archivo|awk '{ print toupper($0)}'\n",
"\tfi\n",
"done\n",
"```\n",
"---\n",
"\n",
"8. Impresión de la cadena de ARN \n",
"* El script imprime la cadena de ARN transcrita.\n",
"\n",
"```bash\n",
"# Impresión del archivo convertido\n",
"\n",
"echo -e \"\\nCadena Convertida a ARN\\n\"\n",
"\n",
"for i in `seq $inicio $final`; do\n",
"\t#echo $i\n",
"\tif [[ $i = $inicio ]]; then\n",
"\t\tsed -n $i'p' $archivo\n",
"\telse\n",
"\t\tsed -n $i'p' $archivo|awk '{ print toupper($0)}'|sed 's/T/a/g;s/A/u/g;s/C/g/g;s/G/c/g'|awk '{ print toupper($0)}'\n",
"\tfi\n",
"done\n",
"```\n",
"---\n",
"\n",
"9. Impresión de la cadena de ARN en reversa\n",
"* El script también imprime la cadena de ARN en orden inverso utilizando el comando rev.\n",
"\n",
"```bash\n",
"echo -e \"\\nCadena Convertida a ARN en reversa\\n\"\n",
"sed -n $inicio'p' $archivo\n",
"for i in `seq $inicio $final|sort -nr`; do\n",
"\t#echo $i\n",
"\tif [[ $i = $inicio ]]; then\n",
"\ta=0\n",
"\telse\n",
"\t\tsed -n $i'p' $archivo|awk '{ print toupper($0)}'|sed 's/T/a/g;s/A/u/g;s/C/g/g;s/G/c/g'|awk '{ print toupper($0)}'|rev\n",
"\tfi\n",
"\t\t\n",
"done\n",
"\n",
"```\n",
"---\n",
"\n",
"10. Salida del programa\n",
"* El programa muestra tres secciones:\n",
" 1. La cadena original de ADN (7).\n",
" 2. La cadena transcrita a ARN (8).\n",
" 3. La cadena de ARN en orden inverso (9).\n",
"\n",
"---\n",
"\n",
"#### Resumen del flujo del programa:\n",
"1. Muestra un menú de cadenas de ADN disponibles.\n",
"2. Solicita al usuario que elija una cadena.\n",
"3. Valida la entrada del usuario.\n",
"4. Determina el rango de líneas para la transcripción.\n",
"5. Transcribe la cadena de ADN a ARN.\n",
"6. Muestra la cadena original, la cadena transcrita y la cadena transcrita en reversa.\n"
]
},
{
"cell_type": "markdown",
"id": "e8862418-fd66-45a8-85d9-022b14b92b65",
"metadata": {},
"source": [
"La codificación anterior puede ser mejorada incorporando buenas prácticas como:\n",
"\n",
"1. Manejo de errores\n",
"2. Validación de entrada\n",
"3. Optimización del rendimiento\n",
"4. Modularización del código\n",
"5. Presentación de la salida\n",
"6. Flexibilidad\n",
"7. Mejorar la documentación\n",
"\n",
"\n",
"4. Modularización del código:\n",
"* Se dividió el código en funciones (mostrar_error, es_numero_valido, transcribir_adn_a_arn) para mejorar la legibilidad y mantenibilidad.\n",
"\n",
"5. Presentación de la salida:\n",
"* Se mejoró el formato de la salida para que sea más clara y fácil de interpretar.\n",
"* Se agregaron separadores y títulos para cada sección (cadena original, cadena transcrita, cadena en reversa).\n",
"\n",
"6. Flexibilidad:\n",
"* Se permitió que el usuario ingrese el número de la cadena en lugar de solo el nombre.\n",
"* Se agregó soporte para manejar archivos FASTA con múltiples cadenas.\n",
"\n",
"7. Documentación:\n",
"* Se agregaron comentarios detallados para explicar cada parte del código.\n"
]
},
{
"cell_type": "markdown",
"id": "46f4852f-ae26-4c44-bc1d-ccde5892d899",
"metadata": {},
"source": [
"```bash\n",
"#!/bin/bash\n",
"# PROGRAMA: transcripción.sh (versión mejorada)\n",
"# Objetivo: Transcribir cadenas de ADN a ARN a partir de un archivo FASTA.\n",
"# Entradas: El usuario ingresa el número de la cadena que desea transcribir.\n",
"# Salidas: Secuencia de ADN original, secuencia transcrita a ARN y secuencia en reversa.\n",
"# Autor: Nombre del autor\n",
"# Fecha: [Fecha actual]\n",
"# Licencia: GNU/GPL v3\n",
"\n",
"# Función para mostrar un mensaje de error y salir\n",
"```\n",
"---\n",
"* Manejo de errores:\n",
" * Se agrega una función mostrar_error para mostrar mensajes de error y salir del script de manera controlada.\n",
"\n",
"```bash\n",
"function mostrar_error() {\n",
" echo -e \"\\n[ERROR] $1\"\n",
" exit 1\n",
"}\n",
"```\n",
"---\n",
"* Validación de entrada:\n",
" * Se agrega una función es_numero_valido para asegurar que el usuario ingrese un número válido.\n",
"\n",
"```bash\n",
"# Función para validar si un valor es un número entero positivo\n",
"function es_numero_valido() {\n",
" if [[ $1 =~ ^[0-9]+$ ]]; then\n",
" return 0\n",
" else\n",
" return 1\n",
" fi\n",
"}\n",
"```\n",
"---\n",
"* Validación de entrada:\n",
" * Se agrega una función es_numero_valido para asegurar que el usuario ingrese un número válido.\n",
" * Se verificó que el número ingresado corresponda a una cadena existente en el archivo.\n",
"\n",
"```bash\n",
"# Ruta del archivo FASTA (puede cambiarse o pasarse como argumento)\n",
"archivo=\"/usr/local/bioinf/sampledata/t-coffee/sproteases_small_dna.fasta\"\n",
"```\n",
"---\n",
"* Manejo de errores:\n",
" * Se verifica que el archivo FASTA exista y contenga cadenas válidas.\n",
"\n",
"```bash\n",
"\n",
"# Verificar si el archivo existe\n",
"if [[ ! -f $archivo ]]; then\n",
" mostrar_error \"El archivo '$archivo' no existe.\"\n",
"fi\n",
"\n",
"# Mostrar las cadenas disponibles\n",
"echo -e \"\\nCadenas de ADN disponibles:\\n\"\n",
"grep \">\" -n $archivo || mostrar_error \"El archivo no contiene cadenas de ADN válidas.\"\n",
"\n",
"# Solicitar al usuario que elija una cadena\n",
"read -p \"Ingrese el número de la cadena que desea transcribir: \" inicio\n",
"\n",
"# Validar la entrada del usuario\n",
"if ! es_numero_valido $inicio; then\n",
" mostrar_error \"Debe ingresar un número válido.\"\n",
"fi\n",
"```\n",
"---\n",
"2. Validación de entrada:\n",
"* Se verifica que el número ingresado corresponda a una cadena existente en el archivo.\n",
"\n",
"```bash\n",
"---\n",
"# Verificar si el número ingresado corresponde a una cadena válida\n",
"valido=$(grep \">\" -n $archivo | awk -F\":\" '{ print $1 }' | grep -w $inicio)\n",
"if [[ -z $valido ]]; then\n",
" mostrar_error \"El número ingresado no corresponde a una cadena válida.\"\n",
"fi\n",
"\n",
"# Determinar la línea final de la secuencia\n",
"final=$(grep \">\" -n $archivo | awk -F\":\" '{ print $1 }' | grep -w $inicio -A1 | tail -n1)\n",
"final=$((final - 1))\n",
"\n",
"# Si no hay más cadenas, usar el final del archivo\n",
"if [[ $final -le $inicio ]]; then\n",
" final=$(wc -l < $archivo)\n",
"fi\n",
"\n",
"# Mostrar el rango de líneas a procesar\n",
"echo -e \"\\nProcesando desde la línea $inicio hasta la línea $final...\\n\"\n",
"\n",
"# Función para transcribir ADN a ARN\n",
"function transcribir_adn_a_arn() {\n",
" echo \"$1\" | sed 's/T/a/g; s/A/u/g; s/C/g/g; s/G/c/g' | awk '{ print toupper($0) }'\n",
"}\n",
"```\n",
"---\n",
"* Presentación de la salida:\n",
" * Se mejora el formato de la salida para que sea más clara y fácil de interpretar.\n",
" * Se agregan separadores y títulos para cada sección (cadena original, cadena transcrita, cadena en reversa).\n",
"```bash\n",
"---\n",
"# Mostrar la cadena original y transcribir a ARN\n",
"echo -e \"=== Cadena Original ===\\n\"\n",
"for i in $(seq $inicio $final); do\n",
" if [[ $i -eq $inicio ]]; then\n",
" sed -n ${i}p $archivo # Mostrar la cabecera\n",
" else\n",
" linea=$(sed -n ${i}p $archivo | awk '{ print toupper($0) }')\n",
" echo \"$linea\"\n",
" fi\n",
"done\n",
"\n",
"echo -e \"\\n=== Cadena Transcrita a ARN ===\\n\"\n",
"for i in $(seq $inicio $final); do\n",
" if [[ $i -eq $inicio ]]; then\n",
" sed -n ${i}p $archivo # Mostrar la cabecera\n",
" else\n",
" linea=$(sed -n ${i}p $archivo | awk '{ print toupper($0) }')\n",
" transcribir_adn_a_arn \"$linea\"\n",
" fi\n",
"done\n",
"\n",
"# Mostrar la cadena de ARN en reversa\n",
"echo -e \"\\n=== Cadena de ARN en Reversa ===\\n\"\n",
"sed -n ${inicio}p $archivo # Mostrar la cabecera\n",
"for i in $(seq $final -1 $inicio); do\n",
" if [[ $i -ne $inicio ]]; then\n",
" linea=$(sed -n ${i}p $archivo | awk '{ print toupper($0) }')\n",
" transcribir_adn_a_arn \"$linea\" | rev\n",
" fi\n",
"done\n",
"\n",
"echo -e \"\\nProceso completado.\\n\"\n",
"```"
]
},
{
"cell_type": "markdown",
"id": "57521e3a-897a-42b9-988c-70ccb09c8cf8",
"metadata": {},
"source": [
"### Ejecutar el Script `transcripcion.sh`\n",
"\n",
"Para ejecutar el script descarguelo desde laplataforma o desde este enlace: https://www.seracademia.com/academia/Bio_Info/M4/transcripcion.sh . Recuerde que puede hacer el uso de wget como herramienta para descargarlo."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "2e0884d1-e341-4f39-baec-f549c7d379d5",
"metadata": {},
"outputs": [],
"source": [
"wget https://www.seracademia.com/academia/Bio_Info/M4/transcripcion.sh"
]
},
{
"cell_type": "markdown",
"id": "d397f7ce-54e1-4f65-abe2-017e1e366700",
"metadata": {},
"source": [
"Una vez descargado puede listarlo con el comando `ls`:"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "6a73d390-8983-4ff1-85bd-2e2260b6607c",
"metadata": {},
"outputs": [],
"source": [
"ls -l transcripcion.sh"
]
},
{
"cell_type": "markdown",
"id": "00083976-9d2e-41b1-9691-1db20f8f2751",
"metadata": {},
"source": [
"En este caso podemos observar la información que nos proporciona este comando:\n",
"\n",
"---\n",
" Interpretación de la línea `-rw-r--r-- 1 jupyter jupyter 2257 ene 23 05:51 transcripcion.sh`\n",
"\n",
" 1. **Tipo de archivo y permisos (`-rw-r--r--`)**\n",
"- **Tipo de archivo**:\n",
" - `-`: Archivo regular.\n",
" - `d`: Directorio.\n",
" - `l`: Enlace simbólico (symlink).\n",
"\n",
" En este caso se trata de un archivo regular ya que este caracter tiene el valor `-`\n",
"\n",
"- **Permisos**:\n",
" - **Propietario (`rw-`)**:\n",
" - `r`: Permiso de lectura.\n",
" - `w`: Permiso de escritura.\n",
" - `-`: Sin permiso de ejecución.\n",
" - **Grupo (`r--`)**:\n",
" - `r`: Permiso de lectura.\n",
" - `-`: Sin permisos de escritura ni ejecución.\n",
" - **Otros (`r--`)**:\n",
" - `r`: Permiso de lectura.\n",
" - `-`: Sin permisos de escritura ni ejecución.\n",
"\n",
" 2. **Número de enlaces (`1`)**\n",
"- Indica cuántos enlaces duros (hard links) apuntan al archivo.\n",
"- `1`: Solo hay un enlace al archivo.\n",
"\n",
"3. **Propietario y grupo (`jupyter jupyter`)**\n",
"- **Propietario**: `jupyter`.\n",
"- **Grupo**: `jupyter`.\n",
"\n",
"4. **Tamaño del archivo (`2257`)**\n",
"- Tamaño del archivo en **bytes**.\n",
"- `2257 bytes` ≈ 2.2 KB.\n",
"\n",
"5. **Fecha y hora de la última modificación (`ene 23 05:51`)**\n",
"- Fecha y hora de la última modificación.\n",
"- **23 de enero a las 05:51**.\n",
"6. **Nombre del archivo (`transcripcion.sh`)** \n",
"- El nombre del archivo es el último elemento en la salida de `ls -l`, en este caso `transcripcion.sh`.\n",
"\n",
"---\n",
"\n",
"| Campo | Valor | Descripción |\n",
"|---------------------|---------------------|-----------------------------------------------------------------------------|\n",
"| **Tipo de archivo** | `-` | Archivo regular. |\n",
"| **Permisos** | `rw-r--r--` | Propietario: lectura y escritura. Grupo y otros: solo lectura. |\n",
"| **Enlaces** | `1` | Número de enlaces duros al archivo. |\n",
"| **Propietario** | `jupyter` | Usuario propietario del archivo. |\n",
"| **Grupo** | `jupyter` | Grupo al que pertenece el archivo. |\n",
"| **Tamaño** | `2257 bytes` | Tamaño del archivo en bytes. |\n",
"| **Última modificación** | `ene 23 05:51` | Fecha y hora de la última modificación. |\n",
"| **Nombre del archivo** | `transcripcion.sh` | Nombre del archivo. |\n",
"\n",
"---\n"
]
},
{
"cell_type": "markdown",
"id": "53b687ec-39f3-463b-b77b-58c006363f87",
"metadata": {},
"source": [
"### **Cambiar los permisos para hacer el script ejecutable**\n",
"\n",
"En GNU/Linux el permiso de los archivos determinan tanto el acceso que se tiene a ellos como la capacidad de ejecutarse, por tanto para hacer el script ejecutable, se debe agregar el permiso de ejecución (x), lo cual se puede realizar de varias maneras:\n",
"\n",
"\n",
" - **Agregar permiso de ejecución solo para el propietario:**\n",
"\n",
" ```bash\n",
" chmod u+x transcripcion.sh\n",
" ```\n",
"\n",
" Esto agrega el permiso de ejecución (`x`) al propietario (`u`).\n",
"\n",
" - **Agregar permiso de ejecución para todos los usuarios:**\n",
"\n",
" ```bash\n",
" chmod +x transcripcion.sh\n",
" ```\n",
"\n",
" Esto agrega el permiso de ejecución (`x`) para todos los usuarios (propietario, grupo y otros).\n",
"\n",
" - **Especificar permisos numéricamente:**\n",
"\n",
" También se puede usar la notación numérica para cambiar los permisos de un archivo, para ello se usa como base el sistema de numeración octal y su equivalencia en binario, donde cada dígito corresponde a la presencia o no de un permiso en el orden rwx, donde `000` es ningún permiso y `111` es todos los permisos para los actores.\n",
"\n",
"En octal se asignan los permisos para cada actor, usuario, grupo y otros, mientras que la ubicación identifica al actor que se le asigna los permisos. Así en detalle:\n",
"\n",
"---\n",
"\n",
"**Tabla de permisos en notación octal**\n",
"\n",
"| Octal | Binario | Permisos | Descripción |\n",
"|-------|----------|--------------------|-----------------------------------------------------------------------------|\n",
"| `0` | `000` | `---` | Sin permisos (ni lectura, ni escritura, ni ejecución). |\n",
"| `1` | `001` | `--x` | Solo permiso de ejecución. |\n",
"| `2` | `010` | `-w-` | Solo permiso de escritura. |\n",
"| `3` | `011` | `-wx` | Escritura y ejecución. |\n",
"| `4` | `100` | `r--` | Solo permiso de lectura. |\n",
"| `5` | `101` | `r-x` | Lectura y ejecución. |\n",
"| `6` | `110` | `rw-` | Lectura y escritura. |\n",
"| `7` | `111` | `rwx` | Lectura, escritura y ejecución. |\n",
"\n",
"---\n",
"\n",
"**Permiso de actores en notación octal**\n",
"\n",
"| Permisos (Octal) | Permisos (Simbólico) | Descripción |\n",
"|------------------|----------------------|-----------------------------------------------------------------------------|\n",
"| `644` | `rw-r--r--` | Propietario: lectura y escritura. Grupo y otros: solo lectura. |\n",
"| `755` | `rwxr-xr-x` | Propietario: lectura, escritura y ejecución. Grupo y otros: lectura y ejecución. |\n",
"| `600` | `rw-------` | Propietario: lectura y escritura. Grupo y otros: sin permisos. |\n",
"| `777` | `rwxrwxrwx` | Todos (propietario, grupo y otros): lectura, escritura y ejecución. |\n",
"| `400` | `r--------` | Propietario: solo lectura. Grupo y otros: sin permisos. |\n",
"\n",
"---\n",
"\n",
"**Explicación de la notación octal**\n",
"- La notación octal usa **tres dígitos** para representar los permisos:\n",
" 1. **Primer dígito**: Permisos del **propietario**.\n",
" 2. **Segundo dígito**: Permisos del **grupo**.\n",
" 3. **Tercer dígito**: Permisos para **otros usuarios**.\n",
"\n",
"- Cada dígito es la suma de los valores de los permisos:\n",
" - `4`: Lectura (`r`).\n",
" - `2`: Escritura (`w`).\n",
" - `1`: Ejecución (`x`).\n",
"\n",
"Por ejemplo:\n",
"- `rwxr-xr--` se traduce a:\n",
" - Propietario: `rwx` = `4 + 2 + 1` = `7`.\n",
" - Grupo: `r-x` = `4 + 0 + 1` = `5`.\n",
" - Otros: `r--` = `4 + 0 + 0` = `4`.\n",
" - Por lo tanto, el permiso en octal es `754`.\n",
"\n",
"---\n",
"\n",
"\n",
"\n",
" Así por ejemplo, para dar permisos de lectura, escritura y ejecución al propietario, y solo lectura y ejecución a los demás, se puede usar:\n",
"\n",
" ```bash\n",
" chmod 755 mi_script.sh\n",
" ```\n",
"\n",
" Aquí, `755` significa:\n",
" - `7` (propietario): lectura (`4`), escritura (`2`) y ejecución (`1`).\n",
" - `5` (grupo y otros): lectura (`4`) y ejecución (`1`).\n",
"\n",
"**Verificación de permisos**\n",
" Después de cambiar los permisos, se puede verificar nuevamente con `ls -l`:\n",
"\n",
" ```bash\n",
" ls -l transcripcion.sh\n",
" ```\n",
"\n",
" Si se usó `chmod +x`, se debería ver algo como:\n",
"\n",
" ```\n",
" -rwxr-xr-x 1 usuario grupo 123 Oct 1 12:34 mi_script.sh\n",
" ```\n",
"\n",
" Esto indica que el archivo ahora es ejecutable.\n",
"\n",
"**Ejecución del script**\n",
" Ahora que el script es ejecutable, puede ser ejecutado directamente desde la terminal anteponiendo `./` que se utiliza para indicar la ruta relativa al directorio actual, por ejemplo en nuestro caso:\n",
"\n",
" ```bash\n",
" ./transcripcion.sh\n",
" ```\n",
"\n",
"### Resumen\n",
"- Usa `chmod u+x` para hacer el script ejecutable solo para el propietario.\n",
"- Usa `chmod +x` para hacer el script ejecutable para todos los usuarios.\n",
"- Usa `chmod 755` para dar permisos de lectura, escritura y ejecución al propietario, y lectura y ejecución a los demás.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "ed042d19-f81a-4ee4-a4a7-7011f8349c3b",
"metadata": {},
"outputs": [],
"source": [
"chmod u+x transcripcion.sh"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "706f1692-c909-4c64-9121-6407e111b97d",
"metadata": {},
"outputs": [],
"source": [
"ls -l transcripcion.sh"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "9e52f75b-dc81-455e-94ad-eeeac2df8d0c",
"metadata": {},
"outputs": [],
"source": [
"chmod +x transcripcion.sh"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "3d2ca15a-beb5-43f0-9918-e7768f5faf2c",
"metadata": {},
"outputs": [],
"source": [
"ls -l transcripcion.sh"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "792f5cd6-2fa2-4997-b827-d15b04b8af79",
"metadata": {},
"outputs": [],
"source": [
"chmod 754 transcripcion.sh"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "268246b5-885c-4914-a031-9631d38de883",
"metadata": {},
"outputs": [],
"source": [
"ls -l transcripcion.sh"
]
},
{
"cell_type": "markdown",
"id": "4bdbae2a-8e54-48d8-8041-668ae3af7008",
"metadata": {},
"source": [
"**Interpretación biológica**\n",
"- **`sed`:** Convierte las secuencias simulando la transcripción de ADN a ARN, sin considerar si la secuencia es 5'-3' o 3'-5'.\n",
"\n",
"El resultado final es una versión \"ARN\" simulada desde la cadena inicial, aunque las transformaciones no necesariamente reflejan una lógica biológica precisa debido a la doble sustitución, sin embargo refleja el trabajo de BASH con flujos de texto, en este caso secuencias.\n",
"\n",
"\n",
"Como ejercicio:\n",
"1. Transcriba el script mejorado a un archivo de texto plano llamado transcripcion1.sh.\n",
"2. Dele permisos de ejecución.\n",
"4. Ejecútelo.\n",
"5. Compare su comportamiento respecto al original. "
]
},
{
"cell_type": "markdown",
"id": "c1683388-22ac-4641-8582-93d39b0ae2d9",
"metadata": {},
"source": [
"---\n",
"\n",
"## Script para el cálculo masivo de GC en una carpeta de archivos\n",
"\n",
"### find y stderr como herramientas para BASH scripting\n",
"\n",
"**`find:`** \n",
"Comando en sistemas Unix/Linux que permite **buscar archivos y directorios** en una jerarquía de directorios basándose en criterios específicos, como nombre, tipo, tamaño, fecha de modificación o permisos. Es una herramienta poderosa y flexible que admite la ejecución de acciones sobre los resultados encontrados (por ejemplo, eliminar, mover o ejecutar comandos). Su sintaxis básica es:\n",
"\n",
"```bash\n",
"find [ruta] [criterios] [acción]\n",
"```\n",
"\n",
"- **Ejemplo de uso:** \n",
" ```bash\n",
" find /home/user -name \"*.txt\" -type f\n",
" ```\n",
" Busca todos los archivos (no directorios) con extensión `.txt` en `/home/user`.\n",
"\n",
"**Características clave:**\n",
"- Búsqueda recursiva en subdirectorios.\n",
"- Filtrado avanzado con expresiones lógicas (`-and`, `-or`, `-not`).\n",
"- Ejecución de comandos sobre los resultados (`-exec`).\n",
"- Soporte para expresiones regulares y búsquedas por tamaño, fecha, permisos, etc.\n",
"\n",
"Es una herramienta esencial para administración de sistemas y automatización de tareas.\n",
"\n",
"\n",
"---\n",
"\n",
"El manejo de **stderr (Standard Error)** es fundamental en Bash para controlar los mensajes de error generados por comandos o scripts. \n",
"\n",
"A continuación se describe una guía sobre cómo manejarlo en todos los casos posibles:\n",
"\n",
"**1. `stderr`**\n",
"\n",
"- **stderr** es un flujo de salida (file descriptor `2`) dedicado a mensajes de error.\n",
"- A diferencia de **stdout (Standard Output, file descriptor `1`)**, que muestra la salida normal de un comando, **stderr** se usa para errores, advertencias o información de depuración.\n",
"- Por defecto, **stderr** se muestra en la terminal, pero puede redirigirse o suprimirse.\n",
"\n",
"**2. Redirección de stderr**\n",
"\n",
"**a. Redirigir stderr a un archivo**\n",
"Guarda los errores en un archivo específico:\n",
"```bash\n",
"comando 2> errores.txt\n",
"```\n",
"- Ejemplo:\n",
" ```bash\n",
" ls /noexiste 2> errores.txt\n",
" ```\n",
" Si el directorio no existe, el error se guarda en `errores.txt`.\n",
"\n",
"**b. Redirigir stderr a stdout**\n",
"Combina stderr y stdout en un solo flujo:\n",
"```bash\n",
"comando 2>&1\n",
"```\n",
"- Ejemplo:\n",
" ```bash\n",
" ls /noexiste > salida.txt 2>&1\n",
" ```\n",
" Guarda tanto la salida normal como los errores en `salida.txt`.\n",
"\n",
"**c. Redirigir stderr a /dev/null**\n",
"Suprime los errores (ignóralos):\n",
"```bash\n",
"comando 2>/dev/null\n",
"```\n",
"- Ejemplo:\n",
" ```bash\n",
" grep \"algo\" archivo.txt 2>/dev/null\n",
" ```\n",
" Si `archivo.txt` no existe, no se muestra ningún error.\n",
"\n",
"\n",
"**3. Redirección de stderr y stdout juntos**\n",
"\n",
"**a. Redirigir ambos a un archivo**\n",
"```bash\n",
"comando > salida.txt 2>&1\n",
"```\n",
"- Ejemplo:\n",
" ```bash\n",
" ls /noexiste > salida.txt 2>&1\n",
" ```\n",
" Guarda stdout y stderr en `salida.txt`.\n",
"\n",
"**b. Redirigir stdout a un archivo y stderr a otro**\n",
"```bash\n",
"comando > salida.txt 2> errores.txt\n",
"```\n",
"- Ejemplo:\n",
" ```bash\n",
" ls /noexiste > salida.txt 2> errores.txt\n",
" ```\n",
" Guarda la salida normal en `salida.txt` y los errores en `errores.txt`.\n",
"\n",
"\n",
"**4. Manejo de stderr en tuberías (pipes)**\n",
"\n",
"**a. Redirigir stderr en tuberías**\n",
"```bash\n",
"comando1 2> errores.txt | comando2\n",
"```\n",
"- Ejemplo:\n",
" ```bash\n",
" ls /noexiste 2> errores.txt | grep \"algo\"\n",
" ```\n",
" Los errores de `ls` se guardan en `errores.txt`, y solo la salida válida pasa al `grep`.\n",
"\n",
"**b. Redirigir stderr y stdout en tuberías**\n",
"```bash\n",
"comando1 2>&1 | comando2\n",
"```\n",
"- Ejemplo:\n",
" ```bash\n",
" ls /noexiste 2>&1 | grep \"algo\"\n",
" ```\n",
" Combina stderr y stdout, y ambos se pasan al `grep`.\n",
"\n",
"\n",
"**5. Manejo de stderr en scripts**\n",
"\n",
"**a. Capturar stderr en una variable**\n",
"```bash\n",
"error=$(comando 2>&1 >/dev/null)\n",
"```\n",
"- Ejemplo:\n",
" ```bash\n",
" error=$(ls /noexiste 2>&1 >/dev/null)\n",
" echo \"Error: $error\"\n",
" ```\n",
" Captura el mensaje de error en la variable `error`.\n",
"\n",
"**b. Validar si un comando falló**\n",
"Usa el código de salida (`$?`):\n",
"```bash\n",
"comando 2>/dev/null\n",
"if [ $? -ne 0 ]; then\n",
" echo \"El comando falló\"\n",
"fi\n",
"```\n",
"- Ejemplo:\n",
" ```bash\n",
" grep \"algo\" archivo.txt 2>/dev/null\n",
" if [ $? -ne 0 ]; then\n",
" echo \"Error: No se encontró 'algo'\"\n",
" fi\n",
" ```\n",
"\n",
"**6. Casos avanzados**\n",
"\n",
"**a. Redirigir stderr a un comando**\n",
"```bash\n",
"comando 2> >(comando2)\n",
"```\n",
"- Ejemplo:\n",
" ```bash\n",
" ls /noexiste 2> >(grep \"No existe\")\n",
" ```\n",
" Redirige stderr a `grep` para filtrar el mensaje de error.\n",
"\n",
"**b. Redirigir stderr a un archivo temporal**\n",
"```bash\n",
"comando 2> >(tee errores.txt >&2)\n",
"```\n",
"- Ejemplo:\n",
" ```bash\n",
" ls /noexiste 2> >(tee errores.txt >&2)\n",
" ```\n",
" Muestra el error en la terminal y lo guarda en `errores.txt`.\n",
"\n",
"\n",
"**7. Resumen de redirecciones comunes**\n",
"\n",
"| Comando | Descripción |\n",
"|-----------------------------|--------------------------------------------------|\n",
"| `comando 2> archivo` | Guarda stderr en `archivo`. |\n",
"| `comando 2>/dev/null` | Suprime stderr. |\n",
"| `comando 2>&1` | Redirige stderr a stdout. |\n",
"| `comando > archivo 2>&1` | Guarda stdout y stderr en `archivo`. |\n",
"| `comando 2> >(comando2)` | Redirige stderr a otro comando. |\n",
"| `error=$(comando 2>&1)` | Captura stderr en una variable. |\n",
"\n",
"---\n",
"\n",
"## Desarrollo del script\n",
"\n",
"**Funcionamiento del script:**\n",
"\n",
"1. **Búsqueda de archivos:**\n",
" ```bash\n",
" find sampledata/t-coffee/ -name \"*.fasta\" | while read -r file; do\n",
" ```\n",
" - Busca recursivamente todos los archivos `.fasta` en el directorio `sampledata/t-coffee/`\n",
" - Procesa cada archivo en un bucle `while`\n",
"\n",
"2. **Validación de secuencias de ADN/ARN:**\n",
" ```bash\n",
" if grep -v '^>' \"$file\" 2>/dev/null | grep -q -E '[^ATUGCatugcN]'\n",
" ```\n",
" - Ignora líneas de cabecera (las que empiezan con `>`)\n",
" - Desecha el error stándar del primer gep\n",
" - Verifica que solo contenga caracteres nucleotídicos válidos (A, T/U, G, C, en mayúsculas/minúsculas, y N para ambigüedades)\n",
"\n",
"3. **Procesamiento de secuencias:**\n",
" ```bash\n",
" sequence=$(grep -v '^>' \"$file\" | tr -d '\\n' | tr 'atugc' 'ATUGC')\n",
" ```\n",
" - Concatena todas las líneas de secuencia en una sola cadena\n",
" - Elimina saltos de línea (`\\n`)\n",
" - Estandariza a mayúsculas (transforma `a t u g c` a `A T U G C`)\n",
"\n",
"4. **Cálculo del porcentaje GC:**\n",
" ```bash\n",
" total=${#sequence} # Longitud total de la secuencia\n",
" gc=$(echo -n \"$sequence\" | tr -dc 'GC' | wc -c) # Cuenta solo G y C\n",
" porcentaje=$(echo \"scale=2; ($gc * 100)/$total\" | bc)\n",
" ```\n",
" - Usa expansión de variables para obtener la longitud total\n",
" - Filtra solo caracteres G/C y cuenta con `wc -c`\n",
" - Calcula el porcentaje con precisión de 2 decimales usando `bc`\n",
"\n",
"5. **Manejo de casos especiales:**\n",
" - Detecta archivos vacíos o sin secuencias (`if [ -n \"$sequence\" ]`)\n",
" - Salta archivos con caracteres inválidos (`continue`)\n",
" - Muestra mensajes de error descriptivos\n",
"\n",
"**Características clave:**\n",
"- Compatible con ADN y ARN (reconoce T y U)\n",
"- Ignora cabeceras y espacios en blanco\n",
"- Eficiente en memoria (procesa archivos grandes)\n",
"- Salida clara con separadores visuales (`-------------------------`)\n",
"- Funciona en cualquier sistema con Bash estándar\n",
"\n",
"**Ejemplo de salida:**\n",
"\n",
"```\n",
"Analizando: sampledata/t-coffee/virus.fasta\n",
"Porcentaje GC: 42.15%\n",
"-------------------------\n",
"Analizando: sampledata/t-coffee/bacteria.fasta\n",
"Error: El archivo contiene caracteres no válidos para DNA\n",
"-------------------------\n",
"```"
]
},
{
"cell_type": "markdown",
"id": "483c7dbc-d3b1-411b-b5e0-78cffe6d0681",
"metadata": {},
"source": [
"Ejecute el siguiente script y valide su funcionamiento"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "b35f529a-89c5-490f-b9e5-7aa9b8788956",
"metadata": {},
"outputs": [],
"source": [
"#!/bin/bash\n",
"\n",
"find sampledata/t-coffee/ -name \"*.fasta\" | while read -r file; do\n",
" echo \"Analizando: $file\"\n",
" \n",
" if grep -v '^>' \"$file\" 2>/dev/null | grep -q -E '[^ATUGCatugcN]'; then\n",
" echo \"Error: El archivo $file contiene caracteres no válidos para DNA\"\n",
" continue\n",
" fi\n",
"\n",
" total=0\n",
" gc=0\n",
" \n",
" # Capturar toda la secuencia en una variable (sin cabeceras ni saltos)\n",
" sequence=$(grep -v '^>' \"$file\" | tr -d '\\n' | tr 'atugc' 'ATUGC')\n",
" # Contar solo si hay secuencia\n",
" if [ -n \"$sequence\" ]; then\n",
" total=${#sequence}\n",
" gc=$(echo -n \"$sequence\" | tr -dc 'GC' | wc -c)\n",
" porcentaje=$(echo \"scale=2; ($gc * 100)/$total\" | bc)\n",
" echo \"Porcentaje GC: $porcentaje%\"\n",
" else\n",
" echo \"Archivo vacío o sin secuencias válidas\"\n",
" fi\n",
" \n",
" echo \"-------------------------\"\n",
"done"
]
},
{
"cell_type": "markdown",
"id": "83967b31-88d6-4f60-b2fc-e7e6b599b11c",
"metadata": {},
"source": [
"### Resumen\n",
"\n",
"En esta práctica hemos realizado un ejercicio ilustrativo de conversión de ADN a ARNm, usando las estructuras de programación en BASH. con el uso de buenas prácticas y documentando el script"
]
},
{
"cell_type": "markdown",
"id": "16eb7afe-725e-41b2-bfeb-8949113102b6",
"metadata": {},
"source": [
"## Tarea \n",
"\n",
"### 1. Práctica\n",
"Modifique el script transcripcion.sh de manera que acepte el ingreso de la ruta de cualquier archivo de ADN tipo fasta y lo transcriba a ARNm\n",
"* Nombre del script: ApellidoNombre_ScriptBASH.sh\n",
"* Suba el script a la plataforma"
]
},
{
"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 se crea un script en Linux?"
]
},
{
"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. ¿Qué extensión debe tener un script en Linux (por ejemplo, .exe)?"
]
},
{
"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. ¿Qué es un \"shebang\" (#!) y por qué es importante en un script?"
]
},
{
"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
}