datahandling/04-NumpyComputationArray/04-ComputationNumpyArray.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": "##  ``numpy.array`` 中的运算"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "给定一个数组，让数组中每一个数乘以2"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2024-08-22T14:47:19.739360Z",
     "start_time": "2024-08-22T14:47:19.733495Z"
    }
   },
   "source": [
    "n = 10\n",
    "L = [i for i in range(n)]"
   ],
   "outputs": [],
   "execution_count": 1
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-22T14:47:19.859121Z",
     "start_time": "2024-08-22T14:47:19.854218Z"
    }
   },
   "source": [
    "2 * L"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 2
  },
  {
   "cell_type": "code",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2024-08-22T14:47:19.885923Z",
     "start_time": "2024-08-22T14:47:19.883253Z"
    }
   },
   "source": [
    "A = []\n",
    "for e in L:\n",
    "    A.append(2*e)"
   ],
   "outputs": [],
   "execution_count": 3
  },
  {
   "cell_type": "code",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2024-08-22T14:47:19.946888Z",
     "start_time": "2024-08-22T14:47:19.912218Z"
    }
   },
   "source": [
    "n = 1000000\n",
    "L = [i for i in range(n)]"
   ],
   "outputs": [],
   "execution_count": 4
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-22T14:47:20.039403Z",
     "start_time": "2024-08-22T14:47:19.948319Z"
    }
   },
   "source": [
    "%%time\n",
    "A = []\n",
    "for e in L:\n",
    "    A.append(2*e)"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 76.3 ms, sys: 11.6 ms, total: 87.9 ms\n",
      "Wall time: 87.7 ms\n"
     ]
    }
   ],
   "execution_count": 5
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-22T14:47:20.102284Z",
     "start_time": "2024-08-22T14:47:20.041059Z"
    }
   },
   "source": [
    "%%time\n",
    "A = [2*e for e in L]"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 41.1 ms, sys: 12.7 ms, total: 53.8 ms\n",
      "Wall time: 53 ms\n"
     ]
    }
   ],
   "execution_count": 6
  },
  {
   "cell_type": "code",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2024-08-22T14:47:20.175527Z",
     "start_time": "2024-08-22T14:47:20.103437Z"
    }
   },
   "source": [
    "import numpy as np\n",
    "L = np.arange(n)"
   ],
   "outputs": [],
   "execution_count": 7
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-22T14:47:20.189046Z",
     "start_time": "2024-08-22T14:47:20.177539Z"
    }
   },
   "source": [
    "%%time\n",
    "A = np.array(2*e for e in L)"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 7.14 ms, sys: 1.53 ms, total: 8.67 ms\n",
      "Wall time: 8.69 ms\n"
     ]
    }
   ],
   "execution_count": 8
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-22T14:47:20.195035Z",
     "start_time": "2024-08-22T14:47:20.190283Z"
    }
   },
   "source": [
    "%%time\n",
    "A = 2 * L"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 1.49 ms, sys: 1.82 ms, total: 3.31 ms\n",
      "Wall time: 2.32 ms\n"
     ]
    }
   ],
   "execution_count": 9
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-22T14:47:20.200384Z",
     "start_time": "2024-08-22T14:47:20.195913Z"
    }
   },
   "source": [
    "n = 10\n",
    "L = np.arange(n)\n",
    "2 * L"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  2,  4,  6,  8, 10, 12, 14, 16, 18])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 10
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### NumPy’s UFuncs (Universal Functions)"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-22T14:47:20.205528Z",
     "start_time": "2024-08-22T14:47:20.201358Z"
    }
   },
   "source": [
    "X = np.arange(1, 16).reshape((3, 5))\n",
    "X"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2,  3,  4,  5],\n",
       "       [ 6,  7,  8,  9, 10],\n",
       "       [11, 12, 13, 14, 15]])"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 11
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-22T14:47:20.211323Z",
     "start_time": "2024-08-22T14:47:20.206999Z"
    }
   },
   "source": [
    "X + 1"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2,  3,  4,  5,  6],\n",
       "       [ 7,  8,  9, 10, 11],\n",
       "       [12, 13, 14, 15, 16]])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 12
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-22T14:47:20.215354Z",
     "start_time": "2024-08-22T14:47:20.212324Z"
    }
   },
   "source": [
    "X - 1"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4],\n",
       "       [ 5,  6,  7,  8,  9],\n",
       "       [10, 11, 12, 13, 14]])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 13
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-22T14:47:20.222540Z",
     "start_time": "2024-08-22T14:47:20.219507Z"
    }
   },
   "source": [
    "X * 2"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2,  4,  6,  8, 10],\n",
       "       [12, 14, 16, 18, 20],\n",
       "       [22, 24, 26, 28, 30]])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 14
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-22T14:47:20.226312Z",
     "start_time": "2024-08-22T14:47:20.223425Z"
    }
   },
   "source": [
    "X / 2"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.5, 1. , 1.5, 2. , 2.5],\n",
       "       [3. , 3.5, 4. , 4.5, 5. ],\n",
       "       [5.5, 6. , 6.5, 7. , 7.5]])"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 15
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-22T14:47:20.229860Z",
     "start_time": "2024-08-22T14:47:20.227288Z"
    }
   },
   "source": [
    "X // 2"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1, 1, 2, 2],\n",
       "       [3, 3, 4, 4, 5],\n",
       "       [5, 6, 6, 7, 7]])"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 16
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-22T14:47:20.233652Z",
     "start_time": "2024-08-22T14:47:20.230937Z"
    }
   },
   "source": [
    "X ** 2"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  1,   4,   9,  16,  25],\n",
       "       [ 36,  49,  64,  81, 100],\n",
       "       [121, 144, 169, 196, 225]])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 17
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-22T14:47:20.237778Z",
     "start_time": "2024-08-22T14:47:20.234874Z"
    }
   },
   "source": [
    "X % 2"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 0, 1, 0, 1],\n",
       "       [0, 1, 0, 1, 0],\n",
       "       [1, 0, 1, 0, 1]])"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 18
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-22T14:47:20.242174Z",
     "start_time": "2024-08-22T14:47:20.238990Z"
    }
   },
   "source": [
    "1 / X"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.        , 0.5       , 0.33333333, 0.25      , 0.2       ],\n",
       "       [0.16666667, 0.14285714, 0.125     , 0.11111111, 0.1       ],\n",
       "       [0.09090909, 0.08333333, 0.07692308, 0.07142857, 0.06666667]])"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 19
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-22T14:47:20.245927Z",
     "start_time": "2024-08-22T14:47:20.242995Z"
    }
   },
   "source": [
    "np.abs(X)"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  2,  3,  4,  5],\n",
       "       [ 6,  7,  8,  9, 10],\n",
       "       [11, 12, 13, 14, 15]])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 20
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-22T14:47:20.249784Z",
     "start_time": "2024-08-22T14:47:20.246897Z"
    }
   },
   "source": [
    "np.sin(X)"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.84147098,  0.90929743,  0.14112001, -0.7568025 , -0.95892427],\n",
       "       [-0.2794155 ,  0.6569866 ,  0.98935825,  0.41211849, -0.54402111],\n",
       "       [-0.99999021, -0.53657292,  0.42016704,  0.99060736,  0.65028784]])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 21
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-22T14:47:20.254129Z",
     "start_time": "2024-08-22T14:47:20.250922Z"
    }
   },
   "source": [
    "np.cos(X)"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.54030231, -0.41614684, -0.9899925 , -0.65364362,  0.28366219],\n",
       "       [ 0.96017029,  0.75390225, -0.14550003, -0.91113026, -0.83907153],\n",
       "       [ 0.0044257 ,  0.84385396,  0.90744678,  0.13673722, -0.75968791]])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 22
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-22T14:47:20.258285Z",
     "start_time": "2024-08-22T14:47:20.255282Z"
    }
   },
   "source": [
    "np.tan(X)"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.55740772e+00, -2.18503986e+00, -1.42546543e-01,\n",
       "         1.15782128e+00, -3.38051501e+00],\n",
       "       [-2.91006191e-01,  8.71447983e-01, -6.79971146e+00,\n",
       "        -4.52315659e-01,  6.48360827e-01],\n",
       "       [-2.25950846e+02, -6.35859929e-01,  4.63021133e-01,\n",
       "         7.24460662e+00, -8.55993401e-01]])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 23
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-22T14:47:20.262327Z",
     "start_time": "2024-08-22T14:47:20.259294Z"
    }
   },
   "source": [
    "np.arctan(X)"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.78539816, 1.10714872, 1.24904577, 1.32581766, 1.37340077],\n",
       "       [1.40564765, 1.42889927, 1.44644133, 1.46013911, 1.47112767],\n",
       "       [1.48013644, 1.48765509, 1.49402444, 1.49948886, 1.50422816]])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 24
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-22T14:47:20.266547Z",
     "start_time": "2024-08-22T14:47:20.263285Z"
    }
   },
   "source": [
    "np.exp(X)"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2.71828183e+00, 7.38905610e+00, 2.00855369e+01, 5.45981500e+01,\n",
       "        1.48413159e+02],\n",
       "       [4.03428793e+02, 1.09663316e+03, 2.98095799e+03, 8.10308393e+03,\n",
       "        2.20264658e+04],\n",
       "       [5.98741417e+04, 1.62754791e+05, 4.42413392e+05, 1.20260428e+06,\n",
       "        3.26901737e+06]])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 25
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-22T14:47:20.270205Z",
     "start_time": "2024-08-22T14:47:20.267281Z"
    }
   },
   "source": [
    "np.exp2(X)"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2.0000e+00, 4.0000e+00, 8.0000e+00, 1.6000e+01, 3.2000e+01],\n",
       "       [6.4000e+01, 1.2800e+02, 2.5600e+02, 5.1200e+02, 1.0240e+03],\n",
       "       [2.0480e+03, 4.0960e+03, 8.1920e+03, 1.6384e+04, 3.2768e+04]])"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 26
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-22T14:47:20.274466Z",
     "start_time": "2024-08-22T14:47:20.270881Z"
    }
   },
   "source": [
    "np.power(3, X)"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[       3,        9,       27,       81,      243],\n",
       "       [     729,     2187,     6561,    19683,    59049],\n",
       "       [  177147,   531441,  1594323,  4782969, 14348907]])"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 27
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-22T14:47:20.279615Z",
     "start_time": "2024-08-22T14:47:20.275392Z"
    }
   },
   "source": [
    "np.log(X)"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.        , 0.69314718, 1.09861229, 1.38629436, 1.60943791],\n",
       "       [1.79175947, 1.94591015, 2.07944154, 2.19722458, 2.30258509],\n",
       "       [2.39789527, 2.48490665, 2.56494936, 2.63905733, 2.7080502 ]])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 28
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-22T14:47:20.283785Z",
     "start_time": "2024-08-22T14:47:20.280610Z"
    }
   },
   "source": [
    "np.log2(X)"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.        , 1.        , 1.5849625 , 2.        , 2.32192809],\n",
       "       [2.5849625 , 2.80735492, 3.        , 3.169925  , 3.32192809],\n",
       "       [3.45943162, 3.5849625 , 3.70043972, 3.80735492, 3.9068906 ]])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 29
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-22T14:47:20.288129Z",
     "start_time": "2024-08-22T14:47:20.284882Z"
    }
   },
   "source": [
    "np.log10(X)"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.        , 0.30103   , 0.47712125, 0.60205999, 0.69897   ],\n",
       "       [0.77815125, 0.84509804, 0.90308999, 0.95424251, 1.        ],\n",
       "       [1.04139269, 1.07918125, 1.11394335, 1.14612804, 1.17609126]])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 30
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 矩阵运算"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-22T14:47:20.292495Z",
     "start_time": "2024-08-22T14:47:20.289130Z"
    }
   },
   "source": [
    "A = np.arange(4).reshape(2, 2)\n",
    "A"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 1],\n",
       "       [2, 3]])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 31
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-22T14:47:20.300518Z",
     "start_time": "2024-08-22T14:47:20.297442Z"
    }
   },
   "source": [
    "B = np.full((2, 2), 10)\n",
    "B"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10, 10],\n",
       "       [10, 10]])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 32
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-22T14:47:20.304241Z",
     "start_time": "2024-08-22T14:47:20.301401Z"
    }
   },
   "source": [
    "A + B"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10, 11],\n",
       "       [12, 13]])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 33
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-22T14:47:20.307626Z",
     "start_time": "2024-08-22T14:47:20.305035Z"
    }
   },
   "source": [
    "A - B"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-10,  -9],\n",
       "       [ -8,  -7]])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 34
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-22T14:47:20.370065Z",
     "start_time": "2024-08-22T14:47:20.366753Z"
    }
   },
   "source": [
    "A * B"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0, 10],\n",
       "       [20, 30]])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 35
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-22T14:47:20.463848Z",
     "start_time": "2024-08-22T14:47:20.460358Z"
    }
   },
   "source": [
    "A.dot(B)"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10, 10],\n",
       "       [50, 50]])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 36
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "矩阵的转置"
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-22T14:47:20.525341Z",
     "start_time": "2024-08-22T14:47:20.522075Z"
    }
   },
   "source": [
    "A.T"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 2],\n",
       "       [1, 3]])"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 37
  },
  {
   "cell_type": "code",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2024-08-22T14:47:20.533503Z",
     "start_time": "2024-08-22T14:47:20.531255Z"
    }
   },
   "source": [
    "C = np.full((3, 3), 666)"
   ],
   "outputs": [],
   "execution_count": 38
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-22T14:48:32.922587Z",
     "start_time": "2024-08-22T14:48:32.888408Z"
    }
   },
   "cell_type": "code",
   "source": "A + C ",
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "operands could not be broadcast together with shapes (2,2) (3,3) ",
     "output_type": "error",
     "traceback": [
      "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m",
      "\u001B[0;31mValueError\u001B[0m                                Traceback (most recent call last)",
      "Cell \u001B[0;32mIn[55], line 1\u001B[0m\n\u001B[0;32m----> 1\u001B[0m \u001B[43mA\u001B[49m\u001B[43m \u001B[49m\u001B[38;5;241;43m+\u001B[39;49m\u001B[43m \u001B[49m\u001B[43mC\u001B[49m \n",
      "\u001B[0;31mValueError\u001B[0m: operands could not be broadcast together with shapes (2,2) (3,3) "
     ]
    }
   ],
   "execution_count": 55
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 向量和矩阵的运算"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 加法"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2024-08-22T14:47:20.549859Z",
     "start_time": "2024-08-22T14:47:20.547763Z"
    }
   },
   "source": [
    "v = np.array([1, 2])"
   ],
   "outputs": [],
   "execution_count": 39
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-22T14:47:20.575281Z",
     "start_time": "2024-08-22T14:47:20.572230Z"
    }
   },
   "source": [
    "v + A"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 3],\n",
       "       [3, 5]])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 40
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": "``v + A`` 是可以的，``numpy.array``的broadcast"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "vstack 堆叠"
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-22T14:47:20.587252Z",
     "start_time": "2024-08-22T14:47:20.584053Z"
    }
   },
   "source": [
    "np.vstack([v] * A.shape[0])"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [1, 2]])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 41
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-22T14:47:20.606454Z",
     "start_time": "2024-08-22T14:47:20.603075Z"
    }
   },
   "source": [
    "np.vstack([v] * A.shape[0]) + A"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 3],\n",
       "       [3, 5]])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 42
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "#### tile 方法： \n",
    "copy形, (2,1) 就是 copy ２行， 列不copy"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-22T14:47:20.630563Z",
     "start_time": "2024-08-22T14:47:20.626963Z"
    }
   },
   "source": [
    "np.tile(v, (2, 1))"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [1, 2]])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 43
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-22T14:47:20.647597Z",
     "start_time": "2024-08-22T14:47:20.644337Z"
    }
   },
   "source": [
    "np.tile(v, (2, 1)) + A"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 3],\n",
       "       [3, 5]])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 44
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-22T14:47:20.656762Z",
     "start_time": "2024-08-22T14:47:20.653349Z"
    }
   },
   "source": [
    "np.tile(v, (2, 2))"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 1, 2],\n",
       "       [1, 2, 1, 2]])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 45
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 乘法"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-22T14:47:20.675689Z",
     "start_time": "2024-08-22T14:47:20.672644Z"
    }
   },
   "source": [
    "v * A"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0, 2],\n",
       "       [2, 6]])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 46
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-22T14:47:20.694660Z",
     "start_time": "2024-08-22T14:47:20.691550Z"
    }
   },
   "source": [
    "v.dot(A)"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 7])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 47
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-22T14:47:20.700041Z",
     "start_time": "2024-08-22T14:47:20.696990Z"
    }
   },
   "source": [
    "A.dot(v)"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 8])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 48
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 矩阵的逆\n",
    "\n",
    "矩阵与矩阵相乘 = 单位阵\n",
    "\n",
    "- 方阵才有逆矩阵\n",
    "- 非放阵我们可以求违逆矩阵， 非１无限接近０的"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-22T14:47:20.722995Z",
     "start_time": "2024-08-22T14:47:20.719511Z"
    }
   },
   "source": [
    "np.linalg.inv(A)"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-1.5,  0.5],\n",
       "       [ 1. ,  0. ]])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 49
  },
  {
   "cell_type": "code",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2024-08-22T14:47:20.734112Z",
     "start_time": "2024-08-22T14:47:20.732121Z"
    }
   },
   "source": [
    "invA = np.linalg.inv(A)"
   ],
   "outputs": [],
   "execution_count": 50
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-22T14:47:20.752614Z",
     "start_time": "2024-08-22T14:47:20.748932Z"
    }
   },
   "source": [
    "A.dot(invA)"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0.],\n",
       "       [0., 1.]])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 51
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-22T14:47:20.779491Z",
     "start_time": "2024-08-22T14:47:20.776188Z"
    }
   },
   "source": [
    "invA.dot(A)"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0.],\n",
       "       [0., 1.]])"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 52
  },
  {
   "cell_type": "code",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2024-08-22T14:47:20.787535Z",
     "start_time": "2024-08-22T14:47:20.785447Z"
    }
   },
   "source": [
    "X = np.arange(16).reshape((2, 8))"
   ],
   "outputs": [],
   "execution_count": 53
  },
  {
   "cell_type": "code",
   "metadata": {
    "scrolled": true,
    "ExecuteTime": {
     "end_time": "2024-08-22T14:47:21.029809Z",
     "start_time": "2024-08-22T14:47:20.798363Z"
    }
   },
   "source": [
    "invX = np.linalg.inv(X)"
   ],
   "outputs": [
    {
     "ename": "LinAlgError",
     "evalue": "Last 2 dimensions of the array must be square",
     "output_type": "error",
     "traceback": [
      "\u001B[0;31m---------------------------------------------------------------------------\u001B[0m",
      "\u001B[0;31mLinAlgError\u001B[0m                               Traceback (most recent call last)",
      "Cell \u001B[0;32mIn[54], line 1\u001B[0m\n\u001B[0;32m----> 1\u001B[0m invX \u001B[38;5;241m=\u001B[39m \u001B[43mnp\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43mlinalg\u001B[49m\u001B[38;5;241;43m.\u001B[39;49m\u001B[43minv\u001B[49m\u001B[43m(\u001B[49m\u001B[43mX\u001B[49m\u001B[43m)\u001B[49m\n",
      "File \u001B[0;32m/opt/anaconda3/envs/myenv3.10/lib/python3.10/site-packages/numpy/linalg/_linalg.py:602\u001B[0m, in \u001B[0;36minv\u001B[0;34m(a)\u001B[0m\n\u001B[1;32m    600\u001B[0m a, wrap \u001B[38;5;241m=\u001B[39m _makearray(a)\n\u001B[1;32m    601\u001B[0m _assert_stacked_2d(a)\n\u001B[0;32m--> 602\u001B[0m \u001B[43m_assert_stacked_square\u001B[49m\u001B[43m(\u001B[49m\u001B[43ma\u001B[49m\u001B[43m)\u001B[49m\n\u001B[1;32m    603\u001B[0m t, result_t \u001B[38;5;241m=\u001B[39m _commonType(a)\n\u001B[1;32m    605\u001B[0m signature \u001B[38;5;241m=\u001B[39m \u001B[38;5;124m'\u001B[39m\u001B[38;5;124mD->D\u001B[39m\u001B[38;5;124m'\u001B[39m \u001B[38;5;28;01mif\u001B[39;00m isComplexType(t) \u001B[38;5;28;01melse\u001B[39;00m \u001B[38;5;124m'\u001B[39m\u001B[38;5;124md->d\u001B[39m\u001B[38;5;124m'\u001B[39m\n",
      "File \u001B[0;32m/opt/anaconda3/envs/myenv3.10/lib/python3.10/site-packages/numpy/linalg/_linalg.py:202\u001B[0m, in \u001B[0;36m_assert_stacked_square\u001B[0;34m(*arrays)\u001B[0m\n\u001B[1;32m    200\u001B[0m m, n \u001B[38;5;241m=\u001B[39m a\u001B[38;5;241m.\u001B[39mshape[\u001B[38;5;241m-\u001B[39m\u001B[38;5;241m2\u001B[39m:]\n\u001B[1;32m    201\u001B[0m \u001B[38;5;28;01mif\u001B[39;00m m \u001B[38;5;241m!=\u001B[39m n:\n\u001B[0;32m--> 202\u001B[0m     \u001B[38;5;28;01mraise\u001B[39;00m LinAlgError(\u001B[38;5;124m'\u001B[39m\u001B[38;5;124mLast 2 dimensions of the array must be square\u001B[39m\u001B[38;5;124m'\u001B[39m)\n",
      "\u001B[0;31mLinAlgError\u001B[0m: Last 2 dimensions of the array must be square"
     ]
    }
   ],
   "execution_count": 54
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 矩阵的伪逆"
   ]
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-22T15:02:38.130318Z",
     "start_time": "2024-08-22T15:02:38.121150Z"
    }
   },
   "source": [
    "pinvX = np.linalg.pinv(X)\n",
    "pinvX"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-1.35416667e-01,  5.20833333e-02],\n",
       "       [-1.01190476e-01,  4.16666667e-02],\n",
       "       [-6.69642857e-02,  3.12500000e-02],\n",
       "       [-3.27380952e-02,  2.08333333e-02],\n",
       "       [ 1.48809524e-03,  1.04166667e-02],\n",
       "       [ 3.57142857e-02, -1.73472348e-18],\n",
       "       [ 6.99404762e-02, -1.04166667e-02],\n",
       "       [ 1.04166667e-01, -2.08333333e-02]])"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 56
  },
  {
   "cell_type": "code",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-22T15:02:44.946701Z",
     "start_time": "2024-08-22T15:02:44.942271Z"
    }
   },
   "source": [
    "X.dot(pinvX)"
   ],
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.00000000e+00, -1.38777878e-16],\n",
       "       [ 4.44089210e-16,  1.00000000e+00]])"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 57
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": "矩阵的伪逆又被称为“广义逆矩阵”。中文wiki链接: [https://zh.wikipedia.org/wiki/%E5%B9%BF%E4%B9%89%E9%80%86%E9%98%B5](https://zh.wikipedia.org/wiki/%E5%B9%BF%E4%B9%89%E9%80%86%E9%98%B5)"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "### 矩阵的转置。\n",
    "\n",
    "矩阵的转置是一种基本的线性代数操作，通过将原矩阵的行转换为列，列转换为行来创建一个新的矩阵。 对于向量，转置实际上不会改变向量的形状，因为向量本身只有一行或一列。因此，向量的转置结果与原向量相同。 例如，向量A[1, 2, 3]的转置表示为A^T = [[1], [2], [3]]。 对于2维矩阵B = [[1, 2, 3], [4, 5, 6]]，这是一个2x3的矩阵。它的转置操作将其变为一个3x2的矩阵，即B^T = [[1, 4], [2, 5], [3, 6]]。"
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "mat 方法用于将二维结构的数值型数据对象转化为 Numpy 的矩阵类型。\n",
    "\n",
    "- 方法：numpy.mat(data, dtype=None)，其中 data 要求为一个数值型的二维数组或者列表或者元组，dtype 为矩阵的数据类型。"
   ]
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-23T04:05:29.695301Z",
     "start_time": "2024-08-23T04:05:29.691319Z"
    }
   },
   "cell_type": "code",
   "source": [
    "import numpy as np \n",
    "arr=np.array([[98,89],[64,90],[60,56],[92,78],[32,45],[48,30]])  \n",
    "print(type(arr))  \n",
    "matrixarr=np.asmatrix(arr)  \n",
    "print(type(matrixarr))"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n",
      "<class 'numpy.matrix'>\n"
     ]
    }
   ],
   "execution_count": 3
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-23T04:10:06.420386Z",
     "start_time": "2024-08-23T04:10:06.417167Z"
    }
   },
   "cell_type": "code",
   "source": [
    "fruit_price=np.array([[5,4,3]])  \n",
    "fudu=np.array([1.5,0.75,3])  \n",
    "print('水果价格浮动后价格为:\\n',fruit_price*fudu)"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "水果价格浮动后价格为:\n",
      " [[7.5 3.  9. ]]\n"
     ]
    }
   ],
   "execution_count": 4
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "### 矩阵与矩阵的乘法"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "运算符号：@或*。当我们使用 ndarray 存储矩阵时，需要使用 @ 实现矩阵的乘法以区别于二维数组的数乘。当我们使用 matrix 存储矩阵时，我们可以直接用*完成矩阵的乘法。\n",
    "\n",
    "- 矩阵乘法公式： 设矩阵 A 是一个 m×n 的矩阵，矩阵 B 是一个 n×p 的矩阵，那么它们的乘积 C 是一个 m×p 的矩阵\n",
    "- 运算规则：需要注意进行矩阵乘法的两个矩阵要求前一个矩阵的列要和后一个矩阵的行的轴长相同，只有保证这个条件才能够进行矩阵乘法。也就是说前面的矩阵的列数和后面矩阵的行数一致两个矩阵才能点乘。 同时矩阵乘法是满足结合律并不满足交换律的，即 ABC 等于 A(BC)，不等于 ACB。\n",
    "- 我们的数据的维度往往是不符合要求的，这是就需要进行升维。升维主要有两个方法，分别为 reshape 方法和 newaxis 方法，下面我们就来看看如何使用这两种方法对数组进行升维吧！"
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "#### reshape 方法\n",
    "- 方法：numpy.reshape(arr, newshape)，其中 arr 为待处理数组，newshape 新数组的形状。\n"
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "我们利用 reshape 函数成功将一个大小为 6 的一维数组，升维成了一个二行三列的二维数组，这样便可以实现矩阵乘法。"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-23T05:37:39.691703Z",
     "start_time": "2024-08-23T05:37:39.681534Z"
    }
   },
   "cell_type": "code",
   "source": [
    "arr = np.array([1,2,3,4,5,6])  \n",
    "arr2=np.reshape(arr,(2,3))  \n",
    "print(arr2)"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n"
     ]
    }
   ],
   "execution_count": 5
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "#### Newaxis 方法\n",
    "- np.newaxis() 是 NumPy 中的一个函数，用于创建一个新的轴，用于多维数组的扩展。它返回一个表示新轴的整数索引。\n",
    "\n",
    "\n"
   ]
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-23T05:39:49.120328Z",
     "start_time": "2024-08-23T05:39:49.116244Z"
    }
   },
   "cell_type": "code",
   "source": [
    "arr = np.array([1,2,3,4,5,6])  \n",
    "arr2=arr[np.newaxis,:]  \n",
    "print('升维后的数组为{}，形状为{}'.format(arr2,arr2.shape))"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "升维后的数组为[[1 2 3 4 5 6]]，形状为(1, 6)\n"
     ]
    }
   ],
   "execution_count": 6
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-23T05:41:23.940425Z",
     "start_time": "2024-08-23T05:41:23.937365Z"
    }
   },
   "cell_type": "code",
   "source": [
    "arr = np.array([1,2,3,4,5,6])  \n",
    "arr2=arr[:,np.newaxis]  \n",
    "print('升维后的数组为{}，形状为{}'.format(arr2,arr2.shape))"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "升维后的数组为[[1]\n",
      " [2]\n",
      " [3]\n",
      " [4]\n",
      " [5]\n",
      " [6]]，形状为(6, 1)\n"
     ]
    }
   ],
   "execution_count": 7
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "### dot 方法\n",
    "dot 方法有两个功能分别为向量点积和矩阵乘法。当两个数组为二维数组（矩阵）且满足矩阵乘法的要求时，利用 dot 方法便能够实现矩阵乘法；当输入的两个数组的形状相同时，利用 dot 方法就能求得这两个数组的点积（所谓矩阵的点积即两个数组对应位置的元素相乘，最后将所有位置的乘法结果相加便得到两个数组的点积）。\n",
    "\n",
    "- 方法：np.dot(A,B)，其中 A 和 B 为进行运算的数组。\n",
    "\n"
   ]
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-09-07T02:34:42.994496Z",
     "start_time": "2024-09-07T02:34:42.989930Z"
    }
   },
   "cell_type": "code",
   "source": [
    "import numpy as np \n",
    "fruit_price=np.array([[5,4,3]])  \n",
    "jinshu=np.array([[2],[3],[1]])  \n",
    "print('水果的总价格为:\\n',fruit_price@jinshu)  \n",
    "print('水果的总价格为:\\n',np.dot(fruit_price,jinshu))\n",
    "print(np.sum(np.dot(fruit_price,jinshu)))\n",
    "#  numpy 数组提供的矩阵乘法符号 @ 或者 dot 方法实现矩阵乘法，便可以非常方便地获取总价格\n"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "水果的总价格为:\n",
      " [[25]]\n",
      "水果的总价格为:\n",
      " [[25]]\n",
      "25\n"
     ]
    }
   ],
   "execution_count": 2
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "### matmul 方法\n",
    "\n",
    "matmul 方法用于实现矩阵乘法，如果两个输入的数组其中一个为一维，另外一个数组为二维，该函数会自动对一维数组进行升维然后实现矩阵乘法。\n",
    "\n",
    "- 方法：matmul(A,B)。\n"
   ]
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "下面同样我们就以顾客购买水果为例，为大家展示矩阵乘法。例如：张三想要买两斤苹果、三斤李子、一斤桃子，那么如何通过 matmul 方法求得水果的总价呢？"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-23T05:48:36.491090Z",
     "start_time": "2024-08-23T05:48:36.487365Z"
    }
   },
   "cell_type": "code",
   "source": [
    "fruit_price=np.asmatrix([[5,4,3]])\n",
    "jinshu=np.array([2,3,1])\n",
    "print('np.matmul，水果的总价格为:\\n',np.matmul(fruit_price,jinshu))\n",
    "\n",
    "# print('fruit_price*jinshu，水果的总价格为:\\n',fruit_price*jinshu)  报错\n"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "np.matmul，水果的总价格为:\n",
      " [[25]]\n"
     ]
    }
   ],
   "execution_count": 15
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}