{
"cells": [
{
"cell_type": "markdown",
"id": "b9a7e53f-8aa7-453b-9ae8-06c00f936531",
"metadata": {
"jp-MarkdownHeadingCollapsed": true
},
"source": [
"# Pontificia Universidad Católica del Ecuador\n",
"## Maestría Virtual en Biología Computacional\n",
"### Programación para las ciencias biológicas\n",
"#### Instalación de paquetes en BASH y Definición de variables\n",
"Charles Escobar\n",
"2024\n",
"\n",
"**Nombre del estudiante:** "
]
},
{
"cell_type": "markdown",
"id": "5d9de106-3513-4265-ad6d-50b94bea1078",
"metadata": {},
"source": [
"# Instalación de paquetes en Debian(R) y derivados\n",
"\n",
"## Instalación de paquetes con APT \n",
"En las distribuciones Debian y derivadas, los paquetes pueden ser instalados con el administrador de paquetes `apt` o de ser el caso **compilándolo** desde las fuentes.\n",
"\n",
"\n",
"El administrador de paquetes `apt`, es un utilitario que gestiona los archivos binarios de software compilado y sus dependencias. Hay diferentes administradores de paquetes disponibles para cada distribución de este sistema operativo, como por ejemplo:\n",
"\n",
"1. `apt` (Advanced Package Tool) para sistemas basados en Debian (Ubuntu, Kali Linux, etc.)\n",
"2. `yum` (Yellowdog Updater, Modified) para sistemas basados en Red Hat (CentOS, Fedora, RHEL, etc.)\n",
"3. `dnf` (Dandified Yum) que es una actualización de `yum` con mejoras en performance y funcionalidades\n",
"4. `pacman` para Arch Linux\n",
"5. `apk` para Alpine Linux\n",
"\n",
"El proceso de instalación de paquetes con estos administradores de paquetes generalmente sigue un proceso similar:\n",
"\n",
"1. Abrir una terminal y acceder a la cuenta de usuario con privilegios de root o sudo.\n",
"2. Actualizar el índice de paquetes (por ejemplo, `apt update`)\n",
"3. Buscar el paquete deseado utilizando el administrador de paquetes (por ejemplo, `apt-cache search nombre_paquete`).\n",
"4. Instalar el paquete utilizando el comando específico del administrador de paquetes (por ejemplo, `sudo apt install cowsay`).\n",
"5. Verificar que el paquete se ha instalado correctamente y que está disponible en la carpeta binaria predeterminada (usualmente `/usr/bin` o `/usr/local/bin`).\n"
]
},
{
"cell_type": "markdown",
"id": "a95b53e2-18c6-443e-abd3-ca008e68e162",
"metadata": {},
"source": [
"Como ejemplo vamos a instalar el paquete `cowsay` con el que imprimiremos el tradicional mensaje \"Hola mundo!!\""
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "bf323844-87c4-4884-89b3-6c69f8cf3bef",
"metadata": {},
"outputs": [],
"source": [
"apt-cache search cowsay"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "ba4b9665-1c42-43c4-b1f2-5676c03b11e7",
"metadata": {
"scrolled": true
},
"outputs": [],
"source": [
"cowsay \"hola mundo!!\""
]
},
{
"cell_type": "markdown",
"id": "b0764d63-2080-4d07-8f93-10384827e9db",
"metadata": {},
"source": [
"como podemos ver, inicialmente `cowsay` no se encuentra instalado, por lo que lo haremos a través del terminal, esto debido a que desde `jupyter` no podemos interactuar con el terminal de shell cuando nos pide la contraseña de administrador.\n",
"\n",
"En el terminal ejecute:\n",
"\n",
"```bash\n",
"sudo apt install cowsay\n",
"```\n",
"\n",
"Una vez que lo instalemos lo podemos probar y ver dónde se instaló con el comando `which`\n",
"\n",
"El comando `which` es un utilitario de línea de comandos (CLI) en GNU/Linux que muestra la ubicación del archivo ejecutable que se asocia a un determinado nombre de comando. Es útil cuando un usuario está utilizando una versión personalizada o alternativa de un comando y desea encontrar su ubicación para modificarlo o eliminarlo.\n",
"\n",
"Por ejemplo, si se ejecuta el comando `which ls`, muestra la ruta del archivo binario de `ls` en el sistema operativo:\n",
"\n",
"```bash\n",
"/bin/ls\n",
"```\n",
"En algunos sistemas operativos puede no encontrar ninguna ubicación, ya que el comando no se encuentra en la carpeta binaria por defecto del sistema. \n",
"En estos casos, es posible utilizar otros comandos como `type` o `command`, que funcionan de manera similar pero también pueden mostrar información sobre las funciones definidas en el shell.\n",
"\n",
"El comando `which` puede ser útil para encontrar errores de rutas de archivos en scripts, ya que permite verificar si el archivo binario se encuentra en la ubicación esperada. También puede ser usado para buscar comandos no estándares que puedan estar instalados como paquetes adicionales."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "0b47a161-65ba-4b76-9224-adf3bc731f91",
"metadata": {},
"outputs": [],
"source": [
"cowsay \"hola mundo\""
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "0f2698d6-32e3-46e9-9cca-27dfeed2a445",
"metadata": {},
"outputs": [],
"source": [
"which cowsay"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "1596d491-4549-473e-83e6-e043106f59b8",
"metadata": {},
"outputs": [],
"source": [
"/usr/games/cowsay \"hola mundo\""
]
},
{
"cell_type": "markdown",
"id": "f77a1f8d-4a66-42dc-9856-00f9747fbff8",
"metadata": {},
"source": [
"### Librería Biopython\n",
"\n",
"Biopython es una colección de bibliotecas de código abierto escritas en Python utilizadas para realizar análisis bioinformáticos, desde la manipulación de datos genéticos y secuencias de ADN hasta el modelado de proteínas y simulaciones de evolución. BioPython se utiliza ampliamente por investigadores que trabajan con datos genéticos y buscan una solución eficiente, fácil de usar y altamente portátil.\n",
"\n",
"A continuación instalaremos la biblioteca `Biopython` que es escrita en Python y mantenida por la comunidad. Esta librería se usará mas adelante en el curso como herramienta para el análisis y manipulación de datos genéticos y bioinformáticos. Biopython proporciona una variedad de utilidades para manipular archivos genéticos comunes (como FASTA, GenBank, SwissProt), así como herramientas para análisis secuencias de ADN, RNA y proteínas, análisis estructural, visualización gráfica y más. También incluye funciones para procesar datos de experimentación, integrar datos externos (como los proporcionados por la base de datos NCBI) y realizar análisis estadísticos y bioinformáticos avanzados.\n",
"\n",
"En el terminal ejecute:\n",
"\n",
"```bash\n",
"sudo apt install python3-biopython\n",
"```"
]
},
{
"cell_type": "markdown",
"id": "73cfc533-91a3-4ac9-bc77-0ecb111558a9",
"metadata": {},
"source": [
"Luego de instalar este paquete desde el terminal y para verificar que se ha instalado se puede usar `apt show packagename`, la cual es una orden utilizada de APT (Advanced Package Tool) en Ubuntu, Debian y otras distribuciones Linux basadas en Debian para mostrar detalles sobre un paquete específico. Cuando se ejecuta `apt show packagename`, el sistema muestra información como:\n",
"- Información de estado del paquete (si está instalado, actualizado o pendiente de actualización).\n",
"- Descripción del paquete, incluyendo la descripción corta y larga, autor, dependencias y licencia.\n",
"- Detalles técnicos del paquete, como su versión, archivos instalados, tamaño, fecha de última actualización, etc.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "eae0d5dc-5db8-4ec6-8a1e-c1e7492c66d7",
"metadata": {},
"outputs": [],
"source": [
"apt show python3-biopython"
]
},