2023/python/2-numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "2ba54dca-483f-43d5-956d-860e882e5d14",
   "metadata": {},
   "source": [
    "# 数据分析实训之 Numpy\n",
    "\n",
    "## Numpy 简介\n",
    "\n",
    "- NumPy 是 Python 语言的一个扩展程序库。支持高阶大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。\n",
    "    - Numpy 官方网址：https://numpy.org\n",
    "    - Numpy 中文文档：https://www.numpy.org.cn/\n",
    "- Numpy 的 ndarray 与 Python 的 list：\n",
    "    - list 列表本身是为了处理更广泛、更通用的目的而构建的\n",
    "    - ndarray 对于处理数组类型结构的数据会更加方便    \n",
    "\n",
    "![](https://vip2.loli.io/2023/11/30/VIevXzfbCwdTGKi.jpg)\n",
    "\n",
    "在Python中，列表是一种内置的数据结构，可以容纳不同数据类型的元素。然而，列表的灵活性是以内存效率为代价的。\n",
    "\n",
    "Python的NumPy库支持优化的数值数组和矩阵操作。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "d2905a56-0a11-478f-8355-9b6cbe15029f",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# importing numpy package\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f57d0f9-9137-4bd3-b0c8-7a81c352436e",
   "metadata": {},
   "source": [
    "在下面这个例子中，将创建一个包含1000个元素的Python列表和一个NumPy数组。将计算每个元素的大小以及两个容器的整体大小，并将在内存消耗方面进行比较。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "9457cec5-b48a-4b8d-821f-5282e9ffc37b",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Size of each element of list in bytes:  48\n",
      "Size of the whole list in bytes:  48000\n"
     ]
    }
   ],
   "source": [
    "# importing system module\n",
    "import sys\n",
    " \n",
    "# declaring a list of 1000 elements\n",
    "S= range(1000)\n",
    " \n",
    "# printing size of each element of the list\n",
    "print(\"Size of each element of list in bytes: \",sys.getsizeof(S))\n",
    " \n",
    "# printing size of the whole list\n",
    "print(\"Size of the whole list in bytes: \",sys.getsizeof(S)*len(S))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "5d5807db-f22a-4cdd-b17d-ea694f79deef",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Size of each element of the Numpy array in bytes:  8\n",
      "Size of the whole Numpy array in bytes:  8000\n"
     ]
    }
   ],
   "source": [
    "# declaring a Numpy array of 1000 elements\n",
    "D= np.arange(1000)\n",
    " \n",
    "# printing size of each element of the Numpy array\n",
    "print(\"Size of each element of the Numpy array in bytes: \",D.itemsize)\n",
    " \n",
    "# printing size of the whole Numpy array\n",
    "print(\"Size of the whole Numpy array in bytes: \",D.size*D.itemsize)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9b63fd7-e088-4734-92f6-2e487b43e10d",
   "metadata": {},
   "source": [
    "- Numpy运算速度快：\n",
    "    - 它将常用的数学函数都支持向量化运算，使得这些数学函数能够直接对数组进行操作，将本来需要在Python级别进行的循环，放到C语言的运算中，明显地提高了程序的运算速度。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9029f5a5-71a5-4172-95d4-8c7d45a0b007",
   "metadata": {},
   "source": [
    "在下面这个例子中，将创建两个包含1000000个元素的Python列表和两个包含1000000个元素的NumPy数组。将分别对列表和NumPy数组中的元素进行乘法运算，并分析执行这两个容器所需的时间差异，以确定哪一个执行操作所需的时间较短。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "e46445b0-eb46-4a84-a542-87c15c009192",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# importing required packages\n",
    "import time\n",
    "\n",
    "# size of arrays and lists\n",
    "size = 100_0000\n",
    "\n",
    "# declaring lists\n",
    "list1 = range(size)\n",
    "list2 = range(size)\n",
    "\n",
    "# declaring arrays\n",
    "array1 = np.arange(size)\n",
    "array2 = np.arange(size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "c9e4128f-b189-4971-8056-0455ef8e0f0e",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "82.8 ms ± 44.5 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit [(a * b) for a, b in zip(list1, list2)]\n",
    "# Time taken by Lists to perform multiplication"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "d4a68b2f-108c-4316-871b-13f8ba35173e",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "979 µs ± 2.15 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit array1 * array2\n",
    "# Time taken by NumPy Arrays to perform multiplication"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8880484-3aa7-489c-825e-ea75b4b664b0",
   "metadata": {},
   "source": [
    "- Numpy 要点：\n",
    "    - 我们可以使用 NumPy.array() 在Python中创建一个N维数组。\n",
    "    - 数组默认是同构的（Homogeneous），这意味着数组内的数据必须是相同的数据类型。（注意：你也可以创建一个结构化数组）\n",
    "    - 支持逐元素（Element-wise）操作。\n",
    "    - NumPy 数组具有各种函数、方法和变量，以简化矩阵计算任务。\n",
    "    - 数组的元素在内存中是连续存储的。例如，二维数组的所有行必须具有相同数量的列。三维数组必须在每个轴上具有相同数量的行和列。\n",
    "    \n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e78d5dea-e39d-4b22-933e-765a213dde6d",
   "metadata": {},
   "source": [
    "## Numpy的array基本操作练习\n",
    "\n",
    "> <time>10 min</time>\n",
    "\n",
    "通过具体操作直观了解 `ndarray` 的关键属性：维度（ndim）、形状（shape）、数值类型（dtype）等。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8fa2b98-4530-4e17-baa8-45d88154b700",
   "metadata": {},
   "source": [
    "### 初始化"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34deb9d1-b212-447b-a75b-e96f8ce9617b",
   "metadata": {},
   "source": [
    "首先引入numpy模块"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "45f32653-4e35-4969-97fc-bf416133083b",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "87337ae0-0740-4d50-924d-98599e694630",
   "metadata": {},
   "source": [
    "### 操作练习"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f8bee3d-adeb-4f92-8856-f73ab950cf1c",
   "metadata": {},
   "source": [
    "定义两个array：np1和np2 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "c9bd28d5-d011-490d-a2cb-444fd960b38b",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "np1 = np.array([1,2,3])\n",
    "np2 = np.array([3,4,5])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b8df9836-f3fe-4e1e-8333-b3e4a358ea72",
   "metadata": {},
   "source": [
    "将上述两个array相加，并输出结果进行查看。直观感受一下array相加操作。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "9f914d67-2d5a-4160-922f-07d3e573b56f",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4 6 8]\n"
     ]
    }
   ],
   "source": [
    "print(np1 + np2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "cbda3cd8-a703-4a42-907c-9f178b4fe062",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([4, 6, 8])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 基本运算\n",
    "\n",
    "np1 + 3       # nd.array + int\n",
    "np2 + 3.2       # nd.array + float\n",
    "np1 + [3,4,5] # nd.array + list"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e5968fe0-489f-477c-bdd5-0e6acfbfb12d",
   "metadata": {},
   "source": [
    "我们再打印输出维度(ndim)、形状(shape)、数值类型(dtype)等array的属性信息，直观感受一下。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "bf131209-4004-4d50-8daa-baf8fb0d79f9",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 (3,) int64\n"
     ]
    }
   ],
   "source": [
    "print(np1.ndim, np1.shape, np1.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90b61737-2abc-42ed-97df-f9077c201a9d",
   "metadata": {},
   "source": [
    "接下来我们再做一个改变array维度的操作，并直观感受一下。\n",
    "- 初始化一个一维矩阵（1 x 6）\n",
    "- 将一维矩阵改为二维矩阵（2 x 3）\n",
    "- 查看改变后矩阵的属性信息"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "db14193d-80e8-4ac0-ac5a-db271d0ee81f",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5 6]\n",
      "[[1 2 3]\n",
      " [4 5 6]]\n",
      "2 (2, 3) int64\n"
     ]
    }
   ],
   "source": [
    "np3 = np.array([1,2,3,4,5,6])\n",
    "print(np3)\n",
    "\n",
    "np3 = np3.reshape([2,3])\n",
    "print(np3)\n",
    "\n",
    "print(np3.ndim, np3.shape, np3.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4a50791-01ee-43a6-b2ce-99a2618d4101",
   "metadata": {},
   "source": [
    "## Numpy 中的数值精度\n",
    "\n",
    "在使用Python Numpy进行数据运算时，不同数据类型的精度存在明显的区别。Python的数据类型int、float并不支持无限精度，因此在进行高精运算时容易出现误差。常用的Numpy数据类型有float32、float64、complex64等，其中float64与double精度相同，为**双精度**浮点数。\n",
    "\n",
    "对于float64数据类型的运算，其精度约为15位有效数字，也就是说在进行超过15位有效数字的计算时，可能出现误差。同时，Numpy库中的一些函数也有精度限制，如原生实现的cos、sin等函数在小数点后10位左右开始出现精度损失。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "8c9d1fdc-c675-474e-a2f1-d26e0a7b651a",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'0.1000000000000000055511151231257827021181583404541015625000000000000000000000000000000000000000000000000000000000000000000000000000'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "format(np.float128(0.1), '.130f')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "742f2d79-3e5e-41bc-9c0a-05e10f663fbe",
   "metadata": {},
   "source": [
    "- NumPy数值类型的固定大小可能在数值需要的内存超过数据类型可用内存时引起溢出错误。例如，对于64位整数，numpy.power正确计算 100 ** 8，但对于32位整数，结果为1874919424（错误）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "87b75019-89d6-4bc9-9f42-bd80bc3f1457",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10000000000000000"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.power(100, 8, dtype=np.int64)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "5cab0a52-0547-46fa-ae96-a03ab5aefc0b",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1874919424"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.power(100, 8, dtype=np.int32)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bcb8f273-3ceb-4497-910e-252412edd9d1",
   "metadata": {},
   "source": [
    "NumPy和Python整数类型在整数溢出方面的行为差异显著，可能会让用户感到困惑，因为他们期望NumPy整数的行为类似于Python的int。与NumPy不同，Python的int大小是灵活的。这意味着Python整数可以扩展以容纳任何整数，不会发生溢出。\n",
    "\n",
    "NumPy提供了 `numpy.iinfo` 和 `numpy.finfo` 来验证NumPy整数和浮点数值的最小或最大值。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "8295d227-d39c-49d9-ace9-c45c3bc8891c",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "iinfo(min=-9223372036854775808, max=9223372036854775807, dtype=int64)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.iinfo(int) # Bounds of the default integer on this system."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "d0dc5eab-83ff-4b2b-9478-54a8ef4e1d66",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "iinfo(min=-2147483648, max=2147483647, dtype=int32)"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.iinfo(np.int32) # Bounds of a 32-bit integer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "d7974b28-1b92-4a4c-98f3-29343f69070d",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "iinfo(min=-9223372036854775808, max=9223372036854775807, dtype=int64)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.iinfo(np.int64) # Bounds of a 64-bit integer"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f3975d9a-bc4d-44a3-8c27-cee3e00d066b",
   "metadata": {
    "tags": []
   },
   "source": [
    "如果64位整数仍然太小，结果可能会转换为浮点数。浮点数提供了一个更大但不精确的可能值范围。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "738aa366-20d9-4cfc-8107-f64d62cfc4a7",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.power(100, 100, dtype=np.int64) # Incorrect even with 64-bit int"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "718d4947-388c-4e3f-8786-d48b79e7027f",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1e+200"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.power(100, 100, dtype=np.float64)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "d9b657c1-ab5c-4e66-a603-ec27545fd592",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "finfo(resolution=0.001, min=-6.55040e+04, max=6.55040e+04, dtype=float16)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.finfo(np.float16)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "c2cbae9e-482d-4396-94dd-895afc21c09e",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Machine parameters for float16\n",
      "---------------------------------------------------------------\n",
      "precision =   3   resolution = 1.00040e-03\n",
      "machep =    -10   eps =        9.76562e-04\n",
      "negep =     -11   epsneg =     4.88281e-04\n",
      "minexp =    -14   tiny =       6.10352e-05\n",
      "maxexp =     16   max =        6.55040e+04\n",
      "nexp =        5   min =        -max\n",
      "smallest_normal = 6.10352e-05   smallest_subnormal = 5.96046e-08\n",
      "---------------------------------------------------------------\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(np.finfo(np.float16))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "490e1be5-8898-49a3-a23e-c1316a2a384b",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Machine parameters for float32\n",
      "---------------------------------------------------------------\n",
      "precision =   6   resolution = 1.0000000e-06\n",
      "machep =    -23   eps =        1.1920929e-07\n",
      "negep =     -24   epsneg =     5.9604645e-08\n",
      "minexp =   -126   tiny =       1.1754944e-38\n",
      "maxexp =    128   max =        3.4028235e+38\n",
      "nexp =        8   min =        -max\n",
      "smallest_normal = 1.1754944e-38   smallest_subnormal = 1.4012985e-45\n",
      "---------------------------------------------------------------\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(np.finfo(np.float32))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "612c7075-67dc-4939-b461-df0f2dbfa997",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Machine parameters for float64\n",
      "---------------------------------------------------------------\n",
      "precision =  15   resolution = 1.0000000000000001e-15\n",
      "machep =    -52   eps =        2.2204460492503131e-16\n",
      "negep =     -53   epsneg =     1.1102230246251565e-16\n",
      "minexp =  -1022   tiny =       2.2250738585072014e-308\n",
      "maxexp =   1024   max =        1.7976931348623157e+308\n",
      "nexp =       11   min =        -max\n",
      "smallest_normal = 2.2250738585072014e-308   smallest_subnormal = 4.9406564584124654e-324\n",
      "---------------------------------------------------------------\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(np.finfo(np.float64))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "47586580-553e-4d74-a59e-3e2e81808f71",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Machine parameters for float128\n",
      "---------------------------------------------------------------\n",
      "precision =  18   resolution = 1e-18\n",
      "machep =    -63   eps =        1.084202172485504434e-19\n",
      "negep =     -64   epsneg =     5.42101086242752217e-20\n",
      "minexp = -16382   tiny =       3.3621031431120935063e-4932\n",
      "maxexp =  16384   max =        1.189731495357231765e+4932\n",
      "nexp =       15   min =        -max\n",
      "smallest_normal = 3.3621031431120935063e-4932   smallest_subnormal = 4e-4951\n",
      "---------------------------------------------------------------\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(np.finfo(np.float128))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "93d702ae-10a9-4e69-b972-7a690c9d23ad",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Machine parameters for float128\n",
      "---------------------------------------------------------------\n",
      "precision =  18   resolution = 1e-18\n",
      "machep =    -63   eps =        1.084202172485504434e-19\n",
      "negep =     -64   epsneg =     5.42101086242752217e-20\n",
      "minexp = -16382   tiny =       3.3621031431120935063e-4932\n",
      "maxexp =  16384   max =        1.189731495357231765e+4932\n",
      "nexp =       15   min =        -max\n",
      "smallest_normal = 3.3621031431120935063e-4932   smallest_subnormal = 4e-4951\n",
      "---------------------------------------------------------------\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(np.finfo(np.complex256))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6caea39b-a2de-4ac1-9d2b-fd9cf387d36c",
   "metadata": {},
   "source": [
    "Python的浮点数通常是64位浮点数，几乎等同于np.float64。在一些不寻常的情况下，使用更高精度的浮点数可能会很有用。在NumPy中是否可以实现这一点取决于硬件和开发环境：具体而言，x86架构的机器提供80位精度的硬件浮点数，而大多数C编译器将其提供为long double类型，但MSVC（Windows版本的标准编译器）将long double定义为double（64位）。NumPy将编译器的long double提供为np.longdouble（对于复数为np.clongdouble）。您可以使用np.finfo(np.longdouble)来查看NumPy提供的内容。\n",
    "\n",
    "NumPy不提供比C的long double更高精度的dtype；特别是，128位IEEE四倍精度数据类型（FORTRAN的REAL*16）不可用。\n",
    "\n",
    "为了实现有效的内存对齐，np.longdouble通常使用零比特填充，填充到96位或128位。哪种填充方式更有效取决于硬件和开发环境；通常在32位系统上，它们填充到96位，而在64位系统上，它们通常填充到128位。np.longdouble填充到系统默认值；np.float96和np.float128是为那些想要特定填充的用户提供的。尽管名称中带有96和128，但np.float96和np.float128提供的精度仅与np.longdouble相同，即在大多数x86架构的机器上为80位，在标准Windows版本上为64位。\n",
    "\n",
    "请注意，即使np.longdouble提供比Python的float更高的精度，由于Python经常强制将值转换为float，很容易失去这些额外的精度。例如，百分比格式化运算符要求其参数转换为标准Python类型，因此即使请求许多小数位，也无法保留扩展精度。可以使用值1 + np.finfo(np.longdouble).eps来测试您的代码。\n",
    "\n",
    "See: https://numpy.org/doc/stable/user/basics.types.html"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e40d5de4-62a0-47d7-902f-3365266b0ca8",
   "metadata": {},
   "source": [
    "## Numpy的数据切片操作练习\n",
    "> <time>10 min</time>\n",
    "\n",
    "除了能够一次访问一个元素之外，Numpy 还提供了访问 ndarray 子集的方式，称之为切片。切片方式是在方括号里用冒号分隔起始和结束索引"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aca1aa2b-171f-4a75-b3a0-9769788d6a6a",
   "metadata": {},
   "source": [
    "### 初始化矩阵"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d0c8d57-2dfa-4241-8ca4-37f6c6e2b490",
   "metadata": {},
   "source": [
    "首先初始化一个6*6的矩阵"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "0dbbfcc1-418b-4c81-92ab-a2855b934446",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 0  1  2  3  4  5]\n",
      " [10 11 12 13 14 15]\n",
      " [20 21 22 23 24 25]\n",
      " [30 31 32 33 34 35]\n",
      " [40 41 42 43 44 45]\n",
      " [50 51 52 53 54 55]]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[0,1,2,3,4,5],\n",
    "              [10,11,12,13,14,15],\n",
    "              [20,21,22,23,24,25],\n",
    "              [30,31,32,33,34,35],\n",
    "              [40,41,42,43,44,45],\n",
    "              [50,51,52,53,54,55]])\n",
    "\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e5dfccb8-3f49-4cee-8eb7-06c72ca43606",
   "metadata": {},
   "source": [
    "### 进行各种不同的数据切片操作\n",
    "\n",
    "<div class=\"sl-block is-focused\" data-block-type=\"image\" style=\"min-width: 1px; min-height: 1px; width: 599px; height: 297px; left: 340.5px; top: 377px;\" data-name=\"image-286fe5\" data-origin-id=\"27673e392cc92b12fb2a206b0c7bc27b\"><div class=\"sl-block-content\" style=\"z-index: 17;\"><img style=\"\" data-natural-width=\"772\" data-natural-height=\"383\" data-lazy-loaded=\"\" src=\"https://i.loli.net/2019/07/27/5d3c36c102f6387120.png\"></div></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4740b0cc-f202-4cb3-8002-29469a098c67",
   "metadata": {},
   "source": [
    "取矩阵第1行、第4列和第5列的两个数据切片。这里需要注意索引都是从0开始，所以第1行的索引值参数是“0”，而第4列的索引值是“3”。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "5716dbe9-afc4-4b34-bca6-4ef816a72381",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 4])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[0,3:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f19ee8ff-6eb3-4e59-9aee-f375abf544fc",
   "metadata": {},
   "source": [
    "取矩阵第5行、第5列开始到结尾的子矩阵数据切片。这里注意冒号后如果值置空，意味着取后面所有，“4:”的含义是从索引4到结尾。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "ae9c1ac0-0bd2-4f27-b707-61ffa86c0a85",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[44, 45],\n",
       "       [54, 55]])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[4:,4:]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9c93f54-6f61-429c-855e-28004f1f7834",
   "metadata": {},
   "source": [
    "取矩阵第3列的所有数据。注意\":\"前后都没有值，含义为从索引0到结尾所有。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "20030611-a923-4a79-a55b-4054c65a9678",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2, 12, 22, 32, 42, 52])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[:,2]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b78fe18-d38e-4cc1-a811-d4aa34fcc335",
   "metadata": {},
   "source": [
    "取从第3行、第0列开始，行列都以2为间隔进行数据切片。这里注意的是\"::\"的用法，后面冒号接的数字代表“步长”，即取数的间隔。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "575a9065-0b83-43e6-ae46-ea7b3d322ace",
   "metadata": {},
   "outputs": [],
   "source": [
    "a[2::2,::2]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a28afdf5-c01d-4a6b-85b1-5bd67c3db857",
   "metadata": {},
   "source": [
    "<div class=\"sl-block is-focused\" data-block-type=\"image\" style=\"width: 809px; height: 297px; left: 235.5px; top: 375px; min-width: 1px; min-height: 1px;\" data-name=\"image-262eee\" data-origin-id=\"01f8f005eba62e726d05c57dfb1051f3\"><div class=\"sl-block-content\" style=\"z-index: 18;\"><img style=\"\" data-natural-width=\"1043\" data-natural-height=\"383\" data-lazy-loaded=\"\" src=\"https://i.loli.net/2019/07/27/5d3c3666165ed31650.png\"></div></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "365d3db0-888f-4143-b721-08fb48cd49c7",
   "metadata": {},
   "source": [
    "以索引列表的方式进行数据切片，例如一次取出矩阵位置索引为(0,1)(1,2)(2,3)(3,4)(4,5)的数据。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "1fe41c1f-676b-4490-a343-0c47a23295e0",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1, 12, 23, 34, 45])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[(0,1,2,3,4),(1,2,3,4,5)]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "be379ecf-6a68-497d-a2bd-47a5cb4a1ccd",
   "metadata": {},
   "source": [
    "行范围选择第4行开始到最后一行，列范围选择第1、3、6列的所有数据切片。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "84b11144-7008-4c6f-a267-0e3207677793",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[30, 32, 35],\n",
       "       [40, 42, 45],\n",
       "       [50, 52, 55]])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[3:,[0,2,5]]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c265ed5f-430a-4115-ac32-323b1bfe9de1",
   "metadata": {},
   "source": [
    "使用掩码的方式进行数据切片选择，掩码值为布尔型，1表示选择，0表示忽略。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "f42866e8-e193-494b-b618-9443700d34b6",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2, 22, 52])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mask = np.array([1,0,1,0,0,1],dtype=bool)\n",
    "a[mask,2]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aebb7da8-0102-4896-ad9b-0eead32dc4e4",
   "metadata": {},
   "source": [
    "### 查找索引"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "823c2016-5b37-4c6c-b7a5-1233394abb53",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([1,2,3,4,2,4,3,3,4])\n",
    "max_a = a.argmax() # 返回对应结果的第一个索引\n",
    "max_a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "3d16630e-67d8-433b-90b2-b30f646014c0",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([2, 6, 7]),)"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.where(a==max_a) # 返回全部索引的元组"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff456725-a0fe-4559-aa0e-035574f7d5de",
   "metadata": {},
   "source": [
    "If all the arrays are 1-D, `where(condition, [x, y], /)` is equivalent to::\n",
    "\n",
    "    [xv if c else yv\n",
    "     for c, xv, yv in zip(condition, x, y)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "d27d9694-b134-4d65-998c-72afa22c50fa",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(10)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "3cfeea7b-d0e5-47cb-a0e7-ae51d80ae328",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4, 50, 60, 70, 80, 90])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.where(a < 5, a, 10*a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "867abefd-2587-4ff0-8957-9b0419a51cff",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88d7da5a-4553-48df-b3e3-8ac85221c381",
   "metadata": {},
   "source": [
    "## Numpy 广播机制操作练习 (Broadcasting)\n",
    "> <time>10 min</time>\n",
    "\n",
    "- 更多官方说明：https://numpy.org/doc/stable/user/basics.broadcasting.html\n",
    "\n",
    "- 前提：两个 ndarray 执行的是 element-wise（按位加，按位减） 的运算，而不是矩阵乘法的运算，矩阵乘法运算时需要维度之间严格匹配。\n",
    "- 规则：\n",
    "    1. 让所有输入数组都向其中shape最长的数组看齐，shape中不足的部分都通过在前面加1补齐\n",
    "    2. 输出数组的shape是输入数组shape的各个轴上的最大值\n",
    "    3. 如果输入数组的某个轴和输出数组的对应轴的长度相同或者其长度为1时，这个数组能够用来计算，否则出错\n",
    "    4. 当输入数组的某个轴的长度为1时，沿着此轴运算时都用此轴上的第一组值\n",
    "- 目的：方便不同shape的array进行数学运算\n",
    "\n",
    "![](https://vip2.loli.io/2023/12/01/ucg1y3IMTJVdrhz.jpg)\n",
    "\n",
    "- 简单的说，任何一个维度是1，那么另一个不为1的维度将被用作最终结果的维度。也就是说，尺寸为1的维度将延展或“逐个复制”到与另一个维度匹配\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a0641574-b95d-490f-990d-4f9f6969da4e",
   "metadata": {},
   "source": [
    "### 操作练习1："
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7798a75f-01e2-4565-82f7-e64b3d046316",
   "metadata": {},
   "source": [
    "实现对一个1-d array的每一个元素乘以2,传统做法如下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "b648b232-a9ae-4039-afea-17939111554d",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2., 4., 6.])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([1.,2.,3.])\n",
    "b = np.array([2.,2.,2.])\n",
    "a * b"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb661cf6-4e29-4121-9705-9610a28e9767",
   "metadata": {},
   "source": [
    "如果利用广播机制，实现上述例子的做法会变得更加简单："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "ef9a21bc-05b5-41bc-882c-9f05ae33487d",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2., 4., 6.])"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([1.,2.,3.])\n",
    "b = 2.\n",
    "a * b"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9a59ebf-584e-47a2-95e8-dece4e2e52c1",
   "metadata": {},
   "source": [
    "### 操作练习2："
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aeee4e67-9fa6-465a-bd95-5d6ef232b22d",
   "metadata": {},
   "source": [
    "ndarray 的广播机制："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "bde2c5e8-9191-4bdc-9187-5fe6baf336d0",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4],\n",
       "       [5, 6]])"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array(range(1, 7)).reshape(3, -1)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "24196890-e2cd-47b0-88bf-3c243ba575a0",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2]])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = np.array([1,2]).reshape(1,-1)\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "24229745-2546-4bc0-bc18-03bdcec7fa0f",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2, 4],\n",
       "       [4, 6],\n",
       "       [6, 8]])"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a + b"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca3c1065-7a96-4262-8c84-2dee85b61b57",
   "metadata": {},
   "source": [
    "### 操作练习3："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "e8eaf1a9-e138-4c98-a6f1-ceb9efff21cd",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(8, 1, 6, 1)\n",
      "(7, 1, 5)\n"
     ]
    }
   ],
   "source": [
    "a = np.ones(shape = (8,1,6,1))\n",
    "print(a.shape)\n",
    "\n",
    "b = np.ones(shape = (7,1,5))\n",
    "print(b.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "a948b0df-807c-433c-ae08-b1b73655bb5e",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(8, 7, 6, 5)"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(a + b).shape"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1fa35117-ce92-4a3d-ae1f-d1f256137e43",
   "metadata": {
    "tags": []
   },
   "source": [
    "简单的说，对两个阵进行操作时，Numpy 逐元素地比较他们的形状。\n",
    "\n",
    "只有两种情况下Numpy会认为两个矩阵(向右对齐后)内的两个对应维度是兼容的：\n",
    "1. 它们相等； \n",
    "2. 其中一个是1维。\n",
    "\n",
    "举个牛逼的例子：\n",
    "\n",
    "```shell\n",
    "A      (4d array):  8 x 1 x 6 x 1\n",
    "B      (3d array):      7 x 1 x 5\n",
    "Result (4d array):  8 x 7 x 6 x 5\n",
    "```\n",
    "当任何一个维度是1，那么另一个不为1的维度将被用作最终结果的维度。也就是说，尺寸为1的维度将延展或“逐个复制”到与另一个维度匹配。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "980b5d87-901f-4166-a08f-f3308e374ef9",
   "metadata": {},
   "source": [
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fbd9d23f-b9d8-4854-a2e7-2eb50168f865",
   "metadata": {},
   "source": [
    "## 用Numpy实现线性代数与数理统计方法操作练习\n",
    "> <time>10 min</time>\n",
    "\n",
    "**线性代数**\n",
    "\n",
    "线性代数（如矩阵乘法、矩阵分解、行列式以及其他方阵数学等）是任何数组库的重要组成部分，Numpy中实现了线性代数中常用的各种操作，并形成了numpy.linalg线性代数相关的模块。\n",
    "\n",
    "\n",
    "- 矩阵的定义、矩阵的加法、矩阵的数乘、矩阵的转置与二维数组完全一致，矩阵的乘法有不同的表示：\n",
    "    1. `numpy.dot(a, b[, out])`   计算两个矩阵的乘积，如果是一维数组则是它们的内积。\n",
    "        注意：b.dot(c)等价于np.dot(b,c)。\n",
    "    2. `numpy.diag`：以一维数组的形式返回方阵的对角线（或非对角线）元素，或将一维数组转换为方阵（非对角线元素为0）。\n",
    "    3. `numpy.trace`：计算对角线元素的和。\n",
    "    2. `numpy.linalg.eig`   计算方阵的特征值和特征向量。\n",
    "    3. `numpy.linalg.eigvals`   计算方阵的特征值。\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f5582093-e732-4df2-b065-8d4b952057e0",
   "metadata": {},
   "source": [
    "### 操作练习1：一维数组的矩阵乘法（内积）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "0ccfb748-a921-4428-a5c2-20dead48d270",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "70\n"
     ]
    }
   ],
   "source": [
    "x = np.array([1,2,3,4,5])\n",
    "y = np.array([2,3,4,5,6])\n",
    "z = np.dot(x,y)\n",
    "\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de5b34db-706b-42d4-8a4d-5715ceec3ada",
   "metadata": {},
   "source": [
    "### 操作练习2：多维矩阵乘法"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "eb74eb19-415d-430d-8191-52ad590a81d7",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [3 4 5]\n",
      " [6 7 8]]\n",
      "[[5 4 3]\n",
      " [1 7 9]\n",
      " [0 4 5]]\n",
      "[[  7  30  36]\n",
      " [ 19  60  70]\n",
      " [ 37 105 121]]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[1,2,3],[3,4,5],[6,7,8]])\n",
    "y = np.array([[5,4,3],[1,7,9],[0,4,5]])\n",
    "z = np.dot(x,y)\n",
    "\n",
    "print(x)\n",
    "print(y)\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3bbacc60-3f18-410f-8cd2-d6bb601d8e97",
   "metadata": {},
   "source": [
    "![](https://i.loli.net/2019/07/27/5d3c39341aae597111.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28aca6d7-a070-401d-a4b9-2f8efd542d34",
   "metadata": {},
   "source": [
    "### 操作练习3：计算矩阵的特征值和特征向量"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "a4bccc5c-0812-4e96-b417-03c29f39e88e",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 0 0]\n",
      " [0 2 0]\n",
      " [0 0 3]]\n"
     ]
    }
   ],
   "source": [
    "x = np.diag((1,2,3))\n",
    "\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "1ab607f3-a2f8-4cb2-8094-beeac2f62ab2",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 2., 3.])"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linalg.eigvals(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ae5a893-dc48-48f9-8bdb-8622b76ea74b",
   "metadata": {},
   "source": [
    "特征值保存在a中，特征向量保存在b中"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "333755fe-3f4d-4cc4-82a2-46f10327b0b0",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1. 2. 3.]\n",
      "[[1. 0. 0.]\n",
      " [0. 1. 0.]\n",
      " [0. 0. 1.]]\n"
     ]
    }
   ],
   "source": [
    "a,b = np.linalg.eig(x)\n",
    "\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93c9df9e-028a-4858-8ddd-a1aa72f54287",
   "metadata": {},
   "source": [
    "### 一些统计方法\n",
    "\n",
    "对整个数组或某个轴向的数据进行统计计算。 \n",
    "\n",
    "*（以下方法既可以当做数组的实例方法，也可以当做Numpy函数使用）*\n",
    "\n",
    "- `mean`：计算算术平均数，零长度数组的 `mean` 为NaN。\n",
    "- `std` 和 `var`：计算标准差和方差，自由度可调（默认为n）。\n",
    "- `sum`：对数组中全部或某轴向的元素求和，零长度数组的 `sum` 为0。\n",
    "- `max` 和 `min`：计算最大值和最小值。\n",
    "- `argmin` 和 `argmax`：分别为最大和最小元素的索引。\n",
    "- `cumsum`：计算所有元素的累加。\n",
    "- `cumprod`：计算所有元素的累积。\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "74cb4a64-0c70-4d77-9891-21b0beb10626",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6],\n",
       "       [7, 8, 9]])"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 计算均值，使用arr.mean() 或 np.mean(arr)，二者是等价的\n",
    "arr = np.array([[1,2,3], [4,5,6], [7,8,9]])\n",
    "arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "2527cf97-3305-4b67-a413-0b929620702d",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(5.0, 5.0)"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr.mean(), np.mean(arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0797f32b-844e-47c3-adf6-20165121953f",
   "metadata": {
    "tags": []
   },
   "source": [
    "- 指定计算的维度"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "0e03d459-abb9-49b4-aa02-aff4805e6ab0",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2., 5., 8.])"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 沿着第1维求平均\n",
    "# 也就是将[1, 2, 3]取平均等于2，[4, 5, 6]取平均等于5，[7, 8, 9]取平均等于8\n",
    "arr.mean(axis = 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "98c6d455-e50e-4600-a659-a60d31f79984",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([12, 15, 18])"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 沿着第0维求和\n",
    "# 也就是将[1, 4, 7]求和等于12，[2, 5, 8]求和等于15，[3, 6, 9]求和等于18\n",
    "arr.sum(axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "1cccaead-d112-4e21-963a-e419d3833584",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([7, 8, 9])"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 沿着第0维求最大值\n",
    "# 也就是将[1, 4, 7]求最大值等于7，[2, 5, 8]求最大值等于8，[3, 6, 9]求最大值等于9\n",
    "arr.max(axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "b7897541-0c94-4dde-81f4-1581d0479a52",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 4, 7])"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 沿着第1维求最小值\n",
    "# 也就是将[1, 2, 3]求最小值等于1，[4, 5, 6]求最小值等于4，[7, 8, 9]求最小值等于7\n",
    "arr.min(axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49f252c0-22ec-495e-bd84-f02af80de959",
   "metadata": {},
   "source": [
    "## 随机数 `np.random`\n",
    "\n",
    "### 创建随机ndarray数组"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a752375-6b29-40f2-a22d-716e6edad480",
   "metadata": {},
   "source": [
    "- 设置随机数种子"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "id": "8a0f3da4-69da-46bd-94f1-8a228790fc8b",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# 多次运行，程序输出结果一致\n",
    "# 如果不设置随机数种子，多次运行输出结果不一致\n",
    "np.random.seed(112)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "id": "1db9d417-5980-4436-87e9-e4bfb4492843",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.37505713, 0.64030462, 0.95001658],\n",
       "       [0.0756772 , 0.77692966, 0.83274576],\n",
       "       [0.05480574, 0.81767738, 0.88535146]])"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.random.rand(3, 3)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "id": "f6f235df-a4d8-44d2-8fd3-607bf777672d",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.72234651, 0.00255603, 0.98119928],\n",
       "       [0.34341985, 0.09475989, 0.39464259],\n",
       "       [0.00494492, 0.73670683, 0.95580687]])"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = np.random.rand(3, 3)\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dab5512c-b7d7-4b4d-aac5-2583081e1259",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "e28b6b86-6b78-4661-886a-e5f632a505b4",
   "metadata": {
    "tags": []
   },
   "source": [
    "自然随机数：\n",
    "\n",
    "- 白噪音\n",
    "- 放射性同位素的散布\n",
    "\n",
    "自然随机数的特点是，真随机，且无法被生成，或者说，无法被重现。\n",
    "\n",
    "伪随机数：\n",
    "\n",
    "- 通过数学方法生成的随机数\n",
    "- 线性同余发生器\n",
    "\n",
    "伪随机数的特点是可以被生成或重现，但是他的随机性体现在你如何去看待。\n",
    "\n",
    "\n",
    "![](https://vip2.loli.io/2023/11/30/l4ebCOiXpEIQZuy.jpg)\n",
    "\n",
    "> Randomness can be seen as the absence of any structure whatsoever.\n",
    ">\n",
    "\n",
    "> 随机性的概念通常在统计学和其他领域中用于表示一组数据中缺乏模式或结构。\n",
    ">然而，值得注意的是，在数学和物理学领域，真正的随机性是一个备受争议的话题。一些人认为，如果我们知道系统的所有变量并完全了解，就能够预测结果。另一些人则认为，宇宙本质上是不可预测的，真正的随机性确实存在。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "81e9d454-c518-46dc-a51d-cad46f93fa56",
   "metadata": {},
   "source": [
    "### 均匀分布"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "id": "06369789-dca2-43f7-88eb-b62c743f3922",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.82060937, 0.344983  , 0.37854446],\n",
       "       [0.78476361, 0.08623151, 0.54607394],\n",
       "       [0.16222602, 0.29006973, 0.04500817]])"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 生成均匀分布随机数，随机数取值范围在[0, 1)之间\n",
    "a = np.random.rand(3, 3)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "id": "f257cb8c-37c6-4a6c-b99b-cc8939371ccb",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.52706065,  0.3674649 ],\n",
       "       [ 0.44391476, -0.57169582]])"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 生成均匀分布随机数，指定随机数取值范围和数组形状\n",
    "# 未指定形状则返回一个数字，即rand()等价于uniform(0,1)\n",
    "a = np.random.uniform(low = -1.0, high = 1.0, size=(2,2))\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e915e337-0842-4fb4-9db9-55828d8411cf",
   "metadata": {},
   "source": [
    "### 正态分布"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "id": "01dcfbea-7d27-4096-9894-e9abf5ea0bbb",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-1.02597417, -2.36855593, -0.07387004],\n",
       "       [ 0.42762768, -0.96564862, -0.22447746],\n",
       "       [-0.33519821, -2.26603543, -0.13224617]])"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 生成标准正态分布随机数\n",
    "a = np.random.randn(3, 3)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "id": "e870994e-10db-4b9a-927b-678dda14a893",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.98989129, 2.50859366, 1.71465326],\n",
       "       [0.2977863 , 0.92995503, 0.61703173],\n",
       "       [1.34599716, 0.79889054, 0.64125484]])"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 生成正态分布随机数，指定均值loc和方差scale\n",
    "a = np.random.normal(loc = 1.0, scale = 1.0, size = (3,3))\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5cc5d446-cd8e-461b-8975-20d2066955ad",
   "metadata": {},
   "source": [
    "### 随机打乱ndarray数组"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c994f661-f9f0-4c32-b81d-8dcf79ae2ac0",
   "metadata": {},
   "source": [
    "随机打乱1维ndarray数组顺序，发现所有元素位置都被打乱了"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "id": "3e9d3b0a-db53-495e-a2bd-14b4c99c4fcc",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,\n",
       "       17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29])"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 生成一维数组\n",
    "a = np.arange(0, 30)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "id": "bc9c6e27-952c-461b-a432-abe3a4b400e0",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# 打乱一维数组顺序\n",
    "np.random.shuffle(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "id": "48b9c703-0fc7-4687-9149-575dd4ea3be3",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([16, 25,  2, 26, 22,  5, 27, 13, 14,  9, 11, 15,  4, 21,  6, 17, 19,\n",
       "       12, 23, 20,  7,  0, 10, 29, 18,  3,  1,  8, 24, 28])"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d85f226b-8107-40ac-9396-596a4e461e2a",
   "metadata": {},
   "source": [
    "随机打乱2维ndarray数组顺序，发现只有行的顺序被打乱了，列顺序不变"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "id": "e7429302-4a2d-4f7c-b08a-4f858bd13943",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,\n",
       "       17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,\n",
       "       34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50,\n",
       "       51, 52, 53, 54, 55, 56, 57, 58, 59])"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 生成一维数组\n",
    "a = np.arange(0, 60)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "id": "4ab23e88-c691-4bc8-8942-cc3c9cff2943",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# 将一维数组转化成2维数组\n",
    "a = a.reshape(10, 3, 2)\n",
    "# a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "id": "77bdc9b4-2470-442f-a114-dc83bcb35ff8",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# 打乱一维数组顺序\n",
    "np.random.shuffle(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "id": "9cdab02a-ed19-428f-9e7f-64c851b58c36",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "# a"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5417a6a6-cc23-42a4-8d14-35a5f30fdc0d",
   "metadata": {},
   "source": [
    "### 随机选取元素（一维）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "id": "2b0b6385-791e-42a8-b411-3bf3047116c0",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,\n",
       "       17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29])"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 随机选取部分元素（30选5）\n",
    "a = np.arange(30)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "id": "a592979e-4316-42a2-9ce7-8cb00a1aa933",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([15,  4, 17, 11,  5])"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = np.random.choice(a, size=5)\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "id": "44016f13-5cc3-4eb0-82c6-aea92b0f6a8d",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "23"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 随机选取部分元素（30选1）\n",
    "c = np.random.choice(30)\n",
    "c"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a988b9c-1796-4da5-9729-9fc18c0038c0",
   "metadata": {},
   "source": [
    "## Numpy 文件读写与保存"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e6f7a9af-79bf-4da1-b9da-1564c6b8eceb",
   "metadata": {},
   "source": [
    "Numpy提供了save和load接口，直接将数组保存成文件(保存为 `.npy`格式)，或者从 `.npy` 文件中读取数组。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "id": "c28b53de-0397-426f-b622-a113b6970ecd",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-rw-r--r-- 1 root root 200 Dec  1 12:00 a.npy\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[0.67983647, 0.21504   , 0.90752074],\n",
       "       [0.20109525, 0.04108355, 0.27542648],\n",
       "       [0.3027903 , 0.19829481, 0.98285595]])"
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 产生随机数组a\n",
    "a = np.random.rand(3,3)\n",
    "np.save('a', a)\n",
    "\n",
    "!ls -lh a.npy\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "id": "03ae40bf-af4c-4f4d-a076-98d91fbf0884",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.67983647, 0.21504   , 0.90752074],\n",
       "       [0.20109525, 0.04108355, 0.27542648],\n",
       "       [0.3027903 , 0.19829481, 0.98285595]])"
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 从本地目录中，将文件'a.npy'读入数组\n",
    "b = np.load('a.npy')\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "id": "876aecd5-2ae8-48e2-b6b8-8b471272b6b3",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "!rm a.npy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "id": "7285202c-db7c-497f-a3fa-b2c417d08b8c",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 157,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 检查a和b的数值是否一样\n",
    "\n",
    "# way.1\n",
    "(a == b).all()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "id": "1d80d747-5716-4ae3-883a-4e787b78398d",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 158,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# way.2\n",
    "np.alltrue(a == b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "id": "85a803e8-0bfd-4ba9-8a31-14b197984c80",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 159,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# way.3\n",
    "np.allclose(a, b)\n",
    "\n",
    "# absolute(`a` - `b`) <= (`atol` + `rtol` * absolute(`b`))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "25e41473-9a4e-46b8-9897-475a86c5ca0e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b6660e2c-cb5f-4b0e-8a30-d775fb988821",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c8e26ec2-9e9d-4933-bc5b-c0e1a6f9678a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "74e9a407-4073-4b28-98c8-7f5cae23e9df",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3f9b7e49-c339-4d25-af83-87fa4f3291b6",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "ICTP-AP",
   "language": "python",
   "name": "ictp-ap"
  },
  "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.10.13"
  },
  "toc-autonumbering": true
 },
 "nbformat": 4,
 "nbformat_minor": 5
}