jupyter_notebook.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![logo jupyter](imagenes/logo_jupyter.jpg)\n",
    "\n",
    "# Jupyter Notebook.\n",
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[*Jupyter Notebook*](https://www.jupyter.org) es una herramienta de desarrollo para facilitar la programación interactiva orientada a la *Computación Científica* y a la *Ciencia de Datos*. Es un entorno de computación interactivo *agnóstico*, ya que es posible usarlo con otros lenguajes como _R_, *Julia* y muchos otros, además de *Python*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Instalación."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para instalar *Jupyter Notebook* debe tener antes instalado *Python*, al menos en la versión 3.3+. *Python* puede descargarse desde el [sitio web](https://www.python.org/downloads/) de *Python*. También es posible que en su distribución Linux/OS-X *Python* ya esté instalado, o también puede instalarlo como uno de los paquetes incluídos en [*Anaconda*](https://www.anaconda.com/distribution/).\n",
    "\n",
    "Para instalar *Jupyter Notebook* usted deberá:\n",
    "1. Abrir una cónsola o terminal de comandos desde su sistema operativo.\n",
    "2. En la línea de comandos deberá escribir `pip install jupyter` y presionar ENTER.\n",
    "3. *Python* se descargará e instalará las librerías necesarias para utilizar *Jupyter Notebook*.\n",
    "4. Para ejecutar *Jupyter Notebook*, deberá escribir en la línea de comandos la instrucción: `jupyter notebook` y presionar Enter.\n",
    "\n",
    "\n",
    "A continuación veremos algunas de las características más importantes de *Jupyter Notebook*. Muchas de estas características pueden sonar un poco abstractas al principio, pero su utilidad se hará evidente con el uso y a medida que aprendamos *Python*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Markdown."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Jupyter* permite que escribamos texto formateado, es decir texto con cursiva, negritas, títulos de distintos tamaños, etc., de forma simple. Para ello *Jupyter* nos permite usar *Markdown*, que es un lenguaje de marcado (markup) muy popular. Los lenguajes de markup son lenguajes ideados para procesar texto, algunos de los más conocidos son [HTML](https://es.wikipedia.org/wiki/HTML) y $\\LaTeX$. *Markdown* tiene como objetivo ser un lenguaje de sintaxis minimalista, simple de aprender y usar; de esa forma uno puede dar formato al texto pero sin perder demasiado tiempo en los detalles.\n",
    "\n",
    "La cantidad de [tutoriales](https://joedicastro.com/pages/markdown.html) en la red sobre *Markdown* es inmenso, por lo que nos centraremos en indicar las opciones que más se utilizan.\n",
    "\n",
    "* Texto en negrita/cursiva: El texto en negrita se indica entre dos pares de asteriscos. De este modo `**palabra**` aparecerá como **palabra**. Por otro lado, el texto en cursiva se indica entre dos asteriscos simples; es decir `*palabra*` aparecerá como *palabra*.\n",
    "\n",
    "\n",
    "* Listas: Las listas en *Markdown* se realizan indicando un asterisco o un número seguido de un punto si se desean listas numeradas. *Markdown* organiza automáticamente los items asignándoles el número correcto.\n",
    "\n",
    "\n",
    "* Inclusión de imágenes: La sintaxis para incluir imágenes en Markdown es `![nombre alternativo](dirección de la imagen)` en donde el nombre alternativo aparecerá en caso de que no se pueda cargar la imágen y la dirección puede referirse a una imagen local o un enlace en Internet.\n",
    "\n",
    "\n",
    "* Inclusión de código HTML: El lenguaje *Markdown* es un subconjunto del lenguaje HTML y en donde se necesite un mayor control del formato, se puede incluir directamente el código HTML.\n",
    "\n",
    "\n",
    "* Enlaces: Las celdas de texto pueden contener enlaces, tanto a otras partes del documento, como a páginas en internet u otros archivos locales. Su sintaxis es `[texto](dirección del enlace)`.\n",
    "\n",
    "\n",
    "* Fórmulas matemáticas: Gracias al uso de *MathJax*, se puede incluir código en $\\LaTeX$ para mostrar todo tipo de fórmulas y expresiones matemáticas. Las fórmulas dentro de una línea de texto se escriben entre símbolos de dólar `$...$`, mientras que las expresiones separadas del texto utilizan símbolos de dólar dobles `$$...$$`. Los siguientes son ejemplos de fórmulas matemáticas escritas en $\\LaTeX$:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$p(x) = 3x^2 + 5y^2 + x^2y^2$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$e^{\\pi i} - 1 = 0$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\\lim_{x \\rightarrow \\infty} 3x+1$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\\sum_{n=1}^\\infty\\frac{1}{n^2}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\\int_0^\\infty\\frac{\\sin x}{x}\\,\\mathrm{d}x=\\frac{\\pi}{2}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$R^2 = \n",
    "\\begin{pmatrix} c & s \\end{pmatrix} \n",
    "\\begin{pmatrix} 1 & 0\\\\ 0 & 1 \\end{pmatrix}\n",
    "\\begin{pmatrix} c \\\\ s \\end{pmatrix} \n",
    "= c^2 + s^2$$\n",
    "\n",
    "En esta [**guía**](documentos/guia_latex_formulas_matematicas.pdf) puede encontrar todos los comandos necesarios para escribir fórmulas matemáticas en $\\LaTeX$.\n",
    "\n",
    "Estas posibilidades de formato en *Jupyter Notebook* nos permiten utilizar las celdas de texto de manera versátil, documentando el código de otras celdas o, por ejemplo, explicando detalladamente algún concepto teórico del que después podamos presentar un ejercicio. Esta [**guía online**](https://joedicastro.com/pages/markdown.html) nos ofrece el resto de las opciones para trabajar con *Markdown*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Completado mediantes Tabs."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cuando se escriben programas es necesario recordar ciertas palabras claves, opciones, nombres de archivos, etc. Aún con práctica uno puede olvidarse del nombre de algún comando o es posible que estemos intentando usar una librería nueva y no sepamos las opciones que ofrece. Una forma en la que *Jupyter* nos ayuda en estos casos es brindándonos sugerencias. El funcionamiento es simple, el usuario escribe uno o más caracteres seguidos de un tab (tabulación) y *Jupyter* intentará autocompletar el comando u ofrecer un listado de posibles opciones."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Buscando ayuda."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En caso de necesitar ayuda sobre cualquier comando de *Python*, *Jupyter* nos ofrece una función llamada `help`. Esta función es muy útil en el trabajo del día a día, ya que es difícil que recordemos siempre todas las opciones disponibles de todos los comandos que usamos, y además estás opciones pueden cambiar con el tiempo o puede que estemos explorando un comando o librería nueva, por lo que no hay forma que conozcamos siempre todas las opciones disponibles. En resumen, ¡suele ser más importante saber como buscar información que memorizarla! Por todo esto, *Jupyter* nos ofrece ayuda sobre cualquier comando agregando un signo de interrogación `?` luego del nombre del comando (y luego ejecutar la celda con la combinación de teclas SHIFT + ENTER). Por ejemplo, existe un comando en *Python* que se llama *range*, que seguramente será desconocido para ustedes; pero no hay problema, ya que *Jupyter* nos brinda información de este comando al escribir `range?`, tal y como se muestra en la siguente celda:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "range?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lo cual nos arrojaría el siguiente texto en una ventana anexa:\n",
    "```python\n",
    "Init signature: range(self, /, *args, **kwargs)\n",
    "Docstring:     \n",
    "range(stop) -> range object\n",
    "range(start, stop[, step]) -> range object\n",
    "\n",
    "Return an object that produces a sequence of integers from start (inclusive)\n",
    "to stop (exclusive) by step.  range(i, j) produces i, i+1, i+2, ..., j-1.\n",
    "start defaults to 0, and stop is omitted!  range(4) produces 0, 1, 2, 3.\n",
    "These are exactly the valid indices for a list of 4 elements.\n",
    "When step is given, it specifies the increment (or decrement).\n",
    "Type:           type\n",
    "Subclasses:     ```\n",
    "\n",
    "Si quisieramos saber más sobre *Jupyter* podemos simplemente teclear `?` y ejecutar la celda con la combinación de teclas SHIFT + ENTER:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Y obtendríamos una ventana anexa con el texto y el siguiente encabezado:\n",
    "```python\n",
    "IPython -- An enhanced Interactive Python\n",
    "=========================================\n",
    "\n",
    "IPython offers a fully compatible replacement for the standard Python\n",
    "interpreter, with convenient shell features, special commands, command\n",
    "history mechanism and output results caching.\n",
    "\n",
    "At your system command line, type 'ipython -h' to see the command line\n",
    "options available. This document only describes interactive features.\n",
    "\n",
    "GETTING HELP\n",
    "------------```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A medida que aprendamos más *Python* llegará el momento en que nos sea de utilidad leer el *código fuente* del comando que queramos utilizar. El código fuente es básicamente el conjunto de instrucciones que hace que un comando funcione como funcione. *Jupyter* permite tener acceso a esta información usando el comando `??`. Por ejemplo, la siguiente línea muestra el código fuente del comando `%timeit`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "%timeit??"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Con *Jupyter* también es posible usar el signo `*` como comodín. Imaginen que sabemos que hay un comando que empieza con \"in\" pero no recordamos cómo sigue. En ese caso podemos hacer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "in*?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Y obtenemos una ventana con el texto:\n",
    "```python\n",
    "input\n",
    "int```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Luego también podríamos recordar que no es que empezara en \"in\", sino que terminaba en \"in\", entonces podemos hacer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "*in?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Con lo que obtendríamos el siguiente texto en una nueva ventana:\n",
    "```python\n",
    "bin\n",
    "min```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "¿y si quisiéramos consultar todos los comando que tengan la particula \"in\" en aǵun sitio?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "*in*?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Obtendríamos el siguiente texto en una nueva ventana:\n",
    "```python\n",
    "BlockingIOError\n",
    "BytesWarning\n",
    "DeprecationWarning\n",
    "FloatingPointError\n",
    "FutureWarning\n",
    "ImportWarning\n",
    "PendingDeprecationWarning\n",
    "ResourceWarning\n",
    "RuntimeWarning\n",
    "SyntaxWarning\n",
    "UnicodeWarning\n",
    "UserWarning\n",
    "Warning\n",
    "__builtin__\n",
    "__builtins__\n",
    "bin\n",
    "input\n",
    "int\n",
    "isinstance\n",
    "min\n",
    "print```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Magias (magics)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Jupyter* posee varias funciones *mágicas* predefinidas que sirven para simplificar tareas comunes.\n",
    "\n",
    "Hay dos tipos de *magias*:\n",
    "\n",
    "* Magias por linea (line magics): son comandos que empiezan con el caracter `%` y que toman como argumentos valores escritos en la misma línea.\n",
    "\n",
    "\n",
    "* Magias por celda (cell magics): son comandos que empiezan con los caracteres `%%`, y que reciben argumentos en la misma línea y en toda la celda. En general solo se puede usar una sola mágias por celda en cada celda y **debe ser escrita en la primer linea de la celda**.\n",
    "\n",
    "Un buen ejemplo de mágia es `%lsmagic` que lista todas las *magias* disponibles:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/json": {
       "cell": {
        "!": "OSMagics",
        "HTML": "Other",
        "SVG": "Other",
        "bash": "Other",
        "capture": "ExecutionMagics",
        "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",
        "cat": "Other",
        "cd": "OSMagics",
        "clear": "KernelMagics",
        "colors": "BasicMagics",
        "conda": "PackagingMagics",
        "config": "ConfigMagics",
        "connect_info": "KernelMagics",
        "cp": "Other",
        "debug": "ExecutionMagics",
        "dhist": "OSMagics",
        "dirs": "OSMagics",
        "doctest_mode": "BasicMagics",
        "ed": "Other",
        "edit": "KernelMagics",
        "env": "OSMagics",
        "gui": "BasicMagics",
        "hist": "Other",
        "history": "HistoryMagics",
        "killbgscripts": "ScriptMagics",
        "ldir": "Other",
        "less": "KernelMagics",
        "lf": "Other",
        "lk": "Other",
        "ll": "Other",
        "load": "CodeMagics",
        "load_ext": "ExtensionMagics",
        "loadpy": "CodeMagics",
        "logoff": "LoggingMagics",
        "logon": "LoggingMagics",
        "logstart": "LoggingMagics",
        "logstate": "LoggingMagics",
        "logstop": "LoggingMagics",
        "ls": "Other",
        "lsmagic": "BasicMagics",
        "lx": "Other",
        "macro": "ExecutionMagics",
        "magic": "BasicMagics",
        "man": "KernelMagics",
        "matplotlib": "PylabMagics",
        "mkdir": "Other",
        "more": "KernelMagics",
        "mv": "Other",
        "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",
        "rep": "Other",
        "rerun": "HistoryMagics",
        "reset": "NamespaceMagics",
        "reset_selective": "NamespaceMagics",
        "rm": "Other",
        "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  %cat  %cd  %clear  %colors  %conda  %config  %connect_info  %cp  %debug  %dhist  %dirs  %doctest_mode  %ed  %edit  %env  %gui  %hist  %history  %killbgscripts  %ldir  %less  %lf  %lk  %ll  %load  %load_ext  %loadpy  %logoff  %logon  %logstart  %logstate  %logstop  %ls  %lsmagic  %lx  %macro  %magic  %man  %matplotlib  %mkdir  %more  %mv  %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  %rep  %rerun  %reset  %reset_selective  %rm  %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  %%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": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%lsmagic"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En varias situaciones resulta necesario medir el tiempo de ejecución de una porción de código. Para ello podemos usar la magia `%timeit`. Esta *magia* está disponible tanto para línea como para celda:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13.8 ns ± 0.248 ns per loop (mean ± std. dev. of 7 runs, 100000000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit 1+1 # timeit repite (adaptativamente) la medición a fin de reducir el error."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Jupyter* permite también mezclar varios lenguajes de programación en una misma notebook. Por ejemplo, podríamos escribir en *bash* lo siguiente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "2\n",
      "1\n",
      "Hola desde /bin/bash\n"
     ]
    }
   ],
   "source": [
    "%%bash\n",
    "for i in {3..1}; do\n",
    "    echo $i\n",
    "done\n",
    "echo \"Hola desde $BASH\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El comando `%quickref` provee una ayuda rápida sobre *Jupyter*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "%quickref"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El cual muestra una nueva ventana con la cabecera de texto:\n",
    "\n",
    "```python\n",
    "IPython -- An enhanced Interactive Python - Quick Reference Card\n",
    "================================================================\n",
    "\n",
    "obj?, obj??      : Get help, or more help for object (also works as\n",
    "                   ?obj, ??obj).\n",
    "?foo.*abc*       : List names in 'foo' containing 'abc' in them.\n",
    "%magic           : Information about IPython's 'magic' % functions.\n",
    "\n",
    "Magic functions are prefixed by % or %%, and typically take their arguments\n",
    "without parentheses, quotes or even commas for convenience.  Line magics take a\n",
    "single % and cell magics are prefixed with two %%.```\n",
    "\n",
    "También podemos ejecutar cualquier comando del sistema operativo anteponiendo el signo `!` antes del comando. Por ejemplo, en un entorno *Linux*, para listar los archivos del directorio actual podemos escribir:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CONTRIBUTING.md  imagenes\t\t LICENSE    requirements.txt\r\n",
      "documentos\t jupyter_notebook.ipynb  README.md\r\n"
     ]
    }
   ],
   "source": [
    "!ls"
   ]
  }
 ],
 "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.5.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}