C02.3 Numpy(funciones de matrices).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"logo.png\">"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Gestión y análisis de datos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Debido a las características de los arreglos de *Numpy* para hacer \"broadcasting\", la biblioteca cuenta con una amplia gama de funciones se transmiten a los elementos seleccionados de un arreglo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funciones trigonométricas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### La función ```np.sin()```.\n",
    "\n",
    "Regresa un arreglo en el que cada elemento es el seno de un ángulo expresado en radianes calculado a partir de cada elemento del arreglo que se ingresa como argumento.\n",
    "\n",
    "La documentación de dicha función se encuentra en:\n",
    "\n",
    "https://numpy.org/doc/stable/reference/generated/numpy.sin.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### La función ```np.cos()```.\n",
    "\n",
    "Regresa un arreglo en el que cada elemento es el coseno de un ángulo expresado en radianes calculado a partir de cada elemento del arreglo que se ingresa como argumento.\n",
    "\n",
    "La documentación de dicha función se encuentra en:\n",
    "\n",
    "https://numpy.org/doc/stable/reference/generated/numpy.cos.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### La función ```np.tan()```.\n",
    "\n",
    "Regresa un arreglo en el que cada elemento es la tangente de un ángulo expresado en radianes calculado a partir de cada elemento del arreglo que se ingresa como argumento.\n",
    "\n",
    "La documentación de dicha función se encuentra en:\n",
    "\n",
    "https://numpy.org/doc/stable/reference/generated/numpy.tan.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### La función ```np.sinh()```.\n",
    "\n",
    "Regresa un arreglo en el que cada elemento es el seno hiperbólico de un ángulo expresado en radianes calculado a partir de cada elemento del arreglo que se ingresa como argumento.\n",
    "\n",
    "La documentación de dicha función se encuentra en:\n",
    "\n",
    "https://numpy.org/doc/stable/reference/generated/numpy.sinh.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### La función ```np.cosh()```.\n",
    "\n",
    "Regresa un arreglo en el que cada elemento es el coseno hiperbólico de un ángulo expresado en radianes calculado a partir de cada elemento del arreglo que se ingresa como argumento.\n",
    "\n",
    "La documentación de dicha función se encuentra en:\n",
    "\n",
    "https://numpy.org/doc/stable/reference/generated/numpy.cosh.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### La función ```np.tanh()```.\n",
    "\n",
    "Regresa un arreglo en el que cada elemento es la tangente hiperbólica de un ángulo expresado en radianes calculado a partir de cada elemento del arreglo que se ingresa como argumento.\n",
    "\n",
    "La documentación de dicha función se encuentra en:\n",
    "\n",
    "https://numpy.org/doc/stable/reference/generated/numpy.tanh.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### La función ```np.arcsin()```.\n",
    "\n",
    "Regresa un arreglo en el que cada elemento corresponde ángulo expresado en radianes calculado a partir del inverso del seno de cada elemento del arreglo que se ingresa como argumento.\n",
    "\n",
    "La documentación de dicha función se encuentra en:\n",
    "\n",
    "https://numpy.org/doc/stable/reference/generated/numpy.arcsin.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### La función ```np.arccos()```.\n",
    "\n",
    "Regresa un arreglo en el que cada elemento corresponde ángulo expresado en radianes calculado a partir del inverso del coseno de cada elemento del arreglo que se ingresa como argumento.\n",
    "\n",
    "La documentación de dicha función se encuentra en:\n",
    "\n",
    "https://numpy.org/doc/stable/reference/generated/numpy.arccos.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### La función ```np.arctan()```.\n",
    "\n",
    "Regresa un arreglo en el que cada elemento corresponde ángulo expresado en radianes calculado a partir del inverso tangente de cada elemento del arreglo que se ingresa como argumento.\n",
    "\n",
    "La documentación de dicha función se encuentra en:\n",
    "\n",
    "https://numpy.org/doc/stable/reference/generated/numpy.arctan.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### La función ```np.arctan2()```.\n",
    "\n",
    "Regresa un arreglo en el que cada elemento corresponde ángulo expresado en radianes calculado a partir del inverso la tangente formado por cada elemento del arreglo que se ingresa como primer argumento tomado como la longitud del lado opuesto y por cada elemento del arreglo que se ingresa como segundo argumento tomado como la longitud del lado adyacente.\n",
    "\n",
    "La documentación de dicha función se encuentra en:\n",
    "\n",
    "https://numpy.org/doc/stable/reference/generated/numpy.arctan.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### La función ```np.arcsinh()```.\n",
    "\n",
    "Regresa un arreglo en el que cada elemento corresponde ángulo expresado en radianes calculado a partir del inverso del seno hiperbólico formado por cada elemento del arreglo que se ingresa como primer argumento.\n",
    "\n",
    "La documentación de dicha función se encuentra en:\n",
    "\n",
    "https://numpy.org/doc/stable/reference/generated/numpy.arcsinh.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### La función ```np.arccosh()```.\n",
    "\n",
    "Regresa un arreglo en el que cada elemento corresponde ángulo expresado en radianes calculado a partir del inverso del coseno hiperbólico formado por cada elemento del arreglo que se ingresa como primer argumento.\n",
    "\n",
    "La documentación de dicha función se encuentra en:\n",
    "\n",
    "https://numpy.org/doc/stable/reference/generated/numpy.arccosh.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### La función ```np.arctanh()```.\n",
    "\n",
    "Regresa un arreglo en el que cada elemento corresponde ángulo expresado en radianes calculado a partir del inverso de la tangente hiperbólica formada por cada elemento del arreglo que se ingresa como primer argumento.\n",
    "\n",
    "La documentación de dicha función se encuentra en:\n",
    "\n",
    "https://numpy.org/doc/stable/reference/generated/numpy.arccosh.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### La función ```np.arctan2h()```.\n",
    "\n",
    "Regresa un arreglo en el que cada elemento corresponde ángulo expresado en radianes calculado a partir del inverso de la tangente hiperbólica calculada partir de dos arreglos que se ingresan como argumentos y que corresponden al lado opuesto y al adyacente.\n",
    "\n",
    "La documentación de dicha función se encuentra en:\n",
    "\n",
    "https://numpy.org/doc/stable/reference/generated/numpy.arctan2h.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### La función  ```np.hypot()```.\n",
    "\n",
    "Regresa un arreglo en el que cada elemento corresponde a la hipotenusa de un triángulo  rectángulo calculado a partir del inverso de la tangente hiperbólica calculada partir de dos arreglos que se ingresan como argumentos y que corresponden al lado opuesto y al adyacente.\n",
    "\n",
    "La documentación de dicha función se encuentra en:\n",
    "\n",
    "https://numpy.org/doc/stable/reference/generated/numpy.hypot.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Las funciones  ```np.deg2rad()``` y ```np.radians()```.\n",
    "\n",
    "Estas funcones regresan un arreglo en el que cada elemento corresponde a un ángulo en radianes a partir de un arreglo que contiene ámgulos en grados.\n",
    "\n",
    "La documentación de dicha función se encuentra en:\n",
    "\n",
    "https://numpy.org/doc/stable/reference/generated/numpy.radians.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Las funciones  ```np.rad2deg()``` y ```np.degrees()```.\n",
    "\n",
    "Estas funcones regresan un arreglo en el que cada elemento corresponde a un ángulo en grados a partir de un arreglo que contiene ángulos en radianes.\n",
    "\n",
    "La documentación de dicha función se encuentra en:\n",
    "\n",
    "https://numpy.org/doc/stable/reference/generated/numpy.degrees.html"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejemplos:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "opuesto = np.ones((4,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.]])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "opuesto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "adyacente = np.ones((4,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.]])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "adyacente"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "angulo = np.arctan2(opuesto, adyacente)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.78539816, 0.78539816, 0.78539816, 0.78539816],\n",
       "       [0.78539816, 0.78539816, 0.78539816, 0.78539816],\n",
       "       [0.78539816, 0.78539816, 0.78539816, 0.78539816],\n",
       "       [0.78539816, 0.78539816, 0.78539816, 0.78539816]])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "angulo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([44.99999981])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.degrees([0.78539816])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[45., 45., 45., 45.],\n",
       "       [45., 45., 45., 45.],\n",
       "       [45., 45., 45., 45.],\n",
       "       [45., 45., 45., 45.]])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.degrees(angulo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funciones da valor."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* ```np.abs()```\n",
    "* ```np.around()```\n",
    "* ```np.ceil()```\n",
    "* ```np.exp()```\n",
    "* ```np.exp2()```\n",
    "* ```np.fabs()```\n",
    "* ```np.fix()```\n",
    "* ```np.floor()```\n",
    "* ```np.log()```\n",
    "* ```np.log10()```\n",
    "* ```np.log1p()```\n",
    "* ```np.log2()```\n",
    "* ```np.logaddexp()```\n",
    "* ```np.logaddexp2()```\n",
    "* ```np.round()```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "numeros = np.array([[1.43, -1, 45.9999, -3.41],\n",
    "                   [np.inf, -np.inf, np.inf, np.inf],\n",
    "                   [np.nan, 13.45, 11, 21]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "numeros"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "np.abs(numeros)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "np.floor(numeros)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "np.ceil(numeros)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "np.round(numeros)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "np.log(numeros)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funciones de evaluación de arreglos.\n",
    "\n",
    "* ```np.iscomplex()```\n",
    "* ```np.isfinite()```\n",
    "* ```np.isin()```\n",
    "* ```np.isinf()```\n",
    "* ```np.isnan()```\n",
    "* ```np.isnat()```\n",
    "* ```np.isneginf()```\n",
    "* ```np.isposinf()```\n",
    "* ```np.isreal()```\n",
    "* ```np.isscalar()```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "numeros"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "np.isfinite(numeros)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "np.isnan(numeros)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "np.isreal(numeros)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funciones lógicas."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* ```np.all()```\n",
    "* ```np.any()```\n",
    "* ```np.logical_and()```\n",
    "* ```np.logical_not()```\n",
    "* ```np.logical_or()```\n",
    "* ```np.logical_xor()```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "booleana = np.array([[0, 1, 1],\n",
    "                   [1, 0, 1],\n",
    "                   [1, 1, 1,]], dtype=np.bool_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "booleana"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "np.any(booleana)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "np.all(booleana)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "np.all(booleana[2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "np.logical_not(booleana)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "np.logical_or(booleana, True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "otro_booleano = np.array([1, 0, 2], dtype=np.bool_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "otro_booleano"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "booleana"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "np.logical_and(booleana, otro_booleano)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funciones polinomiales."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### La función  ```np.poly1d()```.\n",
    "\n",
    "Esta función define un polinomio con coeficientes:\n",
    "\n",
    "```\n",
    "array[c1, c2, .... cn, c0]\n",
    "```\n",
    "\n",
    "$ c_1x^n + c_2x^{n-1} + ... + c_nx + c_o$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejemplo:**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* La siguiente celda creará un arreglo que correponde al polinomio: \n",
    "\n",
    "$2x^4 + 4x^3 - 3x^2 + 0.5$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "ecuacion = np.poly1d([2, 4, -3, 0, 0.5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "ecuacion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La siguiente celda calculará la derivada de ```ecuacion```, la cual da por resultado: \n",
    "\n",
    "$8x^3 + 12x^2 - 6x$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "np.polyder(ecuacion)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La siguiente celda calculará la integral indefinida de ```ecuacion```, la cual da por resultado: \n",
    "\n",
    "$0.4x^5 + x^4 -x^3 + 0.5x + c$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "np.polyint(ecuacion)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Funciones estadísticas.\n",
    "\n",
    "* ```np.amax()```\n",
    "* ```np amin()```\n",
    "* ```np.argmax()```\n",
    "* ```np.argmin()```\n",
    "* ```np.average()```\n",
    "* ```np.correlate()```\n",
    "* ```np.corrcoef()```\n",
    "* ```np.count_nonzero()```\n",
    "* ```np.cov()```\n",
    "* ```np.cumprod()```\n",
    "* ```np.cumsum()```\n",
    "* ```np.histogram()```\n",
    "* ```np.histogram2d()```\n",
    "* ```np.histogram_bin_edges()```\n",
    "* ```np.histogramdd()```\n",
    "* ```np.max()```\n",
    "* ```np.mean()```\n",
    "* ```np.median()```\n",
    "* ```np.min()```\n",
    "* ```np.nanargmax()```\n",
    "* ```np.nanargmin()```\n",
    "* ```np.nancumprod()```\n",
    "* ```np.nancumsum()```\n",
    "* ```np.nanmax()```\n",
    "* ```np.nanmean()```\n",
    "* ```np.nanmedian()```\n",
    "* ```np.nanmin()```\n",
    "* ```np.nanpercentile()```\n",
    "* ```np.nanquantile()```\n",
    "* ```np.nanstd()```\n",
    "* ```np.nansum()```\n",
    "* ```np.nanvar()```\n",
    "* ```np.percentile()```\n",
    "* ```np.quantile()```\n",
    "* ```np.std()```\n",
    "* ```np.var()```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "numeros"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "np.max(numeros)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "np.nanmax(numeros)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "np.nanmin(numeros)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "np.nanmean(numeros)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "np.nanmean(numeros[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "np.nanmean(numeros[2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "np.nanmean(numeros[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "aleatorios = np.random.randint(100,size=(20))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([85, 13, 32,  6, 40, 89, 77, 45, 89, 70, 36, 28, 51,  1, 49, 20, 19,\n",
       "       38, 39, 38])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "aleatorios"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([2, 1, 2, 3, 4, 3, 0, 1, 1, 3], dtype=int64),\n",
       " array([ 1. ,  9.8, 18.6, 27.4, 36.2, 45. , 53.8, 62.6, 71.4, 80.2, 89. ]))"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.histogram(aleatorios)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}