更新numpy的开源内容。
This commit is contained in:
MYP
59
IntroductionToNumpy/readme.md
Normal file
59
IntroductionToNumpy/readme.md
Normal file
@@ -0,0 +1,59 @@
|
||||
# 编程实践（Numpy）上
|
||||
|
||||
开源学习内容：https://github.com/datawhalechina/team-learning-program/tree/master/IntroductionToNumpy
|
||||
|
||||
|
||||
|
||||
## 基本信息
|
||||
- 贡献人员：韩绘锦、左秉文、王彦淳
|
||||
- 学习周期：13天，每天平均花费时间3小时-5小时不等，根据个人学习接受能力强弱有所浮动。
|
||||
- 学习形式：理论学习 + 练习
|
||||
- 人群定位：有一定python编程的基础。
|
||||
- 先修内容：[Python编程语言](https://github.com/datawhalechina/team-learning-program/tree/master/PythonLanguage)
|
||||
- 难度系数：中
|
||||
|
||||
|
||||
|
||||
|
||||
## 学习目标
|
||||
|
||||
本开源内容是Python基础的进阶，主要目标是学习numpy的基本数据类型，了解numpy各类函数的应用；以便为后期学习pandas和sklearn奠定坚实基础。
|
||||
|
||||
## 任务安排
|
||||
|
||||
|
||||
### Task1：数据类型及数组创建（2天）
|
||||
- 熟悉基础常量、常见数据类型，以及时间日期和时间增量的处理。
|
||||
- 掌握数组的创建和数组的属性。
|
||||
|
||||
|
||||
### Task2：索引（3天）
|
||||
|
||||
- 掌握数组的索引与切片，熟悉数组迭代。
|
||||
|
||||
|
||||
### Task3：数组的操作（2天）
|
||||
- 掌握数组的各种操作，比如：更改形状，数组转置，更改维度，数组组合，数组拆分，数组平铺，添加和删除元素等。
|
||||
|
||||
|
||||
### Task4：数学函数及逻辑函数（3天）
|
||||
|
||||
- 掌握numpy中常用的数学函数及逻辑函数。
|
||||
- 数学函数，比如：数学运算，三角函数，指数和对数，加法函数及乘法函数，四舍五入等。
|
||||
- 逻辑函数，比如：真值测试，数组内容，逻辑函数等。
|
||||
|
||||
### Task5：排序搜索计数及集合操作（3天）
|
||||
- 掌握numpy中排序搜索计数的相关函数。
|
||||
- 掌握numpy中关于集合的操作，比如：如何构建集合，集合的交并差集及异或操作等。
|
||||
|
||||
## 备注
|
||||
|
||||
有关组队学习的开源内容
|
||||
|
||||
- [team-learning](https://github.com/datawhalechina/team-learning)：主要展示Datawhale的组队学习计划。
|
||||
- [team-learning-program](https://github.com/datawhalechina/team-learning-program)：主要存储Datawhale组队学习中“编程、数据结构与算法”方向的资料。
|
||||
- [team-learning-data-mining](https://github.com/datawhalechina/team-learning-data-mining)：主要存储Datawhale组队学习中“数据挖掘/机器学习”方向的资料。
|
||||
- [team-learning-nlp](https://github.com/datawhalechina/team-learning-nlp)：主要存储Datawhale组队学习中“自然语言处理”方向的资料。
|
||||
- [team-learning-cv](https://github.com/datawhalechina/team-learning-cv)：主要存储Datawhale组队学习中“计算机视觉”方向的资料。
|
||||
- [team-learning-rs](https://github.com/datawhalechina/team-learning-rs)：主要存储Datawhale组队学习中“推荐系统”方向的资料。
|
||||
- [team-learning-rl](https://github.com/datawhalechina/team-learning-rl)：主要存储Datawhale组队学习中“强化学习”方向的资料。
|
||||
|
Before Width: | Height: | Size: 39 KiB After Width: | Height: | Size: 39 KiB |
@@ -1,6 +0,0 @@
|
||||
{
|
||||
"cells": [],
|
||||
"metadata": {},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -1,6 +0,0 @@
|
||||
{
|
||||
"cells": [],
|
||||
"metadata": {},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -1,617 +0,0 @@
|
||||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"\n",
|
||||
"[toc]\n",
|
||||
"\n",
|
||||
"---\n",
|
||||
"# 数组的创建\n",
|
||||
"\n",
|
||||
"导入 numpy。\n",
|
||||
"\n",
|
||||
"```\n",
|
||||
"import numpy as np\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"numpy 提供的最重要的数据结构是`ndarray`，它是 python 中`list`的扩展。\n",
|
||||
"\n",
|
||||
"## 1. 依据现有数据来创建 ndarray\n",
|
||||
"\n",
|
||||
"### **（a）通过array()函数进行创建。**\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"def array(p_object, dtype=None, copy=True, order='K', subok=False, ndmin=0): \n",
|
||||
"``` \n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"# 创建一维数组\n",
|
||||
"a = np.array([0, 1, 2, 3, 4])\n",
|
||||
"b = np.array((0, 1, 2, 3, 4))\n",
|
||||
"print(a, type(a))\n",
|
||||
"# [0 1 2 3 4] <class 'numpy.ndarray'>\n",
|
||||
"print(b, type(b))\n",
|
||||
"# [0 1 2 3 4] <class 'numpy.ndarray'>\n",
|
||||
"\n",
|
||||
"# 创建二维数组\n",
|
||||
"c = np.array([[11, 12, 13, 14, 15],\n",
|
||||
" [16, 17, 18, 19, 20],\n",
|
||||
" [21, 22, 23, 24, 25],\n",
|
||||
" [26, 27, 28, 29, 30],\n",
|
||||
" [31, 32, 33, 34, 35]])\n",
|
||||
"print(c, type(c))\n",
|
||||
"# [[11 12 13 14 15]\n",
|
||||
"# [16 17 18 19 20]\n",
|
||||
"# [21 22 23 24 25]\n",
|
||||
"# [26 27 28 29 30]\n",
|
||||
"# [31 32 33 34 35]] <class 'numpy.ndarray'>\n",
|
||||
"\n",
|
||||
"# 创建三维数组\n",
|
||||
"d = np.array([[(1.5, 2, 3), (4, 5, 6)],\n",
|
||||
" [(3, 2, 1), (4, 5, 6)]])\n",
|
||||
"print(d, type(d))\n",
|
||||
"# [[[1.5 2. 3. ]\n",
|
||||
"# [4. 5. 6. ]]\n",
|
||||
"#\n",
|
||||
"# [[3. 2. 1. ]\n",
|
||||
"# [4. 5. 6. ]]] <class 'numpy.ndarray'>\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"### **（b）通过asarray()函数进行创建**\n",
|
||||
"\n",
|
||||
"`array()`和`asarray()`都可以将结构数据转化为 ndarray，但是`array()`和`asarray()`主要区别就是当数据源是**ndarray** 时，`array()`仍然会 copy 出一个副本，占用新的内存，但不改变 dtype 时 `asarray()`不会。\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"def asarray(a, dtype=None, order=None):\n",
|
||||
" return array(a, dtype, copy=False, order=order)\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"【例】`array()`和`asarray()`都可以将结构数据转化为 ndarray\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = [[1, 1, 1], [1, 1, 1], [1, 1, 1]]\n",
|
||||
"y = np.array(x)\n",
|
||||
"z = np.asarray(x)\n",
|
||||
"x[1][2] = 2\n",
|
||||
"print(x,type(x))\n",
|
||||
"# [[1, 1, 1], [1, 1, 2], [1, 1, 1]] <class 'list'>\n",
|
||||
"\n",
|
||||
"print(y,type(y))\n",
|
||||
"# [[1 1 1]\n",
|
||||
"# [1 1 1]\n",
|
||||
"# [1 1 1]] <class 'numpy.ndarray'>\n",
|
||||
"\n",
|
||||
"print(z,type(z))\n",
|
||||
"# [[1 1 1]\n",
|
||||
"# [1 1 1]\n",
|
||||
"# [1 1 1]] <class 'numpy.ndarray'>\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"【例】`array()`和`asarray()`的区别。(`array()`和`asarray()`主要区别就是当数据源是**ndarray** 时，`array()`仍然会 copy 出一个副本，占用新的内存，但不改变 dtype 时 `asarray()`不会。)\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([[1, 1, 1], [1, 1, 1], [1, 1, 1]])\n",
|
||||
"y = np.array(x)\n",
|
||||
"z = np.asarray(x)\n",
|
||||
"w = np.asarray(x, dtype=np.int)\n",
|
||||
"x[1][2] = 2\n",
|
||||
"print(x,type(x),x.dtype)\n",
|
||||
"# [[1 1 1]\n",
|
||||
"# [1 1 2]\n",
|
||||
"# [1 1 1]] <class 'numpy.ndarray'> int32\n",
|
||||
"\n",
|
||||
"print(y,type(y),y.dtype)\n",
|
||||
"# [[1 1 1]\n",
|
||||
"# [1 1 1]\n",
|
||||
"# [1 1 1]] <class 'numpy.ndarray'> int32\n",
|
||||
"\n",
|
||||
"print(z,type(z),z.dtype)\n",
|
||||
"# [[1 1 1]\n",
|
||||
"# [1 1 2]\n",
|
||||
"# [1 1 1]] <class 'numpy.ndarray'> int32\n",
|
||||
"\n",
|
||||
"print(w,type(w),w.dtype)\n",
|
||||
"# [[1 1 1]\n",
|
||||
"# [1 1 2]\n",
|
||||
"# [1 1 1]] <class 'numpy.ndarray'> int32\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】更改为较大的dtype时，其大小必须是array的最后一个axis的总大小（以字节为单位）的除数\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([[1, 1, 1], [1, 1, 1], [1, 1, 1]])\n",
|
||||
"print(x, x.dtype)\n",
|
||||
"# [[1 1 1]\n",
|
||||
"# [1 1 1]\n",
|
||||
"# [1 1 1]] int32\n",
|
||||
"x.dtype = np.float\n",
|
||||
"\n",
|
||||
"# ValueError: When changing to a larger dtype, its size must be a divisor of the total size in bytes of the last axis of the array.\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"### **（c）通过fromfunction()函数进行创建**\n",
|
||||
"\n",
|
||||
"给函数绘图的时候可能会用到`fromfunction()`，该函数可从函数中创建数组。\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"def fromfunction(function, shape, **kwargs):\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】通过在每个坐标上执行一个函数来构造数组。\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"def f(x, y):\n",
|
||||
" return 10 * x + y\n",
|
||||
"\n",
|
||||
"x = np.fromfunction(f, (5, 4), dtype=int)\n",
|
||||
"print(x)\n",
|
||||
"# [[ 0 1 2 3]\n",
|
||||
"# [10 11 12 13]\n",
|
||||
"# [20 21 22 23]\n",
|
||||
"# [30 31 32 33]\n",
|
||||
"# [40 41 42 43]]\n",
|
||||
"\n",
|
||||
"x = np.fromfunction(lambda i, j: i == j, (3, 3), dtype=int)\n",
|
||||
"print(x)\n",
|
||||
"# [[ True False False]\n",
|
||||
"# [False True False]\n",
|
||||
"# [False False True]]\n",
|
||||
"\n",
|
||||
"x = np.fromfunction(lambda i, j: i + j, (3, 3), dtype=int)\n",
|
||||
"print(x)\n",
|
||||
"# [[0 1 2]\n",
|
||||
"# [1 2 3]\n",
|
||||
"# [2 3 4]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"## 2. 依据 ones 和 zeros 填充方式\n",
|
||||
"\n",
|
||||
"在机器学习任务中经常做的一件事就是初始化参数，需要用常数值或者随机值来创建一个固定大小的矩阵。\n",
|
||||
"\n",
|
||||
"### **（a）零数组**\n",
|
||||
"\n",
|
||||
"- `zeros()`函数：返回给定形状和类型的零数组。\n",
|
||||
"- `zeros_like()`函数：返回与给定数组形状和类型相同的零数组。\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"def zeros(shape, dtype=None, order='C'):\n",
|
||||
"def zeros_like(a, dtype=None, order='K', subok=True, shape=None):\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.zeros(5)\n",
|
||||
"print(x) # [0. 0. 0. 0. 0.]\n",
|
||||
"x = np.zeros([2, 3])\n",
|
||||
"print(x)\n",
|
||||
"# [[0. 0. 0.]\n",
|
||||
"# [0. 0. 0.]]\n",
|
||||
"\n",
|
||||
"x = np.array([[1, 2, 3], [4, 5, 6]])\n",
|
||||
"y = np.zeros_like(x)\n",
|
||||
"print(y)\n",
|
||||
"# [[0 0 0]\n",
|
||||
"# [0 0 0]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"### **（b）1数组**\n",
|
||||
"\n",
|
||||
"- `ones()`函数：返回给定形状和类型的1数组。\n",
|
||||
"- `ones_like()`函数：返回与给定数组形状和类型相同的1数组。\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"def ones(shape, dtype=None, order='C'):\n",
|
||||
"def ones_like(a, dtype=None, order='K', subok=True, shape=None):\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.ones(5)\n",
|
||||
"print(x) # [1. 1. 1. 1. 1.]\n",
|
||||
"x = np.ones([2, 3])\n",
|
||||
"print(x)\n",
|
||||
"# [[1. 1. 1.]\n",
|
||||
"# [1. 1. 1.]]\n",
|
||||
"\n",
|
||||
"x = np.array([[1, 2, 3], [4, 5, 6]])\n",
|
||||
"y = np.ones_like(x)\n",
|
||||
"print(y)\n",
|
||||
"# [[1 1 1]\n",
|
||||
"# [1 1 1]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"### **（c）空数组**\n",
|
||||
"\n",
|
||||
"- `empty()`函数：返回一个空数组，数组元素为随机数。\n",
|
||||
"- `empty_like`函数：返回与给定数组具有相同形状和类型的新数组。\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"def empty(shape, dtype=None, order='C'): \n",
|
||||
"def empty_like(prototype, dtype=None, order='K', subok=True, shape=None):\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.empty(5)\n",
|
||||
"print(x)\n",
|
||||
"# [1.95821574e-306 1.60219035e-306 1.37961506e-306 \n",
|
||||
"# 9.34609790e-307 1.24610383e-306]\n",
|
||||
"\n",
|
||||
"x = np.empty((3, 2))\n",
|
||||
"print(x)\n",
|
||||
"# [[1.60220393e-306 9.34587382e-307]\n",
|
||||
"# [8.45599367e-307 7.56598449e-307]\n",
|
||||
"# [1.33509389e-306 3.59412896e-317]]\n",
|
||||
"\n",
|
||||
"x = np.array([[1, 2, 3], [4, 5, 6]])\n",
|
||||
"y = np.empty_like(x)\n",
|
||||
"print(y)\n",
|
||||
"# [[ 7209029 6422625 6619244]\n",
|
||||
"# [ 100 707539280 504]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"### **（d）单位数组**\n",
|
||||
"\n",
|
||||
"- `eye()`函数：返回一个对角线上为1，其它地方为零的单位数组。\n",
|
||||
"- `identity()`函数：返回一个方的单位数组。\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"def eye(N, M=None, k=0, dtype=float, order='C'):\n",
|
||||
"def identity(n, dtype=None):\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.eye(4)\n",
|
||||
"print(x)\n",
|
||||
"# [[1. 0. 0. 0.]\n",
|
||||
"# [0. 1. 0. 0.]\n",
|
||||
"# [0. 0. 1. 0.]\n",
|
||||
"# [0. 0. 0. 1.]]\n",
|
||||
"\n",
|
||||
"x = np.eye(2, 3)\n",
|
||||
"print(x)\n",
|
||||
"# [[1. 0. 0.]\n",
|
||||
"# [0. 1. 0.]]\n",
|
||||
"\n",
|
||||
"x = np.identity(4)\n",
|
||||
"print(x)\n",
|
||||
"# [[1. 0. 0. 0.]\n",
|
||||
"# [0. 1. 0. 0.]\n",
|
||||
"# [0. 0. 1. 0.]\n",
|
||||
"# [0. 0. 0. 1.]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"### **（e）对角数组**\n",
|
||||
"\n",
|
||||
"- `diag()`函数：提取对角线或构造对角数组。\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"def diag(v, k=0):\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.arange(9).reshape((3, 3))\n",
|
||||
"print(x)\n",
|
||||
"# [[0 1 2]\n",
|
||||
"# [3 4 5]\n",
|
||||
"# [6 7 8]]\n",
|
||||
"print(np.diag(x)) # [0 4 8]\n",
|
||||
"print(np.diag(x, k=1)) # [1 5]\n",
|
||||
"print(np.diag(x, k=-1)) # [3 7]\n",
|
||||
"\n",
|
||||
"v = [1, 3, 5, 7]\n",
|
||||
"x = np.diag(v)\n",
|
||||
"print(x)\n",
|
||||
"# [[1 0 0 0]\n",
|
||||
"# [0 3 0 0]\n",
|
||||
"# [0 0 5 0]\n",
|
||||
"# [0 0 0 7]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"### **（f）常数数组**\n",
|
||||
"\n",
|
||||
"- `full()`函数：返回一个常数数组。\n",
|
||||
"- `full_like()`函数：返回与给定数组具有相同形状和类型的常数数组。\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"def full(shape, fill_value, dtype=None, order='C'):\n",
|
||||
"def full_like(a, fill_value, dtype=None, order='K', subok=True, shape=None):\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.full((2,), 7)\n",
|
||||
"print(x)\n",
|
||||
"# [7 7]\n",
|
||||
"\n",
|
||||
"x = np.full(2, 7)\n",
|
||||
"print(x)\n",
|
||||
"# [7 7]\n",
|
||||
"\n",
|
||||
"x = np.full((2, 7), 7)\n",
|
||||
"print(x)\n",
|
||||
"# [[7 7 7 7 7 7 7]\n",
|
||||
"# [7 7 7 7 7 7 7]]\n",
|
||||
"\n",
|
||||
"x = np.array([[1, 2, 3], [4, 5, 6]])\n",
|
||||
"y = np.full_like(x, 7)\n",
|
||||
"print(y)\n",
|
||||
"# [[7 7 7]\n",
|
||||
"# [7 7 7]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"## 3. 利用数值范围来创建ndarray\n",
|
||||
" - `arange()`函数：返回给定间隔内的均匀间隔的值。\n",
|
||||
" - `linspace()`函数：返回指定间隔内的等间隔数字。\n",
|
||||
" - `logspace()`函数：返回数以对数刻度均匀分布。\n",
|
||||
" - `numpy.random.rand()` 返回一个由[0,1)内的随机数组成的数组。\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"def arange([start,] stop[, step,], dtype=None): \n",
|
||||
"def linspace(start, stop, num=50, endpoint=True, retstep=False, \n",
|
||||
" dtype=None, axis=0):\n",
|
||||
"def logspace(start, stop, num=50, endpoint=True, base=10.0, \n",
|
||||
" dtype=None, axis=0):\n",
|
||||
"def rand(d0, d1, ..., dn): \n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.arange(5)\n",
|
||||
"print(x) # [0 1 2 3 4]\n",
|
||||
"\n",
|
||||
"x = np.arange(3, 7, 2)\n",
|
||||
"print(x) # [3 5]\n",
|
||||
"\n",
|
||||
"x = np.linspace(start=0, stop=2, num=9)\n",
|
||||
"print(x) \n",
|
||||
"# [0. 0.25 0.5 0.75 1. 1.25 1.5 1.75 2. ]\n",
|
||||
"\n",
|
||||
"x = np.logspace(0, 1, 5)\n",
|
||||
"print(np.around(x, 2))\n",
|
||||
"# [ 1. 1.78 3.16 5.62 10. ] \n",
|
||||
" #np.around 返回四舍五入后的值，可指定精度。\n",
|
||||
" # around(a, decimals=0, out=None)\n",
|
||||
" # a 输入数组\n",
|
||||
" # decimals 要舍入的小数位数。 默认值为0。 如果为负，整数将四舍五入到小数点左侧的位置\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"x = np.linspace(start=0, stop=1, num=5)\n",
|
||||
"x = [10 ** i for i in x]\n",
|
||||
"print(np.around(x, 2))\n",
|
||||
"# [ 1. 1.78 3.16 5.62 10. ]\n",
|
||||
"\n",
|
||||
"x = np.random.random(5)\n",
|
||||
"print(x)\n",
|
||||
"# [0.41768753 0.16315577 0.80167915 0.99690199 0.11812291]\n",
|
||||
"\n",
|
||||
"x = np.random.random([2, 3])\n",
|
||||
"print(x)\n",
|
||||
"# [[0.41151858 0.93785153 0.57031309]\n",
|
||||
"# [0.13482333 0.20583516 0.45429181]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"---\n",
|
||||
"## 4. 结构数组的创建\n",
|
||||
"\n",
|
||||
"结构数组，首先需要定义结构，然后利用`np.array()`来创建数组，其参数`dtype`为定义的结构。\n",
|
||||
"\n",
|
||||
"### **（a）利用字典来定义结构**\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"personType = np.dtype({\n",
|
||||
" 'names': ['name', 'age', 'weight'],\n",
|
||||
" 'formats': ['U30', 'i8', 'f8']})\n",
|
||||
"\n",
|
||||
"a = np.array([('Liming', 24, 63.9), ('Mike', 15, 67.), ('Jan', 34, 45.8)],\n",
|
||||
" dtype=personType)\n",
|
||||
"print(a, type(a))\n",
|
||||
"# [('Liming', 24, 63.9) ('Mike', 15, 67. ) ('Jan', 34, 45.8)]\n",
|
||||
"# <class 'numpy.ndarray'>\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"### **（b）利用包含多个元组的列表来定义结构**\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"personType = np.dtype([('name', 'U30'), ('age', 'i8'), ('weight', 'f8')])\n",
|
||||
"a = np.array([('Liming', 24, 63.9), ('Mike', 15, 67.), ('Jan', 34, 45.8)],\n",
|
||||
" dtype=personType)\n",
|
||||
"print(a, type(a))\n",
|
||||
"# [('Liming', 24, 63.9) ('Mike', 15, 67. ) ('Jan', 34, 45.8)]\n",
|
||||
"# <class 'numpy.ndarray'>\n",
|
||||
"\n",
|
||||
"# 结构数组的取值方式和一般数组差不多，可以通过下标取得元素：\n",
|
||||
"print(a[0])\n",
|
||||
"# ('Liming', 24, 63.9)\n",
|
||||
"\n",
|
||||
"print(a[-2:])\n",
|
||||
"# [('Mike', 15, 67. ) ('Jan', 34, 45.8)]\n",
|
||||
"\n",
|
||||
"# 我们可以使用字段名作为下标获取对应的值\n",
|
||||
"print(a['name'])\n",
|
||||
"# ['Liming' 'Mike' 'Jan']\n",
|
||||
"print(a['age'])\n",
|
||||
"# [24 15 34]\n",
|
||||
"print(a['weight'])\n",
|
||||
"# [63.9 67. 45.8]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"---\n",
|
||||
"# 数组的属性\n",
|
||||
"\n",
|
||||
"在使用 numpy 时，你会想知道数组的某些信息。很幸运，在这个包里边包含了很多便捷的方法，可以给你想要的信息。\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
" - `numpy.ndarray.ndim`用于返回数组的维数（轴的个数）也称为秩，一维数组的秩为 1，二维数组的秩为 2，以此类推。\n",
|
||||
" - `numpy.ndarray.shape`表示数组的维度，返回一个元组，这个元组的长度就是维度的数目，即 `ndim` 属性(秩)。\n",
|
||||
" - `numpy.ndarray.size`数组中所有元素的总量，相当于数组的`shape`中所有元素的乘积，例如矩阵的元素总量为行与列的乘积。\n",
|
||||
" - `numpy.ndarray.dtype` `ndarray` 对象的元素类型。\n",
|
||||
" - `numpy.ndarray.itemsize`以字节的形式返回数组中每一个元素的大小。\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"class ndarray(object):\n",
|
||||
" shape = property(lambda self: object(), lambda self, v: None, lambda self: None)\n",
|
||||
" dtype = property(lambda self: object(), lambda self, v: None, lambda self: None)\n",
|
||||
" size = property(lambda self: object(), lambda self, v: None, lambda self: None)\n",
|
||||
" ndim = property(lambda self: object(), lambda self, v: None, lambda self: None)\n",
|
||||
" itemsize = property(lambda self: object(), lambda self, v: None, lambda self: None)\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"a = np.array([1, 2, 3, 4, 5])\n",
|
||||
"print(a.shape) # (5,)\n",
|
||||
"print(a.dtype) # int32\n",
|
||||
"print(a.size) # 5\n",
|
||||
"print(a.ndim) # 1\n",
|
||||
"print(a.itemsize) # 4\n",
|
||||
"\n",
|
||||
"b = np.array([[1, 2, 3], [4, 5, 6.0]])\n",
|
||||
"print(b.shape) # (2, 3)\n",
|
||||
"print(b.dtype) # float64\n",
|
||||
"print(b.size) # 6\n",
|
||||
"print(b.ndim) # 2\n",
|
||||
"print(b.itemsize) # 8\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"在`ndarray`中所有元素必须是同一类型，否则会自动向下转换，`int->float->str`。\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"a = np.array([1, 2, 3, 4, 5])\n",
|
||||
"print(a) # [1 2 3 4 5]\n",
|
||||
"b = np.array([1, 2, 3, 4, '5'])\n",
|
||||
"print(b) # ['1' '2' '3' '4' '5']\n",
|
||||
"c = np.array([1, 2, 3, 4, 5.0])\n",
|
||||
"print(c) # [1. 2. 3. 4. 5.]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"kernelspec": {
|
||||
"display_name": "Python35",
|
||||
"language": "python",
|
||||
"name": "python35"
|
||||
},
|
||||
"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.10"
|
||||
},
|
||||
"toc": {
|
||||
"base_numbering": 1,
|
||||
"nav_menu": {},
|
||||
"number_sections": true,
|
||||
"sideBar": true,
|
||||
"skip_h1_title": false,
|
||||
"title_cell": "Table of Contents",
|
||||
"title_sidebar": "Contents",
|
||||
"toc_cell": false,
|
||||
"toc_position": {
|
||||
"height": "calc(100% - 180px)",
|
||||
"left": "10px",
|
||||
"top": "150px",
|
||||
"width": "307.188px"
|
||||
},
|
||||
"toc_section_display": true,
|
||||
"toc_window_display": true
|
||||
},
|
||||
"varInspector": {
|
||||
"cols": {
|
||||
"lenName": 16,
|
||||
"lenType": 16,
|
||||
"lenVar": 40
|
||||
},
|
||||
"kernels_config": {
|
||||
"python": {
|
||||
"delete_cmd_postfix": "",
|
||||
"delete_cmd_prefix": "del ",
|
||||
"library": "var_list.py",
|
||||
"varRefreshCmd": "print(var_dic_list())"
|
||||
},
|
||||
"r": {
|
||||
"delete_cmd_postfix": ") ",
|
||||
"delete_cmd_prefix": "rm(",
|
||||
"library": "var_list.r",
|
||||
"varRefreshCmd": "cat(var_dic_list()) "
|
||||
}
|
||||
},
|
||||
"types_to_exclude": [
|
||||
"module",
|
||||
"function",
|
||||
"builtin_function_or_method",
|
||||
"instance",
|
||||
"_Feature"
|
||||
],
|
||||
"window_display": false
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -1,6 +0,0 @@
|
||||
{
|
||||
"cells": [],
|
||||
"metadata": {},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -1,6 +0,0 @@
|
||||
{
|
||||
"cells": [],
|
||||
"metadata": {},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -1,940 +0,0 @@
|
||||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# 数组操作\n",
|
||||
"\n",
|
||||
"## 更改形状\n",
|
||||
"\n",
|
||||
"在对数组进行操作时，为了满足格式和计算的要求通常会改变其形状。\n",
|
||||
"\n",
|
||||
"- `numpy.ndarray.shape`表示数组的维度，返回一个元组，这个元组的长度就是维度的数目，即 `ndim` 属性(秩)。\n",
|
||||
"\n",
|
||||
"【例】通过修改 shap 属性来改变数组的形状。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([1, 2, 9, 4, 5, 6, 7, 8])\n",
|
||||
"print(x.shape) # (8,)\n",
|
||||
"x.shape = [2, 4]\n",
|
||||
"print(x)\n",
|
||||
"# [[1 2 9 4]\n",
|
||||
"# [5 6 7 8]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"- `numpy.ndarray.flat` 将数组转换为一维的迭代器，可以用for访问数组每一个元素。\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([[11, 12, 13, 14, 15],\n",
|
||||
" [16, 17, 18, 19, 20],\n",
|
||||
" [21, 22, 23, 24, 25],\n",
|
||||
" [26, 27, 28, 29, 30],\n",
|
||||
" [31, 32, 33, 34, 35]])\n",
|
||||
"y = x.flat\n",
|
||||
"print(y)\n",
|
||||
"# <numpy.flatiter object at 0x0000020F9BA10C60>\n",
|
||||
"for i in y:\n",
|
||||
" print(i, end=' ')\n",
|
||||
"# 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35\n",
|
||||
"\n",
|
||||
"y[3] = 0\n",
|
||||
"print(end='\\n')\n",
|
||||
"print(x)\n",
|
||||
"# [[11 12 13 0 15]\n",
|
||||
"# [16 17 18 19 20]\n",
|
||||
"# [21 22 23 24 25]\n",
|
||||
"# [26 27 28 29 30]\n",
|
||||
"# [31 32 33 34 35]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"- `numpy.ndarray.flatten([order='C'])` 将数组的副本转换为一维数组，并返回。\n",
|
||||
" - order：'C' -- 按行，'F' -- 按列，'A' -- 原顺序，'k' -- 元素在内存中的出现顺序。(简记)\n",
|
||||
" - order：{'C / F，'A，K}，可选使用此索引顺序读取a的元素。'C'意味着以行大的C风格顺序对元素进行索引，最后一个轴索引会更改F表示以列大的Fortran样式顺序索引元素，其中第一个索引变化最快，最后一个索引变化最快。请注意，'C'和'F'选项不考虑基础数组的内存布局，仅引用轴索引的顺序.A'表示如果a为Fortran，则以类似Fortran的索引顺序读取元素在内存中连续，否则类似C的顺序。“ K”表示按照步序在内存中的顺序读取元素，但步幅为负时反转数据除外。默认情况下，使用Cindex顺序。\n",
|
||||
"\n",
|
||||
"【例】`flatten()`函数返回的是拷贝。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([[11, 12, 13, 14, 15],\n",
|
||||
" [16, 17, 18, 19, 20],\n",
|
||||
" [21, 22, 23, 24, 25],\n",
|
||||
" [26, 27, 28, 29, 30],\n",
|
||||
" [31, 32, 33, 34, 35]])\n",
|
||||
"y = x.flatten()\n",
|
||||
"print(y)\n",
|
||||
"# [11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34\n",
|
||||
"# 35]\n",
|
||||
"\n",
|
||||
"y[3] = 0\n",
|
||||
"print(x)\n",
|
||||
"# [[11 12 13 14 15]\n",
|
||||
"# [16 17 18 19 20]\n",
|
||||
"# [21 22 23 24 25]\n",
|
||||
"# [26 27 28 29 30]\n",
|
||||
"# [31 32 33 34 35]]\n",
|
||||
"\n",
|
||||
"x = np.array([[11, 12, 13, 14, 15],\n",
|
||||
" [16, 17, 18, 19, 20],\n",
|
||||
" [21, 22, 23, 24, 25],\n",
|
||||
" [26, 27, 28, 29, 30],\n",
|
||||
" [31, 32, 33, 34, 35]])\n",
|
||||
"\n",
|
||||
"y = x.flatten(order='F')\n",
|
||||
"print(y)\n",
|
||||
"# [11 16 21 26 31 12 17 22 27 32 13 18 23 28 33 14 19 24 29 34 15 20 25 30\n",
|
||||
"# 35]\n",
|
||||
"\n",
|
||||
"y[3] = 0\n",
|
||||
"print(x)\n",
|
||||
"# [[11 12 13 14 15]\n",
|
||||
"# [16 17 18 19 20]\n",
|
||||
"# [21 22 23 24 25]\n",
|
||||
"# [26 27 28 29 30]\n",
|
||||
"# [31 32 33 34 35]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"- `numpy.ravel(a, order='C')`Return a contiguous flattened array.\n",
|
||||
"\n",
|
||||
"【例】`ravel()`返回的是视图。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([[11, 12, 13, 14, 15],\n",
|
||||
" [16, 17, 18, 19, 20],\n",
|
||||
" [21, 22, 23, 24, 25],\n",
|
||||
" [26, 27, 28, 29, 30],\n",
|
||||
" [31, 32, 33, 34, 35]])\n",
|
||||
"y = np.ravel(x)\n",
|
||||
"print(y)\n",
|
||||
"# [11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34\n",
|
||||
"# 35]\n",
|
||||
"\n",
|
||||
"y[3] = 0\n",
|
||||
"print(x)\n",
|
||||
"# [[11 12 13 0 15]\n",
|
||||
"# [16 17 18 19 20]\n",
|
||||
"# [21 22 23 24 25]\n",
|
||||
"# [26 27 28 29 30]\n",
|
||||
"# [31 32 33 34 35]]\n",
|
||||
"\n",
|
||||
"【例】order=F 就是拷贝\n",
|
||||
"\n",
|
||||
"x = np.array([[11, 12, 13, 14, 15],\n",
|
||||
" [16, 17, 18, 19, 20],\n",
|
||||
" [21, 22, 23, 24, 25],\n",
|
||||
" [26, 27, 28, 29, 30],\n",
|
||||
" [31, 32, 33, 34, 35]])\n",
|
||||
"\n",
|
||||
"y = np.ravel(x, order='F')\n",
|
||||
"print(y)\n",
|
||||
"# [11 16 21 26 31 12 17 22 27 32 13 18 23 28 33 14 19 24 29 34 15 20 25 30\n",
|
||||
"# 35]\n",
|
||||
"\n",
|
||||
"y[3] = 0\n",
|
||||
"print(x)\n",
|
||||
"# [[11 12 13 14 15]\n",
|
||||
"# [16 17 18 19 20]\n",
|
||||
"# [21 22 23 24 25]\n",
|
||||
"# [26 27 28 29 30]\n",
|
||||
"# [31 32 33 34 35]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"- `numpy.reshape(a, newshape[, order='C'])`在不更改数据的情况下为数组赋予新的形状。\n",
|
||||
"\n",
|
||||
"【例】`reshape()`函数当参数`newshape = [rows,-1]`时，将根据行数自动确定列数。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.arange(12)\n",
|
||||
"y = np.reshape(x, [3, 4])\n",
|
||||
"print(y.dtype) # int32\n",
|
||||
"print(y)\n",
|
||||
"# [[ 0 1 2 3]\n",
|
||||
"# [ 4 5 6 7]\n",
|
||||
"# [ 8 9 10 11]]\n",
|
||||
"\n",
|
||||
"y = np.reshape(x, [3, -1])\n",
|
||||
"print(y)\n",
|
||||
"# [[ 0 1 2 3]\n",
|
||||
"# [ 4 5 6 7]\n",
|
||||
"# [ 8 9 10 11]]\n",
|
||||
"\n",
|
||||
"y = np.reshape(x,[-1,3])\n",
|
||||
"print(y)\n",
|
||||
"# [[ 0 1 2]\n",
|
||||
"# [ 3 4 5]\n",
|
||||
"# [ 6 7 8]\n",
|
||||
"# [ 9 10 11]]\n",
|
||||
"\n",
|
||||
"y[0, 1] = 10\n",
|
||||
"print(x)\n",
|
||||
"# [ 0 10 2 3 4 5 6 7 8 9 10 11]（改变x去reshape后y中的值，x对应元素也改变）\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"【例】`reshape()`函数当参数`newshape = -1`时，表示将数组降为一维。\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.random.randint(12, size=[2, 2, 3])\n",
|
||||
"print(x)\n",
|
||||
"# [[[11 9 1]\n",
|
||||
"# [ 1 10 3]]\n",
|
||||
"# \n",
|
||||
"# [[ 0 6 1]\n",
|
||||
"# [ 4 11 3]]]\n",
|
||||
"y = np.reshape(x, -1)\n",
|
||||
"print(y)\n",
|
||||
"# [11 9 1 1 10 3 0 6 1 4 11 3]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"## 数组转置\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"- `numpy.transpose(a, axes=None)` Permute the dimensions of an array.\n",
|
||||
"- `numpy.ndarray.T` Same as `self.transpose()`, except that self is returned if `self.ndim < 2`.\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.random.rand(5, 5) * 10\n",
|
||||
"x = np.around(x, 2)\n",
|
||||
"print(x)\n",
|
||||
"# [[6.74 8.46 6.74 5.45 1.25]\n",
|
||||
"# [3.54 3.49 8.62 1.94 9.92]\n",
|
||||
"# [5.03 7.22 1.6 8.7 0.43]\n",
|
||||
"# [7.5 7.31 5.69 9.67 7.65]\n",
|
||||
"# [1.8 9.52 2.78 5.87 4.14]]\n",
|
||||
"y = x.T\n",
|
||||
"print(y)\n",
|
||||
"# [[6.74 3.54 5.03 7.5 1.8 ]\n",
|
||||
"# [8.46 3.49 7.22 7.31 9.52]\n",
|
||||
"# [6.74 8.62 1.6 5.69 2.78]\n",
|
||||
"# [5.45 1.94 8.7 9.67 5.87]\n",
|
||||
"# [1.25 9.92 0.43 7.65 4.14]]\n",
|
||||
"y = np.transpose(x)\n",
|
||||
"print(y)\n",
|
||||
"# [[6.74 3.54 5.03 7.5 1.8 ]\n",
|
||||
"# [8.46 3.49 7.22 7.31 9.52]\n",
|
||||
"# [6.74 8.62 1.6 5.69 2.78]\n",
|
||||
"# [5.45 1.94 8.7 9.67 5.87]\n",
|
||||
"# [1.25 9.92 0.43 7.65 4.14]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"## 更改维度\n",
|
||||
"\n",
|
||||
"当创建一个数组之后，还可以给它增加一个维度，这在矩阵计算中经常会用到。\n",
|
||||
"\n",
|
||||
"- `numpy.newaxis = None` `None`的别名，对索引数组很有用。\n",
|
||||
"\n",
|
||||
"【例】很多工具包在进行计算时都会先判断输入数据的维度是否满足要求，如果输入数据达不到指定的维度时，可以使用`newaxis`参数来增加一个维度。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([1, 2, 9, 4, 5, 6, 7, 8])\n",
|
||||
"print(x.shape) # (8,)\n",
|
||||
"print(x) # [1 2 9 4 5 6 7 8]\n",
|
||||
"\n",
|
||||
"y = x[np.newaxis, :]\n",
|
||||
"print(y.shape) # (1, 8)\n",
|
||||
"print(y) # [[1 2 9 4 5 6 7 8]]\n",
|
||||
"\n",
|
||||
"y = x[:, np.newaxis]\n",
|
||||
"print(y.shape) # (8, 1)\n",
|
||||
"print(y)\n",
|
||||
"# [[1]\n",
|
||||
"# [2]\n",
|
||||
"# [9]\n",
|
||||
"# [4]\n",
|
||||
"# [5]\n",
|
||||
"# [6]\n",
|
||||
"# [7]\n",
|
||||
"# [8]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"- `numpy.squeeze(a, axis=None)` 从数组的形状中删除单维度条目，即把shape中为1的维度去掉。\n",
|
||||
" - `a`表示输入的数组；\n",
|
||||
" - `axis`用于指定需要删除的维度，但是指定的维度必须为单维度，否则将会报错；\n",
|
||||
"\n",
|
||||
"在机器学习和深度学习中，通常算法的结果是可以表示向量的数组（即包含两对或以上的方括号形式[[]]），如果直接利用这个数组进行画图可能显示界面为空（见后面的示例）。我们可以利用`squeeze()`函数将表示向量的数组转换为秩为1的数组，这样利用 matplotlib 库函数画图时，就可以正常的显示结果了。\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.arange(10)\n",
|
||||
"print(x.shape) # (10,)\n",
|
||||
"x = x[np.newaxis, :]\n",
|
||||
"print(x.shape) # (1, 10)\n",
|
||||
"y = np.squeeze(x)\n",
|
||||
"print(y.shape) # (10,)\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([[[0], [1], [2]]])\n",
|
||||
"print(x.shape) # (1, 3, 1)\n",
|
||||
"print(x)\n",
|
||||
"# [[[0]\n",
|
||||
"# [1]\n",
|
||||
"# [2]]]\n",
|
||||
"\n",
|
||||
"y = np.squeeze(x)\n",
|
||||
"print(y.shape) # (3,)\n",
|
||||
"print(y) # [0 1 2]\n",
|
||||
"\n",
|
||||
"y = np.squeeze(x, axis=0)\n",
|
||||
"print(y.shape) # (3, 1)\n",
|
||||
"print(y)\n",
|
||||
"# [[0]\n",
|
||||
"# [1]\n",
|
||||
"# [2]]\n",
|
||||
"\n",
|
||||
"y = np.squeeze(x, axis=2)\n",
|
||||
"print(y.shape) # (1, 3)\n",
|
||||
"print(y) # [[0 1 2]]\n",
|
||||
"\n",
|
||||
"y = np.squeeze(x, axis=1)\n",
|
||||
"# ValueError: cannot select an axis to squeeze out which has size not equal to one\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"import matplotlib.pyplot as plt\n",
|
||||
"\n",
|
||||
"x = np.array([[1, 4, 9, 16, 25]])\n",
|
||||
"print(x.shape) # (1, 5)\n",
|
||||
"plt.plot(x)\n",
|
||||
"plt.show()\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"import matplotlib.pyplot as plt\n",
|
||||
"\n",
|
||||
"x = np.array([[1, 4, 9, 16, 25]])\n",
|
||||
"x = np.squeeze(x)\n",
|
||||
"print(x.shape) # (5, )\n",
|
||||
"plt.plot(x)\n",
|
||||
"plt.show()\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"## 数组组合\n",
|
||||
"\n",
|
||||
"如果要将两份数据组合到一起，就需要拼接操作。\n",
|
||||
"\n",
|
||||
"- `numpy.concatenate((a1, a2, ...), axis=0, out=None)` Join a sequence of arrays along an existing axis.\n",
|
||||
"\n",
|
||||
"【例】连接沿现有轴的数组序列（原来x，y都是一维的，拼接后的结果也是一维的）。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([1, 2, 3])\n",
|
||||
"y = np.array([7, 8, 9])\n",
|
||||
"z = np.concatenate([x, y])\n",
|
||||
"print(z)\n",
|
||||
"# [1 2 3 7 8 9]\n",
|
||||
"\n",
|
||||
"z = np.concatenate([x, y], axis=0)\n",
|
||||
"print(z)\n",
|
||||
"# [1 2 3 7 8 9]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"【例】原来x，y都是二维的，拼接后的结果也是二维的。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([1, 2, 3]).reshape(1, 3)\n",
|
||||
"y = np.array([7, 8, 9]).reshape(1, 3)\n",
|
||||
"z = np.concatenate([x, y])\n",
|
||||
"print(z)\n",
|
||||
"# [[ 1 2 3]\n",
|
||||
"# [ 7 8 9]]\n",
|
||||
"z = np.concatenate([x, y], axis=0)\n",
|
||||
"print(z)\n",
|
||||
"# [[ 1 2 3]\n",
|
||||
"# [ 7 8 9]]\n",
|
||||
"z = np.concatenate([x, y], axis=1)\n",
|
||||
"print(z)\n",
|
||||
"# [[ 1 2 3 7 8 9]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"【例】x，y在原来的维度上进行拼接。\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([[1, 2, 3], [4, 5, 6]])\n",
|
||||
"y = np.array([[7, 8, 9], [10, 11, 12]])\n",
|
||||
"z = np.concatenate([x, y])\n",
|
||||
"print(z)\n",
|
||||
"# [[ 1 2 3]\n",
|
||||
"# [ 4 5 6]\n",
|
||||
"# [ 7 8 9]\n",
|
||||
"# [10 11 12]]\n",
|
||||
"z = np.concatenate([x, y], axis=0)\n",
|
||||
"print(z)\n",
|
||||
"# [[ 1 2 3]\n",
|
||||
"# [ 4 5 6]\n",
|
||||
"# [ 7 8 9]\n",
|
||||
"# [10 11 12]]\n",
|
||||
"z = np.concatenate([x, y], axis=1)\n",
|
||||
"print(z)\n",
|
||||
"# [[ 1 2 3 7 8 9]\n",
|
||||
"# [ 4 5 6 10 11 12]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"- `numpy.stack(arrays, axis=0, out=None)`Join a sequence of arrays along a new axis.\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】沿着新的轴加入一系列数组（stack为增加维度的拼接）。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([1, 2, 3])\n",
|
||||
"y = np.array([7, 8, 9])\n",
|
||||
"z = np.stack([x, y])\n",
|
||||
"print(z.shape) # (2, 3)\n",
|
||||
"print(z)\n",
|
||||
"# [[1 2 3]\n",
|
||||
"# [7 8 9]]\n",
|
||||
"\n",
|
||||
"z = np.stack([x, y], axis=1)\n",
|
||||
"print(z.shape) # (3, 2)\n",
|
||||
"print(z)\n",
|
||||
"# [[1 7]\n",
|
||||
"# [2 8]\n",
|
||||
"# [3 9]]\n",
|
||||
"```\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([1, 2, 3]).reshape(1, 3)\n",
|
||||
"y = np.array([7, 8, 9]).reshape(1, 3)\n",
|
||||
"z = np.stack([x, y])\n",
|
||||
"print(z.shape) # (2, 1, 3)\n",
|
||||
"print(z)\n",
|
||||
"# [[[1 2 3]]\n",
|
||||
"#\n",
|
||||
"# [[7 8 9]]]\n",
|
||||
"\n",
|
||||
"z = np.stack([x, y], axis=1)\n",
|
||||
"print(z.shape) # (1, 2, 3)\n",
|
||||
"print(z)\n",
|
||||
"# [[[1 2 3]\n",
|
||||
"# [7 8 9]]]\n",
|
||||
"\n",
|
||||
"z = np.stack([x, y], axis=2)\n",
|
||||
"print(z.shape) # (1, 3, 2)\n",
|
||||
"print(z)\n",
|
||||
"# [[[1 7]\n",
|
||||
"# [2 8]\n",
|
||||
"# [3 9]]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([[1, 2, 3], [4, 5, 6]])\n",
|
||||
"y = np.array([[7, 8, 9], [10, 11, 12]])\n",
|
||||
"z = np.stack([x, y])\n",
|
||||
"print(z.shape) # (2, 2, 3)\n",
|
||||
"print(z)\n",
|
||||
"# [[[ 1 2 3]\n",
|
||||
"# [ 4 5 6]]\n",
|
||||
"# \n",
|
||||
"# [[ 7 8 9]\n",
|
||||
"# [10 11 12]]]\n",
|
||||
"\n",
|
||||
"z = np.stack([x, y], axis=1)\n",
|
||||
"print(z.shape) # (2, 2, 3)\n",
|
||||
"print(z)\n",
|
||||
"# [[[ 1 2 3]\n",
|
||||
"# [ 7 8 9]]\n",
|
||||
"# \n",
|
||||
"# [[ 4 5 6]\n",
|
||||
"# [10 11 12]]]\n",
|
||||
"\n",
|
||||
"z = np.stack([x, y], axis=2)\n",
|
||||
"print(z.shape) # (2, 3, 2)\n",
|
||||
"print(z)\n",
|
||||
"# [[[ 1 7]\n",
|
||||
"# [ 2 8]\n",
|
||||
"# [ 3 9]]\n",
|
||||
"# \n",
|
||||
"# [[ 4 10]\n",
|
||||
"# [ 5 11]\n",
|
||||
"# [ 6 12]]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"- `numpy.vstack(tup)`Stack arrays in sequence vertically (row wise).\n",
|
||||
"- `numpy.hstack(tup)`Stack arrays in sequence horizontally (column wise). \n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】一维的情况。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([1, 2, 3])\n",
|
||||
"y = np.array([7, 8, 9])\n",
|
||||
"z = np.vstack((x, y))\n",
|
||||
"print(z.shape) # (2, 3)\n",
|
||||
"print(z)\n",
|
||||
"# [[1 2 3]\n",
|
||||
"# [7 8 9]]\n",
|
||||
"\n",
|
||||
"z = np.stack([x, y])\n",
|
||||
"print(z.shape) # (2, 3)\n",
|
||||
"print(z)\n",
|
||||
"# [[1 2 3]\n",
|
||||
"# [7 8 9]]\n",
|
||||
"\n",
|
||||
"z = np.hstack((x, y))\n",
|
||||
"print(z.shape) # (6,)\n",
|
||||
"print(z)\n",
|
||||
"# [1 2 3 7 8 9]\n",
|
||||
"\n",
|
||||
"z = np.concatenate((x, y))\n",
|
||||
"print(z.shape) # (6,)\n",
|
||||
"print(z) # [1 2 3 7 8 9]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】二维的情况。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([1, 2, 3]).reshape(1, 3)\n",
|
||||
"y = np.array([7, 8, 9]).reshape(1, 3)\n",
|
||||
"z = np.vstack((x, y))\n",
|
||||
"print(z.shape) # (2, 3)\n",
|
||||
"print(z)\n",
|
||||
"# [[1 2 3]\n",
|
||||
"# [7 8 9]]\n",
|
||||
"\n",
|
||||
"z = np.concatenate((x, y), axis=0)\n",
|
||||
"print(z.shape) # (2, 3)\n",
|
||||
"print(z)\n",
|
||||
"# [[1 2 3]\n",
|
||||
"# [7 8 9]]\n",
|
||||
"\n",
|
||||
"z = np.hstack((x, y))\n",
|
||||
"print(z.shape) # (1, 6)\n",
|
||||
"print(z)\n",
|
||||
"# [[ 1 2 3 7 8 9]]\n",
|
||||
"\n",
|
||||
"z = np.concatenate((x, y), axis=1)\n",
|
||||
"print(z.shape) # (1, 6)\n",
|
||||
"print(z)\n",
|
||||
"# [[1 2 3 7 8 9]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"【例】二维的情况。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([[1, 2, 3], [4, 5, 6]])\n",
|
||||
"y = np.array([[7, 8, 9], [10, 11, 12]])\n",
|
||||
"z = np.vstack((x, y))\n",
|
||||
"print(z.shape) # (4, 3)\n",
|
||||
"print(z)\n",
|
||||
"# [[ 1 2 3]\n",
|
||||
"# [ 4 5 6]\n",
|
||||
"# [ 7 8 9]\n",
|
||||
"# [10 11 12]]\n",
|
||||
"\n",
|
||||
"z = np.concatenate((x, y), axis=0)\n",
|
||||
"print(z.shape) # (4, 3)\n",
|
||||
"print(z)\n",
|
||||
"# [[ 1 2 3]\n",
|
||||
"# [ 4 5 6]\n",
|
||||
"# [ 7 8 9]\n",
|
||||
"# [10 11 12]]\n",
|
||||
"\n",
|
||||
"z = np.hstack((x, y))\n",
|
||||
"print(z.shape) # (2, 6)\n",
|
||||
"print(z)\n",
|
||||
"# [[ 1 2 3 7 8 9]\n",
|
||||
"# [ 4 5 6 10 11 12]]\n",
|
||||
"\n",
|
||||
"z = np.concatenate((x, y), axis=1)\n",
|
||||
"print(z.shape) # (2, 6)\n",
|
||||
"print(z)\n",
|
||||
"# [[ 1 2 3 7 8 9]\n",
|
||||
"# [ 4 5 6 10 11 12]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"`hstack(),vstack()`分别表示水平和竖直的拼接方式。在数据维度等于1时，比较特殊。而当维度大于或等于2时，它们的作用相当于`concatenate`，用于在已有轴上进行操作。\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"a = np.hstack([np.array([1, 2, 3, 4]), 5])\n",
|
||||
"print(a) # [1 2 3 4 5]\n",
|
||||
"\n",
|
||||
"a = np.concatenate([np.array([1, 2, 3, 4]), 5])\n",
|
||||
"print(a)\n",
|
||||
"# all the input arrays must have same number of dimensions, but the array at index 0 has 1 dimension(s) and the array at index 1 has 0 dimension(s)\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"## 数组拆分\n",
|
||||
"\n",
|
||||
"- `numpy.split(ary, indices_or_sections, axis=0)` Split an array into multiple sub-arrays as views into ary.\n",
|
||||
"\n",
|
||||
"【例】拆分数组。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([[11, 12, 13, 14],\n",
|
||||
" [16, 17, 18, 19],\n",
|
||||
" [21, 22, 23, 24]])\n",
|
||||
"y = np.split(x, [1, 3])\n",
|
||||
"print(y)\n",
|
||||
"# [array([[11, 12, 13, 14]]), array([[16, 17, 18, 19],\n",
|
||||
"# [21, 22, 23, 24]]), array([], shape=(0, 4), dtype=int32)]\n",
|
||||
"\n",
|
||||
"y = np.split(x, [1, 3], axis=1)\n",
|
||||
"print(y)\n",
|
||||
"# [array([[11],\n",
|
||||
"# [16],\n",
|
||||
"# [21]]), array([[12, 13],\n",
|
||||
"# [17, 18],\n",
|
||||
"# [22, 23]]), array([[14],\n",
|
||||
"# [19],\n",
|
||||
"# [24]])]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"- `numpy.vsplit(ary, indices_or_sections)` Split an array into multiple sub-arrays vertically (row-wise).\n",
|
||||
"\n",
|
||||
"【例】垂直切分是把数组按照高度切分\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([[11, 12, 13, 14],\n",
|
||||
" [16, 17, 18, 19],\n",
|
||||
" [21, 22, 23, 24]])\n",
|
||||
"y = np.vsplit(x, 3)\n",
|
||||
"print(y)\n",
|
||||
"# [array([[11, 12, 13, 14]]), array([[16, 17, 18, 19]]), array([[21, 22, 23, 24]])]\n",
|
||||
"\n",
|
||||
"y = np.split(x, 3)\n",
|
||||
"print(y)\n",
|
||||
"# [array([[11, 12, 13, 14]]), array([[16, 17, 18, 19]]), array([[21, 22, 23, 24]])]\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"y = np.vsplit(x, [1])\n",
|
||||
"print(y)\n",
|
||||
"# [array([[11, 12, 13, 14]]), array([[16, 17, 18, 19],\n",
|
||||
"# [21, 22, 23, 24]])]\n",
|
||||
"\n",
|
||||
"y = np.split(x, [1])\n",
|
||||
"print(y)\n",
|
||||
"# [array([[11, 12, 13, 14]]), array([[16, 17, 18, 19],\n",
|
||||
"# [21, 22, 23, 24]])]\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"y = np.vsplit(x, [1, 3])\n",
|
||||
"print(y)\n",
|
||||
"# [array([[11, 12, 13, 14]]), array([[16, 17, 18, 19],\n",
|
||||
"# [21, 22, 23, 24]]), array([], shape=(0, 4), dtype=int32)]\n",
|
||||
"y = np.split(x, [1, 3], axis=0)\n",
|
||||
"print(y)\n",
|
||||
"# [array([[11, 12, 13, 14]]), array([[16, 17, 18, 19],\n",
|
||||
"# [21, 22, 23, 24]]), array([], shape=(0, 4), dtype=int32)]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"- `numpy.hsplit(ary, indices_or_sections)` Split an array into multiple sub-arrays horizontally (column-wise).\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】水平切分是把数组按照宽度切分。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([[11, 12, 13, 14],\n",
|
||||
" [16, 17, 18, 19],\n",
|
||||
" [21, 22, 23, 24]])\n",
|
||||
"y = np.hsplit(x, 2)\n",
|
||||
"print(y)\n",
|
||||
"# [array([[11, 12],\n",
|
||||
"# [16, 17],\n",
|
||||
"# [21, 22]]), array([[13, 14],\n",
|
||||
"# [18, 19],\n",
|
||||
"# [23, 24]])]\n",
|
||||
"\n",
|
||||
"y = np.split(x, 2, axis=1)\n",
|
||||
"print(y)\n",
|
||||
"# [array([[11, 12],\n",
|
||||
"# [16, 17],\n",
|
||||
"# [21, 22]]), array([[13, 14],\n",
|
||||
"# [18, 19],\n",
|
||||
"# [23, 24]])]\n",
|
||||
"\n",
|
||||
"y = np.hsplit(x, [3])\n",
|
||||
"print(y)\n",
|
||||
"# [array([[11, 12, 13],\n",
|
||||
"# [16, 17, 18],\n",
|
||||
"# [21, 22, 23]]), array([[14],\n",
|
||||
"# [19],\n",
|
||||
"# [24]])]\n",
|
||||
"\n",
|
||||
"y = np.split(x, [3], axis=1)\n",
|
||||
"print(y)\n",
|
||||
"# [array([[11, 12, 13],\n",
|
||||
"# [16, 17, 18],\n",
|
||||
"# [21, 22, 23]]), array([[14],\n",
|
||||
"# [19],\n",
|
||||
"# [24]])]\n",
|
||||
"\n",
|
||||
"y = np.hsplit(x, [1, 3])\n",
|
||||
"print(y)\n",
|
||||
"# [array([[11],\n",
|
||||
"# [16],\n",
|
||||
"# [21]]), array([[12, 13],\n",
|
||||
"# [17, 18],\n",
|
||||
"# [22, 23]]), array([[14],\n",
|
||||
"# [19],\n",
|
||||
"# [24]])]\n",
|
||||
"\n",
|
||||
"y = np.split(x, [1, 3], axis=1)\n",
|
||||
"print(y)\n",
|
||||
"# [array([[11],\n",
|
||||
"# [16],\n",
|
||||
"# [21]]), array([[12, 13],\n",
|
||||
"# [17, 18],\n",
|
||||
"# [22, 23]]), array([[14],\n",
|
||||
"# [19],\n",
|
||||
"# [24]])]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"## 数组平铺\n",
|
||||
"\n",
|
||||
"- `numpy.tile(A, reps)` Construct an array by repeating A the number of times given by reps.\n",
|
||||
"\n",
|
||||
"`tile`是瓷砖的意思，顾名思义，这个函数就是把数组像瓷砖一样铺展开来。\n",
|
||||
"\n",
|
||||
"【例】将原矩阵横向、纵向地复制。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([[1, 2], [3, 4]])\n",
|
||||
"print(x)\n",
|
||||
"# [[1 2]\n",
|
||||
"# [3 4]]\n",
|
||||
"\n",
|
||||
"y = np.tile(x, (1, 3))\n",
|
||||
"print(y)\n",
|
||||
"# [[1 2 1 2 1 2]\n",
|
||||
"# [3 4 3 4 3 4]]\n",
|
||||
"\n",
|
||||
"y = np.tile(x, (3, 1))\n",
|
||||
"print(y)\n",
|
||||
"# [[1 2]\n",
|
||||
"# [3 4]\n",
|
||||
"# [1 2]\n",
|
||||
"# [3 4]\n",
|
||||
"# [1 2]\n",
|
||||
"# [3 4]]\n",
|
||||
"\n",
|
||||
"y = np.tile(x, (3, 3))\n",
|
||||
"print(y)\n",
|
||||
"# [[1 2 1 2 1 2]\n",
|
||||
"# [3 4 3 4 3 4]\n",
|
||||
"# [1 2 1 2 1 2]\n",
|
||||
"# [3 4 3 4 3 4]\n",
|
||||
"# [1 2 1 2 1 2]\n",
|
||||
"# [3 4 3 4 3 4]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"- `numpy.repeat(a, repeats, axis=None)` Repeat elements of an array.\n",
|
||||
" - `axis=0`，沿着y轴复制，实际上增加了行数。\n",
|
||||
" - `axis=1`，沿着x轴复制，实际上增加了列数。\n",
|
||||
" - `repeats`，可以为一个数，也可以为一个矩阵。\n",
|
||||
" - `axis=None`时就会flatten当前矩阵，实际上就是变成了一个行向量。\n",
|
||||
"\n",
|
||||
"【例】重复数组的元素。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.repeat(3, 4)\n",
|
||||
"print(x) # [3 3 3 3]\n",
|
||||
"\n",
|
||||
"x = np.array([[1, 2], [3, 4]])\n",
|
||||
"y = np.repeat(x, 2)\n",
|
||||
"print(y)\n",
|
||||
"# [1 1 2 2 3 3 4 4]\n",
|
||||
"\n",
|
||||
"y = np.repeat(x, 2, axis=0)\n",
|
||||
"print(y)\n",
|
||||
"# [[1 2]\n",
|
||||
"# [1 2]\n",
|
||||
"# [3 4]\n",
|
||||
"# [3 4]]\n",
|
||||
"\n",
|
||||
"y = np.repeat(x, 2, axis=1)\n",
|
||||
"print(y)\n",
|
||||
"# [[1 1 2 2]\n",
|
||||
"# [3 3 4 4]]\n",
|
||||
"\n",
|
||||
"y = np.repeat(x, [2, 3], axis=0)\n",
|
||||
"print(y)\n",
|
||||
"# [[1 2]\n",
|
||||
"# [1 2]\n",
|
||||
"# [3 4]\n",
|
||||
"# [3 4]\n",
|
||||
"# [3 4]]\n",
|
||||
"\n",
|
||||
"y = np.repeat(x, [2, 3], axis=1)\n",
|
||||
"print(y)\n",
|
||||
"# [[1 1 2 2 2]\n",
|
||||
"# [3 3 4 4 4]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"---\n",
|
||||
"## 添加和删除元素\n",
|
||||
"\n",
|
||||
"- `numpy.unique(ar, return_index=False, return_inverse=False,return_counts=False, axis=None)` Find the unique elements of an array.\n",
|
||||
" - return_index：the indices of the input array that give the unique values\n",
|
||||
" - return_inverse：the indices of the unique array that reconstruct the input array\n",
|
||||
" - return_counts：the number of times each unique value comes up in the input array\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】查找数组的唯一元素。\n",
|
||||
"```python\n",
|
||||
"a=np.array([1,1,2,3,3,4,4])\n",
|
||||
"b=np.unique(a,return_counts=True)\n",
|
||||
"print(b[0][list(b[1]).index(1)])\n",
|
||||
"#2\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"---\n",
|
||||
"**参考文献**\n",
|
||||
"- https://blog.csdn.net/csdn15698845876/article/details/73380803\n",
|
||||
"\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 26,
|
||||
"metadata": {
|
||||
"ExecuteTime": {
|
||||
"end_time": "2020-08-30T13:01:49.899843Z",
|
||||
"start_time": "2020-08-30T13:01:49.895853Z"
|
||||
}
|
||||
},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"2\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"a=np.array([1,1,2,3,3,4,4])\n",
|
||||
"b=np.unique(a,return_counts=True)\n",
|
||||
"print(b[0][list(b[1]).index(1)])"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"kernelspec": {
|
||||
"display_name": "Python35",
|
||||
"language": "python",
|
||||
"name": "python35"
|
||||
},
|
||||
"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.10"
|
||||
},
|
||||
"toc": {
|
||||
"base_numbering": 1,
|
||||
"nav_menu": {},
|
||||
"number_sections": true,
|
||||
"sideBar": true,
|
||||
"skip_h1_title": false,
|
||||
"title_cell": "Table of Contents",
|
||||
"title_sidebar": "Contents",
|
||||
"toc_cell": false,
|
||||
"toc_position": {
|
||||
"height": "calc(100% - 180px)",
|
||||
"left": "10px",
|
||||
"top": "150px",
|
||||
"width": "307.193px"
|
||||
},
|
||||
"toc_section_display": true,
|
||||
"toc_window_display": true
|
||||
},
|
||||
"varInspector": {
|
||||
"cols": {
|
||||
"lenName": 16,
|
||||
"lenType": 16,
|
||||
"lenVar": 40
|
||||
},
|
||||
"kernels_config": {
|
||||
"python": {
|
||||
"delete_cmd_postfix": "",
|
||||
"delete_cmd_prefix": "del ",
|
||||
"library": "var_list.py",
|
||||
"varRefreshCmd": "print(var_dic_list())"
|
||||
},
|
||||
"r": {
|
||||
"delete_cmd_postfix": ") ",
|
||||
"delete_cmd_prefix": "rm(",
|
||||
"library": "var_list.r",
|
||||
"varRefreshCmd": "cat(var_dic_list()) "
|
||||
}
|
||||
},
|
||||
"types_to_exclude": [
|
||||
"module",
|
||||
"function",
|
||||
"builtin_function_or_method",
|
||||
"instance",
|
||||
"_Feature"
|
||||
],
|
||||
"window_display": false
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -1,6 +0,0 @@
|
||||
{
|
||||
"cells": [],
|
||||
"metadata": {},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -1,6 +0,0 @@
|
||||
{
|
||||
"cells": [],
|
||||
"metadata": {},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -1,828 +0,0 @@
|
||||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# 向量化和广播\n",
|
||||
"\n",
|
||||
"向量化和广播这两个概念是 numpy 内部实现的基础。有了向量化，编写代码时无需使用显式循环。这些循环实际上不能省略，只不过是在内部实现，被代码中的其他结构代替。向量化的应用使得代码更简洁，可读性更强，也可以说使用了向量化方法的代码看上去更“Pythonic”。\n",
|
||||
"\n",
|
||||
"广播（Broadcasting）机制描述了 numpy 如何在算术运算期间处理具有不同形状的数组，让较小的数组在较大的数组上“广播”，以便它们具有兼容的形状。并不是所有的维度都要彼此兼容才符合广播机制的要求，但它们必须满足一定的条件。\n",
|
||||
"\n",
|
||||
"若两个数组的各维度兼容，也就是两个数组的每一维等长，或其中一个数组为 一维，那么广播机制就适用。如果这两个条件不满足，numpy就会抛出异常，说两个数组不兼容。\n",
|
||||
"\n",
|
||||
"总结来说，广播的规则有三个：\n",
|
||||
"- 如果两个数组的维度数dim不相同，那么小维度数组的形状将会在左边补1。\n",
|
||||
"- 如果shape维度不匹配，但是有维度是1，那么可以扩展维度是1的维度匹配另一个数组；\n",
|
||||
"- 如果shape维度不匹配，但是没有任何一个维度是1，则匹配引发错误；\n",
|
||||
"\n",
|
||||
"【例】二维数组加一维数组\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.arange(4)\n",
|
||||
"y = np.ones((3, 4))\n",
|
||||
"print(x.shape) # (4,)\n",
|
||||
"print(y.shape) # (3, 4)\n",
|
||||
"\n",
|
||||
"print((x + y).shape) # (3, 4)\n",
|
||||
"print(x + y)\n",
|
||||
"# [[1. 2. 3. 4.]\n",
|
||||
"# [1. 2. 3. 4.]\n",
|
||||
"# [1. 2. 3. 4.]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】两个数组均需要广播\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.arange(4).reshape(4, 1)\n",
|
||||
"y = np.ones(5)\n",
|
||||
"\n",
|
||||
"print(x.shape) # (4, 1)\n",
|
||||
"print(y.shape) # (5,)\n",
|
||||
"\n",
|
||||
"print((x + y).shape) # (4, 5)\n",
|
||||
"print(x + y)\n",
|
||||
"# [[1. 1. 1. 1. 1.]\n",
|
||||
"# [2. 2. 2. 2. 2.]\n",
|
||||
"# [3. 3. 3. 3. 3.]\n",
|
||||
"# [4. 4. 4. 4. 4.]]\n",
|
||||
"\n",
|
||||
"x = np.array([0.0, 10.0, 20.0, 30.0])\n",
|
||||
"y = np.array([1.0, 2.0, 3.0])\n",
|
||||
"z = x[:, np.newaxis] + y\n",
|
||||
"print(z)\n",
|
||||
"# [[ 1. 2. 3.]\n",
|
||||
"# [11. 12. 13.]\n",
|
||||
"# [21. 22. 23.]\n",
|
||||
"# [31. 32. 33.]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"【例】不匹配报错的例子\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.arange(4)\n",
|
||||
"y = np.ones(5)\n",
|
||||
"\n",
|
||||
"print(x.shape) # (4,)\n",
|
||||
"print(y.shape) # (5,)\n",
|
||||
"\n",
|
||||
"print(x + y)\n",
|
||||
"# ValueError: operands could not be broadcast together with shapes (4,) (5,) \n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"---\n",
|
||||
"# 数学函数\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"## 算数运算\n",
|
||||
"### numpy.add\n",
|
||||
"### numpy.subtract\n",
|
||||
"### numpy.multiply\n",
|
||||
"\n",
|
||||
"- `numpy.add(x1, x2, *args, **kwargs)` Add arguments element-wise.\n",
|
||||
"- `numpy.subtract(x1, x2, *args, **kwargs)` Subtract arguments element-wise.\n",
|
||||
"- `numpy.multiply(x1, x2, *args, **kwargs)` Multiply arguments element-wise.\n",
|
||||
"- `numpy.divide(x1, x2, *args, **kwargs)` Returns a true division of the inputs, element-wise.\n",
|
||||
"- `numpy.floor_divide(x1, x2, *args, **kwargs)` Return the largest integer smaller or equal to the division of the inputs.\n",
|
||||
"- `numpy.power(x1, x2, *args, **kwargs)` First array elements raised to powers from second array, element-wise.\n",
|
||||
"\n",
|
||||
"在 numpy 中对以上函数进行了运算符的重载，且运算符为 **元素级**。也就是说，它们只用于位置相同的元素之间，所得到的运算结果组成一个新的数组。\n",
|
||||
"\n",
|
||||
"【例】注意 numpy 的广播规则。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([1, 2, 3, 4, 5, 6, 7, 8])\n",
|
||||
"y = x + 1\n",
|
||||
"print(y)\n",
|
||||
"print(np.add(x, 1))\n",
|
||||
"# [2 3 4 5 6 7 8 9]\n",
|
||||
"\n",
|
||||
"y = x - 1\n",
|
||||
"print(y)\n",
|
||||
"print(np.subtract(x, 1))\n",
|
||||
"# [0 1 2 3 4 5 6 7]\n",
|
||||
"\n",
|
||||
"y = x * 2\n",
|
||||
"print(y)\n",
|
||||
"print(np.multiply(x, 2))\n",
|
||||
"# [ 2 4 6 8 10 12 14 16]\n",
|
||||
"\n",
|
||||
"y = x / 2\n",
|
||||
"print(y)\n",
|
||||
"print(np.divide(x, 2))\n",
|
||||
"# [0.5 1. 1.5 2. 2.5 3. 3.5 4. ]\n",
|
||||
"\n",
|
||||
"y = x // 2\n",
|
||||
"print(y)\n",
|
||||
"print(np.floor_divide(x, 2))\n",
|
||||
"# [0 1 1 2 2 3 3 4]\n",
|
||||
"\n",
|
||||
"y = x ** 2\n",
|
||||
"print(y)\n",
|
||||
"print(np.power(x, 2))\n",
|
||||
"# [ 1 4 9 16 25 36 49 64]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】注意 numpy 的广播规则。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([[11, 12, 13, 14, 15],\n",
|
||||
" [16, 17, 18, 19, 20],\n",
|
||||
" [21, 22, 23, 24, 25],\n",
|
||||
" [26, 27, 28, 29, 30],\n",
|
||||
" [31, 32, 33, 34, 35]])\n",
|
||||
"y = x + 1\n",
|
||||
"print(y)\n",
|
||||
"print(np.add(x, 1))\n",
|
||||
"# [[12 13 14 15 16]\n",
|
||||
"# [17 18 19 20 21]\n",
|
||||
"# [22 23 24 25 26]\n",
|
||||
"# [27 28 29 30 31]\n",
|
||||
"# [32 33 34 35 36]]\n",
|
||||
"\n",
|
||||
"y = x - 1\n",
|
||||
"print(y)\n",
|
||||
"print(np.subtract(x, 1))\n",
|
||||
"# [[10 11 12 13 14]\n",
|
||||
"# [15 16 17 18 19]\n",
|
||||
"# [20 21 22 23 24]\n",
|
||||
"# [25 26 27 28 29]\n",
|
||||
"# [30 31 32 33 34]]\n",
|
||||
"\n",
|
||||
"y = x * 2\n",
|
||||
"print(y)\n",
|
||||
"print(np.multiply(x, 2))\n",
|
||||
"# [[22 24 26 28 30]\n",
|
||||
"# [32 34 36 38 40]\n",
|
||||
"# [42 44 46 48 50]\n",
|
||||
"# [52 54 56 58 60]\n",
|
||||
"# [62 64 66 68 70]]\n",
|
||||
"\n",
|
||||
"y = x / 2\n",
|
||||
"print(y)\n",
|
||||
"print(np.divide(x, 2))\n",
|
||||
"# [[ 5.5 6. 6.5 7. 7.5]\n",
|
||||
"# [ 8. 8.5 9. 9.5 10. ]\n",
|
||||
"# [10.5 11. 11.5 12. 12.5]\n",
|
||||
"# [13. 13.5 14. 14.5 15. ]\n",
|
||||
"# [15.5 16. 16.5 17. 17.5]]\n",
|
||||
"\n",
|
||||
"y = x // 2\n",
|
||||
"print(y)\n",
|
||||
"print(np.floor_divide(x, 2))\n",
|
||||
"# [[ 5 6 6 7 7]\n",
|
||||
"# [ 8 8 9 9 10]\n",
|
||||
"# [10 11 11 12 12]\n",
|
||||
"# [13 13 14 14 15]\n",
|
||||
"# [15 16 16 17 17]]\n",
|
||||
"\n",
|
||||
"y = x ** 2\n",
|
||||
"print(y)\n",
|
||||
"print(np.power(x, 2))\n",
|
||||
"# [[ 121 144 169 196 225]\n",
|
||||
"# [ 256 289 324 361 400]\n",
|
||||
"# [ 441 484 529 576 625]\n",
|
||||
"# [ 676 729 784 841 900]\n",
|
||||
"# [ 961 1024 1089 1156 1225]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"【例】注意 numpy 的广播规则。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([[11, 12, 13, 14, 15],\n",
|
||||
" [16, 17, 18, 19, 20],\n",
|
||||
" [21, 22, 23, 24, 25],\n",
|
||||
" [26, 27, 28, 29, 30],\n",
|
||||
" [31, 32, 33, 34, 35]])\n",
|
||||
"\n",
|
||||
"y = np.arange(1, 6)\n",
|
||||
"print(y)\n",
|
||||
"# [1 2 3 4 5]\n",
|
||||
"\n",
|
||||
"z = x + y\n",
|
||||
"print(z)\n",
|
||||
"print(np.add(x, y))\n",
|
||||
"# [[12 14 16 18 20]\n",
|
||||
"# [17 19 21 23 25]\n",
|
||||
"# [22 24 26 28 30]\n",
|
||||
"# [27 29 31 33 35]\n",
|
||||
"# [32 34 36 38 40]]\n",
|
||||
"\n",
|
||||
"z = x - y\n",
|
||||
"print(z)\n",
|
||||
"print(np.subtract(x, y))\n",
|
||||
"# [[10 10 10 10 10]\n",
|
||||
"# [15 15 15 15 15]\n",
|
||||
"# [20 20 20 20 20]\n",
|
||||
"# [25 25 25 25 25]\n",
|
||||
"# [30 30 30 30 30]]\n",
|
||||
"\n",
|
||||
"z = x * y\n",
|
||||
"print(z)\n",
|
||||
"print(np.multiply(x, y))\n",
|
||||
"# [[ 11 24 39 56 75]\n",
|
||||
"# [ 16 34 54 76 100]\n",
|
||||
"# [ 21 44 69 96 125]\n",
|
||||
"# [ 26 54 84 116 150]\n",
|
||||
"# [ 31 64 99 136 175]]\n",
|
||||
"\n",
|
||||
"z = x / y\n",
|
||||
"print(z)\n",
|
||||
"print(np.divide(x, y))\n",
|
||||
"# [[11. 6. 4.33333333 3.5 3. ]\n",
|
||||
"# [16. 8.5 6. 4.75 4. ]\n",
|
||||
"# [21. 11. 7.66666667 6. 5. ]\n",
|
||||
"# [26. 13.5 9.33333333 7.25 6. ]\n",
|
||||
"# [31. 16. 11. 8.5 7. ]]\n",
|
||||
"\n",
|
||||
"z = x // y\n",
|
||||
"print(z)\n",
|
||||
"print(np.floor_divide(x, y))\n",
|
||||
"# [[11 6 4 3 3]\n",
|
||||
"# [16 8 6 4 4]\n",
|
||||
"# [21 11 7 6 5]\n",
|
||||
"# [26 13 9 7 6]\n",
|
||||
"# [31 16 11 8 7]]\n",
|
||||
"\n",
|
||||
"z = x ** np.full([1, 5], 2)\n",
|
||||
"print(z)\n",
|
||||
"print(np.power(x, np.full([5, 5], 2)))\n",
|
||||
"# [[ 121 144 169 196 225]\n",
|
||||
"# [ 256 289 324 361 400]\n",
|
||||
"# [ 441 484 529 576 625]\n",
|
||||
"# [ 676 729 784 841 900]\n",
|
||||
"# [ 961 1024 1089 1156 1225]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([[11, 12, 13, 14, 15],\n",
|
||||
" [16, 17, 18, 19, 20],\n",
|
||||
" [21, 22, 23, 24, 25],\n",
|
||||
" [26, 27, 28, 29, 30],\n",
|
||||
" [31, 32, 33, 34, 35]])\n",
|
||||
"\n",
|
||||
"y = np.arange(1, 26).reshape([5, 5])\n",
|
||||
"print(y)\n",
|
||||
"# [[ 1 2 3 4 5]\n",
|
||||
"# [ 6 7 8 9 10]\n",
|
||||
"# [11 12 13 14 15]\n",
|
||||
"# [16 17 18 19 20]\n",
|
||||
"# [21 22 23 24 25]]\n",
|
||||
"\n",
|
||||
"z = x + y\n",
|
||||
"print(z)\n",
|
||||
"print(np.add(x, y))\n",
|
||||
"# [[12 14 16 18 20]\n",
|
||||
"# [22 24 26 28 30]\n",
|
||||
"# [32 34 36 38 40]\n",
|
||||
"# [42 44 46 48 50]\n",
|
||||
"# [52 54 56 58 60]]\n",
|
||||
"\n",
|
||||
"z = x - y\n",
|
||||
"print(z)\n",
|
||||
"print(np.subtract(x, y))\n",
|
||||
"# [[10 10 10 10 10]\n",
|
||||
"# [10 10 10 10 10]\n",
|
||||
"# [10 10 10 10 10]\n",
|
||||
"# [10 10 10 10 10]\n",
|
||||
"# [10 10 10 10 10]]\n",
|
||||
"\n",
|
||||
"z = x * y\n",
|
||||
"print(z)\n",
|
||||
"print(np.multiply(x, y))\n",
|
||||
"# [[ 11 24 39 56 75]\n",
|
||||
"# [ 96 119 144 171 200]\n",
|
||||
"# [231 264 299 336 375]\n",
|
||||
"# [416 459 504 551 600]\n",
|
||||
"# [651 704 759 816 875]]\n",
|
||||
"\n",
|
||||
"z = x / y\n",
|
||||
"print(z)\n",
|
||||
"print(np.divide(x, y))\n",
|
||||
"# [[11. 6. 4.33333333 3.5 3. ]\n",
|
||||
"# [ 2.66666667 2.42857143 2.25 2.11111111 2. ]\n",
|
||||
"# [ 1.90909091 1.83333333 1.76923077 1.71428571 1.66666667]\n",
|
||||
"# [ 1.625 1.58823529 1.55555556 1.52631579 1.5 ]\n",
|
||||
"# [ 1.47619048 1.45454545 1.43478261 1.41666667 1.4 ]]\n",
|
||||
"\n",
|
||||
"z = x // y\n",
|
||||
"print(z)\n",
|
||||
"print(np.floor_divide(x, y))\n",
|
||||
"# [[11 6 4 3 3]\n",
|
||||
"# [ 2 2 2 2 2]\n",
|
||||
"# [ 1 1 1 1 1]\n",
|
||||
"# [ 1 1 1 1 1]\n",
|
||||
"# [ 1 1 1 1 1]]\n",
|
||||
"\n",
|
||||
"z = x ** np.full([5, 5], 2)\n",
|
||||
"print(z)\n",
|
||||
"print(np.power(x, np.full([5, 5], 2)))\n",
|
||||
"# [[ 121 144 169 196 225]\n",
|
||||
"# [ 256 289 324 361 400]\n",
|
||||
"# [ 441 484 529 576 625]\n",
|
||||
"# [ 676 729 784 841 900]\n",
|
||||
"# [ 961 1024 1089 1156 1225]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"- `numpy.sqrt(x, *args, **kwargs)` Return the non-negative square-root of an array, element-wise.\n",
|
||||
"- `numpy.square(x, *args, **kwargs)` Return the element-wise square of the input.\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.arange(1, 5)\n",
|
||||
"print(x) # [1 2 3 4]\n",
|
||||
"\n",
|
||||
"y = np.sqrt(x)\n",
|
||||
"print(y)\n",
|
||||
"# [1. 1.41421356 1.73205081 2. ]\n",
|
||||
"print(np.power(x, 0.5))\n",
|
||||
"# [1. 1.41421356 1.73205081 2. ]\n",
|
||||
"\n",
|
||||
"y = np.square(x)\n",
|
||||
"print(y)\n",
|
||||
"# [ 1 4 9 16]\n",
|
||||
"print(np.power(x, 2))\n",
|
||||
"# [ 1 4 9 16]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"---\n",
|
||||
"## 三角函数\n",
|
||||
"\n",
|
||||
"- `numpy.sin(x, *args, **kwargs)` Trigonometric sine, element-wise.\n",
|
||||
"- `numpy.cos(x, *args, **kwargs)` Cosine element-wise.\n",
|
||||
"- `numpy.tan(x, *args, **kwargs)` Compute tangent element-wise.\n",
|
||||
"- `numpy.arcsin(x, *args, **kwargs)` Inverse sine, element-wise.\n",
|
||||
"- `numpy.arccos(x, *args, **kwargs)` Trigonometric inverse cosine, element-wise.\n",
|
||||
"- `numpy.arctan(x, *args, **kwargs)` Trigonometric inverse tangent, element-wise.\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"**通用函数**（universal function）通常叫作ufunc，它对数组中的各个元素逐一进行操作。这表明，通用函数分别处理输入数组的每个元素，生成的结果组成一个新的输出数组。输出数组的大小跟输入数组相同。\n",
|
||||
"\n",
|
||||
"三角函数等很多数学运算符合通用函数的定义，例如，计算平方根的`sqrt()`函数、用来取对数的`log()`函数和求正弦值的`sin()`函数。\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.linspace(start=0, stop=np.pi / 2, num=10)\n",
|
||||
"print(x)\n",
|
||||
"# [0. 0.17453293 0.34906585 0.52359878 0.6981317 0.87266463\n",
|
||||
"# 1.04719755 1.22173048 1.3962634 1.57079633]\n",
|
||||
"\n",
|
||||
"y = np.sin(x)\n",
|
||||
"print(y)\n",
|
||||
"# [0. 0.17364818 0.34202014 0.5 0.64278761 0.76604444\n",
|
||||
"# 0.8660254 0.93969262 0.98480775 1. ]\n",
|
||||
"\n",
|
||||
"z = np.arcsin(y)\n",
|
||||
"print(z)\n",
|
||||
"# [0. 0.17453293 0.34906585 0.52359878 0.6981317 0.87266463\n",
|
||||
"# 1.04719755 1.22173048 1.3962634 1.57079633]\n",
|
||||
"\n",
|
||||
"y = np.cos(x)\n",
|
||||
"print(y)\n",
|
||||
"# [1.00000000e+00 9.84807753e-01 9.39692621e-01 8.66025404e-01\n",
|
||||
"# 7.66044443e-01 6.42787610e-01 5.00000000e-01 3.42020143e-01\n",
|
||||
"# 1.73648178e-01 6.12323400e-17]\n",
|
||||
"\n",
|
||||
"z = np.arccos(y)\n",
|
||||
"print(z)\n",
|
||||
"# [0. 0.17453293 0.34906585 0.52359878 0.6981317 0.87266463\n",
|
||||
"# 1.04719755 1.22173048 1.3962634 1.57079633]\n",
|
||||
"\n",
|
||||
"y = np.tan(x)\n",
|
||||
"print(y)\n",
|
||||
"# [0.00000000e+00 1.76326981e-01 3.63970234e-01 5.77350269e-01\n",
|
||||
"# 8.39099631e-01 1.19175359e+00 1.73205081e+00 2.74747742e+00\n",
|
||||
"# 5.67128182e+00 1.63312394e+16]\n",
|
||||
"\n",
|
||||
"z = np.arctan(y)\n",
|
||||
"print(z)\n",
|
||||
"# [0. 0.17453293 0.34906585 0.52359878 0.6981317 0.87266463\n",
|
||||
"# 1.04719755 1.22173048 1.3962634 1.57079633]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"---\n",
|
||||
"## 指数和对数\n",
|
||||
"\n",
|
||||
"- `numpy.exp(x, *args, **kwargs)` Calculate the exponential of all elements in the input array.\n",
|
||||
"- `numpy.log(x, *args, **kwargs)` Natural logarithm, element-wise.\n",
|
||||
"- `numpy.exp2(x, *args, **kwargs)` Calculate `2**p` for all `p` in the input array.\n",
|
||||
"- `numpy.log2(x, *args, **kwargs)` Base-2 logarithm of `x`.\n",
|
||||
"- `numpy.log10(x, *args, **kwargs)` Return the base 10 logarithm of the input array, element-wise.\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】The natural logarithm `log` is the inverse of the exponential function, so that `log(exp(x)) = x`. The natural logarithm is logarithm in base `e`.\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.arange(1, 5)\n",
|
||||
"print(x)\n",
|
||||
"# [1 2 3 4]\n",
|
||||
"y = np.exp(x)\n",
|
||||
"print(y)\n",
|
||||
"# [ 2.71828183 7.3890561 20.08553692 54.59815003]\n",
|
||||
"z = np.log(y)\n",
|
||||
"print(z)\n",
|
||||
"# [1. 2. 3. 4.]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"---\n",
|
||||
"## 加法函数、乘法函数\n",
|
||||
"\n",
|
||||
"- `numpy.sum(a[, axis=None, dtype=None, out=None, …])` Sum of array elements over a given axis.\n",
|
||||
"\n",
|
||||
"通过不同的 `axis`，numpy 会沿着不同的方向进行操作：如果不设置，那么对所有的元素操作；如果`axis=0`，则沿着纵轴进行操作；`axis=1`，则沿着横轴进行操作。但这只是简单的二位数组，如果是多维的呢？可以总结为一句话：设`axis=i`，则 numpy 沿着第`i`个下标变化的方向进行操作。\n",
|
||||
"\n",
|
||||
"- `numpy.cumsum(a, axis=None, dtype=None, out=None)` Return the cumulative sum of the elements along a given axis.\n",
|
||||
"\n",
|
||||
"**聚合函数** 是指对一组值（比如一个数组）进行操作，返回一个单一值作为结果的函数。因而，求数组所有元素之和的函数就是聚合函数。`ndarray`类实现了多个这样的函数。\n",
|
||||
"\n",
|
||||
"【例】返回给定轴上的数组元素的总和。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([[11, 12, 13, 14, 15],\n",
|
||||
" [16, 17, 18, 19, 20],\n",
|
||||
" [21, 22, 23, 24, 25],\n",
|
||||
" [26, 27, 28, 29, 30],\n",
|
||||
" [31, 32, 33, 34, 35]])\n",
|
||||
"y = np.sum(x)\n",
|
||||
"print(y) # 575\n",
|
||||
"\n",
|
||||
"y = np.sum(x, axis=0)\n",
|
||||
"print(y) # [105 110 115 120 125]\n",
|
||||
"\n",
|
||||
"y = np.sum(x, axis=1)\n",
|
||||
"print(y) # [ 65 90 115 140 165]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】返回给定轴上的数组元素的累加和。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([[11, 12, 13, 14, 15],\n",
|
||||
" [16, 17, 18, 19, 20],\n",
|
||||
" [21, 22, 23, 24, 25],\n",
|
||||
" [26, 27, 28, 29, 30],\n",
|
||||
" [31, 32, 33, 34, 35]])\n",
|
||||
"y = np.cumsum(x)\n",
|
||||
"print(y)\n",
|
||||
"# [ 11 23 36 50 65 81 98 116 135 155 176 198 221 245 270 296 323 351\n",
|
||||
"# 380 410 441 473 506 540 575]\n",
|
||||
"\n",
|
||||
"y = np.cumsum(x, axis=0)\n",
|
||||
"print(y)\n",
|
||||
"# [[ 11 12 13 14 15]\n",
|
||||
"# [ 27 29 31 33 35]\n",
|
||||
"# [ 48 51 54 57 60]\n",
|
||||
"# [ 74 78 82 86 90]\n",
|
||||
"# [105 110 115 120 125]]\n",
|
||||
"\n",
|
||||
"y = np.cumsum(x, axis=1)\n",
|
||||
"print(y)\n",
|
||||
"# [[ 11 23 36 50 65]\n",
|
||||
"# [ 16 33 51 70 90]\n",
|
||||
"# [ 21 43 66 90 115]\n",
|
||||
"# [ 26 53 81 110 140]\n",
|
||||
"# [ 31 63 96 130 165]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"- `numpy.prod(a[, axis=None, dtype=None, out=None, …])` Return the product of array elements over a given axis.\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"- `numpy.cumprod(a, axis=None, dtype=None, out=None)` Return the cumulative product of elements along a given axis.\n",
|
||||
"\n",
|
||||
"【例】返回给定轴上数组元素的乘积。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([[11, 12, 13, 14, 15],\n",
|
||||
" [16, 17, 18, 19, 20],\n",
|
||||
" [21, 22, 23, 24, 25],\n",
|
||||
" [26, 27, 28, 29, 30],\n",
|
||||
" [31, 32, 33, 34, 35]])\n",
|
||||
"y = np.prod(x)\n",
|
||||
"print(y) # 788529152\n",
|
||||
"\n",
|
||||
"y = np.prod(x, axis=0)\n",
|
||||
"print(y)\n",
|
||||
"# [2978976 3877632 4972968 6294624 7875000]\n",
|
||||
"\n",
|
||||
"y = np.prod(x, axis=1)\n",
|
||||
"print(y)\n",
|
||||
"# [ 360360 1860480 6375600 17100720 38955840]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】返回给定轴上数组元素的累乘。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([[11, 12, 13, 14, 15],\n",
|
||||
" [16, 17, 18, 19, 20],\n",
|
||||
" [21, 22, 23, 24, 25],\n",
|
||||
" [26, 27, 28, 29, 30],\n",
|
||||
" [31, 32, 33, 34, 35]])\n",
|
||||
"y = np.cumprod(x)\n",
|
||||
"print(y)\n",
|
||||
"# [ 11 132 1716 24024 360360 5765760\n",
|
||||
"# 98017920 1764322560 -837609728 427674624 391232512 17180672\n",
|
||||
"# 395155456 893796352 870072320 1147043840 905412608 -418250752\n",
|
||||
"# 755630080 1194065920 -1638662144 -897581056 444596224 -2063597568\n",
|
||||
"# 788529152]\n",
|
||||
"\n",
|
||||
"y = np.cumprod(x, axis=0)\n",
|
||||
"print(y)\n",
|
||||
"# [[ 11 12 13 14 15]\n",
|
||||
"# [ 176 204 234 266 300]\n",
|
||||
"# [ 3696 4488 5382 6384 7500]\n",
|
||||
"# [ 96096 121176 150696 185136 225000]\n",
|
||||
"# [2978976 3877632 4972968 6294624 7875000]]\n",
|
||||
"\n",
|
||||
"y = np.cumprod(x, axis=1)\n",
|
||||
"print(y)\n",
|
||||
"# [[ 11 132 1716 24024 360360]\n",
|
||||
"# [ 16 272 4896 93024 1860480]\n",
|
||||
"# [ 21 462 10626 255024 6375600]\n",
|
||||
"# [ 26 702 19656 570024 17100720]\n",
|
||||
"# [ 31 992 32736 1113024 38955840]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"- `numpy.diff(a, n=1, axis=-1, prepend=np._NoValue, append=np._NoValue)` Calculate the n-th discrete difference along the given axis.\n",
|
||||
" - a：输入矩阵\n",
|
||||
" - n：可选，代表要执行几次差值\n",
|
||||
" - axis：默认是最后一个\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"The first difference is given by `out[i] = a[i+1] - a[i]` along the given axis, higher differences are calculated by using `diff` recursively.\n",
|
||||
"\n",
|
||||
"【例】沿着指定轴计算第N维的离散差值。\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"A = np.arange(2, 14).reshape((3, 4))\n",
|
||||
"A[1, 1] = 8\n",
|
||||
"print(A)\n",
|
||||
"# [[ 2 3 4 5]\n",
|
||||
"# [ 6 8 8 9]\n",
|
||||
"# [10 11 12 13]]\n",
|
||||
"print(np.diff(A))\n",
|
||||
"# [[1 1 1]\n",
|
||||
"# [2 0 1]\n",
|
||||
"# [1 1 1]]\n",
|
||||
"print(np.diff(A, axis=0))\n",
|
||||
"# [[4 5 4 4]\n",
|
||||
"# [4 3 4 4]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"---\n",
|
||||
"## 四舍五入\n",
|
||||
"\n",
|
||||
"- `numpy.around(a, decimals=0, out=None)` Evenly round to the given number of decimals.\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】将数组舍入到给定的小数位数。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.random.rand(3, 3) * 10\n",
|
||||
"print(x)\n",
|
||||
"# [[6.59144457 3.78566113 8.15321227]\n",
|
||||
"# [1.68241475 3.78753332 7.68886328]\n",
|
||||
"# [2.84255822 9.58106727 7.86678037]]\n",
|
||||
"\n",
|
||||
"y = np.around(x)\n",
|
||||
"print(y)\n",
|
||||
"# [[ 7. 4. 8.]\n",
|
||||
"# [ 2. 4. 8.]\n",
|
||||
"# [ 3. 10. 8.]]\n",
|
||||
"\n",
|
||||
"y = np.around(x, decimals=2)\n",
|
||||
"print(y)\n",
|
||||
"# [[6.59 3.79 8.15]\n",
|
||||
"# [1.68 3.79 7.69]\n",
|
||||
"# [2.84 9.58 7.87]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"- `numpy.ceil(x, *args, **kwargs)` Return the ceiling of the input, element-wise.\n",
|
||||
"- `numpy.floor(x, *args, **kwargs)` Return the floor of the input, element-wise.\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.random.rand(3, 3) * 10\n",
|
||||
"print(x)\n",
|
||||
"# [[0.67847795 1.33073923 4.53920122]\n",
|
||||
"# [7.55724676 5.88854047 2.65502046]\n",
|
||||
"# [8.67640444 8.80110812 5.97528726]]\n",
|
||||
"\n",
|
||||
"y = np.ceil(x)\n",
|
||||
"print(y)\n",
|
||||
"# [[1. 2. 5.]\n",
|
||||
"# [8. 6. 3.]\n",
|
||||
"# [9. 9. 6.]]\n",
|
||||
"\n",
|
||||
"y = np.floor(x)\n",
|
||||
"print(y)\n",
|
||||
"# [[0. 1. 4.]\n",
|
||||
"# [7. 5. 2.]\n",
|
||||
"# [8. 8. 5.]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"---\n",
|
||||
"## 杂项\n",
|
||||
"\n",
|
||||
"- `numpy.clip(a, a_min, a_max, out=None, **kwargs):` Clip (limit) the values in an array.\n",
|
||||
"\n",
|
||||
"Given an interval, values outside the interval are clipped to the interval edges. For example, if an interval of `[0, 1]` is specified, values smaller than 0 become 0, and values larger than 1 become 1.\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】裁剪（限制）数组中的值。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([[11, 12, 13, 14, 15],\n",
|
||||
" [16, 17, 18, 19, 20],\n",
|
||||
" [21, 22, 23, 24, 25],\n",
|
||||
" [26, 27, 28, 29, 30],\n",
|
||||
" [31, 32, 33, 34, 35]])\n",
|
||||
"y = np.clip(x, a_min=20, a_max=30)\n",
|
||||
"print(y)\n",
|
||||
"# [[20 20 20 20 20]\n",
|
||||
"# [20 20 20 20 20]\n",
|
||||
"# [21 22 23 24 25]\n",
|
||||
"# [26 27 28 29 30]\n",
|
||||
"# [30 30 30 30 30]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"- `numpy.absolute(x, *args, **kwargs)` Calculate the absolute value element-wise. \n",
|
||||
"- `numpy.abs(x, *args, **kwargs)` is a shorthand for this function.\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.arange(-5, 5)\n",
|
||||
"print(x)\n",
|
||||
"# [-5 -4 -3 -2 -1 0 1 2 3 4]\n",
|
||||
"\n",
|
||||
"y = np.abs(x)\n",
|
||||
"print(y)\n",
|
||||
"# [5 4 3 2 1 0 1 2 3 4]\n",
|
||||
"\n",
|
||||
"y = np.absolute(x)\n",
|
||||
"print(y)\n",
|
||||
"# [5 4 3 2 1 0 1 2 3 4]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"- `numpy.sign(x, *args, **kwargs)` Returns an element-wise indication of the sign of a number.\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"x = np.arange(-5, 5)\n",
|
||||
"print(x)\n",
|
||||
"#[-5 -4 -3 -2 -1 0 1 2 3 4]\n",
|
||||
"print(np.sign(x))\n",
|
||||
"#[-1 -1 -1 -1 -1 0 1 1 1 1]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"---\n",
|
||||
"**参考文献**\n",
|
||||
"- https://mp.weixin.qq.com/s/RWsGvvmw4ptf7d8zPIDEJw\n",
|
||||
"- https://blog.csdn.net/hanshuobest/article/details/78558826?utm_medium=distribute.pc_relevant.none-task-blog-baidujs-1\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": 7,
|
||||
"metadata": {
|
||||
"ExecuteTime": {
|
||||
"end_time": "2020-08-30T17:00:33.199734Z",
|
||||
"start_time": "2020-08-30T17:00:33.194782Z"
|
||||
}
|
||||
},
|
||||
"outputs": [
|
||||
{
|
||||
"name": "stdout",
|
||||
"output_type": "stream",
|
||||
"text": [
|
||||
"[-5 -4 -3 -2 -1 0 1 2 3 4]\n",
|
||||
"[-1 -1 -1 -1 -1 0 1 1 1 1]\n"
|
||||
]
|
||||
}
|
||||
],
|
||||
"source": [
|
||||
"x = np.arange(-5, 5)\n",
|
||||
"print(x)\n",
|
||||
"print(np.sign(x))"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"kernelspec": {
|
||||
"display_name": "Python35",
|
||||
"language": "python",
|
||||
"name": "python35"
|
||||
},
|
||||
"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.10"
|
||||
},
|
||||
"toc": {
|
||||
"base_numbering": 1,
|
||||
"nav_menu": {},
|
||||
"number_sections": true,
|
||||
"sideBar": true,
|
||||
"skip_h1_title": false,
|
||||
"title_cell": "Table of Contents",
|
||||
"title_sidebar": "Contents",
|
||||
"toc_cell": false,
|
||||
"toc_position": {
|
||||
"height": "calc(100% - 180px)",
|
||||
"left": "10px",
|
||||
"top": "150px",
|
||||
"width": "307.2px"
|
||||
},
|
||||
"toc_section_display": true,
|
||||
"toc_window_display": true
|
||||
},
|
||||
"varInspector": {
|
||||
"cols": {
|
||||
"lenName": 16,
|
||||
"lenType": 16,
|
||||
"lenVar": 40
|
||||
},
|
||||
"kernels_config": {
|
||||
"python": {
|
||||
"delete_cmd_postfix": "",
|
||||
"delete_cmd_prefix": "del ",
|
||||
"library": "var_list.py",
|
||||
"varRefreshCmd": "print(var_dic_list())"
|
||||
},
|
||||
"r": {
|
||||
"delete_cmd_postfix": ") ",
|
||||
"delete_cmd_prefix": "rm(",
|
||||
"library": "var_list.r",
|
||||
"varRefreshCmd": "cat(var_dic_list()) "
|
||||
}
|
||||
},
|
||||
"types_to_exclude": [
|
||||
"module",
|
||||
"function",
|
||||
"builtin_function_or_method",
|
||||
"instance",
|
||||
"_Feature"
|
||||
],
|
||||
"window_display": false
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -1,502 +0,0 @@
|
||||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"# 逻辑函数\n",
|
||||
"\n",
|
||||
"## 真值测试\n",
|
||||
"### numpy.all\n",
|
||||
"### numpy.any\n",
|
||||
"\n",
|
||||
"- `numpy.all(a, axis=None, out=None, keepdims=np._NoValue)` Test whether all array elements along a given axis evaluate to True.\n",
|
||||
"- `numpy.any(a, axis=None, out=None, keepdims=np._NoValue)` Test whether any array element along a given axis evaluates to True.\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"a = np.array([0, 4, 5])\n",
|
||||
"b = np.copy(a)\n",
|
||||
"print(np.all(a == b)) # True\n",
|
||||
"print(np.any(a == b)) # True\n",
|
||||
"\n",
|
||||
"b[0] = 1\n",
|
||||
"print(np.all(a == b)) # False\n",
|
||||
"print(np.any(a == b)) # True\n",
|
||||
"\n",
|
||||
"print(np.all([1.0, np.nan])) # True\n",
|
||||
"print(np.any([1.0, np.nan])) # True\n",
|
||||
"\n",
|
||||
"a = np.eye(3)\n",
|
||||
"print(np.all(a, axis=0)) # [False False False]\n",
|
||||
"print(np.any(a, axis=0)) # [ True True True]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"---\n",
|
||||
"## 数组内容\n",
|
||||
"\n",
|
||||
"- `numpy.isnan(x, *args, **kwargs)` Test element-wise for NaN and return result as a boolean array.\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"a=np.array([1,2,np.nan])\n",
|
||||
"print(np.isnan(a))\n",
|
||||
"#[False False True]\n",
|
||||
"\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"---\n",
|
||||
"## 逻辑运算\n",
|
||||
"\n",
|
||||
"- `numpy.logical_not(x, *args, **kwargs)`Compute the truth value of NOT x element-wise.\n",
|
||||
"- `numpy.logical_and(x1, x2, *args, **kwargs)` Compute the truth value of x1 AND x2 element-wise.\n",
|
||||
"- `numpy.logical_or(x1, x2, *args, **kwargs)`Compute the truth value of x1 OR x2 element-wise.\n",
|
||||
"- `numpy.logical_xor(x1, x2, *args, **kwargs)`Compute the truth value of x1 XOR x2, element-wise.\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"【例】计算非x元素的真值。\n",
|
||||
"\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"print(np.logical_not(3)) \n",
|
||||
"# False\n",
|
||||
"print(np.logical_not([True, False, 0, 1]))\n",
|
||||
"# [False True True False]\n",
|
||||
"\n",
|
||||
"x = np.arange(5)\n",
|
||||
"print(np.logical_not(x < 3))\n",
|
||||
"# [False False False True True]\n",
|
||||
"\n",
|
||||
"【例】计算x1 AND x2元素的真值。\n",
|
||||
"\n",
|
||||
"print(np.logical_and(True, False)) \n",
|
||||
"# False\n",
|
||||
"print(np.logical_and([True, False], [True, False]))\n",
|
||||
"# [ True False]\n",
|
||||
"print(np.logical_and(x > 1, x < 4))\n",
|
||||
"# [False False True True False]\n",
|
||||
"\n",
|
||||
"【例】逐元素计算x1 OR x2的真值。\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"print(np.logical_or(True, False))\n",
|
||||
"# True\n",
|
||||
"print(np.logical_or([True, False], [False, False]))\n",
|
||||
"# [ True False]\n",
|
||||
"print(np.logical_or(x < 1, x > 3))\n",
|
||||
"# [ True False False False True]\n",
|
||||
"\n",
|
||||
"【例】计算x1 XOR x2的真值，按元素计算。\n",
|
||||
"\n",
|
||||
"print(np.logical_xor(True, False))\n",
|
||||
"# True\n",
|
||||
"print(np.logical_xor([True, True, False, False], [True, False, True, False]))\n",
|
||||
"# [False True True False]\n",
|
||||
"print(np.logical_xor(x < 1, x > 3))\n",
|
||||
"# [ True False False False True]\n",
|
||||
"print(np.logical_xor(0, np.eye(2)))\n",
|
||||
"# [[ True False]\n",
|
||||
"# [False True]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"## 对照\n",
|
||||
"\n",
|
||||
"- `numpy.greater(x1, x2, *args, **kwargs)` Return the truth value of (x1 > x2) element-wise.\n",
|
||||
"- `numpy.greater_equal(x1, x2, *args, **kwargs)` Return the truth value of (x1 >= x2) element-wise.\n",
|
||||
"- `numpy.equal(x1, x2, *args, **kwargs)` Return (x1 == x2) element-wise.\n",
|
||||
"- `numpy.not_equal(x1, x2, *args, **kwargs)` Return (x1 != x2) element-wise.\n",
|
||||
"- `numpy.less(x1, x2, *args, **kwargs)` Return the truth value of (x1 < x2) element-wise.\n",
|
||||
"- `numpy.less_equal(x1, x2, *args, **kwargs)` Return the truth value of (x1 =< x2) element-wise.\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"【例】numpy对以上对照函数进行了运算符的重载。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([1, 2, 3, 4, 5, 6, 7, 8])\n",
|
||||
"\n",
|
||||
"y = x > 2\n",
|
||||
"print(y)\n",
|
||||
"print(np.greater(x, 2))\n",
|
||||
"# [False False True True True True True True]\n",
|
||||
"\n",
|
||||
"y = x >= 2\n",
|
||||
"print(y)\n",
|
||||
"print(np.greater_equal(x, 2))\n",
|
||||
"# [False True True True True True True True]\n",
|
||||
"\n",
|
||||
"y = x == 2\n",
|
||||
"print(y)\n",
|
||||
"print(np.equal(x, 2))\n",
|
||||
"# [False True False False False False False False]\n",
|
||||
"\n",
|
||||
"y = x != 2\n",
|
||||
"print(y)\n",
|
||||
"print(np.not_equal(x, 2))\n",
|
||||
"# [ True False True True True True True True]\n",
|
||||
"\n",
|
||||
"y = x < 2\n",
|
||||
"print(y)\n",
|
||||
"print(np.less(x, 2))\n",
|
||||
"# [ True False False False False False False False]\n",
|
||||
"\n",
|
||||
"y = x <= 2\n",
|
||||
"print(y)\n",
|
||||
"print(np.less_equal(x, 2))\n",
|
||||
"# [ True True False False False False False False]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([[11, 12, 13, 14, 15],\n",
|
||||
" [16, 17, 18, 19, 20],\n",
|
||||
" [21, 22, 23, 24, 25],\n",
|
||||
" [26, 27, 28, 29, 30],\n",
|
||||
" [31, 32, 33, 34, 35]])\n",
|
||||
"y = x > 20\n",
|
||||
"print(y)\n",
|
||||
"print(np.greater(x, 20))\n",
|
||||
"# [[False False False False False]\n",
|
||||
"# [False False False False False]\n",
|
||||
"# [ True True True True True]\n",
|
||||
"# [ True True True True True]\n",
|
||||
"# [ True True True True True]]\n",
|
||||
"\n",
|
||||
"y = x >= 20\n",
|
||||
"print(y)\n",
|
||||
"print(np.greater_equal(x, 20))\n",
|
||||
"# [[False False False False False]\n",
|
||||
"# [False False False False True]\n",
|
||||
"# [ True True True True True]\n",
|
||||
"# [ True True True True True]\n",
|
||||
"# [ True True True True True]]\n",
|
||||
"\n",
|
||||
"y = x == 20\n",
|
||||
"print(y)\n",
|
||||
"print(np.equal(x, 20))\n",
|
||||
"# [[False False False False False]\n",
|
||||
"# [False False False False True]\n",
|
||||
"# [False False False False False]\n",
|
||||
"# [False False False False False]\n",
|
||||
"# [False False False False False]]\n",
|
||||
"\n",
|
||||
"y = x != 20\n",
|
||||
"print(y)\n",
|
||||
"print(np.not_equal(x, 20))\n",
|
||||
"# [[ True True True True True]\n",
|
||||
"# [ True True True True False]\n",
|
||||
"# [ True True True True True]\n",
|
||||
"# [ True True True True True]\n",
|
||||
"# [ True True True True True]]\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"y = x < 20\n",
|
||||
"print(y)\n",
|
||||
"print(np.less(x, 20))\n",
|
||||
"# [[ True True True True True]\n",
|
||||
"# [ True True True True False]\n",
|
||||
"# [False False False False False]\n",
|
||||
"# [False False False False False]\n",
|
||||
"# [False False False False False]]\n",
|
||||
"\n",
|
||||
"y = x <= 20\n",
|
||||
"print(y)\n",
|
||||
"print(np.less_equal(x, 20))\n",
|
||||
"# [[ True True True True True]\n",
|
||||
"# [ True True True True True]\n",
|
||||
"# [False False False False False]\n",
|
||||
"# [False False False False False]\n",
|
||||
"# [False False False False False]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"【例】\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"np.random.seed(20200611)\n",
|
||||
"x = np.array([[11, 12, 13, 14, 15],\n",
|
||||
" [16, 17, 18, 19, 20],\n",
|
||||
" [21, 22, 23, 24, 25],\n",
|
||||
" [26, 27, 28, 29, 30],\n",
|
||||
" [31, 32, 33, 34, 35]])\n",
|
||||
"\n",
|
||||
"y = np.random.randint(10, 40, [5, 5])\n",
|
||||
"print(y)\n",
|
||||
"# [[32 28 31 33 37]\n",
|
||||
"# [23 37 37 30 29]\n",
|
||||
"# [32 24 10 33 15]\n",
|
||||
"# [27 17 10 36 16]\n",
|
||||
"# [25 32 23 39 34]]\n",
|
||||
"\n",
|
||||
"z = x > y\n",
|
||||
"print(z)\n",
|
||||
"print(np.greater(x, y))\n",
|
||||
"# [[False False False False False]\n",
|
||||
"# [False False False False False]\n",
|
||||
"# [False False True False True]\n",
|
||||
"# [False True True False True]\n",
|
||||
"# [ True False True False True]]\n",
|
||||
"\n",
|
||||
"z = x >= y\n",
|
||||
"print(z)\n",
|
||||
"print(np.greater_equal(x, y))\n",
|
||||
"# [[False False False False False]\n",
|
||||
"# [False False False False False]\n",
|
||||
"# [False False True False True]\n",
|
||||
"# [False True True False True]\n",
|
||||
"# [ True True True False True]]\n",
|
||||
"\n",
|
||||
"z = x == y\n",
|
||||
"print(z)\n",
|
||||
"print(np.equal(x, y))\n",
|
||||
"# [[False False False False False]\n",
|
||||
"# [False False False False False]\n",
|
||||
"# [False False False False False]\n",
|
||||
"# [False False False False False]\n",
|
||||
"# [False True False False False]]\n",
|
||||
"\n",
|
||||
"z = x != y\n",
|
||||
"print(z)\n",
|
||||
"print(np.not_equal(x, y))\n",
|
||||
"# [[ True True True True True]\n",
|
||||
"# [ True True True True True]\n",
|
||||
"# [ True True True True True]\n",
|
||||
"# [ True True True True True]\n",
|
||||
"# [ True False True True True]]\n",
|
||||
"\n",
|
||||
"z = x < y\n",
|
||||
"print(z)\n",
|
||||
"print(np.less(x, y))\n",
|
||||
"# [[ True True True True True]\n",
|
||||
"# [ True True True True True]\n",
|
||||
"# [ True True False True False]\n",
|
||||
"# [ True False False True False]\n",
|
||||
"# [False False False True False]]\n",
|
||||
"\n",
|
||||
"z = x <= y\n",
|
||||
"print(z)\n",
|
||||
"print(np.less_equal(x, y))\n",
|
||||
"# [[ True True True True True]\n",
|
||||
"# [ True True True True True]\n",
|
||||
"# [ True True False True False]\n",
|
||||
"# [ True False False True False]\n",
|
||||
"# [False True False True False]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"【例】注意 numpy 的广播规则。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.array([[11, 12, 13, 14, 15],\n",
|
||||
" [16, 17, 18, 19, 20],\n",
|
||||
" [21, 22, 23, 24, 25],\n",
|
||||
" [26, 27, 28, 29, 30],\n",
|
||||
" [31, 32, 33, 34, 35]])\n",
|
||||
"\n",
|
||||
"np.random.seed(20200611)\n",
|
||||
"y = np.random.randint(10, 50, 5)\n",
|
||||
"\n",
|
||||
"print(y)\n",
|
||||
"# [32 37 30 24 10]\n",
|
||||
"\n",
|
||||
"z = x > y\n",
|
||||
"print(z)\n",
|
||||
"print(np.greater(x, y))\n",
|
||||
"# [[False False False False True]\n",
|
||||
"# [False False False False True]\n",
|
||||
"# [False False False False True]\n",
|
||||
"# [False False False True True]\n",
|
||||
"# [False False True True True]]\n",
|
||||
"\n",
|
||||
"z = x >= y\n",
|
||||
"print(z)\n",
|
||||
"print(np.greater_equal(x, y))\n",
|
||||
"# [[False False False False True]\n",
|
||||
"# [False False False False True]\n",
|
||||
"# [False False False True True]\n",
|
||||
"# [False False False True True]\n",
|
||||
"# [False False True True True]]\n",
|
||||
"\n",
|
||||
"z = x == y\n",
|
||||
"print(z)\n",
|
||||
"print(np.equal(x, y))\n",
|
||||
"# [[False False False False False]\n",
|
||||
"# [False False False False False]\n",
|
||||
"# [False False False True False]\n",
|
||||
"# [False False False False False]\n",
|
||||
"# [False False False False False]]\n",
|
||||
"\n",
|
||||
"z = x != y\n",
|
||||
"print(z)\n",
|
||||
"print(np.not_equal(x, y))\n",
|
||||
"# [[ True True True True True]\n",
|
||||
"# [ True True True True True]\n",
|
||||
"# [ True True True False True]\n",
|
||||
"# [ True True True True True]\n",
|
||||
"# [ True True True True True]]\n",
|
||||
"\n",
|
||||
"z = x < y\n",
|
||||
"print(z)\n",
|
||||
"print(np.less(x, y))\n",
|
||||
"# [[ True True True True False]\n",
|
||||
"# [ True True True True False]\n",
|
||||
"# [ True True True False False]\n",
|
||||
"# [ True True True False False]\n",
|
||||
"# [ True True False False False]]\n",
|
||||
"\n",
|
||||
"z = x <= y\n",
|
||||
"print(z)\n",
|
||||
"print(np.less_equal(x, y))\n",
|
||||
"# [[ True True True True False]\n",
|
||||
"# [ True True True True False]\n",
|
||||
"# [ True True True True False]\n",
|
||||
"# [ True True True False False]\n",
|
||||
"# [ True True False False False]]\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n",
|
||||
"- `numpy.isclose(a, b, rtol=1.e-5, atol=1.e-8, equal_nan=False)` Returns a boolean array where two arrays are element-wise equal within a tolerance.\n",
|
||||
"- `numpy.allclose(a, b, rtol=1.e-5, atol=1.e-8, equal_nan=False)` Returns True if two arrays are element-wise equal within a tolerance. \n",
|
||||
"\n",
|
||||
"`numpy.allclose()` 等价于 `numpy.all(isclose(a, b, rtol=rtol, atol=atol, equal_nan=equal_nan))`。\n",
|
||||
"\n",
|
||||
"The tolerance values are positive, typically very small numbers. The relative difference (`rtol * abs(b)`) and the absolute difference `atol` are added together to compare against the absolute difference between `a` and `b`.\n",
|
||||
"\n",
|
||||
"判断是否为True的计算依据：\n",
|
||||
"\n",
|
||||
"```python\n",
|
||||
"np.absolute(a - b) <= (atol + rtol * absolute(b))\n",
|
||||
"\n",
|
||||
"- atol：float，绝对公差。\n",
|
||||
"- rtol：float，相对公差。\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"NaNs are treated as equal if they are in the same place and if `equal_nan=True`. Infs are treated as equal if they are in the same place and of the same sign in both arrays.\n",
|
||||
"\n",
|
||||
"【例】比较两个数组是否可以认为相等。\n",
|
||||
"```python\n",
|
||||
"import numpy as np\n",
|
||||
"\n",
|
||||
"x = np.isclose([1e10, 1e-7], [1.00001e10, 1e-8])\n",
|
||||
"print(x) # [ True False]\n",
|
||||
"\n",
|
||||
"x = np.allclose([1e10, 1e-7], [1.00001e10, 1e-8])\n",
|
||||
"print(x) # False\n",
|
||||
"\n",
|
||||
"x = np.isclose([1e10, 1e-8], [1.00001e10, 1e-9])\n",
|
||||
"print(x) # [ True True]\n",
|
||||
"\n",
|
||||
"x = np.allclose([1e10, 1e-8], [1.00001e10, 1e-9])\n",
|
||||
"print(x) # True\n",
|
||||
"\n",
|
||||
"x = np.isclose([1e10, 1e-8], [1.0001e10, 1e-9])\n",
|
||||
"print(x) # [False True]\n",
|
||||
"\n",
|
||||
"x = np.allclose([1e10, 1e-8], [1.0001e10, 1e-9])\n",
|
||||
"print(x) # False\n",
|
||||
"\n",
|
||||
"x = np.isclose([1.0, np.nan], [1.0, np.nan])\n",
|
||||
"print(x) # [ True False]\n",
|
||||
"\n",
|
||||
"x = np.allclose([1.0, np.nan], [1.0, np.nan])\n",
|
||||
"print(x) # False\n",
|
||||
"\n",
|
||||
"x = np.isclose([1.0, np.nan], [1.0, np.nan], equal_nan=True)\n",
|
||||
"print(x) # [ True True]\n",
|
||||
"\n",
|
||||
"x = np.allclose([1.0, np.nan], [1.0, np.nan], equal_nan=True)\n",
|
||||
"print(x) # True\n",
|
||||
"```\n",
|
||||
"\n",
|
||||
"\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "code",
|
||||
"execution_count": null,
|
||||
"metadata": {},
|
||||
"outputs": [],
|
||||
"source": []
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"kernelspec": {
|
||||
"display_name": "Python35",
|
||||
"language": "python",
|
||||
"name": "python35"
|
||||
},
|
||||
"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.10"
|
||||
},
|
||||
"toc": {
|
||||
"base_numbering": 1,
|
||||
"nav_menu": {},
|
||||
"number_sections": true,
|
||||
"sideBar": true,
|
||||
"skip_h1_title": false,
|
||||
"title_cell": "Table of Contents",
|
||||
"title_sidebar": "Contents",
|
||||
"toc_cell": false,
|
||||
"toc_position": {},
|
||||
"toc_section_display": true,
|
||||
"toc_window_display": true
|
||||
},
|
||||
"varInspector": {
|
||||
"cols": {
|
||||
"lenName": 16,
|
||||
"lenType": 16,
|
||||
"lenVar": 40
|
||||
},
|
||||
"kernels_config": {
|
||||
"python": {
|
||||
"delete_cmd_postfix": "",
|
||||
"delete_cmd_prefix": "del ",
|
||||
"library": "var_list.py",
|
||||
"varRefreshCmd": "print(var_dic_list())"
|
||||
},
|
||||
"r": {
|
||||
"delete_cmd_postfix": ") ",
|
||||
"delete_cmd_prefix": "rm(",
|
||||
"library": "var_list.r",
|
||||
"varRefreshCmd": "cat(var_dic_list()) "
|
||||
}
|
||||
},
|
||||
"types_to_exclude": [
|
||||
"module",
|
||||
"function",
|
||||
"builtin_function_or_method",
|
||||
"instance",
|
||||
"_Feature"
|
||||
],
|
||||
"window_display": false
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -1,6 +0,0 @@
|
||||
{
|
||||
"cells": [],
|
||||
"metadata": {},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -1,6 +0,0 @@
|
||||
{
|
||||
"cells": [],
|
||||
"metadata": {},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -1,152 +0,0 @@
|
||||
{
|
||||
"cells": [
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 排序搜索计数"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### **如何通过第n列对一个数组进行排序**\n",
|
||||
"- `Z = np.random.randint(0,10,(3,3))`\n",
|
||||
"\n",
|
||||
"【知识点:排序】\n",
|
||||
"\n",
|
||||
"- (提示: argsort)\n"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### **从`arr`中提取所有奇数。**\n",
|
||||
"\n",
|
||||
"- `arr = np.arange(10)`\n",
|
||||
"\n",
|
||||
"【知识点：搜索】\n",
|
||||
"- 如何从一维数组中提取满足指定条件的元素？"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### **将`arr`中的偶数元素替换为0。**\n",
|
||||
"\n",
|
||||
"- `arr = np.arange(10)`\n",
|
||||
"\n",
|
||||
"【知识点：搜索】\n",
|
||||
"- 如何用numpy数组中的另一个值替换满足条件的元素项？"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### ** 将 `arr` 中的所有偶数元素替换为0，而不改变arr。**\n",
|
||||
"- `arr = np.arange(10)`\n",
|
||||
"\n",
|
||||
"【知识点：搜索】\n",
|
||||
"- 如何在不影响原始数组的情况下替换满足条件的元素项？"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### **获取给定数组a中前5个最大值的位置。**\n",
|
||||
"\n",
|
||||
"- `a = np.random.uniform(1, 50, 20)`\n",
|
||||
"\n",
|
||||
"【知识点：搜索】\n",
|
||||
"- 如何从numpy数组中获取最大的n个值的位置？"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"### **删除一维numpy数组中所有NaN值。**\n",
|
||||
"\n",
|
||||
"- `a = np.array([1, 2, 3, np.nan, 5, 6, 7, np.nan])`\n",
|
||||
"\n",
|
||||
"【知识点：逻辑函数、搜索】\n",
|
||||
"- 如何删除numpy数组中的缺失值？"
|
||||
]
|
||||
},
|
||||
{
|
||||
"cell_type": "markdown",
|
||||
"metadata": {},
|
||||
"source": [
|
||||
"## 集合操作"
|
||||
]
|
||||
}
|
||||
],
|
||||
"metadata": {
|
||||
"kernelspec": {
|
||||
"display_name": "Python35",
|
||||
"language": "python",
|
||||
"name": "python35"
|
||||
},
|
||||
"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.10"
|
||||
},
|
||||
"toc": {
|
||||
"base_numbering": 1,
|
||||
"nav_menu": {},
|
||||
"number_sections": true,
|
||||
"sideBar": true,
|
||||
"skip_h1_title": false,
|
||||
"title_cell": "Table of Contents",
|
||||
"title_sidebar": "Contents",
|
||||
"toc_cell": false,
|
||||
"toc_position": {},
|
||||
"toc_section_display": true,
|
||||
"toc_window_display": false
|
||||
},
|
||||
"varInspector": {
|
||||
"cols": {
|
||||
"lenName": 16,
|
||||
"lenType": 16,
|
||||
"lenVar": 40
|
||||
},
|
||||
"kernels_config": {
|
||||
"python": {
|
||||
"delete_cmd_postfix": "",
|
||||
"delete_cmd_prefix": "del ",
|
||||
"library": "var_list.py",
|
||||
"varRefreshCmd": "print(var_dic_list())"
|
||||
},
|
||||
"r": {
|
||||
"delete_cmd_postfix": ") ",
|
||||
"delete_cmd_prefix": "rm(",
|
||||
"library": "var_list.r",
|
||||
"varRefreshCmd": "cat(var_dic_list()) "
|
||||
}
|
||||
},
|
||||
"types_to_exclude": [
|
||||
"module",
|
||||
"function",
|
||||
"builtin_function_or_method",
|
||||
"instance",
|
||||
"_Feature"
|
||||
],
|
||||
"window_display": false
|
||||
}
|
||||
},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -1,6 +0,0 @@
|
||||
{
|
||||
"cells": [],
|
||||
"metadata": {},
|
||||
"nbformat": 4,
|
||||
"nbformat_minor": 4
|
||||
}
|
||||
@@ -25,7 +25,7 @@
|
||||
- [team-learning-nlp](https://github.com/datawhalechina/team-learning-nlp)：主要存储Datawhale组队学习中“自然语言处理”方向的资料。
|
||||
- [team-learning-cv](https://github.com/datawhalechina/team-learning-cv)：主要存储Datawhale组队学习中“计算机视觉”方向的资料。
|
||||
- [team-learning-rs](https://github.com/datawhalechina/team-learning-rs)：主要存储Datawhale组队学习中“推荐系统”方向的资料。
|
||||
|
||||
- [team-learning-rl](https://github.com/datawhalechina/team-learning-rl)：主要存储Datawhale组队学习中“强化学习”方向的资料。
|
||||
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user