numpy_100.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1-2.导入版本检查"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.16.4\n",
      "blas_mkl_info:\n",
      "  NOT AVAILABLE\n",
      "blis_info:\n",
      "  NOT AVAILABLE\n",
      "openblas_info:\n",
      "    libraries = ['openblas', 'openblas']\n",
      "    library_dirs = ['/usr/local/lib']\n",
      "    language = c\n",
      "    define_macros = [('HAVE_CBLAS', None)]\n",
      "blas_opt_info:\n",
      "    libraries = ['openblas', 'openblas']\n",
      "    library_dirs = ['/usr/local/lib']\n",
      "    language = c\n",
      "    define_macros = [('HAVE_CBLAS', None)]\n",
      "lapack_mkl_info:\n",
      "  NOT AVAILABLE\n",
      "openblas_lapack_info:\n",
      "    libraries = ['openblas', 'openblas']\n",
      "    library_dirs = ['/usr/local/lib']\n",
      "    language = c\n",
      "    define_macros = [('HAVE_CBLAS', None)]\n",
      "lapack_opt_info:\n",
      "    libraries = ['openblas', 'openblas']\n",
      "    library_dirs = ['/usr/local/lib']\n",
      "    language = c\n",
      "    define_macros = [('HAVE_CBLAS', None)]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "print(np.__version__)\n",
    "np.show_config()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3.创建一个10维的向量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z = np.zeros(10)\n",
    "z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.数组占用内存的大小"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "800 bytes\n"
     ]
    }
   ],
   "source": [
    "z = np.zeros((10, 10))\n",
    "print(f'{z.size * z.itemsize} bytes')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 5.从命令行获取api的文档"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "add(x1, x2, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])\n",
      "\n",
      "Add arguments element-wise.\n",
      "\n",
      "Parameters\n",
      "----------\n",
      "x1, x2 : array_like\n",
      "    The arrays to be added.  If ``x1.shape != x2.shape``, they must be\n",
      "    broadcastable to a common shape (which may be the shape of one or\n",
      "    the other).\n",
      "out : ndarray, None, or tuple of ndarray and None, optional\n",
      "    A location into which the result is stored. If provided, it must have\n",
      "    a shape that the inputs broadcast to. If not provided or `None`,\n",
      "    a freshly-allocated array is returned. A tuple (possible only as a\n",
      "    keyword argument) must have length equal to the number of outputs.\n",
      "where : array_like, optional\n",
      "    Values of True indicate to calculate the ufunc at that position, values\n",
      "    of False indicate to leave the value in the output alone.\n",
      "**kwargs\n",
      "    For other keyword-only arguments, see the\n",
      "    :ref:`ufunc docs <ufuncs.kwargs>`.\n",
      "\n",
      "Returns\n",
      "-------\n",
      "add : ndarray or scalar\n",
      "    The sum of `x1` and `x2`, element-wise.\n",
      "    This is a scalar if both `x1` and `x2` are scalars.\n",
      "\n",
      "Notes\n",
      "-----\n",
      "Equivalent to `x1` + `x2` in terms of array broadcasting.\n",
      "\n",
      "Examples\n",
      "--------\n",
      ">>> np.add(1.0, 4.0)\n",
      "5.0\n",
      ">>> x1 = np.arange(9.0).reshape((3, 3))\n",
      ">>> x2 = np.arange(3.0)\n",
      ">>> np.add(x1, x2)\n",
      "array([[  0.,   2.,   4.],\n",
      "       [  3.,   5.,   7.],\n",
      "       [  6.,   8.,  10.]])\n"
     ]
    }
   ],
   "source": [
    "! python -c \"import numpy; numpy.info(numpy.add)\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 6.创建大小为10，第5个元素为1的向量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0., 0., 1., 0., 0., 0., 0., 0.])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z = np.zeros(10)\n",
    "z[4] = 1\n",
    "z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 7.创建一个从10到49的向量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26,\n",
       "       27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,\n",
       "       44, 45, 46, 47, 48, 49])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z = np.arange(10, 50)\n",
    "z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 8.反转向量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([49, 48, 47, 46, 45, 44, 43, 42, 41, 40, 39, 38, 37, 36, 35, 34, 33,\n",
       "       32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16,\n",
       "       15, 14, 13, 12, 11, 10,  9,  8,  7,  6,  5,  4,  3,  2,  1,  0])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z = np.arange(50)\n",
    "z[::-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 9.创建一个0-8的3x3矩阵"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2],\n",
       "       [3, 4, 5],\n",
       "       [6, 7, 8]])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nz = np.arange(9).reshape((3,3))\n",
    "nz"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 10.从指定数组中找出非零元素的索引"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([0, 1, 4]),)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nz = np.nonzero([1,2,0,0,4,0])\n",
    "nz"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 11.创建3x3的单位向量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0., 0.],\n",
       "       [0., 1., 0.],\n",
       "       [0., 0., 1.]])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.eye(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 12.创建3x3x3的随机张量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[0.34282518, 0.16559371, 0.90485649],\n",
       "        [0.78955623, 0.55603327, 0.18013773],\n",
       "        [0.49660208, 0.63365203, 0.66846831]],\n",
       "\n",
       "       [[0.88175637, 0.54336855, 0.6097875 ],\n",
       "        [0.79651274, 0.18562408, 0.5893058 ],\n",
       "        [0.04913705, 0.21157224, 0.77078224]],\n",
       "\n",
       "       [[0.15794543, 0.46873215, 0.2405402 ],\n",
       "        [0.46853508, 0.53329237, 0.07584   ],\n",
       "        [0.83479012, 0.59437738, 0.48493679]]])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.random((3,3,3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 13.创建10x10随机张量，并找出最大值和最小值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([[0.97865134, 0.36990256, 0.49410215, 0.40618375, 0.65704416,\n",
       "         0.2208883 , 0.28048677, 0.53736338, 0.2331402 , 0.67412809],\n",
       "        [0.37290618, 0.15140794, 0.56296107, 0.02344776, 0.8706872 ,\n",
       "         0.00143751, 0.10568316, 0.68733361, 0.47629723, 0.37902334],\n",
       "        [0.10106211, 0.1812896 , 0.19078727, 0.72177187, 0.84592366,\n",
       "         0.80448102, 0.3668204 , 0.5347369 , 0.96256022, 0.88098586],\n",
       "        [0.02960791, 0.39161832, 0.80217883, 0.8411179 , 0.70032741,\n",
       "         0.64002788, 0.81521434, 0.41071292, 0.54183927, 0.31692161],\n",
       "        [0.97321478, 0.98591688, 0.43029702, 0.52824672, 0.98596004,\n",
       "         0.24321835, 0.36172837, 0.14590416, 0.81943029, 0.81348942],\n",
       "        [0.84794683, 0.3782878 , 0.06172852, 0.11194601, 0.3371251 ,\n",
       "         0.3375967 , 0.00361938, 0.34865985, 0.53373933, 0.54454313],\n",
       "        [0.32141157, 0.05576695, 0.13828434, 0.83627648, 0.4217362 ,\n",
       "         0.97803267, 0.79584   , 0.77256564, 0.67031951, 0.62464299],\n",
       "        [0.07257423, 0.48021365, 0.8454221 , 0.3128435 , 0.98549701,\n",
       "         0.24206908, 0.69741166, 0.51544346, 0.40836582, 0.97730344],\n",
       "        [0.28451863, 0.29290153, 0.66652868, 0.97508335, 0.64119537,\n",
       "         0.19633881, 0.60636268, 0.27571441, 0.78348375, 0.54103065],\n",
       "        [0.43341557, 0.42821212, 0.07644333, 0.94515894, 0.37742475,\n",
       "         0.52736851, 0.76973282, 0.08701745, 0.93043535, 0.96703632]]),\n",
       " 0.0014375114059891336,\n",
       " 0.9859600425065329)"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = np.random.random((10,10))\n",
    "s, s.min(), s.max()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 14.创建随机大小为30的张量并获取均值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([0.15710425, 0.15800184, 0.79166578, 0.45142916, 0.24873449,\n",
       "        0.16842868, 0.55482157, 0.7940582 , 0.99546374, 0.91975086,\n",
       "        0.04721699, 0.17479541, 0.58974601, 0.73565342, 0.99278368,\n",
       "        0.53119133, 0.64556544, 0.64349445, 0.36830221, 0.60690088,\n",
       "        0.15972224, 0.55968352, 0.13472359, 0.23037601, 0.56741765,\n",
       "        0.29503977, 0.28678096, 0.09392781, 0.09047634, 0.59084744]),\n",
       " 0.4528034563805088)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z = np.random.random(30)\n",
    "z, z.mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 15.创建2维张量，1在外围，0在内围"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1., 1., 1., 1., 1., 1., 1., 1.],\n",
       "       [1., 0., 0., 0., 0., 0., 0., 0., 0., 1.],\n",
       "       [1., 0., 0., 0., 0., 0., 0., 0., 0., 1.],\n",
       "       [1., 0., 0., 0., 0., 0., 0., 0., 0., 1.],\n",
       "       [1., 0., 0., 0., 0., 0., 0., 0., 0., 1.],\n",
       "       [1., 0., 0., 0., 0., 0., 0., 0., 0., 1.],\n",
       "       [1., 0., 0., 0., 0., 0., 0., 0., 0., 1.],\n",
       "       [1., 0., 0., 0., 0., 0., 0., 0., 0., 1.],\n",
       "       [1., 0., 0., 0., 0., 0., 0., 0., 0., 1.],\n",
       "       [1., 1., 1., 1., 1., 1., 1., 1., 1., 1.]])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = np.ones((10, 10))\n",
    "s[1:-1,1:-1] = 0\n",
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 16.给指定的张量外围加一圈0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0., 0., 0., 0., 0.],\n",
       "       [0., 1., 1., 1., 1., 1., 0.],\n",
       "       [0., 1., 1., 1., 1., 1., 0.],\n",
       "       [0., 1., 1., 1., 1., 1., 0.],\n",
       "       [0., 1., 1., 1., 1., 1., 0.],\n",
       "       [0., 1., 1., 1., 1., 1., 0.],\n",
       "       [0., 0., 0., 0., 0., 0., 0.]])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = np.ones((5, 5))\n",
    "s = np.pad(s, pad_width=1, mode='constant', constant_values=0)\n",
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 17.下面的表达式输出是什么"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[nan, False, False, nan, True, False]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "test = [0 * np.nan, np.nan==np.nan, np.inf > np.nan, np.nan - np.nan, np.nan in set([np.nan]), 0.3 == 3 * 0.1]\n",
    "test"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 18.创建5x5张量，并且对角线下元素为1,2,3,4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0, 0, 0, 0],\n",
       "       [1, 0, 0, 0, 0],\n",
       "       [0, 2, 0, 0, 0],\n",
       "       [0, 0, 3, 0, 0],\n",
       "       [0, 0, 0, 4, 0]])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.diag(1+np.arange(4), k=-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 19.创建8x8张量，且让其符合跳棋布局"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 0, 1, 0, 1, 0, 1],\n",
       "       [1, 0, 1, 0, 1, 0, 1, 0],\n",
       "       [0, 1, 0, 1, 0, 1, 0, 1],\n",
       "       [1, 0, 1, 0, 1, 0, 1, 0],\n",
       "       [0, 1, 0, 1, 0, 1, 0, 1],\n",
       "       [1, 0, 1, 0, 1, 0, 1, 0],\n",
       "       [0, 1, 0, 1, 0, 1, 0, 1],\n",
       "       [1, 0, 1, 0, 1, 0, 1, 0]])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = np.zeros((8, 8), dtype=int)\n",
    "s[1::2, ::2] = 1\n",
    "s[::2, 1::2] = 1\n",
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 20.一个维度为6x7x8的张量，其第100个元素的维度索引是多少"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 5, 3)"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.unravel_index(99, (6, 7, 8))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 21.使用`tile`函数创建棋盘张量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 0, 1, 0, 1, 0, 1],\n",
       "       [1, 0, 1, 0, 1, 0, 1, 0],\n",
       "       [0, 1, 0, 1, 0, 1, 0, 1],\n",
       "       [1, 0, 1, 0, 1, 0, 1, 0],\n",
       "       [0, 1, 0, 1, 0, 1, 0, 1],\n",
       "       [1, 0, 1, 0, 1, 0, 1, 0],\n",
       "       [0, 1, 0, 1, 0, 1, 0, 1],\n",
       "       [1, 0, 1, 0, 1, 0, 1, 0]])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.tile(np.array([[0, 1],[1, 0]]), (4, 4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 22.随机张量的正则化"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.88814082, -1.51537362,  0.29176951,  0.58308696,  0.15144328],\n",
       "       [ 0.70494842,  1.20053038, -0.70039649,  0.39450527, -0.34266141],\n",
       "       [ 0.64800266, -1.02017847,  0.8818805 ,  0.66726354,  1.44609547],\n",
       "       [-1.61087948, -1.98087904, -1.73995106,  0.30925981,  0.40657171],\n",
       "       [-0.9282712 ,  0.5920912 ,  1.13907418,  1.29341663,  0.01679206]])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = np.random.random((5, 5))\n",
    "s = (s - np.mean(s)) / (np.std(s))\n",
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 23.创建一个将颜色描述为四个无符号字节的自定义dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype([('r', 'u1'), ('g', 'u1'), ('b', 'u1'), ('a', 'u1')])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "color = np.dtype([\n",
    "    ('r', np.ubyte, 1),\n",
    "    ('g', np.ubyte, 1),\n",
    "    ('b', np.ubyte, 1),\n",
    "    ('a', np.ubyte, 1),\n",
    "])\n",
    "color"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 24.张量的矩阵乘法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3., 3.],\n",
       "       [3., 3.],\n",
       "       [3., 3.],\n",
       "       [3., 3.],\n",
       "       [3., 3.]])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1 = np.dot(np.ones((5, 3)), np.ones((3, 2)))\n",
    "s1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 25.给定1维向量，对值在3-8的元素取负"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3, -4, -5, -6, -7, -8,  9, 10])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = np.arange(11)\n",
    "s[(3 < s) & (s <= 8)] *= -1\n",
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 26.下面表达式的输出"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(range(5), -1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from numpy import *\n",
    "sum(range(5), -1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 27.以下合法的表达式"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2],\n",
       "       [3, 4, 5],\n",
       "       [6, 7, 8]])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = np.arange(9).reshape((3,3))\n",
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[       1,        1,        4],\n",
       "       [      27,      256,     3125],\n",
       "       [   46656,   823543, 16777216]])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s ** s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  0,   1,   2],\n",
       "       [  4,   8,  16],\n",
       "       [ 32,  64, 128]])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 << s >> 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False, False, False],\n",
       "       [False, False, False],\n",
       "       [False, False, False]])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s <- s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.+0.j, 0.+1.j, 0.+2.j],\n",
       "       [0.+3.j, 0.+4.j, 0.+5.j],\n",
       "       [0.+6.j, 0.+7.j, 0.+8.j]])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1j * s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 1., 2.],\n",
       "       [3., 4., 5.],\n",
       "       [6., 7., 8.]])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s/1/1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "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[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-46-069d87880cb5>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0ms\u001b[0m\u001b[0;34m<\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m>\u001b[0m\u001b[0ms\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()"
     ]
    }
   ],
   "source": [
    "s<s>s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 28.以下表达式的结果"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ljh/anaconda3/envs/nlp_streamlit/lib/python3.6/site-packages/ipykernel_launcher.py:1: RuntimeWarning: invalid value encountered in true_divide\n",
      "  \"\"\"Entry point for launching an IPython kernel.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "nan"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array(0) / np.array(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ljh/anaconda3/envs/nlp_streamlit/lib/python3.6/site-packages/ipykernel_launcher.py:1: RuntimeWarning: divide by zero encountered in floor_divide\n",
      "  \"\"\"Entry point for launching an IPython kernel.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array(0) // np.array(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-9.22337204e+18])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([np.nan]).astype(int).astype(float)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 29.合理取整"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-6.75249955 -8.38820961  3.26681962  1.5390238   9.18848284 -5.97553043\n",
      "  9.06095915  8.65087933  2.936704   -2.28259777]\n",
      "[-7. -9.  4.  2. 10. -6. 10.  9.  3. -3.]\n"
     ]
    }
   ],
   "source": [
    "Z = np.random.uniform(-10,+10,10)\n",
    "print(Z)\n",
    "print(np.copysign(np.ceil(np.abs(Z)), Z))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 30.寻找两个张量的相同值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[6 9 9 0 8 4 4 4 6 3]\n",
      "[8 7 4 9 0 9 3 0 0 9]\n"
     ]
    }
   ],
   "source": [
    "s1 = np.random.randint(0, 10, 10)\n",
    "print(s1)\n",
    "s2 = np.random.randint(0, 10, 10)\n",
    "print(s2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 3, 4, 8, 9])"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.intersect1d(s1, s2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 31.忽略numpy警告"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "defaults = np.seterr(all='ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = np.ones(1) / 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([inf])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'divide': 'ignore', 'over': 'ignore', 'under': 'ignore', 'invalid': 'ignore'}"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.seterr(**defaults)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([0, 1, 2, 5]),)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "nz = np.nonzero([1,2,3,0,0,5,0])\n",
    "nz"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 32.表达式输出 - 复数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ljh/anaconda3/envs/nlp_streamlit/lib/python3.6/site-packages/ipykernel_launcher.py:1: RuntimeWarning: invalid value encountered in sqrt\n",
      "  \"\"\"Entry point for launching an IPython kernel.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sqrt(-1) == np.emath.sqrt(-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/ljh/anaconda3/envs/nlp_streamlit/lib/python3.6/site-packages/ipykernel_launcher.py:1: RuntimeWarning: invalid value encountered in sqrt\n",
      "  \"\"\"Entry point for launching an IPython kernel.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "nan"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sqrt(-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1j"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.emath.sqrt(-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 33.获取昨天，今天，明天的日期"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(numpy.datetime64('2020-03-31'),\n",
       " numpy.datetime64('2020-04-01'),\n",
       " numpy.datetime64('2020-04-02'))"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "yesterday = np.datetime64('today', 'D') - np.timedelta64(1, 'D')\n",
    "today = np.datetime64('today', 'D')\n",
    "tomorrow = np.datetime64('today', 'D') + np.timedelta64(1, 'D')\n",
    "yesterday, today, tomorrow"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 34.获取2016年7月份所有的日期"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['2016-07-01', '2016-07-02', '2016-07-03', '2016-07-04',\n",
       "       '2016-07-05', '2016-07-06', '2016-07-07', '2016-07-08',\n",
       "       '2016-07-09', '2016-07-10', '2016-07-11', '2016-07-12',\n",
       "       '2016-07-13', '2016-07-14', '2016-07-15', '2016-07-16',\n",
       "       '2016-07-17', '2016-07-18', '2016-07-19', '2016-07-20',\n",
       "       '2016-07-21', '2016-07-22', '2016-07-23', '2016-07-24',\n",
       "       '2016-07-25', '2016-07-26', '2016-07-27', '2016-07-28',\n",
       "       '2016-07-29', '2016-07-30', '2016-07-31'], dtype='datetime64[D]')"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = np.arange('2016-07', '2016-08', dtype='datetime64[D]')\n",
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 35.**原地计算以下式子((A+B)*(-A/2))**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-1.5, -1.5, -1.5])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.ones(3)*1\n",
    "B = np.ones(3)*2\n",
    "C = np.ones(3)*3\n",
    "np.add(A,B,out=B)\n",
    "np.divide(A,2,out=A)\n",
    "np.negative(A,out=A)\n",
    "np.multiply(A,B,out=A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 36.用5种方式从一个随机带小数的数组中抽取整数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[9.2363541  5.81770409 6.97628807 2.60160465 7.9521065  6.9025715\n",
      " 9.81981787 8.82999143 6.07077572 5.03208172]\n",
      "[9. 5. 6. 2. 7. 6. 9. 8. 6. 5.]\n",
      "[9. 5. 6. 2. 7. 6. 9. 8. 6. 5.]\n",
      "[9. 5. 6. 2. 7. 6. 9. 8. 6. 5.]\n",
      "[9 5 6 2 7 6 9 8 6 5]\n",
      "[9. 5. 6. 2. 7. 6. 9. 8. 6. 5.]\n"
     ]
    }
   ],
   "source": [
    "Z = np.random.uniform(0,10,10)\n",
    "print(Z)\n",
    "print (Z - Z%1)\n",
    "print (np.floor(Z))\n",
    "print (np.ceil(Z)-1)\n",
    "print (Z.astype(int))\n",
    "print (np.trunc(Z))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 37.创建一个每行范围在0-5的5*5矩阵"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 1. 2. 3. 4.]\n",
      " [0. 1. 2. 3. 4.]\n",
      " [0. 1. 2. 3. 4.]\n",
      " [0. 1. 2. 3. 4.]\n",
      " [0. 1. 2. 3. 4.]]\n"
     ]
    }
   ],
   "source": [
    "Z = np.zeros((5,5))\n",
    "Z += np.arange(5)\n",
    "print(Z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 38.使用生成器构建数组"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]\n"
     ]
    }
   ],
   "source": [
    "def generate():\n",
    "    for x in range(10):\n",
    "        yield x\n",
    "Z = np.fromiter(generate(),dtype=float,count=-1)\n",
    "print(Z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 1., 2.])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.fromiter((s for s in range(10)), dtype=float, count=3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 39.创建区间(0,1)的值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.09090909 0.18181818 0.27272727 0.36363636 0.45454545 0.54545455\n",
      " 0.63636364 0.72727273 0.81818182 0.90909091]\n"
     ]
    }
   ],
   "source": [
    "Z = np.linspace(0,1,11,endpoint=False)[1:]\n",
    "print(Z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1. ]\n"
     ]
    }
   ],
   "source": [
    "# endpoint，决定最后一个数是否为参数stop处的数\n",
    "Z = np.linspace(0,1,11)[1:]\n",
    "print(Z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 40.创建一个随机向量并排序"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.13602845 0.17446344 0.25352851 0.41665601 0.44897837 0.61457149\n",
      " 0.6159659  0.67000031 0.67249238 0.87723055]\n"
     ]
    }
   ],
   "source": [
    "Z = np.random.random(10)\n",
    "Z.sort()\n",
    "print(Z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 41.对一个小型数组进行求和，使其求和速度快于内建函数np.sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.37 µs ± 12.3 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "Z = np.arange(10)\n",
    "np.add.reduce(Z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.89 µs ± 61.6 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "Z = np.arange(10)\n",
    "np.sum(Z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 42.验证两个随机数组是否相等"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 0 1 1 1]\n",
      "[1 1 1 0 0]\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "A = np.random.randint(0,2,5)\n",
    "B = np.random.randint(0,2,5)\n",
    "print(A)\n",
    "print(B)\n",
    "# Assuming identical shape of the arrays and a tolerance for the comparison of values\n",
    "equal = np.allclose(A,B)\n",
    "print(equal)\n",
    "\n",
    "# Checking both the shape and the element values, no tolerance (values have to be exactly equal)\n",
    "equal = np.array_equal(A,B)\n",
    "print(equal)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 43.让一个数组无法被更改"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "assignment destination is read-only",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-33-dcc5e7f145b5>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mZ\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mzeros\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mZ\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mflags\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwriteable\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mZ\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: assignment destination is read-only"
     ]
    }
   ],
   "source": [
    "Z = np.zeros(10)\n",
    "Z.flags.writeable = False\n",
    "Z[0] = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 44.将一个10*2的笛卡尔坐标转换成极坐标"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.37447246 0.95189727 1.05162407 1.19085834 0.66473055 0.98800233\n",
      " 0.84394419 1.16626468 0.59135395 1.21044533]\n",
      "[0.67643607 0.02033565 0.38281584 0.93870108 1.34584781 0.79236102\n",
      " 0.69694668 0.97271225 1.1574381  0.63746085]\n"
     ]
    }
   ],
   "source": [
    "Z = np.random.random((10,2))\n",
    "X,Y = Z[:,0], Z[:,1]\n",
    "R = np.sqrt(X**2+Y**2)\n",
    "T = np.arctan2(Y,X)\n",
    "print(R)\n",
    "print(T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 45.将数组中的最大值替换成0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.5643563  0.38674909 0.92087286 0.64238493 0.0909707  0.23189555\n",
      " 0.33152668 0.45225558 0.09469719 0.57088053]\n",
      "[0.5643563  0.38674909 0.         0.64238493 0.0909707  0.23189555\n",
      " 0.33152668 0.45225558 0.09469719 0.57088053]\n"
     ]
    }
   ],
   "source": [
    "Z = np.random.random(10)\n",
    "print(Z)\n",
    "Z[Z.argmax()] = 0\n",
    "print(Z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 46.创建一个覆盖（0,1）（0,1）的坐标"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[(0.  , 0.  ) (0.25, 0.  ) (0.5 , 0.  ) (0.75, 0.  ) (1.  , 0.  )]\n",
      " [(0.  , 0.25) (0.25, 0.25) (0.5 , 0.25) (0.75, 0.25) (1.  , 0.25)]\n",
      " [(0.  , 0.5 ) (0.25, 0.5 ) (0.5 , 0.5 ) (0.75, 0.5 ) (1.  , 0.5 )]\n",
      " [(0.  , 0.75) (0.25, 0.75) (0.5 , 0.75) (0.75, 0.75) (1.  , 0.75)]\n",
      " [(0.  , 1.  ) (0.25, 1.  ) (0.5 , 1.  ) (0.75, 1.  ) (1.  , 1.  )]]\n"
     ]
    }
   ],
   "source": [
    "Z = np.zeros((5,5), [('x',float),('y',float)])\n",
    "Z['x'], Z['y'] = np.meshgrid(np.linspace(0,1,5),\n",
    "                             np.linspace(0,1,5))\n",
    "print(Z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 47.根据给出的数组X，Y创建柯西矩阵(Cij =1/(xi - yj))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3638.163637117973\n"
     ]
    }
   ],
   "source": [
    "X = np.arange(8)\n",
    "Y = X + 0.5\n",
    "C = 1.0 / np.subtract.outer(X, Y)\n",
    "print(np.linalg.det(C))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 48.打印numpy中支持的数据类型的极值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-128\n",
      "127\n",
      "-2147483648\n",
      "2147483647\n",
      "-9223372036854775808\n",
      "9223372036854775807\n",
      "--------------------\n",
      "-3.4028235e+38\n",
      "3.4028235e+38\n",
      "1.1920929e-07\n",
      "-1.7976931348623157e+308\n",
      "1.7976931348623157e+308\n",
      "2.220446049250313e-16\n"
     ]
    }
   ],
   "source": [
    "for dtype in [np.int8, np.int32, np.int64]:\n",
    "    print(np.iinfo(dtype).min)\n",
    "    print(np.iinfo(dtype).max)\n",
    "print('-' * 20)\n",
    "for dtype in [np.float32, np.float64]:\n",
    "    print(np.finfo(dtype).min)\n",
    "    print(np.finfo(dtype).max)\n",
    "    print(np.finfo(dtype).eps)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 49.打印出数组的所有值（不省略很长的小数点）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.84691369 0.04446819 0.10389416]\n",
      " [0.06886288 0.38702204 0.95577576]\n",
      " [0.02039421 0.25933737 0.67765023]]\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "np.set_printoptions(threshold=sys.maxsize)\n",
    "Z = np.random.random((3,3))\n",
    "print(Z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 50.找出数组中最接近给定值的值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "40.30718012402842\n",
      "40\n"
     ]
    }
   ],
   "source": [
    "Z = np.arange(100)\n",
    "v = np.random.uniform(0,100)\n",
    "print(v)\n",
    "index = (np.abs(Z-v)).argmin()\n",
    "print(Z[index])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 51.创建结构数组来表示位置和颜色"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[((0., 0.), (0., 0., 0.)) ((0., 0.), (0., 0., 0.))\n",
      " ((0., 0.), (0., 0., 0.)) ((0., 0.), (0., 0., 0.))\n",
      " ((0., 0.), (0., 0., 0.)) ((0., 0.), (0., 0., 0.))\n",
      " ((0., 0.), (0., 0., 0.)) ((0., 0.), (0., 0., 0.))\n",
      " ((0., 0.), (0., 0., 0.)) ((0., 0.), (0., 0., 0.))]\n"
     ]
    }
   ],
   "source": [
    "Z = np.zeros(10, [ ('position', [ ('x', float, 1),\n",
    "                                  ('y', float, 1)]),\n",
    "                   ('color',    [ ('r', float, 1),\n",
    "                                  ('g', float, 1),\n",
    "                                  ('b', float, 1)])])\n",
    "print(Z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 52."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 53."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 54."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 55."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 56."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 57."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 58."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 59."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 60."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 61."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 62."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 63."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 64."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 65."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 66."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 67."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 68."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 69."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 70."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 71."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 72."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 73."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 74."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 75."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 76."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 77."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 78."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 79."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 80."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 81."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 82."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 83."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 84."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 85."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 86."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 87."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 88."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 89."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 90."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 91."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 92."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 99."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 94."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 95."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 96."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 97."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 98."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 100."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "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.6.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}