Python/clases/1_introduccion/3_funciones_y_modulos.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Notas para contenedor de docker:**\n",
    "\n",
    "Comando de docker para ejecución de la nota de forma local:\n",
    "\n",
    "nota: cambiar `dir_montar` por la ruta de directorio que se desea mapear a `/datos` dentro del contenedor de docker.\n",
    "\n",
    "```\n",
    "dir_montar=<ruta completa de mi máquina a mi directorio>#aquí colocar la ruta al directorio a montar, por ejemplo: \n",
    "#dir_montar=/Users/erick/midirectorio.\n",
    "```\n",
    "\n",
    "Ejecutar:\n",
    "\n",
    "```\n",
    "VERSION=<versión imagen de docker>\n",
    "docker run --rm -v $dir_montar:/datos --name jupyterlab_prope_r_kernel_tidyverse -p 8888:8888 -d palmoreck/jupyterlab_prope_r_kernel_tidyverse:$VERSION\n",
    "\n",
    "```\n",
    "\n",
    "Ir a `localhost:8888` y escribir el password para jupyterlab: `qwerty`\n",
    "\n",
    "\n",
    "Detener el contenedor de docker:\n",
    "\n",
    "```\n",
    "docker stop jupyterlab_prope_r_kernel_tidyverse\n",
    "```\n",
    "\n",
    "Documentación de la imagen de docker `palmoreck/jupyterlab_prope_r_kernel_tidyverse:<versión imagen de docker>` en [liga](https://github.com/palmoreck/dockerfiles/tree/master/jupyterlab/prope_r_kernel_tidyverse)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para ejecución de la nota usar:\n",
    "\n",
    "[docker](https://www.docker.com/) (instalación de forma **local** con [Get docker](https://docs.docker.com/install/)) y ejecutar comandos que están al inicio de la nota de forma **local**. \n",
    "\n",
    "O bien dar click en alguno de los botones siguientes:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/palmoreck/dockerfiles-for-binder/jupyterlab_prope_r_kernel_tidyverse?urlpath=lab/tree/Propedeutico/Python/clases/1_introduccion/3_funciones_y_modulos.ipynb) esta opción crea una máquina individual en un servidor de Google, clona el repositorio y permite la ejecución de los notebooks de jupyter."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[![Run on Repl.it](https://repl.it/badge/github/palmoreck/dummy)](https://repl.it/languages/python3) esta opción no clona el repositorio, no ejecuta los notebooks de jupyter pero permite ejecución de instrucciones de *Python* de forma colaborativa con [repl.it](https://repl.it/). Al dar click se crearán nuevos ***repl*** debajo de sus users de ***repl.it***.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Funciones y módulos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funciones"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La estructura general de una función en *Python* es:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func(param1, param2): #puede haber más parámetros\n",
    "    #statements\n",
    "    return #return_values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "donde: `param1`, `param2` son los parámetros.\n",
    "\n",
    "Una función puede no tener `return` statement con lo que se regresará un objeto `Null`. \n",
    "\n",
    "Un parámetro puede ser cualquier objeto de *Python* incluyendo una función. Los parámetros se les puede dar valores por *default*, en cuyo caso al llamar a la función es opcional escribir los parámetros por ejemplo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Así llamamos a la función anterior\n",
    "p1 = 2\n",
    "p2 = -5\n",
    "func(p1, p2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func(param1, param2=0):\n",
    "    #statements\n",
    "    return #return_values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Así podemos llamar a la función func con parámetro de default\n",
    "p1 = 2\n",
    "func(p1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "**Observación**\n",
    "\n",
    "Es común utilizar el nombre de párametros y argumentos como sinónimos, sin embargo sí existe diferencia: el nombre **parámetros** se utiliza dentro de funciones y el nombre **argumentos** se utiliza en llamadas a funciones, esto es, los valores que se le pasan a la función. En el ejemplo anterior p1 es una variable con valor 2 y en la línea `func(p1)` p1 es el argumento de func y en la definición de `func`, `param1`, `param2` son parámetros.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejercicio:**\n",
    "\n",
    "Dado el siguiente *string* intercambiar la ocurrencia `<name>` por un nombre definido por uds. Esto realizarlo en un archivo con extensión `.py` y escribir el resultado en un archivo de nombre `queen_of_Katoren.txt` utilizando `with` y [context-manager](https://book.pythontips.com/en/latest/context_managers.html#context-managers). Ejecutarlo en [repl.it](http://repl.it) y mostrar funcionalidad del comando de magic `%%file`  para escribir el `.py` en jupyterlab y también ejecutarlo en jupyterlab con el comando `%%bash`.\n",
    "\n",
    "Para referencias de los comandos de magic ver [magics](https://ipython.readthedocs.io/en/stable/interactive/magics.html).\n",
    "\n",
    "a) Realizarlo con listas y métodos de *strings*.\n",
    "\n",
    "b) Realizarlo con [re](https://docs.python.org/3/library/re.html).\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Solución a)**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "string = \"\"\"The merry old queen of Katoren has died\n",
    "and there’s no heir to the throne. Six sour ministers rule the land\n",
    "and claim that they’re looking for a new queen,\n",
    "but nothing happens – for seventeen years. \n",
    "Then suddenly there’s a girl standing at the door of the royal\n",
    "palace who was born on the night the queen died.\n",
    "\n",
    "This girl, <name> , has firmly resolved to become the new queen of Katoren and\n",
    "she asks the six ministers what she must do in order to be considered for \n",
    "the role. The ministers, afraid of losing their splendid position at court, give the\n",
    "girl seven almost impossible tasks, which can be brought to a successful\n",
    "conclusion only by one who possesses royal attributes such as wisdom,\n",
    "courage and self-sacrifice. The six ministers are convinced that <name> will fall\n",
    "at the first hurdle, but she turns out to have an amazing amount of\n",
    "persistence and ingenuity.\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Parámetros posicionales, *excess parameters* y *packing-unpacking*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El número de parámetros de entrada en la definición de una función puede dejarse de forma arbitraria. Por ejemplo en la definición: \n",
    "\n",
    "```\n",
    "def func(x1,x2,*x3)\n",
    "```\n",
    "\n",
    "x1 y x2 son parámetros posicionales y x3 es una *tuple* de longitud arbitraria que contiene *excess parameters*. Al llamar a la función anterior con:\n",
    "\n",
    "```\n",
    "func(a,b,c,d,e)\n",
    "```\n",
    "\n",
    "resulta en la siguiente correspondencia entre los parámetros:\n",
    "\n",
    "```\n",
    "a<->x1, b<->x2, (c,d,e)<->x3\n",
    "```\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "**Observación**\n",
    "\n",
    "Los parámetros posicionales siempre deben estar antes que los *excess parameters*.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El operador `*` en este caso está realizando un *packing* de los *excess parameters*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejemplo**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func(x,*y):\n",
    "    print(x)\n",
    "    print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-1\n",
      "()\n"
     ]
    }
   ],
   "source": [
    "func(-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "('Ejemplo', 4, 'excess', -1, 'parameters')\n"
     ]
    }
   ],
   "source": [
    "func(3,'Ejemplo', 4, 'excess',-1, 'parameters')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "y se podría haber llamado a `func` con:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "('Ejemplo', 4, 'excess', -1, 'parameters')\n"
     ]
    }
   ],
   "source": [
    "tup = ('Ejemplo', 4, 'excess',-1, 'parameters')\n",
    "func(3, tup[0], tup[1], tup[2], tup[3], tup[4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O bien realizar un *unpacking* de la variable *tup*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "('Ejemplo', 4, 'excess', -1, 'parameters')\n"
     ]
    }
   ],
   "source": [
    "func(3,*tup)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si se utiliza el operador `**` en los *excess parameters* se indica que se recibe un diccionario, por ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func(x, **y):\n",
    "    print(x)\n",
    "    print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-1\n",
      "{}\n"
     ]
    }
   ],
   "source": [
    "func(-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lo que se realizó fue un *packing* de los *excess parameters*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para mandar a llamar a la función se realiza un *unpacking* con el operador `**`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "{'k': 1, 'k3': 'cadena'}\n"
     ]
    }
   ],
   "source": [
    "func(3, **{'k': 1, 'k3': 'cadena'})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "y se podría haber llamado `func`con:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "{'k': 1, 'k3': 'cadena'}\n"
     ]
    }
   ],
   "source": [
    "dic = {'k': 1, 'k3': 'cadena'}\n",
    "func(3, k=dic['k'], k3=dic['k3'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "o bien realizar un *unpacking* de la variable *dic*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "{'k': 1, 'k3': 'cadena'}\n"
     ]
    }
   ],
   "source": [
    "func(3,**dic)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### *Key-words arguments*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las funciones también pueden ser llamadas en la forma `kwarg = value`. Por ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func(par_posicional, kwpar1 = 'un día', kwpar2 = 'como hoy'):\n",
    "    print('mi par posicional:', par_posicional)\n",
    "    print('mi key-word parameter 1:', kwpar1)\n",
    "    print('mi key-word parameter 2:', kwpar2)\n",
    "    print(kwpar1, kwpar2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mi par posicional: 3\n",
      "mi key-word parameter 1: un día\n",
      "mi key-word parameter 2: como hoy\n",
      "un día como hoy\n",
      "----------\n",
      "mi par posicional: 3\n",
      "mi key-word parameter 1: un día\n",
      "mi key-word parameter 2: como hoy\n",
      "un día como hoy\n",
      "----------\n",
      "mi par posicional: -1\n",
      "mi key-word parameter 1: un día\n",
      "mi key-word parameter 2: lluvioso\n",
      "un día lluvioso\n",
      "----------\n",
      "mi par posicional: 5\n",
      "mi key-word parameter 1: el día de hoy está\n",
      "mi key-word parameter 2: soleado\n",
      "el día de hoy está soleado\n"
     ]
    }
   ],
   "source": [
    "#Obsérvese que al llamar a la función los argumentos posicionales preceden a los key words arguments\n",
    "#y esto debe ser así para evitar errores en los llamados a la función\n",
    "\n",
    "func(3) #argumento posicional\n",
    "print('-'*10)\n",
    "func(par_posicional = 3) #1 key-word argument\n",
    "print('-'*10)\n",
    "func(par_posicional = -1, kwpar2 = 'lluvioso') #2 key-words arguments\n",
    "print('-'*10)\n",
    "func(5, kwpar2 = 'soleado', kwpar1 = 'el día de hoy está') #2 key-words arguments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejemplo**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func(a,b,c,x,y):\n",
    "    print(a,b,c,x,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 -1 2 uno -2\n"
     ]
    }
   ],
   "source": [
    "tup = (-1,2)\n",
    "dic = {'x': 'uno', 'y': -2}\n",
    "func(10,*tup,**dic)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejemplo**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func2(*t): #el parámetro t es un excess parameter y está packed\n",
    "    x,h = t\n",
    "    result = x+h\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1.1700e+00'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x_arg = 1.16\n",
    "h_arg = 1e-2\n",
    "tup = (x_arg, h_arg)\n",
    "\"{:0.4e}\".format(func2(*tup))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejemplo con *keyword arguments***"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func3(x,h):\n",
    "    return (x-h, x+h)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "dic = {\"x\": 1.16, \"h\": 1e-2}\n",
    "res1, res2 = func3(**dic)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.1500e+00\t1.1700e+00\n"
     ]
    }
   ],
   "source": [
    "print(\"{:0.4e}\\t{:0.4e}\".format(res1, res2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "dic2 = {\"h\": 1e-2, \"x\": 1.16}\n",
    "res1, res2 = func3(**dic2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.1500e+00\t1.1700e+00\n"
     ]
    }
   ],
   "source": [
    "print(\"{:0.4e}\\t{:0.4e}\".format(res1, res2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### *Lambda statement*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es conveniente utilizar este *statement* para definir funciones que realizan operaciones sencillas en su cuerpo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func(x, y):\n",
    "    return x**2+y**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "func(2,-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "lamb = lambda x,y : x**2 + y**2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "y se manda a llamar como sigue:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lamb(2,-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Módulos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Un módulo es un archivo con extensión `.py` que contiene definiciones de funciones, clases,métodos y constantes. \n",
    "El nombre del módulo es el nombre del archivo y muchos de los módulos vienen en la distribución estándar de *Python* pero otros deben instalarse con un manager para *Python packages* como `pip`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Hay tres formas de acceder a las funciones de un módulo, por ejemplo para el módulo [math](https://docs.python.org/2/library/math.html), el cual forma parte de los *builtins* de python, se puede hacer:\n",
    "\n",
    "```\n",
    "* from math import *\n",
    "* from math import func1, func2\n",
    "* import math\n",
    "```\n",
    "\n",
    "La primer forma carga todas las definiciones de funciones en el módulo `math` y **no** se recomienda por el posible conflicto que puede existir con las definiciones cargadas de otros módulos. Por ejemplo hay dos definiciones distintas de la función seno en los módulos `math` y `numpy` por lo que al importarse ambos módulos en el programa no es claro cual definición debe usarse al llamado `sin`. La segunda forma también tiene este problema.\n",
    "\n",
    "La tercer forma hace accesible el módulo `math` y para acceder a sus definiciones se utiliza el nombre del módulo como prefijo:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "math\n",
      "-0.7351666863853142\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "print(math.__name__) #nombre del módulo\n",
    "print(math.log(math.sin(0.5)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "esta última forma de realizar imports evita el problema antes planteado de no tener claridad de cuál definición debe utilizarse para cada módulo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A un módulo también se le puede dar un alias para tener acceso a sus definiciones:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-0.7351666863853142\n"
     ]
    }
   ],
   "source": [
    "import math as m\n",
    "print(m.log(m.sin(0.5)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El contenido de un módulo puede imprimirse con `dir(module)`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e', 'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'pi', 'pow', 'radians', 'sin', 'sinh', 'sqrt', 'tan', 'tanh', 'tau', 'trunc']\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "print(dir(math))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.141592653589793\n",
      "2.718281828459045\n"
     ]
    }
   ],
   "source": [
    "#Obsérvese que se tienen dos constantes:\n",
    "print(math.pi)\n",
    "print(math.e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se puede ejecutar los siguientes comandos para obtener información del módulo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in module math:\n",
      "\n",
      "NAME\n",
      "    math\n",
      "\n",
      "DESCRIPTION\n",
      "    This module is always available.  It provides access to the\n",
      "    mathematical functions defined by the C standard.\n",
      "\n",
      "FUNCTIONS\n",
      "    acos(...)\n",
      "        acos(x)\n",
      "        \n",
      "        Return the arc cosine (measured in radians) of x.\n",
      "    \n",
      "    acosh(...)\n",
      "        acosh(x)\n",
      "        \n",
      "        Return the inverse hyperbolic cosine of x.\n",
      "    \n",
      "    asin(...)\n",
      "        asin(x)\n",
      "        \n",
      "        Return the arc sine (measured in radians) of x.\n",
      "    \n",
      "    asinh(...)\n",
      "        asinh(x)\n",
      "        \n",
      "        Return the inverse hyperbolic sine of x.\n",
      "    \n",
      "    atan(...)\n",
      "        atan(x)\n",
      "        \n",
      "        Return the arc tangent (measured in radians) of x.\n",
      "    \n",
      "    atan2(...)\n",
      "        atan2(y, x)\n",
      "        \n",
      "        Return the arc tangent (measured in radians) of y/x.\n",
      "        Unlike atan(y/x), the signs of both x and y are considered.\n",
      "    \n",
      "    atanh(...)\n",
      "        atanh(x)\n",
      "        \n",
      "        Return the inverse hyperbolic tangent of x.\n",
      "    \n",
      "    ceil(...)\n",
      "        ceil(x)\n",
      "        \n",
      "        Return the ceiling of x as an Integral.\n",
      "        This is the smallest integer >= x.\n",
      "    \n",
      "    copysign(...)\n",
      "        copysign(x, y)\n",
      "        \n",
      "        Return a float with the magnitude (absolute value) of x but the sign \n",
      "        of y. On platforms that support signed zeros, copysign(1.0, -0.0) \n",
      "        returns -1.0.\n",
      "    \n",
      "    cos(...)\n",
      "        cos(x)\n",
      "        \n",
      "        Return the cosine of x (measured in radians).\n",
      "    \n",
      "    cosh(...)\n",
      "        cosh(x)\n",
      "        \n",
      "        Return the hyperbolic cosine of x.\n",
      "    \n",
      "    degrees(...)\n",
      "        degrees(x)\n",
      "        \n",
      "        Convert angle x from radians to degrees.\n",
      "    \n",
      "    erf(...)\n",
      "        erf(x)\n",
      "        \n",
      "        Error function at x.\n",
      "    \n",
      "    erfc(...)\n",
      "        erfc(x)\n",
      "        \n",
      "        Complementary error function at x.\n",
      "    \n",
      "    exp(...)\n",
      "        exp(x)\n",
      "        \n",
      "        Return e raised to the power of x.\n",
      "    \n",
      "    expm1(...)\n",
      "        expm1(x)\n",
      "        \n",
      "        Return exp(x)-1.\n",
      "        This function avoids the loss of precision involved in the direct evaluation of exp(x)-1 for small x.\n",
      "    \n",
      "    fabs(...)\n",
      "        fabs(x)\n",
      "        \n",
      "        Return the absolute value of the float x.\n",
      "    \n",
      "    factorial(...)\n",
      "        factorial(x) -> Integral\n",
      "        \n",
      "        Find x!. Raise a ValueError if x is negative or non-integral.\n",
      "    \n",
      "    floor(...)\n",
      "        floor(x)\n",
      "        \n",
      "        Return the floor of x as an Integral.\n",
      "        This is the largest integer <= x.\n",
      "    \n",
      "    fmod(...)\n",
      "        fmod(x, y)\n",
      "        \n",
      "        Return fmod(x, y), according to platform C.  x % y may differ.\n",
      "    \n",
      "    frexp(...)\n",
      "        frexp(x)\n",
      "        \n",
      "        Return the mantissa and exponent of x, as pair (m, e).\n",
      "        m is a float and e is an int, such that x = m * 2.**e.\n",
      "        If x is 0, m and e are both 0.  Else 0.5 <= abs(m) < 1.0.\n",
      "    \n",
      "    fsum(...)\n",
      "        fsum(iterable)\n",
      "        \n",
      "        Return an accurate floating point sum of values in the iterable.\n",
      "        Assumes IEEE-754 floating point arithmetic.\n",
      "    \n",
      "    gamma(...)\n",
      "        gamma(x)\n",
      "        \n",
      "        Gamma function at x.\n",
      "    \n",
      "    gcd(...)\n",
      "        gcd(x, y) -> int\n",
      "        greatest common divisor of x and y\n",
      "    \n",
      "    hypot(...)\n",
      "        hypot(x, y)\n",
      "        \n",
      "        Return the Euclidean distance, sqrt(x*x + y*y).\n",
      "    \n",
      "    isclose(...)\n",
      "        isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0) -> bool\n",
      "        \n",
      "        Determine whether two floating point numbers are close in value.\n",
      "        \n",
      "           rel_tol\n",
      "               maximum difference for being considered \"close\", relative to the\n",
      "               magnitude of the input values\n",
      "            abs_tol\n",
      "               maximum difference for being considered \"close\", regardless of the\n",
      "               magnitude of the input values\n",
      "        \n",
      "        Return True if a is close in value to b, and False otherwise.\n",
      "        \n",
      "        For the values to be considered close, the difference between them\n",
      "        must be smaller than at least one of the tolerances.\n",
      "        \n",
      "        -inf, inf and NaN behave similarly to the IEEE 754 Standard.  That\n",
      "        is, NaN is not close to anything, even itself.  inf and -inf are\n",
      "        only close to themselves.\n",
      "    \n",
      "    isfinite(...)\n",
      "        isfinite(x) -> bool\n",
      "        \n",
      "        Return True if x is neither an infinity nor a NaN, and False otherwise.\n",
      "    \n",
      "    isinf(...)\n",
      "        isinf(x) -> bool\n",
      "        \n",
      "        Return True if x is a positive or negative infinity, and False otherwise.\n",
      "    \n",
      "    isnan(...)\n",
      "        isnan(x) -> bool\n",
      "        \n",
      "        Return True if x is a NaN (not a number), and False otherwise.\n",
      "    \n",
      "    ldexp(...)\n",
      "        ldexp(x, i)\n",
      "        \n",
      "        Return x * (2**i).\n",
      "    \n",
      "    lgamma(...)\n",
      "        lgamma(x)\n",
      "        \n",
      "        Natural logarithm of absolute value of Gamma function at x.\n",
      "    \n",
      "    log(...)\n",
      "        log(x[, base])\n",
      "        \n",
      "        Return the logarithm of x to the given base.\n",
      "        If the base not specified, returns the natural logarithm (base e) of x.\n",
      "    \n",
      "    log10(...)\n",
      "        log10(x)\n",
      "        \n",
      "        Return the base 10 logarithm of x.\n",
      "    \n",
      "    log1p(...)\n",
      "        log1p(x)\n",
      "        \n",
      "        Return the natural logarithm of 1+x (base e).\n",
      "        The result is computed in a way which is accurate for x near zero.\n",
      "    \n",
      "    log2(...)\n",
      "        log2(x)\n",
      "        \n",
      "        Return the base 2 logarithm of x.\n",
      "    \n",
      "    modf(...)\n",
      "        modf(x)\n",
      "        \n",
      "        Return the fractional and integer parts of x.  Both results carry the sign\n",
      "        of x and are floats.\n",
      "    \n",
      "    pow(...)\n",
      "        pow(x, y)\n",
      "        \n",
      "        Return x**y (x to the power of y).\n",
      "    \n",
      "    radians(...)\n",
      "        radians(x)\n",
      "        \n",
      "        Convert angle x from degrees to radians.\n",
      "    \n",
      "    sin(...)\n",
      "        sin(x)\n",
      "        \n",
      "        Return the sine of x (measured in radians).\n",
      "    \n",
      "    sinh(...)\n",
      "        sinh(x)\n",
      "        \n",
      "        Return the hyperbolic sine of x.\n",
      "    \n",
      "    sqrt(...)\n",
      "        sqrt(x)\n",
      "        \n",
      "        Return the square root of x.\n",
      "    \n",
      "    tan(...)\n",
      "        tan(x)\n",
      "        \n",
      "        Return the tangent of x (measured in radians).\n",
      "    \n",
      "    tanh(...)\n",
      "        tanh(x)\n",
      "        \n",
      "        Return the hyperbolic tangent of x.\n",
      "    \n",
      "    trunc(...)\n",
      "        trunc(x:Real) -> Integral\n",
      "        \n",
      "        Truncates x to the nearest Integral toward 0. Uses the __trunc__ magic method.\n",
      "\n",
      "DATA\n",
      "    e = 2.718281828459045\n",
      "    inf = inf\n",
      "    nan = nan\n",
      "    pi = 3.141592653589793\n",
      "    tau = 6.283185307179586\n",
      "\n",
      "FILE\n",
      "    (built-in)\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(math)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function log in module math:\n",
      "\n",
      "log(...)\n",
      "    log(x[, base])\n",
      "    \n",
      "    Return the logarithm of x to the given base.\n",
      "    If the base not specified, returns the natural logarithm (base e) of x.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(math.log)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Se pueden obtener los módulos que forman parte de los *builtins* (escritos en *C*) con:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('_ast', '_bisect', '_blake2', '_codecs', '_collections', '_datetime', '_elementtree', '_functools', '_heapq', '_imp', '_io', '_locale', '_md5', '_operator', '_pickle', '_posixsubprocess', '_random', '_sha1', '_sha256', '_sha3', '_sha512', '_signal', '_socket', '_sre', '_stat', '_string', '_struct', '_symtable', '_thread', '_tracemalloc', '_warnings', '_weakref', 'array', 'atexit', 'binascii', 'builtins', 'cmath', 'errno', 'faulthandler', 'fcntl', 'gc', 'grp', 'itertools', 'marshal', 'math', 'posix', 'pwd', 'pyexpat', 'select', 'spwd', 'sys', 'syslog', 'time', 'unicodedata', 'xxsubtype', 'zipimport', 'zlib')\n"
     ]
    }
   ],
   "source": [
    "print(sys.builtin_module_names)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para el paquete *NumPy* se puede realizar lo siguiente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "class:  ndarray\n",
      "shape:  (3,)\n",
      "strides:  (8,)\n",
      "itemsize:  8\n",
      "aligned:  True\n",
      "contiguous:  True\n",
      "fortran:  True\n",
      "data pointer: 0x251bd60\n",
      "byteorder:  little\n",
      "byteswap:  False\n",
      "type: int64\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "a=np.array([1,2,3])\n",
    "np.info(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Search results for 'sort'\n",
      "-------------------------\n",
      "numpy.sort\n",
      "    Return a sorted copy of an array.\n",
      "numpy.msort\n",
      "    Return a copy of an array sorted along the first axis.\n",
      "numpy.argsort\n",
      "    Returns the indices that would sort an array.\n",
      "numpy.lexsort\n",
      "    Perform an indirect stable sort using a sequence of keys.\n",
      "numpy.searchsorted\n",
      "    Find indices where elements should be inserted to maintain order.\n",
      "numpy.sort_complex\n",
      "    Sort a complex array using the real part first, then the imaginary part.\n",
      "numpy.unique\n",
      "    Find the unique elements of an array.\n",
      "numpy.ma.sort\n",
      "    Sort the array, in-place\n",
      "numpy.union1d\n",
      "    Find the union of two arrays.\n",
      "numpy.setxor1d\n",
      "    Find the set exclusive-or of two arrays.\n",
      "numpy.ma.argsort\n",
      "    Return an ndarray of indices that sort the array along the\n",
      "numpy.intersect1d\n",
      "    Find the intersection of two arrays.\n",
      "numpy.chararray.sort\n",
      "    Sort an array in-place. Refer to `numpy.sort` for full documentation.\n",
      "numpy.matrix.argsort\n",
      "    Returns the indices that would sort this array.\n",
      "numpy.chararray.argsort\n",
      "    Returns the indices that would sort this array.\n",
      "numpy.chararray.searchsorted\n",
      "    Find indices where elements of v should be inserted in a to maintain order.\n",
      "numpy.ma.MaskedArray.sort\n",
      "    Sort the array, in-place\n",
      "numpy.ma.MaskedArray.argsort\n",
      "    Return an ndarray of indices that sort the array along the\n",
      "numpy.core._multiarray_umath.lexsort\n",
      "    Perform an indirect stable sort using a sequence of keys.\n",
      "numpy.savez\n",
      "    Save several arrays into a single file in uncompressed ``.npz`` format.\n",
      "numpy.split\n",
      "    Split an array into multiple sub-arrays as views into `ary`.\n",
      "numpy.geterr\n",
      "    Get the current way of handling floating-point errors.\n",
      "numpy.interp\n",
      "    One-dimensional linear interpolation.\n",
      "numpy.median\n",
      "    Compute the median along the specified axis.\n",
      "numpy.lookfor\n",
      "    Do a keyword search on docstrings.\n",
      "numpy.digitize\n",
      "    Return the indices of the bins to which each value in input array belongs.\n",
      "numpy.errstate\n",
      "    errstate(**kwargs)\n",
      "numpy.quantile\n",
      "    Compute the q-th quantile of the data along the specified axis.\n",
      "numpy.chararray\n",
      "    chararray(shape, itemsize=1, unicode=False, buffer=None, offset=0,\n",
      "numpy.histogram\n",
      "    Compute the histogram of a set of data.\n",
      "numpy.nanmedian\n",
      "    Compute the median along the specified axis, while ignoring NaNs.\n",
      "numpy.partition\n",
      "    Return a partitioned copy of an array.\n",
      "numpy.setdiff1d\n",
      "    Find the set difference of two arrays.\n",
      "numpy.transpose\n",
      "    Permute the dimensions of an array.\n",
      "numpy.percentile\n",
      "    Compute the q-th percentile of the data along the specified axis.\n",
      "numpy.seterrcall\n",
      "    Set the floating-point error callback function or log object.\n",
      "numpy.argpartition\n",
      "    Perform an indirect partition along the given axis using the\n",
      "numpy.nanpercentile\n",
      "    Compute the qth percentile of the data along the specified axis,\n",
      "numpy.busdaycalendar\n",
      "    A business day calendar object that efficiently stores information\n",
      "numpy.put_along_axis\n",
      "    Put values into the destination array by matching 1d index and data slices.\n",
      "numpy.ma.median\n",
      "    Compute the median along the specified axis.\n",
      "numpy.linalg.svd\n",
      "    Singular Value Decomposition.\n",
      "numpy.take_along_axis\n",
      "    Take values from the input array by matching 1d index and data slices.\n",
      "numpy.apply_along_axis\n",
      "    Apply a function to 1-D slices along the given axis.\n",
      "numpy.matrix.partition\n",
      "    Rearranges the elements in the array in such a way that the value of the\n",
      "numpy.ma.apply_along_axis\n",
      "    Apply a function to 1-D slices along the given axis.\n",
      "numpy.random.Generator.f\n",
      "    Draw samples from an F distribution.\n",
      "numpy.ma.flatnotmasked_contiguous\n",
      "    Find contiguous unmasked data in a masked array along the given axis.\n",
      "numpy.random.RandomState.f\n",
      "    Draw samples from an F distribution.\n",
      "numpy.lib.recfunctions.join_by\n",
      "    Join arrays `r1` and `r2` on key `key`.\n",
      "numpy.ma.MaskedArray.partition\n",
      "    Rearranges the elements in the array in such a way that the value of the\n",
      "numpy.distutils.command.develop.develop._get_all_ns_packages\n",
      "    Return sorted list of all package namespaces"
     ]
    }
   ],
   "source": [
    "np.lookfor('sort')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function sort in module numpy:\n",
      "\n",
      "sort(a, axis=-1, kind=None, order=None)\n",
      "    Return a sorted copy of an array.\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    a : array_like\n",
      "        Array to be sorted.\n",
      "    axis : int or None, optional\n",
      "        Axis along which to sort. If None, the array is flattened before\n",
      "        sorting. The default is -1, which sorts along the last axis.\n",
      "    kind : {'quicksort', 'mergesort', 'heapsort', 'stable'}, optional\n",
      "        Sorting algorithm. The default is 'quicksort'. Note that both 'stable'\n",
      "        and 'mergesort' use timsort or radix sort under the covers and, in general,\n",
      "        the actual implementation will vary with data type. The 'mergesort' option\n",
      "        is retained for backwards compatibility.\n",
      "    \n",
      "        .. versionchanged:: 1.15.0.\n",
      "           The 'stable' option was added.\n",
      "    \n",
      "    order : str or list of str, optional\n",
      "        When `a` is an array with fields defined, this argument specifies\n",
      "        which fields to compare first, second, etc.  A single field can\n",
      "        be specified as a string, and not all fields need be specified,\n",
      "        but unspecified fields will still be used, in the order in which\n",
      "        they come up in the dtype, to break ties.\n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    sorted_array : ndarray\n",
      "        Array of the same type and shape as `a`.\n",
      "    \n",
      "    See Also\n",
      "    --------\n",
      "    ndarray.sort : Method to sort an array in-place.\n",
      "    argsort : Indirect sort.\n",
      "    lexsort : Indirect stable sort on multiple keys.\n",
      "    searchsorted : Find elements in a sorted array.\n",
      "    partition : Partial sort.\n",
      "    \n",
      "    Notes\n",
      "    -----\n",
      "    The various sorting algorithms are characterized by their average speed,\n",
      "    worst case performance, work space size, and whether they are stable. A\n",
      "    stable sort keeps items with the same key in the same relative\n",
      "    order. The four algorithms implemented in NumPy have the following\n",
      "    properties:\n",
      "    \n",
      "    =========== ======= ============= ============ ========\n",
      "       kind      speed   worst case    work space   stable\n",
      "    =========== ======= ============= ============ ========\n",
      "    'quicksort'    1     O(n^2)            0          no\n",
      "    'heapsort'     3     O(n*log(n))       0          no\n",
      "    'mergesort'    2     O(n*log(n))      ~n/2        yes\n",
      "    'timsort'      2     O(n*log(n))      ~n/2        yes\n",
      "    =========== ======= ============= ============ ========\n",
      "    \n",
      "    .. note:: The datatype determines which of 'mergesort' or 'timsort'\n",
      "       is actually used, even if 'mergesort' is specified. User selection\n",
      "       at a finer scale is not currently available.\n",
      "    \n",
      "    All the sort algorithms make temporary copies of the data when\n",
      "    sorting along any but the last axis.  Consequently, sorting along\n",
      "    the last axis is faster and uses less space than sorting along\n",
      "    any other axis.\n",
      "    \n",
      "    The sort order for complex numbers is lexicographic. If both the real\n",
      "    and imaginary parts are non-nan then the order is determined by the\n",
      "    real parts except when they are equal, in which case the order is\n",
      "    determined by the imaginary parts.\n",
      "    \n",
      "    Previous to numpy 1.4.0 sorting real and complex arrays containing nan\n",
      "    values led to undefined behaviour. In numpy versions >= 1.4.0 nan\n",
      "    values are sorted to the end. The extended sort order is:\n",
      "    \n",
      "      * Real: [R, nan]\n",
      "      * Complex: [R + Rj, R + nanj, nan + Rj, nan + nanj]\n",
      "    \n",
      "    where R is a non-nan real value. Complex values with the same nan\n",
      "    placements are sorted according to the non-nan part if it exists.\n",
      "    Non-nan values are sorted as before.\n",
      "    \n",
      "    .. versionadded:: 1.12.0\n",
      "    \n",
      "    quicksort has been changed to `introsort <https://en.wikipedia.org/wiki/Introsort>`_.\n",
      "    When sorting does not make enough progress it switches to\n",
      "    `heapsort <https://en.wikipedia.org/wiki/Heapsort>`_.\n",
      "    This implementation makes quicksort O(n*log(n)) in the worst case.\n",
      "    \n",
      "    'stable' automatically chooses the best stable sorting algorithm\n",
      "    for the data type being sorted.\n",
      "    It, along with 'mergesort' is currently mapped to\n",
      "    `timsort <https://en.wikipedia.org/wiki/Timsort>`_\n",
      "    or `radix sort <https://en.wikipedia.org/wiki/Radix_sort>`_\n",
      "    depending on the data type.\n",
      "    API forward compatibility currently limits the\n",
      "    ability to select the implementation and it is hardwired for the different\n",
      "    data types.\n",
      "    \n",
      "    .. versionadded:: 1.17.0\n",
      "    \n",
      "    Timsort is added for better performance on already or nearly\n",
      "    sorted data. On random data timsort is almost identical to\n",
      "    mergesort. It is now used for stable sort while quicksort is still the\n",
      "    default sort if none is chosen. For timsort details, refer to\n",
      "    `CPython listsort.txt <https://github.com/python/cpython/blob/3.7/Objects/listsort.txt>`_.\n",
      "    'mergesort' and 'stable' are mapped to radix sort for integer data types. Radix sort is an\n",
      "    O(n) sort instead of O(n log n).\n",
      "    \n",
      "    .. versionchanged:: 1.17.0\n",
      "    \n",
      "    NaT now sorts to the end of arrays for consistency with NaN.\n",
      "    \n",
      "    Examples\n",
      "    --------\n",
      "    >>> a = np.array([[1,4],[3,1]])\n",
      "    >>> np.sort(a)                # sort along the last axis\n",
      "    array([[1, 4],\n",
      "           [1, 3]])\n",
      "    >>> np.sort(a, axis=None)     # sort the flattened array\n",
      "    array([1, 1, 3, 4])\n",
      "    >>> np.sort(a, axis=0)        # sort along the first axis\n",
      "    array([[1, 1],\n",
      "           [3, 4]])\n",
      "    \n",
      "    Use the `order` keyword to specify a field to use when sorting a\n",
      "    structured array:\n",
      "    \n",
      "    >>> dtype = [('name', 'S10'), ('height', float), ('age', int)]\n",
      "    >>> values = [('Arthur', 1.8, 41), ('Lancelot', 1.9, 38),\n",
      "    ...           ('Galahad', 1.7, 38)]\n",
      "    >>> a = np.array(values, dtype=dtype)       # create a structured array\n",
      "    >>> np.sort(a, order='height')                        # doctest: +SKIP\n",
      "    array([('Galahad', 1.7, 38), ('Arthur', 1.8, 41),\n",
      "           ('Lancelot', 1.8999999999999999, 38)],\n",
      "          dtype=[('name', '|S10'), ('height', '<f8'), ('age', '<i4')])\n",
      "    \n",
      "    Sort by age, then height if ages are equal:\n",
      "    \n",
      "    >>> np.sort(a, order=['age', 'height'])               # doctest: +SKIP\n",
      "    array([('Galahad', 1.7, 38), ('Lancelot', 1.8999999999999999, 38),\n",
      "           ('Arthur', 1.8, 41)],\n",
      "          dtype=[('name', '|S10'), ('height', '<f8'), ('age', '<i4')])\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(np.sort)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "---\n",
    "\n",
    "**Observación**\n",
    "\n",
    "\n",
    "¿Qué es un paquete?\n",
    "\n",
    "\n",
    "Un paquete es un conjunto de módulos dispuestos en una jerarquía de árbol. Por ejemplo el paquete de `scipy` contiene los siguientes sub-módulos:\n",
    "\n",
    "* scipy.fftpack\n",
    "* scipy.stats\n",
    "* scipy.linalg\n",
    "* scipy.linalg.blas\n",
    "* scipy.linalg.lapack\n",
    " \n",
    "y otra característica de los paquetes es que son directorios que contienen el archivo `__init__.py`\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejemplo**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En una máquina que tiene instalado *SciPy* se tiene la siguiente jerarquía para tal paquete."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "scipy/\n",
    "    ...\n",
    "    __init__.py\n",
    "    ...\n",
    "    fftpack/\n",
    "        ...\n",
    "        __init__.py\n",
    "    \n",
    "    linalg/\n",
    "        ...\n",
    "        __init__.py\n",
    "        ...\n",
    "        blas.py\n",
    "        ...\n",
    "        lapack.py\n",
    "        ...\n",
    "    ...\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Instalación de paquetes y módulos de *Python*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tanto la instalación de *Python* en los sistemas operativos así como sus módulos y paquetes se puede realizar con un flujo del tipo: *Descargar fuente + Extraer + Compilar + Instalar* (ver pestaña *Downloads* en la liga [about](https://www.python.org/about/)) sin embargo este flujo se lleva a cabo típicamente si se desea tener diferente funcionalidad de *Python* o de sus paquetes o módulos (por ejemplo soporte para librerías de álgebra lineal como [OpenBLAS](https://github.com/xianyi/OpenBLAS)) y es indispensable una buena guía o conocimiento de sus sistemas para realizar tal flujo.   \n",
    "\n",
    "En lugar de correr el flujo anterior se utilizan gestores/distribuidores/manejadores de paquetes. Entre los más populares se encuentran:\n",
    "\n",
    "* [Advanced Packaging Tool (apt-get)](https://www.debian.org/doc/manuals/apt-guide/ch2.es.html) y [documentación de debian](https://www.debian.org/doc/) para instalación de Python en un sistema [debian](https://www.debian.org/intro/about).\n",
    "* [Anaconda](https://www.anaconda.com/) para instalación de Python. Ver también la liga [Managing packages](https://docs.conda.io/projects/conda/en/latest/user-guide/tasks/manage-pkgs.html) en la que se explica que al instalar `anaconda` también instala `conda` y `pip`.\n",
    "* pip que instala paquetes o módulos del repositorio [Python Package Index (PypI)](https://pypi.org/). Para más información ver [Installing Packages](https://packaging.python.org/tutorials/installing-packages/#installing-from-pypi).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En un sistema basado en *Debian* se puede instalar *Python* y *pip* desde la terminal con:\n",
    "\n",
    "```\n",
    "apt install -y python3-dev python3-pip\n",
    "```\n",
    "\n",
    "La bandera `-y` de `apt install` es *yes* e indica que se instalen ambos.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para el propedéutico se ha creado una imagen de [docker](https://www.docker.com/) basada en [Ubuntu](https://ubuntu.com/) que pueden utilizar para tener *Python* y paquetes como *NumPy, Matplotlib, SciPy* (ver inicio de la nota). \n",
    "\n",
    "Para instalar paquetes es posible:\n",
    "\n",
    "1) Ejecutar lo siguiente en su terminal\n",
    "\n",
    "```\n",
    "pip install --user <paquete>\n",
    "```\n",
    "\n",
    "2) En una celda de jupyter:\n",
    "\n",
    "```\n",
    "!pip install --user -q <paquete>\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejemplo**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "%%bash\n",
    "pip install --user -q pytest"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install --user -q nose"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Referencias\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "* [Modules](https://docs.python.org/3/tutorial/modules.html)\n",
    "* [The module search path](https://docs.python.org/3/tutorial/modules.html#the-module-search-path)\n",
    "* En la comunidad de *Python* el término paquete también se utiliza como sinónimo de *distribution* pero este último término no se prefiere pues se puede confundir con una *GNU/Linux distribution*. Ver [Installing Packages](https://packaging.python.org/tutorials/installing-packages/#installing-from-pypi).\n",
    "* Para referencias de los comandos de *magic* ver [magics](https://ipython.readthedocs.io/en/stable/interactive/magics.html)."
   ]
  }
 ],
 "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}