
{
"cell_type": "markdown",
"id": "51251d01-ac4e-4edf-98e6-1d92a742cee8",
"metadata": {},
"source": [
"## Instalación de paquetes compilándolo desde las fuentes\n",
"\n",
"Para instalar un paquete desde las fuentes en GNU/Linux utilizando `make` y `make install`, primero se necesita descargar los archivos fuente del repositorio git, o obtenerlos a partir de un repositorio del desarrollador de la aplicación. Una vez que tenga los fuentes del programa puede seguir los siguientes pasos:\n",
"\n",
"1. Descargar las fuentes del repositorio del desarrollador, por ejemplo `git`. Para ello debería tener instalado `git`, en caso de no tenerlo instálelo con `apt-get install git`.\n",
"2. Ubíquese dentro de la carpeta que descargó o descomprimió y revise la documentación del desarrollador. \n",
"3. Instalar las dependencias requeridas para compilar el paquete, estas dependencias deberían constar en la documentación del programa. Esto puede ser realizado utilizando `apt-get`. Dependiendo del sistema operativo. En algunos casos, también es posible instalar las dependencias directamente desde los fuentes si las mismas están disponibles en su repositorio.\n",
"4. Configurar la instalación utilizando el comando `make` o `configure`, dependiendo de como lo haya establecido el desarrollador. En algunos casos, esta opción puede estar automatizada mediante una llamada a un archivo `setup.sh` o `configure.sh`. Esto configura el paquete para trabajar con el sistema operativo y las dependencias correctas. Para determinar la opción correcta revise detenidamente la documentación del programa.\n",
"5. Compilar y realizar pruebas utilizando los siguientes comandos:\n",
"```bash\n",
"make\n",
"make check\n",
"```\n",
"Si no hay errores, ya se puede proceder a la instalación.\n",
"5. Instalar el paquete utilizando el comando `make install`. El paquete será instalado en la carpeta especificada con la opción `--prefix`:\n",
"```bash\n",
"sudo make install\n",
"```\n",
"Es posible que sea necesario ejecutar este comando como superusuario si el paquete incluye archivos compartidos o escritos en carpetas específicas.\n",
"\n",
"Como ejemplo compilaremos BEDTools, sin embargo dado que, de esta aplicación, existen los binarios nativos de Debian, no ejecutaremos el último paso que copia los binarios a la carpeta `bin` pero si la ejecutaremos localmente.\n",
"\n",
"### BEDTools\n",
"BEDTools (BIOinformatics Toolkit) es una colección de herramientas de línea de comandos escrita en Perl para la manipulación de datos genéticos y \n",
"bioinformáticos de archivos de tablas de posición (BED, GFF, VCF, etc.). \n",
"\n",
"Las herramientas de BEDTools se pueden utilizar para un amplio espectro de tareas, incluida la combinación y manipulación de archivos de tablas de posición, la extracción de registros, el cálculo de estadísticas genómicas, la visualización gráfica y mucho más. Algunos de los programas más \n",
"populares de BEDTools incluyen:\n",
"\n",
"* `bx-merge`: para combinar archivos BED en un solo archivo.\n",
"* `bx-sort`: para ordenar los archivos BED por posición genómica.\n",
"* `bx-stats`: para cálculo de estadísticas genómicas básicas sobre archivos BED, incluyendo la distribución del tamaño de los registros y la cantidad de registros en regiones específicas.\n",
"* `bx-intersect`: para identificar las coincidencias entre archivos BED y realizar cálculos estadísticos sobre ellos.\n",
"* `bedtools genomecov`: para generar gráficos de histograma y barras de colores en archivos BED, utilizando por ejemplo el número de registros o la \n",
"cantidad de ADN transcrito en regiones específicas del genoma.\n",
"\n",
"BEDTools es ampliamente utilizado por investigadores que trabajan con datos genéticos y bioinformáticos, ya que es fácil de instalar y utilizar gracias a su interfaz de línea de comandos y su documentación clara y exhaustiva. También se puede integrar con otros paquetes bioinformáticos como Biopython para realizar análisis más complejos.\n",
"\n",
"En el siguiente ejercicio se descargará y compilará la herramienta `bedtools`, sin embargo dado que está disponible en el repositorio no se realizará la instalación, pero si se verificará que se creará la carpeta bin y dentro de ella los ejecutables.\n",
"\n",
"Para instalar Bedtools en su última versión, podemos utilizar Git para descargar la última versión, instalar las dependencias necesarias y luego ejecutar los scripts de instalación:\n",
"\n",
"\n",
"#### 1. Descargue el paquete\n",
"Descargar el paquete con GIT: \n",
"Para descargar el código fuente con `git`, primero nos cambiaremos a la carpeta del usuario con el comando `cd` sin opciones adicionales y luego bajaremos las fuentes con git:\n",
"\n",
"```bash\n",
"cd\n",
"git clone https://github.com/arq5x/bedtools2.git\n",
"```\n",
"\n",
"2. Instale las dependencias\n",
"Dependencias:\n",
"\n",
"Actualice los repositorios de dependencias\n",
"\n",
"```bash\n",
"sudo apt update\n",
"```\n",
"\n",
"#### 2. Instale las dependencias:\n",
"```bash\n",
"sudo apt install build-essential\n",
"sudo apt install liblzma-dev\n",
"sudo apt install liblz-dev\n",
"sudo apt install libbz2-dev\n",
"sudo apt install git\n",
"```\n",
"\n",
"#### 3. Compile\n",
"Compilar:\n",
"```bash\n",
"cd bedtools2\n",
"make \n",
"```\n",
"#### 4. Instalar\n",
"\n",
"Para instalar se debería ejecutar `sudo make install`, sin embargo ene este caso solamente verificaremos que se creó la carpeta bin y dentro de ella los binarios de esta herramienta\n",
"\n",
"Este último paso no lo ejecutaremos\n",
"```bash\n",
"sudo make install\n"
]
},