tema_1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "source": [
    "<font size=6>\n",
    "\n",
    "<b>Curso de Programación en Python</b>\n",
    "</font>\n",
    "\n",
    "<font size=4>\n",
    "    \n",
    "Curso de formación interna, CIEMAT. <br/>\n",
    "Madrid, marzo de 2023\n",
    "\n",
    "Antonio Delgado Peris\n",
    "</font>\n",
    "\n",
    "https://github.com/andelpe/curso-intro-python/\n",
    "\n",
    "<br/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Tema 1 - Introducción y Generalidades"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Objetivos del curso\n",
    "\n",
    "- Aprender a escribir programas en Python\n",
    "- Acercarse a las ventajas del desarrollo incremental\n",
    "  - Huir de los largos ciclos de edición - compilación – depuración. \n",
    "  - Probar cada pequeño cambio\n",
    "- Ventajas de programación de alto nivel\n",
    "  - Introspección, dinamismo\n",
    "  - Concentrarse en el problema, no en el código\n",
    "  - Desarrollo rápido de software\n",
    "- Ventajas del código \"para humanos\"\n",
    "  - Legible, mantenible, reutilizable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Características de python\n",
    "\n",
    "- **Interpretado** (no compilado)\n",
    "  - Portable: soportado en multiples plataformas (mismo código fuente)\n",
    "  - Más lento que C/C++ (pero existen opciones para acelerar las partes críticas)\n",
    "- **Desarrollo incremental**\n",
    "  - Intérprete interactivo y Jupyter notebooks\n",
    "  - Capacidades de introspección\n",
    "  - Tipos dinámicos\n",
    "- **Versátil**\n",
    "  - Desarrollos rápidos (prototipos, scripts)\n",
    "    - Tipos dinámicos, rica librería estándar, sintaxis intuitiva... \n",
    "  - Herramienta de control / integración (_pegamento_)\n",
    "    - Interfaces con código C o Java, ejecutables\n",
    "  - Desarrollos complejos (GUIs, DBs, webs, cálculo científico)\n",
    "  - Orientación a objetos, excepciones, generadores...\n",
    "- **Uso muy extendido**\n",
    "  - Seguramente el más usado en entornos científicos\n",
    "  - Cualquier nuevo proyecto ofrece _python library/bindings_\n",
    "- Rinde homenaje a los Monty Python!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modelo de ejecución\n",
    "\n",
    "- Python compila el código fuente a bytecodes\n",
    "  - Almacenados como ficheros .pyc para reutilización\n",
    "- Python Virtual Machine (PVM): ejecuta los bytecodes\n",
    "\n",
    "![modelo_ejecucion](images/t1_modelo_ejecucion.png)\n",
    "  \n",
    "<br/>\n",
    "\n",
    "- Otras posibilidades (_esotéricas_)\n",
    "  - Traductores a C++\n",
    "  - Integración con Java (_Jython_, en lugar de CPython)\n",
    "  - Compilación a ejecutable: _py2exe_ (Windows) , _Numba_\n",
    "- Además, se puede integrar Python con lenguaje compilado, de varias maneras:\n",
    "  - Escribiendo módulos Python en C (usando `Python.h`)\n",
    "  - Usar _Cython_ para integrar código Python y C, y crear módulos compilados para Python\n",
    "  - Usar _CFFI_ o _Ctypes_, para usar librerías C (compiladas) existentes, desde Python\n",
    "  - Crear un _wrapper_ Python para librerías C/C++, con _Swig_ o _Boost_\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Instalación de Python\n",
    "\n",
    "Solo hay que descargarlo en el formato adecuado para nuestro sistema operativo desde https://www.python.org\n",
    "\n",
    "En muchos sistemas Unix/Linux, Python viene ya instalado por defecto (incluso es usado por el propio S.O.).\n",
    "\n",
    "**NOTA:** Si la instalación es en Windows marcar la opción de añadir Python al PATH. Ver notas en: https://docs.python.org/3/using/windows.html\n",
    "\n",
    "También puede venir incluido en distribuciones de software más amplias:\n",
    "\n",
    "- El ejemplo más conocido es `Anaconda`, que incluye numerosos paquetes científico/técnicos adicionales (así como un IDE, una GUI, un gestor de paquetes/entornos (`conda`), etc.)\n",
    "  - Existe una versión minimalista llamada `Miniconda`, que solo incluye Python, _conda_, y unos pocos paquetes extra."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Instalación de paquetes externos\n",
    "\n",
    "La herramienta oficial (y más usada) para instalar paquetes Python es `pip`. \n",
    "\n",
    "Instala paquetes del Python Package Index (PyPi): https://pypi.org/\n",
    "\n",
    "    python3 -m pip install cowsay\n",
    "    # o       \n",
    "    pip install cowsay    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Una práctica recomendada, y cada vez más extendida, es el uso de entornos virtuales para aislar aplicaciones (cada entorno puede tener sus propios paquetes, en la versión que quieran):\n",
    "  - `venv`, incluida con Python 3.3+. Para versiones anteriores: `virtualenv` (externa, Python 2 y 3).\n",
    "  - `conda` _environments_: el gestor de paquetes y entornos distribuido con `Anaconda`, o `Miniconda`.\n",
    "- Para entornos científicos, como ya hemos comentado, existen distribuciones pre-empaquetadas, como Anaconda."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Usando entornos virtuales _venv_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "Directorio base para nuestros entornos:\n",
    "\n",
    "    $> mkdir $HOME/pythonenvs\n",
    "    $> cd $HOME/pythonenvs\n",
    "\n",
    "\n",
    "Crear el nuevo entorno, contenido en un directorio del mismo nombre, usando el módulo `venv`:\n",
    "\n",
    "    $> python3 -m venv data       # [Windows] C:\\>python -m venv c:\\path\\to\\myenv\n",
    "\n",
    "\n",
    "Activar el entorno virtual `data` (para instalar nuevos paquetes, o para utilizarlo):\n",
    "\n",
    "    $> source data/bin/activate   # [Windows] C:\\> ...myenv\\Scripts\\activate.bat\n",
    "    (data)\n",
    "\n",
    "\n",
    "El entorno incluye su propio `python` (y `pip`):\n",
    "\n",
    "    $> which python3\n",
    "    ~/pythonenvs/data/bin/python3\n",
    "    (data)\n",
    "\n",
    "\n",
    "Actualizar `pip`:\n",
    "\n",
    "    $> python3 -m pip install --upgrade pip\n",
    "    [...]\n",
    "    Successfully installed pip-21.2.4\n",
    "      (data)\n",
    "\n",
    "\n",
    "Instalar los paquetes necesarios (p.ej. para este curso):\n",
    "<br/>Nota: se recomienda instalar todos los paquetes necesarios de una vez para minimizar problemas de dependencias\n",
    "\n",
    "    $> python3 -m pip install jupyterlab matplotlib pytest\n",
    "\n",
    "\n",
    "Un atajo es el uso de un fichero `requirements.txt` que liste todos los paquetes necesarios:\n",
    "  - Para instalar todos los paquetes de un fichero `requirements.txt`: `pip install -r requirements.txt`\n",
    "  - Para producir el fichero `requirements.txt` con lo instalado en el entorno actual: `pip freeze > requirements.txt` \n",
    "\n",
    "Finalmente, para salir del entorno virtual:    \n",
    "\n",
    "    $> deactivate\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Usando entornos virtuales _Conda_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "Crear un entorno virtual (en directorio `[Conda]/envs/data`):\n",
    "\n",
    "    $> conda create -n data [python=3.6]\n",
    "      \n",
    "\n",
    "Activar el entorno virtual `data` (para instalar nuevos paquetes, o para utilizarlo):\n",
    "\n",
    "    $> conda activate data\n",
    "    (data) $> \n",
    "\n",
    "\n",
    "Instalar los paquetes necesarios (p.ej. para este curso):\n",
    "<br/>Nota: se recomienda instalar todos los paquetes necesarios de una vez para minimizar problemas de dependencias\n",
    "\n",
    "    (data) $> conda install jupyterlab matplotlib pytest\n",
    "\n",
    "\n",
    "También se puede crear un entorno a partir de un fichero de entorno, que incluye el nombre del entorno, y dependencias a instalar (con o sin versiones). P.ej:\n",
    "  - El siguiente comando crea un entorno `stats` e instala las dependencias incluidas: `conda env create -f stats_env.yml`\n",
    "  - Para crear un fichero de entorno que refleje la instalación del entorno en uso: `conda env export > data_env.yml` \n",
    "  \n",
    "NOTA: en un entorno Conda también podemos usar `pip freeze` para generar un fichero `requirements.txt`,\n",
    "que es en general más detallado que un `<environment>.yml` (lista todos los paquetes y sus versiones, no dependencias).\n",
    "\n",
    "Finalmente, para salir del entorno virtual:    \n",
    "\n",
    "    (data) $> conda deactivate\n",
    "      \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Ejecución de Python\n",
    "\n",
    "### Intérpretes interactivos\n",
    "\n",
    "- Intérprete interactivo (consola):\n",
    "\n",
    "<font size=1>\n",
    "    \n",
    "         ~ $> python\n",
    "         Python 3.6.4 |Anaconda, Inc.| (default, Jan 16 2018, 12:04:33)\n",
    "         [GCC 4.2.1 Compatible Clang 4.0.1 (tags/RELEASE_401/final)] on darwin\n",
    "         Type \"help\", \"copyright\", \"credits\" or \"license\" for more information.\n",
    "         \n",
    "         >>> print(\"Hello\")\n",
    "         Hello\n",
    "\n",
    "</font>\n",
    "\n",
    "- O la variante _mejorada_, _ipython_:\n",
    "\n",
    "<font size=1>\n",
    "\n",
    "         ~ $> ipython\n",
    "         Python 3.6.4 |Anaconda, Inc.| (default, Jan 16 2018, 12:04:33)\n",
    "         Type 'copyright', 'credits' or 'license' for more information\n",
    "         IPython 6.2.1 -- An enhanced Interactive Python. Type '?' for help.\n",
    "\n",
    "```python\n",
    "    \n",
    "     In [1]: print(\"Hello\")\n",
    "     Hello\n",
    "```\n",
    "\n",
    "</font>\n",
    "<br/>\n",
    "\n",
    "Los intérpretes interactivos son ideales para pruebas rápidas (o _super-calculadora_...).\n",
    "\n",
    "- Permiten ejectuar código línea a línea, manteniendo el estado\n",
    "- Ofrecen las posibilidades de introspección y documentación de Python (`help`, `dir`, `type`...)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### En _scripts_\n",
    "\n",
    "    python myscript.py\n",
    "    \n",
    "O ejecutándolo:\n",
    "\n",
    "    myscript.py\n",
    "    \n",
    "- En Unix, se usa algo como `#!/usr/bin/env python`, en la primera línea del script.\n",
    "- En Windows, se puede hacer _doble click_ con el ratón (cuidado: se puede cerrar sin poder ver el resultado)\n",
    "\n",
    "Los programas suelen necesitar acceder a librerías externas (en Python, módulos), otros ficheros `.py`.\n",
    "\n",
    "- Volveremos sobre ello, pero los módulos se buscan o bien el directorio actual, o en algunos directorios del sistema, o en los indicados por la variable de entorno `PYTHONPATH`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Edición de scripts y módulos\n",
    "\n",
    "Se puede usar cualquier editor de texto puro: `vim`, `emacs`, `sublime`, `notepad++`...\n",
    "- No usar algo como `Word`!\n",
    "- Yo uso `vim` (como cualquier programador serio, ejem...)\n",
    "\n",
    "También se puede usar un entorno de desarrollo integrado (IDE)\n",
    "- Incluyen muchas utilidades de ayuda, depuración, refactorización\n",
    "- Integran un intérprete interactivo\n",
    "- Muchas opciones: IDLE (parte de Python), PyCharm, Spyder (de Anaconda), Visual Studio, Eclipse...\n",
    "\n",
    "O se puede usar _Jupyter_."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## El código fuente en Python\n",
    "\n",
    "La indentación tiene significado sintáctico en Python \n",
    "- Python anima a escribir código legible\n",
    "- La indentación (espacios o tabuladores) crea bloques de código\n",
    "- Se recomienda usar siempre 4 espacios (y evitar el tabulador)\n",
    "\n",
    "Ejemplo (_incorrecto_), en C:\n",
    "```c\n",
    "if (X > 0) {\n",
    "     printf(\"X es positivo\") }\n",
    "     if (X < 2) {\n",
    "          printf(\"X es 1\")\n",
    "}\n",
    "```\n",
    "\n",
    "Lo mismo en Python:  \n",
    "```python\n",
    "if X > 0:\n",
    "    print(\"X es positivo\")\n",
    "if X < 2:\n",
    "    print(\"X es 1\")\n",
    "```\n",
    "\n",
    "NOTA: La indentación es ignorada dentro de un paréntesis:\n",
    "```python\n",
    "if ((X > 0)\n",
    "    and ((if X < 2):\n",
    "print(\"X es 1\")\n",
    "```\n",
    "\n",
    "En Python, los comentarios se introducen con `#`:\n",
    "```python\n",
    "# This is a comment\n",
    "print(\"Hello\")\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sobre las versiones de Python\n",
    "\n",
    "### Versiones de Python\n",
    "\n",
    "Python 3 es la única versión soportada oficialmente en la actualidad.\n",
    "- Python 2 ya no recibe mejoras, ni parches de seguridad\n",
    "\n",
    "Eso no impide que Python 2 todavía se use mucho, y viene pre-instalada en sistemas operativos _recientes_ como _CentOs 7_.\n",
    "\n",
    "Los ejemplos y ejercicios de este curso están realizados completamente en Python 3.\n",
    "- En algún caso, se hace referencia a diferencias con Python 2, pero son mínimas.\n",
    "\n",
    "### Diferencias entre Python 2 y 3\n",
    "\n",
    "_Compatibilidad hacia atrás_: Cualquier programa de `Python 3.x` puede ser interpretado por `Python 3.y`, si `y > x` (la recíproca no es necesariamente cierta, si ha usado alguna funcionalidad añadida).\n",
    "\n",
    "Sin embargo, Python 3 no mantiene compatibilidad hacia atrás con Python 2. Los siguientes casos no funcionan en Python 3:\n",
    "\n",
    "- `print` pasó de ser una sentencia a una función: `print \"This\"` --> `print('This')`\n",
    "- La división entre enteros pasó a producir un _float_: `3/2 == 1` --> `3/2 == 1.5`\n",
    "- Sintaxis para excepciones: `except IOError, ex` --> `except IOError as ex`\n",
    "\n",
    "Existen algunas soluciones:\n",
    "\n",
    "- Script de conversión automática (`2to3 <python-2-script>` genera un python-3-script)\n",
    "\n",
    "- Usar siempre la sintaxis de Python 3, y añadir la siguiente línea a todos los scripts\n",
    "\n",
    "  - Inocua en Python 3, posibilita la nueva sintaxis en Python 2 (>=2.6):\n",
    "\n",
    "        from __future__ import division, print_function\n",
    "\n",
    "No hay Python 4.0 previsto *any time soom*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Jupyter\n",
    "\n",
    "#### Jupyter notebooks\n",
    "\n",
    "El proyecto Jupyter nació como una evolución (y _spin-off_) de IPython.\n",
    "\n",
    "Su elemento central son los _Jupyter notebooks_:\n",
    "\n",
    "- Son documentos que integran código, resultados, visualizaciones y texto en formato _Markdown_ (que se muestra como HTML).\n",
    "\n",
    "- Soporta diferentes entornos (_kernels_), e incluso lenguajes (R, Julia...)\n",
    "\n",
    "- El usuario interacciona con los notebooks a través de su navegador.\n",
    "\n",
    "- Muy útil para documentar y compartir trabajo científico\n",
    "\n",
    "- También muy práctico para pre-configurar entornos de trabajo: ideal para cursos, p. ej.\n",
    "\n",
    "- También es una opción como entorno de desarrollo/pruebas (pero no la única)\n",
    "\n",
    "- Los _notebooks_ se almacenan como ficheros _JSON_, con todos sus elementos, y se pueden recuperar, y ejecutar posteriormente.\n",
    "\n",
    "La otra pieza de Jupyter es el programa que sirve el contenido de los notebooks al navegador, y ejecuta su código bajo demanda.\n",
    "\n",
    "- Jupyter integra un pequeño servidor web y varios _kernels_ de ejecución (uno por notebook abierto).\n",
    "\n",
    "- Usando el navegador, podemos ejecutar el código del notebook en el ordenador local, o en un sistema remoto (p.ej. en la nube)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![jupyter](images/t1_jupyter.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Jupyterlab\n",
    "\n",
    "La versión más reciente de Jupyer se llama `Jupyterlab` (por oposición a `Jupyter notebooks`).\n",
    "\n",
    "- Jupyterlab permite trabajar en varios notebooks a la vez, editar archivos de texto (o módulos Python), abrir una consola IPython tradicional, o acceder a una terminal del sistema donde está corriendo.\n",
    "\n",
    "- Además, Jupyterlab soporta la instalación de complementos para aportar funcionalidad adicional\n",
    "\n",
    "Dadas sus capacidades, Jupyterlab puede ser considerado también como un IDE, y cada vez más científicos lo utilizan como su único entorno de desarrollo (es una cuestión de hábito y preferencia personal).\n",
    "\n",
    "\n",
    "#### Notas sobre el uso de Jupyterlab\n",
    "\n",
    "- Los notebooks se dividen en celdas. Cada celda puede ser de código, de texto Markdown, o de puro texto (_raw_).\n",
    "  - `Shift+Enter` ejecuta una celda de código, y convierte una celda Markdown a HTML.\n",
    "  - Se puede ejecutar también un comando en la terminal (y no en Python) usando `!<comando>`, p.ej.: `!ls`.\n",
    "  - Finalmente, también están los comandos _mágicos_ de IPython, que empiezan por `%`.\n",
    "    - Se puede consultar ayuda sobre estos comandos ejecutando `%magic`\n",
    "- Operaciones con celdas:\n",
    "  - Añadir nueva celda: botón +, o A (arriba), o B (abajo)\n",
    "  - Copiar, cortar, pegar, borrar celda:  C, X, V, DD\n",
    "  - Deshacer una operación con celdas:  Z  (Otras operaciones: Ctrl-Z)\n",
    "- Para comandos de ayuda, o, en general, con salidas largas, recomiendo...\n",
    "  - Ejecutarlos en una consola independiente (para no contaminar el notebook)\n",
    "  - O usar la opción de activar las barras de _scroll_ (menú del botón derecho del ratón en la celda de salida).\n",
    "- Jupyterlab puede gestionar diversos ficheros y carpetas, y este curso hace uso de ellos.\n",
    "  - Mantened los notebooks de los temas en la carpeta raíz, y trabajar en ella.\n",
    "    - El directorio de trabajo será el correcto si se usa Binder, o si se lanza un Jupyterlab local desde la carpeta raíz del curso.\n",
    "    - Si se usa Google Colab, se requieren acciones adicionales: consultar la información del `README` de este curso."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Instalación de Jupyterlab\n",
    "\n",
    "Desde una terminal de Linux o el símbolo del sistema de Windows, ejecutar:\n",
    "```\n",
    "pip install jupyterlab\n",
    "```\n",
    "NOTA: para que esto funcione en Windows es necesario haber marcado la casilla de añadir Python al PATH en su instalación.\n",
    "\n",
    "#### Ejecución de Jupyterlab\n",
    "Desde una terminal de Linux o el símbolo del sistema de Windows, ejecutar:\n",
    "```\n",
    "cd <directorio-del-curso>\n",
    "jupyter lab \n",
    "```\n",
    "\n",
    "La salida del comando mostrará muchas líneas que acaban con algo como: \n",
    "```\n",
    "To access the server, open this file in a browser:\n",
    "    file:///D:/Users/andelpe/AppData_Roaming/jupyter/runtime/jpserver-16760-open.html\n",
    "Or copy and paste one of these URLs:\n",
    "    http://localhost:8888/lab?token=07a1171468a0c5da80a7dfd9546037123e554a54e5a0ea17\n",
    "     http://127.0.0.1:8888/lab?token=07a1171468a0c5da80a7dfd9546037123e554a54e5a0ea17\n",
    "```\n",
    "\n",
    "Seguramente la sesión jupyter se abrirá directamente en nuestro navegador. Si no es así, podemos copiar una de las líneas que empiezan por `http://` y pegarla en la barra de direcciones de nuestro navegador.\n",
    "\n",
    "\n",
    "##### Carpeta de inicio de Jupyterlab\n",
    "Por defecto la carpeta de inicio de jupyter lab es aquella desde que lo lancemos (por eso la instrucción `cd` del ejemplo anterior).\n",
    "\n",
    "Alternativamente, se puede forzar modificando la variable `c.ServerApp.root_dir` en el fichero de configuración `.jupyter/jupyter_lab_config.py`, situado en nuestro directorio de usuario (en Windows, seguramente `C:\\Usuarios\\<nombre>`.\n",
    "\n",
    "Ejemplo de configuración para Windows:\n",
    "```\n",
    "c.ServerApp.root_dir = 'D:\\\\Users\\\\andelpe\\\\work\\\\python\\\\curso_ciemat'\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Referencias\n",
    "\n",
    "- Web de referencia: http://python.org\n",
    "- Documentación (enlazada por la previa): http://docs.python.org/ \n",
    "- Documentos de cabecera:\n",
    "  - Tutorial: https://docs.python.org/3/tutorial/\n",
    "  - Library reference: https://docs.python.org/3/library/\n",
    "- Python en Windows: https://docs.python.org/3/using/windows.html\n",
    "- Virtual environments: https://docs.python.org/3/tutorial/venv.html\n",
    "- Conda: https://conda.io/projects/conda/en/latest/user-guide/\n",
    "- Jupyter(lab):\n",
    "  - Proyecto Jupyter: https://jupyter.org/\n",
    "  - Docs Jupyterlab: https://jupyterlab.readthedocs.io\n",
    "- Pero hay mucha más información en Internet\n",
    "  - _Google_, _Stack Overflow_, _ChatGPT_ ..."
   ]
  }
 ],
 "metadata": {
  "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.2"
  },
  "title": "Curso de Programación en Python",
  "toc-autonumbering": false,
  "toc-showcode": false,
  "toc-showtags": true
 },
 "nbformat": 4,
 "nbformat_minor": 4
}