python3_ipython_es.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "toc": true
   },
   "source": [
    "<h1>Mis notas: IPython<span class=\"tocSkip\"></span></h1>\n",
    "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Intro\" data-toc-modified-id=\"Intro-0\"><span class=\"toc-item-num\">0&nbsp;&nbsp;</span>Intro</a></span></li><li><span><a href=\"#Acceso-a-la-documentación\" data-toc-modified-id=\"Acceso-a-la-documentación-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>Acceso a la documentación</a></span></li><li><span><a href=\"#Ayudas-al-programador\" data-toc-modified-id=\"Ayudas-al-programador-2\"><span class=\"toc-item-num\">2&nbsp;&nbsp;</span>Ayudas al programador</a></span></li><li><span><a href=\"#Comandos-mágicos-de-IPython\" data-toc-modified-id=\"Comandos-mágicos-de-IPython-3\"><span class=\"toc-item-num\">3&nbsp;&nbsp;</span>Comandos mágicos de IPython</a></span></li><li><span><a href=\"#Objetos-In-y-Out\" data-toc-modified-id=\"Objetos-In-y-Out-4\"><span class=\"toc-item-num\">4&nbsp;&nbsp;</span>Objetos In y Out</a></span></li><li><span><a href=\"#Comandos-de-terminal\" data-toc-modified-id=\"Comandos-de-terminal-5\"><span class=\"toc-item-num\">5&nbsp;&nbsp;</span>Comandos de terminal</a></span></li><li><span><a href=\"#Depuración\" data-toc-modified-id=\"Depuración-6\"><span class=\"toc-item-num\">6&nbsp;&nbsp;</span>Depuración</a></span></li></ul></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Disclaimer**: Este notebook contiene mis notas sobre IPython basadas básicamente en el [capítulo 1](https://jakevdp.github.io/PythonDataScienceHandbook/01.00-ipython-beyond-normal-python.html) de [Python Data Science Handbook](https://jakevdp.github.io/PythonDataScienceHandbook/index.html) escrito por [Jake VanderPlas](http://vanderplas.com/). Recomiendo leer la fuente original e ir ejecutando todos los ejemplos (___learn by doing!___).\n",
    "\n",
    "### Intro\n",
    "\n",
    "[IPython](http://ipython.org/) es un intérprete avanzado de Python que nos proporciona un terminal interactivo con funcionalidades añadidas donde poder ejecutar, evaluar y depurar comandos o scripts. Es además el kernel de [Jupyter](https://jupyter.org/); herramienta que nos proporciona una interfaz web desde donde poder desarrollar, ejecutar, documentar, visualizar y compartir (¡lo que estás viendo es un notebook de Jupyter!).\n",
    "\n",
    "Para lanzar el intérprete de IPython simplemente tendremos que ejecutar `ipython` en nuestro terminal (podemos escribir `ipython --version` para comprobar que está disponible)\n",
    "\n",
    "En este notebook se exponen las funcionalidades básicas de IPython."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Acceso a la documentación\n",
    "\n",
    "Podemos acceder a la **documentación** de cualquier objeto (docstring) en Python usando la función `help()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function sum in module builtins:\n",
      "\n",
      "sum(iterable, start=0, /)\n",
      "    Return the sum of a 'start' value (default: 0) plus an iterable of numbers\n",
      "    \n",
      "    When the iterable is empty, return the start value.\n",
      "    This function is intended specifically for use with numeric values and may\n",
      "    reject non-numeric types.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "IPython introdujo el símbolo `?` para obtener la misma documentación pero con **información extra**. Es aplicable a funciones, a los métodos de un objeto, a variables, etc.\n",
    "\n",
    "En la consola obtendremos la información justo a continuación. En Jupyter aparecerá en una ventanita."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "sum?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```ipython\n",
    "Signature: sum(iterable, start=0, /)\n",
    "Docstring:\n",
    "Return the sum of a 'start' value (default: 0) plus an iterable of numbers\n",
    "\n",
    "When the iterable is empty, return the start value.\n",
    "This function is intended specifically for use with numeric values and may\n",
    "reject non-numeric types.\n",
    "\n",
    "Type:      builtin_function_or_method\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos acceder al **código fuente** de un objeto en Python usando `??`. \n",
    "\n",
    "Nota: la salida será la misma que la obtenida con ? si se trata de funciones propias de Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def potencia(base, exponente):\n",
    "    '''Devuelve el resultado de elevar la base al exponente'''\n",
    "    return base**exp\n",
    "\n",
    "potencia??"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```ipython\n",
    "Signature: potencia(base, exponente)\n",
    "Source:   \n",
    "def potencia(base, exponente):\n",
    "    '''Devuelve el resultado de elevar la base al exponente'''\n",
    "    return base**exp\n",
    "File:      c:\\users\\yago\\dropbox\\dev\\projects\\notebooks\\python3-101\\<ipython-input-13-f604adecc4ad>\n",
    "Type:      function\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ayudas al programador\n",
    "\n",
    "Podemos usar el `tabulador` en cualquier momento para completar el nombre de una variable, función, clase, paquete o módulo. \n",
    "\n",
    "Si lo pulsamos después de escribir el nombre de un objeto y un punto, tendremos todas las funciones disponibles para ejecutar sobre el mismo.\n",
    "\n",
    "Si lo pulsamos después de escribir import también obtendremos todas las opciones.\n",
    "\n",
    "```ipython\n",
    "In [ ]: from math import <TAB>\n",
    "         acos()      atan()      copysign()  e           expm1()     fmod()      gcd()       isfinite()  lgamma()\n",
    "         acosh()     atan2()     cos()       erf()       fabs()      frexp()     hypot()     isinf()     log()\n",
    "         asin()      atanh()     cosh()      erfc()      factorial() fsum()      inf         isnan()     log10()  >\n",
    "         asinh()     ceil()      degrees()   exp()       floor()     gamma()     isclose()   ldexp()     log1p()\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos usar el `*` como **comodín** para búsquedas\n",
    "\n",
    "```ipython\n",
    "In [ ]: *Exception?\n",
    "BaseException\n",
    "Exception\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos utilizar los **atajos de teclado** propios de un terminal unix.\n",
    "\n",
    "Aparte de los más conocidos tenemos:\n",
    "\n",
    "* `ctrl+r`: buscar en el historial de comandos\n",
    "* `ctrl+c`: interrumpir el comando actual\n",
    "* `ctrl+d`: salir de iPython\n",
    "\n",
    "Podemos averiguar en qué paquete/módulo está incluida una función, o sus parámetros, simplemente escribiendo su nombre. Es útil si queremos acotar los imports a la hora de crear nuestros scripts finales:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function IPython.core.display.display(*objs, include=None, exclude=None, metadata=None, transient=None, display_id=None, **kwargs)>"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "display"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Comandos mágicos de IPython\n",
    "\n",
    "Por un lado tenemos los comandos de una línea (o *magia de línea*) precedidos por el símbolo `%`. Por otro están los comandos multilínea (o *magia de celda*) precedidos por `%%`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/json": {
       "cell": {
        "!": "OSMagics",
        "HTML": "Other",
        "SVG": "Other",
        "bash": "Other",
        "capture": "ExecutionMagics",
        "cmd": "Other",
        "debug": "ExecutionMagics",
        "file": "Other",
        "html": "DisplayMagics",
        "javascript": "DisplayMagics",
        "js": "DisplayMagics",
        "latex": "DisplayMagics",
        "markdown": "DisplayMagics",
        "perl": "Other",
        "prun": "ExecutionMagics",
        "pypy": "Other",
        "python": "Other",
        "python2": "Other",
        "python3": "Other",
        "ruby": "Other",
        "script": "ScriptMagics",
        "sh": "Other",
        "svg": "DisplayMagics",
        "sx": "OSMagics",
        "system": "OSMagics",
        "time": "ExecutionMagics",
        "timeit": "ExecutionMagics",
        "writefile": "OSMagics"
       },
       "line": {
        "alias": "OSMagics",
        "alias_magic": "BasicMagics",
        "autoawait": "AsyncMagics",
        "autocall": "AutoMagics",
        "automagic": "AutoMagics",
        "autosave": "KernelMagics",
        "bookmark": "OSMagics",
        "cd": "OSMagics",
        "clear": "KernelMagics",
        "cls": "KernelMagics",
        "colors": "BasicMagics",
        "conda": "PackagingMagics",
        "config": "ConfigMagics",
        "connect_info": "KernelMagics",
        "copy": "Other",
        "ddir": "Other",
        "debug": "ExecutionMagics",
        "dhist": "OSMagics",
        "dirs": "OSMagics",
        "doctest_mode": "BasicMagics",
        "echo": "Other",
        "ed": "Other",
        "edit": "KernelMagics",
        "env": "OSMagics",
        "gui": "BasicMagics",
        "hist": "Other",
        "history": "HistoryMagics",
        "killbgscripts": "ScriptMagics",
        "ldir": "Other",
        "less": "KernelMagics",
        "load": "CodeMagics",
        "load_ext": "ExtensionMagics",
        "loadpy": "CodeMagics",
        "logoff": "LoggingMagics",
        "logon": "LoggingMagics",
        "logstart": "LoggingMagics",
        "logstate": "LoggingMagics",
        "logstop": "LoggingMagics",
        "ls": "Other",
        "lsmagic": "BasicMagics",
        "macro": "ExecutionMagics",
        "magic": "BasicMagics",
        "matplotlib": "PylabMagics",
        "mkdir": "Other",
        "more": "KernelMagics",
        "notebook": "BasicMagics",
        "page": "BasicMagics",
        "pastebin": "CodeMagics",
        "pdb": "ExecutionMagics",
        "pdef": "NamespaceMagics",
        "pdoc": "NamespaceMagics",
        "pfile": "NamespaceMagics",
        "pinfo": "NamespaceMagics",
        "pinfo2": "NamespaceMagics",
        "pip": "PackagingMagics",
        "popd": "OSMagics",
        "pprint": "BasicMagics",
        "precision": "BasicMagics",
        "prun": "ExecutionMagics",
        "psearch": "NamespaceMagics",
        "psource": "NamespaceMagics",
        "pushd": "OSMagics",
        "pwd": "OSMagics",
        "pycat": "OSMagics",
        "pylab": "PylabMagics",
        "qtconsole": "KernelMagics",
        "quickref": "BasicMagics",
        "recall": "HistoryMagics",
        "rehashx": "OSMagics",
        "reload_ext": "ExtensionMagics",
        "ren": "Other",
        "rep": "Other",
        "rerun": "HistoryMagics",
        "reset": "NamespaceMagics",
        "reset_selective": "NamespaceMagics",
        "rmdir": "Other",
        "run": "ExecutionMagics",
        "save": "CodeMagics",
        "sc": "OSMagics",
        "set_env": "OSMagics",
        "store": "StoreMagics",
        "sx": "OSMagics",
        "system": "OSMagics",
        "tb": "ExecutionMagics",
        "time": "ExecutionMagics",
        "timeit": "ExecutionMagics",
        "unalias": "OSMagics",
        "unload_ext": "ExtensionMagics",
        "who": "NamespaceMagics",
        "who_ls": "NamespaceMagics",
        "whos": "NamespaceMagics",
        "xdel": "NamespaceMagics",
        "xmode": "BasicMagics"
       }
      },
      "text/plain": [
       "Available line magics:\n",
       "%alias  %alias_magic  %autoawait  %autocall  %automagic  %autosave  %bookmark  %cd  %clear  %cls  %colors  %conda  %config  %connect_info  %copy  %ddir  %debug  %dhist  %dirs  %doctest_mode  %echo  %ed  %edit  %env  %gui  %hist  %history  %killbgscripts  %ldir  %less  %load  %load_ext  %loadpy  %logoff  %logon  %logstart  %logstate  %logstop  %ls  %lsmagic  %macro  %magic  %matplotlib  %mkdir  %more  %notebook  %page  %pastebin  %pdb  %pdef  %pdoc  %pfile  %pinfo  %pinfo2  %pip  %popd  %pprint  %precision  %prun  %psearch  %psource  %pushd  %pwd  %pycat  %pylab  %qtconsole  %quickref  %recall  %rehashx  %reload_ext  %ren  %rep  %rerun  %reset  %reset_selective  %rmdir  %run  %save  %sc  %set_env  %store  %sx  %system  %tb  %time  %timeit  %unalias  %unload_ext  %who  %who_ls  %whos  %xdel  %xmode\n",
       "\n",
       "Available cell magics:\n",
       "%%!  %%HTML  %%SVG  %%bash  %%capture  %%cmd  %%debug  %%file  %%html  %%javascript  %%js  %%latex  %%markdown  %%perl  %%prun  %%pypy  %%python  %%python2  %%python3  %%ruby  %%script  %%sh  %%svg  %%sx  %%system  %%time  %%timeit  %%writefile\n",
       "\n",
       "Automagic is ON, % prefix IS NOT needed for line magics."
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%lsmagic"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Utilidad**\n",
    "\n",
    "* `%magic`: ayuda sobre los comandos mágicos\n",
    "* `%lsmagic`: imprime todos los comandos mágicos\n",
    "\n",
    "\n",
    "* `%history`: imprime el historial de comandos\n",
    "* `%rerun`: re-ejecuta una porción del historial\n",
    "* `%save`: guarda parte del historial en un fichero\n",
    "\n",
    "\n",
    "* `%paste`: usado antes de pegar código copiado de otro sitio, para evitar posibles problemas de formato.\n",
    "* `%cpaste`: igual uso que %paste pero nos permite pegar más de una porción de código.\n",
    "* `%run _`: para ejecutar un script externo.\n",
    "\n",
    "\n",
    "* `%timeit _`: para determinar el tiempo de ejecución del código a continuación, realizando múltiples repeticiones y devolviendo la media. Sirve para comparar la eficiencia de distintas soluciones para implementar la misma funcionalidad.\n",
    "* `%time _`: igual que %timeit pero sin repeticiones. Ideal para el caso en que las repeticiones no tardarían lo mismo porque algún objeto se va modificando y los tiempos cambian.\n",
    "\n",
    "\n",
    "* `%prun _`: realiza un perfil/profile del comando a continuación. Evalúa en qué funciones se va el tiempo de ejecución.\n",
    "\n",
    "\n",
    "Paquete **`line_profiler`**:\n",
    "* `%load_ext line_profiler`: carga el paquete en IPython\n",
    "* `%lprun _`: igual que %prun pero a nivel de línea\n",
    "\n",
    "\n",
    "Paquete **`memory_profiler`**:\n",
    "* `%memit _`: evalúa la memoria utilizada por el comando\n",
    "* `%mprun _`: evalúa la memoria consumida a nivel de línea por un comando importado previamente de un fichero\n",
    "\n",
    "\n",
    "Para más información sobre los comandos mágicos...\n",
    "* `%comando?`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si automagic está activado, podremos usar los comandos mágicos sin necesidad de poner el % delante. Esto nos permite usar comandos de IPython como si se tratara de un terminal normal."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Objetos In y Out\n",
    "\n",
    "El objeto `In` es una lista ordenada que contiene las entradas anteriores.\n",
    "El objeto `Out` es un diccionario con las salidas anteriores; la clave es el número de entrada, y el valor es el resultado de ejecutar la misma.\n",
    "\n",
    "Podremos operar con los resultados de distintas operaciones como lo haríamos con otras variables."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ejemplo que genera una salida\n",
    "a = 3\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Otro ejemplo\n",
    "b = a**2\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['', 'help(sum)', \"get_ipython().run_line_magic('pinfo', 'sum')\", \"def potencia(base, exponente):\\n    '''Devuelve el resultado de elevar la base al exponente'''\\n    return base**exp\\n\\nget_ipython().run_line_magic('pinfo2', 'potencia')\", 'display', \"get_ipython().run_line_magic('lsmagic', '')\", '# Ejemplo que genera una salida\\na = 3\\na', '# Otro ejemplo\\nb = a**2\\nb', 'print(In)']\n"
     ]
    }
   ],
   "source": [
    "print(In)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{4: <function display at 0x000001E43A6EE0D8>, 5: <IPython.core.magics.basic.MagicsDisplay object at 0x000001E43C5EDCC8>, 6: 3, 7: 9}\n"
     ]
    }
   ],
   "source": [
    "print(Out)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En el terminal estándar de Python podemos acceder al último resultado escribiendo un `_` (guión bajo). En IPython podemos acceder además al penúltimo y el antepenúltimo usando 2 y 3 guiones respectivamente. \n",
    "\n",
    "NOTA: También podemos acceder a un resultado concreto de Out usando la clave correspondiente, mediante `Out[x]` o `_x`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    }
   ],
   "source": [
    "print(_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "print(__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "  ### Comandos de terminal\n",
    "  \n",
    "  IPython nos permite ejecutar comandos propios de un terminal unix, simplemente precediéndolos del símbolo de exclamación `!`. Estos comandos serán ejecutados por el sistema en lugar del kernel de Python.\n",
    "  \n",
    "  NOTA: hay algunos comandos que no funcionan (!cd no cambia de directorio), pero con suerte tendremos un comando mágico equivalente (%cd)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "images\n",
      "plano.png\n",
      "python3_basics_es.ipynb\n",
      "python3_builtin_es.ipynb\n",
      "python3_ipython_es.ipynb\n",
      "python3_matplotlib_es.ipynb\n",
      "python3_numpy_es.ipynb\n",
      "python3_pandas_es.ipynb\n",
      "python3_scikitlearn_es.ipynb\n",
      "README.md\n"
     ]
    }
   ],
   "source": [
    "!ls"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos asignar la salida de un comando a una variable:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'IPython.utils.text.SList'>\n",
      "['images', 'plano.png', 'python3_basics_es.ipynb', 'python3_builtin_es.ipynb', 'python3_ipython_es.ipynb', 'python3_matplotlib_es.ipynb', 'python3_numpy_es.ipynb', 'python3_pandas_es.ipynb', 'python3_scikitlearn_es.ipynb', 'README.md']\n"
     ]
    }
   ],
   "source": [
    "ficheros = !ls\n",
    "print(type(ficheros))\n",
    "print(ficheros)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La lista obtenida es de un tipo especial, que nos permite usar los métodos `grep()` y `fields()`, o las propiedades `s`, `n`, `p`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['python3_ipython_es.ipynb']\n"
     ]
    }
   ],
   "source": [
    "print(ficheros.grep('ipython'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "También podemos acceder a una variable de Python desde un comando unix:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    }
   ],
   "source": [
    "!echo {b}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Depuración\n",
    "\n",
    "Cuando ocurre un error al ejecutar un comando o celda en IPython, se imprimirán las trazas del mismo. Podemos usar el comando mágico `%xmode` para cambiar el modo, usando uno de los parámetros disponibles:\n",
    "\n",
    "* `%xmode Context`: imprime información por defecto\n",
    "* `%xmode Verbose`: imprime información extra\n",
    "* `%xmode Plain`: imprime menos información\n",
    "\n",
    "Como es natural, hay veces en que esto no será suficiente. En Python la herramienta estándar para depurar es `pdb`. La versión mejorada e interactiva para IPython se llama `ipdb`. Tendremos disponibles los siguientes comandos:\n",
    "\n",
    "* `%debug`: ejecutado después de un error lanzará ipdb en el punto del error\n",
    " * `print`: imprime una variable\n",
    " * `up`: sale a la función anterior\n",
    " * `down`: entra a la función posterior\n",
    " * `quit`: salir\n",
    "* `%pdb on`: activa la ejecución de ipdb automáticamente cuando ocurra un error\n",
    "* `%run -d script.py`: para depurar un script\n",
    " * `n(ext)`: ejecuta la siguiente línea\n",
    " * `c(ontinue)`: para parar la depuración y seguir ejecutando el programa hasta el final\n",
    " * `p(rint)`: imprime variables\n",
    " * `s(tep)`: entra en una subrutina\n",
    " * `r(eturn)`: sale de una subrutina\n",
    " * `list`: muestra la posición actual en el script\n",
    " * `h(elp)`: muestra la lista de comandos, o ayuda sobre uno de ellos\n",
    " * `q(uit)`: salir"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.5"
  },
  "toc": {
   "base_numbering": "0",
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Mis notas: IPython",
   "title_sidebar": "Contents",
   "toc_cell": true,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}