
{
"cell_type": "markdown",
"id": "441526ef-d3a4-42f4-8268-3ca18cc431aa",
"metadata": {},
"source": [
"para verificar que se compiló bedtolls ingrese a su carpeta y dentro de ella a `bin` y ejecute uno de los binarios "
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "19653c76-cc69-4716-b1a5-0d635af4e5d0",
"metadata": {},
"outputs": [],
"source": [
"ls"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "389b14ef-4eea-46b6-8304-f0c2b5542fb4",
"metadata": {},
"outputs": [],
"source": [
"cd bedtools2"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cd68faa6-7b0f-4250-89d5-acb178fe9745",
"metadata": {},
"outputs": [],
"source": [
"cd bin"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c7376dca-0f75-4079-a98a-467addb8c63d",
"metadata": {},
"outputs": [],
"source": [
"ls"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "a10d8647-092d-4a14-bbb0-d8e1d0c9c275",
"metadata": {},
"outputs": [],
"source": [
"./mapBed\t"
]
},
{
"cell_type": "markdown",
"id": "51d8464b-2d89-4085-bd4c-5a3e201557d0",
"metadata": {},
"source": [
"### Variables\n",
"\n",
"En el Shell de BASH, las variables son utilizadas para almacenar valores de datos que pueden ser utilizados en varias líneas de comandos y escribir código reutilizable. Hay diferentes tipos de variables en BASH:\n",
"\n",
"1. **Variables de entorno**: Son variables predefinidas por el sistema operativo o puede haber sido definido por otro programa. Las variables de \n",
"entorno son disponibles para cualquier proceso y su valor no cambia durante la vida útil del proceso. Ejemplos de variables de entorno incluyen: \n",
"`$PATH`, `$HOME`, `$SHELL`.\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "8140f43f-72cb-4440-8aa8-7d1a3f540ff7",
"metadata": {},
"outputs": [],
"source": [
"echo $HOME"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "a48364fc-bd38-4e46-9ce0-03fec0024ce0",
"metadata": {},
"outputs": [],
"source": [
"echo $SHELL"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "f368d2ad-2553-4bde-b8a1-a134f1989099",
"metadata": {},
"outputs": [],
"source": [
"echo $PATH"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "a71e282d-4e71-4158-8117-d3d8ed2b47b1",
"metadata": {},
"outputs": [],
"source": [
"echo $PWD"
]
},