基本的/numpy学习记录.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3>1.1 生成numpy数组</h3>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#查看numpy函数的帮助信息\n",
    "np.abs??"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1.1.1 从已有数据中创建数组"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3.14 2.17 0.   1.   2.  ]\n",
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "lst1 = [3.14, 2.17, 0, 1, 2]\n",
    "nd1 =np.array(lst1)\n",
    "print(nd1)\n",
    "# [3.14 2.17 0.   1.   2.  ]\n",
    "print(type(nd1))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[3.14 2.17 0.   1.   2.  ]\n",
      " [1.   2.   3.   4.   5.  ]]\n",
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "lst2 = [[3.14, 2.17, 0, 1, 2], [1, 2, 3, 4, 5]]\n",
    "nd2 =np.array(lst2)\n",
    "print(nd2)\n",
    "# [[3.14 2.17 0.   1.   2.  ]\n",
    "#  [1.   2.   3.   4.   5.  ]]\n",
    "print(type(nd2))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[list([1, 2, 3, 4]) list([1, 6, 9])]\n",
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "list = [[1,2,3,4],[1,6,9]]\n",
    "nd = np.array(list)\n",
    "print(nd)\n",
    "print(type(nd))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以看到利用list创建数组时，如果数组的长度不等长，则数组中的元素就是列表里元素的种类，即一个列表的数组"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1.1.2 利用 random 模块生成数组"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.2825494  0.49026544 0.89050493]\n",
      " [0.73615031 0.82211001 0.07713871]\n",
      " [0.94375842 0.75488908 0.97321202]]\n",
      "nd3的形状为: (3, 3)\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "nd3 =np.random.random([3, 3])\n",
    "print(nd3)\n",
    "print(\"nd3的形状为:\",nd3.shape)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-1.0856306   0.99734545  0.2829785 ]\n",
      " [-1.50629471 -0.57860025  1.65143654]]\n",
      "随机打乱后数据:\n",
      "[[-1.50629471 -0.57860025  1.65143654]\n",
      " [-1.0856306   0.99734545  0.2829785 ]]\n",
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "np.random.seed(123)\n",
    "nd4 = np.random.randn(2,3)\n",
    "print(nd4)\n",
    "np.random.shuffle(nd4)\n",
    "print(\"随机打乱后数据:\")\n",
    "print(nd4)\n",
    "print(type(nd4))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1.1.3 创建特定形状的多维数组"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0. 0.]\n",
      " [0. 0. 0.]\n",
      " [0. 0. 0.]]\n",
      "[[1. 1. 1.]\n",
      " [1. 1. 1.]\n",
      " [1. 1. 1.]]\n",
      "[[1. 0. 0.]\n",
      " [0. 1. 0.]\n",
      " [0. 0. 1.]]\n",
      "[[1 0 0]\n",
      " [0 2 0]\n",
      " [0 0 3]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "# 生成全是 0 的 3x3 矩阵\n",
    "nd5 =np.zeros([3, 3])\n",
    "#生成与nd5形状一样的全0矩阵\n",
    "#np.zeros_like(nd5)\n",
    "# 生成全是 1 的 3x3 矩阵\n",
    "nd6 = np.ones([3, 3])\n",
    "# 生成 3 阶的单位矩阵\n",
    "nd7 = np.eye(3)\n",
    "# 生成 3 阶对角矩阵\n",
    "nd8 = np.diag([1, 2, 3])\n",
    "\n",
    "print(nd5)\n",
    "print(nd6)\n",
    "print(nd7)\n",
    "print(nd8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "从文件载入数据创建数组"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.02798196 0.17390652 0.15408224 0.07708648 0.8898657 ]\n",
      " [0.7503787  0.69340324 0.51176338 0.46426806 0.56843069]\n",
      " [0.30254945 0.49730879 0.68326291 0.91669867 0.10892895]\n",
      " [0.49549179 0.23283593 0.43686066 0.75154299 0.48089213]\n",
      " [0.79772841 0.28270293 0.43341824 0.00975735 0.34079598]]\n",
      "[[0.02798196 0.17390652 0.15408224 0.07708648 0.8898657 ]\n",
      " [0.7503787  0.69340324 0.51176338 0.46426806 0.56843069]\n",
      " [0.30254945 0.49730879 0.68326291 0.91669867 0.10892895]\n",
      " [0.49549179 0.23283593 0.43686066 0.75154299 0.48089213]\n",
      " [0.79772841 0.28270293 0.43341824 0.00975735 0.34079598]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "nd9 =np.random.random([5, 5])\n",
    "print(nd9)\n",
    "np.savetxt(X=nd9, fname='./test1.txt')\n",
    "nd10 = np.loadtxt('./test1.txt')\n",
    "print(nd10)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1.1.4 利用 arange、linspace 函数生成数组"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6 7 8 9]\n",
      "[0 1 2 3 4 5 6 7 8 9]\n",
      "[1.  1.5 2.  2.5 3.  3.5]\n",
      "[9 8 7 6 5 4 3 2 1 0]\n",
      "[ 0.          0.20408163  0.40816327  0.6122449   0.81632653  1.02040816\n",
      "  1.2244898   1.42857143  1.63265306  1.83673469  2.04081633  2.24489796\n",
      "  2.44897959  2.65306122  2.85714286  3.06122449  3.26530612  3.46938776\n",
      "  3.67346939  3.87755102  4.08163265  4.28571429  4.48979592  4.69387755\n",
      "  4.89795918  5.10204082  5.30612245  5.51020408  5.71428571  5.91836735\n",
      "  6.12244898  6.32653061  6.53061224  6.73469388  6.93877551  7.14285714\n",
      "  7.34693878  7.55102041  7.75510204  7.95918367  8.16326531  8.36734694\n",
      "  8.57142857  8.7755102   8.97959184  9.18367347  9.3877551   9.59183673\n",
      "  9.79591837 10.        ]\n",
      "[ 0.   2.5  5.   7.5 10. ]\n",
      "[ 1.  4.  7. 10.]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "print(np.arange(10))\n",
    "# [0 1 2 3 4 5 6 7 8 9]\n",
    "print(np.arange(0, 10))\n",
    "# [0 1 2 3 4 5 6 7 8 9]\n",
    "print(np.arange(1, 4, 0.5))\n",
    "# [1.  1.5 2.  2.5 3.  3.5]\n",
    "print(np.arange(9, -1, -1))\n",
    "# [9 8 7 6 5 4 3 2 1 0]\n",
    "print(np.linspace(0,10))\n",
    "print(np.linspace(0,10,5))\n",
    "#[ 0.   2.5  5.   7.5 10. ]\n",
    "print(np.linspace(1,10,4))\n",
    "#[ 1.  4.  7. 10.]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "利用arange创建数组：arange（start,end,step)，默认start=0,step=1)即只输入一个数n，则创建0，1，2，，，，n-1的数组\n",
    "\n",
    "利用linspace创建数组 linspace(start,end,step) 至少输入两个参数，start开始的数，end为结束数，step为几步从start到end，步长为（end-sart）/（step-1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2>1.2 获取元素</h2>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "数组： [0.90348221 0.39308051 0.62396996 0.6378774  0.88049907 0.29917202\n",
      " 0.70219827 0.90320616 0.88138193 0.4057498 ]\n",
      "第四个元素: 0.6378774010222266\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "np.random.seed(2019)\n",
    "nd11 = np.random.random([10])\n",
    "print(\"数组：\",nd11)\n",
    "#获取指定位置的数据，获取第4个元素\n",
    "print(\"第四个元素:\",nd11[3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.6378774  0.88049907 0.29917202] \n",
      "\n",
      "[0.39308051 0.6378774  0.29917202]\n"
     ]
    }
   ],
   "source": [
    "#截取一段数据 下标3,4,5的位置\n",
    "print(nd11[3:6],'\\n')\n",
    "#截取固定间隔数据\n",
    "print(nd11[1:6:2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.4057498  0.90320616 0.29917202 0.6378774  0.39308051]\n"
     ]
    }
   ],
   "source": [
    "#倒序取数\n",
    "print(nd11[::-2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3  4]\n",
      " [ 5  6  7  8  9]\n",
      " [10 11 12 13 14]\n",
      " [15 16 17 18 19]\n",
      " [20 21 22 23 24]]\n",
      "[[ 6  7]\n",
      " [11 12]]\n",
      "[4 5 6 7 8 9]\n",
      "[[ 5  6  7  8  9]\n",
      " [10 11 12 13 14]]\n",
      "[[ 1  2]\n",
      " [ 6  7]\n",
      " [11 12]\n",
      " [16 17]\n",
      " [21 22]]\n"
     ]
    }
   ],
   "source": [
    "#截取一个多维数组的一个区域内数据\n",
    "nd12=np.arange(25).reshape([5,5])\n",
    "print(nd12)\n",
    "print(nd12[1:3,1:3])\n",
    "#截取一个多维数组中，数值在一个值域之内的数据\n",
    "print(nd12[(nd12>3)&(nd12<10)])\n",
    "#截取多维数组中，指定的行,如读取第2,3行\n",
    "print(nd12[[1,2]]) #或nd12[1:3,:]\n",
    "##截取多维数组中，指定的列,如读取第2,3列\n",
    "print(nd12[:,1:3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "随机可重复抽取\n",
      "[[19.  6. 24. 22.]\n",
      " [21. 17. 16.  2.]\n",
      " [23. 15. 13. 11.]]\n",
      "随机但不重复抽取\n",
      "[[ 5. 14. 23. 15.]\n",
      " [ 8. 24.  6. 18.]\n",
      " [13. 10. 21. 11.]]\n",
      "随机但按制度概率抽取\n",
      "[[19. 21. 18. 11.]\n",
      " [10. 21. 23. 19.]\n",
      " [18. 19. 11. 20.]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "from numpy import random as nr\n",
    "\n",
    "a=np.arange(1,25,dtype=float)\n",
    "c1=nr.choice(a,size=(3,4))  #size指定输出数组形状\n",
    "c2=nr.choice(a,size=(3,4),replace=False)  #replace缺省为True，即可重复抽取。\n",
    "#下式中参数p指定每个元素对应的抽取概率，缺省为每个元素被抽取的概率相同。\n",
    "c3=nr.choice(a,size=(3,4),p=a / np.sum(a))\n",
    "print(\"随机可重复抽取\")\n",
    "print(c1)\n",
    "print(\"随机但不重复抽取\")\n",
    "print(c2)\n",
    "print(\"随机但按制度概率抽取\")\n",
    "print(c3)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "这里说一下按概率抽取\n",
    "\n",
    "choice（a,size,p）a就是被抽取的数组，size是抽取成什么样子的数组，而p为a每一点数组被抽取的概率，如上面代码，即a每一点抽取的概率为每一点的值除以数组元素和，大数的概率比较大，所以可以看到第三个数组中大数比较多"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3>1.3 Numpy的算术运算</h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1.3.1对应元素相乘"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2,  0],\n",
       "       [-3, 16]])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.array([[1, 2], [-1, 4]])\n",
    "B = np.array([[2, 0], [3, 4]])\n",
    "A*B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2,  0],\n",
       "       [-3, 16]])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#或另一种表示方法\n",
    "np.multiply(A,B)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 2.  4.]\n",
      " [-2.  8.]]\n",
      "[[ 0.5  1. ]\n",
      " [-0.5  2. ]]\n"
     ]
    }
   ],
   "source": [
    "print(A*2.0)\n",
    "print(A/2.0)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "输入参数X的形状： (2, 3)\n",
      "激活函数softmoid输出形状： (2, 3)\n",
      "激活函数relu输出形状： (2, 3)\n",
      "激活函数softmax输出形状： (2, 3)\n"
     ]
    }
   ],
   "source": [
    "X=np.random.rand(2,3)\n",
    "def softmoid(x):\n",
    "    return 1/(1+np.exp(-x))\n",
    "def relu(x):\n",
    "    return np.maximum(0,x)\n",
    "def softmax(x):\n",
    "    return np.exp(x)/np.sum(np.exp(x))\n",
    "\n",
    "print(\"输入参数X的形状：\",X.shape)\n",
    "print(\"激活函数softmoid输出形状：\",softmoid(X).shape)\n",
    "print(\"激活函数relu输出形状：\",relu(X).shape)\n",
    "print(\"激活函数softmax输出形状：\",softmax(X).shape)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "softmoid是一个用来解决二分类问题的激活函数\n",
    "而softmax可以用来解决多分类，她的值在0 -1之间\n",
    "relu是最简单的激活函数，非负值为本身，而负值则为零\n",
    "在这列一下常见的激活函数\n",
    "![jupyter](https://pic3.zhimg.com/v2-0021e8d3d34584abd80ac3851f15956c_1440w.jpg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1.3.2 点积运算"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[21 24 27]\n",
      " [47 54 61]]\n"
     ]
    }
   ],
   "source": [
    "X1=np.array([[1,2],[3,4]])\n",
    "X2=np.array([[5,6,7],[8,9,10]])\n",
    "X3=np.dot(X1,X2)\n",
    "print(X3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3>1.4 数组变形</h3>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1.4.1 更改数组的形状"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6 7 8 9]\n",
      "[[0 1 2 3 4]\n",
      " [5 6 7 8 9]]\n",
      "[[0 1]\n",
      " [2 3]\n",
      " [4 5]\n",
      " [6 7]\n",
      " [8 9]]\n",
      "[[0 1 2 3 4]\n",
      " [5 6 7 8 9]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "arr =np.arange(10)\n",
    "print(arr)\n",
    "# 将向量 arr 维度变换为2行5列\n",
    "print(arr.reshape(2, 5))\n",
    "# 指定维度时可以只指定行数或列数, 其他用 -1 代替\n",
    "print(arr.reshape(5, -1))\n",
    "print(arr.reshape(-1, 5))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6 7 8 9]\n",
      "[[0 1 2 3 4]\n",
      " [5 6 7 8 9]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "arr =np.arange(10)\n",
    "print(arr)\n",
    "# 将向量 arr 维度变换为2行5列\n",
    "arr.resize(2, 5)\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3]\n",
      " [ 4  5  6  7]\n",
      " [ 8  9 10 11]]\n",
      "[[ 0  4  8]\n",
      " [ 1  5  9]\n",
      " [ 2  6 10]\n",
      " [ 3  7 11]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "arr =np.arange(12).reshape(3,4)\n",
    "# 向量 arr 为3行4列\n",
    "print(arr)\n",
    "# 将向量 arr 进行转置为4行3列\n",
    "print(arr.T)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1 2]\n",
      " [3 4 5]]\n",
      "按照列优先，展平\n",
      "[0 3 1 4 2 5]\n",
      "按照行优先，展平\n",
      "[0 1 2 3 4 5]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "arr =np.arange(6).reshape(2, -1)\n",
    "print(arr)\n",
    "# 按照列优先，展平\n",
    "print(\"按照列优先，展平\")\n",
    "print(arr.ravel('F'))\n",
    "# 按照行优先，展平\n",
    "print(\"按照行优先，展平\")\n",
    "print(arr.ravel())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[3. 7. 7. 4.]\n",
      " [3. 1. 0. 9.]\n",
      " [4. 8. 2. 9.]]\n",
      "[3. 7. 7. 4. 3. 1. 0. 9. 4. 8. 2. 9.]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "a =np.floor(10*np.random.random((3,4)))\n",
    "print(a)\n",
    "print(a.flatten())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以看到这两个函数实现的功能一样,但我们在平时使用的时候flatten()更为合适.在使用过程中flatten()分配了新的内存,但ravel()返回的是一个数组的视图.视图是数组的引用(说引用不太恰当,因为原数组和ravel()返回后的数组的地址并不一样),在使用过程中应该注意避免在修改视图时影响原本的数组.这是什么意思咧,我们通过代码来具体解释:\n",
    "\n",
    "做一个例子体会一下"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1 2]\n",
      " [3 4 5]]\n",
      "[[10  1  2]\n",
      " [ 3  4  5]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "a = np.arange(6).reshape(2,3)\n",
    "b = a.copy()\n",
    "c = a.flatten()\n",
    "d = b.ravel()\n",
    "c[0] = 10\n",
    "d[0] = 10\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "可以看到的是我们修改flatten展开后的数组，原数组不会改变，而修改ravel展开的数组，原来的数组也随之改变了"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 1)\n",
      "(3,)\n",
      "(3, 1, 2, 1)\n",
      "(3, 2)\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "arr =np.arange(3).reshape(3, 1)\n",
    "print(arr.shape)  #(3,1)\n",
    "print(arr.squeeze().shape)  #(3,)\n",
    "arr1 =np.arange(6).reshape(3,1,2,1)\n",
    "print(arr1.shape) #(3, 1, 2, 1)\n",
    "print(arr1.squeeze().shape) #(3, 2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, 2)\n"
     ]
    }
   ],
   "source": [
    "arr = np.arange(6).reshape(3,2)\n",
    "print(arr.squeeze().shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "squeeze()的作用就是把单维度去掉,即把维度为1的层去掉"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 3, 4)\n",
      "[[[ 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",
      "(3, 4, 2)\n",
      "[[[ 0 12]\n",
      "  [ 1 13]\n",
      "  [ 2 14]\n",
      "  [ 3 15]]\n",
      "\n",
      " [[ 4 16]\n",
      "  [ 5 17]\n",
      "  [ 6 18]\n",
      "  [ 7 19]]\n",
      "\n",
      " [[ 8 20]\n",
      "  [ 9 21]\n",
      "  [10 22]\n",
      "  [11 23]]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "arr2 = np.arange(24).reshape(2,3,4)\n",
    "print(arr2.shape)  #(2, 3, 4)\n",
    "print(arr2)\n",
    "print(arr2.transpose(1,2,0).shape)  #(3, 4, 2)\n",
    "print(arr2.transpose(1,2,0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "transpose()可以理解成对坐标轴的转换，0，1，2即对应的维数的坐标轴,接用下图来说明一下\n",
    "![jupyter](https://img-blog.csdn.net/20171227164718917?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvdTAxMjc2MjQxMA==/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/SouthEast)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1.4.2 合并数组"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5 6]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "a =np.array([1, 2, 3])\n",
    "b = np.array([4, 5, 6])\n",
    "c = np.append(a, b)\n",
    "print(c) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "按行合并后的结果\n",
      "[[0 1]\n",
      " [2 3]\n",
      " [0 1]\n",
      " [2 3]]\n",
      "合并后数据维度 (4, 2)\n",
      "按列合并后的结果\n",
      "[[0 1 0 1]\n",
      " [2 3 2 3]]\n",
      "合并后数据维度 (2, 4)\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "a =np.arange(4).reshape(2, 2)\n",
    "b = np.arange(4).reshape(2, 2)\n",
    "# 按行合并\n",
    "c = np.append(a, b, axis=0)\n",
    "print('按行合并后的结果')\n",
    "print(c)\n",
    "print('合并后数据维度', c.shape)\n",
    "# 按列合并\n",
    "d = np.append(a, b, axis=1)\n",
    "print('按列合并后的结果')\n",
    "print(d)\n",
    "print('合并后数据维度', d.shape)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]\n",
      " [5 6]]\n",
      "[[1 2 5]\n",
      " [3 4 6]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "a =np.array([[1, 2], [3, 4]])\n",
    "b = np.array([[5, 6]])\n",
    "\n",
    "c = np.concatenate((a, b), axis=0)\n",
    "print(c)\n",
    "d = np.concatenate((a, b.T), axis=1)\n",
    "print(d)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "在concatenate（）中axis即不动的轴，和上面所说的编号一样，即axis=0则是第一维度不变，进行拼接"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[1 2]\n",
      "  [3 4]]\n",
      "\n",
      " [[5 6]\n",
      "  [7 8]]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "a =np.array([[1, 2], [3, 4]])\n",
    "b = np.array([[5, 6], [7, 8]])\n",
    "print(np.stack((a, b), axis=0))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "stack（）中axis即拼接的维度，如果是0.则是整体的拼接，如果是则是数组中第一维堆叠，还是用上面的这个例子体会一下"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[[1 2]\n",
      "  [5 6]]\n",
      "\n",
      " [[3 4]\n",
      "  [7 8]]]\n",
      "[[[1 5]\n",
      "  [2 6]]\n",
      "\n",
      " [[3 7]\n",
      "  [4 8]]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "a =np.array([[1, 2], [3, 4]])\n",
    "b = np.array([[5, 6], [7, 8]])\n",
    "print(np.stack((a, b), axis=1))\n",
    "a =np.array([[1, 2], [3, 4]])\n",
    "b = np.array([[5, 6], [7, 8]])\n",
    "print(np.stack((a, b), axis=2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3>1.5 批量处理</h3>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10000, 2, 3)\n",
      "第0批次,该批次的数据之和:-15.536990243960666\n",
      "第100批次,该批次的数据之和:-21.985298462061966\n",
      "第200批次,该批次的数据之和:-6.855888222836782\n",
      "第300批次,该批次的数据之和:3.6083079848920177\n",
      "第400批次,该批次的数据之和:-27.40567692288462\n",
      "第500批次,该批次的数据之和:20.068354790364182\n",
      "第600批次,该批次的数据之和:-13.839675656904632\n",
      "第700批次,该批次的数据之和:-6.800114389801605\n",
      "第800批次,该批次的数据之和:-1.9488451010894652\n",
      "第900批次,该批次的数据之和:26.949204942120392\n",
      "第1000批次,该批次的数据之和:-2.979366161898813\n",
      "第1100批次,该批次的数据之和:5.312401696285585\n",
      "第1200批次,该批次的数据之和:1.3890251621522829\n",
      "第1300批次,该批次的数据之和:18.8278831675152\n",
      "第1400批次,该批次的数据之和:-3.013130267630288\n",
      "第1500批次,该批次的数据之和:9.19572394091026\n",
      "第1600批次,该批次的数据之和:13.626914005186402\n",
      "第1700批次,该批次的数据之和:0.37350417857288587\n",
      "第1800批次,该批次的数据之和:36.73925921491799\n",
      "第1900批次,该批次的数据之和:43.06712584126686\n",
      "第2000批次,该批次的数据之和:23.638307136673426\n",
      "第2100批次,该批次的数据之和:-4.75115381990968\n",
      "第2200批次,该批次的数据之和:9.141910224904446\n",
      "第2300批次,该批次的数据之和:-20.59408298159168\n",
      "第2400批次,该批次的数据之和:-3.8542936637889635\n",
      "第2500批次,该批次的数据之和:5.190831422077821\n",
      "第2600批次,该批次的数据之和:0.1033080749731976\n",
      "第2700批次,该批次的数据之和:28.514888340013478\n",
      "第2800批次,该批次的数据之和:-4.250705282285964\n",
      "第2900批次,该批次的数据之和:17.312294875434937\n",
      "第3000批次,该批次的数据之和:0.5178363908270427\n",
      "第3100批次,该批次的数据之和:-17.8790934227159\n",
      "第3200批次,该批次的数据之和:-36.038534218631526\n",
      "第3300批次,该批次的数据之和:-18.657461526119754\n",
      "第3400批次,该批次的数据之和:8.96642791168259\n",
      "第3500批次,该批次的数据之和:-16.8977731392328\n",
      "第3600批次,该批次的数据之和:-39.054872436325724\n",
      "第3700批次,该批次的数据之和:29.935644015116434\n",
      "第3800批次,该批次的数据之和:30.81055271944732\n",
      "第3900批次,该批次的数据之和:23.851982375149078\n",
      "第4000批次,该批次的数据之和:-8.478701579368202\n",
      "第4100批次,该批次的数据之和:40.85481653211612\n",
      "第4200批次,该批次的数据之和:26.97601083992147\n",
      "第4300批次,该批次的数据之和:17.21262555227974\n",
      "第4400批次,该批次的数据之和:-50.016561720525274\n",
      "第4500批次,该批次的数据之和:7.631903490893341\n",
      "第4600批次,该批次的数据之和:25.243168771911083\n",
      "第4700批次,该批次的数据之和:20.190514976100143\n",
      "第4800批次,该批次的数据之和:-18.98702100615133\n",
      "第4900批次,该批次的数据之和:34.36360805643004\n",
      "第5000批次,该批次的数据之和:25.35375896132753\n",
      "第5100批次,该批次的数据之和:43.424816168297085\n",
      "第5200批次,该批次的数据之和:11.608363288030285\n",
      "第5300批次,该批次的数据之和:21.68416206846238\n",
      "第5400批次,该批次的数据之和:6.436689489116896\n",
      "第5500批次,该批次的数据之和:23.006041325030225\n",
      "第5600批次,该批次的数据之和:-4.249812203931111\n",
      "第5700批次,该批次的数据之和:-17.871637787937228\n",
      "第5800批次,该批次的数据之和:7.323918659671357\n",
      "第5900批次,该批次的数据之和:4.309354533237804\n",
      "第6000批次,该批次的数据之和:6.633432875784267\n",
      "第6100批次,该批次的数据之和:26.218426870623425\n",
      "第6200批次,该批次的数据之和:-26.91658590296429\n",
      "第6300批次,该批次的数据之和:-3.1430761455881417\n",
      "第6400批次,该批次的数据之和:-22.26223782650041\n",
      "第6500批次,该批次的数据之和:30.91871933556546\n",
      "第6600批次,该批次的数据之和:-31.898292758640856\n",
      "第6700批次,该批次的数据之和:18.59988200903708\n",
      "第6800批次,该批次的数据之和:-15.791132841722868\n",
      "第6900批次,该批次的数据之和:3.238520833596276\n",
      "第7000批次,该批次的数据之和:29.277501741691015\n",
      "第7100批次,该批次的数据之和:12.522408724950385\n",
      "第7200批次,该批次的数据之和:-0.04632167826632738\n",
      "第7300批次,该批次的数据之和:-3.608568580957826\n",
      "第7400批次,该批次的数据之和:-21.734163196503275\n",
      "第7500批次,该批次的数据之和:-3.3394183779285953\n",
      "第7600批次,该批次的数据之和:21.199090908362376\n",
      "第7700批次,该批次的数据之和:0.7073121847016655\n",
      "第7800批次,该批次的数据之和:-9.496965787226815\n",
      "第7900批次,该批次的数据之和:-8.102498149343045\n",
      "第8000批次,该批次的数据之和:-26.111801722552734\n",
      "第8100批次,该批次的数据之和:-7.824020704193143\n",
      "第8200批次,该批次的数据之和:14.258594184191388\n",
      "第8300批次,该批次的数据之和:41.14559557118639\n",
      "第8400批次,该批次的数据之和:-42.423226225171845\n",
      "第8500批次,该批次的数据之和:11.13236358559491\n",
      "第8600批次,该批次的数据之和:-1.2049458243346294\n",
      "第8700批次,该批次的数据之和:5.3873446796294395\n",
      "第8800批次,该批次的数据之和:24.155931755306803\n",
      "第8900批次,该批次的数据之和:-12.25847649662716\n",
      "第9000批次,该批次的数据之和:5.1467032230558605\n",
      "第9100批次,该批次的数据之和:17.989358787209316\n",
      "第9200批次,该批次的数据之和:17.246006465757496\n",
      "第9300批次,该批次的数据之和:22.15262511102754\n",
      "第9400批次,该批次的数据之和:-50.060940782199324\n",
      "第9500批次,该批次的数据之和:-15.72888648024591\n",
      "第9600批次,该批次的数据之和:-3.687025332996005\n",
      "第9700批次,该批次的数据之和:27.34512912877116\n",
      "第9800批次,该批次的数据之和:-21.107887951322212\n",
      "第9900批次,该批次的数据之和:22.67782616351013\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "#生成10000个形状为2X3的矩阵\n",
    "data_train = np.random.randn(10000,2,3)\n",
    "#这是一个3维矩阵，第一个维度为样本数，后两个是数据形状\n",
    "print(data_train.shape)\n",
    "#(10000,2,3)\n",
    "#打乱这10000条数据\n",
    "np.random.shuffle(data_train)\n",
    "#定义批量大小\n",
    "batch_size=100\n",
    "#进行批处理\n",
    "for i in range(0,len(data_train),batch_size):\n",
    "    x_batch_sum=np.sum(data_train[i:i+batch_size])\n",
    "    print(\"第{}批次,该批次的数据之和:{}\".format(i,x_batch_sum))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3>1.6 通用函数</h3>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "math.sin: 0.2364024\n",
      "numpy.sin: 0.010098599999999847\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "import math\n",
    "import numpy as np\n",
    "\n",
    "x = [i * 0.001 for i in np.arange(1000000)]\n",
    "start = time.clock()\n",
    "for i, t in enumerate(x):\n",
    "    x[i] = math.sin(t)\n",
    "print (\"math.sin:\", time.clock() - start )\n",
    "\n",
    "x = [i * 0.001 for i in np.arange(1000000)]\n",
    "x = np.array(x)\n",
    "start = time.clock()\n",
    "np.sin(x)\n",
    "print (\"numpy.sin:\", time.clock() - start )\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dot = 250060.8664321925\n",
      " for loop----- Computation time = 375.0ms\n",
      "dot = 250060.8664321958\n",
      " verctor version---- Computation time = 0.0ms\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "import numpy as np\n",
    "\n",
    "x1 = np.random.rand(1000000)\n",
    "x2 = np.random.rand(1000000)\n",
    "##使用循环计算向量点积\n",
    "tic = time.process_time()\n",
    "dot = 0\n",
    "for i in range(len(x1)):\n",
    "    dot+= x1[i]*x2[i]\n",
    "toc = time.process_time()\n",
    "print (\"dot = \" + str(dot) + \"\\n for loop----- Computation time = \" + str(1000*(toc - tic)) + \"ms\")\n",
    "##使用numpy函数求点积\n",
    "tic = time.process_time()\n",
    "dot = 0\n",
    "dot = np.dot(x1,x2)\n",
    "toc = time.process_time()\n",
    "print (\"dot = \" + str(dot) + \"\\n verctor version---- Computation time = \" + str(1000*(toc - tic)) + \"ms\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h3>1.7 广播机制</h3>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0]\n",
      " [10]\n",
      " [20]\n",
      " [30]]\n",
      "[0 1 2]\n",
      "A矩阵的形状:(4, 1),B矩阵的形状:(3,)\n",
      "C矩阵的形状:(4, 3)\n",
      "[[ 0  1  2]\n",
      " [10 11 12]\n",
      " [20 21 22]\n",
      " [30 31 32]]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "A = np.arange(0, 40,10).reshape(4, 1)\n",
    "B = np.arange(0, 3)\n",
    "print(A)\n",
    "print(B)\n",
    "print(\"A矩阵的形状:{},B矩阵的形状:{}\".format(A.shape,B.shape))\n",
    "C=A+B\n",
    "print(\"C矩阵的形状:{}\".format(C.shape))\n",
    "print(C)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "广播机制其实就是把两个矩阵reshape到一个同样的shape，然后进行加减"
   ]
  }
 ],
 "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}