day2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'1.16.3'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.__version__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function fromfile in module numpy:\n",
      "\n",
      "fromfile(...)\n",
      "    fromfile(file, dtype=float, count=-1, sep='')\n",
      "    \n",
      "    Construct an array from data in a text or binary file.\n",
      "    \n",
      "    A highly efficient way of reading binary data with a known data-type,\n",
      "    as well as parsing simply formatted text files.  Data written using the\n",
      "    `tofile` method can be read using this function.\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    file : file or str\n",
      "        Open file object or filename.\n",
      "    dtype : data-type\n",
      "        Data type of the returned array.\n",
      "        For binary files, it is used to determine the size and byte-order\n",
      "        of the items in the file.\n",
      "    count : int\n",
      "        Number of items to read. ``-1`` means all items (i.e., the complete\n",
      "        file).\n",
      "    sep : str\n",
      "        Separator between items if file is a text file.\n",
      "        Empty (\"\") separator means the file should be treated as binary.\n",
      "        Spaces (\" \") in the separator match zero or more whitespace characters.\n",
      "        A separator consisting only of spaces must match at least one\n",
      "        whitespace.\n",
      "    \n",
      "    See also\n",
      "    --------\n",
      "    load, save\n",
      "    ndarray.tofile\n",
      "    loadtxt : More flexible way of loading data from a text file.\n",
      "    \n",
      "    Notes\n",
      "    -----\n",
      "    Do not rely on the combination of `tofile` and `fromfile` for\n",
      "    data storage, as the binary files generated are are not platform\n",
      "    independent.  In particular, no byte-order or data-type information is\n",
      "    saved.  Data can be stored in the platform independent ``.npy`` format\n",
      "    using `save` and `load` instead.\n",
      "    \n",
      "    Examples\n",
      "    --------\n",
      "    Construct an ndarray:\n",
      "    \n",
      "    >>> dt = np.dtype([('time', [('min', int), ('sec', int)]),\n",
      "    ...                ('temp', float)])\n",
      "    >>> x = np.zeros((1,), dtype=dt)\n",
      "    >>> x['time']['min'] = 10; x['temp'] = 98.25\n",
      "    >>> x\n",
      "    array([((10, 0), 98.25)],\n",
      "          dtype=[('time', [('min', '<i4'), ('sec', '<i4')]), ('temp', '<f8')])\n",
      "    \n",
      "    Save the raw data to disk:\n",
      "    \n",
      "    >>> import os\n",
      "    >>> fname = os.tmpnam()\n",
      "    >>> x.tofile(fname)\n",
      "    \n",
      "    Read the raw data from disk:\n",
      "    \n",
      "    >>> np.fromfile(fname, dtype=dt)\n",
      "    array([((10, 0), 98.25)],\n",
      "          dtype=[('time', [('min', '<i4'), ('sec', '<i4')]), ('temp', '<f8')])\n",
      "    \n",
      "    The recommended way to store and load data:\n",
      "    \n",
      "    >>> np.save(fname, x)\n",
      "    >>> np.load(fname + '.npy')\n",
      "    array([((10, 0), 98.25)],\n",
      "          dtype=[('time', [('min', '<i4'), ('sec', '<i4')]), ('temp', '<f8')])\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(np.fromfile)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function savetxt in module numpy:\n",
      "\n",
      "savetxt(fname, X, fmt='%.18e', delimiter=' ', newline='\\n', header='', footer='', comments='# ', encoding=None)\n",
      "    Save an array to a text file.\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    fname : filename or file handle\n",
      "        If the filename ends in ``.gz``, the file is automatically saved in\n",
      "        compressed gzip format.  `loadtxt` understands gzipped files\n",
      "        transparently.\n",
      "    X : 1D or 2D array_like\n",
      "        Data to be saved to a text file.\n",
      "    fmt : str or sequence of strs, optional\n",
      "        A single format (%10.5f), a sequence of formats, or a\n",
      "        multi-format string, e.g. 'Iteration %d -- %10.5f', in which\n",
      "        case `delimiter` is ignored. For complex `X`, the legal options\n",
      "        for `fmt` are:\n",
      "    \n",
      "        * a single specifier, `fmt='%.4e'`, resulting in numbers formatted\n",
      "          like `' (%s+%sj)' % (fmt, fmt)`\n",
      "        * a full string specifying every real and imaginary part, e.g.\n",
      "          `' %.4e %+.4ej %.4e %+.4ej %.4e %+.4ej'` for 3 columns\n",
      "        * a list of specifiers, one per column - in this case, the real\n",
      "          and imaginary part must have separate specifiers,\n",
      "          e.g. `['%.3e + %.3ej', '(%.15e%+.15ej)']` for 2 columns\n",
      "    delimiter : str, optional\n",
      "        String or character separating columns.\n",
      "    newline : str, optional\n",
      "        String or character separating lines.\n",
      "    \n",
      "        .. versionadded:: 1.5.0\n",
      "    header : str, optional\n",
      "        String that will be written at the beginning of the file.\n",
      "    \n",
      "        .. versionadded:: 1.7.0\n",
      "    footer : str, optional\n",
      "        String that will be written at the end of the file.\n",
      "    \n",
      "        .. versionadded:: 1.7.0\n",
      "    comments : str, optional\n",
      "        String that will be prepended to the ``header`` and ``footer`` strings,\n",
      "        to mark them as comments. Default: '# ',  as expected by e.g.\n",
      "        ``numpy.loadtxt``.\n",
      "    \n",
      "        .. versionadded:: 1.7.0\n",
      "    encoding : {None, str}, optional\n",
      "        Encoding used to encode the outputfile. Does not apply to output\n",
      "        streams. If the encoding is something other than 'bytes' or 'latin1'\n",
      "        you will not be able to load the file in NumPy versions < 1.14. Default\n",
      "        is 'latin1'.\n",
      "    \n",
      "        .. versionadded:: 1.14.0\n",
      "    \n",
      "    \n",
      "    See Also\n",
      "    --------\n",
      "    save : Save an array to a binary file in NumPy ``.npy`` format\n",
      "    savez : Save several arrays into an uncompressed ``.npz`` archive\n",
      "    savez_compressed : Save several arrays into a compressed ``.npz`` archive\n",
      "    \n",
      "    Notes\n",
      "    -----\n",
      "    Further explanation of the `fmt` parameter\n",
      "    (``%[flag]width[.precision]specifier``):\n",
      "    \n",
      "    flags:\n",
      "        ``-`` : left justify\n",
      "    \n",
      "        ``+`` : Forces to precede result with + or -.\n",
      "    \n",
      "        ``0`` : Left pad the number with zeros instead of space (see width).\n",
      "    \n",
      "    width:\n",
      "        Minimum number of characters to be printed. The value is not truncated\n",
      "        if it has more characters.\n",
      "    \n",
      "    precision:\n",
      "        - For integer specifiers (eg. ``d,i,o,x``), the minimum number of\n",
      "          digits.\n",
      "        - For ``e, E`` and ``f`` specifiers, the number of digits to print\n",
      "          after the decimal point.\n",
      "        - For ``g`` and ``G``, the maximum number of significant digits.\n",
      "        - For ``s``, the maximum number of characters.\n",
      "    \n",
      "    specifiers:\n",
      "        ``c`` : character\n",
      "    \n",
      "        ``d`` or ``i`` : signed decimal integer\n",
      "    \n",
      "        ``e`` or ``E`` : scientific notation with ``e`` or ``E``.\n",
      "    \n",
      "        ``f`` : decimal floating point\n",
      "    \n",
      "        ``g,G`` : use the shorter of ``e,E`` or ``f``\n",
      "    \n",
      "        ``o`` : signed octal\n",
      "    \n",
      "        ``s`` : string of characters\n",
      "    \n",
      "        ``u`` : unsigned decimal integer\n",
      "    \n",
      "        ``x,X`` : unsigned hexadecimal integer\n",
      "    \n",
      "    This explanation of ``fmt`` is not complete, for an exhaustive\n",
      "    specification see [1]_.\n",
      "    \n",
      "    References\n",
      "    ----------\n",
      "    .. [1] `Format Specification Mini-Language\n",
      "           <https://docs.python.org/library/string.html#format-specification-mini-language>`_,\n",
      "           Python Documentation.\n",
      "    \n",
      "    Examples\n",
      "    --------\n",
      "    >>> x = y = z = np.arange(0.0,5.0,1.0)\n",
      "    >>> np.savetxt('test.out', x, delimiter=',')   # X is an array\n",
      "    >>> np.savetxt('test.out', (x,y,z))   # x,y,z equal sized 1D arrays\n",
      "    >>> np.savetxt('test.out', x, fmt='%1.4e')   # use exponential notation\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(np.savetxt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset = np.random.randint(1, 100, 10000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([28, 84, 57, ..., 25, 65, 39])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.savetxt(\"sample1.txt\", dataset, fmt=\"%d\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset = np.fromfile(\"sample1.txt\", sep=\"\\n\", dtype=np.int64)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([28, 84, 57, ..., 25, 65, 39], dtype=int64)"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.3980432862761015e-76"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2.96780801e-260"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10000"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset.size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "28"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "97"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset[100]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([28, 84, 57, 52, 66,  4, 94, 19, 47, 54, 32, 16, 46, 80, 19, 22, 47,\n",
       "       26,  9,  8, 40, 28, 76, 16, 76, 95, 87, 46, 15, 77,  2, 94, 69, 81,\n",
       "       59, 14, 50, 54, 47, 39, 10, 40, 38, 69, 83, 93, 87, 96, 14, 56,  5,\n",
       "       22, 66, 30, 85, 75, 70, 81, 42, 54, 53, 64, 80, 42,  2, 86, 29, 57,\n",
       "       55, 16, 73, 96, 81, 17, 24, 12, 85, 78, 15, 98, 22, 37, 14, 23, 47,\n",
       "       68, 22, 93, 76, 41, 58, 30, 68, 37, 96, 63, 97, 85, 82, 76],\n",
       "      dtype=int64)"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset[0:100]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'s is '"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"this is test\"[3:8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'test'"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"this is test\"[-4:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'s t'"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"this is test\"[-6:-3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'s t'"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"this is test\"[12-6:12-3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'s t'"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"this is test\"[-6:-3:1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'i sts'"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"this is test\"[2::2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'tset si siht'"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"this is test\"[::-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'te ish'"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"this is test\"[::-2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([42, 72, 28, 11, 38, 99, 88, 38, 20, 14, 57, 40, 20, 77, 54,  3, 17,\n",
       "       17, 24, 88, 15, 87, 17, 67, 47, 81,  3, 48, 87, 27,  2, 98, 72, 33,\n",
       "       57, 49, 63, 65, 86,  2, 32, 62, 61, 67, 72, 15, 31, 82, 81, 10, 54,\n",
       "       94, 93, 52, 35, 64, 26, 28, 58, 41, 31,  2, 97, 69, 33,  1, 70, 38,\n",
       "       67, 38, 32, 83,  2, 84, 89, 88, 75, 73, 92, 86, 10, 11, 55, 21, 59,\n",
       "       89,  8, 88, 73, 90, 37, 74, 51, 51, 62, 45, 72, 25, 65, 39],\n",
       "      dtype=int64)"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset[-100:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([42, 72, 28, 11, 38, 99, 88, 38, 20, 14, 57, 40, 20, 77, 54,  3, 17,\n",
       "       17, 24, 88, 15, 87, 17, 67, 47, 81,  3, 48, 87, 27,  2, 98, 72, 33,\n",
       "       57, 49, 63, 65, 86,  2, 32, 62, 61, 67, 72, 15, 31, 82, 81, 10, 54,\n",
       "       94, 93, 52, 35, 64, 26, 28, 58, 41, 31,  2, 97, 69, 33,  1, 70, 38,\n",
       "       67, 38, 32, 83,  2, 84, 89, 88, 75, 73, 92, 86, 10, 11, 55, 21, 59,\n",
       "       89,  8, 88, 73, 90, 37, 74, 51, 51, 62, 45, 72, 25, 65, 39],\n",
       "      dtype=int64)"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset[dataset.size - 100:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False, False, ..., False, False, False])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset < 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "boolean index did not match indexed array along dimension 0; dimension is 10000 but corresponding boolean dimension is 100",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-54-a78d2da62c53>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mdataset\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mdataset\u001b[0m \u001b[1;33m<\u001b[0m \u001b[1;36m10\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;36m100\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m: boolean index did not match indexed array along dimension 0; dimension is 10000 but corresponding boolean dimension is 100"
     ]
    }
   ],
   "source": [
    "dataset[(dataset < 10)[:100]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 9, 8, 2, 5, 2, 9, 5, 1, 4, 9, 5, 1, 4, 6, 9, 4, 7, 5, 7, 4, 3,\n",
       "       6, 4, 4, 7, 6, 8, 7, 1, 4, 8, 6, 9, 2, 1, 4, 7, 7, 7, 6, 3, 4, 1,\n",
       "       2, 7, 5, 8, 5, 3, 5, 1, 9, 5, 4, 7, 8, 5, 9, 4, 7, 4, 6, 9, 8, 7,\n",
       "       5, 3, 4, 1, 1, 3, 6, 1, 1, 8, 9, 4, 7, 4, 1, 9, 5, 1, 2, 1, 9, 9,\n",
       "       7, 9, 5, 8, 3, 5, 7, 4, 9, 5, 7, 1, 8, 1, 4, 8, 3, 4, 7, 2, 4, 1,\n",
       "       2, 1, 1, 3, 5, 4, 4, 7, 4, 5, 7, 9, 1, 4, 7, 9, 5, 2, 9, 6, 9, 5,\n",
       "       2, 1, 6, 9, 3, 5, 8, 6, 3, 2, 7, 3, 2, 3, 9, 1, 7, 6, 8, 2, 5, 9,\n",
       "       8, 3, 6, 7, 1, 4, 4, 4, 8, 7, 9, 7, 3, 1, 7, 1, 4, 7, 1, 1, 3, 9,\n",
       "       7, 3, 4, 9, 8, 7, 9, 1, 8, 6, 6, 6, 6, 5, 4, 1, 9, 2, 6, 5, 9, 8,\n",
       "       1, 3, 9, 1, 6, 9, 7, 7, 3, 1, 7, 4, 2, 6, 3, 7, 1, 1, 9, 9, 4, 1,\n",
       "       2, 1, 5, 9, 6, 5, 8, 9, 5, 8, 4, 5, 5, 9, 3, 4, 2, 4, 4, 5, 9, 3,\n",
       "       7, 9, 1, 7, 4, 8, 8, 3, 3, 8, 9, 3, 8, 3, 2, 1, 9, 7, 5, 7, 2, 1,\n",
       "       4, 9, 8, 5, 2, 1, 9, 3, 6, 6, 7, 2, 9, 3, 1, 4, 9, 5, 7, 5, 6, 6,\n",
       "       6, 6, 7, 7, 2, 6, 6, 4, 3, 5, 3, 7, 2, 1, 4, 8, 9, 5, 9, 1, 4, 5,\n",
       "       7, 3, 4, 1, 4, 2, 3, 7, 1, 8, 9, 9, 9, 3, 4, 7, 3, 8, 3, 6, 5, 2,\n",
       "       1, 6, 9, 2, 1, 6, 2, 3, 5, 3, 6, 9, 6, 9, 9, 7, 1, 1, 8, 5, 5, 9,\n",
       "       1, 6, 1, 4, 4, 2, 9, 4, 7, 8, 8, 9, 8, 8, 8, 6, 6, 8, 6, 2, 6, 6,\n",
       "       9, 3, 2, 9, 5, 2, 5, 9, 5, 3, 3, 5, 8, 4, 3, 3, 8, 4, 1, 3, 4, 4,\n",
       "       7, 1, 4, 2, 7, 9, 7, 5, 6, 4, 2, 5, 2, 9, 4, 2, 1, 7, 1, 5, 7, 1,\n",
       "       2, 6, 8, 5, 8, 5, 4, 3, 5, 4, 7, 4, 5, 1, 3, 6, 2, 3, 2, 4, 2, 5,\n",
       "       1, 9, 8, 6, 5, 7, 5, 9, 6, 8, 6, 2, 8, 1, 8, 5, 4, 2, 9, 8, 1, 3,\n",
       "       6, 2, 6, 6, 2, 1, 6, 2, 3, 2, 8, 4, 8, 1, 3, 2, 6, 1, 4, 6, 1, 7,\n",
       "       8, 1, 5, 3, 2, 2, 8, 7, 6, 2, 6, 5, 5, 5, 4, 7, 8, 6, 3, 6, 1, 7,\n",
       "       8, 1, 2, 8, 6, 8, 9, 6, 5, 9, 3, 4, 6, 7, 5, 5, 3, 1, 4, 6, 5, 8,\n",
       "       4, 6, 9, 6, 1, 8, 7, 7, 9, 4, 7, 7, 5, 2, 1, 5, 5, 2, 4, 3, 9, 4,\n",
       "       5, 1, 2, 2, 4, 9, 3, 3, 7, 2, 8, 5, 7, 5, 5, 3, 1, 9, 6, 6, 9, 1,\n",
       "       5, 4, 4, 5, 5, 3, 3, 2, 8, 9, 4, 1, 4, 7, 1, 8, 2, 7, 5, 1, 5, 1,\n",
       "       7, 2, 3, 3, 4, 5, 6, 6, 1, 2, 2, 3, 9, 8, 3, 3, 6, 4, 6, 2, 8, 8,\n",
       "       9, 4, 3, 6, 9, 9, 5, 3, 1, 2, 1, 5, 2, 2, 1, 1, 7, 2, 7, 9, 5, 1,\n",
       "       6, 6, 5, 7, 5, 6, 8, 9, 4, 8, 1, 4, 2, 2, 7, 2, 6, 6, 2, 1, 3, 2,\n",
       "       8, 5, 1, 3, 6, 1, 2, 5, 2, 3, 1, 5, 3, 8, 1, 3, 9, 3, 4, 6, 2, 2,\n",
       "       4, 9, 1, 9, 8, 4, 5, 2, 7, 5, 1, 7, 7, 2, 5, 8, 8, 4, 6, 5, 7, 1,\n",
       "       1, 3, 6, 4, 6, 1, 4, 4, 7, 8, 2, 2, 6, 3, 1, 2, 9, 5, 4, 9, 1, 2,\n",
       "       7, 2, 2, 6, 9, 2, 7, 2, 8, 2, 1, 5, 5, 2, 1, 2, 6, 7, 1, 7, 2, 9,\n",
       "       2, 3, 7, 5, 7, 9, 8, 7, 5, 1, 1, 5, 4, 8, 9, 1, 3, 5, 3, 6, 5, 8,\n",
       "       9, 5, 1, 1, 6, 1, 7, 5, 3, 7, 1, 9, 1, 4, 8, 7, 7, 4, 3, 5, 8, 1,\n",
       "       5, 7, 3, 6, 7, 9, 5, 4, 5, 3, 1, 8, 2, 5, 2, 4, 4, 5, 9, 1, 5, 8,\n",
       "       1, 4, 7, 5, 7, 2, 6, 1, 9, 6, 5, 8, 9, 4, 6, 4, 7, 8, 4, 9, 2, 4,\n",
       "       4, 7, 8, 2, 7, 1, 9, 8, 1, 2, 6, 1, 3, 1, 3, 7, 6, 3, 1, 9, 6, 8,\n",
       "       2, 7, 5, 6, 1, 5, 2, 7, 8, 1, 7, 4, 9, 9, 3, 9, 9, 3, 5, 9, 3, 9,\n",
       "       8, 7, 5, 8, 2, 3, 8, 7, 8, 3, 5, 3, 1, 5, 7, 4, 2, 3, 8, 4, 3, 9,\n",
       "       8, 8, 8, 6, 6, 8, 1, 4, 6, 9, 5, 3, 3, 2, 2, 2, 1, 2, 8],\n",
       "      dtype=int64)"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset[dataset < 10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-56-76ed28e3c66d>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mdataset\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mdataset\u001b[0m \u001b[1;33m<\u001b[0m \u001b[1;36m3\u001b[0m \u001b[1;33m&\u001b[0m \u001b[0mdataset\u001b[0m \u001b[1;33m>\u001b[0m \u001b[1;36m97\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()"
     ]
    }
   ],
   "source": [
    "dataset[dataset < 3 & dataset > 97]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([], dtype=int64)"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset[(dataset < 3) & (dataset > 97)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2,  2, 98,  1, 98,  1, 99, 99, 99,  1,  2,  1, 99,  1, 98,  2, 98,\n",
       "        1, 99, 99, 98,  1, 99,  1,  1,  1,  1, 98,  1,  2, 99,  1, 99, 98,\n",
       "       98, 98,  1,  1, 99,  2, 99,  1,  2,  1,  1, 99, 98, 99, 98, 99, 99,\n",
       "        1, 99, 99,  2, 98,  2, 99,  1, 98, 99,  2, 98,  2, 99,  1,  2, 98,\n",
       "        1, 98,  1,  1,  1,  1, 99, 99, 98, 98,  1,  1, 99, 99,  2,  1,  1,\n",
       "       98, 98, 98,  1, 98, 98, 98, 99, 98,  2,  1, 98,  1,  1,  2, 99, 98,\n",
       "        1, 98, 98, 98,  2,  1, 98,  2, 98,  1,  2,  1, 99,  2, 99, 98,  1,\n",
       "       99, 99,  2,  1, 98, 98,  2,  2,  1, 99,  1, 98, 99,  1, 99,  2,  1,\n",
       "       98, 99,  2,  1, 99,  2,  1, 99, 98,  2, 98, 99,  1,  1, 98, 98,  1,\n",
       "        1, 98, 98,  2, 99, 99, 99, 99, 98,  2,  2, 98,  2, 98,  1, 98, 99,\n",
       "        1,  2, 99,  2,  2,  2,  1,  1, 98,  1,  2, 98, 99, 99, 98,  1,  2,\n",
       "        2,  2, 99,  1, 99, 99, 98, 98, 99, 98, 98, 99,  2, 99,  1,  2, 98,\n",
       "       99, 99,  1, 98, 99, 99,  2,  2,  1,  2, 99,  2, 99,  1,  2, 99,  1,\n",
       "        1,  1,  2,  2, 99,  2, 98, 98,  1, 99,  1,  2, 98, 99, 98, 99,  1,\n",
       "       99, 98,  1, 98, 98,  2,  1, 98, 99,  2,  1,  2,  2,  2, 99, 99,  1,\n",
       "       98,  1, 99, 99,  2, 99, 99,  1, 99, 99,  1, 98,  2,  1,  1,  2, 99,\n",
       "       98, 99,  1,  2, 99,  2, 99, 98, 99, 99,  2, 98,  1,  2,  1,  2,  2,\n",
       "        1,  1,  2,  1, 98, 99, 99,  1, 99,  2,  2,  2, 98,  2,  1,  2, 99,\n",
       "       99,  1,  1, 98,  2,  2,  1,  1,  2,  2,  1, 99,  2,  1, 98, 98, 98,\n",
       "        2, 98, 99,  1, 98,  1, 98, 99, 98,  1,  2,  2, 99,  1,  2, 99, 98,\n",
       "        1,  2, 98,  2,  2,  2,  2, 99,  2,  1, 99,  2,  1,  2,  1,  2,  2,\n",
       "        1,  1,  1, 98, 99, 99,  1,  1, 98,  1,  1,  1, 99, 99, 98,  1, 99,\n",
       "        1,  2,  2, 98, 98, 98,  1, 99,  1, 99, 98,  2,  1, 99,  2, 98, 99,\n",
       "        2,  1,  1,  2,  1, 99, 98, 99,  1, 99,  1, 98,  2, 99,  1, 98,  2,\n",
       "       99, 98,  1, 98, 99, 98, 99,  2, 99, 98, 98, 98, 98, 99,  1,  2, 98,\n",
       "        1, 99, 99,  2, 98,  2,  2,  1,  2], dtype=int64)"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dataset[(dataset < 3) | (dataset > 97)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True and False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True or False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "dset1 = dataset[dataset < 3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "223"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dset1.size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 2, 1, 1, 1, 2, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 2, 1,\n",
       "       2, 1, 1, 1, 2, 2, 1, 2, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1,\n",
       "       2, 1, 1, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 2, 1, 1, 1, 2,\n",
       "       1, 2, 1, 2, 1, 2, 1, 1, 1, 1, 2, 2, 2, 2, 1, 1, 2, 2, 2, 2, 1, 1,\n",
       "       1, 2, 1, 2, 2, 2, 1, 2, 1, 2, 1, 2, 2, 1, 2, 2, 1, 2, 1, 1, 1, 2,\n",
       "       2, 2, 1, 1, 2, 1, 1, 2, 1, 2, 1, 2, 2, 2, 1, 1, 2, 1, 1, 2, 1, 1,\n",
       "       2, 1, 2, 2, 2, 1, 2, 1, 2, 2, 1, 1, 2, 1, 1, 2, 2, 2, 2, 1, 2, 1,\n",
       "       1, 2, 2, 1, 1, 2, 2, 1, 2, 1, 2, 1, 1, 1, 2, 2, 1, 2, 1, 2, 2, 2,\n",
       "       2, 2, 2, 1, 2, 1, 2, 1, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2,\n",
       "       1, 1, 2, 1, 2, 2, 1, 1, 2, 1, 1, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 2,\n",
       "       2, 1, 2], dtype=int64)"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dset1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function any in module numpy:\n",
      "\n",
      "any(a, axis=None, out=None, keepdims=<no value>)\n",
      "    Test whether any array element along a given axis evaluates to True.\n",
      "    \n",
      "    Returns single boolean unless `axis` is not ``None``\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    a : array_like\n",
      "        Input array or object that can be converted to an array.\n",
      "    axis : None or int or tuple of ints, optional\n",
      "        Axis or axes along which a logical OR reduction is performed.\n",
      "        The default (`axis` = `None`) is to perform a logical OR over all\n",
      "        the dimensions of the input array. `axis` may be negative, in\n",
      "        which case it counts from the last to the first axis.\n",
      "    \n",
      "        .. versionadded:: 1.7.0\n",
      "    \n",
      "        If this is a tuple of ints, a reduction is performed on multiple\n",
      "        axes, instead of a single axis or all the axes as before.\n",
      "    out : ndarray, optional\n",
      "        Alternate output array in which to place the result.  It must have\n",
      "        the same shape as the expected output and its type is preserved\n",
      "        (e.g., if it is of type float, then it will remain so, returning\n",
      "        1.0 for True and 0.0 for False, regardless of the type of `a`).\n",
      "        See `doc.ufuncs` (Section \"Output arguments\") for details.\n",
      "    \n",
      "    keepdims : bool, optional\n",
      "        If this is set to True, the axes which are reduced are left\n",
      "        in the result as dimensions with size one. With this option,\n",
      "        the result will broadcast correctly against the input array.\n",
      "    \n",
      "        If the default value is passed, then `keepdims` will not be\n",
      "        passed through to the `any` method of sub-classes of\n",
      "        `ndarray`, however any non-default value will be.  If the\n",
      "        sub-class' method does not implement `keepdims` any\n",
      "        exceptions will be raised.\n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    any : bool or ndarray\n",
      "        A new boolean or `ndarray` is returned unless `out` is specified,\n",
      "        in which case a reference to `out` is returned.\n",
      "    \n",
      "    See Also\n",
      "    --------\n",
      "    ndarray.any : equivalent method\n",
      "    \n",
      "    all : Test whether all elements along a given axis evaluate to True.\n",
      "    \n",
      "    Notes\n",
      "    -----\n",
      "    Not a Number (NaN), positive infinity and negative infinity evaluate\n",
      "    to `True` because these are not equal to zero.\n",
      "    \n",
      "    Examples\n",
      "    --------\n",
      "    >>> np.any([[True, False], [True, True]])\n",
      "    True\n",
      "    \n",
      "    >>> np.any([[True, False], [False, False]], axis=0)\n",
      "    array([ True, False])\n",
      "    \n",
      "    >>> np.any([-1, 0, 5])\n",
      "    True\n",
      "    \n",
      "    >>> np.any(np.nan)\n",
      "    True\n",
      "    \n",
      "    >>> o=np.array([False])\n",
      "    >>> z=np.any([-1, 4, 5], out=o)\n",
      "    >>> z, o\n",
      "    (array([ True]), array([ True]))\n",
      "    >>> # Check now that z is a reference to o\n",
      "    >>> z is o\n",
      "    True\n",
      "    >>> id(z), id(o) # identity of z and o              # doctest: +SKIP\n",
      "    (191614240, 191614240)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(np.any)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.any(dset1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.all(dset1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False,  True,  True,  True, False,  True,  True, False,\n",
       "        True,  True,  True,  True,  True,  True,  True, False,  True,\n",
       "        True,  True, False,  True, False,  True,  True,  True, False,\n",
       "       False,  True, False, False,  True, False,  True,  True,  True,\n",
       "        True,  True,  True,  True, False,  True,  True,  True, False,\n",
       "        True,  True,  True, False,  True, False,  True, False,  True,\n",
       "       False,  True, False,  True, False,  True, False, False,  True,\n",
       "        True,  True, False,  True, False,  True, False,  True, False,\n",
       "        True,  True,  True,  True, False, False, False, False,  True,\n",
       "        True, False, False, False, False,  True,  True,  True, False,\n",
       "        True, False, False, False,  True, False,  True, False,  True,\n",
       "       False, False,  True, False, False,  True, False,  True,  True,\n",
       "        True, False, False, False,  True,  True, False,  True,  True,\n",
       "       False,  True, False,  True, False, False, False,  True,  True,\n",
       "       False,  True,  True, False,  True,  True, False,  True, False,\n",
       "       False, False,  True, False,  True, False, False,  True,  True,\n",
       "       False,  True,  True, False, False, False, False,  True, False,\n",
       "        True,  True, False, False,  True,  True, False, False,  True,\n",
       "       False,  True, False,  True,  True,  True, False, False,  True,\n",
       "       False,  True, False, False, False, False, False, False,  True,\n",
       "       False,  True, False,  True, False, False,  True,  True,  True,\n",
       "        True,  True,  True,  True,  True,  True,  True, False, False,\n",
       "        True,  True, False,  True, False, False,  True,  True, False,\n",
       "        True,  True,  True, False,  True, False,  True, False,  True,\n",
       "       False,  True, False, False, False,  True, False])"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dset1 < 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.any(dset1 < 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.all(dset1 < 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function where in module numpy:\n",
      "\n",
      "where(...)\n",
      "    where(condition, [x, y])\n",
      "    \n",
      "    Return elements chosen from `x` or `y` depending on `condition`.\n",
      "    \n",
      "    .. note::\n",
      "        When only `condition` is provided, this function is a shorthand for\n",
      "        ``np.asarray(condition).nonzero()``. Using `nonzero` directly should be\n",
      "        preferred, as it behaves correctly for subclasses. The rest of this\n",
      "        documentation covers only the case where all three arguments are\n",
      "        provided.\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    condition : array_like, bool\n",
      "        Where True, yield `x`, otherwise yield `y`.\n",
      "    x, y : array_like\n",
      "        Values from which to choose. `x`, `y` and `condition` need to be\n",
      "        broadcastable to some shape.\n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    out : ndarray\n",
      "        An array with elements from `x` where `condition` is True, and elements\n",
      "        from `y` elsewhere.\n",
      "    \n",
      "    See Also\n",
      "    --------\n",
      "    choose\n",
      "    nonzero : The function that is called when x and y are omitted\n",
      "    \n",
      "    Notes\n",
      "    -----\n",
      "    If all the arrays are 1-D, `where` is equivalent to::\n",
      "    \n",
      "        [xv if c else yv\n",
      "         for c, xv, yv in zip(condition, x, y)]\n",
      "    \n",
      "    Examples\n",
      "    --------\n",
      "    >>> a = np.arange(10)\n",
      "    >>> a\n",
      "    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])\n",
      "    >>> np.where(a < 5, a, 10*a)\n",
      "    array([ 0,  1,  2,  3,  4, 50, 60, 70, 80, 90])\n",
      "    \n",
      "    This can be used on multidimensional arrays too:\n",
      "    \n",
      "    >>> np.where([[True, False], [True, True]],\n",
      "    ...          [[1, 2], [3, 4]],\n",
      "    ...          [[9, 8], [7, 6]])\n",
      "    array([[1, 8],\n",
      "           [3, 4]])\n",
      "    \n",
      "    The shapes of x, y, and the condition are broadcast together:\n",
      "    \n",
      "    >>> x, y = np.ogrid[:3, :4]\n",
      "    >>> np.where(x < y, x, 10 + y)  # both x and 10+y are broadcast\n",
      "    array([[10,  0,  0,  0],\n",
      "           [10, 11,  1,  1],\n",
      "           [10, 11, 12,  2]])\n",
      "    \n",
      "    >>> a = np.array([[0, 1, 2],\n",
      "    ...               [0, 2, 4],\n",
      "    ...               [0, 3, 6]])\n",
      "    >>> np.where(a < 4, a, -1)  # -1 is broadcast\n",
      "    array([[ 0,  1,  2],\n",
      "           [ 0,  2, -1],\n",
      "           [ 0,  3, -1]])\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(np.where)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['Two', 'Two', 'One', 'One', 'One', 'Two', 'One', 'One', 'Two',\n",
       "       'One', 'One', 'One', 'One', 'One', 'One', 'One', 'Two', 'One',\n",
       "       'One', 'One', 'Two', 'One', 'Two', 'One', 'One', 'One', 'Two',\n",
       "       'Two', 'One', 'Two', 'Two', 'One', 'Two', 'One', 'One', 'One',\n",
       "       'One', 'One', 'One', 'One', 'Two', 'One', 'One', 'One', 'Two',\n",
       "       'One', 'One', 'One', 'Two', 'One', 'Two', 'One', 'Two', 'One',\n",
       "       'Two', 'One', 'Two', 'One', 'Two', 'One', 'Two', 'Two', 'One',\n",
       "       'One', 'One', 'Two', 'One', 'Two', 'One', 'Two', 'One', 'Two',\n",
       "       'One', 'One', 'One', 'One', 'Two', 'Two', 'Two', 'Two', 'One',\n",
       "       'One', 'Two', 'Two', 'Two', 'Two', 'One', 'One', 'One', 'Two',\n",
       "       'One', 'Two', 'Two', 'Two', 'One', 'Two', 'One', 'Two', 'One',\n",
       "       'Two', 'Two', 'One', 'Two', 'Two', 'One', 'Two', 'One', 'One',\n",
       "       'One', 'Two', 'Two', 'Two', 'One', 'One', 'Two', 'One', 'One',\n",
       "       'Two', 'One', 'Two', 'One', 'Two', 'Two', 'Two', 'One', 'One',\n",
       "       'Two', 'One', 'One', 'Two', 'One', 'One', 'Two', 'One', 'Two',\n",
       "       'Two', 'Two', 'One', 'Two', 'One', 'Two', 'Two', 'One', 'One',\n",
       "       'Two', 'One', 'One', 'Two', 'Two', 'Two', 'Two', 'One', 'Two',\n",
       "       'One', 'One', 'Two', 'Two', 'One', 'One', 'Two', 'Two', 'One',\n",
       "       'Two', 'One', 'Two', 'One', 'One', 'One', 'Two', 'Two', 'One',\n",
       "       'Two', 'One', 'Two', 'Two', 'Two', 'Two', 'Two', 'Two', 'One',\n",
       "       'Two', 'One', 'Two', 'One', 'Two', 'Two', 'One', 'One', 'One',\n",
       "       'One', 'One', 'One', 'One', 'One', 'One', 'One', 'Two', 'Two',\n",
       "       'One', 'One', 'Two', 'One', 'Two', 'Two', 'One', 'One', 'Two',\n",
       "       'One', 'One', 'One', 'Two', 'One', 'Two', 'One', 'Two', 'One',\n",
       "       'Two', 'One', 'Two', 'Two', 'Two', 'One', 'Two'], dtype='<U3')"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.where(dset1 < 2, \"One\", \"Two\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([  2,   3,   4,   6,   7,   9,  10,  11,  12,  13,  14,  15,  17,\n",
       "         18,  19,  21,  23,  24,  25,  28,  31,  33,  34,  35,  36,  37,\n",
       "         38,  39,  41,  42,  43,  45,  46,  47,  49,  51,  53,  55,  57,\n",
       "         59,  62,  63,  64,  66,  68,  70,  72,  73,  74,  75,  80,  81,\n",
       "         86,  87,  88,  90,  94,  96,  98, 101, 104, 106, 107, 108, 112,\n",
       "        113, 115, 116, 118, 120, 124, 125, 127, 128, 130, 131, 133, 137,\n",
       "        139, 142, 143, 145, 146, 151, 153, 154, 157, 158, 161, 163, 165,\n",
       "        166, 167, 170, 172, 179, 181, 183, 186, 187, 188, 189, 190, 191,\n",
       "        192, 193, 194, 195, 198, 199, 201, 204, 205, 207, 208, 209, 211,\n",
       "        213, 215, 217, 221], dtype=int64),)"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.where(dset1 < 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function apply_along_axis in module numpy:\n",
      "\n",
      "apply_along_axis(func1d, axis, arr, *args, **kwargs)\n",
      "    Apply a function to 1-D slices along the given axis.\n",
      "    \n",
      "    Execute `func1d(a, *args)` where `func1d` operates on 1-D arrays and `a`\n",
      "    is a 1-D slice of `arr` along `axis`.\n",
      "    \n",
      "    This is equivalent to (but faster than) the following use of `ndindex` and\n",
      "    `s_`, which sets each of ``ii``, ``jj``, and ``kk`` to a tuple of indices::\n",
      "    \n",
      "        Ni, Nk = a.shape[:axis], a.shape[axis+1:]\n",
      "        for ii in ndindex(Ni):\n",
      "            for kk in ndindex(Nk):\n",
      "                f = func1d(arr[ii + s_[:,] + kk])\n",
      "                Nj = f.shape\n",
      "                for jj in ndindex(Nj):\n",
      "                    out[ii + jj + kk] = f[jj]\n",
      "    \n",
      "    Equivalently, eliminating the inner loop, this can be expressed as::\n",
      "    \n",
      "        Ni, Nk = a.shape[:axis], a.shape[axis+1:]\n",
      "        for ii in ndindex(Ni):\n",
      "            for kk in ndindex(Nk):\n",
      "                out[ii + s_[...,] + kk] = func1d(arr[ii + s_[:,] + kk])\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    func1d : function (M,) -> (Nj...)\n",
      "        This function should accept 1-D arrays. It is applied to 1-D\n",
      "        slices of `arr` along the specified axis.\n",
      "    axis : integer\n",
      "        Axis along which `arr` is sliced.\n",
      "    arr : ndarray (Ni..., M, Nk...)\n",
      "        Input array.\n",
      "    args : any\n",
      "        Additional arguments to `func1d`.\n",
      "    kwargs : any\n",
      "        Additional named arguments to `func1d`.\n",
      "    \n",
      "        .. versionadded:: 1.9.0\n",
      "    \n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    out : ndarray  (Ni..., Nj..., Nk...)\n",
      "        The output array. The shape of `out` is identical to the shape of\n",
      "        `arr`, except along the `axis` dimension. This axis is removed, and\n",
      "        replaced with new dimensions equal to the shape of the return value\n",
      "        of `func1d`. So if `func1d` returns a scalar `out` will have one\n",
      "        fewer dimensions than `arr`.\n",
      "    \n",
      "    See Also\n",
      "    --------\n",
      "    apply_over_axes : Apply a function repeatedly over multiple axes.\n",
      "    \n",
      "    Examples\n",
      "    --------\n",
      "    >>> def my_func(a):\n",
      "    ...     \"\"\"Average first and last element of a 1-D array\"\"\"\n",
      "    ...     return (a[0] + a[-1]) * 0.5\n",
      "    >>> b = np.array([[1,2,3], [4,5,6], [7,8,9]])\n",
      "    >>> np.apply_along_axis(my_func, 0, b)\n",
      "    array([ 4.,  5.,  6.])\n",
      "    >>> np.apply_along_axis(my_func, 1, b)\n",
      "    array([ 2.,  5.,  8.])\n",
      "    \n",
      "    For a function that returns a 1D array, the number of dimensions in\n",
      "    `outarr` is the same as `arr`.\n",
      "    \n",
      "    >>> b = np.array([[8,1,7], [4,3,9], [5,2,6]])\n",
      "    >>> np.apply_along_axis(sorted, 1, b)\n",
      "    array([[1, 7, 8],\n",
      "           [3, 4, 9],\n",
      "           [2, 5, 6]])\n",
      "    \n",
      "    For a function that returns a higher dimensional array, those dimensions\n",
      "    are inserted in place of the `axis` dimension.\n",
      "    \n",
      "    >>> b = np.array([[1,2,3], [4,5,6], [7,8,9]])\n",
      "    >>> np.apply_along_axis(np.diag, -1, b)\n",
      "    array([[[1, 0, 0],\n",
      "            [0, 2, 0],\n",
      "            [0, 0, 3]],\n",
      "           [[4, 0, 0],\n",
      "            [0, 5, 0],\n",
      "            [0, 0, 6]],\n",
      "           [[7, 0, 0],\n",
      "            [0, 8, 0],\n",
      "            [0, 0, 9]]])\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(np.apply_along_axis)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mapp_nums(val):\n",
    "    # print(val)\n",
    "    if val == 1: return \"One\"\n",
    "    elif val == 2: return \"Two\"\n",
    "    elif val == 3: return \"Three\"\n",
    "    else: return \"Other\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "dset2 = dataset[dataset < 5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 2, 2, 1, 4, 1, 4, 4, 4, 3], dtype=int64)"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dset2[:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "https://docs.scipy.org/doc/numpy/reference/ufuncs.html"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4 2 2 1 4 1 4 4 4 3 4 4 1 4 2 1 4 3 4 1 2 3 1 4 4 4 3 4 1 1 3 1 1 4 4 1 1\n",
      " 2 1 3 4 1 1 4 3 4 2 4 1 2 1 1 3 4 4 4 1 4 2 2 1 3 3 2 3 2 3 1 2 3 1 4 4 4\n",
      " 3 1 1 4 1 1 3 3 4 1 4 1 2 1 3 1 3 1 4 2 3 1 1 4 1 2 1 4 3 4 2 4 4 3 1 4 3\n",
      " 3 3 3 2 1 2 1 4 2 1 3 2 3 1 4 2 4 3 3 2 1 4 1 4 3 4 1 4 2 3 1 3 4 3 3 2 1\n",
      " 2 1 2 3 3 1 1 1 1 4 4 2 4 2 3 2 2 3 3 4 3 3 4 1 3 4 4 1 4 2 4 2 2 4 2 1 1\n",
      " 1 2 4 3 4 4 1 3 2 3 2 4 2 1 2 1 4 2 1 3 2 2 1 2 3 2 4 1 3 2 1 4 1 1 3 2 2\n",
      " 2 4 3 1 1 2 3 4 3 1 4 4 1 4 2 1 2 4 3 4 1 2 2 4 3 3 2 3 1 1 4 4 3 3 2 4 1\n",
      " 4 1 2 1 1 2 3 3 4 1 2 2 3 3 3 4 2 4 3 3 1 2 1 2 2 1 1 2 1 4 1 4 2 2 2 2 1\n",
      " 3 2 1 3 1 2 2 3 1 3 1 3 3 4 2 2 4 1 4 2 1 2 4 1 1 3 4 1 4 4 2 2 3 1 2 4 1\n",
      " 2 2 2 2 2 2 1 2 1 2 1 2 2 3 1 1 4 1 3 3 1 1 1 3 1 1 4 4 3 1 3 4 3 1 2 2 4\n",
      " 4 1 1 4 2 1 4 4 4 2 4 4 2 1 1 2 1 3 1 3 3 1 2 1 2 1 4 3 3 3 2 3 3 3 1 4 2\n",
      " 3 4 3 1 4 3 3 2 2 2 1 2]\n"
     ]
    },
    {
     "ename": "ValueError",
     "evalue": "The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-87-baa109bfa9ce>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mapply_along_axis\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmapp_nums\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m0\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mdset2\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32mC:\\Anaconda3\\lib\\site-packages\\numpy\\lib\\shape_base.py\u001b[0m in \u001b[0;36mapply_along_axis\u001b[1;34m(func1d, axis, arr, *args, **kwargs)\u001b[0m\n\u001b[0;32m    378\u001b[0m     \u001b[1;32mexcept\u001b[0m \u001b[0mStopIteration\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    379\u001b[0m         \u001b[1;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'Cannot apply_along_axis when any iteration dimensions are 0'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 380\u001b[1;33m     \u001b[0mres\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0masanyarray\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfunc1d\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0minarr_view\u001b[0m\u001b[1;33m[\u001b[0m\u001b[0mind0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m*\u001b[0m\u001b[0margs\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;33m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    381\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    382\u001b[0m     \u001b[1;31m# build a buffer for storing evaluations of func1d.\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m<ipython-input-86-8f81fbaa0ffd>\u001b[0m in \u001b[0;36mmapp_nums\u001b[1;34m(val)\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mmapp_nums\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mval\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m     \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mval\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m     \u001b[1;32mif\u001b[0m \u001b[0mval\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;36m1\u001b[0m\u001b[1;33m:\u001b[0m \u001b[1;32mreturn\u001b[0m \u001b[1;34m\"One\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      4\u001b[0m     \u001b[1;32melif\u001b[0m \u001b[0mval\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;36m2\u001b[0m\u001b[1;33m:\u001b[0m \u001b[1;32mreturn\u001b[0m \u001b[1;34m\"Two\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m     \u001b[1;32melif\u001b[0m \u001b[0mval\u001b[0m \u001b[1;33m==\u001b[0m \u001b[1;36m3\u001b[0m\u001b[1;33m:\u001b[0m \u001b[1;32mreturn\u001b[0m \u001b[1;34m\"Three\"\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mValueError\u001b[0m: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()"
     ]
    }
   ],
   "source": [
    "np.apply_along_axis(mapp_nums, 0, dset2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class vectorize in module numpy:\n",
      "\n",
      "class vectorize(builtins.object)\n",
      " |  vectorize(pyfunc, otypes=None, doc=None, excluded=None, cache=False, signature=None)\n",
      " |  \n",
      " |  vectorize(pyfunc, otypes=None, doc=None, excluded=None, cache=False,\n",
      " |            signature=None)\n",
      " |  \n",
      " |  Generalized function class.\n",
      " |  \n",
      " |  Define a vectorized function which takes a nested sequence of objects or\n",
      " |  numpy arrays as inputs and returns a single numpy array or a tuple of numpy\n",
      " |  arrays. The vectorized function evaluates `pyfunc` over successive tuples\n",
      " |  of the input arrays like the python map function, except it uses the\n",
      " |  broadcasting rules of numpy.\n",
      " |  \n",
      " |  The data type of the output of `vectorized` is determined by calling\n",
      " |  the function with the first element of the input.  This can be avoided\n",
      " |  by specifying the `otypes` argument.\n",
      " |  \n",
      " |  Parameters\n",
      " |  ----------\n",
      " |  pyfunc : callable\n",
      " |      A python function or method.\n",
      " |  otypes : str or list of dtypes, optional\n",
      " |      The output data type. It must be specified as either a string of\n",
      " |      typecode characters or a list of data type specifiers. There should\n",
      " |      be one data type specifier for each output.\n",
      " |  doc : str, optional\n",
      " |      The docstring for the function. If `None`, the docstring will be the\n",
      " |      ``pyfunc.__doc__``.\n",
      " |  excluded : set, optional\n",
      " |      Set of strings or integers representing the positional or keyword\n",
      " |      arguments for which the function will not be vectorized.  These will be\n",
      " |      passed directly to `pyfunc` unmodified.\n",
      " |  \n",
      " |      .. versionadded:: 1.7.0\n",
      " |  \n",
      " |  cache : bool, optional\n",
      " |     If `True`, then cache the first function call that determines the number\n",
      " |     of outputs if `otypes` is not provided.\n",
      " |  \n",
      " |      .. versionadded:: 1.7.0\n",
      " |  \n",
      " |  signature : string, optional\n",
      " |      Generalized universal function signature, e.g., ``(m,n),(n)->(m)`` for\n",
      " |      vectorized matrix-vector multiplication. If provided, ``pyfunc`` will\n",
      " |      be called with (and expected to return) arrays with shapes given by the\n",
      " |      size of corresponding core dimensions. By default, ``pyfunc`` is\n",
      " |      assumed to take scalars as input and output.\n",
      " |  \n",
      " |      .. versionadded:: 1.12.0\n",
      " |  \n",
      " |  Returns\n",
      " |  -------\n",
      " |  vectorized : callable\n",
      " |      Vectorized function.\n",
      " |  \n",
      " |  Examples\n",
      " |  --------\n",
      " |  >>> def myfunc(a, b):\n",
      " |  ...     \"Return a-b if a>b, otherwise return a+b\"\n",
      " |  ...     if a > b:\n",
      " |  ...         return a - b\n",
      " |  ...     else:\n",
      " |  ...         return a + b\n",
      " |  \n",
      " |  >>> vfunc = np.vectorize(myfunc)\n",
      " |  >>> vfunc([1, 2, 3, 4], 2)\n",
      " |  array([3, 4, 1, 2])\n",
      " |  \n",
      " |  The docstring is taken from the input function to `vectorize` unless it\n",
      " |  is specified:\n",
      " |  \n",
      " |  >>> vfunc.__doc__\n",
      " |  'Return a-b if a>b, otherwise return a+b'\n",
      " |  >>> vfunc = np.vectorize(myfunc, doc='Vectorized `myfunc`')\n",
      " |  >>> vfunc.__doc__\n",
      " |  'Vectorized `myfunc`'\n",
      " |  \n",
      " |  The output type is determined by evaluating the first element of the input,\n",
      " |  unless it is specified:\n",
      " |  \n",
      " |  >>> out = vfunc([1, 2, 3, 4], 2)\n",
      " |  >>> type(out[0])\n",
      " |  <type 'numpy.int32'>\n",
      " |  >>> vfunc = np.vectorize(myfunc, otypes=[float])\n",
      " |  >>> out = vfunc([1, 2, 3, 4], 2)\n",
      " |  >>> type(out[0])\n",
      " |  <type 'numpy.float64'>\n",
      " |  \n",
      " |  The `excluded` argument can be used to prevent vectorizing over certain\n",
      " |  arguments.  This can be useful for array-like arguments of a fixed length\n",
      " |  such as the coefficients for a polynomial as in `polyval`:\n",
      " |  \n",
      " |  >>> def mypolyval(p, x):\n",
      " |  ...     _p = list(p)\n",
      " |  ...     res = _p.pop(0)\n",
      " |  ...     while _p:\n",
      " |  ...         res = res*x + _p.pop(0)\n",
      " |  ...     return res\n",
      " |  >>> vpolyval = np.vectorize(mypolyval, excluded=['p'])\n",
      " |  >>> vpolyval(p=[1, 2, 3], x=[0, 1])\n",
      " |  array([3, 6])\n",
      " |  \n",
      " |  Positional arguments may also be excluded by specifying their position:\n",
      " |  \n",
      " |  >>> vpolyval.excluded.add(0)\n",
      " |  >>> vpolyval([1, 2, 3], x=[0, 1])\n",
      " |  array([3, 6])\n",
      " |  \n",
      " |  The `signature` argument allows for vectorizing functions that act on\n",
      " |  non-scalar arrays of fixed length. For example, you can use it for a\n",
      " |  vectorized calculation of Pearson correlation coefficient and its p-value:\n",
      " |  \n",
      " |  >>> import scipy.stats\n",
      " |  >>> pearsonr = np.vectorize(scipy.stats.pearsonr,\n",
      " |  ...                         signature='(n),(n)->(),()')\n",
      " |  >>> pearsonr([[0, 1, 2, 3]], [[1, 2, 3, 4], [4, 3, 2, 1]])\n",
      " |  (array([ 1., -1.]), array([ 0.,  0.]))\n",
      " |  \n",
      " |  Or for a vectorized convolution:\n",
      " |  \n",
      " |  >>> convolve = np.vectorize(np.convolve, signature='(n),(m)->(k)')\n",
      " |  >>> convolve(np.eye(4), [1, 2, 1])\n",
      " |  array([[ 1.,  2.,  1.,  0.,  0.,  0.],\n",
      " |         [ 0.,  1.,  2.,  1.,  0.,  0.],\n",
      " |         [ 0.,  0.,  1.,  2.,  1.,  0.],\n",
      " |         [ 0.,  0.,  0.,  1.,  2.,  1.]])\n",
      " |  \n",
      " |  See Also\n",
      " |  --------\n",
      " |  frompyfunc : Takes an arbitrary Python function and returns a ufunc\n",
      " |  \n",
      " |  Notes\n",
      " |  -----\n",
      " |  The `vectorize` function is provided primarily for convenience, not for\n",
      " |  performance. The implementation is essentially a for loop.\n",
      " |  \n",
      " |  If `otypes` is not specified, then a call to the function with the\n",
      " |  first argument will be used to determine the number of outputs.  The\n",
      " |  results of this call will be cached if `cache` is `True` to prevent\n",
      " |  calling the function twice.  However, to implement the cache, the\n",
      " |  original function must be wrapped which will slow down subsequent\n",
      " |  calls, so only do this if your function is expensive.\n",
      " |  \n",
      " |  The new keyword argument interface and `excluded` argument support\n",
      " |  further degrades performance.\n",
      " |  \n",
      " |  References\n",
      " |  ----------\n",
      " |  .. [1] NumPy Reference, section `Generalized Universal Function API\n",
      " |         <https://docs.scipy.org/doc/numpy/reference/c-api.generalized-ufuncs.html>`_.\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __call__(self, *args, **kwargs)\n",
      " |      Return arrays with the results of `pyfunc` broadcast (vectorized) over\n",
      " |      `args` and `kwargs` not in `excluded`.\n",
      " |  \n",
      " |  __init__(self, pyfunc, otypes=None, doc=None, excluded=None, cache=False, signature=None)\n",
      " |      Initialize self.  See help(type(self)) for accurate signature.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data descriptors defined here:\n",
      " |  \n",
      " |  __dict__\n",
      " |      dictionary for instance variables (if defined)\n",
      " |  \n",
      " |  __weakref__\n",
      " |      list of weak references to the object (if defined)\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(np.vectorize)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [],
   "source": [
    "# for item in dset2:\n",
    "#     mapp_nums(item)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [],
   "source": [
    "mapp = np.vectorize(mapp_nums)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['Other', 'Two', 'Two', 'One', 'Other', 'One', 'Other', 'Other',\n",
       "       'Other', 'Three', 'Other', 'Other', 'One', 'Other', 'Two', 'One',\n",
       "       'Other', 'Three', 'Other', 'One', 'Two', 'Three', 'One', 'Other',\n",
       "       'Other', 'Other', 'Three', 'Other', 'One', 'One', 'Three', 'One',\n",
       "       'One', 'Other', 'Other', 'One', 'One', 'Two', 'One', 'Three',\n",
       "       'Other', 'One', 'One', 'Other', 'Three', 'Other', 'Two', 'Other',\n",
       "       'One', 'Two', 'One', 'One', 'Three', 'Other', 'Other', 'Other',\n",
       "       'One', 'Other', 'Two', 'Two', 'One', 'Three', 'Three', 'Two',\n",
       "       'Three', 'Two', 'Three', 'One', 'Two', 'Three', 'One', 'Other',\n",
       "       'Other', 'Other', 'Three', 'One', 'One', 'Other', 'One', 'One',\n",
       "       'Three', 'Three', 'Other', 'One', 'Other', 'One', 'Two', 'One',\n",
       "       'Three', 'One', 'Three', 'One', 'Other', 'Two', 'Three', 'One',\n",
       "       'One', 'Other', 'One', 'Two', 'One', 'Other', 'Three', 'Other',\n",
       "       'Two', 'Other', 'Other', 'Three', 'One', 'Other', 'Three', 'Three',\n",
       "       'Three', 'Three', 'Two', 'One', 'Two', 'One', 'Other', 'Two',\n",
       "       'One', 'Three', 'Two', 'Three', 'One', 'Other', 'Two', 'Other',\n",
       "       'Three', 'Three', 'Two', 'One', 'Other', 'One', 'Other', 'Three',\n",
       "       'Other', 'One', 'Other', 'Two', 'Three', 'One', 'Three', 'Other',\n",
       "       'Three', 'Three', 'Two', 'One', 'Two', 'One', 'Two', 'Three',\n",
       "       'Three', 'One', 'One', 'One', 'One', 'Other', 'Other', 'Two',\n",
       "       'Other', 'Two', 'Three', 'Two', 'Two', 'Three', 'Three', 'Other',\n",
       "       'Three', 'Three', 'Other', 'One', 'Three', 'Other', 'Other', 'One',\n",
       "       'Other', 'Two', 'Other', 'Two', 'Two', 'Other', 'Two', 'One',\n",
       "       'One', 'One', 'Two', 'Other', 'Three', 'Other', 'Other', 'One',\n",
       "       'Three', 'Two', 'Three', 'Two', 'Other', 'Two', 'One', 'Two',\n",
       "       'One', 'Other', 'Two', 'One', 'Three', 'Two', 'Two', 'One', 'Two',\n",
       "       'Three', 'Two', 'Other', 'One', 'Three', 'Two', 'One', 'Other',\n",
       "       'One', 'One', 'Three', 'Two', 'Two', 'Two', 'Other', 'Three',\n",
       "       'One', 'One', 'Two', 'Three', 'Other', 'Three', 'One', 'Other',\n",
       "       'Other', 'One', 'Other', 'Two', 'One', 'Two', 'Other', 'Three',\n",
       "       'Other', 'One', 'Two', 'Two', 'Other', 'Three', 'Three', 'Two',\n",
       "       'Three', 'One', 'One', 'Other', 'Other', 'Three', 'Three', 'Two',\n",
       "       'Other', 'One', 'Other', 'One', 'Two', 'One', 'One', 'Two',\n",
       "       'Three', 'Three', 'Other', 'One', 'Two', 'Two', 'Three', 'Three',\n",
       "       'Three', 'Other', 'Two', 'Other', 'Three', 'Three', 'One', 'Two',\n",
       "       'One', 'Two', 'Two', 'One', 'One', 'Two', 'One', 'Other', 'One',\n",
       "       'Other', 'Two', 'Two', 'Two', 'Two', 'One', 'Three', 'Two', 'One',\n",
       "       'Three', 'One', 'Two', 'Two', 'Three', 'One', 'Three', 'One',\n",
       "       'Three', 'Three', 'Other', 'Two', 'Two', 'Other', 'One', 'Other',\n",
       "       'Two', 'One', 'Two', 'Other', 'One', 'One', 'Three', 'Other',\n",
       "       'One', 'Other', 'Other', 'Two', 'Two', 'Three', 'One', 'Two',\n",
       "       'Other', 'One', 'Two', 'Two', 'Two', 'Two', 'Two', 'Two', 'One',\n",
       "       'Two', 'One', 'Two', 'One', 'Two', 'Two', 'Three', 'One', 'One',\n",
       "       'Other', 'One', 'Three', 'Three', 'One', 'One', 'One', 'Three',\n",
       "       'One', 'One', 'Other', 'Other', 'Three', 'One', 'Three', 'Other',\n",
       "       'Three', 'One', 'Two', 'Two', 'Other', 'Other', 'One', 'One',\n",
       "       'Other', 'Two', 'One', 'Other', 'Other', 'Other', 'Two', 'Other',\n",
       "       'Other', 'Two', 'One', 'One', 'Two', 'One', 'Three', 'One',\n",
       "       'Three', 'Three', 'One', 'Two', 'One', 'Two', 'One', 'Other',\n",
       "       'Three', 'Three', 'Three', 'Two', 'Three', 'Three', 'Three', 'One',\n",
       "       'Other', 'Two', 'Three', 'Other', 'Three', 'One', 'Other', 'Three',\n",
       "       'Three', 'Two', 'Two', 'Two', 'One', 'Two'], dtype='<U5')"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mapp(dset2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [],
   "source": [
    "def m1(arg):\n",
    "    return arg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hello(func):\n",
    "    def wrapper(arg):\n",
    "        return \"Hello \" + func(arg)\n",
    "    return wrapper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "m2 = hello(m1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.hello.<locals>.wrapper(arg)>"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'world'"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m1(\"world\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello world'"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m2(\"world\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [],
   "source": [
    "@hello\n",
    "def m3(arg):\n",
    "    return arg * 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [],
   "source": [
    "# m3 = hello(m3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello worldworldworld'"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m3(\"world\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}