
{
"cell_type": "markdown",
"id": "cf712d09-094d-458e-aa29-5f9590e834d3",
"metadata": {},
"source": [
"2. **Variables locales**: Son las que se definen dentro de un script o función utilizando la sintaxis `variable=valor`. Las variables locales solo \n",
"están disponibles dentro del script o función en el que son definidas y no pueden ser accedidas desde fuera del mismo.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "702b6930-b07a-42cd-bcb1-359e10cceb3f",
"metadata": {},
"outputs": [],
"source": [
"a=100"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "0676130b-a0bd-400b-b3a0-8b6ec0f09cda",
"metadata": {},
"outputs": [],
"source": [
"b=\"hola mundo\""
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "519c704f-91b0-4f19-8b85-79d4cd0ff386",
"metadata": {},
"outputs": [],
"source": [
"echo $a"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "92e426e2-bebd-4c6c-8abe-be0d9e52005e",
"metadata": {},
"outputs": [],
"source": [
"echo $b"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "f39b5178-a920-4cdb-9110-b44ca84ece0b",
"metadata": {},
"outputs": [],
"source": [
"echo $b \"al\" $a \"%\""
]
},
{
"cell_type": "markdown",
"id": "2e8fa17d-17da-41a5-b768-e021dcaa58db",
"metadata": {},
"source": [
"3. **Variables de entorno local**: Son las que se definen en el archivo de configuración `.bashrc` o `.bash_profile`. Estas variables solo están disponibles para la sesión actual de BASH y no para otras sesiones posteriores.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "49b71077-1e3f-4995-963c-f1440d442ff8",
"metadata": {},
"outputs": [],
"source": [
"cd"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "adaf4970-6d53-4349-8567-f7bdba2582a1",
"metadata": {},
"outputs": [],
"source": [
"pwd"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "be682d8c-b18d-4dfc-a0bf-649cb27ed3c1",
"metadata": {},
"outputs": [],
"source": [
"head .bashrc"
]
},
{
"cell_type": "markdown",
"id": "bceefac5-7482-4aa0-864b-a9b6bc92e525",
"metadata": {},
"source": [
"4. **Variables de bash**: Hay algunas variables que son especialmente reservadas por BASH, como `$0`, `$1`, `$2`, etc., que se utilizan para acceder a información sobre el script en ejecución.\n",
"5. **Variable de array**: Son un tipo especial de variable que puede almacenar una lista de valores separados por espacios o comas. La sintaxis para definir una variable de array es: `nombre_array=(valor1 valor2 valor3 ...)`.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "27bbb386-bf9b-4c75-aa11-ab45f4aa780c",
"metadata": {},
"outputs": [],
"source": [
"arr=(1 2 \"hola\" \"falso\")"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "1de0ef31-142e-4120-9f96-1a3d02e6abf4",
"metadata": {},
"outputs": [],
"source": [
"echo ${arr[0]}"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "98425676-919d-4224-a4da-9934dbc90fd1",
"metadata": {},
"outputs": [],
"source": [
"echo ${arr[1]}"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "64138712-0f7c-41c6-9dba-f441c727dac3",
"metadata": {},
"outputs": [],
"source": [
"echo ${arr[2]}"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "4f8d822c-c13b-4995-b39d-2e4d9776061a",
"metadata": {},
"outputs": [],
"source": [
"echo ${arr[3]}"
]
},