Python25-numpy快速入门教程.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# [参考 ](https://docs.scipy.org/doc/numpy-dev/user/quickstart.html)\n",
    "```NumPy的主要对象是具有相同数据类型数据的多维数组。它是一个含有相同数据（通常为数字）类型的表，这些有一组整数来标注索引。\n",
    "NumPy的维称作成轴(axis)，轴的个数叫做行(rank)。比如：\n",
    "[1, 2, 1]\n",
    "轴的个数为1，行(rank)就是1\n",
    "\n",
    "[[ 1., 0., 0.],\n",
    "[ 0., 1., 2.]] \n",
    "上面这个数组有2行(也就是它是2维的)，第一位维度的长度为2（也就是2行），第二维度的长度为3（也就是3列）\n",
    " ```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "NumPy的数组类叫作ndarray。下面是ndarray的几个重要属性\n",
    "ndarray.ndim:数组的轴的个数（就是维数）\n",
    "ndarray.shape:数组的维度(是一个元组)。比如矩阵有n行m列，那么shape为（n,m）\n",
    "ndarray.size:数组元素的个数。也是shape(n,m)元素的乘积\n",
    "ndarray.dtype:数组元素类型的描述。例如：numpy.int32, numpy.int16, and numpy.float64 \n",
    "ndarray.itemsize:数组每个元素的字节大小。对于类型为floa64的元素，itemsize为8（=64/8，1byte=8bit）\n",
    "ndarray.data:数组的缓存数据。通常情况下通过索引获取数据，不必要使用这个属性\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 快速入门实例"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14]\n",
      "[[ 0  1  2  3  4]\n",
      " [ 5  6  7  8  9]\n",
      " [10 11 12 13 14]]\n",
      "b.shape= (3, 5)\n",
      "b.ndim= 2\n",
      "b.dtype.name= int32\n",
      "b.itemsize= 4\n",
      "b.size= 15\n",
      "b.type= <class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "import numpy  as np\n",
    "a=np.arange(15)\n",
    "b=a.reshape(3,5)\n",
    "print(a)\n",
    "print(b)\n",
    "print(\"b.shape=\",b.shape)\n",
    "print(\"b.ndim=\",b.ndim)\n",
    "print(\"b.dtype.name=\",b.dtype.name)\n",
    "print(\"b.itemsize=\",b.itemsize)\n",
    "print(\"b.size=\",b.size)\n",
    "print(\"b.type=\",type(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 创建数组"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3] int32\n",
      "float64\n"
     ]
    }
   ],
   "source": [
    "a=np.array([1,2,3])\n",
    "print(a,a.dtype)\n",
    "b=np.array([1,2,3,4,5.0])\n",
    "print(b.dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "only 2 non-keyword arguments accepted",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-3-d608a665f52c>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m#一个常见错误就是：提供给array的参数是多个数字，而不是包含数字的列表\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0ma\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0marray\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m4\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;31m#错误\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      3\u001b[0m \u001b[0ma\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0marray\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m4\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;31m#正确\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mValueError\u001b[0m: only 2 non-keyword arguments accepted"
     ]
    }
   ],
   "source": [
    "#一个常见错误就是：提供给array的参数是多个数字，而不是包含数字的列表\n",
    "a=np.array(1,2,3,4)#错误\n",
    "a=np.array([1,2,3,4])#正确"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([(1, 2, 3, 5), (4, 5, 6)], dtype=object)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#创建多维数组\n",
    "b=np.array([(1,2,3,5),(4,5,6)])\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.+0.j, 2.+0.j],\n",
       "       [3.+0.j, 4.+0.j]])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#创建数组的时候，可以声明数组的数据类型\n",
    "c=np.array([[1,2],[3,4]],dtype=complex)\n",
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "关于：zeros,ones、empty\n",
    "zeros()：创建元素全为0的数组\n",
    "ones()：创建元素全为1的数组\n",
    "empty():创建随机元素的数组，默认数据类型为float64"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0.]])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros((3,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[1, 1, 1, 1],\n",
       "        [1, 1, 1, 1],\n",
       "        [1, 1, 1, 1]],\n",
       "\n",
       "       [[1, 1, 1, 1],\n",
       "        [1, 1, 1, 1],\n",
       "        [1, 1, 1, 1]]], dtype=int16)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones((2,3,4),dtype=np.int16)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3.75921675e-316, 9.58487353e-322, 0.00000000e+000,\n",
       "        0.00000000e+000, 0.00000000e+000, 5.02034658e+175],\n",
       "       [4.04186035e-037, 2.72587556e-056, 4.12352216e-061,\n",
       "        2.05476829e+160, 1.47763641e+248, 1.16096346e-028],\n",
       "       [7.69165785e+218, 1.35617292e+248, 1.30932099e-071,\n",
       "        1.61899735e-051, 2.25578622e+180, 4.00073286e+175],\n",
       "       [4.26397240e-096, 6.32299154e+233, 6.48224638e+170,\n",
       "        5.22411352e+257, 5.74020278e+180, 8.37174974e-144],\n",
       "       [1.41529402e+161, 9.16651763e-072, 3.45944511e+097,\n",
       "        2.21623333e-052, 3.58637636e+126, 1.58268989e-319]])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.empty((5,6))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.   0.25 0.5  0.75 1.   1.25 1.5  1.75 2.  ]\n"
     ]
    }
   ],
   "source": [
    "from numpy import pi\n",
    "print(np.linspace(0,2,9))#0-2中的9个数字\n",
    "x=np.linspace(0,2*pi,100)\n",
    "f=np.sin(x)#f结果集"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "打印数组\n",
    "如果数组元素太多，NumPy就会自动跳过中间部分的元素并且只打印边界元素"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[   0    1    2 ... 9997 9998 9999]\n",
      "[[   0    1    2 ...   97   98   99]\n",
      " [ 100  101  102 ...  197  198  199]\n",
      " [ 200  201  202 ...  297  298  299]\n",
      " ...\n",
      " [9700 9701 9702 ... 9797 9798 9799]\n",
      " [9800 9801 9802 ... 9897 9898 9899]\n",
      " [9900 9901 9902 ... 9997 9998 9999]]\n"
     ]
    }
   ],
   "source": [
    "print(np.arange(10000))\n",
    "print(np.arange(10000).reshape(100,100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 基本运算"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[20 29 38 47]\n",
      "[0 1 4 9]\n",
      "[ 9.12945251 -9.88031624  7.4511316  -2.62374854]\n",
      "[ True  True False False]\n",
      "[20 31 42 53]\n"
     ]
    }
   ],
   "source": [
    "a=np.array([20,30,40,50])\n",
    "b=np.arange(4)\n",
    "c=a-b\n",
    "print(c)#减\n",
    "print(b**2)#乘\n",
    "d=10*np.sin(a)#计算sin函数的结果集\n",
    "print(d)\n",
    "print(a<35)\n",
    "b+=a#加\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在不同数据类型的数组计算过程中，结果的数据类型自动变为精度更高的数据类型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "float64\n",
      "[1.         2.57079633 4.14159265] float64\n",
      "[ 0.54030231+0.84147098j -0.84147098+0.54030231j -0.54030231-0.84147098j] complex128\n"
     ]
    }
   ],
   "source": [
    "a=np.ones(3,dtype=np.int32)\n",
    "b=np.linspace(0,np.pi,3)\n",
    "print(b.dtype.name)\n",
    "c=a+b\n",
    "print(c,c.dtype.name)\n",
    "d=np.exp(c*1j)\n",
    "print(d,d.dtype.name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ndarray这个类有很多对数组的一元操作，比如计算整个数组的所有元素的和"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.18975279 0.56613643 0.47077784]\n",
      " [0.44095475 0.13323983 0.57282698]]\n",
      "2.3736886161127395\n",
      "0.13323983169400022\n",
      "0.5728269809733358\n"
     ]
    }
   ],
   "source": [
    "a=np.random.random((2,3))\n",
    "print(a)\n",
    "print(a.sum())\n",
    "print(a.min())\n",
    "print(a.max())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以按轴计算结果，比如下面"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3]\n",
      " [ 4  5  6  7]\n",
      " [ 8  9 10 11]]\n",
      "[ 6 22 38]\n",
      "[12 15 18 21]\n",
      "[[ 0  1  3  6]\n",
      " [ 4  9 15 22]\n",
      " [ 8 17 27 38]]\n"
     ]
    }
   ],
   "source": [
    "b=np.arange(12).reshape(3,4)\n",
    "print(b)\n",
    "print(b.sum(axis=1))#计算机每一行的和\n",
    "print(b.sum(axis=0))#计算每一列的和\n",
    "print(b.cumsum(axis=1))#计算每一行的累积和（对于第一行，0，0+1=1,1+2=3,3+3=6）"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 通用函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2]\n",
      "[1.         2.71828183 7.3890561 ]\n",
      "[0.         1.         1.41421356]\n",
      "[2. 0. 6.]\n"
     ]
    }
   ],
   "source": [
    "B=np.arange(3)#生成[0,1,2]数组\n",
    "print(B)\n",
    "print(np.exp(B))#计算机e的幂\n",
    "print(np.sqrt(B))#计算机每个元素的平方根\n",
    "C=np.array([2.,-1.,4.])\n",
    "print(np.add(B,C))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.97812517]\n",
      " [0.97012536]\n",
      " [0.03980562]]\n",
      "[[-0.09154642  0.05763739 -0.31849807]]\n",
      "[[-0.80319518  0.94813082  1.87201692]\n",
      " [ 1.66276194  0.45541713 -2.00078828]\n",
      " [-1.12021938  0.44848649  2.27630446]\n",
      " [ 0.48444545  0.51631078 -0.90395865]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "#Input array\n",
    "X=np.array([[1,0,1,0],[1,0,1,1],[0,1,0,1]])\n",
    "\n",
    "#Output\n",
    "y=np.array([[1],[1],[0]])\n",
    "\n",
    "#Sigmoid Function\n",
    "def sigmoid (x):\n",
    "    return 1/(1 + np.exp(-x))\n",
    "\n",
    "#Derivative of Sigmoid Function\n",
    "def derivatives_sigmoid(x):\n",
    "    return x * (1 - x)\n",
    "\n",
    "#Variable initialization\n",
    "epoch=5000 #Setting training iterations\n",
    "lr=0.1 #Setting learning rate\n",
    "inputlayer_neurons = X.shape[1] #number of features in data set\n",
    "hiddenlayer_neurons = 3 #number of hidden layers neurons\n",
    "output_neurons = 1 #number of neurons at output layer\n",
    "\n",
    "#weight and bias initialization\n",
    "wh=np.random.uniform(size=(inputlayer_neurons,hiddenlayer_neurons))\n",
    "bh=np.random.uniform(size=(1,hiddenlayer_neurons))\n",
    "wout=np.random.uniform(size=(hiddenlayer_neurons,output_neurons))\n",
    "bout=np.random.uniform(size=(1,output_neurons))\n",
    "\n",
    "for i in range(epoch):\n",
    "    #Forward Propogation\n",
    "    hidden_layer_input1=np.dot(X,wh)\n",
    "    hidden_layer_input=hidden_layer_input1 + bh\n",
    "    hiddenlayer_activations = sigmoid(hidden_layer_input)\n",
    "    output_layer_input1=np.dot(hiddenlayer_activations,wout)\n",
    "    output_layer_input= output_layer_input1+ bout\n",
    "    output = sigmoid(output_layer_input)\n",
    "\n",
    "    #Backpropagation\n",
    "    E = y-output\n",
    "    slope_output_layer = derivatives_sigmoid(output)\n",
    "    slope_hidden_layer = derivatives_sigmoid(hiddenlayer_activations)\n",
    "    d_output = E * slope_output_layer\n",
    "    Error_at_hidden_layer = d_output.dot(wout.T)\n",
    "    d_hiddenlayer = Error_at_hidden_layer * slope_hidden_layer\n",
    "    wout += hiddenlayer_activations.T.dot(d_output) *lr\n",
    "    bout += np.sum(d_output, axis=0,keepdims=True) *lr\n",
    "    wh += X.T.dot(d_hiddenlayer) *lr\n",
    "    bh += np.sum(d_hiddenlayer, axis=0,keepdims=True) *lr\n",
    "print(output)\n",
    "print(bh)\n",
    "print(wh)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 索引、切片、递归"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[  0   1   8  27  64 125 216 343 512 729]\n",
      "[ 8 27 64]\n",
      "[-1000     1 -1000    27 -1000   125   216   343   512   729]\n",
      "[  729   512   343   216   125 -1000    27 -1000     1 -1000]\n"
     ]
    }
   ],
   "source": [
    "a=np.arange(10)**3\n",
    "print(a)\n",
    "print(a[2:5])\n",
    "a[:6:2]=-1000#0-6之间的元素，每两个元素，第二个等于-1000\n",
    "print(a)\n",
    "print(a[::-1])#翻转元素"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3]\n",
      " [10 11 12 13]\n",
      " [20 21 22 23]\n",
      " [30 31 32 33]\n",
      " [40 41 42 43]]\n",
      "23\n",
      "[ 1 11 21 31 41]\n",
      "[ 1 11 21 31 41]\n",
      "[[10 11 12 13]\n",
      " [20 21 22 23]]\n"
     ]
    }
   ],
   "source": [
    "#多维数组\n",
    "def f(x,y):\n",
    "    return 10*x+y\n",
    "b=np.fromfunction(f,(5,4),dtype=int)\n",
    "print(b)\n",
    "print(b[2,3])\n",
    "print(b[0:5,1])\n",
    "print(b[:,1])\n",
    "print(b[1:3,:])#在第2行和第3行的每一列元素"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# 形状操作\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[9. 3. 9. 8.]\n",
      " [3. 8. 2. 3.]\n",
      " [7. 3. 0. 2.]]\n",
      "(3, 4)\n"
     ]
    }
   ],
   "source": [
    "a=np.floor(10*np.random.random((3,4)))#向下取整\n",
    "print(a)\n",
    "print(a.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "一个数组的形状可以使用多种命令去改变。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[9. 3. 9. 8. 3. 8. 2. 3. 7. 3. 0. 2.]\n",
      "[[9. 3.]\n",
      " [9. 8.]\n",
      " [3. 8.]\n",
      " [2. 3.]\n",
      " [7. 3.]\n",
      " [0. 2.]]\n"
     ]
    }
   ],
   "source": [
    "print(a.ravel())#返回一个平铺的数组\n",
    "print(a.reshape(6,2))#重新改变形状"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3],\n",
       "       [ 4,  5,  6,  7],\n",
       "       [ 8,  9, 10, 11],\n",
       "       [12, 13, 14, 15]])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z=np.arange(16).reshape(4,4)\n",
    "z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4, 4)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z.reshape(-1) # 一行"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15]])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z.reshape(1,-1) # 一行"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0],\n",
       "       [ 1],\n",
       "       [ 2],\n",
       "       [ 3],\n",
       "       [ 4],\n",
       "       [ 5],\n",
       "       [ 6],\n",
       "       [ 7],\n",
       "       [ 8],\n",
       "       [ 9],\n",
       "       [10],\n",
       "       [11],\n",
       "       [12],\n",
       "       [13],\n",
       "       [14],\n",
       "       [15]])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z.reshape(-1,1) # 一列"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4,  5,  6,  7],\n",
       "       [ 8,  9, 10, 11, 12, 13, 14, 15]])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z.reshape(2,-1) # 不管有多少列，只要保证为两行"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1],\n",
       "       [ 2,  3],\n",
       "       [ 4,  5],\n",
       "       [ 6,  7],\n",
       "       [ 8,  9],\n",
       "       [10, 11],\n",
       "       [12, 13],\n",
       "       [14, 15]])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z.reshape(-1,2) # 不管有多少行，只要保证为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
}