intro-numpy.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "view-in-github"
   },
   "source": [
    "<a href=\"https://colab.research.google.com/github/mcd-unison/material-programacion/blob/main/intro-numpy.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "mIbHKZ-mXY6A"
   },
   "source": [
    "<center>\n",
    "<p><img src=\"https://mcd.unison.mx/wp-content/themes/awaken/img/logo_mcd.png\" width=\"100\">\n",
    "</p>\n",
    "\n",
    "\n",
    "\n",
    "# Curso Propedéutico en *Programación*\n",
    "\n",
    "## Introducción a `numpy` y `matplotlib`\n",
    "\n",
    "\n",
    "**Julio Waissman Vilanova**\n",
    "\n",
    "</center>\n",
    "\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "TBA7lyBwXY6B"
   },
   "source": [
    "## Iniciando una libreta de `jupyter`"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "nUjm0Tt8XY6B"
   },
   "source": [
    "Para inicializar la libreta siempre es saludable (como en la mayoría de los lenguajes de programación) poner al principio las biblotecas (modulos en python), así como los comandos al sistema y de ser posible la descarga de datos.\n",
    "\n",
    "En este caso vamos a practicar y aprender el uso de los modulos `numpy` y `matplotlib`.\n",
    "\n",
    "Tambien vamos a utilizar un comando *mágico* para decirle donde queremos los gráficos de `matplotlib`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "XRY8HAwuXY6C"
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Para insertar las gráficas dentro del entorno\n",
    "%matplotlib inline"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "wb7pq2mDXY6C"
   },
   "source": [
    "Recuerda que hay que ejecutar cada celda (cell) con *ctrl-enter* o con el simbolo de ejecutar. Un número que indica el orden en que se han ido ejecutando las celdas se va apareciendo. Fijate que si la ejecutas varias veces, el número se incrementa. \n",
    "\n",
    "Un grave problema de diseño de las libretas `jupyter`que siempre molesta (con razón) a los ingenieros de software, es que el orden de las celdas no es mandatorio. Es muy importante conocer la secuencia en que uno ejecutó las celdas, si no, el resultado puede ser inesperado para uno. Veremos unos ejemplos.\n",
    "\n",
    "La primer linea es un comando conocidos como *comandos mágicos*. En este comando le especificamos a la libreta que vamos a utilizar `matplotlib` para hacer gráficas y que queremos que las anexe dentro del documento. \n",
    "\n",
    "Si quieres que tu documentación sea atractiva se puede utilizar [estas características de `markdown` que funcionan en las libretas de colab](https://colab.research.google.com/notebooks/markdown_guide.ipynb).\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "1RT4tJO4XY6D"
   },
   "source": [
    "## Pequeños trucos en `jupyter` y colab "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "LiruZ79qXY6D"
   },
   "source": [
    "En `jupyter` hay varios trucos que facilitan la vida como desarrolladores, vamos a ver unos pocos. Primero y antes que nada, como obtener ayuda sobre una función y autocompletado.\n",
    "\n",
    "El autocompletado se obtiene con la tecla `TAB`. Una vez que la función, método o clase se encuentra completa, se puede consultar su documentación en linea. Para eso se utilizan la combinación `SHIFT` + `TAB`. Si se realiza una sola vez, Jupyter presenta solo los argumentos, dos veces, se extiende a una pequeña presentación (en cuadro) de los argumentos, tres veces, da una versión más detallada, y 4 veces, lo presenta en un marco independiente, para tener la documentación a la mano mientras se implementa la función.\n",
    "\n",
    "Sin embargo, en colab las cosas no funcionan igual. Dentro de colab, el autocompletado se realiza en forma automática, y si quiere uno la documentación, se inicia con paréntesis abierto, como si se fuera a aplicar una función o a inicializar un objeto. Entonces empieza la documentación en un *tooltip*. Si es la celda activa, poner el cursor sobre un comando o clase nos da la documentación básica de éste.Otra manera de obtener la documentación, es usando el comando mñagico `?`.\n",
    "\n",
    "Vamos a experimentar con la primer función que vamos a utilizar en este tutorial:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "bnlfa5BjXY6D"
   },
   "outputs": [],
   "source": [
    "np.array"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "4Vmer2SqXY6E"
   },
   "source": [
    "En Jupyter existen varias funciones que se llaman *mágicas* las cuales empiezan siempre con %. La más común es `%matplotlib inline` para realizar gráficas dentro de la libreta y no que las genere en forma independiente. Otras muy usadas son %time Para calcular el tiempo que tarda en ejecitarse una celda, y %prun para hacer profile de la celda. \n",
    "\n",
    "Por ejemplo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "pFOeZkRrXY6E"
   },
   "outputs": [],
   "source": [
    "%time sum([x for x in range(100000)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "eVcARp0DXY6F"
   },
   "outputs": [],
   "source": [
    "%prun sum([x for x in range(100000)])"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "i4LajNnsXY6F"
   },
   "source": [
    "En general los comandos mágicos se pueden consultar con otro comando mágico"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "s-tOMpnbXY6F"
   },
   "outputs": [],
   "source": [
    "%quickref"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "lxXdNOoHfSgM"
   },
   "source": [
    "Existen muchos comandos mágicos, algunos muy útiles que vamos a ir viendo sobre la marcha. Para una explicacion mas completa vamos a darnos una vueltacita [a esta libreta](https://colab.research.google.com/github/jdwittenauer/ipython-notebooks/blob/master/notebooks/language/IPythonMagic.ipynb)."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "XHcKcDatXY6G"
   },
   "source": [
    "## Inicializando variables en `numpy`"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "YMV2RinIXY6G"
   },
   "source": [
    "`numpy` agrega a python básicamente dos nuevos tipos o clases, de los cuales solo nos vamos a interesar por los arreglos multidimensionales o `ndarray`. La manera más sencilla de crear un array (vector o matriz) es utilizando `array` como:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "hY6OAEfCXY6G"
   },
   "outputs": [],
   "source": [
    "# Crea un objeto vector\n",
    "vector_a = np.array([1, 3.1416, 40, 0, 2, 5])\n",
    "print(\"vector a = \" )\n",
    "print(vector_a)\n",
    "\n",
    "# Crea una matriz\n",
    "matriz_A = np.array([[1, 2], [3, 4], [5, 6]])\n",
    "print(\"matriz A = \") \n",
    "print(matriz_A)\n",
    "\n",
    "type(matriz_A)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "i3W7r0E6XY6H"
   },
   "source": [
    "Esta es la manera más directa pero no la única (y en muchos casos la mas usada) para crear nuevos vectores multidimensionales. Existen otras maneras de generar arreglos como son las funciones:\n",
    "\n",
    "* `arange(ini=0, fin, inc=1)`: Devuelve un ndarray iniciando en `ini` y terminando en `fin`, con incrementos de inc\n",
    "\n",
    "* `zeros(dim)`: Devuelve un ndarray de dimensión `dim` (si es un escalar se considera un vector, si es una tupla de números entonces son las dimensiones del ndarray), con todas sus entradas en cero. \n",
    "      \n",
    "* `ones(dim)`: Similar a `zeros()` pero con unos.\n",
    "    \n",
    "* `eye(x, y=none)`: si solo se tiene el argumento `x` devuelve una matriz identidad de $x \\times x$. Si se encuentra `y`, entonces una matriz diagonal rectangular de dimensión x por y.\n",
    "      \n",
    "* `zeros_like(x)`: Un ndarray de ceros de la misma dimensión que `x` (igual existe `ones_like`).\n",
    "    \n",
    "* `linspace(inicial, final, elementos)`: Devuelve un ndarray de una dimensión iniciando en inicial, hasta final de \n",
    "manera que existan elementos numeros igualmente espaciados. Muy útil para graficación principalmente.\n",
    "      \n",
    "* `random.rand(dim1, dim2, ...)`: Devuelve un ndarray de dimensiones `dim1` por `dim2` por ... con números aleatorios\n",
    "generados por una distribución uniforme entre 0 y 1. \n",
    "      \n",
    "Veamos unos cuantos ejemplos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "jyEpTwNbXY6H"
   },
   "outputs": [],
   "source": [
    "vZ = np.zeros(5)\n",
    "print(\"Un vector de ceros con 5 valores\")\n",
    "print(vZ)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "LGUzUKGyXY6I"
   },
   "outputs": [],
   "source": [
    "mO = np.ones((3, 10))\n",
    "print(\"Una matriz de 3 x 10 de puron unos\")\n",
    "print(mO)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "WBvgzjWTXY6I"
   },
   "outputs": [],
   "source": [
    "va = np.arange(10)\n",
    "print(\"va = \", va)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "lpg2YwU-XY6I"
   },
   "outputs": [],
   "source": [
    "vb = np.arange(20,-10,-5)\n",
    "print(f\"vb = {vb}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "-0V5RB1iXY6J"
   },
   "outputs": [],
   "source": [
    "print(\"Una matriz de ceros de las dimensiones de mO:\")\n",
    "print(np.zeros_like(mO))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ISmGBXWvXY6J"
   },
   "outputs": [],
   "source": [
    "mA = np.random.rand(5, 12)\n",
    "print(\"Y una matriz con números aleatorios bajo una distribución uniforme entre 0 y 1\")\n",
    "print(mA)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "TEypDz2DXY6K"
   },
   "source": [
    "### Vamos a practicar"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "NVDQIJyvXY6K"
   },
   "source": [
    "En la siguiente celda (o puedes crear las que consideres convenientes) crea las siguientes matrices:\n",
    "\n",
    "* Una matriz de 4 por 6 con valores aleatorios de acuerdo a una distribución normal con media cero y varianza unitaria.\n",
    "    \n",
    "* Un vector de 10 elementos con valores aleatorios de números enteros entre 4 y 100\n",
    "    \n",
    "* Una matriz diagonal de 5 por 5 cuyos elementos de la diagonal sean (1, 2, 3, 4, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "QhLKdPPBXY6K"
   },
   "outputs": [],
   "source": [
    "# Introduce aqui tus respuestas\n",
    "\n",
    "#Recuerda probar con el autocompletado de las celdas, así como la documentación en linea"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "e899rnczXY6K"
   },
   "source": [
    "## Operaciones básicas de los ndarray"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "n2mSkwWtXY6L"
   },
   "source": [
    "La mayoría de las operaciones que se pueden aplicar en los `ndarray`\n",
    " se encuenran en el espacio de nombres de np, y las cuales son bastante directas tal como:\n",
    "\n",
    "    b = np.sin(a)\n",
    "\n",
    "la cual devuelve en b un ndarray de las mismas dimensiones que a, cuyas entradas son el seno de las entradas de a (en radianes).\n",
    "Así, parece inecesario explicar las funciones cos, tan, tanh, acos, asin, etc..\n",
    "\n",
    "Otras funciones muy útiles no son tan directas. Veamos algunas:\n",
    "\n",
    "    c = a + b\n",
    "\n",
    "es la suma de dos ndarray, bastante obvio, lo que no lo es tanto es:\n",
    "\n",
    "    c = a * b\n",
    "\n",
    "la cual es un ndarray resultante de la *multiplicación punto a punto* de los elementos de a y b, asumiendo que ambos tienen\n",
    "las mismas dimensiones. ¿Y para aplicar un producto matricial? Pues se utiliza el comando dot (o producto punto) el cual puede ser\n",
    "expresado de tres formas:\n",
    "\n",
    "    c = np.dot(a, b)\n",
    "    c = a.dot(b)\n",
    "    c = a @ b\n",
    "\n",
    "La suma de los elementos de un ndarray tambien es un método del objeto (como min, max, argmin, argmax, etc...)\n",
    "\n",
    "    b = a.sum()\n",
    "\n",
    "es la suma de *todos los elementos del array* mientras que\n",
    "\n",
    "    b = a.sum(axis=0) \n",
    "\n",
    "es un ndarray con una dimensión menos que a, con la suma de las columnas. Veamos unos ejemplos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "MYD1qpN2XY6L"
   },
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "# Vamos a generar varios ndarrays\n",
    "a = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "b = np.random.rand(2, 3)\n",
    "\n",
    "print(\"a = \")\n",
    "print(a)\n",
    "\n",
    "print(\"b = \")\n",
    "print(b)\n",
    "\n",
    "print(\"Suma de todos los números de b\")\n",
    "print(b.sum())\n",
    "print(np.sum(b))\n",
    "\n",
    "print(\"Media de cada columna de a\")\n",
    "print(a.mean(axis=0))\n",
    "print(np.mean(a, axis=0))\n",
    "\n",
    "print(\"Transpuesta de a\")\n",
    "print(a.transpose())\n",
    "print(a.T)\n",
    "\n",
    "print(\"10 * b = \")\n",
    "print(10 * b)\n",
    "\n",
    "print(\"a * b =\")\n",
    "print(a * b)\n",
    "\n",
    "print(\"2 elevado a la matriz a\")\n",
    "print(np.power(2, a))\n",
    "\n",
    "print(\"a elevada al cuadrado (elemento a elemento)\")\n",
    "print(np.power(a, 2))\n",
    "\n",
    "print(\"Producto punto de a con b transpuesta\")\n",
    "print(a.dot(b.T))\n",
    "print(np.dot(a, b.T))\n",
    "print(a @ b.T)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "higGz83ai1rN"
   },
   "outputs": [],
   "source": [
    "print(\"a.dot(b) debería dar error\")\n",
    "print(a.T @ b)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "aVka0KiqXY6M"
   },
   "source": [
    "Como vemos tenemos aqui una bateria completa de funciones, las cuales se aplican en un ndarray. ¿Pero que información tengo de un ndarray? ¿Como puedo componer un ndarray a partir de otros?  Asumamos por ejemplo un ndarray de una dimensión:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "sW6Ff6gNXY6M"
   },
   "outputs": [],
   "source": [
    "#Generamos el ndarray\n",
    "a = np.arange(100)\n",
    "\n",
    "# Checamos algunas propiedades\n",
    "print(\"El número de dimensiones de a es: \", a.ndim)\n",
    "print(\"Y su forma es \", a.shape)\n",
    "print(\"Y tiene \", a.size, \" elementos\")\n",
    "\n",
    "#Generamos algunos ndarrays a partir de a\n",
    "b, c = a[:20], a[20:]\n",
    "d, e = a[-1:-10:-1], a[10:11]\n",
    "f = a[::-1]\n",
    "g = a[a % 5 == 0]\n",
    "h = f[[1, 15, 60]]\n",
    "\n",
    "# Ahora trata de inferir que es lo que debe contener cada array b, c, d, e, f, g, h sin hacer ninguna prueba.\n",
    "\n",
    "# Agrega ahora los print que consideres necesarios para verificar que valores tiene b, c, d, e, f, g, h "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "h"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "pP9HLjSPXY6M"
   },
   "source": [
    "A partir de una matriz (un ndarray de dos dimensiones) se pueden ejemplificar otras cosas, por ejemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "mBpUn6dIXY6N"
   },
   "outputs": [],
   "source": [
    "#Generamos un arreglo con 100 valores equiespaciados del seno desde 0 a 2$\\pi$\n",
    "a = np.sin(np.linspace(0, 2 * np.pi, 100))\n",
    "\n",
    "#Lo convertimos en una matriz de 10 por *lo que sea* (-1), donde *lo que sea* es 10 en este caso, \n",
    "b = a.reshape((10, -1))\n",
    "print(\"b queda como: \")\n",
    "print(b)\n",
    "print(\"donde b tiene \", b.ndim, \" dimensiones, con una forma \", b.shape, \"y con \", b.size, \" elementos.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "-hVc-LtwXY6N"
   },
   "outputs": [],
   "source": [
    "#Si queremos convertir un ndarray a un array de una sola dimension (desenrrollar la matriz podría ser el término)\n",
    "c = b.ravel()\n",
    "\n",
    "print(\"La diferencia absoluta de a y c sería\")\n",
    "print(np.sum(np.abs(a - c)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "9NuoY-PJXY6N"
   },
   "outputs": [],
   "source": [
    "# Si queremos hacer que un vector se comporte como un vector renglon\n",
    "a = np.arange(30).reshape(1,-1)\n",
    "print(\"a es de forma \", a.shape)\n",
    "\n",
    "# Y si queremos que sea un vector columna hacemos esto\n",
    "b = np.linspace(30, 35, 30).reshape(-1,1)\n",
    "print(\"b es de forma \", b.shape)\n",
    "\n",
    "# Y para hacer una concatenacion de columnas entonces utilizamps la forma especial np._[]\n",
    "c = np.c_[a.T, b]\n",
    "print(\"c es de forma \", c.shape)\n",
    "\n",
    "#Y una concatenación de renglones es por lo tanto\n",
    "d = np.r_[a.T, b]\n",
    "print(\"d es de forma \", d.shape)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "OutgQm9PXY6N"
   },
   "source": [
    "### Seguimos practicando"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "XUd1p-BxXY6O"
   },
   "source": [
    "1. Genera una matriz de 100 por 5 de forma que en cada columna tengamos lo siguiente:\n",
    "    \n",
    "  - En la primer columna los valores entre -1 y 1, equiespaciados\n",
    "\n",
    "  - En la segunda columna el valor de seno para los valores de la primer columna\n",
    "\n",
    "  - En la tercer columna el valor de la función logística de los valores de la primer columna, la cual es   \n",
    "  $$g(x) = \\frac{1}{1 + \\exp(-x)}$$\n",
    "\n",
    "  - En la cuarta columna 1 si el valor de la segunda columna es mayor que cero y -1 en otro caso (revisa la función np.where)\n",
    "\n",
    "  - En la quinta columna valores aleatorios de acuerdo a una distribución gaussiana con media 1 y varianza 0.5\n",
    "        \n",
    "2. Encuentra un arreglo con todos los valores de la función logística, cuando el valor absoluto del seno de x es menor a 0.5 y asignala a una variable llamada `toto_2`\n",
    "    \n",
    "3. Convierte este arreglo en una matriz con 5 columnas y los renglones que sean necesarios.\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "JDv69DmPXY6O"
   },
   "outputs": [],
   "source": [
    "# Escribe aqui tu código"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "YCjWBGDSXY6O"
   },
   "source": [
    "Además de estas funciones, numpy cuenta con funciones del algebra lineal altamente optimizadas (aunque no paralelizadas), las cuales son (entre otras):\n",
    "\n",
    "* `np.linalg.inv(a)`: Inversa de a\n",
    "* `np.linalg.pinv(a)`: Pseudoinversa de Ross-Penrose de a (muy útil para nosotros)\n",
    "* `np.linalg.det(a)`: determinante de a\n",
    "* `np.linalg.eig(a)`: eigenvalores y eigenvectores de a\n",
    "* `np.linalg.svd(a)`: Valores singulares de a"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "np1nh8Y5XY6O"
   },
   "source": [
    "## Haciendo gráficas sencillas con Matplotlib"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "dtGEjeFIXY6O"
   },
   "source": [
    "La mejor manera de mostrar como funcionan las facilidades que ofrece matplotlib, es mostrando directamente su uso más sencillo,\n",
    "así que veamos un ejemplo muy simple. Es importante recordar que en la primer celda de esta libreta se definió la manera de realizar las gráficas (dentro del documento y no como figuras aparte), así como se cargo matplotlib en el espacio de nombres plt."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 315
    },
    "id": "NsQfL3y4XY6P",
    "outputId": "c0f28a09-d64c-4178-dfbf-41a4cecd4435"
   },
   "outputs": [],
   "source": [
    "# Vamos a hacerlo pasito a pasito\n",
    "\n",
    "# Primero obtenemos un vector x\n",
    "x = np.linspace(-np.pi, np.pi, 1000)\n",
    "\n",
    "# Luego obtenemos un vector y bastante trivial\n",
    "y = np.sin(x)\n",
    "\n",
    "# Y ahora hacemos una gráfica bastante básica de x y y\n",
    "plt.plot(x, y)\n",
    "plt.xlabel(\"el eje de las x's\")\n",
    "plt.ylabel(\"el eje de las y's\")\n",
    "plt.title(\"Este es un plot bastante trivial y sin mucho chiste\")\n",
    "\n",
    "# Bueno como la gráfica no esta muy bien a lo mejor se ve mejor si modificamos los limites de los ejes\n",
    "plt.axis([-3.1416, 3.1416, -1.1, 1.1])\n",
    "plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "EGxTW0LiXY6P"
   },
   "source": [
    "Aunque a veces queremos hacer unas gráficas más bien indicativas por lo que un estilo más informal podría ser útil:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 323
    },
    "id": "LD_ieG0MXY6P",
    "outputId": "b37d64fc-1a3c-4fe2-8637-c666cc2fad0f"
   },
   "outputs": [],
   "source": [
    "with plt.xkcd():\n",
    "    plt.plot(x, y)\n",
    "    plt.xlabel(\"el eje de las x's\")\n",
    "    plt.ylabel(\"el eje de las y's\")\n",
    "    plt.title(\"Este es un plot bastante trivial y sin mucho chiste\")\n",
    "    plt.axis([-3.1416, 3.1416, -1.1, 1.1])\n",
    "    plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "8Ji3LQHPXY6P"
   },
   "source": [
    "Hay que tener mucho cuidado, ya que si no se utiliza plt.xkcd() dentro de un with, entonces va a modificar todas las graficas que se realicen en la libreta (a veces es deseable, pero es una mejor práctica de programación hacerlo así)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 320
    },
    "id": "gN-DtEIvXY6Q",
    "outputId": "469a0105-ced3-4d0b-b6cd-044701de7497"
   },
   "outputs": [],
   "source": [
    "with plt.style.context(('ggplot')):\n",
    "    plt.plot(x, y)\n",
    "    plt.xlabel(\"el eje de las x's\")\n",
    "    plt.ylabel(\"el eje de las y's\")\n",
    "    plt.title(\"Este es un plot bastante trivial y sin mucho chiste\")\n",
    "    plt.axis([-3.1416, 3.1416, -1.1, 1.1])\n",
    "    plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "2_tQHlnuXY6Q"
   },
   "source": [
    "Ahora hagamos una gráfica con varios valores diferentes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 376
    },
    "id": "RljRqdt5XY6Q",
    "outputId": "9b378cad-3cee-40af-cf71-30b757598702"
   },
   "outputs": [],
   "source": [
    "with plt.style.context(('ggplot')):\n",
    "\n",
    "  fig = plt.figure(figsize=(10, 5))\n",
    "\n",
    "  plt.plot(x, np.sin(x), label='seno')\n",
    "  plt.plot(x, 1/(1 + np.exp(-x)), label=u\"logística\")\n",
    "  plt.plot(x, (0.2 * x * x) - 0.5, label=r'$0.2 x^2 - 0.5$')\n",
    "\n",
    "  plt.axis([-3.1416, 3.1416, -1.1, 1.4])\n",
    "\n",
    "  plt.title(\"Tres funciones piteras juntas\")\n",
    "  plt.xlabel(r\"$\\theta$ (rad)\")\n",
    "  plt.ylabel(\"magnitud\")\n",
    "\n",
    "  plt.legend(loc=0)\n",
    "\n",
    "  plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "-NfV22QmXY6Q"
   },
   "source": [
    "Hay muchos tipos de funciones, lo mejor para saber como utilizar matplotlib es ver la galería de ejemplos que se encuentran en la ayuda,\n",
    "y pueden consultarse en https://matplotlib.org/stable/gallery/index.html (al darle click a una imagen se puede ver el código que la genera).\n",
    "\n",
    "Por ejemplo si queremos una gráfica tipo pay:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 285
    },
    "id": "21SXCxDpXY6R",
    "outputId": "9ad9b5ab-62f8-4aae-eae1-fe1674348e59"
   },
   "outputs": [],
   "source": [
    "labels = 'Tortas', 'Taquitos', 'Burros', 'Ensaladas'\n",
    "porcentajes = [15, 30, 45, 10]\n",
    "colores = ['yellowgreen', 'gold', 'lightskyblue', 'lightcoral']\n",
    "separa = (0, 0.1, 0, 0) # solo separa la segunda rebanada (i.e. 'Taquitos')\n",
    "\n",
    "with plt.xkcd():\n",
    "    plt.pie(porcentajes, explode=separa, labels=labels, colors=colores, autopct='%1.1f%%', shadow=True, startangle=90)\n",
    "    plt.axis('equal') #Para que el pay se vea como un círculo\n",
    "    plt.xlabel(u'Lo que como cuando no alcanzo a salir a comer')\n",
    "    plt.show()\n"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "tQgQ_SGeXY6R"
   },
   "source": [
    "O si queremos una gráfica tipo contorno con todo y datos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 292
    },
    "id": "AlmfN7lAXY6R",
    "outputId": "a597b7aa-2cc0-4d06-9d90-63c0a0ca71c3"
   },
   "outputs": [],
   "source": [
    "from matplotlib import ticker, cm\n",
    "\n",
    "N = 100\n",
    "x = np.linspace(-3.0, 3.0, N)\n",
    "y = np.linspace(-2.0, 2.0, N)\n",
    "\n",
    "X, Y = np.meshgrid(x, y)\n",
    "\n",
    "# Vamos a crear un valor de Z usando la suma de dos funciones\n",
    "Z1 = np.exp(-X**2 - Y**2)\n",
    "Z2 = np.exp(-(X * 10)**2 - (Y * 10)**2)\n",
    "z = Z1 + 50 * Z2\n",
    "\n",
    "# ponemos algunos puntos negativos para ver los problemas que pueden causar:\n",
    "z[:5, :5] = -1\n",
    "\n",
    "# Esta linea es para evitar un warning, pero se puede quitar para ver\n",
    "# que avisa el sistema.\n",
    "z = np.ma.masked_where(z <= 0, z)\n",
    "\n",
    "\n",
    "# Automatic selection of levels works; setting the\n",
    "# log locator tells contourf to use a log scale:\n",
    "fig, ax = plt.subplots()\n",
    "cs = ax.contourf(X, Y, z, locator=ticker.LogLocator(), cmap=cm.PuBu_r)\n",
    "\n",
    "# Tambien se pueden ajustar los niveles de forma manual\n",
    "# levs = np.linspace(0, z.max(), 200)\n",
    "# cs = ax.contourf(X, Y, z, levs)\n",
    "\n",
    "cbar = fig.colorbar(cs)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "EcIc-KagXY6R"
   },
   "source": [
    "Por último, un detalle muy importante y que puede ser de mucha utilidad: La generación de subplots. Una figura puede contener varias subgraficas, para esto hay que especificar en cuantas gráficas vamos a dividir la figura en forma de renglones y columnas, y luego seleccionar la subgráfica en la que vamos a graficar. Por ejemplo\n",
    "\n",
    "    plt.subplot(2,2,1)\n",
    "    \n",
    "significa que la figura la vamos a dividir en 2 renglones y dos columnas (cuatro subgráficas) y vamos a escribir sobre la subgráfica 1. Lo mejor es ilustrarlo con un ejemplo muy simple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 466
    },
    "id": "MY2P05sCXY6S",
    "outputId": "8f5ab342-9bfb-4055-d937-7ae3bbafeaaa"
   },
   "outputs": [],
   "source": [
    "x = np.linspace(0, 5, 1000)\n",
    "y1 = np.exp(-0.2 * x) * np.cos(2 * np.pi * x)\n",
    "y2 = np.cos(2 * np.pi * x)\n",
    "y3 = np.exp(0.2 * x) * np.cos(2 * np.pi * x)\n",
    "y4 = np.exp(-0.1 * x)\n",
    "\n",
    "with plt.style.context(('ggplot')):\n",
    "  plt.figure(figsize=(15,7))\n",
    "\n",
    "  plt.subplot(2, 2, 1)\n",
    "  plt.plot(x, y1)\n",
    "  plt.title('Estable subamortiguado')\n",
    "\n",
    "  plt.subplot(2, 2, 2)\n",
    "  plt.plot(x, y2)\n",
    "  plt.title('Criticamente estable')\n",
    "\n",
    "  plt.subplot(2, 2, 3)\n",
    "  plt.plot(x, y3)\n",
    "  plt.title('inestable')\n",
    "\n",
    "  plt.subplot(2, 2, 4)\n",
    "  plt.plot(x, y4)\n",
    "  plt.title('Estable sobreamortiguado')\n",
    "  \n",
    "  plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "UKXLiq_JXY6S"
   },
   "source": [
    "### Practiquemos haciendo algunas gráficas"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {
    "id": "3FltoLKHXY6S"
   },
   "source": [
    "Realiza lo siguiente en varias celdas abajo de esta:\n",
    "\n",
    "1. Genera un vector de 1000 datos aleatorios distribuidos de acuerdo a una gaussiana con media 3 y varianza .5, y otro vector con 1000 datos aleatorios distribuidos con una media 0 y una varianza unitaria. Al concatenar los dos vectores, estás generando una serie de datos proveniente de una distribución conocida como suma de gaussianas. Para ver como es esta distribución de datos, realiza un histograma (con un número suficiente de bins).\n",
    "\n",
    "2. Genera un vector de datos de entrada `x = np.linspace(0, 1, 1000)` y grafica $\\sin(2\\pi x)$, $\\sin(4\\pi x)$, $\\sin(8\\pi x)$. ¿Que conlusión puedes sacar al respecto? Realiza la gráfica con titulo, ejes, etiquetas y todo lo necesario para que sea publicable.\n",
    "\n",
    "3. Grafíca la función $e^{-t}\\cos(2\\pi t)$ para $t \\in [0, 5]$. Asegurate que la gráfica sea una linea punteada de color rojo, que la gráfica tenga título, etiqueta en el eje de $t$ (tiempo), etiqueta en el eje de $y$ (voltaje en $\\mu V$), y una nota donde se escriba la ecuación simulada.\n",
    "\n",
    "4. Copia un ejemplo de la galería de matplotlib (por ejemplo [este](https://matplotlib.org/stable/gallery/lines_bars_and_markers/spectrum_demo.html#sphx-glr-gallery-lines-bars-and-markers-spectrum-demo-py) o [este](https://matplotlib.org/stable/gallery/images_contours_and_fields/contour_demo.html#sphx-glr-gallery-images-contours-and-fields-contour-demo-py), o [este inclusive](https://matplotlib.org/stable/gallery/lines_bars_and_markers/fill_between_demo.html#sphx-glr-gallery-lines-bars-and-markers-fill-between-demo-py)) y modificalo para que se grafique dentro de la libreta. Una vez funcionando, comenta el código, dejando bien claro **en español y con tus palabras** que es lo que hace cada una de las lineas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "CykWxflvXY6S"
   },
   "outputs": [],
   "source": [
    "#Agrega aqui el primer problema y resuelve cada problema en una celda independiente."
   ]
  }
 ],
 "metadata": {
  "colab": {
   "collapsed_sections": [],
   "include_colab_link": true,
   "name": "Copia de Introducción_numpy_matplotlib.ipynb",
   "provenance": []
  },
  "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}