3.numpy数组操作.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[上一章:2.numpy数组创建](./2.numpy数组创建.md)\n",
    "\n",
    "# numpy数组操作\n",
    "\n",
    "主要包含\n",
    "\n",
    "数组形变\n",
    "- `ndarray.reshape()`: 可以改变数组的形状，一维变二维，二维变一维等等\n",
    "- `ndarray.T`: 数组转置\n",
    "- `ndarray.ravel()`: 拉直数组，多维数组变成一维\n",
    "\n",
    ">提示\n",
    ">\n",
    ">`ndarray`表示某个数组对象，比如之前创建的`a=np.array([0, 1, 2, 3])`\n",
    ">\n",
    ">数组`a`就是一个`ndarray`对象，它可以执行`a.reshape(...)`或`a.T`等操作\n",
    "\n",
    "数组拼接\n",
    "- `np.concatenate()`: 数组拼接，可以选择特定的轴进行数组拼接\n",
    "- `np.hstack()`: 数组横向拼接\n",
    "- `np.vstack()`: 数组纵向拼接\n",
    "\n",
    "数组拆分\n",
    "- `np.hsplit()`: 数组横向拆分\n",
    "- `np.vsplit()`: 数组纵向拆分\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](./images/3.numpy数组操作_思维导图1.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-01T01:08:16.910527Z",
     "start_time": "2021-12-01T01:08:16.753946Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.22.3\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "print(np.__version__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 数组形变\n",
    "\n",
    "改变数组的形状，数组的`.shape`属性会发生变化\n",
    "\n",
    "- `ndarray.reshape()`: 改变数组的形状\n",
    "- `ndarray.T`: 数组转置\n",
    "- `ndarray.ravel()`: 拉直数组"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ndarray.reshape()\n",
    ":book:[官方文档](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.reshape.html#numpy.ndarray.reshape)\n",
    "\n",
    "```python\n",
    "numpy.reshape(shape)\n",
    "```\n",
    "\n",
    "可以改变数组的形状，一维变二维，二维变一维等等。具体用法如下"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "一维数组变二维数组"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-30T07:48:53.674432Z",
     "start_time": "2021-11-30T07:48:53.665459Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1],\n",
       "       [2, 3]])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([0, 1, 2, 3])\n",
    "a.reshape(2, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`shape`参数也可以用`-1`表示自动计算应该填的数值，最多只能有一个位置使用`-1`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-30T07:49:09.011407Z",
     "start_time": "2021-11-30T07:49:09.004431Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1],\n",
       "       [2, 3]])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.reshape((-1, 2))  # 同a.reshape((2, 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](./images/3.numpy数组操作_数组变形1.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "二维数组变一维数组"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-30T07:48:54.751459Z",
     "start_time": "2021-11-30T07:48:54.745445Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = np.array([[0, 1],\n",
    "              [2, 3]])\n",
    "b.reshape(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-30T07:49:09.821888Z",
     "start_time": "2021-11-30T07:49:09.815874Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.reshape(-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](./images/3.numpy数组操作_数组变形2.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "使用`np.arange()`加`reshape()`的方式可以比[numpy数组初识](./基础_numpy数组初识.md)一节中更方便地创建数组\n",
    "\n",
    "快速创建二维数组"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-30T07:50:24.323938Z",
     "start_time": "2021-11-30T07:50:24.315953Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3],\n",
       "       [ 4,  5,  6,  7],\n",
       "       [ 8,  9, 10, 11]])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(12).reshape(3, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "也可以便捷地生成三维数组"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-30T07:51:01.399262Z",
     "start_time": "2021-11-30T07:51:01.389261Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0,  1,  2,  3],\n",
       "        [ 4,  5,  6,  7],\n",
       "        [ 8,  9, 10, 11]],\n",
       "\n",
       "       [[12, 13, 14, 15],\n",
       "        [16, 17, 18, 19],\n",
       "        [20, 21, 22, 23]],\n",
       "\n",
       "       [[24, 25, 26, 27],\n",
       "        [28, 29, 30, 31],\n",
       "        [32, 33, 34, 35]]])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(36).reshape(3, 3, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](./images/3.numpy数组操作_数组变形3.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ndarray.T\n",
    ":book:[官方文档](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.T.html)\n",
    "\n",
    "数组转置，线性代数中经常使用。不过对一维数组没有效果，一般多用于二维数组"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-30T07:54:30.239667Z",
     "start_time": "2021-11-30T07:54:30.233683Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(4)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-30T07:54:30.607902Z",
     "start_time": "2021-11-30T07:54:30.600930Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-30T07:54:44.527788Z",
     "start_time": "2021-11-30T07:54:44.521808Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2],\n",
       "       [3, 4, 5]])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = np.arange(6).reshape(2, 3)\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-30T07:54:47.057918Z",
     "start_time": "2021-11-30T07:54:47.051933Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 3],\n",
       "       [1, 4],\n",
       "       [2, 5]])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.T"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](./images/3.numpy数组操作_数组变形4.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### ndarray.ravel()\n",
    ":book:[官方文档](https://numpy.org/doc/stable/reference/generated/numpy.ndarray.ravel.html)\n",
    "\n",
    "```python\n",
    "numpy.ravel()\n",
    "```\n",
    "\n",
    "可以将多维数组拉平成一维数组"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "二维数组拉成一维数组"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-30T07:58:50.807742Z",
     "start_time": "2021-11-30T07:58:50.801729Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2],\n",
       "       [3, 4, 5]])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = np.arange(6).reshape(2, 3)\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-30T07:58:51.049669Z",
     "start_time": "2021-11-30T07:58:51.042688Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.ravel()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "三维数组拉成一维数组"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-30T07:59:17.961908Z",
     "start_time": "2021-11-30T07:59:17.955925Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0,  1,  2],\n",
       "        [ 3,  4,  5]],\n",
       "\n",
       "       [[ 6,  7,  8],\n",
       "        [ 9, 10, 11]]])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = np.arange(12).reshape(2, 2, 3)\n",
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-30T07:59:20.985109Z",
     "start_time": "2021-11-30T07:59:20.978124Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c.ravel()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](./images/3.numpy数组操作_数组变形5.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 数组拼接\n",
    "\n",
    "将多个相同维度的数组拼接起来\n",
    "\n",
    "- `np.concatenate()`: 数组拼接，可以选择特定的轴进行数组拼接\n",
    "- `np.hstack()`: 数组横向拼接\n",
    "- `np.vstack()`: 数组纵向拼接"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### np.concatenate()\n",
    ":book:[官方文档](https://numpy.org/doc/stable/reference/generated/numpy.concatenate.html)\n",
    "\n",
    "```python\n",
    "numpy.concatenate((a1, a2, ...), axis=0, ...)\n",
    "```\n",
    "\n",
    "数组拼接\n",
    "\n",
    "- `(a1, a2, ...)`: 要拼接的多个数组，用`()`或`[]`包起来再传给`np.concatenate`\n",
    "- `axis`: 沿哪个轴拼接，默认沿`axis=0`的方向拼接数组，一维数组只能沿`axis=0`的方向拼接，二维数组可以沿`axis=0`或`axis=1`的方向拼接，以此类推\n",
    "\n",
    "> 回忆之前的**右下里，依次递减**原则\n",
    ">\n",
    "> 如果是二维数组：\n",
    "> - 最高维是`axis=1`，方向**向右**。\n",
    "> - 第二维是`axis=0`，方向**向下**。\n",
    ">\n",
    "> 如果是三维数组：\n",
    "> - 最高维是`axis=2`，方向**向右**。\n",
    "> - 第二维是`axis=1`，方向**向下**。\n",
    "> - 第三维是`axis=0`，方向**向里**。\n",
    "\n",
    "> 注意\n",
    ">\n",
    ">`np.concatenate`、`np.hstack()`、`np.vstack`均**只能在维度相同的数组之间进行拼接**\n",
    ">\n",
    ">比如一维数组和一维数组拼接，二维数组和二维数组拼接\n",
    ">\n",
    ">**不能用一维数组和二维数组拼接**。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "拼接多个一维数组，默认是沿`axis=0`的方向拼接数组\n",
    "\n",
    "一维数组的话就是向右拼接"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-30T08:33:59.051247Z",
     "start_time": "2021-11-30T08:33:59.044266Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a1 = np.array([0, 1])\n",
    "a2 = np.array([2, 3, 4])\n",
    "a3 = np.array([5])\n",
    "\n",
    "np.concatenate((a1, a2, a3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](./images/3.numpy数组操作_数组拼接1.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "沿`axis=0`拼接二维数组，**方向向下**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-30T08:33:59.950994Z",
     "start_time": "2021-11-30T08:33:59.945036Z"
    }
   },
   "outputs": [],
   "source": [
    "b1 = np.arange(6).reshape(2, 3)\n",
    "b2 = np.arange(6, 12).reshape(2, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 2],\n",
       "       [3, 4, 5]])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 6,  7,  8],\n",
       "       [ 9, 10, 11]])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2],\n",
       "       [ 3,  4,  5],\n",
       "       [ 6,  7,  8],\n",
       "       [ 9, 10, 11]])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.concatenate((b1, b2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](./images/3.numpy数组操作_数组拼接2.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "沿`axis=1`拼接二维数组"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-30T08:34:08.136282Z",
     "start_time": "2021-11-30T08:34:08.129299Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  6,  7,  8],\n",
       "       [ 3,  4,  5,  9, 10, 11]])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.concatenate((b1, b2), axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](./images/3.numpy数组操作_数组拼接3.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "沿`axis=0`拼接三维数组，**方向向里**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-30T08:44:01.178162Z",
     "start_time": "2021-11-30T08:44:01.169183Z"
    }
   },
   "outputs": [],
   "source": [
    "c1 = np.arange(8).reshape(2,2,2)\n",
    "c2 = np.arange(8, 16).reshape(2,2,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[0, 1],\n",
       "        [2, 3]],\n",
       "\n",
       "       [[4, 5],\n",
       "        [6, 7]]])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 8,  9],\n",
       "        [10, 11]],\n",
       "\n",
       "       [[12, 13],\n",
       "        [14, 15]]])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0,  1],\n",
       "        [ 2,  3]],\n",
       "\n",
       "       [[ 4,  5],\n",
       "        [ 6,  7]],\n",
       "\n",
       "       [[ 8,  9],\n",
       "        [10, 11]],\n",
       "\n",
       "       [[12, 13],\n",
       "        [14, 15]]])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.concatenate((c1, c2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](./images/3.numpy数组操作_数组拼接4.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "沿`axis=1`拼接三维数组，**方向向下**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-30T08:44:29.626370Z",
     "start_time": "2021-11-30T08:44:29.618391Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0,  1],\n",
       "        [ 2,  3],\n",
       "        [ 8,  9],\n",
       "        [10, 11]],\n",
       "\n",
       "       [[ 4,  5],\n",
       "        [ 6,  7],\n",
       "        [12, 13],\n",
       "        [14, 15]]])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.concatenate((c1, c2), axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](./images/3.numpy数组操作_数组拼接5.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "沿`axis=2`拼接三维数组，**方向向右**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-30T08:44:37.272482Z",
     "start_time": "2021-11-30T08:44:37.264502Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0,  1,  8,  9],\n",
       "        [ 2,  3, 10, 11]],\n",
       "\n",
       "       [[ 4,  5, 12, 13],\n",
       "        [ 6,  7, 14, 15]]])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.concatenate((c1, c2), axis=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](./images/3.numpy数组操作_数组拼接6.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### np.hstack()\n",
    ":book:[官方文档](https://numpy.org/doc/stable/reference/generated/numpy.hstack.html)\n",
    "\n",
    "```python\n",
    "numpy.hstack((a1, a2, ...))\n",
    "```\n",
    "\n",
    "数组拼接\n",
    "\n",
    "- `(a1, a2, ...)`: 要拼接的多个数组\n",
    "\n",
    "其实这个跟`np.concatenate()`类似，只是该方法不能选择拼接哪个轴。\n",
    "\n",
    "hstack的完整版就是: Stack arrays in sequence horizontally\n",
    "\n",
    "翻译一下就是沿水平方向（横向）拼接数组。\n",
    "\n",
    ">注意\n",
    ">\n",
    ">个人建议**只在一、二维数组拼接的时候应用这个函数**。\n",
    ">\n",
    ">展现的效果和该方法字面意义一致。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "一维数组横向拼接，与直接使用`np.concatenate()`的效果一致"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-30T08:41:26.807221Z",
     "start_time": "2021-11-30T08:41:26.800237Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a1 = np.array([0, 1])\n",
    "a2 = np.array([2, 3, 4])\n",
    "a3 = np.array([5])\n",
    "\n",
    "np.hstack((a1, a2, a3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](./images/3.numpy数组操作_np.hstack1.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "二维数组拼接，效果与`np.concatenate()`沿`axis=1`拼接数组时一致"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-30T08:42:15.608850Z",
     "start_time": "2021-11-30T08:42:15.600871Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  6,  7,  8],\n",
       "       [ 3,  4,  5,  9, 10, 11]])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b1 = np.arange(6).reshape(2, 3)\n",
    "b2 = np.arange(6, 12).reshape(2, 3)\n",
    "\n",
    "np.hstack((b1, b2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](./images/3.numpy数组操作_np.hstack2.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "三维数组拼接，效果与`np.concatenate()`沿`axis=1`拼接数组时一致\n",
    "\n",
    "但是不符合函数名横向拼接的含义。\n",
    "\n",
    "所以不建议`np.hstack`在三维数组使用\n",
    "\n",
    "可以把该函数理解为：\n",
    "- 始终沿`axis=1`的方向拼接数组\n",
    "- 如果是一维数组，就沿`axis=0`的方向拼接"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-30T08:43:14.307933Z",
     "start_time": "2021-11-30T08:43:14.300949Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0,  1],\n",
       "        [ 2,  3],\n",
       "        [ 8,  9],\n",
       "        [10, 11]],\n",
       "\n",
       "       [[ 4,  5],\n",
       "        [ 6,  7],\n",
       "        [12, 13],\n",
       "        [14, 15]]])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c1 = np.arange(8).reshape(2,2,2)\n",
    "c2 = np.arange(8, 16).reshape(2,2,2)\n",
    "\n",
    "np.hstack((c1, c2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](./images/3.numpy数组操作_np.hstack3.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### np.vstack()\n",
    ":book:[官方文档](https://numpy.org/doc/stable/reference/generated/numpy.vstack.html)\n",
    "\n",
    "```python\n",
    "numpy.vstack((a1, a2, ...))\n",
    "```\n",
    "\n",
    "数组拼接\n",
    "\n",
    "- `(a1, a2, ...)`: 要拼接的多个数组\n",
    "\n",
    "**纵向**拼接数组，分别以一维、二维、三维数组举例。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "一维数组拼接\n",
    "\n",
    "> 提示\n",
    ">\n",
    ">`np.vstack`与`np.concatenate`和`np.hstack`的差异：\n",
    ">- 用`np.vstack`拼接一维数组输出的结果是一个二维数组。而用`np.concatenate`或`np.hstack`拼接一维数组输出的结果还是一维数组\n",
    ">- `np.vstack`只能拼接**长度相同**的一维数组\n",
    ">\n",
    ">同样：建议只在一、二维数组上使用`np.vstack`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-30T08:55:40.833202Z",
     "start_time": "2021-11-30T08:55:40.825192Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1],\n",
       "       [2, 3],\n",
       "       [4, 5]])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a1 = np.array([0, 1])\n",
    "a2 = np.array([2, 3])\n",
    "a3 = np.array([4, 5])\n",
    "\n",
    "np.vstack((a1, a2, a3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](./images/3.numpy数组操作_np.vstack1.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "二维数组拼接，输出与`np.concatenate()`沿`axis=0`拼接数组时一致"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-30T08:55:41.872320Z",
     "start_time": "2021-11-30T08:55:41.865366Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2],\n",
       "       [ 3,  4,  5],\n",
       "       [ 6,  7,  8],\n",
       "       [ 9, 10, 11]])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b1 = np.arange(6).reshape(2, 3)\n",
    "b2 = np.arange(6, 12).reshape(2, 3)\n",
    "\n",
    "np.vstack((b1, b2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](./images/3.numpy数组操作_np.vstack2.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "三维数组拼接，输出与`np.concatenate()`沿`axis=0`拼接数组时一致"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-11-30T08:55:42.767331Z",
     "start_time": "2021-11-30T08:55:42.761317Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 0,  1],\n",
       "        [ 2,  3]],\n",
       "\n",
       "       [[ 4,  5],\n",
       "        [ 6,  7]],\n",
       "\n",
       "       [[ 8,  9],\n",
       "        [10, 11]],\n",
       "\n",
       "       [[12, 13],\n",
       "        [14, 15]]])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c1 = np.arange(8).reshape(2,2,2)\n",
    "c2 = np.arange(8, 16).reshape(2,2,2)\n",
    "\n",
    "np.vstack((c1, c2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](./images/3.numpy数组操作_np.vstack3.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 小结\n",
    "\n",
    "- `np.concatenate`可以沿数组不同的方向进行拼接。\n",
    "- `np.hstack`对于二维及以上的数组，总是沿着`axis=1`的方向进行拼接。\n",
    "- `np.vstack`对于二维及以上的数组，总是沿着`axis=0`的方向进行拼接。\n",
    "- `np.vstack`只能拼接长度相同的一维数组。\n",
    "- `np.vstack`拼接一维数组后输出的结果是一个二维数组"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 数组拆分\n",
    "\n",
    "数组拼接的反向操作\n",
    "\n",
    "- `np.hsplit()`: 数组横向拆分\n",
    "- `np.vsplit()`: 数组纵向拆分\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### np.hsplit()\n",
    ":book:[官方文档](https://numpy.org/doc/stable/reference/generated/numpy.hsplit.html)\n",
    "\n",
    "```python\n",
    "numpy.hspilt(ary, indices_or_sections)\n",
    "```\n",
    "\n",
    "按列拆分数组（始终按`axis=1`的方向拆分数组，当数组是二维数组时，`axis=1`就表示列）\n",
    "\n",
    "- `ary`: 要拆分的数组\n",
    "- `indices_or_sections`: 拆分方式，如果传入整数。就会均匀拆分，比如一个n行6列的数组，`indices_or_sections=2`时会把数组拆分成两个n行3列的新数组，`indices_or_sectioons=3`时会拆分成3个n行2列的新数组。\n",
    "\n",
    ">提示\n",
    ">\n",
    ">也可以采用非均匀的拆分方式，基础教程暂不涉及。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "拆分一维数组"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-01T01:08:33.671192Z",
     "start_time": "2021-12-01T01:08:33.664226Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(4)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-01T01:08:34.119393Z",
     "start_time": "2021-12-01T01:08:34.113409Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[array([0, 1]), array([2, 3])]"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.hsplit(a, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "拆分二维数组"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-01T01:08:47.262882Z",
     "start_time": "2021-12-01T01:08:47.256899Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3],\n",
       "       [ 4,  5,  6,  7],\n",
       "       [ 8,  9, 10, 11]])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = np.arange(12).reshape(3, 4)\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-01T01:08:47.766307Z",
     "start_time": "2021-12-01T01:08:47.756333Z"
    }
   },
   "outputs": [],
   "source": [
    "b1, b2 = np.hsplit(b, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1],\n",
       "       [4, 5],\n",
       "       [8, 9]])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2,  3],\n",
       "       [ 6,  7],\n",
       "       [10, 11]])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](./images/3.numpy数组操作_np.hsplit1.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### np.vsplit()\n",
    ":book:[官方文档](https://numpy.org/doc/stable/reference/generated/numpy.vsplit.html)\n",
    "\n",
    "```python\n",
    "numpy.vspilt(ary, indices_or_sections)\n",
    "```\n",
    "\n",
    "按行拆分数组（始终按`axis=0`的方向拆分数组，当数组是二维数组时，`axis=0`就表示行）\n",
    "\n",
    "- `ary`: 要拆分的数组\n",
    "- `indices_or_sections`: 拆分方式，如果传入整数。就会均匀拆分，比如一个6行m列的数组，`indices_or_sections=2`时会把数组拆分成两个3行m列的新数组，`indices_or_sectioons=3`时会拆分成3个2行m列的新数组。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">注意\n",
    ">\n",
    ">`np.vsplit`无法拆分一维数组"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "拆分二维数组"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-01T01:11:51.351418Z",
     "start_time": "2021-12-01T01:11:51.345456Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1],\n",
       "       [ 2,  3],\n",
       "       [ 4,  5],\n",
       "       [ 6,  7],\n",
       "       [ 8,  9],\n",
       "       [10, 11]])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = np.arange(12).reshape(6, 2)\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-01T01:11:52.710092Z",
     "start_time": "2021-12-01T01:11:52.705104Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1],\n",
       "       [2, 3],\n",
       "       [4, 5]])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b1, b2 = np.vsplit(b, 2)\n",
    "b1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 6,  7],\n",
       "       [ 8,  9],\n",
       "       [10, 11]])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2021-12-01T01:11:53.566924Z",
     "start_time": "2021-12-01T01:11:53.560909Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1],\n",
       "       [2, 3]])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b1, b2, b3 = np.vsplit(b, 3)\n",
    "b1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[4, 5],\n",
       "       [6, 7]])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 8,  9],\n",
       "       [10, 11]])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](./images/3.numpy数组操作_np.vsplit1.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 小结\n",
    "\n",
    "![](./images/3.numpy数组操作_思维导图2.png)\n",
    "\n",
    "[下一章:4.numpy数组索引](./4.numpy数组索引.md)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.8.5"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}