theory/python/eyes/11.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 第十一章 Numpy库"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 11.1 为什么要用Numpy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 11.1.1 &ensp;低效的Python for循环"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "【例】 求100万个数的倒数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "145 ms ± 13.7 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
     ]
    }
   ],
   "source": [
    "def compute_reciprocals(values):\n",
    "    res = []\n",
    "    for value in values:      # 每遍历到一个元素，就要判断其类型，并查找适用于该数据类型的正确函数\n",
    "        res.append(1/value)\n",
    "    return res\n",
    "\n",
    "\n",
    "values = list(range(1, 1000000))\n",
    "%timeit compute_reciprocals(values)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "%timeit ：ipython中统计运行时间的魔术方法（多次运行取平均值）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.99 ms ± 33.9 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "values = np.arange(1, 1000000)\n",
    "%timeit 1/values"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**实现相同计算，Numpy的运行速度是Python循环的25倍，产生了质的飞跃**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 11.1.2 &ensp;Numpy为什么如此高效"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Numpy 是由C语言编写的**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1、编译型语言VS解释型语言**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "C语言执行时，对代码进行整体编译，速度更快"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2、连续单一类型存储VS分散多变类型存储**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "（1）Numpy数组内的数据类型必须是统一的，如全部是浮点型，而Python列表支持任意类型数据的填充\n",
    "  \n",
    "（2）Numpy数组内的数据**连续存储在内存中**，而Python列表的数据**分散在内存中**\n",
    "  \n",
    " &emsp; **这种存储结构，与一些更加高效的底层处理方式更加的契合**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**3、多线程VS线程锁**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python语言执行时有线程锁，无法实现真正的多线程并行，而C语言可以"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 11.1.3 &ensp;什么时候用Numpy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**在数据处理的过程中，遇到使用“Python for循环” 实现一些向量化、矩阵化操作的时候，要优先考虑用Numpy**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如：  1、两个向量的点乘  \n",
    "  \n",
    "&emsp;  &emsp;2、矩阵乘法  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 11.2 Numpy数组的创建"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 11.2.1 从列表开始创建"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "x = np.array([1, 2, 3, 4, 5])\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n",
      "(5,)\n"
     ]
    }
   ],
   "source": [
    "print(type(x))\n",
    "print(x.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 设置数组的数据类型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1. 2. 3. 4. 5.]\n",
      "<class 'numpy.float32'>\n"
     ]
    }
   ],
   "source": [
    "x = np.array([1, 2, 3, 4, 5], dtype=\"float32\")\n",
    "print(x)\n",
    "print(type(x[0]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 二维数组"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n",
      "(3, 3)\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[1, 2, 3],\n",
    "             [4, 5, 6],\n",
    "             [7, 8, 9]])\n",
    "print(x)\n",
    "print(x.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 11.2.2 从头创建数组"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**（1）创建长度为5的数组，值都为0**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0, 0, 0])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros(5, dtype=int)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**（2）创建一个2*4的浮点型数组，值都为1**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.]])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones((2, 4), dtype=float)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**（3）创建一个3*5的数组，值都为8.8**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[8.8, 8.8, 8.8, 8.8, 8.8],\n",
       "       [8.8, 8.8, 8.8, 8.8, 8.8],\n",
       "       [8.8, 8.8, 8.8, 8.8, 8.8]])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.full((3, 5), 8.8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**（4）创建一个3*3的单位矩阵**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0., 0.],\n",
       "       [0., 1., 0.],\n",
       "       [0., 0., 1.]])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.eye(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**（5）创建一个线性序列数组，从1开始，到15结束，步长为2**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  3,  5,  7,  9, 11, 13])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(1, 15, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**（6）创建一个4个元素的数组，这四个数均匀的分配到0~1**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.        , 0.33333333, 0.66666667, 1.        ])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(0, 1, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**（7）创建一个10个元素的数组，形成1~10^9的等比数列**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.e+00, 1.e+01, 1.e+02, 1.e+03, 1.e+04, 1.e+05, 1.e+06, 1.e+07,\n",
       "       1.e+08, 1.e+09])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.logspace(0, 9, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**（8）创建一个3*3的，在0~1之间均匀分布的随机数构成的数组**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.24347952, 0.41715541, 0.41363866],\n",
       "       [0.44869706, 0.18128167, 0.18568051],\n",
       "       [0.05705023, 0.0689205 , 0.74837661]])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.random((3,3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**（9）创建一个3*3的，均值为0，标准差为1的正态分布随机数构成的数组**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-0.38530465,  0.17474932,  0.31129291],\n",
       "       [ 1.61626424, -2.18883854,  0.54043825],\n",
       "       [-0.9141666 , -0.03804043, -0.6645122 ]])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.normal(0, 1, (3,3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**（10）创建一个3*3的，在[0,10)之间随机整数构成的数组**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[9, 1, 9],\n",
       "       [0, 3, 9],\n",
       "       [8, 5, 4]])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.randint(0, 10, (3,3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**（11）随机重排列**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([20, 40, 10, 30])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.array([10, 20, 30, 40])\n",
    "np.random.permutation(x)       # 生产新列表"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10 20 30 40]\n",
      "[20 40 10 30]\n"
     ]
    }
   ],
   "source": [
    "print(x)\n",
    "np.random.shuffle(x)          # 修改原列表\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**（12）随机采样**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 按指定形状采样"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10., 11., 12., 13., 14., 15., 16., 17., 18., 19., 20., 21., 22.,\n",
       "       23., 24.])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.arange(10, 25, dtype = float)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[19., 23., 22.],\n",
       "       [22., 21., 13.],\n",
       "       [15., 21., 17.],\n",
       "       [14., 23., 19.]])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.choice(x, size=(4, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 9, 5, 8, 5, 2, 4, 9, 8])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "np.random.choice(10, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10]])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.arange(5).reshape(1, 5)\n",
    "x\n",
    "x.sum(axis=1, keepdims=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 按概率采样"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[15., 21., 20.],\n",
       "       [23., 17., 18.],\n",
       "       [23., 15., 17.],\n",
       "       [19., 24., 22.]])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.choice(x, size=(4, 3), p=x/np.sum(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 11.3 Numpy数组的性质"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 11.3.1 数组的属性"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[5, 5, 2, 7],\n",
       "       [2, 3, 0, 8],\n",
       "       [3, 8, 1, 7]])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.random.randint(10, size=(3, 4))\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1、数组的形状shape**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 4)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2、数组的维度ndim**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = np.arange(10)\n",
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y.ndim"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**3、数组的大小size**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**4、数组的数据类型dtype**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int32')"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 11.3.2 数组索引"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1、一维数组的索引**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x1 = np.arange(10)\n",
    "x1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x1[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x1[5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x1[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2、多维数组的索引——以二维为例**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[11,  3, 11],\n",
       "       [ 6,  1,  5]])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x2 = np.random.randint(0, 20, (2,3))\n",
    "x2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x2[0, 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x2[0][0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**注意：numpy数组的数据类型是固定的，向一个整型数组插入一个浮点值，浮点值会向下进行取整**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "x2[0, 0] = 1.618"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  3, 11],\n",
       "       [ 6,  1,  5]])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 11.3.3 数组的切片"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1、一维数组——跟列表一样**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x1 = np.arange(10)\n",
    "x1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x1[:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x1[3:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([9, 8, 7, 6, 5, 4, 3, 2, 1, 0])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x1[::-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2、多维数组——以二维为例**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[14,  9, 15,  8],\n",
       "       [18,  8, 16, 17],\n",
       "       [ 0,  8,  2, 17]])"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x2 = np.random.randint(20, size=(3,4)) \n",
    "x2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[14,  9, 15],\n",
       "       [18,  8, 16]])"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x2[:2, :3]             # 前两行，前三列"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[14, 15],\n",
       "       [18, 16]])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x2[:2, 0:3:2]       # 前两行 前三列（每隔一列）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[17,  2,  8,  0],\n",
       "       [17, 16,  8, 18],\n",
       "       [ 8, 15,  9, 14]])"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x2[::-1, ::-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**3、获取数组的行和列**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 8, 13, 15,  7],\n",
       "       [19, 13, 17,  6],\n",
       "       [11,  2,  0, 12]])"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x3 = np.random.randint(20, size=(3,4)) \n",
    "x3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([19, 13, 17,  6])"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x3[1, :]   #第一行  从0开始计数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([19, 13, 17,  6])"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x3[1]    # 第一行简写"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([15, 17,  0])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x3[:, 2]  # 第二列   从0开始计数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**4、切片获取的是视图，而非副本**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 5, 14,  7,  2],\n",
       "       [ 8, 12,  9,  3],\n",
       "       [19,  0, 10,  7]])"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x4 = np.random.randint(20, size=(3,4)) \n",
    "x4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 5, 14],\n",
       "       [ 8, 12]])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x5 = x4[:2, :2]\n",
    "x5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**注意：视图元素发生修改，则原数组亦发生相应修改**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0, 14],\n",
       "       [ 8, 12]])"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x5[0, 0] = 0\n",
    "x5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0, 14,  7,  2],\n",
       "       [ 8, 12,  9,  3],\n",
       "       [19,  0, 10,  7]])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**修改切片的安全方式：copy**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[18, 14, 10, 12],\n",
       "       [10, 16,  7, 19],\n",
       "       [ 3, 16,  3, 12]])"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x4 = np.random.randint(20, size=(3,4)) \n",
    "x4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[18, 14],\n",
       "       [10, 16]])"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x6 = x4[:2, :2].copy()\n",
    "x6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0, 14],\n",
       "       [10, 16]])"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x6[0, 0] = 0\n",
    "x6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[18, 14, 10, 12],\n",
       "       [10, 16,  7, 19],\n",
       "       [ 3, 16,  3, 12]])"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 11.3.4 数组的变形"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([9, 8, 5, 9, 2, 6, 2, 9, 4, 5, 1, 7])"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x5 = np.random.randint(0, 10, (12,))\n",
    "x5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(12,)"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x5.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[9, 8, 5, 9],\n",
       "       [2, 6, 2, 9],\n",
       "       [4, 5, 1, 7]])"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x6 = x5.reshape(3, 4)\n",
    "x6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**注意：reshape返回的是视图，而非副本**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 8, 5, 9, 2, 6, 2, 9, 4, 5, 1, 7])"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x6[0, 0] = 0\n",
    "x5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**一维向量转行向量**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 8, 5, 9, 2, 6, 2, 9, 4, 5, 1, 7]])"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x7 = x5.reshape(1, x5.shape[0])    \n",
    "x7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 8, 5, 9, 2, 6, 2, 9, 4, 5, 1, 7]])"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x8 = x5[np.newaxis, :]\n",
    "x8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**一维向量转列向量**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0],\n",
       "       [8],\n",
       "       [5],\n",
       "       [9],\n",
       "       [2],\n",
       "       [6],\n",
       "       [2],\n",
       "       [9],\n",
       "       [4],\n",
       "       [5],\n",
       "       [1],\n",
       "       [7]])"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x7 = x5.reshape(x5.shape[0], 1)    \n",
    "x7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0],\n",
       "       [8],\n",
       "       [5],\n",
       "       [9],\n",
       "       [2],\n",
       "       [6],\n",
       "       [2],\n",
       "       [9],\n",
       "       [4],\n",
       "       [5],\n",
       "       [1],\n",
       "       [7]])"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x8 = x5[:, np.newaxis]\n",
    "x8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**多维向量转一维向量**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3, 7, 6, 4],\n",
       "       [4, 5, 6, 3],\n",
       "       [7, 6, 2, 3]])"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x6 = np.random.randint(0, 10, (3, 4))\n",
    "x6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**flatten返回的是副本**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 7, 6, 4, 4, 5, 6, 3, 7, 6, 2, 3])"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x9 = x6.flatten()\n",
    "x9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3, 7, 6, 4],\n",
       "       [4, 5, 6, 3],\n",
       "       [7, 6, 2, 3]])"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x9[0]=0\n",
    "x6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**ravel返回的是视图**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 7, 6, 4, 4, 5, 6, 3, 7, 6, 2, 3])"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x10 = x6.ravel()\n",
    "x10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 7, 6, 4],\n",
       "       [4, 5, 6, 3],\n",
       "       [7, 6, 2, 3]])"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x10[0]=0\n",
    "x6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**reshape返回的是视图**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 7, 6, 4, 4, 5, 6, 3, 7, 6, 2, 3])"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x11 = x6.reshape(-1)\n",
    "x11"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10,  7,  6,  4],\n",
       "       [ 4,  5,  6,  3],\n",
       "       [ 7,  6,  2,  3]])"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x11[0]=10\n",
    "x6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 11.3.5 数组的拼接"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [],
   "source": [
    "x1 = np.array([[1, 2, 3],\n",
    "              [4, 5, 6]])\n",
    "x2 = np.array([[7, 8, 9],\n",
    "              [0, 1, 2]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1、水平拼接——非视图**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3, 7, 8, 9],\n",
       "       [4, 5, 6, 0, 1, 2]])"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x3 = np.hstack([x1, x2])\n",
    "x3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6]])"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x3[0][0] = 0\n",
    "x1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3, 7, 8, 9],\n",
       "       [4, 5, 6, 0, 1, 2]])"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x4 = np.c_[x1, x2]\n",
    "x4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6]])"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x4[0][0] = 0\n",
    "x1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2、垂直拼接——非视图**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "metadata": {},
   "outputs": [],
   "source": [
    "x1 = np.array([[1, 2, 3],\n",
    "              [4, 5, 6]])\n",
    "x2 = np.array([[7, 8, 9],\n",
    "              [0, 1, 2]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6],\n",
       "       [7, 8, 9],\n",
       "       [0, 1, 2]])"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x5 = np.vstack([x1, x2])\n",
    "x5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6],\n",
       "       [7, 8, 9],\n",
       "       [0, 1, 2]])"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x6 = np.r_[x1, x2]\n",
    "x6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 11.3.6 数组的分裂"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1、split的用法**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x6 = np.arange(10)\n",
    "x6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1] [2 3 4 5 6] [7 8 9]\n"
     ]
    }
   ],
   "source": [
    "x1, x2, x3 = np.split(x6, [2, 7])\n",
    "print(x1, x2, x3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2、hsplit的用法**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2,  3,  4,  5],\n",
       "       [ 6,  7,  8,  9, 10],\n",
       "       [11, 12, 13, 14, 15],\n",
       "       [16, 17, 18, 19, 20],\n",
       "       [21, 22, 23, 24, 25]])"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x7 = np.arange(1, 26).reshape(5, 5)\n",
    "x7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "left:\n",
      " [[ 1  2]\n",
      " [ 6  7]\n",
      " [11 12]\n",
      " [16 17]\n",
      " [21 22]]\n",
      "middle:\n",
      " [[ 3  4]\n",
      " [ 8  9]\n",
      " [13 14]\n",
      " [18 19]\n",
      " [23 24]]\n",
      "right:\n",
      " [[ 5]\n",
      " [10]\n",
      " [15]\n",
      " [20]\n",
      " [25]]\n"
     ]
    }
   ],
   "source": [
    "left, middle, right = np.hsplit(x7, [2,4])\n",
    "print(\"left:\\n\", left)            # 第0~1列\n",
    "print(\"middle:\\n\", middle)        # 第2~3列\n",
    "print(\"right:\\n\", right)          # 第4列"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**3、vsplit的用法**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2,  3,  4,  5],\n",
       "       [ 6,  7,  8,  9, 10],\n",
       "       [11, 12, 13, 14, 15],\n",
       "       [16, 17, 18, 19, 20],\n",
       "       [21, 22, 23, 24, 25]])"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x7 = np.arange(1, 26).reshape(5, 5)\n",
    "x7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "upper:\n",
      " [[ 1  2  3  4  5]\n",
      " [ 6  7  8  9 10]]\n",
      "middle:\n",
      " [[11 12 13 14 15]\n",
      " [16 17 18 19 20]]\n",
      "lower:\n",
      " [[21 22 23 24 25]]\n"
     ]
    }
   ],
   "source": [
    "upper, middle, lower = np.vsplit(x7, [2,4])\n",
    "print(\"upper:\\n\", upper)         # 第0~1行\n",
    "print(\"middle:\\n\", middle)       # 第2~3行\n",
    "print(\"lower:\\n\", lower)         # 第4行"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 11.4 Numpy四大运算"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 11.4.1 向量化运算"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1、与数字的加减乘除等**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5])"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x1 = np.arange(1,6)\n",
    "x1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x1+5 [ 6  7  8  9 10]\n",
      "x1-5 [-4 -3 -2 -1  0]\n",
      "x1*5 [ 5 10 15 20 25]\n",
      "x1/5 [0.2 0.4 0.6 0.8 1. ]\n"
     ]
    }
   ],
   "source": [
    "print(\"x1+5\", x1+5)\n",
    "print(\"x1-5\", x1-5)\n",
    "print(\"x1*5\", x1*5)\n",
    "print(\"x1/5\", x1/5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-x1 [-1 -2 -3 -4 -5]\n",
      "x1**2 [ 1  4  9 16 25]\n",
      "x1//2 [0 1 1 2 2]\n",
      "x1%2 [1 0 1 0 1]\n"
     ]
    }
   ],
   "source": [
    "print(\"-x1\", -x1)\n",
    "print(\"x1**2\", x1**2)\n",
    "print(\"x1//2\", x1//2)\n",
    "print(\"x1%2\", x1%2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2、绝对值、三角函数、指数、对数**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "（1）绝对值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, -1,  2, -2,  0])"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x2 = np.array([1, -1, 2, -2, 0])\n",
    "x2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 2, 2, 0])"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abs(x2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 2, 2, 0])"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.abs(x2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "（2）三角函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.        , 1.57079633, 3.14159265])"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "theta = np.linspace(0, np.pi, 3)\n",
    "theta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sin(theta) [0.0000000e+00 1.0000000e+00 1.2246468e-16]\n",
      "con(theta) [ 1.000000e+00  6.123234e-17 -1.000000e+00]\n",
      "tan(theta) [ 0.00000000e+00  1.63312394e+16 -1.22464680e-16]\n"
     ]
    }
   ],
   "source": [
    "print(\"sin(theta)\", np.sin(theta))\n",
    "print(\"con(theta)\", np.cos(theta))\n",
    "print(\"tan(theta)\", np.tan(theta))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "arcsin(x) [ 1.57079633  0.         -1.57079633]\n",
      "arccon(x) [0.         1.57079633 3.14159265]\n",
      "arctan(x) [ 0.78539816  0.         -0.78539816]\n"
     ]
    }
   ],
   "source": [
    "x = [1, 0 ,-1]\n",
    "print(\"arcsin(x)\", np.arcsin(x))\n",
    "print(\"arccon(x)\", np.arccos(x))\n",
    "print(\"arctan(x)\", np.arctan(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "（3）指数运算"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2])"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.arange(3)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.        , 2.71828183, 7.3890561 ])"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.exp(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "（4）对数运算"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ln(x) [0.         0.69314718 1.38629436 2.07944154 2.30258509]\n",
      "log2(x) [0.         1.         2.         3.         3.32192809]\n",
      "log10(x) [0.         0.30103    0.60205999 0.90308999 1.        ]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([1, 2, 4, 8 ,10])\n",
    "print(\"ln(x)\", np.log(x))\n",
    "print(\"log2(x)\", np.log2(x))\n",
    "print(\"log10(x)\", np.log10(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**3、两个数组的运算**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5])"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x1 = np.arange(1,6)\n",
    "x1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 6,  7,  8,  9, 10])"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x2 = np.arange(6,11)\n",
    "x2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x1+x2: [ 7  9 11 13 15]\n",
      "x1-x2: [-5 -5 -5 -5 -5]\n",
      "x1*x2: [ 6 14 24 36 50]\n",
      "x1/x2: [0.16666667 0.28571429 0.375      0.44444444 0.5       ]\n"
     ]
    }
   ],
   "source": [
    "print(\"x1+x2:\", x1+x2)\n",
    "print(\"x1-x2:\", x1-x2)\n",
    "print(\"x1*x2:\", x1*x2)\n",
    "print(\"x1/x2:\", x1/x2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 11.4.2 矩阵运算"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2],\n",
       "       [3, 4, 5],\n",
       "       [6, 7, 8]])"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.arange(9).reshape(3, 3)\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 矩阵的转置"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 3, 6],\n",
       "       [1, 4, 7],\n",
       "       [2, 5, 8]])"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = x.T\n",
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 矩阵乘法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "x = np.array([[1, 0],\n",
    "             [1, 1]])\n",
    "y = np.array([[0, 1],\n",
    "             [1, 1]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1],\n",
       "       [1, 2]])"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.dot(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1],\n",
       "       [1, 2]])"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(x, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 1],\n",
       "       [2, 1]])"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y.dot(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 1],\n",
       "       [2, 1]])"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(y, x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**注意跟x*y的区别**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 0],\n",
       "       [1, 1]])"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x*y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 11.4.3 广播运算"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2]])"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.arange(3).reshape(1, 3)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[5, 6, 7]])"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x+5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**规则**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "如果两个数组的形状在维度上不匹配\n",
    "  \n",
    "那么数组的形式会沿着维度为1的维度进行扩展以匹配另一个数组的形状。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1.],\n",
       "       [1., 1., 1.],\n",
       "       [1., 1., 1.]])"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x1 = np.ones((3,3))\n",
    "x1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2]])"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x2 = np.arange(3).reshape(1, 3)\n",
    "x2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 2., 3.],\n",
       "       [1., 2., 3.],\n",
       "       [1., 2., 3.]])"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x1+x2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[   2.,    4.,    8.,   16.,   32.],\n",
       "       [  64.,  128.,  256.,  512., 1024.]])"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x3 = np.logspace(1, 10, 10, base=2).reshape(2, 5)\n",
    "x3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2,  4,  8, 16]])"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x4 = np.array([[1, 2, 4, 8, 16]])\n",
    "x4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2.,  2.,  2.,  2.,  2.],\n",
       "       [64., 64., 64., 64., 64.]])"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x3/x4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0],\n",
       "       [1],\n",
       "       [2]])"
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x5 = np.arange(3).reshape(3, 1)\n",
    "x5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2]])"
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x6 = np.arange(3).reshape(1, 3)\n",
    "x6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2],\n",
       "       [1, 2, 3],\n",
       "       [2, 3, 4]])"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x5+x6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 11.4.4 比较运算和掩码"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1、比较运算**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[37, 44, 58, 79,  1, 24, 85, 90, 27, 56],\n",
       "       [74, 68, 88, 27, 46, 34, 92,  1, 35, 45],\n",
       "       [84, 80, 83, 72, 98, 15,  4, 77, 14, 98],\n",
       "       [19, 85, 98, 32, 47, 50, 73,  3, 24,  2],\n",
       "       [ 5, 28, 26, 31, 48, 43, 72, 73, 53, 64],\n",
       "       [81, 87, 56, 59, 24, 42, 84, 34, 97, 65],\n",
       "       [74,  9, 41, 54, 78, 62, 53, 49,  8, 70],\n",
       "       [63, 44, 33, 35, 26, 83,  7, 14, 65, 84],\n",
       "       [57, 10, 62,  8, 74, 47, 90, 25, 78, 48],\n",
       "       [36, 31, 45, 39, 66, 82, 42, 25, 33, 84]])"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x1 = np.random.randint(100, size=(10,10))\n",
    "x1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False, False,  True,  True, False, False,  True,  True, False,\n",
       "         True],\n",
       "       [ True,  True,  True, False, False, False,  True, False, False,\n",
       "        False],\n",
       "       [ True,  True,  True,  True,  True, False, False,  True, False,\n",
       "         True],\n",
       "       [False,  True,  True, False, False, False,  True, False, False,\n",
       "        False],\n",
       "       [False, False, False, False, False, False,  True,  True,  True,\n",
       "         True],\n",
       "       [ True,  True,  True,  True, False, False,  True, False,  True,\n",
       "         True],\n",
       "       [ True, False, False,  True,  True,  True,  True, False, False,\n",
       "         True],\n",
       "       [ True, False, False, False, False,  True, False, False,  True,\n",
       "         True],\n",
       "       [ True, False,  True, False,  True, False,  True, False,  True,\n",
       "        False],\n",
       "       [False, False, False, False,  True,  True, False, False, False,\n",
       "         True]])"
      ]
     },
     "execution_count": 157,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x1 > 50"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2、操作布尔数组**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 4, 2, 9],\n",
       "       [8, 8, 2, 4],\n",
       "       [9, 5, 3, 6]])"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x2 = np.random.randint(10, size=(3, 4))\n",
    "x2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[False False False  True]\n",
      " [ True  True False False]\n",
      " [ True False False  True]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(x2 > 5)\n",
    "np.sum(x2 > 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 160,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.all(x2 > 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.any(x2 == 6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False,  True, False])"
      ]
     },
     "execution_count": 163,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.all(x2 < 9, axis=1)   # 按行进行判断"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 4, 2, 9],\n",
       "       [8, 8, 2, 4],\n",
       "       [9, 5, 3, 6]])"
      ]
     },
     "execution_count": 164,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False, False, False, False],\n",
       "       [ True,  True, False, False],\n",
       "       [False, False, False,  True]])"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(x2 < 9) & (x2 >5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 166,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum((x2 < 9) & (x2 >5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**3、将布尔数组作为掩码**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 4, 2, 9],\n",
       "       [8, 8, 2, 4],\n",
       "       [9, 5, 3, 6]])"
      ]
     },
     "execution_count": 167,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False, False, False,  True],\n",
       "       [ True,  True, False, False],\n",
       "       [ True, False, False,  True]])"
      ]
     },
     "execution_count": 168,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x2 > 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([9, 8, 8, 9, 6])"
      ]
     },
     "execution_count": 169,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x2[x2 > 5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 11.4.5  花哨的索引"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**1、一维数组**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([43, 69, 67,  9, 11, 27, 55, 93, 23, 82])"
      ]
     },
     "execution_count": 170,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.random.randint(100, size=10)\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**注意：结果的形状与索引数组ind一致**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([67, 55, 82])"
      ]
     },
     "execution_count": 171,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ind = [2, 6, 9]\n",
    "x[ind]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[69, 43],\n",
       "       [67,  9]])"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ind = np.array([[1, 0],\n",
    "               [2, 3]])\n",
    "x[ind]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**2、多维数组**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3],\n",
       "       [ 4,  5,  6,  7],\n",
       "       [ 8,  9, 10, 11]])"
      ]
     },
     "execution_count": 173,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.arange(12).reshape(3, 4)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 7, 8])"
      ]
     },
     "execution_count": 174,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "row = np.array([0, 1, 2])\n",
    "col = np.array([1, 3, 0])\n",
    "x[row, col]               # x(0, 1) x(1, 3) x(2, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0],\n",
       "       [1],\n",
       "       [2]])"
      ]
     },
     "execution_count": 175,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "row[:, np.newaxis]       # 列向量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  3,  0],\n",
       "       [ 5,  7,  4],\n",
       "       [ 9, 11,  8]])"
      ]
     },
     "execution_count": 176,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[row[:, np.newaxis], col]    # 广播机制"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 11.5 其他Numpy通用函数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 11.5.1  数值排序"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 402,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([48, 27, 44, 24, 34, 21, 24, 30, 34, 46])"
      ]
     },
     "execution_count": 402,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.random.randint(20, 50, size=10)\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 产生新的排序数组"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 403,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([21, 24, 24, 27, 30, 34, 34, 44, 46, 48])"
      ]
     },
     "execution_count": 403,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sort(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 404,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([48, 27, 44, 24, 34, 21, 24, 30, 34, 46])"
      ]
     },
     "execution_count": 404,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 替换原数组"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 406,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([21, 24, 24, 27, 30, 34, 34, 44, 46, 48])"
      ]
     },
     "execution_count": 406,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.sort()\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 获得排序索引"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 407,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([27, 36, 35, 28, 34, 20, 21, 49, 48, 30])"
      ]
     },
     "execution_count": 407,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.random.randint(20, 50, size=10)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 409,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5, 6, 0, 3, 9, 4, 2, 1, 8, 7], dtype=int64)"
      ]
     },
     "execution_count": 409,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "i = np.argsort(x)\n",
    "i"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 11.5.2  最大最小值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 411,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([48, 31, 30, 44, 48, 33, 44, 48, 39, 35])"
      ]
     },
     "execution_count": 411,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.random.randint(20, 50, size=10)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 413,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "max: 48\n",
      "min: 30\n"
     ]
    }
   ],
   "source": [
    "print(\"max:\", np.max(x))\n",
    "print(\"min:\", np.min(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 414,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "max_index: 0\n",
      "min_index: 2\n"
     ]
    }
   ],
   "source": [
    "print(\"max_index:\", np.argmax(x))\n",
    "print(\"min_index:\", np.argmin(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 11.5.3  数值求和、求积"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5])"
      ]
     },
     "execution_count": 183,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.arange(1,6)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 417,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 417,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 419,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 419,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2],\n",
       "       [3, 4, 5]])"
      ]
     },
     "execution_count": 177,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x1 = np.arange(6).reshape(2,3)\n",
    "x1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 按行求和"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 3, 12])"
      ]
     },
     "execution_count": 178,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(x1, axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 按列求和"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 5, 7])"
      ]
     },
     "execution_count": 179,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(x1, axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 全体求和"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 181,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sum(x1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 求积"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5])"
      ]
     },
     "execution_count": 184,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 420,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "120"
      ]
     },
     "execution_count": 420,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.prod()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 421,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "120"
      ]
     },
     "execution_count": 421,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.prod(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 11.5.4  中位数、均值、方差、标准差"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 424,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "x = np.random.normal(0, 1, size=10000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 425,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "plt.hist(x, bins=50)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 中位数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 427,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-0.01024418366119727"
      ]
     },
     "execution_count": 427,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.median(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 均值"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 428,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-0.004164442327293362"
      ]
     },
     "execution_count": 428,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 430,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-0.004164442327293362"
      ]
     },
     "execution_count": 430,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.mean(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 方差"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 431,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0221853234535774"
      ]
     },
     "execution_count": 431,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.var()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 432,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0221853234535774"
      ]
     },
     "execution_count": 432,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.var(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* 标准差"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 433,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0110318112965473"
      ]
     },
     "execution_count": 433,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x.std()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 434,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0110318112965473"
      ]
     },
     "execution_count": 434,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.std(x)"
   ]
  }
 ],
 "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
}