
{
"cell_type": "markdown",
"id": "32dd6833-a769-4fbd-81f2-7eb268c5cbe7",
"metadata": {},
"source": [
"6. **Variables de bash de solo lectura**: Son variables que pueden ser leídas pero no modificadas durante la ejecución del script. La sintaxis para definir una variable de sólo lectura es: `declare -r nombre_variable=valor`.\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "f5e81662-e61d-43a2-abc8-3ef3abd36db5",
"metadata": {},
"outputs": [],
"source": [
"declare -r inmutable=7"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c2fe8e10-c69a-40c1-aeff-2df9edf387f2",
"metadata": {},
"outputs": [],
"source": [
"echo $inmutable"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "7feecc5c-1d69-4720-8b84-08772a661976",
"metadata": {},
"outputs": [],
"source": [
"inmutable=8"
]
},
{
"cell_type": "markdown",
"id": "da602f49-7655-4461-b6f5-618220ef450f",
"metadata": {},
"source": [
"# Comparación de `BASH` con otros lenguajes de programación\n",
"\n",
"BASH es un shell de comandos utilizado en sistemas operativos Unix / Linux que permite a los usuarios ejecutar comandos, redirigir la \n",
"entrada/salida y crear scripts para automatizar tareas repetitivas. Python es un lenguaje de programación multipropósito utilizado para una variedad de aplicaciones como análisis de datos, Machine Learning, robótica y mucho más. R es un lenguaje estadístico y computacional utilizado principalmente para análisis estadístico y científico. \n",
"\n",
"En sistemas operativos GNU/Linux BASH es una buena opción para ejecutar comandos o automatizar tareas repetitivas, de manera complementaria Python o R son las mejores opciones para analizar datos o realizar cálculos estadísticos, .\n",
"\n",
"\n",
"| **Característica** | **BASH** | **Python** | **R** |\n",
"|-------------------------------|-----------------------------------------------|------------------------------------------------|-----------------------------------------------|\n",
"| **Propósito principal** | Shell scripting, automatización de tareas | Desarrollo de software, automatización, ciencia de datos | Análisis estadístico y visualización de datos |\n",
"| **Facilidad de aprendizaje** | Moderada, basada en comandos de texto | Alta, sintaxis clara y legible | Moderada, especialmente para estadística |\n",
"| **Popularidad** | Alta en administración de sistemas y DevOps | Alta en desarrollo general y ciencia de datos | Alta en estadística y análisis de datos |\n",
"| **Sintaxis** | Sencilla pero precisa, basada en comandos | Fácil de leer y escribir, más estructurada | Especializada en estadísticas y matrices |\n",
"| **Ámbito de uso** | Administración de sistemas, scripts de automatización | Desarrollo de aplicaciones, análisis de datos, automatización | Análisis de datos, modelado estadístico |\n",
"| **Bibliotecas y paquetes** | Limitado en comparación con Python y R | Gran cantidad de bibliotecas (como NumPy, pandas, matplotlib) | Gran cantidad de paquetes para análisis estadístico |\n",
"| **Interactividad** | Limitado a la línea de comandos | Interactivo en consolas y notebooks (Jupyter) | Interactivo en consolas y notebooks (RStudio) |\n",
"| **Velocidad de ejecución** | Muy rápida para tareas simples de administración | Moderada, depende de la tarea | Moderada, optimizada para estadísticas |\n",
"| **Soporte para programación orientada a objetos (OOP)** | No soporta OOP | Soporta OOP completamente | Limitado soporte para OOP |\n",
"| **Compatibilidad multiplataforma** | Sí (Linux, macOS, Windows) | Sí (Linux, macOS, Windows) | Sí (Linux, macOS, Windows) |\n",
"| **Comunidad y documentación** | Amplia comunidad en administración de sistemas | Gran comunidad de desarrolladores y científicos de datos | Gran comunidad en estadísticas y ciencia de datos |\n",
"| **Entornos de desarrollo** | Terminal o editores de texto | IDEs como PyCharm, VSCode, Jupyter Notebooks | RStudio, Jupyter Notebooks |\n",
"| **Velocidad de desarrollo** | Rápido para tareas simples, menos flexible | Rápido y flexible para desarrollo general | Rápido en tareas estadísticas, menos flexible en desarrollo general |\n",
"\n",
"\n"
]
},