numpy_exercises.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## [Numpy Exercises for Data Analysis](https://www.machinelearningplus.com/101-numpy-exercises-python/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">1.Import numpy as np and see the version</span>\n",
    "\n",
    "Q. Import numpy as `np` and print the version number."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.13.3\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "print(np.__version__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">2.How to create a 1D array?</span>\n",
    "\n",
    "Q. Create a 1D array of numbers from 0 to 9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.arange(10)\n",
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">3.How to create a boolean array?</span>\n",
    "\n",
    "Q. Create a 3×3 numpy array of all True’s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ True,  True,  True],\n",
       "       [ True,  True,  True],\n",
       "       [ True,  True,  True]], dtype=bool)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones((3, 3), dtype=bool)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False, False, False],\n",
       "       [False, False, False],\n",
       "       [False, False, False]], dtype=bool)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros((3, 3), dtype=bool)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">4.How to extract items that satisfy a given condition from 1D array?</span>\n",
    "\n",
    "Input:  \n",
    "`arr = np.arange(10)`  \n",
    "Desired Output:  \n",
    "`array([1, 3, 5, 7, 9])`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 3, 5, 7, 9])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.arange(10)\n",
    "arr[arr % 2 ==1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">5.How to replace items that satisfy a condition with another value in numpy array?</span>\n",
    "\n",
    "Q. Replace all odd numbers in **arr** with -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0, -1,  2, -1,  4, -1,  6, -1,  8, -1])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.arange(10)\n",
    "arr[arr % 2 == 1] = -1\n",
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">6.How to replace items that satisfy a condition without affecting the original array?</span>\n",
    "\n",
    "Q. Replace all odd numbers in **arr** with -1 without changing **arr**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0, -1,  2, -1,  4, -1,  6, -1,  8, -1])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.arange(10)\n",
    "np.where(arr % 2 == 1, -1, arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">7.How to reshape an array?</span>\n",
    "\n",
    "Q. Convert a 1D array to a 2D array with 2 rows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2, 3, 4],\n",
       "       [5, 6, 7, 8, 9]])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.arange(10)\n",
    "arr.reshape((2, 5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">8.How to stack two arrays vertically?</span>\n",
    "\n",
    "Q. Stack arrays **a** and **b** vertically."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2, 3, 4],\n",
       "       [5, 6, 7, 8, 9]])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(10).reshape(2, -1)\n",
    "b = np.repeat(1, 10).reshape(2, -1)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 1, 1, 1, 1],\n",
       "       [1, 1, 1, 1, 1]])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2, 3, 4],\n",
       "       [5, 6, 7, 8, 9],\n",
       "       [1, 1, 1, 1, 1],\n",
       "       [1, 1, 1, 1, 1]])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.r_[a, b]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">9.How to stack two arrays horizontally?</span>\n",
    "\n",
    "Q. Stack the arrays **a** and **b** horizontally."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2, 3, 4, 1, 1, 1, 1, 1],\n",
       "       [5, 6, 7, 8, 9, 1, 1, 1, 1, 1]])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.c_[a, b]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">10.How to generate custom sequences in numpy without hardcoding?</span>\n",
    "\n",
    "Q. Create the following pattern without hardcoding. Use only numpy functions and the below input array **a**.\n",
    "\n",
    "Input:  \n",
    "`a = np.array((1, 2, 3))`  \n",
    "Desired Output:  \n",
    "`array([1, 1, 1, 2, 2, 2, 3, 3, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3])`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 1, 2, 2, 2, 3, 3, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array((1, 2, 3))\n",
    "np.r_[np.repeat(a, 3), np.tile(a, 3)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">11.How to get the common items between two python numpy arrays?</span>\n",
    "\n",
    "Q. Get the common items between **a** and **b**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 4])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([1, 2, 3, 2, 3, 4, 3, 4, 5, 6])\n",
    "b = np.array([7, 2, 10, 2, 7, 4, 9, 4, 9, 8])\n",
    "np.intersect1d(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">12.How to remove from one array those items that exist in another?</span>\n",
    "\n",
    "Q. From array **a** remove all items present in array **b**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([1, 2, 3, 4, 5])\n",
    "b = np.array([5, 6, 7, 8, 9])\n",
    "np.setdiff1d(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "<span style=\"color: red\">13.How to get the positions where elements of two arrays match?</span>\n",
    "\n",
    "Q. Get the positions where elements of **a** and **b** match"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([1, 3, 5, 7], dtype=int64),)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([1, 2, 3, 2, 3, 4, 3, 4, 5, 6])\n",
    "b = np.array([7, 2, 10, 2, 7, 4, 9, 4, 9, 8])\n",
    "np.where(a == b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">14.How to extract all numbers between a given range from a numpy array?</span>\n",
    "\n",
    "Q. Get all items between 5 and 10 from **a**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 5,  6,  7,  8,  9, 10])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(15)\n",
    "a[(a >= 5) & (a <=10)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([ 5,  6,  7,  8,  9, 10], dtype=int64),)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.where((a >= 5) & (a <= 10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([ 5,  6,  7,  8,  9, 10], dtype=int64),)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.where(np.logical_and(a>=5, a<=10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">15.How to make a python function that handles scalars to work on numpy arrays?</span>\n",
    "\n",
    "Q. Convert the function maxx that works on two scalars, to work on two arrays.\n",
    "\n",
    "Input:  \n",
    "```python\n",
    "def maxx(x, y):\n",
    "    \"\"\"Get the maximum of two items.\"\"\"\n",
    "    if x >= y:\n",
    "        return x\n",
    "    else:\n",
    "        return y\n",
    "\n",
    "#> maxx(1, 5)\n",
    "#> 5\n",
    "```  \n",
    "Desired Output:\n",
    "```python\n",
    "a = np.array([5, 7, 9, 8, 6, 4, 5])\n",
    "b = np.array([6, 3, 4, 8, 9, 7, 1])\n",
    "\n",
    "#> pair_max(a, b)\n",
    "#> array([6., 7., 9., 8., 7., 5.])\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 6.,  7.,  9.,  8.,  9.,  7.,  5.])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def maxx(x, y):\n",
    "    \"\"\"Get the maximum of two items.\"\"\"\n",
    "    if x >= y:\n",
    "        return x\n",
    "    else:\n",
    "        return y\n",
    "\n",
    "pair_max = np.vectorize(maxx, otypes=[float])\n",
    "\n",
    "a = np.array([5, 7, 9, 8, 6, 4, 5])\n",
    "b = np.array([6, 3, 4, 8, 9, 7, 1])\n",
    "\n",
    "pair_max(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "<span style=\"color: red\">16.How to swap two columns in a 2d numpy array?</span>\n",
    "\n",
    "Q. Swap columns 1 and 2 in the array **arr**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 0, 2],\n",
       "       [4, 3, 5],\n",
       "       [7, 6, 8]])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.arange(9).reshape((3, 3))\n",
    "arr[:, [1, 0, 2]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">17.How to swap two rows in a 2d numpy array?</span>\n",
    "\n",
    "Q. Swap rows 1 and 2 in the array **arr**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3, 4, 5],\n",
       "       [0, 1, 2],\n",
       "       [6, 7, 8]])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.arange(9).reshape((3, 3))\n",
    "arr[[1, 0, 2]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">18.How to reverse the rows of a 2D array?</span>\n",
    "\n",
    "Q. Reverse the rows of a 2D array **arr**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[6, 7, 8],\n",
       "       [3, 4, 5],\n",
       "       [0, 1, 2]])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr = np.arange(9).reshape((3, 3))\n",
    "arr[::-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2],\n",
       "       [3, 4, 5],\n",
       "       [6, 7, 8]])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">19.How to reverse the columns of a 2D array?</span>\n",
    "\n",
    "Q. Reverse the columns of a 2D array **arr**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2, 1, 0],\n",
       "       [5, 4, 3],\n",
       "       [8, 7, 6]])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[:, ::-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">20.How to create a 2D array containing random floats between 5 and 10?</span>\n",
    "\n",
    "Q. Create a 2D array of shape 5x3 to contain random decimal numbers between 5 and 10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 8.77305711,  6.57468646,  9.17556093],\n",
       "       [ 7.40076307,  7.48461222,  7.37856231],\n",
       "       [ 7.83176895,  8.18174803,  7.66970361],\n",
       "       [ 9.28652074,  5.45747331,  6.33414947],\n",
       "       [ 7.16296112,  6.42996746,  9.05844405]])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.randint(5, 10, size=(5, 3)) + np.random.rand(5, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">21.How to print only 3 decimal places in python numpy array?</span>\n",
    "\n",
    "Q. Print or show only 3 decimal places of the numpy array **rand_arr**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.401,  0.632,  0.54 ],\n",
       "       [ 0.604,  0.815,  0.249],\n",
       "       [ 0.403,  0.795,  0.287],\n",
       "       [ 0.759,  0.135,  0.457],\n",
       "       [ 0.613,  0.985,  0.026]])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.set_printoptions(precision=3)\n",
    "rand_arr = np.random.random((5, 3))\n",
    "rand_arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">22.How to pretty print a numpy array by suppressing the scientific notation (like 1e10)?</span>\n",
    "\n",
    "Q. Pretty print **rand_arr** by suppressing the scientific notation (like 1e10)\n",
    "\n",
    "如何通过禁用科学计数法（如1e10）打印Numpy数组**rand_arr**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.000654,  0.000115,  0.00095 ],\n",
       "       [ 0.000482,  0.000872,  0.000212],\n",
       "       [ 0.000041,  0.000397,  0.000233]])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.seed(1000)\n",
    "np.set_printoptions(precision=6, suppress=True)\n",
    "rand_arr = np.random.random((3, 3)) / 1e3\n",
    "rand_arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">23.How to limit the number of items printed in output of numpy array?</span>\n",
    "\n",
    "Q. Limit the number of items printed in python numpy array a to a maximum of 6 elements.\n",
    "\n",
    "如何限制Numpy数组输出中项m的数目。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2, ..., 12, 13, 14])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.set_printoptions(threshold=6)\n",
    "a = np.arange(15)\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">24.How to print the full numpy array without truncating?</span>\n",
    "\n",
    "Q. Print the full numpy array a without truncating.\n",
    "\n",
    "如何在不截断数组的前提下打印出完整的Numpy数组？"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(15)\n",
    "np.set_printoptions(threshold=np.nan)\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">25.How to import a dataset with numbers and texts keeping the text intact in python numpy?</span>\n",
    "\n",
    "Q. Import the iris dataset keeping the text intact."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[b'5.1', b'3.5', b'1.4', b'0.2', b'Iris-setosa'],\n",
       "       [b'4.9', b'3.0', b'1.4', b'0.2', b'Iris-setosa'],\n",
       "       [b'4.7', b'3.2', b'1.3', b'0.2', b'Iris-setosa']], dtype=object)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "url = 'https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data'\n",
    "iris = np.genfromtxt(url, delimiter=',', dtype='object')\n",
    "names = ('sepallength', 'sepalwidth', 'petallength', 'petalwidth', 'species')\n",
    "iris[:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">26.How to extract a particular column from 1D array of tuples?</span>\n",
    "\n",
    "Q. Extract the text column *species* from the 1D iris imported in previous question.\n",
    "\n",
    "如何从1维元组数组中提取特定的列？"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([b'Iris-setosa', b'Iris-setosa', b'Iris-setosa', b'Iris-setosa',\n",
       "       b'Iris-setosa'],\n",
       "      dtype='|S15')"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "species = np.array([row[4] for row in iris])\n",
    "species[: 5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">27.How to convert a 1d array of tuples to a 2d numpy array?</span>\n",
    "\n",
    "Q. Convert the 1D **iris** to 2D array **iris_2d** by omitting the *species* text field.\n",
    "\n",
    "如何将1维元组转换成2维Numpy数组？"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 5.1,  3.5,  1.4,  0.2],\n",
       "       [ 4.9,  3. ,  1.4,  0.2],\n",
       "       [ 4.7,  3.2,  1.3,  0.2],\n",
       "       [ 4.6,  3.1,  1.5,  0.2],\n",
       "       [ 5. ,  3.6,  1.4,  0.2]])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "url = 'https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data'\n",
    "iris_1d = np.genfromtxt(url, delimiter=',', dtype=None)\n",
    "iris_1d[:10]\n",
    "iris_2d = np.array([row.tolist()[:4] for row in iris_1d])\n",
    "iris_2d[:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">28.How to compute the mean, median, standard deviation of a numpy array?</span>\n",
    "\n",
    "Q. Find the mean, median, standard deviation of iris's sepallength (1st column)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.84333333333 5.8 0.825301291785\n"
     ]
    }
   ],
   "source": [
    "url = 'https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data'\n",
    "iris = np.genfromtxt(url, delimiter=',', dtype='object')\n",
    "sepallength = np.genfromtxt(url, delimiter=',', dtype='float', usecols=[0])\n",
    "\n",
    "mu, med, std = np.mean(sepallength), np.median(sepallength), np.std(sepallength)\n",
    "print(mu, med, std)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">29.How to normalize an array so the values range exactly between 0 and 1?</span>\n",
    "\n",
    "Q. Create a normalized form of iris's sepallength whose values range exactly between 0 and 1 so that the minimum has value 0 and maximum has value 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.222222,  0.166667,  0.111111,  0.083333,  0.194444,  0.305556,\n",
       "        0.083333,  0.194444,  0.027778,  0.166667,  0.305556,  0.138889,\n",
       "        0.138889,  0.      ,  0.416667,  0.388889,  0.305556,  0.222222,\n",
       "        0.388889,  0.222222,  0.305556,  0.222222,  0.083333,  0.222222,\n",
       "        0.138889,  0.194444,  0.194444,  0.25    ,  0.25    ,  0.111111,\n",
       "        0.138889,  0.305556,  0.25    ,  0.333333,  0.166667,  0.194444,\n",
       "        0.333333,  0.166667,  0.027778,  0.222222,  0.194444,  0.055556,\n",
       "        0.027778,  0.194444,  0.222222,  0.138889,  0.222222,  0.083333,\n",
       "        0.277778,  0.194444,  0.75    ,  0.583333,  0.722222,  0.333333,\n",
       "        0.611111,  0.388889,  0.555556,  0.166667,  0.638889,  0.25    ,\n",
       "        0.194444,  0.444444,  0.472222,  0.5     ,  0.361111,  0.666667,\n",
       "        0.361111,  0.416667,  0.527778,  0.361111,  0.444444,  0.5     ,\n",
       "        0.555556,  0.5     ,  0.583333,  0.638889,  0.694444,  0.666667,\n",
       "        0.472222,  0.388889,  0.333333,  0.333333,  0.416667,  0.472222,\n",
       "        0.305556,  0.472222,  0.666667,  0.555556,  0.361111,  0.333333,\n",
       "        0.333333,  0.5     ,  0.416667,  0.194444,  0.361111,  0.388889,\n",
       "        0.388889,  0.527778,  0.222222,  0.388889,  0.555556,  0.416667,\n",
       "        0.777778,  0.555556,  0.611111,  0.916667,  0.166667,  0.833333,\n",
       "        0.666667,  0.805556,  0.611111,  0.583333,  0.694444,  0.388889,\n",
       "        0.416667,  0.583333,  0.611111,  0.944444,  0.944444,  0.472222,\n",
       "        0.722222,  0.361111,  0.944444,  0.555556,  0.666667,  0.805556,\n",
       "        0.527778,  0.5     ,  0.583333,  0.805556,  0.861111,  1.      ,\n",
       "        0.583333,  0.555556,  0.5     ,  0.944444,  0.555556,  0.583333,\n",
       "        0.472222,  0.722222,  0.666667,  0.722222,  0.416667,  0.694444,\n",
       "        0.666667,  0.666667,  0.555556,  0.611111,  0.527778,  0.444444])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "url = 'https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data'\n",
    "sepallength = np.genfromtxt(url, delimiter=',', dtype='float', usecols=[0])\n",
    "(sepallength - sepallength.min()) / (sepallength.max() - sepallength.min())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">30.How to compute the softmax score?</span>\n",
    "\n",
    "Q. Compute the softmax score of **sepallength**.\n",
    "\n",
    "```python\n",
    "def softmax(x):\n",
    "    \"\"\"Compute softmax values for each sets of scores in x.\"\"\"\n",
    "    e_x = np.exp(x - np.max(x))\n",
    "    return e_x / e_x.sum(axis=0)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.00222 ,  0.001817,  0.001488,  0.001346,  0.002008,  0.002996,\n",
       "        0.001346,  0.002008,  0.001102,  0.001817,  0.002996,  0.001644,\n",
       "        0.001644,  0.000997,  0.00447 ,  0.004044,  0.002996,  0.00222 ,\n",
       "        0.004044,  0.00222 ,  0.002996,  0.00222 ,  0.001346,  0.00222 ,\n",
       "        0.001644,  0.002008,  0.002008,  0.002453,  0.002453,  0.001488,\n",
       "        0.001644,  0.002996,  0.002453,  0.003311,  0.001817,  0.002008,\n",
       "        0.003311,  0.001817,  0.001102,  0.00222 ,  0.002008,  0.001218,\n",
       "        0.001102,  0.002008,  0.00222 ,  0.001644,  0.00222 ,  0.001346,\n",
       "        0.002711,  0.002008,  0.01484 ,  0.008144,  0.013428,  0.003311,\n",
       "        0.009001,  0.004044,  0.007369,  0.001817,  0.009947,  0.002453,\n",
       "        0.002008,  0.00494 ,  0.005459,  0.006033,  0.003659,  0.010994,\n",
       "        0.003659,  0.00447 ,  0.006668,  0.003659,  0.00494 ,  0.006033,\n",
       "        0.007369,  0.006033,  0.008144,  0.009947,  0.01215 ,  0.010994,\n",
       "        0.005459,  0.004044,  0.003311,  0.003311,  0.00447 ,  0.005459,\n",
       "        0.002996,  0.005459,  0.010994,  0.007369,  0.003659,  0.003311,\n",
       "        0.003311,  0.006033,  0.00447 ,  0.002008,  0.003659,  0.004044,\n",
       "        0.004044,  0.006668,  0.00222 ,  0.004044,  0.007369,  0.00447 ,\n",
       "        0.016401,  0.007369,  0.009001,  0.02704 ,  0.001817,  0.020032,\n",
       "        0.010994,  0.018126,  0.009001,  0.008144,  0.01215 ,  0.004044,\n",
       "        0.00447 ,  0.008144,  0.009001,  0.029884,  0.029884,  0.005459,\n",
       "        0.013428,  0.003659,  0.029884,  0.007369,  0.010994,  0.018126,\n",
       "        0.006668,  0.006033,  0.008144,  0.018126,  0.022139,  0.0365  ,\n",
       "        0.008144,  0.007369,  0.006033,  0.029884,  0.007369,  0.008144,\n",
       "        0.005459,  0.013428,  0.010994,  0.013428,  0.00447 ,  0.01215 ,\n",
       "        0.010994,  0.010994,  0.007369,  0.009001,  0.006668,  0.00494 ])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "url = 'https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data'\n",
    "sepallength = np.genfromtxt(url, delimiter=',', dtype='float', usecols=[0])\n",
    "\n",
    "def softmax(x):\n",
    "    e_x = np.exp(x - np.max(x))\n",
    "    return e_x / e_x.sum(axis=0)\n",
    "\n",
    "softmax(sepallength)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">31.How to find the percentile scores of a numpy array?</span>\n",
    "\n",
    "Q. Find the 5th and 95th percentile of iris's **sepallength**.\n",
    "\n",
    "如何找到Numpy数组的百分位数？"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 4.6  ,  7.255])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "url = 'https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data'\n",
    "sepallength = np.genfromtxt(url, delimiter=',', dtype='float', usecols=[0])\n",
    "\n",
    "np.percentile(sepallength, [5, 95])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">32.How to insert values at random positions in an array?</span>\n",
    "\n",
    "Q. Insert np.nan values at 20 random positions in iris_2d dataset.\n",
    "\n",
    "如何在数组的随机位置插入值？"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[b'5.1', b'3.5', b'1.4', b'0.2', b'Iris-setosa'],\n",
       "       [b'4.9', b'3.0', b'1.4', b'0.2', b'Iris-setosa'],\n",
       "       [b'4.7', b'3.2', b'1.3', b'0.2', b'Iris-setosa'],\n",
       "       [b'4.6', b'3.1', b'1.5', b'0.2', b'Iris-setosa'],\n",
       "       [b'5.0', b'3.6', b'1.4', b'0.2', b'Iris-setosa'],\n",
       "       [b'5.4', b'3.9', b'1.7', b'0.4', b'Iris-setosa'],\n",
       "       [b'4.6', b'3.4', b'1.4', b'0.3', b'Iris-setosa'],\n",
       "       [b'5.0', b'3.4', b'1.5', b'0.2', b'Iris-setosa'],\n",
       "       [b'4.4', nan, b'1.4', b'0.2', b'Iris-setosa'],\n",
       "       [b'4.9', b'3.1', b'1.5', b'0.1', b'Iris-setosa']], dtype=object)"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "url = 'https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data'\n",
    "iris_2d = np.genfromtxt(url, delimiter=',', dtype='object')\n",
    "\n",
    "np.random.seed(100)\n",
    "iris_2d[np.random.randint(150, size=20), np.random.randint(4, size=20)] = np.nan\n",
    "iris_2d[:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">33.How to find the position of missing values in numpy array?</span>\n",
    "\n",
    "Q. Find the number and position of missing values in **iris_2d**'s *sepallength* (1st column)\n",
    "\n",
    "如何在Numpy数组中找出缺失值的位置？"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of missing values: \n",
      " 5\n",
      "Position of missing values: \n",
      " (array([ 38,  80, 106, 113, 121], dtype=int64),)\n"
     ]
    }
   ],
   "source": [
    "url = 'https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data'\n",
    "iris_2d = np.genfromtxt(url, delimiter=',', dtype='float')\n",
    "iris_2d[np.random.randint(150, size=20), np.random.randint(4, size=20)] = np.nan\n",
    "\n",
    "print(\"Number of missing values: \\n\", np.isnan(iris_2d[:, 0]).sum())\n",
    "print(\"Position of missing values: \\n\", np.where(np.isnan(iris_2d[:, 0])))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">34.How to filter a numpy array based on two or more conditions?</span>\n",
    "\n",
    "Q. Filter the rows of **iris_2d** that has *petallength (3rd column) > 1.5* and *sepallength (1st column) < 5.0*.\n",
    "\n",
    "如何基于两个或以上的条件过滤Numpy数组？"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 4.8,  3.4,  1.6,  0.2],\n",
       "       [ 4.8,  3.4,  1.9,  0.2],\n",
       "       [ 4.7,  3.2,  1.6,  0.2],\n",
       "       [ 4.8,  3.1,  1.6,  0.2],\n",
       "       [ 4.9,  2.4,  3.3,  1. ],\n",
       "       [ 4.9,  2.5,  4.5,  1.7]])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "url = 'https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data'\n",
    "iris_2d = np.genfromtxt(url, delimiter=',', dtype='float', usecols=[0,1,2,3])\n",
    "\n",
    "condition = (iris_2d[:, 2] > 1.5) & (iris_2d[:, 0] < 5.0)\n",
    "iris_2d[condition]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">35.How to drop rows that contain a missing value from a numpy array?</span>\n",
    "\n",
    "Q. Select the rows of iris_2d that does not have any nan value.\n",
    "\n",
    "如何在Numpy数组中删除包含缺失值的行？"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 4.9,  3. ,  1.4,  0.2],\n",
       "       [ 4.7,  3.2,  1.3,  0.2],\n",
       "       [ 4.6,  3.1,  1.5,  0.2],\n",
       "       [ 5. ,  3.6,  1.4,  0.2],\n",
       "       [ 4.6,  3.4,  1.4,  0.3]])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "url = 'https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data'\n",
    "iris_2d = np.genfromtxt(url, delimiter=',', dtype='float', usecols=[0,1,2,3])\n",
    "iris_2d[np.random.randint(150, size=20), np.random.randint(4, size=20)] = np.nan\n",
    "\n",
    "any_nan_in_row = np.array([~np.any(np.isnan(row)) for row in iris_2d])\n",
    "iris_2d[any_nan_in_row][:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">36.How to find the correlation between two columns of a numpy array?</span>\n",
    "\n",
    "Q. Find the correlation between SepalLength(1st column) and PetalLength(3rd column) in iris_2d\n",
    "\n",
    "如何找出Numpy数组中两列之间的相关性？"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.      ,  0.871754],\n",
       "       [ 0.871754,  1.      ]])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "url = 'https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data'\n",
    "iris_2d = np.genfromtxt(url, delimiter=',', dtype='float', usecols=[0,1,2,3])\n",
    "\n",
    "np.corrcoef(iris_2d[:, 0], iris_2d[:, 2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.871754157305\n"
     ]
    }
   ],
   "source": [
    "from scipy.stats.stats import pearsonr\n",
    "corr, p_value = pearsonr(iris_2d[:, 0], iris_2d[:, 2])\n",
    "print(corr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">37.How to find if a given array has any null values?</span>\n",
    "\n",
    "Q. Find out if iris_2d has any missing values.\n",
    "\n",
    "如何确定数组是否有空值？"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "url = 'https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data'\n",
    "iris_2d = np.genfromtxt(url, delimiter=',', dtype='float', usecols=[0,1,2,3])\n",
    "\n",
    "np.isnan(iris_2d).any()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> 没有空值。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">38.How to replace all missing values with 0 in a numpy array?</span>\n",
    "\n",
    "Q. Replace all ccurrences of nan with 0 in numpy array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Input\n",
    "url = 'https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data'\n",
    "iris_2d = np.genfromtxt(url, delimiter=',', dtype='float', usecols=[0,1,2,3])\n",
    "iris_2d[np.random.randint(150, size=20), np.random.randint(4, size=20)] = np.nan\n",
    "\n",
    "\n",
    "iris_2d[np.isnan(iris_2d)] = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">39.How to find the count of unique values in a numpy array?</span>\n",
    "\n",
    "Q. Find the unique values and the count of unique values in iris's *species*.\n",
    "\n",
    "如何在Numpy数组中找出唯一值的数量？"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([b'Iris-setosa', b'Iris-versicolor', b'Iris-virginica'],\n",
       "       dtype='|S15'), array([50, 50, 50], dtype=int64))"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Input\n",
    "url = 'https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data'\n",
    "iris = np.genfromtxt(url, delimiter=',', dtype='object')\n",
    "names = ('sepallength', 'sepalwidth', 'petallength', 'petalwidth', 'species')\n",
    "\n",
    "species = np.array([row[4] for row in iris])\n",
    "# species = np.array([row.tolist()[4] for row in iris])\n",
    "np.unique(species, return_counts=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">40.How to convert a numeric to a categorical (text) array?</span>\n",
    "\n",
    "如何将一个数值转换为一个类别（文本）数组？\n",
    "\n",
    "Q. Bin the petal length (3rd) column of iris_2d to form a text array, such that if petal length is:\n",
    "+ Less than 3 --> 'small'\n",
    "+ From 3 to 5 --> 'medium'\n",
    "+ Greater than 5 --> 'large'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "       1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n",
       "       1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n",
       "       2, 2, 2, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 3, 2, 2, 2, 2, 2, 2, 2, 2,\n",
       "       2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 2, 3, 3, 3, 3, 3, 3, 3, 3,\n",
       "       3, 3, 3, 3, 3, 3, 2, 3, 2, 3, 3, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,\n",
       "       2, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3], dtype=int64)"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Input\n",
    "url = 'https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data'\n",
    "iris = np.genfromtxt(url, delimiter=',', dtype='object')\n",
    "names = ('sepallength', 'sepalwidth', 'petallength', 'petalwidth', 'species')\n",
    "\n",
    "# bin petallength\n",
    "petal_length_bin = np.digitize(iris[:, 2].astype('float'), [0, 3, 5, 10])\n",
    "petal_length_bin"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['small',\n",
       " 'small',\n",
       " 'small',\n",
       " 'small',\n",
       " 'small',\n",
       " 'small',\n",
       " 'small',\n",
       " 'small',\n",
       " 'small',\n",
       " 'small']"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# map it to respective category\n",
    "label_map = {1: 'small', 2: 'medium', 3: 'large', 4: np.nan}\n",
    "petal_length_cat = [label_map[x] for x in petal_length_bin]\n",
    "petal_length_cat[:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">41.How to create a new column from existing columns of a numpy array?</span>\n",
    "\n",
    "如何基于Numpy数组现有列创建一个新的列？\n",
    "\n",
    "Q. Create a new column for volume in iris_2d, where volume is $(pi \\times petallength \\times sepallength^2)\\div3$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[b'5.1', b'3.5', b'1.4', b'0.2', b'Iris-setosa', 38.13265162927291],\n",
       "       [b'4.9', b'3.0', b'1.4', b'0.2', b'Iris-setosa', 35.200498485922445],\n",
       "       [b'4.7', b'3.2', b'1.3', b'0.2', b'Iris-setosa', 30.0723720777127],\n",
       "       [b'4.6', b'3.1', b'1.5', b'0.2', b'Iris-setosa', 33.238050274980004]], dtype=object)"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Input\n",
    "url = 'https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data'\n",
    "iris_2d = np.genfromtxt(url, delimiter=',', dtype='object')\n",
    "names = ('sepallength', 'sepalwidth', 'petallength', 'petalwidth', 'species')\n",
    "\n",
    "petallength = iris_2d[:, 2].astype('float')\n",
    "sepallength = iris_2d[:, 0].astype('float')\n",
    "volume = np.pi * petallength * np.power(sepallength, 2) / 3\n",
    "\n",
    "# add a new dimension to volume\n",
    "volume[:, np.newaxis]\n",
    "\n",
    "# add the new column\n",
    "# new_iris_2d = np.c_[iris_2d, volume]\n",
    "np.c_[iris_2d, volume][:4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">42.How to do probabilistic sampling in numpy?</span>\n",
    "\n",
    "如何在Numpy中执行概率采样？\n",
    "\n",
    "Q. Randomly sample **iris**'s **species** such that **setosa** is twice the number of **versicolor** and **virginica**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array(['Iris-setosa', 'Iris-versicolor', 'Iris-virginica'],\n",
       "       dtype='<U15'), array([77, 37, 36], dtype=int64))"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Import iris keeping the text column intact\n",
    "url = 'https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data'\n",
    "iris = np.genfromtxt(url, delimiter=',', dtype='object')\n",
    "\n",
    "species = iris[:, 4]\n",
    "\n",
    "\n",
    "# Approach 1: Generate Probablistically\n",
    "np.random.seed(100)\n",
    "a = np.array(['Iris-setosa', 'Iris-versicolor', 'Iris-virginica'])\n",
    "species_out = np.random.choice(a, 150, p=[.5, .25, .25])\n",
    "np.unique(species_out, return_counts=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([b'Iris-setosa', b'Iris-versicolor', b'Iris-virginica'], dtype=object),\n",
       " array([77, 37, 36], dtype=int64))"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Approach 2: Probablistic Sampling(perferred)\n",
    "np.random.seed(100)\n",
    "probs = np.r_[np.linspace(0, 0.500), np.linspace(0.501, 0.750), np.linspace(.751, 1.0)]\n",
    "index = np.searchsorted(probs, np.random.random(150))\n",
    "species_out = species[index]\n",
    "np.unique(species_out, return_counts=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Approach 2 is preferred because it creates an index variable that can be used to sample 2d tabular data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">43.How to get the second largest value of an array when grouped by another array?</span>\n",
    "\n",
    "如何在多维数组中找到一维的最大值？\n",
    "\n",
    "Q. What is the value of second longest **petallength** of species **setosa**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.7"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Input\n",
    "url = 'https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data'\n",
    "iris = np.genfromtxt(url, delimiter=',', dtype='object')\n",
    "names = ('sepallength', 'sepalwidth', 'petallength', 'petalwidth', 'species')\n",
    "\n",
    "# Get the species and petal lenget column\n",
    "iris_setosa = iris[iris[:, 4] == b'Iris-setosa', 2].astype('float')\n",
    "\n",
    "# np.unique(iris_setosa)\n",
    "np.unique(iris_setosa)[-2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">44.How to sort a 2D array by a column</span>\n",
    "\n",
    "如何用给定列将二维数组排序？\n",
    "\n",
    "Q. Sort the iris dataset based on *sepallength* column."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[b'4.3', b'3.0', b'1.1', b'0.1', b'Iris-setosa'],\n",
       "       [b'4.4', b'3.2', b'1.3', b'0.2', b'Iris-setosa'],\n",
       "       [b'4.4', b'3.0', b'1.3', b'0.2', b'Iris-setosa'],\n",
       "       [b'4.4', b'2.9', b'1.4', b'0.2', b'Iris-setosa'],\n",
       "       [b'4.5', b'2.3', b'1.3', b'0.3', b'Iris-setosa'],\n",
       "       [b'4.6', b'3.6', b'1.0', b'0.2', b'Iris-setosa'],\n",
       "       [b'4.6', b'3.1', b'1.5', b'0.2', b'Iris-setosa'],\n",
       "       [b'4.6', b'3.4', b'1.4', b'0.3', b'Iris-setosa'],\n",
       "       [b'4.6', b'3.2', b'1.4', b'0.2', b'Iris-setosa'],\n",
       "       [b'4.7', b'3.2', b'1.3', b'0.2', b'Iris-setosa'],\n",
       "       [b'4.7', b'3.2', b'1.6', b'0.2', b'Iris-setosa'],\n",
       "       [b'4.8', b'3.0', b'1.4', b'0.1', b'Iris-setosa'],\n",
       "       [b'4.8', b'3.0', b'1.4', b'0.3', b'Iris-setosa'],\n",
       "       [b'4.8', b'3.4', b'1.9', b'0.2', b'Iris-setosa'],\n",
       "       [b'4.8', b'3.4', b'1.6', b'0.2', b'Iris-setosa'],\n",
       "       [b'4.8', b'3.1', b'1.6', b'0.2', b'Iris-setosa'],\n",
       "       [b'4.9', b'2.4', b'3.3', b'1.0', b'Iris-versicolor'],\n",
       "       [b'4.9', b'2.5', b'4.5', b'1.7', b'Iris-virginica'],\n",
       "       [b'4.9', b'3.1', b'1.5', b'0.1', b'Iris-setosa'],\n",
       "       [b'4.9', b'3.1', b'1.5', b'0.1', b'Iris-setosa']], dtype=object)"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "url = 'https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data'\n",
    "iris = np.genfromtxt(url, delimiter=',', dtype='object')\n",
    "names = ('sepallength', 'sepalwidth', 'petallength', 'petalwidth', 'species')\n",
    "\n",
    "iris[iris[:, 0].argsort()][: 20]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">45.How to find the most frequent value in a numpy array?</span>\n",
    "\n",
    "如何在Numpy数组中找到最频繁出现的值？\n",
    "\n",
    "Q. Find the most frequent value of petal length (3rd column) in iris dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vals: [b'0.1' b'0.2' b'0.3' b'0.4' b'0.5' b'0.6' b'1.0' b'1.1' b'1.2' b'1.3'\n",
      " b'1.4' b'1.5' b'1.6' b'1.7' b'1.8' b'1.9' b'2.0' b'2.1' b'2.2' b'2.3'\n",
      " b'2.4' b'2.5'] \n",
      "Counts: [ 6 28  7  7  1  1  7  3  5 13  8 12  4  2 12  5  6  6  3  8  3  3]\n"
     ]
    }
   ],
   "source": [
    "# Input\n",
    "url = 'https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data'\n",
    "iris = np.genfromtxt(url, delimiter=',', dtype='object')\n",
    "names = ('sepallength', 'sepalwidth', 'petallength', 'petalwidth', 'species')\n",
    "\n",
    "vals, counts = np.unique(iris[:, 3], return_counts=True)\n",
    "print('Vals:', vals, '\\nCounts:', counts)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "b'0.2'"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vals[np.argmax(counts)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">46.How to find the position of the first occurrence of a value greater than a given value?</span>\n",
    "\n",
    "如何找到第一个大于给定值的数的位置？\n",
    "\n",
    "Q. Find the position of the first occurrence of a value greater than 1.0 in petalwidth 4th column of iris dataset."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "50"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Input\n",
    "url = 'https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data'\n",
    "iris = np.genfromtxt(url, delimiter=',', dtype='object')\n",
    "names = ('sepallength', 'sepalwidth', 'petallength', 'petalwidth', 'species')\n",
    "np.argmax(iris[:, 3].astype('float') > 1.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">47.How to replace all values greater than a given value to a given cutoff?</span>\n",
    "\n",
    "如何将数组中所有大于给定值的数替换为给定的cutoff值？\n",
    "\n",
    "Q. From the array **a**, replace all values greater than 30 to 30 and less than 10 to 10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 27.626842,  14.6401  ,  21.801362,  30.      ,  10.      ,\n",
       "        10.      ,  30.      ,  30.      ,  10.      ,  29.179573,\n",
       "        30.      ,  11.250904,  10.081083,  10.      ,  11.765177,\n",
       "        30.      ,  30.      ,  10.      ,  30.      ,  14.429614])"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.seed(100)\n",
    "a = np.random.uniform(1, 50, 20)\n",
    "\n",
    "np.where(a > 30, 30, np.where(a < 10, 10, a))  # Solution 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 27.626842,  14.6401  ,  21.801362,  30.      ,  10.      ,\n",
       "        10.      ,  30.      ,  30.      ,  10.      ,  29.179573,\n",
       "        30.      ,  11.250904,  10.081083,  10.      ,  11.765177,\n",
       "        30.      ,  30.      ,  10.      ,  30.      ,  14.429614])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.clip(a, 10, 30)  # Solution 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">48.How to get the positions of top n values from a numpy array?</span>\n",
    "\n",
    "如何在数组中找到top-n的数值的位置？\n",
    "\n",
    "Q. Get the positions of top 5 maximum values in a given array **a**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([18,  7,  3, 10, 15], dtype=int64)"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.seed(100)\n",
    "a = np.random.uniform(1, 50, 20)\n",
    "\n",
    "# Solution 1\n",
    "np.argsort(a)[-5:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([15, 10,  3,  7, 18], dtype=int64)"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.argpartition(-a, 5)[:5]  # Solution 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([18,  7,  3, 10, 15], dtype=int64)"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.argpartition(a, kth=-5)[-5:]  # Solution 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([18,  7,  3, 10, 15], dtype=int64)"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.argpartition(a, kth=16)[-5:]   # Solution 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 40.995013,  41.466785,  42.39403 ,  44.674776,  48.952565])"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sort(a)[-5:]  # Method 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 40.995013,  41.466785,  42.39403 ,  44.674776,  48.952565])"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[a.argsort()][-5:]  # Method 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Method 1 and 2 will get you the values."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color: red'>49.How to compute the row wise counts of all possible values in an array?</span>\n",
    "\n",
    "如何逐行计算数组中所有值的数量？\n",
    "\n",
    "Q. Compute the counts of unique values row-wise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 9,  9,  4,  8,  8,  1,  5,  3,  6,  3],\n",
       "       [ 3,  3,  2,  1,  9,  5,  1, 10,  7,  3],\n",
       "       [ 5,  2,  6,  4,  5,  5,  4,  8,  2,  2],\n",
       "       [ 8,  8,  1,  3, 10, 10,  4,  3,  6,  9],\n",
       "       [ 2,  1,  8,  7,  3,  1,  9,  3,  6,  2],\n",
       "       [ 9,  2,  6,  5,  3,  9,  4,  6,  1, 10]])"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.seed(100)\n",
    "arr = np.random.randint(1, 11, size=(6, 10))\n",
    "arr"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Input:\n",
    "```python\n",
    "array([[ 9,  9,  4,  8,  8,  1,  5,  3,  6,  3],\n",
    "     [ 3,  3,  2,  1,  9,  5,  1, 10,  7,  3],\n",
    "     [ 5,  2,  6,  4,  5,  5,  4,  8,  2,  2],\n",
    "     [ 8,  8,  1,  3, 10, 10,  4,  3,  6,  9],\n",
    "     [ 2,  1,  8,  7,  3,  1,  9,  3,  6,  2],\n",
    "     [ 9,  2,  6,  5,  3,  9,  4,  6,  1, 10]])\n",
    "```\n",
    "Desired Output:\n",
    "```python\n",
    "array([[1, 0, 2, 1, 1, 1, 0, 2, 2, 0],\n",
    "     [2, 1, 3, 0, 1, 0, 1, 0, 1, 1],\n",
    "     [0, 3, 0, 2, 3, 1, 0, 1, 0, 0],\n",
    "     [1, 0, 2, 1, 0, 1, 0, 2, 1, 2],\n",
    "     [2, 2, 2, 0, 0, 1, 1, 1, 1, 0],      \n",
    "     [1, 1, 1, 1, 1, 2, 0, 0, 2, 1]] \n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Output contains 10 columns representing numbers from 1 to 10. The values are the counts of the numbers in the respective rows.  \n",
    "For example, Cell[0, 2] have the value 2, which means, the number 3 occurs exactly 2 times in the 1st row.\n",
    "\n",
    "输出包含 10 个列，表示从 1 到 10 的数字。这些数值分别代表每一行的计数数量。\n",
    "例如，Cell(0,2) 中有值 2，这意味着，数字 3 在第一行出现了两次。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 0, 2, 1, 1, 1, 0, 2, 2, 0],\n",
       "       [2, 1, 3, 0, 1, 0, 1, 0, 1, 1],\n",
       "       [0, 3, 0, 2, 3, 1, 0, 1, 0, 0],\n",
       "       [1, 0, 2, 1, 0, 1, 0, 2, 1, 2],\n",
       "       [2, 2, 2, 0, 0, 1, 1, 1, 1, 0],\n",
       "       [1, 1, 1, 1, 1, 2, 0, 0, 2, 1]])"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def counts_of_all_values_rowwise_1(arr2d):\n",
    "    # the number of columns of returned array\n",
    "    column_num = len(np.unique(arr2d))\n",
    "    xixi = np.zeros((arr2d.shape[0], column_num))\n",
    "    for i in range(arr2d.shape[0]):\n",
    "        # Unique values and its counts row wise\n",
    "        vals, counts = np.unique(arr2d[i], return_counts=True)\n",
    "        for j in range(column_num):\n",
    "            if j+1 in vals:\n",
    "                xixi[i, j] = counts[vals.tolist().index(j+1)]\n",
    "            else:\n",
    "                xixi[i, j] = 0\n",
    "    return xixi.astype('int')\n",
    "\n",
    "counts_of_all_values_rowwise_1(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def counts_of_all_values_rowwise_2(arr2d):\n",
    "    '''Reference answer.'''\n",
    "    # Unique values and its counts row wise\n",
    "    num_counts_array = [np.unique(row, return_counts=True) for row in arr2d]\n",
    "    # Counts of all values row wise\n",
    "    return ([[int(b[a == i]) if i in a else 0 for i in np.unique(arr2d)]\n",
    "             for a, b in num_counts_array])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 0, 2, 1, 1, 1, 0, 2, 2, 0],\n",
       " [2, 1, 3, 0, 1, 0, 1, 0, 1, 1],\n",
       " [0, 3, 0, 2, 3, 1, 0, 1, 0, 0],\n",
       " [1, 0, 2, 1, 0, 1, 0, 2, 1, 2],\n",
       " [2, 2, 2, 0, 0, 1, 1, 1, 1, 0],\n",
       " [1, 1, 1, 1, 1, 2, 0, 0, 2, 1]]"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "counts_of_all_values_rowwise_2(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([['b', 'i', 'l', 'l', ' ', 'c', 'l', 'i', 'n', 't', 'o', 'n'],\n",
       "       ['n', 'a', 'r', 'e', 'n', 'd', 'r', 'a', 'm', 'o', 'd', 'i'],\n",
       "       ['j', 'j', 'a', 'y', 'a', 'l', 'a', 'l', 'i', 't', 'h', 'a']],\n",
       "      dtype='<U1')"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Another example\n",
    "arr2 = np.array([np.array(list('bill clinton')),\n",
    "                 np.array(list('narendramodi')),\n",
    "                np.array(list('jjayalalitha'))])\n",
    "arr2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([' ', 'a', 'b', 'c', 'd', 'e', 'h', 'i', 'j', 'l', 'm', 'n', 'o',\n",
       "       'r', 't', 'y'],\n",
       "      dtype='<U1')"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.unique(arr2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 0, 1, 1, 0, 0, 0, 2, 0, 3, 0, 2, 1, 0, 1, 0],\n",
       " [0, 2, 0, 0, 2, 1, 0, 1, 0, 0, 1, 2, 1, 2, 0, 0],\n",
       " [0, 4, 0, 0, 0, 0, 1, 1, 2, 2, 0, 0, 0, 0, 1, 1]]"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "counts_of_all_values_rowwise_2(arr2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">50.How to convert an array of arrays into a flat 1d array?</span>\n",
    "\n",
    "如何将 array_of_arrays 转换为平面 1 维数组？\n",
    "\n",
    "Q. Convert **array_of_arrays** into a flat linear 1d array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([array([0, 1, 2]), array([3, 4, 5, 6]), array([7, 8, 9])], dtype=object)"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Input\n",
    "arr1 = np.arange(3)\n",
    "arr2 = np.arange(3, 7)\n",
    "arr3 = np.arange(7, 10)\n",
    "\n",
    "array_of_arrays = np.array([arr1, arr2, arr3])\n",
    "array_of_arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([array([0, 1, 2]), array([3, 4, 5, 6]), array([7, 8, 9])], dtype=object)"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ravel(array_of_arrays)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([a for row in array_of_arrays for a in row])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.concatenate(array_of_arrays)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">51.How to generate one-hot encodings for an array in numpy?</span>\n",
    "\n",
    "如何为 NumPy 数组生成 one-hot 编码？\n",
    "\n",
    "Q. Compute the one-hot encodings (dummy binary variables for each unique value in the array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.,  1.,  0.],\n",
       "       [ 0.,  0.,  1.],\n",
       "       [ 0.,  1.,  0.],\n",
       "       [ 0.,  1.,  0.],\n",
       "       [ 0.,  1.,  0.],\n",
       "       [ 1.,  0.,  0.]])"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Input\n",
    "np.random.seed(101)\n",
    "arr = np.random.randint(1, 4 ,size=6)\n",
    "\n",
    "def one_hot_encoding(arr):\n",
    "    uniqs = np.unique(arr)\n",
    "    out = np.zeros((arr.shape[0], uniqs.shape[0]))\n",
    "    for i, k in enumerate(arr):\n",
    "        out[i, k-1] = 1\n",
    "    return out\n",
    "\n",
    "one_hot_encoding(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">52.How to create row numbers grouped by a categorical variable?</span>\n",
    "\n",
    "如何创建由类别变量分组确定的一维数值？\n",
    "\n",
    "Q. Create row numbers grouped by a categorical variable. Use the following sample from **iris** **species** as input."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['Iris-setosa', 'Iris-setosa', 'Iris-setosa', 'Iris-setosa',\n",
       "       'Iris-setosa', 'Iris-versicolor', 'Iris-versicolor',\n",
       "       'Iris-versicolor', 'Iris-versicolor', 'Iris-versicolor',\n",
       "       'Iris-versicolor', 'Iris-virginica', 'Iris-virginica',\n",
       "       'Iris-virginica', 'Iris-virginica', 'Iris-virginica',\n",
       "       'Iris-virginica', 'Iris-virginica', 'Iris-virginica',\n",
       "       'Iris-virginica'],\n",
       "      dtype='<U15')"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Input\n",
    "url = 'https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data'\n",
    "species = np.genfromtxt(url, delimiter=',', dtype='str', usecols=4)\n",
    "species_small = np.sort(np.random.choice(species, size=20))\n",
    "species_small"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 6, 7, 8]\n"
     ]
    }
   ],
   "source": [
    "print([index for val in np.unique(species_small)\n",
    "       for index, value in enumerate(species_small[species_small == val])])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color: red'>53.How to create groud ids based on a given categorical variable?</span>\n",
    "\n",
    "如何基于给定的类别变量创建分组 id？\n",
    "\n",
    "Q. Create group ids based on a given categorical variable. Use the following sample from **iris species** as input."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['Iris-setosa', 'Iris-setosa', 'Iris-setosa', 'Iris-setosa',\n",
       "       'Iris-setosa', 'Iris-setosa', 'Iris-versicolor', 'Iris-versicolor',\n",
       "       'Iris-versicolor', 'Iris-versicolor', 'Iris-versicolor',\n",
       "       'Iris-versicolor', 'Iris-virginica', 'Iris-virginica',\n",
       "       'Iris-virginica', 'Iris-virginica', 'Iris-virginica',\n",
       "       'Iris-virginica', 'Iris-virginica', 'Iris-virginica'],\n",
       "      dtype='<U15')"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Input\n",
    "url = 'https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data'\n",
    "species = np.genfromtxt(url, delimiter=',', dtype='str', usecols=4)\n",
    "species_small = np.sort(np.random.choice(species, size=20))\n",
    "species_small"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2])"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vals, counts = np.unique(species_small, return_counts=True)\n",
    "output = np.repeat([i for i, val in enumerate(vals)], counts)\n",
    "# output.tolist()\n",
    "output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2]"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Reference solution\n",
    "[np.argwhere(np.unique(species_small) == s).tolist()[0][0]\n",
    "for val in np.unique(species_small) for s in species_small[species_small == val]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2]\n"
     ]
    }
   ],
   "source": [
    "# Reference solution: For loop version\n",
    "output = []\n",
    "uniqs = np.unique(species_small)\n",
    "\n",
    "for val in uniqs:  # unique values in group\n",
    "    for s in species_small[species_small == val]:  # each element in group\n",
    "        groupid = np.argwhere(uniqs == s).tolist()[0][0]  # groupid\n",
    "        output.append(groupid)\n",
    "        \n",
    "print(output)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color: red'>54.How to rank items in an array using numpy?</span>\n",
    "\n",
    "如何使用 NumPy 对数组中的项进行排序？\n",
    "\n",
    "Q. Create the ranks for the given numeric array **a**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 9,  4, 15,  0, 17, 16, 17,  8,  9,  0])"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Input\n",
    "np.random.seed(10)\n",
    "a = np.random.randint(20, size=10)\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Desired Output:\n",
    "```python\n",
    "[4 2 6 0 8 7 9 3 5 1]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 9, 1, 7, 0, 8, 2, 5, 4, 6], dtype=int64)"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.argsort(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 2, 6, 0, 8, 7, 9, 3, 5, 1], dtype=int64)"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.argsort(np.argsort(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">55.How to rank items in a multidimensional array using numpy?</span>\n",
    "\n",
    "如何使用 NumPy 对多维数组中的项进行排序？\n",
    "\n",
    "Q. Create a rank array of the same shape as a given numeric array **a**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 9,  4, 15,  0, 17],\n",
       "       [16, 17,  8,  9,  0]])"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Input\n",
    "np.random.seed(10)\n",
    "a = np.random.randint(20, size=(2, 5))\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Desired Output\n",
    "```python\n",
    "[[4 2 6 0 8]\n",
    "[7 9 3 5 1]]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[4 2 6 0 8]\n",
      " [7 9 3 5 1]]\n"
     ]
    }
   ],
   "source": [
    "print(np.ravel(a).argsort().argsort().reshape(a.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">56.How to find the maximum value in each row of a numpy array 2d?</span>\n",
    "\n",
    "如何在 2 维 NumPy 数组中找到每一行的最大值？\n",
    "\n",
    "Q. Compute the maximum for each row in the given array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([9, 8, 6, 3, 9])"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Input\n",
    "np.random.seed(100)\n",
    "a = np.random.randint(1, 10, size=[5, 3])\n",
    "\n",
    "np.max(a, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([9, 8, 6, 3, 9])"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Reference solution 1\n",
    "np.amax(a, axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([9, 8, 6, 3, 9])"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Reference solution 2\n",
    "np.apply_along_axis(np.max, arr=a, axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">57.How to compute the min-by-max for each row for a numpy array 2d?</span>\n",
    "\n",
    "如何计算 2 维 NumPy 数组每一行的 min-by-max？\n",
    "\n",
    "Q. Compute the min-by-max for each row for given 2d numpy array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[9, 9, 4],\n",
       "       [8, 8, 1],\n",
       "       [5, 3, 6],\n",
       "       [3, 3, 3],\n",
       "       [2, 1, 9]])"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Input \n",
    "np.random.seed(100)\n",
    "a = np.random.randint(1, 10, size=(5, 3))\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.444444,  0.125   ,  0.5     ,  1.      ,  0.111111])"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.apply_along_axis(lambda x: np.min(x)/np.max(x), arr=a, axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">58.How to find the duplicate records in a numpy array?</span>\n",
    "\n",
    "如何在 NumPy 数组中找到重复条目？\n",
    "\n",
    "Q. Find the duplicate entries (2nd occurrence onwards) in the given numpy array and mark them as `True`. First time occurrences should be `False`.\n",
    "\n",
    "问题：在给定的 NumPy 数组中找到重复条目（从第二次出现开始），并将其标记为 `True`。第一次出现的条目需要标记为 `False`。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 3, 0, 2, 4, 2, 2, 2, 2])"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Input\n",
    "np.random.seed(100)\n",
    "a = np.random.randint(0, 5, size=10)\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Desired Output:\n",
    "```python\n",
    "[False True False True False False True True True True]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False,  True, False,  True, False, False,  True,  True,  True,  True], dtype=bool)"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Create an all True array\n",
    "out = np.full(a.shape[0], True)\n",
    "# Find the index positions of uniques elements\n",
    "unique_positions = np.unique(a, return_index=True)[1]\n",
    "# Mark those positions as False\n",
    "out[unique_positions] = False\n",
    "out"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">59.How to find the grouped mean in numpy?</span>\n",
    "\n",
    "如何找到 NumPy 的分组平均值\n",
    "\n",
    "Q. Find the mean of a numeric column grouped by a categorical column in a 2D numpy array.\n",
    "\n",
    "问题：在 2 维 NumPy 数组的类别列中找到数值的平均值。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Input\n",
    "url = 'https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data'\n",
    "iris = np.genfromtxt(url, delimiter=',', dtype='object')\n",
    "names = ('sepallength', 'sepalwidth', 'petallength', 'petalwidth', 'species')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "numeric_column = iris[:, 1].astype('float')  # sepal length\n",
    "grouping_species = iris[:, 4]  # species"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[b'Iris-setosa', 3.4180000000000001],\n",
       " [b'Iris-versicolor', 2.7700000000000005],\n",
       " [b'Iris-virginica', 2.9740000000000002]]"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# For loop version\n",
    "output = []\n",
    "for group_val in np.unique(grouping_species):\n",
    "    output.append([group_val, numeric_column[grouping_species == group_val].mean()])\n",
    "output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[b'Iris-setosa', 3.4180000000000001],\n",
       " [b'Iris-versicolor', 2.7700000000000005],\n",
       " [b'Iris-virginica', 2.9740000000000002]]"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# List comprehension version\n",
    "[[group_val, numeric_column[grouping_species == group_val].mean()]\n",
    " for group_val in np.unique(grouping_species)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">60.How to convert a PIL image to numpy array?</span>\n",
    "\n",
    "如何将 PIL 图像转换成 NumPy 数组？\n",
    "\n",
    "Q. Import the image from the following URL and convert it to a numpy array.\n",
    "\n",
    "URL = 'https://upload.wikimedia.org/wikipedia/commons/8/8b/Denali_Mt_McKinley.jpg'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from io import BytesIO\n",
    "import PIL\n",
    "import requests\n",
    "\n",
    "# Import image from URL\n",
    "URL = 'https://upload.wikimedia.org/wikipedia/commons/8/8b/Denali_Mt_McKinley.jpg'\n",
    "response = requests.get(URL)\n",
    "\n",
    "# Read it as Image\n",
    "I = PIL.Image.open(BytesIO(response.content))\n",
    "\n",
    "# Optionally resize\n",
    "I = I.resize([150, 150])\n",
    "\n",
    "# Convert to numpy array\n",
    "arr = np.asarray(I)\n",
    "\n",
    "# Optionaly convert it back to an image and show\n",
    "im = PIL.Image.fromarray(np.uint8(arr))\n",
    "PIL.Image.Image.show(im)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">61.How to drop all missing values from a numpy array?</span>\n",
    "\n",
    "如何删除 NumPy 数组中所有的缺失值？\n",
    "\n",
    "Q. Drop all `nan` values from a 1D numpy array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Input\n",
    "a = np.array([1, 2, 3, np.nan, 5, 6, 7, np.nan])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Desired Output:\n",
    "```python\n",
    "array([1., 2., 3., 4., 5., 6., 7.])\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False, False,  True, False, False, False,  True], dtype=bool)"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.isnan(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.,  2.,  3.,  5.,  6.,  7.])"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[~np.isnan(a)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color: red'>62.How to compute the euclidean distance between two arrays?</span>\n",
    "\n",
    "Q. Compute the euclidean distance between two arrays **a** and **b**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.7082039324993694"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Input\n",
    "a = np.array([1, 2, 3, 4, 5])\n",
    "b = np.array([4, 5, 6, 7, 8])\n",
    "\n",
    "np.linalg.norm(a-b, ord=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color:red'>63.How to find all the local maxima (or peaks) in a 1d array?</span>\n",
    "\n",
    "如何在一个 1 维数组中找到所有的局部极大值（peak）？\n",
    "\n",
    "Q. Find all the peaks in a 1D numpy array **a**. Peaks are points surrounded by smaller values on both sides."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Input\n",
    "a = np.array([1, 3, 7, 1, 2, 6, 0, 1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Desired Output:\n",
    "```python\n",
    "array([2, 5])\n",
    "```\n",
    "where, 2 and 5 are the positions of peak values 7 an 6."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 5], dtype=int64)"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Solution\n",
    "doublediff = np.diff(np.sign(np.diff(a)))\n",
    "peak_locations = np.where(doublediff == -2)[0] + 1\n",
    "peak_locations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">64.How to subtract a 1d array from a 2d array, where each item of 1d array subtracts from respective row?</span>\n",
    "\n",
    "如何从 2 维数组中减去 1 维数组，从 2 维数组的每一行分别减去 1 维数组的每一项？\n",
    "\n",
    "Q. Subtract the 1d array **b_1d** from the 2d array **a_2d**, such that each item of **b_1d** subtracts from respective row of **a_2d**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Input\n",
    "a_2d = np.array([[3, 3, 3], [4, 4, 4], [5, 5, 5]])\n",
    "b_1d = np.array([1, 2, 3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Desired Output:\n",
    "```python\n",
    "[[2 2 2]\n",
    " [2 2 2]\n",
    " [2 2 2]]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2, 2, 2],\n",
       "       [2, 2, 2],\n",
       "       [2, 2, 2]])"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a_2d - b_1d[:, np.newaxis]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2, 2, 2],\n",
       "       [2, 2, 2],\n",
       "       [2, 2, 2]])"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Reference solution\n",
    "a_2d - b_1d[:, None]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1],\n",
       "       [2],\n",
       "       [3]])"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b_1d[:, np.newaxis]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1],\n",
       "       [2],\n",
       "       [3]])"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b_1d[:, None]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">65.How to find the index of n'th repetition of an item in an array?</span>\n",
    "\n",
    "如何在数组中找出某个项的第 n 个重复索引？\n",
    "\n",
    "Q. Find the index of 5th repetition of number 1 in **x**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Input\n",
    "x = np.array([1, 2, 1, 1, 3, 4, 3, 1, 1, 2, 1, 1, 2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 2, 3, 7, 8, 10, 11]"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Solution 1: List comprehension\n",
    "n = 5\n",
    "[index for index, value in enumerate(x) if value == 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[index for index, value in enumerate(x) if value == 1][n-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Solution 2: Numpu version\n",
    "np.where(x == 1)[0][n-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">66.How to convert numpy's datetime64 object to datetime's datetime object?</span>\n",
    "\n",
    "如何将 NumPy 的 datetime64 对象（object）转换为 datetime 的 datetime 对象？\n",
    "\n",
    "Q. Convert numpy's `datetime64` object to datetime's `datetime` object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.datetime64('2018-03-08T15:21:15')"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Input: a numpy datetime64 object\n",
    "dt64 = np.datetime64('2018-03-08 15:21:15')\n",
    "dt64"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from datetime import datetime"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.datetime(2018, 3, 8, 15, 21, 15)"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dt64.astype(datetime)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "datetime.datetime(2018, 3, 8, 15, 21, 15)"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Solution 2\n",
    "dt64.tolist()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style='color: red'>67.How to compute the moving average of a numpy array?</span>\n",
    "\n",
    "如何计算 NumPy 数组的移动平均数？\n",
    "\n",
    "Q. Compute the moving average of window size 3, for the given 1D array.\n",
    "\n",
    "给定 1 维数组，计算 window size 为 3 的移动平均数。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([8, 8, 3, 7, 7, 0, 4, 2, 5, 2])"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Input\n",
    "np.random.seed(100)\n",
    "Z = np.random.randint(10, size=10)\n",
    "Z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 6.33,  6.  ,  5.67,  4.67,  3.67,  2.  ,  3.67,  3.  ])"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Solution 1\n",
    "def moving_average(a, n=3):\n",
    "    ret = np.cumsum(a, dtype=float)\n",
    "    ret[n:] = ret[n:] - ret[:-n]\n",
    "    return ret[n-1:] / n\n",
    "\n",
    "moving_average(Z).round(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 6.33,  6.  ,  5.67,  4.67,  3.67,  2.  ,  3.67,  3.  ])"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Solution 2\n",
    "np.convolve(Z, np.ones(3)/3, mode='valid').round(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> `np.ones(3)/3` gives equal weights. Use `np.ones(4)/4` for window size 4."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">68.How to create a numpy array sequence given only the starting point, length and the step?</span>\n",
    "\n",
    "给定起始数字、length 和步长，如何创建一个 NumPy 数组序列？\n",
    "\n",
    "Q. Create a numpy array of length 10, starting from 5 and has a step of 3 between consecutive numbers.\n",
    "\n",
    "问题：从 5 开始，创建一个 length 为 10 的 NumPy 数组，相邻数字的差是 3。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 5,  8, 11, 14, 17, 20, 23, 26, 29, 32])"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(5, 5+3*10, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 5,  8, 11, 14, 17, 20, 23, 26, 29, 32])"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def seq(start, length, step):\n",
    "    end = start + length * step\n",
    "    return np.arange(start, end, step)\n",
    "\n",
    "seq(5, 10, 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">69.How to fill in missing dates in an irregular series of numpy dates?</span>\n",
    "\n",
    "如何在不规则 NumPy 日期序列中填充缺失日期？\n",
    "\n",
    "Q. Given an array of a non-continuous sequence of dates. Make it a continuous sequence of dates, by filling in the missing dates.\n",
    "\n",
    "问题：给定一个非连续日期序列的数组，通过填充缺失的日期，使其变成连续的日期序列。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['2018-02-01', '2018-02-03', '2018-02-05', '2018-02-07',\n",
       "       '2018-02-09', '2018-02-11', '2018-02-13', '2018-02-15',\n",
       "       '2018-02-17', '2018-02-19', '2018-02-21', '2018-02-23'], dtype='datetime64[D]')"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Input\n",
    "dates = np.arange(np.datetime64('2018-02-01'), np.datetime64('2018-02-25'), 2)\n",
    "dates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['2018-02-01', '2018-02-02', '2018-02-03', '2018-02-04',\n",
       "       '2018-02-05', '2018-02-06', '2018-02-07', '2018-02-08',\n",
       "       '2018-02-09', '2018-02-10', '2018-02-11', '2018-02-12',\n",
       "       '2018-02-13', '2018-02-14', '2018-02-15', '2018-02-16',\n",
       "       '2018-02-17', '2018-02-18', '2018-02-19', '2018-02-20',\n",
       "       '2018-02-21', '2018-02-22'], dtype='datetime64[D]')"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Solution\n",
    "filled_in = np.array([np.arange(date, (date+d))\n",
    "                      for date, d in zip(dates, np.diff(dates))]).reshape(-1)\n",
    "filled_in"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['2018-02-01', '2018-02-02', '2018-02-03', '2018-02-04',\n",
       "       '2018-02-05', '2018-02-06', '2018-02-07', '2018-02-08',\n",
       "       '2018-02-09', '2018-02-10', '2018-02-11', '2018-02-12',\n",
       "       '2018-02-13', '2018-02-14', '2018-02-15', '2018-02-16',\n",
       "       '2018-02-17', '2018-02-18', '2018-02-19', '2018-02-20',\n",
       "       '2018-02-21', '2018-02-22', '2018-02-23'], dtype='datetime64[D]')"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Solution: For loop version\n",
    "out = []\n",
    "for date, d in zip(dates, np.diff(dates)):\n",
    "    out.append(np.arange(date, date+d))\n",
    "    \n",
    "filled_in = np.array(out).reshape(-1)\n",
    "\n",
    "# add the last day\n",
    "output = np.hstack([filled_in, dates[-1]])\n",
    "output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<span style=\"color: red\">70.How to create strides from a given 1D array?</span>\n",
    "\n",
    "如何基于给定的 1 维数组创建 strides？\n",
    "\n",
    "Q. From the given 1d array **arr**, generate a 2d matrix using strides, with a window length of 4 and strides of 2, like [[0,1,2,3], [2,3,4,5], [4,5,6,7]..].\n",
    "\n",
    "问题：给定 1 维数组 arr，使用 strides 生成一个 2 维矩阵，其中 window length 等于 4，strides 等于 2，例如 [[0,1,2,3], [2,3,4,5], [4,5,6,7]..]。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14])"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Input\n",
    "arr = np.arange(15)\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3]\n",
      " [ 2  3  4  5]\n",
      " [ 4  5  6  7]\n",
      " [ 6  7  8  9]\n",
      " [ 8  9 10 11]\n",
      " [10 11 12 13]]\n"
     ]
    }
   ],
   "source": [
    "# Solution\n",
    "def gen_strides(arr, stride_len=5, window_len=5):\n",
    "    n_strides = ((arr.size-window_len)//stride_len) + 1\n",
    "    # return np.array([a[s:(s+window_len)]\n",
    "    # for s in np.arange(0, a.size, stride_len)[:n_strides]])\n",
    "    return np.array([arr[s:(s+window_len)] for s in np.arange(0, n_strides*stride_len, stride_len)])\n",
    "\n",
    "print(gen_strides(arr, stride_len=2, window_len=4))"
   ]
  }
 ],
 "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.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}