01-pair-numpy.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pair programming NumPy\n",
    "\n",
    "**Creación y Indexación**:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1- Crea un array 1D con 50 valores aleatorio del 10 al 99. Accede a los elementos en las posiciones múltiplos de 5."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([30, 63, 96, 26, 22, 92, 48, 98, 49, 50, 69, 97, 46, 76, 20, 60, 17,\n",
       "       17, 37, 74, 25, 52, 34, 17, 91, 20, 86, 80, 20, 95, 78, 45, 50, 95,\n",
       "       20, 83, 43, 37, 78, 16, 34, 77, 52, 78, 78, 35, 29, 47, 83, 21])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array_1= np.random.randint(10,100, 50)\n",
    "array_1\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([30, 50, 20, 60, 25, 20, 80, 20, 95, 45, 50, 95, 20, 35])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array_multiplo_5= array_1[array_1 %5 ==0]\n",
    "array_multiplo_5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2- Crea un array 1D con 30 valores del 1 al 20 (ambos incluidos). Utiliza indexación para obtener los elementos en las posiciones impares."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 9,  6, 11,  8, 19,  3,  8, 13,  1,  9,  9,  8, 13, 12,  7, 15, 17,\n",
       "       10, 14,  7,  1,  2, 11,  6, 14,  7, 11, 18,  2,  1])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array_2 = np.random.randint(1,21,30)\n",
    "array_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 6,  8,  3, 13,  9,  8, 12, 15, 10,  7,  2,  6,  7, 18,  1])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array_2[1::2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3- Crea un array 2D de forma (4, 6) con números aleatorios decimales (no deben estar comprendidos solo entre 0 y 1). Accede a la última fila de la matriz. Los decimales deben estar redondeados a 2 decimales."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "array_4_bi = np.random.rand(4,6)\n",
    "array_5 = array_4_bi +4\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[4.43, 4.05, 4.27, 4.19, 4.67, 4.74],\n",
       "       [4.07, 4.92, 4.21, 4.28, 4.22, 4.38],\n",
       "       [4.94, 4.4 , 4.13, 4.26, 4.4 , 4.57],\n",
       "       [4.11, 4.29, 4.37, 4.85, 4.55, 4.52]])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array_5_round = np.round(array_5,2)\n",
    "array_5_round"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4.11, 4.29, 4.37, 4.85, 4.55, 4.52])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#accedemos a la última fila\n",
    "\n",
    "array_5_round[-1, :]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4- Crea un array NumPy 2D de forma (6, 4) con valores decimales entre 0 y 1. Accede a la segunda columna de la matriz. Los números deben estar redondeados a 2 decimales."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.94, 0.69, 0.24, 0.78],\n",
       "       [0.36, 0.66, 0.91, 0.14],\n",
       "       [0.35, 0.48, 0.75, 0.1 ],\n",
       "       [0.07, 0.44, 0.36, 0.26],\n",
       "       [0.09, 0.04, 0.05, 0.92],\n",
       "       [0.74, 0.84, 0.74, 0.17]])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array_6 = np.round(np.random.rand(6,4), 2)\n",
    "array_6 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5b - Crea un array 1D con 30 valores enteros aleatorios entre -50 y 50. Extrae los valores negativos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 23,  48, -37, -38,  45,  26,  31,  -2, -23,   1,  44,  -7,   4,\n",
       "        28, -23, -39, -10,   1, -30, -35,  20,  26,  39, -43,  16,   6,\n",
       "       -41,  12, -30,  -5])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array_7 = np.random.randint(-50, 50, 30)\n",
    "array_7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-37, -38,  -2, -23,  -7, -23, -39, -10, -30, -35, -43, -41, -30,\n",
       "        -5])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array_7_negativo = array_7[array_7<0]\n",
    "array_7_negativo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "6 - Crea un array 1D con 10 valores entre 0 y 1. Redondea los decimales a 2. Obtén los elementos cuyo valor es mayor que 0.5. ¿En que posición/es están esos elementos?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.89, 1.  , 0.63, 0.74, 0.24, 0.3 , 0.26, 0.21, 0.41, 0.09])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array_8 = np.round(np.random.rand(10),2)\n",
    "array_8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.89, 1.  , 0.63, 0.74])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#elementos mayores a 0.5\n",
    "\n",
    "array_8[array_8>0.5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([0, 1, 2, 3]),)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#posición elementos\n",
    "posicion_array_8 = np.where(array_8 > 0.5)\n",
    "posicion_array_8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "7- Crea un array 1D con 40 valores del 1 al 100 (ambos incluidos). Obtén los elementos que son divisibles por 3 y por 4."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 72,  61,  68,  20,  52, 100,  91,  51,  92,  91,  40,  43,  43,\n",
       "        35,   3,  41,  18,  50,  20,  72,  76,  27,  19,   1,  61,  56,\n",
       "        74,  49,  77,  68,  93,  48,  16,  46,  25,  63,  73,  31,  49,\n",
       "        43])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array_9 = np.random.randint(1,101,40)\n",
    "array_9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "operands could not be broadcast together with shapes (9,) (14,) ",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/fy/lv_7fpvj1v5grf8t28cz_4nw0000gn/T/ipykernel_20431/414462133.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0marray_9_3\u001b[0m\u001b[0;34m=\u001b[0m \u001b[0marray_9\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0marray_9\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0;36m3\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m&\u001b[0m \u001b[0marray_9\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0marray_9\u001b[0m \u001b[0;34m%\u001b[0m \u001b[0;36m4\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0marray_9_3\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mValueError\u001b[0m: operands could not be broadcast together with shapes (9,) (14,) "
     ]
    }
   ],
   "source": [
    "array_9_3= array_9[array_9 % 3 == 0] & array_9[array_9 % 4 == 0]\n",
    "array_9_3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array_9_4 = "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "8- BONUS: Crea un array 3D de forma (2, 3, 5) y 50 elementos con números enteros entre 0 y 100 (ambos incluidos). Reemplaza los elementos en posiciones múltiplos de 3 por 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[60, 48, 45, 19, 19],\n",
       "        [77,  1,  2, 20, 69],\n",
       "        [28, 79, 89, 62, 35]],\n",
       "\n",
       "       [[38, 38, 45, 58, 87],\n",
       "        [35, 76, 10, 69, 49],\n",
       "        [54, 74, 93, 50, 58]]])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array_3D = np.random.randint(0, 101, (2,3,5))\n",
    "array_3D\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "60"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Reemplaza los elementos en posiciones múltiplos de 3 por 0.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[60, 19],\n",
       "        [77, 20],\n",
       "        [28, 62]],\n",
       "\n",
       "       [[38, 58],\n",
       "        [35, 69],\n",
       "        [54, 50]]])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cada3 = array_3D[:,:,::3]\n",
    "cada3\n",
    "\n",
    "# Así accede al elemento 3 de cada fila"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0, 48, 45,  0, 19],\n",
       "        [ 0,  1,  2,  0, 69],\n",
       "        [ 0, 79, 89,  0, 35]],\n",
       "\n",
       "       [[ 0, 38, 45,  0, 87],\n",
       "        [ 0, 76, 10,  0, 49],\n",
       "        [ 0, 74, 93,  0, 58]]])"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array_3D[:,:,::3]=0\n",
    "array_3D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#nota: para que haya 50 elementos se debe modificar la forma del array, \n",
    "# ya que con la forma (2,3,5) dan 30 elementos\n",
    "array_3D.size "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Reshape y Transpose**:\n",
    "\n",
    "**Ejercicios con reshape**:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1- Crea un array 3D de forma (2, 3, 4) con valores aleatorios entre 1 y 100 (ambos inclusive). Utiliza reshape para convertirlo en un array 2D. Deberás pensar en la forma que es correcta para hacer este cambio"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2- Crea un array 3D de forma (3, 4, 5) con valores enteros del 1 al 60 (sin incluir). Utiliza reshape para convertirlo en un array 2D."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[37, 28, 24, 59,  0],\n",
       "        [ 2, 10, 19, 53, 25],\n",
       "        [10, 43, 40, 26, 16],\n",
       "        [32, 53, 12, 30,  2]],\n",
       "\n",
       "       [[59, 50, 37, 29,  5],\n",
       "        [51, 32, 50, 43, 39],\n",
       "        [56, 33, 58, 36, 52],\n",
       "        [10,  1, 36, 32,  3]],\n",
       "\n",
       "       [[23,  6, 20,  4, 46],\n",
       "        [39,  8, 27, 26, 50],\n",
       "        [37, 52, 22, 51, 43],\n",
       "        [38,  0, 35, 53, 16]]])"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "otro_3D =  np.random.randint(0, 60, (3,4,5))\n",
    "otro_3D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[37, 28, 24, 59,  0,  2],\n",
       "       [10, 19, 53, 25, 10, 43],\n",
       "       [40, 26, 16, 32, 53, 12],\n",
       "       [30,  2, 59, 50, 37, 29],\n",
       "       [ 5, 51, 32, 50, 43, 39],\n",
       "       [56, 33, 58, 36, 52, 10],\n",
       "       [ 1, 36, 32,  3, 23,  6],\n",
       "       [20,  4, 46, 39,  8, 27],\n",
       "       [26, 50, 37, 52, 22, 51],\n",
       "       [43, 38,  0, 35, 53, 16]])"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "otro_3D_reshape = np.reshape(otro_3D, (10,6))\n",
    "otro_3D_reshape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#para comprobar el número de dimensiones:\n",
    "otro_3D_reshape.ndim "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3- Crea un array 3D de forma (4, 3, 2) con valores aleatorios entre 0 y 1. Utiliza reshape para convertirlo en un array 2D."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ejercicios con transpose**:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4- Utiliza el array 3D del ejercicio 2 de reshape. Utiliza transpose para permutar los ejes y obtener un nuevo array con forma (5, 4, 3)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[37, 28, 24, 59,  0],\n",
       "        [ 2, 10, 19, 53, 25],\n",
       "        [10, 43, 40, 26, 16],\n",
       "        [32, 53, 12, 30,  2]],\n",
       "\n",
       "       [[59, 50, 37, 29,  5],\n",
       "        [51, 32, 50, 43, 39],\n",
       "        [56, 33, 58, 36, 52],\n",
       "        [10,  1, 36, 32,  3]],\n",
       "\n",
       "       [[23,  6, 20,  4, 46],\n",
       "        [39,  8, 27, 26, 50],\n",
       "        [37, 52, 22, 51, 43],\n",
       "        [38,  0, 35, 53, 16]]])"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "otro_3D "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[37, 59, 23],\n",
       "        [ 2, 51, 39],\n",
       "        [10, 56, 37],\n",
       "        [32, 10, 38]],\n",
       "\n",
       "       [[28, 50,  6],\n",
       "        [10, 32,  8],\n",
       "        [43, 33, 52],\n",
       "        [53,  1,  0]],\n",
       "\n",
       "       [[24, 37, 20],\n",
       "        [19, 50, 27],\n",
       "        [40, 58, 22],\n",
       "        [12, 36, 35]],\n",
       "\n",
       "       [[59, 29,  4],\n",
       "        [53, 43, 26],\n",
       "        [26, 36, 51],\n",
       "        [30, 32, 53]],\n",
       "\n",
       "       [[ 0,  5, 46],\n",
       "        [25, 39, 50],\n",
       "        [16, 52, 43],\n",
       "        [ 2,  3, 16]]])"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "otro_3D_trans = np.transpose(otro_3D)\n",
    "otro_3D_trans"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "5- Utiliza el array 3D del ejercicio 3 de reshape. Utiliza transpose para cambiar el orden de los ejes y obtener un nuevo array con forma (3, 2, 4)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Preguntas teóricas:\n",
    "\n",
    "6- ¿Qué diferencia existe entre el reshape y el transpose?\n",
    "\n",
    "- El **transpose** cambia la posición de 3 dimensiones, donde reorganizan el número de matrices, de filas y de columnas.\n",
    "\n",
    "- En cambio el **reshape** cambia la forma el array, pero no su contenido. El número total de elementos siempre será el mismo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "7 - ¿Y entre el transpose y el swapaxes?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Funciones Aritméticas y Estadísticas**:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_____"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1 - Crea un array de tres 3D con elementos entre el 0 y 1 de forma (2, 3, 5) cuyos valores solo tengan 1 decimal."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 217,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[0.8, 0.5, 0.8, 0.3, 0.8],\n",
       "        [0.2, 0. , 0.6, 0.2, 0.3],\n",
       "        [0.4, 0.4, 0.1, 0.6, 0.3]],\n",
       "\n",
       "       [[0.5, 0.2, 0. , 0.5, 0.8],\n",
       "        [0.4, 0.5, 0.6, 0.2, 0.1],\n",
       "        [0.2, 0.1, 0.1, 0.6, 0.9]]])"
      ]
     },
     "execution_count": 217,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array_unos_ceros = np.round(np.random.rand(2,3,5),1)\n",
    "array_unos_ceros"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2 - Crea un array vacío con la misma forma y dimensiones que el array creado anteriormente. Vamos a reemplazar los valores de la matriz vacía que nos acabamos de crear pero basándonos en los valores del primer array bajo las siguientes condiciones:\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Si el valor del array es igual que la media, se reemplaza por \"A\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[['', '', '', '', ''],\n",
       "        ['', '', '', '', ''],\n",
       "        ['', '', '', '', '']],\n",
       "\n",
       "       [['', '', '', '', ''],\n",
       "        ['', '', '', '', ''],\n",
       "        ['', '', '', '', '']]], dtype='<U1')"
      ]
     },
     "execution_count": 218,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Creamos un array vacío de strings:\n",
    "\n",
    "array_vacio_str = np.empty((2,3,5), str)\n",
    "array_vacio_str"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Si el valor del array es igual que la media, se reemplaza por \"A\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0.4'"
      ]
     },
     "execution_count": 219,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#buscamos la media de array_unos_ceros\n",
    "\n",
    "media = np.round(np.mean(array_unos_ceros),1).astype(str)\n",
    "media\n",
    "\n",
    "#ponemos .astype(str) para transformar los datos de float a cadena, y para que posteriormente pueda hacer la comparación"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[['', '', '', '', ''],\n",
       "        ['', '', '', '', ''],\n",
       "        ['A', 'A', '', '', '']],\n",
       "\n",
       "       [['', '', '', '', ''],\n",
       "        ['A', '', '', '', ''],\n",
       "        ['', '', '', '', '']]], dtype='<U1')"
      ]
     },
     "execution_count": 220,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Reemplazar los valores en el array vacío basándonos en las condiciones dadas\n",
    "array_vacio_str[array_unos_ceros.astype(str) == media] = \"A\"\n",
    "array_vacio_str\n",
    "\n",
    "#nota: añadimos .astype(str) para que pueda comparar los datos de la media, que hemos pasado a string, con la \"A\", que también es string"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Si el valor del array es mayor que la media, se reemplaza por \"B\".\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 221,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[['B', 'B', 'B', '', 'B'],\n",
       "        ['', '', 'B', '', ''],\n",
       "        ['A', 'A', '', 'B', '']],\n",
       "\n",
       "       [['B', '', '', 'B', 'B'],\n",
       "        ['A', 'B', 'B', '', ''],\n",
       "        ['', '', '', 'B', 'B']]], dtype='<U1')"
      ]
     },
     "execution_count": 221,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array_vacio_str[array_unos_ceros.astype(str) > media] = \"B\"\n",
    "array_vacio_str"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Si el valor del array es menor que la media, se reemplaza por \"C\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 222,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[['B', 'B', 'B', 'C', 'B'],\n",
       "        ['C', 'C', 'B', 'C', 'C'],\n",
       "        ['A', 'A', 'C', 'B', 'C']],\n",
       "\n",
       "       [['B', 'C', 'C', 'B', 'B'],\n",
       "        ['A', 'B', 'B', 'C', 'C'],\n",
       "        ['C', 'C', 'C', 'B', 'B']]], dtype='<U1')"
      ]
     },
     "execution_count": 222,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array_vacio_str[array_unos_ceros.astype(str) < media] = \"C\"\n",
    "array_vacio_str"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Si el valor es igual que el máximo, se reemplaza por \"D\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 223,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0.9'"
      ]
     },
     "execution_count": 223,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#buscamos el valor máximo de array_unos_ceros\n",
    "\n",
    "max = np.round(np.max(array_unos_ceros),1).astype(str)\n",
    "max\n",
    "\n",
    "#ponemos .astype(str) para transformar los datos de float a cadena, y para que posteriormente pueda hacer la comparación"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 224,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[['B', 'B', 'B', 'C', 'B'],\n",
       "        ['C', 'C', 'B', 'C', 'C'],\n",
       "        ['A', 'A', 'C', 'B', 'C']],\n",
       "\n",
       "       [['B', 'C', 'C', 'B', 'B'],\n",
       "        ['A', 'B', 'B', 'C', 'C'],\n",
       "        ['C', 'C', 'C', 'B', 'D']]], dtype='<U1')"
      ]
     },
     "execution_count": 224,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array_vacio_str[array_unos_ceros.astype(str) == max] = \"D\"\n",
    "array_vacio_str"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Si el valor es igual que el mínimo, se reemplaza por \"E\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 225,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0.0'"
      ]
     },
     "execution_count": 225,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#buscamos el valor mínimo de array_unos_ceros\n",
    "\n",
    "min= np.round(np.min(array_unos_ceros),1).astype(str)\n",
    "min\n",
    "\n",
    "#ponemos .astype(str) para transformar los datos de float a cadena, y para que posteriormente pueda hacer la comparación"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 226,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[['B', 'B', 'B', 'C', 'B'],\n",
       "        ['C', 'E', 'B', 'C', 'C'],\n",
       "        ['A', 'A', 'C', 'B', 'C']],\n",
       "\n",
       "       [['B', 'C', 'E', 'B', 'B'],\n",
       "        ['A', 'B', 'B', 'C', 'C'],\n",
       "        ['C', 'C', 'C', 'B', 'D']]], dtype='<U1')"
      ]
     },
     "execution_count": 226,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array_vacio_str[array_unos_ceros.astype(str) == min] = \"E\"\n",
    "array_vacio_str"
   ]
  }
 ],
 "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.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}