
{
"cell_type": "markdown",
"id": "27d038a3-1ce1-4844-b414-8ee6df9e1fb7",
"metadata": {},
"source": [
"# Resumen\n",
"\n",
"* En este cuaderno hemos revisado como instalar paquetes en BASH, ya sea a partir del gestor de paquetes APT o compilándolo desde las fuentes.\n",
"\n",
"* También hemos revisado la naturaleza y el tipo de variables que existen en BASH "
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "10ef5817-bc37-4cf5-bd71-52266c274744",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "e4f70ce5-2738-425f-b584-0b25f7e6416f",
"metadata": {},
"source": [
"Cuestionario"
]
},
{
"cell_type": "markdown",
"id": "6d9b2f1c-9ff0-4c4b-9f48-eb1e8dc3457a",
"metadata": {},
"source": [
"Explique: ¿qué diferencia existe entre instalar un paquete con `apt` o compilarlo desde las fuentes?"
]
},
{
"cell_type": "markdown",
"id": "9f865987-8fe7-4edd-9085-7b6000b8e588",
"metadata": {},
"source": [
"respuesta"
]
},
{
"cell_type": "markdown",
"id": "73d19435-cd93-43ad-87fc-f91692c198fa",
"metadata": {},
"source": [
"Explique: ¿Qué diferencia existe entre las variables de entorno y las variables de entorno locales?"
]
},
{
"cell_type": "markdown",
"id": "c70e4955-abb2-4db9-851e-3e74c37cb0f1",
"metadata": {},
"source": [
"respuesta"
]
},
{
"cell_type": "markdown",
"id": "3c0f09da-d24f-4416-8226-d969ae5f1038",
"metadata": {},
"source": [
"Conteste: Cuando se busca reproducir experiencias científicas ¿Qué ventajas tiene jupyter?"
]
},
{
"cell_type": "markdown",
"id": "d3bea7e1-6fc6-4410-98dc-d666d6403ab8",
"metadata": {},
"source": [
"repuesta"
]
},
{
"cell_type": "markdown",
"id": "5d6fb1ab-ccc3-4357-9b5b-301a63b581fa",
"metadata": {},
"source": [
"Investigue y conteste ¿Qué es indexación cero e indexación uno en los lenguajes de programación?"
]
},
{
"cell_type": "markdown",
"id": "dc55731e-7344-4262-ae43-bd89fae8932e",
"metadata": {},
"source": [
"respuesta"
]
},
{
"cell_type": "markdown",
"id": "d4a77011-8abc-4a4d-b9bf-d0a738c52eeb",
"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": "74bccb0b-7432-48bc-afa9-cd004ddd3900",
"metadata": {},
"source": [
"## Conclusiones\n",
"1. Conclusión 1\n",
"2. Conclusión 2\n",
"3. Conclusión 3"
]
},
{
"cell_type": "markdown",
"id": "6546a3be-9fa1-44fd-bdb1-de7ef5938161",
"metadata": {},
"source": [
"## Recomendaciones\n",
"1. Recomendación 1\n",
"2. Recomendación 2\n",
"3. Recomendación 3"
]
},
{
"cell_type": "markdown",
"id": "50e71959-0532-465b-b2c7-4d7d5e07cf4f",
"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": "4ba10268-1153-4026-819b-17e69d2bde6a",
"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
}