{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "iwFmF2sLRkJr"
   },
   "source": [
    "<p>\n",
    "<font size='5' face='Georgia, Arial'>IIC-2233 Apunte Programación Avanzada</font><br>\n",
    "<font size='1'> Material creado en 2022-2 y actualizado al 2025-1 por Equipo Docente IIC2233.</font>\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "ptYFt7BTRxHt"
   },
   "source": [
    "## Tabla de contenidos\n",
    "\n",
    "1. [Terminal](#Terminal)\n",
    "2. [Comandos](#Comandos)\n",
    "3. [Ejecución de Python en Terminal](#Ejecución-de-Python-en-Terminal)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "5HIBT105R7zy"
   },
   "source": [
    "## Terminal\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "YmfR9bJfgOkI",
    "jp-MarkdownHeadingCollapsed": true,
    "tags": []
   },
   "source": [
    "### 1. ¿Qué es la terminal o consola?\n",
    "\n",
    "Una terminal o consola es una de las formas para comunicarnos con un computador. Esta nos provee de una interfaz instrucciones o comandos al computador. Por ejemplo, ejecutar programas instalados previamente como Python y Jupyter Notebook, navegar por el sistema de archivos del computador, explorar qué archivos hay en determinadas carpetas, entre otros. \n",
    "\n",
    "El funcionamiento de esta interfaz es a través de comando de línea de texto, es decir, su funcionamiento se basa en que el usuario escribe comandos junto con sus parámetros para que el sistema operativo entregue una respuesta. A continuación se presenta una foto de una terminal en MAC donde se ejecutó el comando `cd` para acceder al escritorio del computador y `ls` para saber qué archivos y carpetas hay en el escritorio\n",
    "\n",
    "<center><img src=\"data/example.png\" alt=\"Terminal Example\" style=\"width: 500px;\"/></center>\n",
    "\n",
    "\n",
    "Para efectos de este curso, las dos principales ventajas de utilizar la terminal son:\n",
    "\n",
    "1. Poder tener varias terminales abiertas y cada una utilizarla para diferentes propósitos. Por ejemplo, **ejecutar diferentes archivos Python de forma simultánea**.\n",
    "\n",
    "2. Ser capaz de saber siempre desde qué carpeta estamos ejecutando un archivo. Lo cual nos reducirá la posibilidad de tener errores relacionados a **rutas relativas**.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "oRH-nJl1gHLs"
   },
   "source": [
    "### 2. ¿Cómo abrir la terminal?\n",
    "\n",
    "* **Windows**: En la barra de inicio, puedes buscar \"cmd\" y abrir el programa (\"Command prompt\"). Aunque también recomendamos descargar desde la tienda la aplicación \"Windows Terminal\" y usarla como terminal.\n",
    "* **Linux**: Puedes usar la combinación de teclas ` Ctrl + Alt + T ` para abrir la terminal.\n",
    "* **macOS**: En Finder, abre la carpeta /Aplicaciones/Utilidades y haz doble clic en \"Terminal\".\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_re2t4NDSoEx"
   },
   "source": [
    "## Comandos\n",
    "\n",
    "Los comandos corresponden al mecanismo donde el usuario se puede comunicar con el computador y solicitar que haga ciertas acciones. Para este curso, los comandos más importantes a conocer son 6: `pwd`, `dir` o `ls`, `cd`, `mkdir`, `echo` o `touch` y `python`. \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "9zZPe_JIgM2g"
   },
   "source": [
    "### 1. Formato del comando\n",
    "\n",
    "El formato para todo comando es el siguiente:\n",
    "\n",
    "`comando argumentos* -opciones*`\n",
    "\n",
    "* **`comando`**: corresponde al nombre del comando a llamar. Por ejemplo, `pwd`, `cd`, `python`, `pip`.\n",
    "\n",
    "- **`argumentos*`**: corresponde a los parámetros que el comando va a utilizar para su ejecución. Dependiente del parámetro, estos argumentos pueden ser 0, 1, 2, etc. Algunos casos son:\n",
    "    1. **`pwd`** es un comando que no necesita argumentos, solo escribimos dicho comando y funcionará.\n",
    "    2. **`python`** es un comando que cambia su funcionamiento según la cantidad de argumentos. Si se ejecuta sin ningún argumento (`python`), se abrirá la consola de Python. Si se ejecuta con 1 argumento que corresponde a un archivo .py (`python ejemplo3.py`), se ejecutará el archivo correspondiente.\n",
    "    3. **`pip`** es un comando que interactúa con el gestor de librerías en Python, y este tiene muchos argumentos posibles. Para ver las librerías instaladas, se necesita de 1 argumento, `list`, para su ejecución: `pip list`. Para instalar una librería, se necesita 2 argumentos, `install nombre_librería`, para su ejecución: `pip install pyqt6`. \n",
    "\n",
    "* **`-opciones`**: también conocidos como _flags_, es la forma de especificar opciones durante la ejecución del comando. Cada opción se escribe como `-nombre_de_la_opción parámetro*` en donde el parámetro puede ser opcional según la opción que estemos llamando. Por ejemplo:\n",
    "    1. Para  instalar una librería de python, se puede hacer `pip install pyqt6`, pero también se puede hacer `pip install pyqt6 -q`. El `-q` se encarga de personalizar la ejecución, en este caso, hacer la instalación \"quiet\", es decir, sin imprimir tantas cosas en consola.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2. Uso de comandos\n",
    "\n",
    "Para ejemplificar cada comando que veremos a continuación, imaginemos que tenemos la siguiente estructura de carpetas y archivos:\n",
    "\n",
    "<center><img src=\"data/files.png\" alt=\"Drawing\" style=\"width: 500px;\"/></center>\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Windows\n",
    "\n",
    "En Windows tenemos 4 comandos básicos: `cd`, `dir`, `mkdir` y `echo`.\n",
    "\n",
    "##### 1. Ver directorio actual (`cd`)\n",
    "\n",
    "Del inglés **c**hange **d**irectory, este comando nos permite movernos en el sistema de archivos para acceder a diferentes directorios/carpetas. Cuando ejecutamos este comando sin ningún argumento, nos retorna la posición actual como una **ruta absoluta**.\n",
    "\n",
    "```cmd\n",
    "➜ cd\n",
    "C:\\Users\\Pedro\n",
    "```\n",
    "En este caso, nuestra terminal está ubicada dentro de la carpeta `Pedro` que a su vez esta carpeta está dentro de la carpeta `Users`, la cual está dentro de la carpeta raíz.\n",
    "\n",
    "\n",
    "##### 2. Cambiar directorio actual (`cd`)\n",
    "\n",
    "En caso de que se agregue una ruta (absoluta o relativa) al comando, este nos permitirá cambiar nuestro directorio.\n",
    "\n",
    "```cmd\n",
    "➜ cd\n",
    "C:\\Users\\Pedro\n",
    "➜ cd Libros\n",
    "➜ cd\n",
    "\\Users\\Pedro\\Libros\n",
    "```\n",
    "Ahora, desde la carpeta `Pedro` nos movimos a la carpeta `Libros`. También es posible subir a la carpeta superior utilizando el argumento `..`.\n",
    "\n",
    "```cmd\n",
    "➜ cd\n",
    "C:\\Users\\Pedro\n",
    "➜ cd Libros\n",
    "➜ cd\n",
    "C:\\Users\\Pedro\\Libros\n",
    "➜ cd ..\n",
    "➜ cd\n",
    "C:\\Users\\Pedro\n",
    "➜ cd Música\n",
    "➜ cd\n",
    "C:\\Users\\Pedro\\Música\n",
    "➜ cd ..\\..\\data\n",
    "➜ cd\n",
    "\\data\n",
    "```\n",
    "\n",
    "\n",
    "##### 3. Listar contenido de un directorio (`dir`)\n",
    "\n",
    "Del inglés **dir**ectory, este comando nos entrega un detalle de los archivos y carpetas presentes en un determinado directorio. De forma informal, podemos decir que este comando nos responde a la pregunta: ¿Qué tenemos en la carpeta?\n",
    "\n",
    "```cmd\n",
    "➜ cd\n",
    "\\Users\\Pedro\n",
    "➜ dir\n",
    "... (texto omitido para este ejemplo)\n",
    "\n",
    "Directorio de \\Users\\Pedro\n",
    "02-08-2022  12:29    <DIR>          .\n",
    "02-08-2022  12:29    <DIR>          ..\n",
    "19-07-2022  18:45    <DIR>          Fotos\n",
    "19-07-2022  18:45    <DIR>          Libros\n",
    "19-07-2022  18:45    <DIR>          Música\n",
    "... (texto omitido para este ejemplo)\n",
    "➜ Libros\n",
    "➜ cd\n",
    "\\Users\\Pedro\\Libros\n",
    "➜ dir\n",
    "... (texto omitido para este ejemplo)\n",
    "\n",
    "Directorio de \\Users\\Pedro\\Libros\n",
    "02-08-2022  12:29    <DIR>          .\n",
    "02-08-2022  12:29    <DIR>          ..\n",
    "02-08-2022  12:29            11.960 calculo.pdf\n",
    "02-08-2022  11:55            16.119 python.pdf\n",
    "... (texto omitido para este ejemplo)\n",
    "\n",
    "```\n",
    "\n",
    "##### 4. Crear un directorio nuevo (`mkdir`)\n",
    "Del inglés **m**a**k**e **dir**ectory, este comando crea una nueva carpeta o subcarpeta con el nombre indicado como argumento. También podemos entregarle el *path* con la dirección hacia la nueva carpeta.\n",
    "\n",
    "```cmd\n",
    "➜ cd\n",
    "\\Users\\Pedro\n",
    "➜ dir\n",
    "... (texto omitido para este ejemplo)\n",
    "\n",
    "Directorio de \\Users\\Pedro\n",
    "02-08-2022  12:29    <DIR>          .\n",
    "02-08-2022  12:29    <DIR>          ..\n",
    "19-07-2022  18:45    <DIR>          Fotos\n",
    "19-07-2022  18:45    <DIR>          Libros\n",
    "19-07-2022  18:45    <DIR>          Música\n",
    "... (texto omitido para este ejemplo)\n",
    "```\n",
    "Ahora, crearemos una nueva carpeta llamada Codigos. Esta carpeta no existe antes del comando y se crea en el momento en que lo ejecutamos.\n",
    "```cmd\n",
    "➜ mkdir Codigos\n",
    "➜ dir\n",
    "... (texto omitido para este ejemplo)\n",
    "\n",
    "Directorio de \\Users\\Pedro\n",
    "02-08-2022  12:29    <DIR>          .\n",
    "02-08-2022  12:29    <DIR>          ..\n",
    "19-07-2022  18:45    <DIR>          Fotos\n",
    "19-07-2022  18:45    <DIR>          Libros\n",
    "19-07-2022  18:45    <DIR>          Música\n",
    "07-03-2024  10:00    <DIR>          Codigos\n",
    "... (texto omitido para este ejemplo)\n",
    "```\n",
    "\n",
    "##### 5. Crear un archivo nuevo (`echo`)\n",
    "Este comando permite mostrar un mensaje de salida en la terminal, lo mas parecido a un print de Python pero en consola. En este caso, lo usaremos para redirigir esa salida a un archivo. La sintaxis es: `echo \"TEXTO\" > NOMBRE_ARCHIVO`, donde `echo` es el nombre del comando, `\"TEXTO\"` es el texto de salida entre comillas simples o dobles, y `NOMBRE_ARCHIVO` será el nombre de nuestro nuevo archivo considerando siempre la extensión (.txt, .py). \n",
    "\n",
    "Para crear un archivo vacío de Python, simplemente dejaremos el TEXTO como un string vacío `\"\"`, y le daremos el nombre junto a la extensión .py.\n",
    "```\n",
    "➜ echo \"\" > nuevo.py\n",
    "```\n",
    "\n",
    "\n",
    "**¡Te invitamos a probar estos 4 comandos (`cd`, `dir`, `mkdir` y `echo`) en tu terminal para familiarizarte con su uso!** Utilizarás mucho estos comandos en este curso."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Z61Y35H3gLjS"
   },
   "source": [
    "#### Linux y macos\n",
    "\n",
    "Tanto Linux como Mac OS X funcionan con facilidades estándar de Unix en sus terminales. Esto nos permite utilizar los mismos comandos para ambos sistemas operativos: `pwd`, `cd`, `ls`, `mkdir` y `touch`.\n",
    "\n",
    "\n",
    "##### 1. Ver directorio actual (`pwd`)\n",
    "\n",
    "De las siglas en inglés **p**rint **w**orking **d**irectory, es el comando que nos retorna la **ruta absoluta** para llegar a nuestra posición desde la terminal. De forma informal, podemos decir que este comando nos responde a la pregunta: ¿Dónde estamos?. Cuando ejecutamos este comando, nos retorna la posición actual como una **ruta absoluta**.\n",
    "\n",
    "```cmd\n",
    "➜ pwd\n",
    "/Users/Pedro\n",
    "```\n",
    "En este caso, nuestra terminal está ubicada dentro de la carpeta `Pedro` que a su vez esta carpeta está dentro de la carpeta `Users`, la cual está dentro de la carpeta raíz.\n",
    "\n",
    "\n",
    "##### 2. Cambiar directorio actual (`cd`)\n",
    "\n",
    "Del inglés **c**hange **d**irectory, este comando nos permite movernos en el sistema de archivos para acceder a diferentes directorios/carpetas. Para esto, es necesario agregar una **ruta absoluta** o **relativa** como argumento.\n",
    "\n",
    "```cmd\n",
    "➜ pwd\n",
    "/Users/Pedro\n",
    "➜ cd Libros\n",
    "➜ pwd\n",
    "/Users/Pedro/Libros\n",
    "```\n",
    "Ahora, desde la carpeta `Pedro` nos movimos a la carpeta `Libros`. También es posible salir de una carpeta utilizando el argumento `..`.\n",
    "\n",
    "```cmd\n",
    "➜ pwd\n",
    "/Users/Pedro\n",
    "➜ cd Libros\n",
    "➜ pwd\n",
    "/Users/Pedro/Libros\n",
    "➜ cd ..\n",
    "➜ pwd\n",
    "/Users/Pedro\n",
    "➜ cd Música\n",
    "➜ pwd\n",
    "/Users/Pedro/Música\n",
    "➜ cd ../../data\n",
    "➜ pwd\n",
    "/data\n",
    "```\n",
    "\n",
    "\n",
    "##### 3. Listar contenido de un directorio (`ls`)\n",
    "\n",
    "Del inglés **l**i**s**t, este comando nos entrega un detalle de los archivos y carpetas presentes en un determinado directorio. De forma informal, podemos decir que este comando nos responde a la pregunta: ¿Qué tenemos en la carpeta?\n",
    "\n",
    "```cmd\n",
    "➜ pwd\n",
    "/Users/Pedro\n",
    "➜ ls\n",
    "Fotos\n",
    "Libros\n",
    "Música\n",
    "➜ Libros\n",
    "➜ cd\n",
    "/Users/Pedro/Libros\n",
    "➜ ls\n",
    "calculo.pdf\n",
    "python.pdf\n",
    "```\n",
    "\n",
    "##### 4. Crear un directorio (`mkdir`)\n",
    "Del inglés **m**a**k**e **dir**ectory, este comando crea una nueva carpeta o subcarpeta con el nombre indicado como argumento. También podemos entregarle el *path* con la dirección hacia la nueva carpeta.\n",
    "\n",
    "```cmd\n",
    "➜ pwd\n",
    "/Users/Pedro\n",
    "➜ ls\n",
    "Fotos\n",
    "Libros\n",
    "Música\n",
    "➜ mkdir Codigos\n",
    "➜ ls\n",
    "Codigos\n",
    "Fotos\n",
    "Libros\n",
    "Música\n",
    "➜ mkdir /Users/Pedro/Apuntes\n",
    "➜ ls\n",
    "Apuntes\n",
    "Codigos\n",
    "Fotos\n",
    "Libros\n",
    "Música\n",
    "```\n",
    "\n",
    "##### 5. Cear un archivo vacío (`touch`)\n",
    "Este comando \"toca\" el archivo para comprobar si existe o no en esa ruta. Si un archivo no existe en el directorio indicado, crea un archivo vacío con el nombre y la extensión. Si el archivo existe, modifica instantáneamente el _timestamp_ o fecha de último acceso al archivo al momento de ejecución del comando. Su nombre \"touch\" en español es \"tocar\", como si estuvieras comprobando si está ahi o no con un palito. De forma informal, podemos decir que este comando nos responde a la pregunta: ¿Existes en este momento?.\n",
    "\n",
    "```cmd\n",
    "➜ touch main.py\n",
    "```\n",
    "\n",
    "Al ejecutar este comando, la terminal no emitirá ningún mensaje. Si el archivo pedido main.py no existe, podrás comprobar con `ls` que ha sido creado y está vacío.\n",
    "\n",
    "**¡Te invitamos a probar estos 5 comandos (`pwd`, `cd`, `ls`, `mkdir` y `touch`) en tu terminal para familiarizarte con su uso!** Utilizarás mucho estos comandos en este curso."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "1GawiQJRS8iL"
   },
   "source": [
    "## Ejecución de Python en Terminal\n",
    "\n",
    "La mayoría de las _IDEs_ para programar en Python ofrecen opción de ejecutar esos archivos con solo oprimir un botón. No obstante, en muchos casos, su interfaz no muestra claramente desde donde se está ejecutando el archivo, es decir, no se sabe tan fácilmente el `pwd` desde donde se ejecutó el archivo Python. Esto en varias ocasiones genera **problemas** con la apertura de archivos y también `imports` o cuando utilizamos **rulas relativas** en el código.\n",
    "\n",
    "Adicionalmente, estas _IDEs_ vienen por defecto con la configuración para ejecutar **1 archivo a la vez**. Esto provoca que para actividades donde el estudiantado requiere ejecutar **2 o más archivos a la vez**, no se logre.\n",
    "\n",
    "En vista de las dificultades presentadas anteriormente, a continuación se explica cómo poder ejecutar archivos de Python en terminal. Esto nos dará la ventaja de:\n",
    "1. Saber claramente nuestra ubicación en el sistema de archivos.\n",
    "2. Evitar problemas con la apertura de archivos, los `imports` y con las **rulas relativas** dentro del código.\n",
    "3. Poder ejecutar más de 1 archivo simultáneamente.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "3jW7eO0ygQ1S"
   },
   "source": [
    "### 1. Abrir Python\n",
    "\n",
    "Desde la terminal, podemos escribir `python` o `python3` y podremos acceder a la consola de Python, donde podremos ejecutar comandos de python. Por ejemplo, si necesitamos hacer una operación rápida (y no queremos usar nuestra calculadora).\n",
    "\n",
    "<center><img src=\"data/screenshot_1.png\" alt=\"Screenshot_1\" style=\"width: 500px;\"/></center>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "2D9Mgj3GgQD5"
   },
   "source": [
    "### 2. Ejecutar _script_ de Python\n",
    "\n",
    "Otra ventaja de usar la terminal es poder ejecutar nuestros archivos Python sin recurrir a alguna _IDE_ (como Visual Studio Code o SublimeText3). Para esto, solo basta agregar como argumento el nombre del archivo a ejecutar.\n",
    "\n",
    "En el siguiente caso, vamos a acceder a la carpeta `semana-01` que está dentro de `contenidos` en el escritorio y vamos a ejecutar el archivo `ejemplo.py`\n",
    "\n",
    "<center><img src=\"data/screenshot_2.png\" alt=\"Screenshot_2\" style=\"width: 500px;\"/></center>\n",
    "\n",
    "También es posible ejecutar un archivo que no esté dentro de nuestro directorio actual. Para esto, es necesario escribir la **ruta absoluta** o **relativa** a dicho archivo. En el siguiente ejemplo se ejecutó el mismo archivo, pero en el primer caso se utilizó una **rula relativa** para acceder a él y en el segundo caso se utilizó una **ruta absoluta**. \n",
    "\n",
    "<center><img src=\"data/screenshot_3.png\" alt=\"Screenshot_3\" style=\"width: 500px;\"/></center>\n",
    "\n",
    "⚠️ **Importante** ⚠️: esto hace que el `ejemplo.py` crea que está siendo ejecutado desde la ruta actual de la consola, que es distinta a la carpeta donde se encuentra el archivo. Lo cual puede generar un error."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. Errores comunes en Python con la terminal\n",
    "\n",
    "1. **Archivo no existe**\n",
    "\n",
    "    Es posible que el archivo a ejecutar o la ruta a dicho archivo no estén bien escritos o simplemente no exista dicho archivo. En ese caso Python retornará un error indicando que el archivo no existe.\n",
    "\n",
    "    <center><img src=\"data/screenshot_4.png\" alt=\"Screenshot_4\" style=\"width: 500px;\"/></center>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "2. **Conflictos con rutas relativas**\n",
    "\n",
    "    Es posible que el archivo a ejecutar ocupe rutas relativas y esto genere conflictos según donde ejecutamos el archivo. Por ejemplo, junto a estos contenidos hay un directorio llamado `carpeta_auxiliar`. Dentro de este existen 2 archivos: `hello_world.txt` y `main.py`. El contenido de este segundo archivo es\n",
    "\n",
    "    ```python\n",
    "    import os\n",
    "\n",
    "\n",
    "    if __name__ == '__main__':\n",
    "        print(\"Me estoy ejecutando desde:\")\n",
    "        path = os.getcwd()\n",
    "        print(path)\n",
    "        content = open(\"hello world.txt\").read()\n",
    "        print(content)\n",
    "    ```\n",
    "\n",
    "    Es decir, este nuevo archivo nos indica desde donde se está ejecutando el Python y luego abre `hello world.txt` para imprimir su contenido. Dado que solo está escrito el nombre del archivo, `main.py` asume que `hello world.txt` está en el mismo directorio desde donde se ejecutará `main.py`.\n",
    "\n",
    "    Ahora, desde la terminal, vamos a posicionarnos en la carpeta de los contenidos de la semana 1 y vamos a intentar ejecutar el `main.py`.\n",
    "\n",
    "    <center><img src=\"data/screenshot_5.png\" alt=\"Screenshot_5\" style=\"width: 500px;\"/></center>\n",
    "\n",
    "    Nos salió el siguiente error:\n",
    "\n",
    "    ```cmd\n",
    "    Traceback (most recent call last):\n",
    "      File \"/Users/macbook/Desktop/contenidos/semana-01/carpeta_auxiliar/main.py\", line 8, in <module>\n",
    "        content = open(\"hello world.txt\").read()\n",
    "    FileNotFoundError: [Errno 2] No such file or directory: 'hello world.txt'\n",
    "    ```\n",
    "    Esto ocurrió porque nosotros ejecutamos `main.py` desde el directorio `/Users/macbook/Desktop/contenidos/semana-01`. En dicho directorio **no existe `hello world.txt`**. \n",
    "\n",
    "    Ahora, utilizaremos `cd` para acceder al directorio `carpeta_auxiliar` y volvemos a ejecutar `main.py`. \n",
    "\n",
    "    <center><img src=\"data/screenshot_6.png\" alt=\"Screenshot_6\" style=\"width: 500px;\"/></center>\n",
    "\n",
    "    Ahora, sí funciona porque efectivamente en `/Users/macbook/Desktop/contenidos/semana-01/carpeta_auxiliar` sí existe el archivo `hello world.txt`.\n",
    "\n",
    "    **Importante**: siempre tengan en mente desde qué carpeta se ejecutarán sus archivos Python para no tener problema con las rutas relativas."
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "name": "5-terminal.ipynb",
   "provenance": []
  },
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
