01-PyconUS-Ariel-Iniciando-Jupyter-Widgets.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "<img src=\"images/pyconus2022-logo.png\" alt=\"drawing\" width=\"400\"/>\n",
    "\n",
    "![banner](images/banner.png)\n",
    "\n",
    "### Python + VPS Jupyter HUB/Notebook, aprender, enseñar, investigar, trabajar de manera colaborativa, remota y presencial\n",
    "#### Fecha: 30 de Abril , 1.45 a 2.30 hs. pm\n",
    "####  Sofía Martin, Ariel Ramos, Liliana Hurtado, Enzo Juárez"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### Parte 2 - Conociendo Jupyter\n",
    "\n",
    "**Expectativa**: Al final de esta sección de la charla, conocerán Jupyter y podrán editar texto y ejecutar celdas de código."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> La Tecnologia hoy en dia nos da una dinamica para llevar adelante los pocesos de enseñanza y Aprendizaje en Base a Proyectos o Desafios Tangibles (ABP - M.Conde)\n",
    "\n",
    "* Componentes relacionados aplicados a un contenido por enseñar: \n",
    "\n",
    "* Lenguaje de Programacion + Entorno de Trabajo (FrameWork) + Infraestructura -> CONTENIDO a enseñar (Funcion principal)\n",
    "\n",
    "## Descartes: sepamos recorrer desde lo simple, hasta todo lo complejo que podamos llegar...\n",
    "\n",
    "Python + Project Jupyter + VPS (Servidor Virtual Privado) aplicados al contenido (Profesor o Maestro o el Experto en un tema)\n",
    "\n",
    "Links que siginifica cada uno\n",
    "\n",
    "Esta es la principal razon para trabajar en equipo, interdisciplinario\n",
    "\n",
    "> Esto es el porque del Proyecto\n",
    "\n",
    "Aplica tanto el Modo Remoto como Presencial\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Ejercicio de Ejemplo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "## Usando librerías o módulos Python en Jupyter\n",
    "\n",
    "También es posible usar librerías de Python en Jupyter. Para ello, basta importarlas como se haría normalmente en Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "A continuación, a modo de ejemplo, usaremos la librería `numpy` y el método `linspace` para explicar el concepto de función, dominio y codominio y luego hacer su grafica."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "## Definimos el DOMINIO de una Función\n",
    "* realizamos la búsqueda de información en la web para agregar las definiciones de:\n",
    "    * dominio\n",
    "    * codominio\n",
    "    * funciones matemáticas\n",
    "    * gráfica"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "N = 55\n",
    "X = np.linspace(-5, 5, N) # -5 limite inferior, 5 limite superior, N cantidad de puntos a generar"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Mostramos los valores\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Para ver el contenido de las variables ¿es necesario poner **print**?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "X"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Mostrar la cantidad de puntos en x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(len(X))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Calculamos el CO-DOMINIO de una Función"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "Y = np.sin(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Mostramos los valores calculados"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "print(Y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [],
   "source": [
    "Y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## ¿Por qué decimos que es un entorno lúdico y creativo?\n",
    "* Se puede cambiar fácilmente la función que queremos calcular\n",
    "* Vmos en el momento los cambios con la modificación realizada\n",
    "* Los estudiantes cambiar y pueden verificar la implicancia de ese cambio"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.95892427,  0.99475906,  0.9965774 ,  0.96431712,  0.89908137,\n",
       "        0.80310095,  0.67965796,  0.53297361,  0.36806388,  0.19056796,\n",
       "        0.00655545, -0.17768124, -0.35584199, -0.5218345 , -0.66998252,\n",
       "       -0.79522006, -0.89326452, -0.9607632 , -0.99540796, -0.99601408,\n",
       "       -0.96256084, -0.8961922 , -0.79917768, -0.67483474, -0.52741539,\n",
       "       -0.36196071, -0.18412856,  0.        ,  0.18412856,  0.36196071,\n",
       "        0.52741539,  0.67483474,  0.79917768,  0.8961922 ,  0.96256084,\n",
       "        0.99601408,  0.99540796,  0.9607632 ,  0.89326452,  0.79522006,\n",
       "        0.66998252,  0.5218345 ,  0.35584199,  0.17768124, -0.00655545,\n",
       "       -0.19056796, -0.36806388, -0.53297361, -0.67965796, -0.80310095,\n",
       "       -0.89908137, -0.96431712, -0.9965774 , -0.99475906, -0.95892427])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Y = X ** 2\n",
    "Y = np.sin(X)\n",
    "#Y = np.cos(X)\n",
    "#Y = np.tan(X)\n",
    "Y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mostrar la cantidad de puntos en y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "55\n"
     ]
    }
   ],
   "source": [
    "print(len(Y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Graficamos los valores de X e Y con círculos \"o\" de color ROJO (red = r)\n",
    "## Usamos el método PLOT (Dibujar) en matplotlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f9095d7d6a0>]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import pyplot as grafica\n",
    "grafica.plot(X, Y, 'ro')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Y = X ** 2\n",
    "#Y = np.sin(X)\n",
    "#Y = np.cos(X)\n",
    "Y = np.tan(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ahora agregamos o habilitamos la GRILLA en la Grafica con plt.grid(True)\n",
    "### Graficamos los valores de X e Y con círculos \"o\" de color CYAN (cyan = c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "grafica.grid(True)\n",
    "grafica.plot(X, Y, 'co')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Graficamos los valores de X e Y con líneas \"-\" de color azul, blue en Ingles (blue = b)\n",
    "### Usamos en metod PLOT (Dibujar) con la Grilla habilitada: plt.grid(True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "grafica.grid(True)\n",
    "grafica.plot(X, Y, 'b-')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Es posible evaluar y componer funciones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f9093adf9a0>]"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "grafica.grid(True)\n",
    "Z = ( np.sin(X) ) **2 \n",
    "grafica.plot(X, Z, '.-')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ahora aplicamos los Wigets para tener interaccion y generar una mejor atencion, entonces..\n",
    "\n",
    "## ¿Podemos hacerlo más interactivo?\n",
    "* ¿y si queremos probar en el momento la modificación de la función?\n",
    "\n",
    "## ¿Es necesario graficar las diferentes funciones con potenica: 0, 1, 2, 3, 4....?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ipywidgets as widgets\n",
    "from ipywidgets import HBox, VBox\n",
    "from IPython.display import display"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "489c50173fe14f6bac9364e1f1deecba",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(IntSlider(value=4, description='n', max=9), Output()), _dom_classes=('widget-interact',)…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.linspace(-50, 50)\n",
    "\n",
    "@widgets.interact(n=(0, 9))\n",
    "def p(n):\n",
    "    y = x**n\n",
    "    grafica.plot(x, y)\n",
    "    grafica.grid(True)\n",
    "    grafica.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4363e6ad51f64376b1906156979e8f8e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(IntSlider(value=4, description='n', max=9), Output()), _dom_classes=('widget-interact',)…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#plt.plot(x, y, 'ro')\n",
    "\n",
    "x = np.linspace(-50, 50, 35) #Dominio de la Funcion\n",
    "\n",
    "@widgets.interact(n=(0, 9)) #Variacion de manera interactiva en un parametro de la Funcion\n",
    "def p(n):\n",
    "    y = x**n #Codominio de la Funcion\n",
    "    grafica.plot(x, y, 'ro') #Grafica en memoria\n",
    "    grafica.grid(True)\n",
    "    grafica.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "8591db66dce04de09449fcdf379577c7",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(IntSlider(value=4, description='n', max=9), IntSlider(value=20, description='npoints', m…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%matplotlib inline\n",
    "import ipywidgets as widgets\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "@widgets.interact(n=(0, 9), npoints=(5,35)) #Variacion de manera interactiva en un parametro de la Funcion y la cantidad de puntos\n",
    "def p(n, npoints):\n",
    "    x = np.linspace(-50, 50, npoints) #Dominio de la Funcion y agregamos la cantidad de puntos tambien, la cual varia tambien\n",
    "    y = x**n #Codominio de la Funcion\n",
    "    grafica.plot(x, y, 'ro-') #Grafica en memoria\n",
    "    grafica.grid(True)\n",
    "    grafica.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Y si no me acuerdo cómo se hace algo con la librería numpy, cómo pido ayuda ?\n",
    "Recordar que cuando importamos **numpy** le pusimos **np** de nombre"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(np)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Y qué puedo hacer con **numpy**?: \n",
    "### Funciones de la librería"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['ALLOW_THREADS',\n",
       " 'AxisError',\n",
       " 'BUFSIZE',\n",
       " 'Bytes0',\n",
       " 'CLIP',\n",
       " 'ComplexWarning',\n",
       " 'DataSource',\n",
       " 'Datetime64',\n",
       " 'ERR_CALL',\n",
       " 'ERR_DEFAULT',\n",
       " 'ERR_IGNORE',\n",
       " 'ERR_LOG',\n",
       " 'ERR_PRINT',\n",
       " 'ERR_RAISE',\n",
       " 'ERR_WARN',\n",
       " 'FLOATING_POINT_SUPPORT',\n",
       " 'FPE_DIVIDEBYZERO',\n",
       " 'FPE_INVALID',\n",
       " 'FPE_OVERFLOW',\n",
       " 'FPE_UNDERFLOW',\n",
       " 'False_',\n",
       " 'Inf',\n",
       " 'Infinity',\n",
       " 'MAXDIMS',\n",
       " 'MAY_SHARE_BOUNDS',\n",
       " 'MAY_SHARE_EXACT',\n",
       " 'MachAr',\n",
       " 'ModuleDeprecationWarning',\n",
       " 'NAN',\n",
       " 'NINF',\n",
       " 'NZERO',\n",
       " 'NaN',\n",
       " 'PINF',\n",
       " 'PZERO',\n",
       " 'RAISE',\n",
       " 'RankWarning',\n",
       " 'SHIFT_DIVIDEBYZERO',\n",
       " 'SHIFT_INVALID',\n",
       " 'SHIFT_OVERFLOW',\n",
       " 'SHIFT_UNDERFLOW',\n",
       " 'ScalarType',\n",
       " 'Str0',\n",
       " 'Tester',\n",
       " 'TooHardError',\n",
       " 'True_',\n",
       " 'UFUNC_BUFSIZE_DEFAULT',\n",
       " 'UFUNC_PYVALS_NAME',\n",
       " 'Uint64',\n",
       " 'VisibleDeprecationWarning',\n",
       " 'WRAP',\n",
       " '_NoValue',\n",
       " '_UFUNC_API',\n",
       " '__NUMPY_SETUP__',\n",
       " '__all__',\n",
       " '__builtins__',\n",
       " '__cached__',\n",
       " '__config__',\n",
       " '__deprecated_attrs__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__expired_functions__',\n",
       " '__file__',\n",
       " '__getattr__',\n",
       " '__git_version__',\n",
       " '__loader__',\n",
       " '__name__',\n",
       " '__package__',\n",
       " '__path__',\n",
       " '__spec__',\n",
       " '__version__',\n",
       " '_add_newdoc_ufunc',\n",
       " '_distributor_init',\n",
       " '_financial_names',\n",
       " '_globals',\n",
       " '_mat',\n",
       " '_pytesttester',\n",
       " '_version',\n",
       " 'abs',\n",
       " 'absolute',\n",
       " 'add',\n",
       " 'add_docstring',\n",
       " 'add_newdoc',\n",
       " 'add_newdoc_ufunc',\n",
       " 'alen',\n",
       " 'all',\n",
       " 'allclose',\n",
       " 'alltrue',\n",
       " 'amax',\n",
       " 'amin',\n",
       " 'angle',\n",
       " 'any',\n",
       " 'append',\n",
       " 'apply_along_axis',\n",
       " 'apply_over_axes',\n",
       " 'arange',\n",
       " 'arccos',\n",
       " 'arccosh',\n",
       " 'arcsin',\n",
       " 'arcsinh',\n",
       " 'arctan',\n",
       " 'arctan2',\n",
       " 'arctanh',\n",
       " 'argmax',\n",
       " 'argmin',\n",
       " 'argpartition',\n",
       " 'argsort',\n",
       " 'argwhere',\n",
       " 'around',\n",
       " 'array',\n",
       " 'array2string',\n",
       " 'array_equal',\n",
       " 'array_equiv',\n",
       " 'array_repr',\n",
       " 'array_split',\n",
       " 'array_str',\n",
       " 'asanyarray',\n",
       " 'asarray',\n",
       " 'asarray_chkfinite',\n",
       " 'ascontiguousarray',\n",
       " 'asfarray',\n",
       " 'asfortranarray',\n",
       " 'asmatrix',\n",
       " 'asscalar',\n",
       " 'atleast_1d',\n",
       " 'atleast_2d',\n",
       " 'atleast_3d',\n",
       " 'average',\n",
       " 'bartlett',\n",
       " 'base_repr',\n",
       " 'binary_repr',\n",
       " 'bincount',\n",
       " 'bitwise_and',\n",
       " 'bitwise_not',\n",
       " 'bitwise_or',\n",
       " 'bitwise_xor',\n",
       " 'blackman',\n",
       " 'block',\n",
       " 'bmat',\n",
       " 'bool8',\n",
       " 'bool_',\n",
       " 'broadcast',\n",
       " 'broadcast_arrays',\n",
       " 'broadcast_shapes',\n",
       " 'broadcast_to',\n",
       " 'busday_count',\n",
       " 'busday_offset',\n",
       " 'busdaycalendar',\n",
       " 'byte',\n",
       " 'byte_bounds',\n",
       " 'bytes0',\n",
       " 'bytes_',\n",
       " 'c_',\n",
       " 'can_cast',\n",
       " 'cast',\n",
       " 'cbrt',\n",
       " 'cdouble',\n",
       " 'ceil',\n",
       " 'cfloat',\n",
       " 'char',\n",
       " 'character',\n",
       " 'chararray',\n",
       " 'choose',\n",
       " 'clip',\n",
       " 'clongdouble',\n",
       " 'clongfloat',\n",
       " 'column_stack',\n",
       " 'common_type',\n",
       " 'compare_chararrays',\n",
       " 'compat',\n",
       " 'complex128',\n",
       " 'complex256',\n",
       " 'complex64',\n",
       " 'complex_',\n",
       " 'complexfloating',\n",
       " 'compress',\n",
       " 'concatenate',\n",
       " 'conj',\n",
       " 'conjugate',\n",
       " 'convolve',\n",
       " 'copy',\n",
       " 'copysign',\n",
       " 'copyto',\n",
       " 'core',\n",
       " 'corrcoef',\n",
       " 'correlate',\n",
       " 'cos',\n",
       " 'cosh',\n",
       " 'count_nonzero',\n",
       " 'cov',\n",
       " 'cross',\n",
       " 'csingle',\n",
       " 'ctypeslib',\n",
       " 'cumprod',\n",
       " 'cumproduct',\n",
       " 'cumsum',\n",
       " 'datetime64',\n",
       " 'datetime_as_string',\n",
       " 'datetime_data',\n",
       " 'deg2rad',\n",
       " 'degrees',\n",
       " 'delete',\n",
       " 'deprecate',\n",
       " 'deprecate_with_doc',\n",
       " 'diag',\n",
       " 'diag_indices',\n",
       " 'diag_indices_from',\n",
       " 'diagflat',\n",
       " 'diagonal',\n",
       " 'diff',\n",
       " 'digitize',\n",
       " 'disp',\n",
       " 'divide',\n",
       " 'divmod',\n",
       " 'dot',\n",
       " 'double',\n",
       " 'dsplit',\n",
       " 'dstack',\n",
       " 'dtype',\n",
       " 'e',\n",
       " 'ediff1d',\n",
       " 'einsum',\n",
       " 'einsum_path',\n",
       " 'emath',\n",
       " 'empty',\n",
       " 'empty_like',\n",
       " 'equal',\n",
       " 'errstate',\n",
       " 'euler_gamma',\n",
       " 'exp',\n",
       " 'exp2',\n",
       " 'expand_dims',\n",
       " 'expm1',\n",
       " 'extract',\n",
       " 'eye',\n",
       " 'fabs',\n",
       " 'fastCopyAndTranspose',\n",
       " 'fft',\n",
       " 'fill_diagonal',\n",
       " 'find_common_type',\n",
       " 'finfo',\n",
       " 'fix',\n",
       " 'flatiter',\n",
       " 'flatnonzero',\n",
       " 'flexible',\n",
       " 'flip',\n",
       " 'fliplr',\n",
       " 'flipud',\n",
       " 'float128',\n",
       " 'float16',\n",
       " 'float32',\n",
       " 'float64',\n",
       " 'float_',\n",
       " 'float_power',\n",
       " 'floating',\n",
       " 'floor',\n",
       " 'floor_divide',\n",
       " 'fmax',\n",
       " 'fmin',\n",
       " 'fmod',\n",
       " 'format_float_positional',\n",
       " 'format_float_scientific',\n",
       " 'format_parser',\n",
       " 'frexp',\n",
       " 'frombuffer',\n",
       " 'fromfile',\n",
       " 'fromfunction',\n",
       " 'fromiter',\n",
       " 'frompyfunc',\n",
       " 'fromregex',\n",
       " 'fromstring',\n",
       " 'full',\n",
       " 'full_like',\n",
       " 'gcd',\n",
       " 'generic',\n",
       " 'genfromtxt',\n",
       " 'geomspace',\n",
       " 'get_array_wrap',\n",
       " 'get_include',\n",
       " 'get_printoptions',\n",
       " 'getbufsize',\n",
       " 'geterr',\n",
       " 'geterrcall',\n",
       " 'geterrobj',\n",
       " 'gradient',\n",
       " 'greater',\n",
       " 'greater_equal',\n",
       " 'half',\n",
       " 'hamming',\n",
       " 'hanning',\n",
       " 'heaviside',\n",
       " 'histogram',\n",
       " 'histogram2d',\n",
       " 'histogram_bin_edges',\n",
       " 'histogramdd',\n",
       " 'hsplit',\n",
       " 'hstack',\n",
       " 'hypot',\n",
       " 'i0',\n",
       " 'identity',\n",
       " 'iinfo',\n",
       " 'imag',\n",
       " 'in1d',\n",
       " 'index_exp',\n",
       " 'indices',\n",
       " 'inexact',\n",
       " 'inf',\n",
       " 'info',\n",
       " 'infty',\n",
       " 'inner',\n",
       " 'insert',\n",
       " 'int0',\n",
       " 'int16',\n",
       " 'int32',\n",
       " 'int64',\n",
       " 'int8',\n",
       " 'int_',\n",
       " 'intc',\n",
       " 'integer',\n",
       " 'interp',\n",
       " 'intersect1d',\n",
       " 'intp',\n",
       " 'invert',\n",
       " 'is_busday',\n",
       " 'isclose',\n",
       " 'iscomplex',\n",
       " 'iscomplexobj',\n",
       " 'isfinite',\n",
       " 'isfortran',\n",
       " 'isin',\n",
       " 'isinf',\n",
       " 'isnan',\n",
       " 'isnat',\n",
       " 'isneginf',\n",
       " 'isposinf',\n",
       " 'isreal',\n",
       " 'isrealobj',\n",
       " 'isscalar',\n",
       " 'issctype',\n",
       " 'issubclass_',\n",
       " 'issubdtype',\n",
       " 'issubsctype',\n",
       " 'iterable',\n",
       " 'ix_',\n",
       " 'kaiser',\n",
       " 'kernel_version',\n",
       " 'kron',\n",
       " 'lcm',\n",
       " 'ldexp',\n",
       " 'left_shift',\n",
       " 'less',\n",
       " 'less_equal',\n",
       " 'lexsort',\n",
       " 'lib',\n",
       " 'linalg',\n",
       " 'linspace',\n",
       " 'little_endian',\n",
       " 'load',\n",
       " 'loads',\n",
       " 'loadtxt',\n",
       " 'log',\n",
       " 'log10',\n",
       " 'log1p',\n",
       " 'log2',\n",
       " 'logaddexp',\n",
       " 'logaddexp2',\n",
       " 'logical_and',\n",
       " 'logical_not',\n",
       " 'logical_or',\n",
       " 'logical_xor',\n",
       " 'logspace',\n",
       " 'longcomplex',\n",
       " 'longdouble',\n",
       " 'longfloat',\n",
       " 'longlong',\n",
       " 'lookfor',\n",
       " 'ma',\n",
       " 'mafromtxt',\n",
       " 'mask_indices',\n",
       " 'mat',\n",
       " 'math',\n",
       " 'matmul',\n",
       " 'matrix',\n",
       " 'matrixlib',\n",
       " 'max',\n",
       " 'maximum',\n",
       " 'maximum_sctype',\n",
       " 'may_share_memory',\n",
       " 'mean',\n",
       " 'median',\n",
       " 'memmap',\n",
       " 'meshgrid',\n",
       " 'mgrid',\n",
       " 'min',\n",
       " 'min_scalar_type',\n",
       " 'minimum',\n",
       " 'mintypecode',\n",
       " 'mod',\n",
       " 'modf',\n",
       " 'moveaxis',\n",
       " 'msort',\n",
       " 'multiply',\n",
       " 'nan',\n",
       " 'nan_to_num',\n",
       " 'nanargmax',\n",
       " 'nanargmin',\n",
       " 'nancumprod',\n",
       " 'nancumsum',\n",
       " 'nanmax',\n",
       " 'nanmean',\n",
       " 'nanmedian',\n",
       " 'nanmin',\n",
       " 'nanpercentile',\n",
       " 'nanprod',\n",
       " 'nanquantile',\n",
       " 'nanstd',\n",
       " 'nansum',\n",
       " 'nanvar',\n",
       " 'nbytes',\n",
       " 'ndarray',\n",
       " 'ndenumerate',\n",
       " 'ndfromtxt',\n",
       " 'ndim',\n",
       " 'ndindex',\n",
       " 'nditer',\n",
       " 'negative',\n",
       " 'nested_iters',\n",
       " 'newaxis',\n",
       " 'nextafter',\n",
       " 'nonzero',\n",
       " 'not_equal',\n",
       " 'numarray',\n",
       " 'number',\n",
       " 'obj2sctype',\n",
       " 'object0',\n",
       " 'object_',\n",
       " 'ogrid',\n",
       " 'oldnumeric',\n",
       " 'ones',\n",
       " 'ones_like',\n",
       " 'os',\n",
       " 'outer',\n",
       " 'packbits',\n",
       " 'pad',\n",
       " 'partition',\n",
       " 'percentile',\n",
       " 'pi',\n",
       " 'piecewise',\n",
       " 'place',\n",
       " 'poly',\n",
       " 'poly1d',\n",
       " 'polyadd',\n",
       " 'polyder',\n",
       " 'polydiv',\n",
       " 'polyfit',\n",
       " 'polyint',\n",
       " 'polymul',\n",
       " 'polynomial',\n",
       " 'polysub',\n",
       " 'polyval',\n",
       " 'positive',\n",
       " 'power',\n",
       " 'printoptions',\n",
       " 'prod',\n",
       " 'product',\n",
       " 'promote_types',\n",
       " 'ptp',\n",
       " 'put',\n",
       " 'put_along_axis',\n",
       " 'putmask',\n",
       " 'quantile',\n",
       " 'r_',\n",
       " 'rad2deg',\n",
       " 'radians',\n",
       " 'random',\n",
       " 'ravel',\n",
       " 'ravel_multi_index',\n",
       " 'real',\n",
       " 'real_if_close',\n",
       " 'rec',\n",
       " 'recarray',\n",
       " 'recfromcsv',\n",
       " 'recfromtxt',\n",
       " 'reciprocal',\n",
       " 'record',\n",
       " 'remainder',\n",
       " 'repeat',\n",
       " 'require',\n",
       " 'reshape',\n",
       " 'resize',\n",
       " 'result_type',\n",
       " 'right_shift',\n",
       " 'rint',\n",
       " 'roll',\n",
       " 'rollaxis',\n",
       " 'roots',\n",
       " 'rot90',\n",
       " 'round',\n",
       " 'round_',\n",
       " 'row_stack',\n",
       " 's_',\n",
       " 'safe_eval',\n",
       " 'save',\n",
       " 'savetxt',\n",
       " 'savez',\n",
       " 'savez_compressed',\n",
       " 'sctype2char',\n",
       " 'sctypeDict',\n",
       " 'sctypes',\n",
       " 'searchsorted',\n",
       " 'select',\n",
       " 'set_numeric_ops',\n",
       " 'set_printoptions',\n",
       " 'set_string_function',\n",
       " 'setbufsize',\n",
       " 'setdiff1d',\n",
       " 'seterr',\n",
       " 'seterrcall',\n",
       " 'seterrobj',\n",
       " 'setxor1d',\n",
       " 'shape',\n",
       " 'shares_memory',\n",
       " 'short',\n",
       " 'show_config',\n",
       " 'sign',\n",
       " 'signbit',\n",
       " 'signedinteger',\n",
       " 'sin',\n",
       " 'sinc',\n",
       " 'single',\n",
       " 'singlecomplex',\n",
       " 'sinh',\n",
       " 'size',\n",
       " 'sometrue',\n",
       " 'sort',\n",
       " 'sort_complex',\n",
       " 'source',\n",
       " 'spacing',\n",
       " 'split',\n",
       " 'sqrt',\n",
       " 'square',\n",
       " 'squeeze',\n",
       " 'stack',\n",
       " 'std',\n",
       " 'str0',\n",
       " 'str_',\n",
       " 'string_',\n",
       " 'subtract',\n",
       " 'sum',\n",
       " 'swapaxes',\n",
       " 'sys',\n",
       " 'take',\n",
       " 'take_along_axis',\n",
       " 'tan',\n",
       " 'tanh',\n",
       " 'tensordot',\n",
       " 'test',\n",
       " 'testing',\n",
       " 'tile',\n",
       " 'timedelta64',\n",
       " 'trace',\n",
       " 'tracemalloc_domain',\n",
       " 'transpose',\n",
       " 'trapz',\n",
       " 'tri',\n",
       " 'tril',\n",
       " 'tril_indices',\n",
       " 'tril_indices_from',\n",
       " 'trim_zeros',\n",
       " 'triu',\n",
       " 'triu_indices',\n",
       " 'triu_indices_from',\n",
       " 'true_divide',\n",
       " 'trunc',\n",
       " 'typecodes',\n",
       " 'typename',\n",
       " 'ubyte',\n",
       " 'ufunc',\n",
       " 'uint',\n",
       " 'uint0',\n",
       " 'uint16',\n",
       " 'uint32',\n",
       " 'uint64',\n",
       " 'uint8',\n",
       " 'uintc',\n",
       " 'uintp',\n",
       " 'ulonglong',\n",
       " 'unicode_',\n",
       " 'union1d',\n",
       " 'unique',\n",
       " 'unpackbits',\n",
       " 'unravel_index',\n",
       " 'unsignedinteger',\n",
       " 'unwrap',\n",
       " 'use_hugepage',\n",
       " 'ushort',\n",
       " 'vander',\n",
       " 'var',\n",
       " 'vdot',\n",
       " 'vectorize',\n",
       " 'version',\n",
       " 'void',\n",
       " 'void0',\n",
       " 'vsplit',\n",
       " 'vstack',\n",
       " 'warnings',\n",
       " 'where',\n",
       " 'who',\n",
       " 'zeros',\n",
       " 'zeros_like']"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(np)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Todavía necesito más ayuda sobre cómo usar uno de los métodos: \n",
    "\n",
    "### Ayuda del método linspace de la librería numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function linspace in module numpy:\n",
      "\n",
      "linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0)\n",
      "    Return evenly spaced numbers over a specified interval.\n",
      "    \n",
      "    Returns `num` evenly spaced samples, calculated over the\n",
      "    interval [`start`, `stop`].\n",
      "    \n",
      "    The endpoint of the interval can optionally be excluded.\n",
      "    \n",
      "    .. versionchanged:: 1.16.0\n",
      "        Non-scalar `start` and `stop` are now supported.\n",
      "    \n",
      "    .. versionchanged:: 1.20.0\n",
      "        Values are rounded towards ``-inf`` instead of ``0`` when an\n",
      "        integer ``dtype`` is specified. The old behavior can\n",
      "        still be obtained with ``np.linspace(start, stop, num).astype(int)``\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    start : array_like\n",
      "        The starting value of the sequence.\n",
      "    stop : array_like\n",
      "        The end value of the sequence, unless `endpoint` is set to False.\n",
      "        In that case, the sequence consists of all but the last of ``num + 1``\n",
      "        evenly spaced samples, so that `stop` is excluded.  Note that the step\n",
      "        size changes when `endpoint` is False.\n",
      "    num : int, optional\n",
      "        Number of samples to generate. Default is 50. Must be non-negative.\n",
      "    endpoint : bool, optional\n",
      "        If True, `stop` is the last sample. Otherwise, it is not included.\n",
      "        Default is True.\n",
      "    retstep : bool, optional\n",
      "        If True, return (`samples`, `step`), where `step` is the spacing\n",
      "        between samples.\n",
      "    dtype : dtype, optional\n",
      "        The type of the output array.  If `dtype` is not given, the data type\n",
      "        is inferred from `start` and `stop`. The inferred dtype will never be\n",
      "        an integer; `float` is chosen even if the arguments would produce an\n",
      "        array of integers.\n",
      "    \n",
      "        .. versionadded:: 1.9.0\n",
      "    \n",
      "    axis : int, optional\n",
      "        The axis in the result to store the samples.  Relevant only if start\n",
      "        or stop are array-like.  By default (0), the samples will be along a\n",
      "        new axis inserted at the beginning. Use -1 to get an axis at the end.\n",
      "    \n",
      "        .. versionadded:: 1.16.0\n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    samples : ndarray\n",
      "        There are `num` equally spaced samples in the closed interval\n",
      "        ``[start, stop]`` or the half-open interval ``[start, stop)``\n",
      "        (depending on whether `endpoint` is True or False).\n",
      "    step : float, optional\n",
      "        Only returned if `retstep` is True\n",
      "    \n",
      "        Size of spacing between samples.\n",
      "    \n",
      "    \n",
      "    See Also\n",
      "    --------\n",
      "    arange : Similar to `linspace`, but uses a step size (instead of the\n",
      "             number of samples).\n",
      "    geomspace : Similar to `linspace`, but with numbers spaced evenly on a log\n",
      "                scale (a geometric progression).\n",
      "    logspace : Similar to `geomspace`, but with the end points specified as\n",
      "               logarithms.\n",
      "    \n",
      "    Examples\n",
      "    --------\n",
      "    >>> np.linspace(2.0, 3.0, num=5)\n",
      "    array([2.  , 2.25, 2.5 , 2.75, 3.  ])\n",
      "    >>> np.linspace(2.0, 3.0, num=5, endpoint=False)\n",
      "    array([2. ,  2.2,  2.4,  2.6,  2.8])\n",
      "    >>> np.linspace(2.0, 3.0, num=5, retstep=True)\n",
      "    (array([2.  ,  2.25,  2.5 ,  2.75,  3.  ]), 0.25)\n",
      "    \n",
      "    Graphical illustration:\n",
      "    \n",
      "    >>> import matplotlib.pyplot as plt\n",
      "    >>> N = 8\n",
      "    >>> y = np.zeros(N)\n",
      "    >>> x1 = np.linspace(0, 10, N, endpoint=True)\n",
      "    >>> x2 = np.linspace(0, 10, N, endpoint=False)\n",
      "    >>> plt.plot(x1, y, 'o')\n",
      "    [<matplotlib.lines.Line2D object at 0x...>]\n",
      "    >>> plt.plot(x2, y + 0.5, 'o')\n",
      "    [<matplotlib.lines.Line2D object at 0x...>]\n",
      "    >>> plt.ylim([-0.5, 1])\n",
      "    (-0.5, 1)\n",
      "    >>> plt.show()\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(np.linspace)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "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"
  },
  "rise": {
   "autolaunch": false,
   "enable_chalkboard": false,
   "theme": "simple",
   "transition": "slide"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}