python/2-numpy基础.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1、numpy属性\n",
    "创建一个numpy数组，并查看它的维度、形状、大小和类型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n"
     ]
    }
   ],
   "source": [
    "array = np.array([[1,2,3],[4,5,6],[7,8,9]])\n",
    "print(array)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "nature = {'维度':array.ndim, '形状':array.shape, '大小':array.size, '类型':array.dtype}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'维度': 2, '形状': (3, 3), '大小': 9, '类型': dtype('int32')}\n"
     ]
    }
   ],
   "source": [
    "print(nature)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2、创建数组\n",
    "可以通过dtype参数控制数组类型，形如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "float64\n"
     ]
    }
   ],
   "source": [
    "a = np.array([1,2,3],dtype=np.float)\n",
    "print(a.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "通过`np.zeros()`创建一个2行3列的全0矩阵，形如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0. 0.]\n",
      " [0. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "zero = np.zeros((2,3)) #生成2行3列全为0的矩阵\n",
    "print(zero)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "通过`np.ones()`创建一个3行4列全为1的矩阵，形如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 1. 1. 1.]\n",
      " [1. 1. 1. 1.]\n",
      " [1. 1. 1. 1.]]\n"
     ]
    }
   ],
   "source": [
    "one = np.ones((3,4)) #生成3行4列全为1的矩阵\n",
    "print(one)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "通过`np.arange()`创建一个等差数组，并通过参数控制起始值、结束值和间距值，形如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nd1: [0 1 2 3 4 5 6 7 8 9] (10,) \n",
      "nd2: [ 4  5  6  7  8  9 10 11] (8,) \n",
      "nd2: [ 1  4  7 10 13 16 19 22] (8,)\n"
     ]
    }
   ],
   "source": [
    "nd1 = np.arange(10)\n",
    "nd2 = np.arange(4, 12)\n",
    "nd3 = np.arange(1, 24, 3)\n",
    "print('nd1:', nd1, nd1.shape, '\\nnd2:', nd2, nd2.shape, '\\nnd2:', nd3, nd3.shape,)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "通过`np.reshape()`重新定义nd1矩阵的形状为5行2列，形如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1]\n",
      " [2 3]\n",
      " [4 5]\n",
      " [6 7]\n",
      " [8 9]]\n"
     ]
    }
   ],
   "source": [
    "h = nd1.reshape(5,2)#重新定义矩阵的形状\n",
    "print(h)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3、numpy矩阵的运算\n",
    "创建两个numpy矩阵arr1和arr2："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n",
      "[[1 1 2]\n",
      " [2 3 3]]\n"
     ]
    }
   ],
   "source": [
    "arr1 = np.array([[1,2,3], [4,5,6]])\n",
    "arr2 = np.array([[1,1,2], [2,3,3]])\n",
    "print(arr1)\n",
    "print(arr2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "矩阵加法、减法、乘法（点乘）、除法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2 3 5]\n",
      " [6 8 9]]\n"
     ]
    }
   ],
   "source": [
    "print(arr1 + arr2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1 1]\n",
      " [2 2 3]]\n"
     ]
    }
   ],
   "source": [
    "print(arr1 - arr2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  6]\n",
      " [ 8 15 18]]\n"
     ]
    }
   ],
   "source": [
    "print(arr1 * arr2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.         2.         1.5       ]\n",
      " [2.         1.66666667 2.        ]]\n"
     ]
    }
   ],
   "source": [
    "print(arr1 / arr2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "矩阵的幂、求商、求余、"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[  1   2   9]\n",
      " [ 16 125 216]]\n"
     ]
    }
   ],
   "source": [
    "print(arr1 ** arr2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 1]\n",
      " [2 1 2]]\n"
     ]
    }
   ],
   "source": [
    "print(arr1 // arr2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 0 1]\n",
      " [0 2 0]]\n"
     ]
    }
   ],
   "source": [
    "print(arr1 % arr2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "矩阵逻辑运算，判断哪些值大于3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[False False False]\n",
      " [ True  True  True]]\n"
     ]
    }
   ],
   "source": [
    "print(arr1>3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "矩阵叉乘，通过`np.dot()`实现，其中arr1为2\\*3，arr3为3\\*2："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 6.,  6.],\n",
       "       [15., 15.]])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr3 = np.ones((3,2))\n",
    "np.dot(arr1,arr3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 6.,  6.],\n",
       "       [15., 15.]])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr1.dot(arr3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "矩阵转置，通过'np.transpose()'或'.T'实现："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 4]\n",
      " [2 5]\n",
      " [3 6]]\n"
     ]
    }
   ],
   "source": [
    "print(arr1.T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4、随机数与矩阵操作\n",
    "随机数通过`np.random`类下的函数实现，包括纯随机数、正态分布随机数、随机整数等等，例如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sample1: [[0.20851764 0.65305927]\n",
      " [0.11839854 0.1234624 ]\n",
      " [0.47173529 0.70418576]]\n",
      "sample2: [[ 0.19993282  0.71223613 -0.25105548  0.22952161 -1.05439482 -1.20315699\n",
      "   0.7119116  -0.93046797  0.74426924 -1.26174009]]\n",
      "sample3: [[5 4]\n",
      " [1 3]\n",
      " [3 4]]\n"
     ]
    }
   ],
   "source": [
    "sample1 = np.random.random((3,2)) #生成3行2列从0到1的随机数\n",
    "sample2 = np.random.normal(size=(1,10)) #生成3行2列符合标准正态分布的随机数\n",
    "sample3 = np.random.randint(0,10,size=(3,2)) #生成3行2列从0到10的随机整数\n",
    "print('sample1:',sample1)\n",
    "print('sample2:',sample2)\n",
    "print('sample3:',sample3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "求和，通过`np.sum()`实现，其中`axis`参数可以控制对行或列分别求和，例如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.2793589060465207\n",
      "[0.79865147 1.48070743]\n",
      "[0.86157691 0.24186094 1.17592105]\n"
     ]
    }
   ],
   "source": [
    "print(np.sum(sample1)) #对所有元素求和\n",
    "print(np.sum(sample1,axis=0)) #对所有列求和\n",
    "print(np.sum(sample1,axis=1)) #对所有行求和"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "求最大值、最小值、最大值索引、最小值索引："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.7041857595234023\n",
      "5\n",
      "0.11839853738313877\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "print(np.max(sample1)) #求最大值\n",
    "print(np.argmax(sample1)) #求最大值的索引\n",
    "print(np.min(sample1)) #求最小值\n",
    "print(np.argmin(sample1)) #求最小值的索引"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "求平均值、中位数：`np.mean()`、`np.median()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.37989315100775345\n",
      "0.34012646802999585\n"
     ]
    }
   ],
   "source": [
    "print(np.mean(sample1)) #求平均值\n",
    "print(np.median(sample1)) #求中位数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "排序，通过`np.srot()`函数实现，例如："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[7 0 9 1 6 9 0 0 2 4]]\n",
      "[[0 0 0 1 2 4 6 7 9 9]]\n"
     ]
    }
   ],
   "source": [
    "sample4 = np.random.randint(0,10,size=(1,10))\n",
    "print(sample4)\n",
    "print(np.sort(sample4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "设定最小和最大阈值，小于或大于该数就直接替换："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[7 0 9 1 6 9 0 0 2 4]]\n",
      "[[7 2 7 2 6 7 2 2 2 4]]\n"
     ]
    }
   ],
   "source": [
    "print(sample4)\n",
    "print(np.clip(sample4,2,7))#小于2就变成2，大于7就变为7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5、numpy的索引"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 2  3  4  5  6  7  8  9 10 11 12 13]\n"
     ]
    }
   ],
   "source": [
    "arr1 = np.arange(2,14)\n",
    "print(arr1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "按位置进行索引："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "[3 4 5]\n",
      "[ 4  5  6  7  8  9 10 11 12]\n",
      "[2 3 4 5 6]\n",
      "[12 13]\n",
      "[3 5 5 6 7]\n"
     ]
    }
   ],
   "source": [
    "print(arr1[2]) #第二个位置的数据\n",
    "print(arr1[1:4]) #第一到第四个位置的数据\n",
    "print(arr1[2:-1]) #第二到倒数第一个位置的数据\n",
    "print(arr1[:5]) #前五个数据\n",
    "print(arr1[-2:]) #最后两个数据\n",
    "index = [1,3,3,4,5]\n",
    "print(arr1[index]) #按照索引列表进行索引"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "二维数组的索引："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 2  3  4  5]\n",
      " [ 6  7  8  9]\n",
      " [10 11 12 13]]\n"
     ]
    }
   ],
   "source": [
    "arr2 = arr1.reshape(3,4)\n",
    "print(arr2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[6 7 8 9]\n",
      "7\n",
      "8\n",
      "[ 4  8 12]\n"
     ]
    }
   ],
   "source": [
    "print(arr2[1]) #索引第一行\n",
    "print(arr2[1][1]) #第一行第一列的值\n",
    "print(arr2[1,2]) #第一行和第二列的值\n",
    "print(arr2[:,2]) #索引第二列"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6、numpy数组合并"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 创建两个一维数组\n",
    "arr1 = np.array([1,2,3])\n",
    "arr2 = np.array([4,5,6])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "按垂直方向进行合并："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]] (2, 3)\n"
     ]
    }
   ],
   "source": [
    "arr3 = np.vstack((arr1,arr2))#垂直合并\n",
    "print(arr3, arr3.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "按水平方向进行合并："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5 6] (6,)\n"
     ]
    }
   ],
   "source": [
    "arr4 = np.hstack((arr1,arr2))#水平合并\n",
    "print(arr4, arr4.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "按数组维度进行拼接："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [1 2 3]\n",
      " [4 5 6]]\n"
     ]
    }
   ],
   "source": [
    "arr4 = np.concatenate((arr3,arr3),axis=0)#合并的array维度要相同，array形状要匹配，axis=0纵向合并\n",
    "print(arr4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3 1 2 3]\n",
      " [4 5 6 4 5 6]]\n"
     ]
    }
   ],
   "source": [
    "arr4 = np.concatenate((arr3,arr3),axis=1)#合并的array维度要相同，array形状要匹配，axis=0纵向合并\n",
    "print(arr4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "转置（一维数组转置为本身）："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr1.T #一维数组转置为本身"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1]\n",
      " [2]\n",
      " [3]] (3, 1)\n"
     ]
    }
   ],
   "source": [
    "arr1_1 = arr1[np.newaxis,:] #将一维数组按行方向进行扩维\n",
    "print(arr1_1.T, arr1_1.T.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1]\n",
      " [2]\n",
      " [3]] (3, 1)\n"
     ]
    }
   ],
   "source": [
    "arr1_2 = arr1[:,np.newaxis] #将一维数组按列方向进行扩维\n",
    "print(arr1_2, arr1_2.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7、numpy数组的分割"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3]\n",
      " [ 4  5  6  7]\n",
      " [ 8  9 10 11]]\n"
     ]
    }
   ],
   "source": [
    "arr1 = np.arange(12).reshape((3,4))\n",
    "print(arr1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "通过`np.split(data,num,axis)`进行横向分割，分成两份，切割份数必须均匀："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "arr2: [[0 1]\n",
      " [4 5]\n",
      " [8 9]]\n",
      "arr3: [[ 2  3]\n",
      " [ 6  7]\n",
      " [10 11]]\n"
     ]
    }
   ],
   "source": [
    "arr2,arr3 = np.split(arr1,2,axis=1)#横向分割，分成2份\n",
    "print('arr2:', arr2)\n",
    "print('arr3:', arr3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "纵向分割为三份："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "arr4: [[0 1 2 3]]\n",
      "arr5: [[4 5 6 7]]\n",
      "arr6: [[ 8  9 10 11]]\n"
     ]
    }
   ],
   "source": [
    "arr4,arr5,arr6 = np.split(arr1,3,axis=0)#纵向分割，分成3份\n",
    "print('arr4:', arr4)\n",
    "print('arr5:', arr5)\n",
    "print('arr6:', arr6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "通过`np.array_split(data,num,axis)`可以进行不等份分割，如把arr1横向分割为三份："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "arr7: [[0 1]\n",
      " [4 5]\n",
      " [8 9]]\n",
      "arr8: [[ 2]\n",
      " [ 6]\n",
      " [10]]\n",
      "arr9: [[ 3]\n",
      " [ 7]\n",
      " [11]]\n"
     ]
    }
   ],
   "source": [
    "arr7,arr8,arr9 = np.array_split(arr1,3,axis=1)#横向分割，分成3份，不等分割\n",
    "print('arr7:', arr7)\n",
    "print('arr8:', arr8)\n",
    "print('arr9:', arr9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "也可以通过`np.vsplit()`和`np.hsplit`进行纵向和横向的快速分割"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "arrv1,arrv2,arrv3 = np.vsplit(arr1,3)#纵向分割\n",
    "\n",
    "arrh1,arrh2 = np.hsplit(arr1,2)#横向分割"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}