ejercicios_soluciones/soluciones_modulo_2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___\n",
    "## Módulo 2: Introducción a las librería Numpy.\n",
    "___"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1. Introducción a NumPy I."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2.1.1.**  Crea un vector con valores de 10 a 49 en pasos de 0.5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vect = np.arange(10, 49.5, 0.5)\n",
    "vect"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2.1.2.** Muestra su dimensión y su tipo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vect.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vect.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2.1.3.** Crea un array con los números que elijas de dimensiones 2x3."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lista_para_arr = [\n",
    "    [1,2,3],\n",
    "    [1,4,2],\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.array(lista_para_arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2.1.4.** Indexing y slicing:\n",
    "\n",
    "- Crea un array unidimensional de 10 elemento aleatorios.\n",
    "- Crea un array bidimensional de 10x10 elementos aletorios.\n",
    "- Accede al primer elemento y al penúltimo número de cada array. \n",
    "- Para el array unidimensional: muestra todos los elementos en posiciones pares desde la posición 6. \n",
    "- Para el array bidimensional: muestra una submatriz con las dos primeras filas y las tres primeras columnas.\n",
    "- Divide el array bidimensional en dos: uno con las 2 primera filas y otro con las siguientes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "uni = np.random.rand(10)\n",
    "bi_dim = np.random.rand(10, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "uni.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bi_dim.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(uni[0])\n",
    "print(uni[-2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(bi_dim[0, 0])\n",
    "print(bi_dim[-2,-2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "uni[6::2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bi_dim[:2,:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bi_dim_a = bi_dim[:2,:]\n",
    "bi_dim_b = bi_dim[2:,:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bi_dim_a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bi_dim_b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2.1.5.** Crea una función que reciba como parámetro un número n y devuelva una matriz cuadrada (dos dimensiones) de nxn donde los elementos de la diagonal principal valgan 5 y el resto valgan n."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fun(n):\n",
    "    \n",
    "    matriz = np.full((n, n), n)\n",
    "    np.fill_diagonal(matriz, 5)\n",
    "    \n",
    "    return matriz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fun(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2.1.6.** Crea una matriz de números aleatorios de 4*3 (no importa la distribución)\n",
    "\n",
    "- Localiza con una máscara booleana aquellos números que estén por encima del percentil 90\n",
    "- Usa la máscara booleana para convertir a 1 aquellos que estén por encima de dicho percentil\n",
    "- Usa la máscara booleana para convertir a 0 el resto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "matriz = np.random.normal(size=(4, 3))\n",
    "print(matriz)\n",
    "\n",
    "limite = np.percentile(matriz, 90)\n",
    "mascara = matriz > limite\n",
    "\n",
    "matriz[mascara] = 1\n",
    "matriz[~mascara] = 0\n",
    "\n",
    "matriz"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2.1.7.** Crea un vector de números de 1 a 10. \n",
    "\n",
    "- Extrae las posiciones 6 a 8 y guárdalas un un nuevo vector\n",
    "- Iguala el nuevo vector a ceros\n",
    "- Haz todo lo anterior, de tal forma, que no modifiques el vector original"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "original = np.arange(1,11)\n",
    "print(original)\n",
    "\n",
    "# copia = original[5:8] # Si lo hacemos así cambiamos ambos vectores\n",
    "# copia = original[::] # Funciona con listas, pero no funciona con np\n",
    "copia = original[5:8].copy()\n",
    "print(copia)\n",
    "\n",
    "copia[:] = 0\n",
    "print(copia)\n",
    "print(original)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2.1.8.** Genera una matriz de 3x3 de números aleatorios (da igual la distribución)\n",
    "\n",
    "- Extrae la tercera columna en un vector de 2 dimensiones\n",
    "- Extrae la tercera columna en un vector de 1 dimensión\n",
    "- Extrae el segundo y tercer elemento, de la segunda fila, en un vector de 2 dimensiones\n",
    "- Extrae el segundo y tercer elemento, de la segunda fila, en un vector de 1 dimensión"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "matriz = np.random.normal(size=(3, 3))\n",
    "\n",
    "print(matriz)\n",
    "\n",
    "ej1 = matriz[0:3, 2:3]\n",
    "print(ej1.shape)\n",
    "\n",
    "ej2 = matriz[:,2]\n",
    "print(ej2.shape)\n",
    "\n",
    "ej3 = matriz[1:2, 1:]\n",
    "print(ej3.shape)\n",
    "\n",
    "ej4 = matriz[1,1:]\n",
    "print(ej4.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___\n",
    "### 2.2. Introducción a NumPy II."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2.2.1.**  Crea una función que reciba dos números n y m que definirán ancho y alto de una matriz de nxm elementos numéricos secuenciales y un booleano que definirá si se debe devolver la matriz generada (False) o su traspuesta (True)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mi_fun(n=10, m=10, trp=True):\n",
    "    mat = np.arange(n*m).reshape((n, m))\n",
    "    if trp:\n",
    "        return mat.T\n",
    "    return mat"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = mi_fun(10, 5, True)\n",
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2.2.2.**  Crea una función que reciba una matriz y chequee si hay o no algún valor negativo en la misma."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def chequear_neg(matriz):\n",
    "    return (matriz<0).any()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "matriz = np.random.randint(-10, 10, (5,5))\n",
    "print(matriz)\n",
    "\n",
    "chequear_neg(matriz)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2.2.3.** Crea una función que sume el valor absoluto de todos los elementos negativos de una matriz recibida como parámetro."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def suma_val_abs_neg(matriz):\n",
    "    return np.sum(np.abs(matriz[(matriz<0)]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "matriz = np.random.randint(-10, 10, (5,5))\n",
    "print(matriz)\n",
    "\n",
    "suma_val_abs_neg(matriz)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2.2.4.** Utiliza el ejercicio 2.1.9. Genera una matriz de 3x3 de números aleatorios (da igual la distribución)\n",
    "\n",
    "- Extrae la tercera columna en un vector de 2 dimensiones\n",
    "- Extrae la tercera columna en un vector de 1 dimensión\n",
    "- Extrae el segundo y tercer elemento, de la segunda fila, en un vector de 2 dimensiones\n",
    "- Extrae el segundo y tercer elemento, de la segunda fila, en un vector de 1 dimensión\n",
    "\n",
    "Calcula la traspuesta de los 4 apartados, imprímela y comenta los resultados"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "matriz = np.random.normal(size=(3, 3))\n",
    "\n",
    "print(matriz)\n",
    "\n",
    "ej1 = matriz[0:3, 2:3]\n",
    "print(ej1.shape)\n",
    "\n",
    "ej2 = matriz[:,2]\n",
    "print(ej2.shape)\n",
    "\n",
    "ej3 = matriz[1:2, 1:]\n",
    "print(ej3.shape)\n",
    "\n",
    "ej4 = matriz[1,1:]\n",
    "print(ej4.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(ej1)\n",
    "print(ej1.T)\n",
    "print(\"\")\n",
    "\n",
    "print(ej2)\n",
    "print(ej2.T)\n",
    "print(\"\")\n",
    "\n",
    "print(ej3)\n",
    "print(ej3.T)\n",
    "print(\"\")\n",
    "\n",
    "print(ej4)\n",
    "print(ej4.T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cuando se trata de un vector, no es columna ni fila. El propio Python lo \"coloca\" cuando se realiza una multiplicación vector @ matriz. Por esto no se puede calcular la traspuesta. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "___\n",
    "### 2.3. Introducción a NumPy III."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2.3.1.** Crea un vector de 30 elementos aleatorios y calcula su media."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vector = np.random.random(30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.mean(vector)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vector.mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2.3.2.** Crea una matriz de 8x10 aleatoria y substrae la media por columnas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "matriz = np.random.randint(1, 10, (8,10))\n",
    "matriz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "matriz.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "matriz.mean(axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2.3.3.** Crea una función que reciba dos enteros n y m, \n",
    "\n",
    "- Genere dos matrices aleatorias (normales 0,1) de dimensiones nxm y mxn\n",
    "- Haga el producto matricial de ambas para obtener una matriz nxn. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mxn(a,b):\n",
    "\n",
    "    x = np.random.rand(a, b)\n",
    "    y = np.random.rand(b, a)\n",
    "    \n",
    "    return np.dot(x,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mxn(5,10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2.3.4.** Crea una función que reciba dos matrices y devuelva la secuencia ordenada, de la unión, de los elementos únicos de ambas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func234(x, y):\n",
    "    inter = np.union1d(x,y)\n",
    "    inter.sort()\n",
    "    return inter    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.random.randint(2, 7, (2, 2))\n",
    "y = np.random.randint(5, 10, (8, 10))\n",
    "result = func234(x,y)\n",
    "\n",
    "print(x)\n",
    "print(y)\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2.3.5.** Crea una matriz aleatoria normal de 5x10 y normalízala en media y varianza por columnas (resta la media y divide entre la desviación típica).\n",
    "\n",
    "- Procedimiento muy típico en ML para normalizar lo que vamos a introducir en la red neuronal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.random.rand(5, 10)\n",
    "\n",
    "y = x  - x.mean(axis=0)\n",
    "y = y / x.std(axis=0)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si quisiésemos hacer el procedimiento sobre todos los elementos de la matriz, no indicaríamos axis"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = x  - x.mean()\n",
    "y = y / x.std()\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2.3.6.** Calcule el capital final de invertir 500€ mensuales durante 10 años, a un interés anual del 10%"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy_financial as npf"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "npf.fv?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "npf.fv(rate = 0.1/12, nper = 10*12, pmt = -500, pv = 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por convención, el signo negativo representa el flujo de efectivo que sale (es decir, dinero que no está disponible hoy)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2.3.7.** ¿Cuál es el valor futuro después de 10 años si empiezas con 100 euros, y tienes un ahorro mensual adicional de 100 €? La tasa de interés es del 5% anual."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "npf.fv(rate = 0.05/12, nper = 10*12, pmt = -100, pv = -100)"
   ]
  }
 ],
 "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.10.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}