├── .gitignore ├── 0.md ├── 1.md ├── 10.md ├── 11.md ├── 12.md ├── 13.md ├── 14.md ├── 15.md ├── 16.md ├── 17.md ├── 18.md ├── 19.md ├── 2.md ├── 20.md ├── 21.md ├── 22.md ├── 23.md ├── 24.md ├── 25.md ├── 26.md ├── 3.md ├── 4.md ├── 5.md ├── 6.md ├── 7.md ├── 8.md ├── 9.md ├── README.md ├── SUMMARY.md └── styles └── ebook.css /.gitignore: -------------------------------------------------------------------------------- 1 | _book 2 | -------------------------------------------------------------------------------- /0.md: -------------------------------------------------------------------------------- 1 | # NumPy - 简介 2 | 3 | NumPy 是一个 Python 包。 它代表 “Numeric Python”。 它是一个由多维数组对象和用于处理数组的例程集合组成的库。 4 | 5 | **Numeric**，即 NumPy 的前身，是由 Jim Hugunin 开发的。 也开发了另一个包 Numarray ，它拥有一些额外的功能。 2005年，Travis Oliphant 通过将 Numarray 的功能集成到 Numeric 包中来创建 NumPy 包。 这个开源项目有很多贡献者。 6 | 7 | ## NumPy 操作 8 | 9 | 使用NumPy，开发人员可以执行以下操作： 10 | 11 | + 数组的算数和逻辑运算。 12 | 13 | + 傅立叶变换和用于图形操作的例程。 14 | 15 | + 与线性代数有关的操作。 NumPy 拥有线性代数和随机数生成的内置函数。 16 | 17 | ## NumPy – MatLab 的替代之一 18 | 19 | NumPy 通常与 **SciPy**（Scientific Python）和 **Matplotlib**（绘图库）一起使用。 这种组合广泛用于替代 MatLab，是一个流行的技术计算平台。 但是，Python 作为 MatLab 的替代方案，现在被视为一种更加现代和完整的编程语言。 20 | 21 | NumPy 是开源的，这是它的一个额外的优势。 22 | 23 | 24 | -------------------------------------------------------------------------------- /1.md: -------------------------------------------------------------------------------- 1 | 2 | 3 | # NumPy - 环境 4 | 5 | > ### 在线尝试 6 | > 7 | > 我们已经在线设置了 NumPy 编程环境，以便在线编译和执行所有可用的示例。 它向你提供了信心，并使您能够使用不同的选项验证程序， 随意修改任何示例并在线执行。 8 | > 9 | > 使用我们的在线编译器尝试一下示例，它位于 [CodingGround](https://www.tutorialspoint.com/codingground.htm) 10 | > 11 | > ``` 12 | > import numpy as np 13 | > a = 'hello world' 14 | > print a 15 | > ``` 16 | > 17 | > 对于本教程中给出的大多数示例，你会在我们的网站代码部分的右上角找到一个`Try it`选项，这会把你带到在线编译器。 所以快来使用它，享受你的学习吧。 18 | 19 | 标准的 Python 发行版不会与 NumPy 模块捆绑在一起。 一个轻量级的替代方法是使用流行的 Python 包安装程序 **pip** 来安装 NumPy。 20 | 21 | ``` 22 | pip install numpy 23 | 24 | ``` 25 | 26 | 启用 NumPy 的最佳方法是使用特定于您的操作系统的可安装的二进制包。 这些二进制包含完整的 SciPy 技术栈（包括 NumPy，SciPy，matplotlib，IPython，SymPy 以及 Python 核心自带的其它包）。 27 | 28 | ## Windows 29 | 30 | Anaconda (from [www.continuum.io](https://www.continuum.io)) 是一个带有 SciPy 技术栈的免费 Python 发行版。 它也可用于 Linux 和 Mac. 31 | 32 | Canopy ([www.enthought.com/products/canopy/](https://www.enthought.com/products/canopy/)) 是可用的免费和商业发行版，带有完整的 SciPy 技术栈，可用于 Windows, Linux and Mac。 33 | 34 | Python (x,y): 是个免费的 Python 发行版，带有 SciPy 技术栈和 Spyder IDE，可用于 Windows。 (从这里下载：[www.python-xy.github.io/](https://python-xy.github.io/)) 35 | 36 | ## Linux 37 | 38 | Linux 发行版的相应软件包管理器可用于安装一个或多个 SciPy 技术栈中的软件包。 39 | 40 | ## 对于 Ubuntu 41 | 42 | ``` 43 | sudo apt-get install python-numpy 44 | python-scipy python-matplotlibipythonipythonnotebook python-pandas 45 | python-sympy python-nose 46 | 47 | ``` 48 | 49 | ## 对于 Fedora 50 | 51 | ``` 52 | sudo yum install numpyscipy python-matplotlibipython 53 | python-pandas sympy python-nose atlas-devel 54 | 55 | ``` 56 | 57 | ## 从源码构建 58 | 59 | 核心 Python（2.6.x，2.7.x 和 3.2.x 起）必须安装`distutils`，`zlib`模块应该启用。 60 | 61 | GNU gcc（4.2及以上）C 编译器必须可用。 62 | 63 | 要安装 NumPy，请运行以下命令。 64 | 65 | ``` 66 | Python setup.py install 67 | 68 | ``` 69 | 70 | 要测试 NumPy 模块是否正确安装，请尝试从 Python 提示符导入它。 71 | 72 | 如果未安装，将显示以下错误消息。 73 | 74 | 75 | ``` 76 | Traceback (most recent call last): 77 | File "", line 1, in 78 | import numpy 79 | ImportError: No module named 'numpy' 80 | 81 | ``` 82 | 83 | 或者，使用以下语法导入NumPy包。 84 | 85 | 86 | -------------------------------------------------------------------------------- /10.md: -------------------------------------------------------------------------------- 1 | 2 | 3 | # NumPy - 广播 4 | 5 | 术语**广播**是指 NumPy 在算术运算期间处理不同形状的数组的能力。 对数组的算术运算通常在相应的元素上进行。 如果两个阵列具有完全相同的形状，则这些操作被无缝执行。 6 | 7 | ## 示例 1 8 | 9 | ``` 10 | import numpy as np 11 | 12 | a = np.array([1,2,3,4]) 13 | b = np.array([10,20,30,40]) 14 | c = a * b 15 | print c 16 | ``` 17 | 18 | 输出如下： 19 | 20 | ``` 21 | [10 40 90 160] 22 | 23 | ``` 24 | 25 | 如果两个数组的维数不相同，则元素到元素的操作是不可能的。 然而，在 NumPy 中仍然可以对形状不相似的数组进行操作，因为它拥有广播功能。 较小的数组会**广播**到较大数组的大小，以便使它们的形状可兼容。 26 | 27 | 如果满足以下规则，可以进行广播： 28 | 29 | * `ndim`较小的数组会在前面追加一个长度为 1 的维度。 30 | 31 | * 输出数组的每个维度的大小是输入数组该维度大小的最大值。 32 | 33 | * 如果输入在每个维度中的大小与输出大小匹配，或其值正好为 1，则在计算中可它。 34 | 35 | * 如果输入的某个维度大小为 1，则该维度中的第一个数据元素将用于该维度的所有计算。 36 | 37 | 如果上述规则产生有效结果，并且满足以下条件之一，那么数组被称为**可广播的**。 38 | 39 | * 数组拥有相同形状。 40 | 41 | * 数组拥有相同的维数，每个维度拥有相同长度，或者长度为 1。 42 | 43 | * 数组拥有极少的维度，可以在其前面追加长度为 1 的维度，使上述条件成立。 44 | 45 | 下面的例称展示了广播的示例。 46 | 47 | ## 示例 2 48 | 49 | ``` 50 | import numpy as np 51 | a = np.array([[0.0,0.0,0.0],[10.0,10.0,10.0],[20.0,20.0,20.0],[30.0,30.0,30.0]]) 52 | b = np.array([1.0,2.0,3.0]) 53 | print '第一个数组：' 54 | print a 55 | print '\n' 56 | print '第二个数组：' 57 | print b 58 | print '\n' 59 | print '第一个数组加第二个数组：' 60 | print a + b 61 | ``` 62 | 63 | 输出如下： 64 | 65 | ``` 66 | 第一个数组： 67 | [[ 0. 0. 0.] 68 | [ 10. 10. 10.] 69 | [ 20. 20. 20.] 70 | [ 30. 30. 30.]] 71 | 72 | 第二个数组： 73 | [ 1. 2. 3.] 74 | 75 | 第一个数组加第二个数组： 76 | [[ 1. 2. 3.] 77 | [ 11. 12. 13.] 78 | [ 21. 22. 23.] 79 | [ 31. 32. 33.]] 80 | 81 | ``` 82 | 83 | 下面的图片展示了数组`b`如何通过广播来与数组`a`兼容。 84 | 85 | ![array](https://www.tutorialspoint.com//numpy/images/array.jpg) 86 | -------------------------------------------------------------------------------- /11.md: -------------------------------------------------------------------------------- 1 | 2 | 3 | # NumPy - 数组上的迭代 4 | 5 | NumPy 包包含一个迭代器对象`numpy.nditer`。 它是一个有效的多维迭代器对象，可以用于在数组上进行迭代。 数组的每个元素可使用 Python 的标准`Iterator`接口来访问。 6 | 7 | 让我们使用`arange()`函数创建一个 3X4 数组，并使用`nditer`对它进行迭代。 8 | 9 | 10 | ### 示例 1 11 | 12 | ``` 13 | import numpy as np 14 | a = np.arange(0,60,5) 15 | a = a.reshape(3,4) 16 | print '原始数组是：' 17 | print a print '\n' 18 | print '修改后的数组是：' 19 | for x in np.nditer(a): 20 | print x, 21 | ``` 22 | 23 | 输出如下： 24 | 25 | ``` 26 | 原始数组是： 27 | [[ 0 5 10 15] 28 | [20 25 30 35] 29 | [40 45 50 55]] 30 | 31 | 修改后的数组是： 32 | 0 5 10 15 20 25 30 35 40 45 50 55 33 | 34 | ``` 35 | 36 | ### 示例 2 37 | 38 | 迭代的顺序匹配数组的内容布局，而不考虑特定的排序。 这可以通过迭代上述数组的转置来看到。 39 | 40 | ``` 41 | import numpy as np 42 | a = np.arange(0,60,5) 43 | a = a.reshape(3,4) 44 | print '原始数组是：' 45 | print a 46 | print '\n' 47 | print '原始数组的转置是：' 48 | b = a.T 49 | print b 50 | print '\n' 51 | print '修改后的数组是：' 52 | for x in np.nditer(b): 53 | print x, 54 | ``` 55 | 56 | 输出如下： 57 | 58 | ``` 59 | 原始数组是： 60 | [[ 0 5 10 15] 61 | [20 25 30 35] 62 | [40 45 50 55]] 63 | 64 | 原始数组的转置是： 65 | [[ 0 20 40] 66 | [ 5 25 45] 67 | [10 30 50] 68 | [15 35 55]] 69 | 70 | 修改后的数组是： 71 | 0 5 10 15 20 25 30 35 40 45 50 55 72 | 73 | ``` 74 | 75 | ## 迭代顺序 76 | 77 | 如果相同元素使用 F 风格顺序存储，则迭代器选择以更有效的方式对数组进行迭代。 78 | 79 | ### 示例 1 80 | 81 | ``` 82 | import numpy as np 83 | a = np.arange(0,60,5) 84 | a = a.reshape(3,4) 85 | print '原始数组是：' 86 | print a print '\n' 87 | print '原始数组的转置是：' 88 | b = a.T 89 | print b 90 | print '\n' 91 | print '以 C 风格顺序排序：' 92 | c = b.copy(order='C') 93 | print c for x in np.nditer(c): 94 | print x, 95 | print '\n' 96 | print '以 F 风格顺序排序：' 97 | c = b.copy(order='F') 98 | print c 99 | for x in np.nditer(c): 100 | print x, 101 | ``` 102 | 103 | 输出如下： 104 | 105 | ``` 106 | 原始数组是： 107 | [[ 0 5 10 15] 108 | [20 25 30 35] 109 | [40 45 50 55]] 110 | 111 | 原始数组的转置是： 112 | [[ 0 20 40] 113 | [ 5 25 45] 114 | [10 30 50] 115 | [15 35 55]] 116 | 117 | 以 C 风格顺序排序： 118 | [[ 0 20 40] 119 | [ 5 25 45] 120 | [10 30 50] 121 | [15 35 55]] 122 | 0 20 40 5 25 45 10 30 50 15 35 55 123 | 124 | 以 F 风格顺序排序： 125 | [[ 0 20 40] 126 | [ 5 25 45] 127 | [10 30 50] 128 | [15 35 55]] 129 | 0 5 10 15 20 25 30 35 40 45 50 55 130 | 131 | ``` 132 | 133 | ### 示例 2 134 | 135 | 可以通过显式提醒，来强制`nditer`对象使用某种顺序： 136 | 137 | ``` 138 | import numpy as np 139 | a = np.arange(0,60,5) 140 | a = a.reshape(3,4) 141 | print '原始数组是：' 142 | print a 143 | print '\n' 144 | print '以 C 风格顺序排序：' 145 | for x in np.nditer(a, order = 'C'): 146 | print x, 147 | print '\n' 148 | print '以 F 风格顺序排序：' 149 | for x in np.nditer(a, order = 'F'): 150 | print x, 151 | ``` 152 | 153 | 输出如下： 154 | 155 | ``` 156 | 原始数组是： 157 | [[ 0 5 10 15] 158 | [20 25 30 35] 159 | [40 45 50 55]] 160 | 161 | 以 C 风格顺序排序： 162 | 0 5 10 15 20 25 30 35 40 45 50 55 163 | 164 | 以 F 风格顺序排序： 165 | 0 20 40 5 25 45 10 30 50 15 35 55 166 | 167 | ``` 168 | 169 | ## 修改数组的值 170 | 171 | `nditer`对象有另一个可选参数`op_flags`。 其默认值为只读，但可以设置为读写或只写模式。 这将允许使用此迭代器修改数组元素。 172 | 173 | ### 示例 174 | 175 | ``` 176 | import numpy as np 177 | a = np.arange(0,60,5) 178 | a = a.reshape(3,4) 179 | print '原始数组是：' 180 | print a 181 | print '\n' 182 | for x in np.nditer(a, op_flags=['readwrite']): 183 | x[...]=2*x 184 | print '修改后的数组是：' 185 | print a 186 | ``` 187 | 188 | 输出如下： 189 | 190 | ``` 191 | 原始数组是： 192 | [[ 0 5 10 15] 193 | [20 25 30 35] 194 | [40 45 50 55]] 195 | 196 | 修改后的数组是： 197 | [[ 0 10 20 30] 198 | [ 40 50 60 70] 199 | [ 80 90 100 110]] 200 | 201 | ``` 202 | 203 | ## 外部循环 204 | 205 | `nditer`类的构造器拥有`flags`参数，它可以接受下列值： 206 | 207 | | 序号 | 参数及描述 | 208 | | --- | --- | 209 | | 1. | `c_index` 可以跟踪 C 顺序的索引 | 210 | | 2. | `f_index` 可以跟踪 Fortran 顺序的索引 | 211 | | 3. | `multi-index` 每次迭代可以跟踪一种索引类型 | 212 | | 4. | `external_loop` 给出的值是具有多个值的一维数组，而不是零维数组 | 213 | 214 | ### 示例 215 | 216 | 在下面的示例中，迭代器遍历对应于每列的一维数组。 217 | 218 | ``` 219 | import numpy as np 220 | a = np.arange(0,60,5) 221 | a = a.reshape(3,4) 222 | print '原始数组是：' 223 | print a 224 | print '\n' 225 | print '修改后的数组是：' 226 | for x in np.nditer(a, flags = ['external_loop'], order = 'F'): 227 | print x, 228 | ``` 229 | 230 | 输出如下： 231 | 232 | ``` 233 | 原始数组是： 234 | [[ 0 5 10 15] 235 | [20 25 30 35] 236 | [40 45 50 55]] 237 | 238 | 修改后的数组是： 239 | [ 0 20 40] [ 5 25 45] [10 30 50] [15 35 55] 240 | 241 | ``` 242 | 243 | ## 广播迭代 244 | 245 | 如果两个数组是**可广播的**，`nditer`组合对象能够同时迭代它们。 假设数组`a `具有维度 3X4，并且存在维度为 1X4 的另一个数组`b`，则使用以下类型的迭代器（数组`b`被广播到`a`的大小）。 246 | 247 | ### 示例 248 | 249 | ``` 250 | import numpy as np 251 | a = np.arange(0,60,5) 252 | a = a.reshape(3,4) 253 | print '第一个数组：' 254 | print a 255 | print '\n' 256 | print '第二个数组：' 257 | b = np.array([1, 2, 3, 4], dtype = int) 258 | print b 259 | print '\n' 260 | print '修改后的数组是：' 261 | for x,y in np.nditer([a,b]): 262 | print "%d:%d" % (x,y), 263 | ``` 264 | 265 | 输出如下： 266 | 267 | ``` 268 | 第一个数组： 269 | [[ 0 5 10 15] 270 | [20 25 30 35] 271 | [40 45 50 55]] 272 | 273 | 第二个数组： 274 | [1 2 3 4] 275 | 276 | 修改后的数组是： 277 | 0:1 5:2 10:3 15:4 20:1 25:2 30:3 35:4 40:1 45:2 50:3 55:4 278 | 279 | ``` 280 | 281 | 282 | -------------------------------------------------------------------------------- /12.md: -------------------------------------------------------------------------------- 1 | 2 | 3 | # NumPy - 数组操作 4 | 5 | NumPy包中有几个例程用于处理`ndarray`对象中的元素。 它们可以分为以下类型： 6 | 7 | ## 修改形状 8 | 9 | | 序号 | 形状及描述 | 10 | | --- | --- | 11 | | 1. | `reshape` 不改变数据的条件下修改形状 | 12 | | 2. | `flat` 数组上的一维迭代器 | 13 | | 3. | `flatten` 返回折叠为一维的数组副本 | 14 | | 4. | `ravel` 返回连续的展开数组 | 15 | 16 | ### `numpy.reshape` 17 | 18 | 这个函数在不改变数据的条件下修改形状，它接受如下参数： 19 | 20 | ``` 21 | numpy.reshape(arr, newshape, order') 22 | ``` 23 | 24 | 其中： 25 | 26 | + `arr`：要修改形状的数组 27 | + `newshape`：整数或者整数数组，新的形状应当兼容原有形状 28 | + `order`：`'C'`为 C 风格顺序，`'F'`为 F 风格顺序，`'A'`为保留原顺序。 29 | 30 | 例子 31 | 32 | ``` 33 | import numpy as np 34 | a = np.arange(8) 35 | print '原始数组：' 36 | print a 37 | print '\n' 38 | 39 | b = a.reshape(4,2) 40 | print '修改后的数组：' 41 | print b 42 | ``` 43 | 44 | 输出如下： 45 | 46 | ``` 47 | 原始数组： 48 | [0 1 2 3 4 5 6 7] 49 | 50 | 修改后的数组： 51 | [[0 1] 52 | [2 3] 53 | [4 5] 54 | [6 7]] 55 | ``` 56 | 57 | ### `numpy.ndarray.flat` 58 | 59 | 该函数返回数组上的一维迭代器，行为类似 Python 内建的迭代器。 60 | 61 | 例子 62 | 63 | ``` 64 | import numpy as np 65 | a = np.arange(8).reshape(2,4) 66 | print '原始数组：' 67 | print a 68 | print '\n' 69 | 70 | print '调用 flat 函数之后：' 71 | # 返回展开数组中的下标的对应元素 72 | print a.flat[5] 73 | ``` 74 | 75 | 输出如下： 76 | 77 | ``` 78 | 原始数组： 79 | [[0 1 2 3] 80 | [4 5 6 7]] 81 | 82 | 调用 flat 函数之后： 83 | 5 84 | ``` 85 | 86 | ### `numpy.ndarray.flatten` 87 | 88 | 该函数返回折叠为一维的数组副本，函数接受下列参数： 89 | 90 | ``` 91 | ndarray.flatten(order) 92 | ``` 93 | 94 | 其中： 95 | 96 | + `order`：`'C'` -- 按行，`'F'` -- 按列，`'A'` -- 原顺序，`'k'` -- 元素在内存中的出现顺序。 97 | 98 | 例子 99 | 100 | ``` 101 | import numpy as np 102 | a = np.arange(8).reshape(2,4) 103 | 104 | print '原数组：' 105 | print a 106 | print '\n' 107 | # default is column-major 108 | 109 | print '展开的数组：' 110 | print a.flatten() 111 | print '\n' 112 | 113 | print '以 F 风格顺序展开的数组：' 114 | print a.flatten(order = 'F') 115 | ``` 116 | 117 | 输出如下： 118 | 119 | ``` 120 | 原数组： 121 | [[0 1 2 3] 122 | [4 5 6 7]] 123 | 124 | 展开的数组： 125 | [0 1 2 3 4 5 6 7] 126 | 127 | 以 F 风格顺序展开的数组： 128 | [0 4 1 5 2 6 3 7] 129 | ``` 130 | 131 | ### `numpy.ravel` 132 | 133 | 这个函数返回展开的一维数组，并且按需生成副本。返回的数组和输入数组拥有相同数据类型。这个函数接受两个参数。 134 | 135 | ``` 136 | numpy.ravel(a, order) 137 | ``` 138 | 139 | 构造器接受下列参数： 140 | 141 | + `order`：`'C'` -- 按行，`'F'` -- 按列，`'A'` -- 原顺序，`'k'` -- 元素在内存中的出现顺序。 142 | 143 | 例子 144 | 145 | ``` 146 | import numpy as np 147 | a = np.arange(8).reshape(2,4) 148 | 149 | print '原数组：' 150 | print a 151 | print '\n' 152 | 153 | print '调用 ravel 函数之后：' 154 | print a.ravel() 155 | print '\n' 156 | 157 | print '以 F 风格顺序调用 ravel 函数之后：' 158 | print a.ravel(order = 'F') 159 | ``` 160 | 161 | ``` 162 | 原数组： 163 | [[0 1 2 3] 164 | [4 5 6 7]] 165 | 166 | 调用 ravel 函数之后： 167 | [0 1 2 3 4 5 6 7] 168 | 169 | 以 F 风格顺序调用 ravel 函数之后： 170 | [0 4 1 5 2 6 3 7] 171 | ``` 172 | 173 | ## 翻转操作 174 | 175 | | 序号 | 操作及描述 | 176 | | --- | --- | 177 | | 1. | `transpose` 翻转数组的维度 | 178 | | 2. | `ndarray.T` 和`self.transpose()`相同 | 179 | | 3. | `rollaxis` 向后滚动指定的轴 | 180 | | 4. | `swapaxes` 互换数组的两个轴 | 181 | 182 | ### `numpy.transpose` 183 | 184 | 这个函数翻转给定数组的维度。如果可能的话它会返回一个视图。函数接受下列参数： 185 | 186 | ``` 187 | numpy.transpose(arr, axes) 188 | ``` 189 | 190 | 其中： 191 | 192 | + `arr`：要转置的数组 193 | + `axes`：整数的列表，对应维度，通常所有维度都会翻转。 194 | 195 | 例子 196 | 197 | ``` 198 | import numpy as np 199 | a = np.arange(12).reshape(3,4) 200 | 201 | print '原数组：' 202 | print a 203 | print '\n' 204 | 205 | print '转置数组：' 206 | print np.transpose(a) 207 | ``` 208 | 209 | 输出如下： 210 | 211 | ``` 212 | 原数组： 213 | [[ 0 1 2 3] 214 | [ 4 5 6 7] 215 | [ 8 9 10 11]] 216 | 217 | 转置数组： 218 | [[ 0 4 8] 219 | [ 1 5 9] 220 | [ 2 6 10] 221 | [ 3 7 11]] 222 | ``` 223 | 224 | ### `numpy.ndarray.T` 225 | 226 | 该函数属于`ndarray`类，行为类似于` numpy.transpose`。 227 | 228 | 例子 229 | 230 | ``` 231 | import numpy as np 232 | a = np.arange(12).reshape(3,4) 233 | 234 | print '原数组：' 235 | print a 236 | print '\n' 237 | 238 | print '转置数组：' 239 | print a.T 240 | ``` 241 | 242 | 输出如下： 243 | 244 | ``` 245 | 原数组： 246 | [[ 0 1 2 3] 247 | [ 4 5 6 7] 248 | [ 8 9 10 11]] 249 | 250 | 转置数组： 251 | [[ 0 4 8] 252 | [ 1 5 9] 253 | [ 2 6 10] 254 | [ 3 7 11]] 255 | ``` 256 | 257 | ### `numpy.rollaxis` 258 | 259 | 该函数向后滚动特定的轴，直到一个特定位置。这个函数接受三个参数： 260 | 261 | ``` 262 | numpy.rollaxis(arr, axis, start) 263 | ``` 264 | 265 | 其中： 266 | 267 | + `arr`：输入数组 268 | + `axis`：要向后滚动的轴，其它轴的相对位置不会改变 269 | + `start`：默认为零，表示完整的滚动。会滚动到特定位置。 270 | 271 | 例子 272 | 273 | ``` 274 | # 创建了三维的 ndarray 275 | import numpy as np 276 | a = np.arange(8).reshape(2,2,2) 277 | 278 | print '原数组：' 279 | print a 280 | print '\n' 281 | # 将轴 2 滚动到轴 0（宽度到深度） 282 | 283 | print '调用 rollaxis 函数：' 284 | print np.rollaxis(a,2) 285 | # 将轴 0 滚动到轴 1：（宽度到高度） 286 | print '\n' 287 | 288 | print '调用 rollaxis 函数：' 289 | print np.rollaxis(a,2,1) 290 | ``` 291 | 292 | 输出如下： 293 | 294 | ``` 295 | 原数组： 296 | [[[0 1] 297 | [2 3]] 298 | [[4 5] 299 | [6 7]]] 300 | 301 | 调用 rollaxis 函数： 302 | [[[0 2] 303 | [4 6]] 304 | [[1 3] 305 | [5 7]]] 306 | 307 | 调用 rollaxis 函数： 308 | [[[0 2] 309 | [1 3]] 310 | [[4 6] 311 | [5 7]]] 312 | ``` 313 | 314 | ### `numpy.swapaxes` 315 | 316 | 该函数交换数组的两个轴。对于 1.10 之前的 NumPy 版本，会返回交换后数组的试图。这个函数接受下列参数： 317 | 318 | ``` 319 | numpy.swapaxes(arr, axis1, axis2) 320 | ``` 321 | 322 | + `arr`：要交换其轴的输入数组 323 | + `axis1`：对应第一个轴的整数 324 | + `axis2`：对应第二个轴的整数 325 | 326 | ``` 327 | # 创建了三维的 ndarray 328 | import numpy as np 329 | a = np.arange(8).reshape(2,2,2) 330 | 331 | print '原数组：' 332 | print a 333 | print '\n' 334 | # 现在交换轴 0（深度方向）到轴 2（宽度方向） 335 | 336 | print '调用 swapaxes 函数后的数组：' 337 | print np.swapaxes(a, 2, 0) 338 | ``` 339 | 340 | 输出如下： 341 | 342 | ``` 343 | 原数组： 344 | [[[0 1] 345 | [2 3]] 346 | 347 | [[4 5] 348 | [6 7]]] 349 | 350 | 调用 swapaxes 函数后的数组： 351 | [[[0 4] 352 | [2 6]] 353 | 354 | [[1 5] 355 | [3 7]]] 356 | ``` 357 | 358 | 359 | ## 修改维度 360 | 361 | | 序号 | 维度和描述 | 362 | | --- | --- | 363 | | 1. | `broadcast` 产生模仿广播的对象 | 364 | | 2. | `broadcast_to` 将数组广播到新形状 | 365 | | 3. | `expand_dims` 扩展数组的形状 | 366 | | 4. | `squeeze` 从数组的形状中删除单维条目 | 367 | 368 | ### `broadcast` 369 | 370 | 如前所述，NumPy 已经内置了对广播的支持。 此功能模仿广播机制。 它返回一个对象，该对象封装了将一个数组广播到另一个数组的结果。 371 | 372 | 该函数使用两个数组作为输入参数。 下面的例子说明了它的用法。 373 | 374 | ``` 375 | import numpy as np 376 | x = np.array([[1], [2], [3]]) 377 | y = np.array([4, 5, 6]) 378 | 379 | # 对 y 广播 x 380 | b = np.broadcast(x,y) 381 | # 它拥有 iterator 属性，基于自身组件的迭代器元组 382 | 383 | print '对 y 广播 x：' 384 | r,c = b.iters 385 | print r.next(), c.next() 386 | print r.next(), c.next() 387 | print '\n' 388 | # shape 属性返回广播对象的形状 389 | 390 | print '广播对象的形状：' 391 | print b.shape 392 | print '\n' 393 | # 手动使用 broadcast 将 x 与 y 相加 394 | b = np.broadcast(x,y) 395 | c = np.empty(b.shape) 396 | 397 | print '手动使用 broadcast 将 x 与 y 相加：' 398 | print c.shape 399 | print '\n' 400 | c.flat = [u + v for (u,v) in b] 401 | 402 | print '调用 flat 函数：' 403 | print c 404 | print '\n' 405 | # 获得了和 NumPy 内建的广播支持相同的结果 406 | 407 | print 'x 与 y 的和：' 408 | print x + y 409 | ``` 410 | 411 | 输出如下： 412 | 413 | ``` 414 | 对 y 广播 x： 415 | 1 4 416 | 1 5 417 | 418 | 广播对象的形状： 419 | (3, 3) 420 | 421 | 手动使用 broadcast 将 x 与 y 相加： 422 | (3, 3) 423 | 424 | 调用 flat 函数： 425 | [[ 5. 6. 7.] 426 | [ 6. 7. 8.] 427 | [ 7. 8. 9.]] 428 | 429 | x 与 y 的和： 430 | [[5 6 7] 431 | [6 7 8] 432 | [7 8 9]] 433 | ``` 434 | 435 | ### `numpy.broadcast_to` 436 | 437 | 此函数将数组广播到新形状。 它在原始数组上返回只读视图。 它通常不连续。 如果新形状不符合 NumPy 的广播规则，该函数可能会抛出`ValueError`。 438 | 439 | 注意 - 此功能可用于 1.10.0 及以后的版本。 440 | 441 | 该函数接受以下参数。 442 | 443 | ``` 444 | numpy.broadcast_to(array, shape, subok) 445 | ``` 446 | 447 | 例子 448 | 449 | ``` 450 | import numpy as np 451 | a = np.arange(4).reshape(1,4) 452 | 453 | print '原数组：' 454 | print a 455 | print '\n' 456 | 457 | print '调用 broadcast_to 函数之后：' 458 | print np.broadcast_to(a,(4,4)) 459 | ``` 460 | 461 | 输出如下： 462 | 463 | ``` 464 | [[0 1 2 3] 465 | [0 1 2 3] 466 | [0 1 2 3] 467 | [0 1 2 3]] 468 | ``` 469 | 470 | ### `numpy.expand_dims` 471 | 472 | 函数通过在指定位置插入新的轴来扩展数组形状。该函数需要两个参数： 473 | 474 | ``` 475 | numpy.expand_dims(arr, axis) 476 | ``` 477 | 478 | 其中： 479 | 480 | + `arr`：输入数组 481 | + `axis`：新轴插入的位置 482 | 483 | 例子 484 | 485 | ``` 486 | import numpy as np 487 | x = np.array(([1,2],[3,4])) 488 | 489 | print '数组 x：' 490 | print x 491 | print '\n' 492 | y = np.expand_dims(x, axis = 0) 493 | 494 | print '数组 y：' 495 | print y 496 | print '\n' 497 | 498 | print '数组 x 和 y 的形状：' 499 | print x.shape, y.shape 500 | print '\n' 501 | # 在位置 1 插入轴 502 | y = np.expand_dims(x, axis = 1) 503 | 504 | print '在位置 1 插入轴之后的数组 y：' 505 | print y 506 | print '\n' 507 | 508 | print 'x.ndim 和 y.ndim：' 509 | print x.ndim,y.ndim 510 | print '\n' 511 | 512 | print 'x.shape 和 y.shape：' 513 | print x.shape, y.shape 514 | ``` 515 | 516 | 输出如下： 517 | 518 | ``` 519 | 数组 x： 520 | [[1 2] 521 | [3 4]] 522 | 523 | 数组 y： 524 | [[[1 2] 525 | [3 4]]] 526 | 527 | 数组 x 和 y 的形状： 528 | (2, 2) (1, 2, 2) 529 | 530 | 在位置 1 插入轴之后的数组 y： 531 | [[[1 2]] 532 | [[3 4]]] 533 | 534 | x.shape 和 y.shape： 535 | 2 3 536 | 537 | x.shape and y.shape: 538 | (2, 2) (2, 1, 2) 539 | ``` 540 | 541 | ### `numpy.squeeze` 542 | 543 | 函数从给定数组的形状中删除一维条目。 此函数需要两个参数。 544 | 545 | ``` 546 | numpy.squeeze(arr, axis) 547 | ``` 548 | 549 | 其中： 550 | 551 | + `arr`：输入数组 552 | + `axis`：整数或整数元组，用于选择形状中单一维度条目的子集 553 | 554 | 例子 555 | 556 | ``` 557 | import numpy as np 558 | x = np.arange(9).reshape(1,3,3) 559 | 560 | print '数组 x：' 561 | print x 562 | print '\n' 563 | y = np.squeeze(x) 564 | 565 | print '数组 y：' 566 | print y 567 | print '\n' 568 | 569 | print '数组 x 和 y 的形状：' 570 | print x.shape, y.shape 571 | ``` 572 | 573 | 输出如下： 574 | 575 | ``` 576 | 数组 x： 577 | [[[0 1 2] 578 | [3 4 5] 579 | [6 7 8]]] 580 | 581 | 数组 y： 582 | [[0 1 2] 583 | [3 4 5] 584 | [6 7 8]] 585 | 586 | 数组 x 和 y 的形状： 587 | (1, 3, 3) (3, 3) 588 | ``` 589 | 590 | ## 数组的连接 591 | 592 | | 序号 | 数组及描述 | 593 | | --- | --- | 594 | | 1. | `concatenate` 沿着现存的轴连接数据序列 | 595 | | 2. | `stack` 沿着新轴连接数组序列 | 596 | | 3. | `hstack` 水平堆叠序列中的数组（列方向） | 597 | | 4. | `vstack` 竖直堆叠序列中的数组（行方向） | 598 | 599 | ### `numpy.concatenate` 600 | 601 | 数组的连接是指连接。 此函数用于沿指定轴连接相同形状的两个或多个数组。 该函数接受以下参数。 602 | 603 | ``` 604 | numpy.concatenate((a1, a2, ...), axis) 605 | ``` 606 | 607 | 其中： 608 | 609 | + `a1, a2, ...`：相同类型的数组序列 610 | + `axis`：沿着它连接数组的轴，默认为 0 611 | 612 | 例子 613 | 614 | ``` 615 | import numpy as np 616 | a = np.array([[1,2],[3,4]]) 617 | 618 | print '第一个数组：' 619 | print a 620 | print '\n' 621 | b = np.array([[5,6],[7,8]]) 622 | 623 | print '第二个数组：' 624 | print b 625 | print '\n' 626 | # 两个数组的维度相同 627 | 628 | print '沿轴 0 连接两个数组：' 629 | print np.concatenate((a,b)) 630 | print '\n' 631 | 632 | print '沿轴 1 连接两个数组：' 633 | print np.concatenate((a,b),axis = 1) 634 | ``` 635 | 636 | 输出如下： 637 | 638 | ``` 639 | 第一个数组： 640 | [[1 2] 641 | [3 4]] 642 | 643 | 第二个数组： 644 | [[5 6] 645 | [7 8]] 646 | 647 | 沿轴 0 连接两个数组： 648 | [[1 2] 649 | [3 4] 650 | [5 6] 651 | [7 8]] 652 | 653 | 沿轴 1 连接两个数组： 654 | [[1 2 5 6] 655 | [3 4 7 8]] 656 | ``` 657 | 658 | ### `numpy.stack` 659 | 660 | 此函数沿新轴连接数组序列。 此功能添加自 NumPy 版本 1.10.0。 需要提供以下参数。 661 | 662 | ``` 663 | numpy.stack(arrays, axis) 664 | ``` 665 | 666 | 其中： 667 | 668 | + `arrays`：相同形状的数组序列 669 | + `axis`：返回数组中的轴，输入数组沿着它来堆叠 670 | 671 | ``` 672 | import numpy as np 673 | a = np.array([[1,2],[3,4]]) 674 | 675 | print '第一个数组：' 676 | print a 677 | print '\n' 678 | b = np.array([[5,6],[7,8]]) 679 | 680 | print '第二个数组：' 681 | print b 682 | print '\n' 683 | 684 | print '沿轴 0 堆叠两个数组：' 685 | print np.stack((a,b),0) 686 | print '\n' 687 | 688 | print '沿轴 1 堆叠两个数组：' 689 | print np.stack((a,b),1) 690 | ``` 691 | 692 | 输出如下： 693 | 694 | ``` 695 | 第一个数组： 696 | [[1 2] 697 | [3 4]] 698 | 699 | 第二个数组： 700 | [[5 6] 701 | [7 8]] 702 | 703 | 沿轴 0 堆叠两个数组： 704 | [[[1 2] 705 | [3 4]] 706 | [[5 6] 707 | [7 8]]] 708 | 709 | 沿轴 1 堆叠两个数组： 710 | [[[1 2] 711 | [5 6]] 712 | [[3 4] 713 | [7 8]]] 714 | ``` 715 | 716 | ### `numpy.hstack` 717 | 718 | `numpy.stack`函数的变体，通过堆叠来生成水平的单个数组。 719 | 720 | 例子 721 | 722 | ``` 723 | import numpy as np 724 | a = np.array([[1,2],[3,4]]) 725 | 726 | print '第一个数组：' 727 | print a 728 | print '\n' 729 | b = np.array([[5,6],[7,8]]) 730 | 731 | print '第二个数组：' 732 | print b 733 | print '\n' 734 | 735 | print '水平堆叠：' 736 | c = np.hstack((a,b)) 737 | print c 738 | print '\n' 739 | ``` 740 | 741 | 输出如下： 742 | 743 | ``` 744 | 第一个数组： 745 | [[1 2] 746 | [3 4]] 747 | 748 | 第二个数组： 749 | [[5 6] 750 | [7 8]] 751 | 752 | 水平堆叠： 753 | [[1 2 5 6] 754 | [3 4 7 8]] 755 | ``` 756 | 757 | ### `numpy.vstack` 758 | 759 | `numpy.stack`函数的变体，通过堆叠来生成竖直的单个数组。 760 | 761 | ``` 762 | import numpy as np 763 | a = np.array([[1,2],[3,4]]) 764 | 765 | print '第一个数组：' 766 | print a 767 | print '\n' 768 | b = np.array([[5,6],[7,8]]) 769 | 770 | print '第二个数组：' 771 | print b 772 | print '\n' 773 | 774 | print '竖直堆叠：' 775 | c = np.vstack((a,b)) 776 | print c 777 | ``` 778 | 779 | 输出如下： 780 | 781 | ``` 782 | 第一个数组： 783 | [[1 2] 784 | [3 4]] 785 | 786 | 第二个数组： 787 | [[5 6] 788 | [7 8]] 789 | 790 | 竖直堆叠： 791 | [[1 2] 792 | [3 4] 793 | [5 6] 794 | [7 8]] 795 | ``` 796 | 797 | ## 数组分割 798 | 799 | | 序号 | 数组及操作 | 800 | | --- | --- | 801 | | 1. | `split` 将一个数组分割为多个子数组 | 802 | | 2. | `hsplit` 将一个数组水平分割为多个子数组（按列） | 803 | | 3. | `vsplit` 将一个数组竖直分割为多个子数组（按行） | 804 | 805 | ### `numpy.split` 806 | 807 | 该函数沿特定的轴将数组分割为子数组。函数接受三个参数： 808 | 809 | ``` 810 | numpy.split(ary, indices_or_sections, axis) 811 | ``` 812 | 813 | 其中： 814 | 815 | + `ary`：被分割的输入数组 816 | + `indices_or_sections`：可以是整数，表明要从输入数组创建的，等大小的子数组的数量。 如果此参数是一维数组，则其元素表明要创建新子数组的点。 817 | + `axis`：默认为 0 818 | 819 | 例子 820 | 821 | ``` 822 | import numpy as np 823 | a = np.arange(9) 824 | 825 | print '第一个数组：' 826 | print a 827 | print '\n' 828 | 829 | print '将数组分为三个大小相等的子数组：' 830 | b = np.split(a,3) 831 | print b 832 | print '\n' 833 | 834 | print '将数组在一维数组中表明的位置分割：' 835 | b = np.split(a,[4,7]) 836 | print b 837 | ``` 838 | 839 | 输出如下： 840 | 841 | ``` 842 | 第一个数组： 843 | [0 1 2 3 4 5 6 7 8] 844 | 845 | 将数组分为三个大小相等的子数组： 846 | [array([0, 1, 2]), array([3, 4, 5]), array([6, 7, 8])] 847 | 848 | 将数组在一维数组中表明的位置分割： 849 | [array([0, 1, 2, 3]), array([4, 5, 6]), array([7, 8])] 850 | ``` 851 | 852 | ### `numpy.hsplit` 853 | 854 | `numpy.hsplit`是`split()`函数的特例，其中轴为 1 表示水平分割，无论输入数组的维度是什么。 855 | 856 | ``` 857 | import numpy as np 858 | a = np.arange(16).reshape(4,4) 859 | 860 | print '第一个数组：' 861 | print a 862 | print '\n' 863 | 864 | print '水平分割：' 865 | b = np.hsplit(a,2) 866 | print b 867 | print '\n' 868 | ``` 869 | 870 | 输出： 871 | 872 | ``` 873 | 第一个数组： 874 | [[ 0 1 2 3] 875 | [ 4 5 6 7] 876 | [ 8 9 10 11] 877 | [12 13 14 15]] 878 | 879 | 水平分割： 880 | [array([[ 0, 1], 881 | [ 4, 5], 882 | [ 8, 9], 883 | [12, 13]]), array([[ 2, 3], 884 | [ 6, 7], 885 | [10, 11], 886 | [14, 15]])] 887 | ``` 888 | 889 | ### `numpy.vsplit` 890 | 891 | `numpy.vsplit`是`split()`函数的特例，其中轴为 0 表示竖直分割，无论输入数组的维度是什么。下面的例子使之更清楚。 892 | 893 | ``` 894 | import numpy as np 895 | a = np.arange(16).reshape(4,4) 896 | 897 | print '第一个数组：' 898 | print a 899 | print '\n' 900 | 901 | print '竖直分割：' 902 | b = np.vsplit(a,2) 903 | print b 904 | ``` 905 | 906 | 输出如下： 907 | 908 | ``` 909 | 第一个数组： 910 | [[ 0 1 2 3] 911 | [ 4 5 6 7] 912 | [ 8 9 10 11] 913 | [12 13 14 15]] 914 | 915 | 竖直分割： 916 | [array([[0, 1, 2, 3], 917 | [4, 5, 6, 7]]), array([[ 8, 9, 10, 11], 918 | [12, 13, 14, 15]])] 919 | ``` 920 | 921 | 922 | ## 添加/删除元素 923 | 924 | | 序号 | 元素及描述 | 925 | | --- | --- | 926 | | 1. | `resize` 返回指定形状的新数组 | 927 | | 2. | `append` 将值添加到数组末尾 | 928 | | 3. | `insert` 沿指定轴将值插入到指定下标之前 | 929 | | 4. | `delete` 返回删掉某个轴的子数组的新数组 | 930 | | 5. | `unique` 寻找数组内的唯一元素 | 931 | 932 | ### `numpy.resize` 933 | 934 | 此函数返回指定大小的新数组。 如果新大小大于原始大小，则包含原始数组中的元素的重复副本。 该函数接受以下参数。 935 | 936 | ``` 937 | numpy.resize(arr, shape) 938 | ``` 939 | 940 | 其中： 941 | 942 | + `arr`：要修改大小的输入数组 943 | + `shape`：返回数组的新形状 944 | 945 | 例子 946 | 947 | ``` 948 | import numpy as np 949 | a = np.array([[1,2,3],[4,5,6]]) 950 | 951 | print '第一个数组：' 952 | print a 953 | print '\n' 954 | 955 | print '第一个数组的形状：' 956 | print a.shape 957 | print '\n' 958 | b = np.resize(a, (3,2)) 959 | 960 | print '第二个数组：' 961 | print b 962 | print '\n' 963 | 964 | print '第二个数组的形状：' 965 | print b.shape 966 | print '\n' 967 | # 要注意 a 的第一行在 b 中重复出现，因为尺寸变大了 968 | 969 | print '修改第二个数组的大小：' 970 | b = np.resize(a,(3,3)) 971 | print b 972 | ``` 973 | 974 | 输出如下： 975 | 976 | ``` 977 | 第一个数组： 978 | [[1 2 3] 979 | [4 5 6]] 980 | 981 | 第一个数组的形状： 982 | (2, 3) 983 | 984 | 第二个数组： 985 | [[1 2] 986 | [3 4] 987 | [5 6]] 988 | 989 | 第二个数组的形状： 990 | (3, 2) 991 | 992 | 修改第二个数组的大小： 993 | [[1 2 3] 994 | [4 5 6] 995 | [1 2 3]] 996 | ``` 997 | 998 | ### `numpy.append` 999 | 1000 | 此函数在输入数组的末尾添加值。 附加操作不是原地的，而是分配新的数组。 此外，输入数组的维度必须匹配否则将生成`ValueError`。 1001 | 1002 | 函数接受下列函数： 1003 | 1004 | ``` 1005 | numpy.append(arr, values, axis) 1006 | ``` 1007 | 1008 | 其中： 1009 | 1010 | + `arr`：输入数组 1011 | + `values`：要向`arr`添加的值，比如和`arr`形状相同（除了要添加的轴） 1012 | + `axis`：沿着它完成操作的轴。如果没有提供，两个参数都会被展开。 1013 | 1014 | 例子 1015 | 1016 | ``` 1017 | import numpy as np 1018 | a = np.array([[1,2,3],[4,5,6]]) 1019 | 1020 | print '第一个数组：' 1021 | print a 1022 | print '\n' 1023 | 1024 | print '向数组添加元素：' 1025 | print np.append(a, [7,8,9]) 1026 | print '\n' 1027 | 1028 | print '沿轴 0 添加元素：' 1029 | print np.append(a, [[7,8,9]],axis = 0) 1030 | print '\n' 1031 | 1032 | print '沿轴 1 添加元素：' 1033 | print np.append(a, [[5,5,5],[7,8,9]],axis = 1) 1034 | ``` 1035 | 1036 | 输出如下： 1037 | 1038 | ``` 1039 | 第一个数组： 1040 | [[1 2 3] 1041 | [4 5 6]] 1042 | 1043 | 向数组添加元素： 1044 | [1 2 3 4 5 6 7 8 9] 1045 | 1046 | 沿轴 0 添加元素： 1047 | [[1 2 3] 1048 | [4 5 6] 1049 | [7 8 9]] 1050 | 1051 | 沿轴 1 添加元素： 1052 | [[1 2 3 5 5 5] 1053 | [4 5 6 7 8 9]] 1054 | ``` 1055 | 1056 | ## `numpy.insert` 1057 | 1058 | 此函数在给定索引之前，沿给定轴在输入数组中插入值。 如果值的类型转换为要插入，则它与输入数组不同。 插入没有原地的，函数会返回一个新数组。 此外，如果未提供轴，则输入数组会被展开。 1059 | 1060 | `insert()`函数接受以下参数： 1061 | 1062 | ``` 1063 | numpy.insert(arr, obj, values, axis) 1064 | ``` 1065 | 1066 | 其中： 1067 | 1068 | + `arr`：输入数组 1069 | + `obj`：在其之前插入值的索引 1070 | + `values`：要插入的值 1071 | + `axis`：沿着它插入的轴，如果未提供，则输入数组会被展开 1072 | 1073 | 例子 1074 | 1075 | ``` 1076 | import numpy as np 1077 | a = np.array([[1,2],[3,4],[5,6]]) 1078 | 1079 | print '第一个数组：' 1080 | print a 1081 | print '\n' 1082 | 1083 | print '未传递 Axis 参数。 在插入之前输入数组会被展开。' 1084 | print np.insert(a,3,[11,12]) 1085 | print '\n' 1086 | print '传递了 Axis 参数。 会广播值数组来配输入数组。' 1087 | 1088 | print '沿轴 0 广播：' 1089 | print np.insert(a,1,[11],axis = 0) 1090 | print '\n' 1091 | 1092 | print '沿轴 1 广播：' 1093 | print np.insert(a,1,11,axis = 1) 1094 | ``` 1095 | 1096 | ### `numpy.delete` 1097 | 1098 | 此函数返回从输入数组中删除指定子数组的新数组。 与`insert()`函数的情况一样，如果未提供轴参数，则输入数组将展开。 该函数接受以下参数： 1099 | 1100 | ``` 1101 | Numpy.delete(arr, obj, axis) 1102 | ``` 1103 | 1104 | 其中： 1105 | 1106 | + `arr`：输入数组 1107 | + `obj`：可以被切片，整数或者整数数组，表明要从输入数组删除的子数组 1108 | + `axis`：沿着它删除给定子数组的轴，如果未提供，则输入数组会被展开 1109 | 1110 | 例子 1111 | 1112 | ``` 1113 | import numpy as np 1114 | a = np.arange(12).reshape(3,4) 1115 | 1116 | print '第一个数组：' 1117 | print a 1118 | print '\n' 1119 | 1120 | print '未传递 Axis 参数。 在插入之前输入数组会被展开。' 1121 | print np.delete(a,5) 1122 | print '\n' 1123 | 1124 | print '删除第二列：' 1125 | print np.delete(a,1,axis = 1) 1126 | print '\n' 1127 | 1128 | print '包含从数组中删除的替代值的切片：' 1129 | a = np.array([1,2,3,4,5,6,7,8,9,10]) 1130 | print np.delete(a, np.s_[::2]) 1131 | ``` 1132 | 1133 | 输出如下： 1134 | 1135 | ``` 1136 | 第一个数组： 1137 | [[ 0 1 2 3] 1138 | [ 4 5 6 7] 1139 | [ 8 9 10 11]] 1140 | 1141 | 未传递 Axis 参数。 在插入之前输入数组会被展开。 1142 | [ 0 1 2 3 4 6 7 8 9 10 11] 1143 | 1144 | 删除第二列： 1145 | [[ 0 2 3] 1146 | [ 4 6 7] 1147 | [ 8 10 11]] 1148 | 1149 | 包含从数组中删除的替代值的切片： 1150 | [ 2 4 6 8 10] 1151 | ``` 1152 | 1153 | ### `numpy.unique` 1154 | 1155 | 此函数返回输入数组中的去重元素数组。 该函数能够返回一个元组，包含去重数组和相关索引的数组。 索引的性质取决于函数调用中返回参数的类型。 1156 | 1157 | ``` 1158 | numpy.unique(arr, return_index, return_inverse, return_counts) 1159 | ``` 1160 | 1161 | 其中： 1162 | 1163 | + `arr`：输入数组，如果不是一维数组则会展开 1164 | + `return_index`：如果为`true`，返回输入数组中的元素下标 1165 | + `return_inverse`：如果为`true`，返回去重数组的下标，它可以用于重构输入数组 1166 | + `return_counts`：如果为`true`，返回去重数组中的元素在原数组中的出现次数 1167 | 1168 | 例子 1169 | 1170 | ``` 1171 | import numpy as np 1172 | a = np.array([5,2,6,2,7,5,6,8,2,9]) 1173 | 1174 | print '第一个数组：' 1175 | print a 1176 | print '\n' 1177 | 1178 | print '第一个数组的去重值：' 1179 | u = np.unique(a) 1180 | print u 1181 | print '\n' 1182 | 1183 | print '去重数组的索引数组：' 1184 | u,indices = np.unique(a, return_index = True) 1185 | print indices 1186 | print '\n' 1187 | 1188 | print '我们可以看到每个和原数组下标对应的数值：' 1189 | print a 1190 | print '\n' 1191 | 1192 | print '去重数组的下标：' 1193 | u,indices = np.unique(a,return_inverse = True) 1194 | print u 1195 | print '\n' 1196 | 1197 | print '下标为：' 1198 | print indices 1199 | print '\n' 1200 | 1201 | print '使用下标重构原数组：' 1202 | print u[indices] 1203 | print '\n' 1204 | 1205 | print '返回去重元素的重复数量：' 1206 | u,indices = np.unique(a,return_counts = True) 1207 | print u 1208 | print indices 1209 | ``` 1210 | 1211 | 输出如下： 1212 | 1213 | ``` 1214 | 第一个数组： 1215 | [5 2 6 2 7 5 6 8 2 9] 1216 | 1217 | 第一个数组的去重值： 1218 | [2 5 6 7 8 9] 1219 | 1220 | 去重数组的索引数组： 1221 | [1 0 2 4 7 9] 1222 | 1223 | 我们可以看到每个和原数组下标对应的数值： 1224 | [5 2 6 2 7 5 6 8 2 9] 1225 | 1226 | 去重数组的下标： 1227 | [2 5 6 7 8 9] 1228 | 1229 | 下标为： 1230 | [1 0 2 0 3 1 2 4 0 5] 1231 | 1232 | 使用下标重构原数组： 1233 | [5 2 6 2 7 5 6 8 2 9] 1234 | 1235 | 返回唯一元素的重复数量： 1236 | [2 5 6 7 8 9] 1237 | [3 2 2 1 1 1] 1238 | ``` 1239 | -------------------------------------------------------------------------------- /13.md: -------------------------------------------------------------------------------- 1 | 2 | 3 | # NumPy - 位操作 4 | 5 | 下面是 NumPy 包中可用的位操作函数。 6 | 7 | | 序号 | 操作及描述 | 8 | | --- | --- | 9 | | 1. | `bitwise_and` 对数组元素执行位与操作 | 10 | | 2. | `bitwise_or` 对数组元素执行位或操作 | 11 | | 3. | `invert` 计算位非 | 12 | | 4. | `left_shift` 向左移动二进制表示的位 | 13 | | 5. | `right_shift` 向右移动二进制表示的位 | 14 | 15 | ## `bitwise_and` 16 | 17 | 通过`np.bitwise_and()`函数对输入数组中的整数的二进制表示的相应位执行位与运算。 18 | 19 | 例子 20 | 21 | ``` 22 | import numpy as np 23 | print '13 和 17 的二进制形式：' 24 | a,b = 13,17 25 | print bin(a), bin(b) 26 | print '\n' 27 | 28 | print '13 和 17 的位与：' 29 | print np.bitwise_and(13, 17) 30 | ``` 31 | 32 | 输出如下： 33 | 34 | ``` 35 | 13 和 17 的二进制形式： 36 | 0b1101 0b10001 37 | 38 | 13 和 17 的位与： 39 | 1 40 | ``` 41 | 42 | 你可以使用下表验证此输出。 考虑下面的位与真值表。 43 | 44 | | A | B | AND | 45 | | --- | --- | --- | 46 | | 1 | 1 | 1 | 47 | | 1 | 0 | 0 | 48 | | 0 | 1 | 0 | 49 | | 0 | 0 | 0 | 50 | 51 | | | | 1 | 1 | 0 | 1 | 52 | | --- | --- | 53 | | AND | 54 | | | 1 | 0 | 0 | 0 | 1 | 55 | | result | 0 | 0 | 0 | 0 | 1 | 56 | 57 | ## `bitwise_or` 58 | 59 | 通过`np.bitwise_or()`函数对输入数组中的整数的二进制表示的相应位执行位或运算。 60 | 61 | 例子 62 | 63 | ``` 64 | import numpy as np 65 | a,b = 13,17 66 | print '13 和 17 的二进制形式：' 67 | print bin(a), bin(b) 68 | 69 | print '13 和 17 的位或：' 70 | print np.bitwise_or(13, 17) 71 | ``` 72 | 73 | 输出如下： 74 | 75 | ``` 76 | 13 和 17 的二进制形式： 77 | 0b1101 0b10001 78 | 79 | 13 和 17 的位或： 80 | 29 81 | ``` 82 | 83 | 你可以使用下表验证此输出。 考虑下面的位或真值表。 84 | 85 | | A | B | OR | 86 | | --- | --- | --- | 87 | | 1 | 1 | 1 | 88 | | 1 | 0 | 1 | 89 | | 0 | 1 | 1 | 90 | | 0 | 0 | 0 | 91 | 92 | | | | 1 | 1 | 0 | 1 | 93 | | --- | --- | 94 | | OR | 95 | | | 1 | 0 | 0 | 0 | 1 | 96 | | result | 1 | 1 | 1 | 0 | 1 | 97 | 98 | ## `invert` 99 | 100 | 此函数计算输入数组中整数的位非结果。 对于有符号整数，返回补码。 101 | 102 | 例子 103 | 104 | ``` 105 | import numpy as np 106 | 107 | print '13 的位反转，其中 ndarray 的 dtype 是 uint8：' 108 | print np.invert(np.array([13], dtype = np.uint8)) 109 | print '\n' 110 | # 比较 13 和 242 的二进制表示，我们发现了位的反转 111 | 112 | print '13 的二进制表示：' 113 | print np.binary_repr(13, width = 8) 114 | print '\n' 115 | 116 | print '242 的二进制表示：' 117 | print np.binary_repr(242, width = 8) 118 | ``` 119 | 120 | 输出如下： 121 | 122 | ``` 123 | 13 的位反转，其中 ndarray 的 dtype 是 uint8： 124 | [242] 125 | 126 | 13 的二进制表示： 127 | 00001101 128 | 129 | 242 的二进制表示： 130 | 11110010 131 | ``` 132 | 133 | 请注意，`np.binary_repr()`函数返回给定宽度中十进制数的二进制表示。 134 | 135 | ## `left_shift` 136 | 137 | `numpy.left shift()`函数将数组元素的二进制表示中的位向左移动到指定位置，右侧附加相等数量的 0。 138 | 139 | 例如， 140 | 141 | ``` 142 | import numpy as np 143 | 144 | print '将 10 左移两位：' 145 | print np.left_shift(10,2) 146 | print '\n' 147 | 148 | print '10 的二进制表示：' 149 | print np.binary_repr(10, width = 8) 150 | print '\n' 151 | 152 | print '40 的二进制表示：' 153 | print np.binary_repr(40, width = 8) 154 | # '00001010' 中的两位移动到了左边，并在右边添加了两个 0。 155 | ``` 156 | 157 | 输出如下： 158 | 159 | ``` 160 | 将 10 左移两位： 161 | 40 162 | 163 | 10 的二进制表示： 164 | 00001010 165 | 166 | 40 的二进制表示： 167 | 00101000 168 | ``` 169 | 170 | ## `right_shift` 171 | 172 | `numpy.right_shift()`函数将数组元素的二进制表示中的位向右移动到指定位置，左侧附加相等数量的 0。 173 | 174 | ``` 175 | import numpy as np 176 | 177 | print '将 40 右移两位：' 178 | print np.right_shift(40,2) 179 | print '\n' 180 | 181 | print '40 的二进制表示：' 182 | print np.binary_repr(40, width = 8) 183 | print '\n' 184 | 185 | print '10 的二进制表示：' 186 | print np.binary_repr(10, width = 8) 187 | # '00001010' 中的两位移动到了右边，并在左边添加了两个 0。 188 | ``` 189 | 190 | 输出如下： 191 | 192 | ``` 193 | 将 40 右移两位： 194 | 10 195 | 196 | 40 的二进制表示： 197 | 00101000 198 | 199 | 10 的二进制表示： 200 | 00001010 201 | ``` 202 | 203 | 204 | 205 | -------------------------------------------------------------------------------- /14.md: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | # NumPy - 字符串函数 5 | 6 | 以下函数用于对`dtype`为`numpy.string_`或`numpy.unicode_`的数组执行向量化字符串操作。 它们基于 Python 内置库中的标准字符串函数。 7 | 8 | | 序号 | 函数及描述 | 9 | | --- | --- | 10 | | 1. | `add()` 返回两个`str`或`Unicode`数组的逐个字符串连接 | 11 | | 2. | `multiply()` 返回按元素多重连接后的字符串 | 12 | | 3. | `center()` 返回给定字符串的副本，其中元素位于特定字符串的中央 | 13 | | 4. | `capitalize()` 返回给定字符串的副本，其中只有第一个字符串大写 | 14 | | 5. | `title()` 返回字符串或 Unicode 的按元素标题转换版本 | 15 | | 6. | `lower()` 返回一个数组，其元素转换为小写 | 16 | | 7. | `upper()` 返回一个数组，其元素转换为大写 | 17 | | 8. | `split()` 返回字符串中的单词列表，并使用分隔符来分割 | 18 | | 9. | `splitlines()` 返回元素中的行列表，以换行符分割 | 19 | | 10. | `strip()` 返回数组副本，其中元素移除了开头或者结尾处的特定字符 | 20 | | 11. | `join()` 返回一个字符串，它是序列中字符串的连接 | 21 | | 12. | `replace()` 返回字符串的副本，其中所有子字符串的出现位置都被新字符串取代 | 22 | | 13. | `decode()` 按元素调用`str.decode` | 23 | | 14. | `encode()` 按元素调用`str.encode` | 24 | 25 | 这些函数在字符数组类（`numpy.char`）中定义。 较旧的 Numarray 包包含`chararray`类。 `numpy.char`类中的上述函数在执行向量化字符串操作时非常有用。 26 | 27 | ## `numpy.char.add()` 28 | 29 | 函数执行按元素的字符串连接。 30 | 31 | ``` 32 | import numpy as np 33 | print '连接两个字符串：' 34 | print np.char.add(['hello'],[' xyz']) 35 | print '\n' 36 | 37 | print '连接示例：' 38 | print np.char.add(['hello', 'hi'],[' abc', ' xyz']) 39 | ``` 40 | 41 | 输出如下： 42 | 43 | ``` 44 | 连接两个字符串： 45 | ['hello xyz'] 46 | 47 | 连接示例： 48 | ['hello abc' 'hi xyz'] 49 | ``` 50 | 51 | ## `numpy.char.multiply()` 52 | 53 | 这个函数执行多重连接。 54 | 55 | ``` 56 | import numpy as np 57 | print np.char.multiply('Hello ',3) 58 | ``` 59 | 60 | 输出如下： 61 | 62 | ``` 63 | Hello Hello Hello 64 | ``` 65 | 66 | ## `numpy.char.center()` 67 | 68 | 此函数返回所需宽度的数组，以便输入字符串位于中心，并使用`fillchar`在左侧和右侧进行填充。 69 | 70 | ``` 71 | import numpy as np 72 | # np.char.center(arr, width,fillchar) 73 | print np.char.center('hello', 20,fillchar = '*') 74 | ``` 75 | 76 | 输出如下： 77 | 78 | ``` 79 | *******hello******** 80 | ``` 81 | 82 | ## `numpy.char.capitalize()` 83 | 84 | 函数返回字符串的副本，其中第一个字母大写 85 | 86 | ``` 87 | import numpy as np 88 | print np.char.capitalize('hello world') 89 | ``` 90 | 91 | 输出如下： 92 | 93 | ``` 94 | Hello world 95 | ``` 96 | 97 | ## `numpy.char.title()` 98 | 99 | 返回输入字符串的按元素标题转换版本，其中每个单词的首字母都大写。 100 | 101 | ``` 102 | import numpy as np 103 | print np.char.title('hello how are you?') 104 | ``` 105 | 106 | 输出如下： 107 | 108 | ``` 109 | Hello How Are You? 110 | ``` 111 | 112 | ## `numpy.char.lower()` 113 | 114 | 函数返回一个数组，其元素转换为小写。它对每个元素调用`str.lower`。 115 | 116 | ``` 117 | import numpy as np 118 | print np.char.lower(['HELLO','WORLD']) 119 | print np.char.lower('HELLO') 120 | ``` 121 | 122 | 输出如下： 123 | 124 | ``` 125 | ['hello' 'world'] 126 | hello 127 | ``` 128 | 129 | ## `numpy.char.upper()` 130 | 131 | 函数返回一个数组，其元素转换为大写。它对每个元素调用`str.upper`。 132 | 133 | ``` 134 | import numpy as np 135 | print np.char.upper('hello') 136 | print np.char.upper(['hello','world']) 137 | ``` 138 | 139 | 140 | 输出如下： 141 | 142 | ``` 143 | HELLO 144 | ['HELLO' 'WORLD'] 145 | ``` 146 | 147 | ## `numpy.char.split()` 148 | 149 | 此函数返回输入字符串中的单词列表。 默认情况下，空格用作分隔符。 否则，指定的分隔符字符用于分割字符串。 150 | 151 | ``` 152 | import numpy as np 153 | print np.char.split ('hello how are you?') 154 | print np.char.split ('TutorialsPoint,Hyderabad,Telangana', sep = ',') 155 | ``` 156 | 157 | 输出如下： 158 | 159 | ``` 160 | ['hello', 'how', 'are', 'you?'] 161 | ['TutorialsPoint', 'Hyderabad', 'Telangana'] 162 | ``` 163 | 164 | ## `numpy.char.splitlines()` 165 | 166 | 函数返回数组中元素的单词列表，以换行符分割。 167 | 168 | ``` 169 | import numpy as np 170 | print np.char.splitlines('hello\nhow are you?') 171 | print np.char.splitlines('hello\rhow are you?') 172 | ``` 173 | 174 | 输出如下： 175 | 176 | ``` 177 | ['hello', 'how are you?'] 178 | ['hello', 'how are you?'] 179 | ``` 180 | 181 | `'\n'`，`'\r'`，`'\r\n'`都会用作换行符。 182 | 183 | ## `numpy.char.strip()` 184 | 185 | 函数返回数组的副本，其中元素移除了开头或结尾处的特定字符。 186 | 187 | ``` 188 | import numpy as np 189 | print np.char.strip('ashok arora','a') 190 | print np.char.strip(['arora','admin','java'],'a') 191 | ``` 192 | 193 | 输出如下： 194 | 195 | ``` 196 | shok aror 197 | ['ror' 'dmin' 'jav'] 198 | ``` 199 | 200 | ## `numpy.char.join()` 201 | 202 | 这个函数返回一个字符串，其中单个字符由特定的分隔符连接。 203 | 204 | ``` 205 | import numpy as np 206 | print np.char.join(':','dmy') 207 | print np.char.join([':','-'],['dmy','ymd']) 208 | ``` 209 | 210 | 输出如下： 211 | 212 | ``` 213 | d:m:y 214 | ['d:m:y' 'y-m-d'] 215 | ``` 216 | 217 | ## `numpy.char.replace()` 218 | 219 | 这个函数返回字符串副本，其中所有字符序列的出现位置都被另一个给定的字符序列取代。 220 | 221 | ``` 222 | import numpy as np 223 | print np.char.replace ('He is a good boy', 'is', 'was') 224 | ``` 225 | 226 | 输出如下： 227 | 228 | ``` 229 | He was a good boy 230 | ``` 231 | 232 | ## `numpy.char.decode()` 233 | 234 | 这个函数在给定的字符串中使用特定编码调用`str.decode()`。 235 | 236 | ``` 237 | import numpy as np 238 | 239 | a = np.char.encode('hello', 'cp500') 240 | print a 241 | print np.char.decode(a,'cp500') 242 | ``` 243 | 244 | 输出如下： 245 | 246 | ``` 247 | \x88\x85\x93\x93\x96 248 | hello 249 | ``` 250 | 251 | ## `numpy.char.encode()` 252 | 253 | 此函数对数组中的每个元素调用`str.encode`函数。 默认编码是`utf_8`，可以使用标准 Python 库中的编解码器。 254 | 255 | ``` 256 | import numpy as np 257 | a = np.char.encode('hello', 'cp500') 258 | print a 259 | ``` 260 | 261 | 输出如下： 262 | 263 | ``` 264 | \x88\x85\x93\x93\x96 265 | ``` 266 | 267 | 268 | -------------------------------------------------------------------------------- /15.md: -------------------------------------------------------------------------------- 1 | 2 | 3 | # NumPy - 算数函数 4 | 5 | 很容易理解的是，NumPy 包含大量的各种数学运算功能。 NumPy 提供标准的三角函数，算术运算的函数，复数处理函数等。 6 | 7 | ## 三角函数 8 | 9 | NumPy 拥有标准的三角函数，它为弧度制单位的给定角度返回三角函数比值。 10 | 11 | **示例** 12 | 13 | ``` 14 | import numpy as np 15 | a = np.array([0,30,45,60,90]) 16 | print '不同角度的正弦值：' 17 | # 通过乘 pi/180 转化为弧度 18 | print np.sin(a*np.pi/180) 19 | print '\n' 20 | print '数组中角度的余弦值：' 21 | print np.cos(a*np.pi/180) 22 | print '\n' 23 | print '数组中角度的正切值：' 24 | print np.tan(a*np.pi/180) 25 | ``` 26 | 27 | 输出如下： 28 | 29 | ``` 30 | 不同角度的正弦值： 31 | [ 0. 0.5 0.70710678 0.8660254 1. ] 32 | 33 | 数组中角度的余弦值： 34 | [ 1.00000000e+00 8.66025404e-01 7.07106781e-01 5.00000000e-01 35 | 6.12323400e-17] 36 | 37 | 数组中角度的正切值： 38 | [ 0.00000000e+00 5.77350269e-01 1.00000000e+00 1.73205081e+00 39 | 1.63312394e+16] 40 | 41 | ``` 42 | 43 | `arcsin`，`arccos`，和`arctan`函数返回给定角度的`sin`，`cos`和`tan`的反三角函数。 这些函数的结果可以通过`numpy.degrees()`函数通过将弧度制转换为角度制来验证。 44 | 45 | **示例** 46 | 47 | ``` 48 | import numpy as np 49 | a = np.array([0,30,45,60,90]) 50 | print '含有正弦值的数组：' 51 | sin = np.sin(a*np.pi/180) 52 | print sin 53 | print '\n' 54 | print '计算角度的反正弦，返回值以弧度为单位：' 55 | inv = np.arcsin(sin) 56 | print inv 57 | print '\n' 58 | print '通过转化为角度制来检查结果：' 59 | print np.degrees(inv) 60 | print '\n' 61 | print 'arccos 和 arctan 函数行为类似：' 62 | cos = np.cos(a*np.pi/180) 63 | print cos 64 | print '\n' 65 | print '反余弦：' 66 | inv = np.arccos(cos) 67 | print inv 68 | print '\n' 69 | print '角度制单位：' 70 | print np.degrees(inv) 71 | print '\n' 72 | print 'tan 函数：' 73 | tan = np.tan(a*np.pi/180) 74 | print tan 75 | print '\n' 76 | print '反正切：' 77 | inv = np.arctan(tan) 78 | print inv 79 | print '\n' 80 | print '角度制单位：' 81 | print np.degrees(inv) 82 | ``` 83 | 84 | 输出如下： 85 | 86 | ``` 87 | 含有正弦值的数组： 88 | [ 0. 0.5 0.70710678 0.8660254 1. ] 89 | 90 | 计算角度的反正弦，返回值以弧度制为单位： 91 | [ 0. 0.52359878 0.78539816 1.04719755 1.57079633] 92 | 93 | 通过转化为角度制来检查结果： 94 | [ 0. 30. 45. 60. 90.] 95 | 96 | arccos 和 arctan 函数行为类似： 97 | [ 1.00000000e+00 8.66025404e-01 7.07106781e-01 5.00000000e-01 98 | 6.12323400e-17] 99 | 100 | 反余弦： 101 | [ 0. 0.52359878 0.78539816 1.04719755 1.57079633] 102 | 103 | 角度制单位： 104 | [ 0. 30. 45. 60. 90.] 105 | 106 | tan 函数： 107 | [ 0.00000000e+00 5.77350269e-01 1.00000000e+00 1.73205081e+00 108 | 1.63312394e+16] 109 | 110 | 反正切： 111 | [ 0. 0.52359878 0.78539816 1.04719755 1.57079633] 112 | 113 | 角度制单位： 114 | [ 0. 30. 45. 60. 90.] 115 | 116 | ``` 117 | 118 | ## 舍入函数 119 | 120 | ### `numpy.around()` 121 | 122 | 这个函数返回四舍五入到所需精度的值。 该函数接受以下参数。 123 | 124 | ``` 125 | numpy.around(a,decimals) 126 | 127 | ``` 128 | 129 | 其中： 130 | 131 | | 序号 | 参数及描述 | 132 | | --- | --- | 133 | | 1. | `a` 输入数组 | 134 | | 2. | `decimals` 要舍入的小数位数。 默认值为0。 如果为负，整数将四舍五入到小数点左侧的位置 | 135 | 136 | **示例** 137 | 138 | ``` 139 | import numpy as np 140 | a = np.array([1.0,5.55, 123, 0.567, 25.532]) 141 | print '原数组：' 142 | print a 143 | print '\n' 144 | print '舍入后：' 145 | print np.around(a) 146 | print np.around(a, decimals = 1) 147 | print np.around(a, decimals = -1) 148 | ``` 149 | 150 | 输出如下： 151 | 152 | ``` 153 | 原数组： 154 | [ 1. 5.55 123. 0.567 25.532] 155 | 156 | 舍入后： 157 | [ 1. 6. 123. 1. 26. ] 158 | [ 1. 5.6 123. 0.6 25.5] 159 | [ 0. 10. 120. 0. 30. ] 160 | 161 | ``` 162 | 163 | ### `numpy.floor()` 164 | 165 | 此函数返回不大于输入参数的最大整数。 即标量`x` 的下限是最大的整数`i` ，使得`i <= x `。 注意在Python中，向下取整总是从 0 舍入。 166 | 167 | **示例** 168 | 169 | ``` 170 | import numpy as np 171 | a = np.array([-1.7, 1.5, -0.2, 0.6, 10]) 172 | print '提供的数组：' 173 | print a 174 | print '\n' 175 | print '修改后的数组：' 176 | print np.floor(a) 177 | ``` 178 | 179 | 输出如下： 180 | 181 | ``` 182 | 提供的数组： 183 | [ -1.7 1.5 -0.2 0.6 10. ] 184 | 185 | 修改后的数组： 186 | [ -2. 1. -1. 0. 10.] 187 | 188 | ``` 189 | 190 | ### `numpy.ceil()` 191 | 192 | `ceil()`函数返回输入值的上限，即，标量`x`的上限是最小的整数`i` ，使得` i> = x`。 193 | 194 | **示例** 195 | 196 | ``` 197 | import numpy as np 198 | a = np.array([-1.7, 1.5, -0.2, 0.6, 10]) 199 | print '提供的数组：' 200 | print a 201 | print '\n' 202 | print '修改后的数组：' 203 | print np.ceil(a) 204 | ``` 205 | 206 | 输出如下： 207 | 208 | ``` 209 | 提供的数组： 210 | [ -1.7 1.5 -0.2 0.6 10. ] 211 | 212 | 修改后的数组： 213 | [ -1. 2. -0. 1. 10.] 214 | 215 | ``` 216 | -------------------------------------------------------------------------------- /16.md: -------------------------------------------------------------------------------- 1 | 2 | 3 | # NumPy - 算数运算 4 | 5 | 用于执行算术运算（如`add()`，`subtract()`，`multiply()`和`divide()`）的输入数组必须具有相同的形状或符合数组广播规则。 6 | 7 | ### 示例 8 | 9 | ``` 10 | import numpy as np 11 | a = np.arange(9, dtype = np.float_).reshape(3,3) 12 | print '第一个数组：' 13 | print a 14 | print '\n' 15 | print '第二个数组：' 16 | b = np.array([10,10,10]) 17 | print b 18 | print '\n' 19 | print '两个数组相加：' 20 | print np.add(a,b) 21 | print '\n' 22 | print '两个数组相减：' 23 | print np.subtract(a,b) 24 | print '\n' 25 | print '两个数组相乘：' 26 | print np.multiply(a,b) 27 | print '\n' 28 | print '两个数组相除：' 29 | print np.divide(a,b) 30 | ``` 31 | 32 | 输出如下： 33 | 34 | ``` 35 | 第一个数组： 36 | [[ 0. 1. 2.] 37 | [ 3. 4. 5.] 38 | [ 6. 7. 8.]] 39 | 40 | 第二个数组： 41 | [10 10 10] 42 | 43 | 两个数组相加： 44 | [[ 10. 11. 12.] 45 | [ 13. 14. 15.] 46 | [ 16. 17. 18.]] 47 | 48 | 两个数组相减： 49 | [[-10. -9. -8.] 50 | [ -7. -6. -5.] 51 | [ -4. -3. -2.]] 52 | 53 | 两个数组相乘： 54 | [[ 0. 10. 20.] 55 | [ 30. 40. 50.] 56 | [ 60. 70. 80.]] 57 | 58 | 两个数组相除： 59 | [[ 0. 0.1 0.2] 60 | [ 0.3 0.4 0.5] 61 | [ 0.6 0.7 0.8]] 62 | 63 | ``` 64 | 65 | 让我们现在来讨论 NumPy 中提供的一些其他重要的算术函数。 66 | 67 | ## `numpy.reciprocal()` 68 | 69 | 此函数返回参数逐元素的倒数，。 由于 Python 处理整数除法的方式，对于绝对值大于 1 的整数元素，结果始终为 0， 对于整数 0，则发出溢出警告。 70 | 71 | ### 示例 72 | 73 | ``` 74 | import numpy as np 75 | a = np.array([0.25, 1.33, 1, 0, 100]) 76 | print '我们的数组是：' 77 | print a 78 | print '\n' 79 | print '调用 reciprocal 函数：' 80 | print np.reciprocal(a) 81 | print '\n' 82 | b = np.array([100], dtype = int) 83 | print '第二个数组：' 84 | print b 85 | print '\n' 86 | print '调用 reciprocal 函数：' 87 | print np.reciprocal(b) 88 | ``` 89 | 90 | 输出如下： 91 | 92 | ``` 93 | 我们的数组是： 94 | [ 0.25 1.33 1. 0. 100. ] 95 | 96 | 调用 reciprocal 函数： 97 | main.py:9: RuntimeWarning: divide by zero encountered in reciprocal 98 | print np.reciprocal(a) 99 | [ 4. 0.7518797 1. inf 0.01 ] 100 | 101 | 第二个数组： 102 | [100] 103 | 104 | 调用 reciprocal 函数： 105 | [0] 106 | 107 | ``` 108 | 109 | ## `numpy.power()` 110 | 111 | 此函数将第一个输入数组中的元素作为底数，计算它与第二个输入数组中相应元素的幂。 112 | 113 | ``` 114 | import numpy as np 115 | a = np.array([10,100,1000]) 116 | print '我们的数组是；' 117 | print a 118 | print '\n' 119 | print '调用 power 函数：' 120 | print np.power(a,2) 121 | print '\n' 122 | print '第二个数组：' 123 | b = np.array([1,2,3]) 124 | print b 125 | print '\n' 126 | print '再次调用 power 函数：' 127 | print np.power(a,b) 128 | ``` 129 | 130 | 输出如下： 131 | 132 | ``` 133 | 我们的数组是； 134 | [ 10 100 1000] 135 | 136 | 调用 power 函数： 137 | [ 100 10000 1000000] 138 | 139 | 第二个数组： 140 | [1 2 3] 141 | 142 | 再次调用 power 函数： 143 | [ 10 10000 1000000000] 144 | 145 | ``` 146 | 147 | ## `numpy.mod()` 148 | 149 | 此函数返回输入数组中相应元素的除法余数。 函数`numpy.remainder()`也产生相同的结果。 150 | 151 | ``` 152 | import numpy as np 153 | a = np.array([10,20,30]) 154 | b = np.array([3,5,7]) 155 | print '第一个数组：' 156 | print a 157 | print '\n' 158 | print '第二个数组：' 159 | print b 160 | print '\n' 161 | print '调用 mod() 函数：' 162 | print np.mod(a,b) 163 | print '\n' 164 | print '调用 remainder() 函数：' 165 | print np.remainder(a,b) 166 | ``` 167 | 168 | 输出如下： 169 | 170 | ``` 171 | 第一个数组： 172 | [10 20 30] 173 | 174 | 第二个数组： 175 | [3 5 7] 176 | 177 | 调用 mod() 函数： 178 | [1 0 2] 179 | 180 | 调用 remainder() 函数： 181 | [1 0 2] 182 | 183 | ``` 184 | 185 | 以下函数用于对含有复数的数组执行操作。 186 | 187 | * `numpy.real()` 返回复数类型参数的实部。 188 | 189 | * `numpy.imag()` 返回复数类型参数的虚部。 190 | 191 | * `numpy.conj()` 返回通过改变虚部的符号而获得的共轭复数。 192 | 193 | * `numpy.angle()` 返回复数参数的角度。 函数的参数是`degree`。 如果为`true`，返回的角度以角度制来表示，否则为以弧度制来表示。 194 | 195 | ``` 196 | import numpy as np 197 | a = np.array([-5.6j, 0.2j, 11. , 1+1j]) 198 | print '我们的数组是：' 199 | print a 200 | print '\n' 201 | print '调用 real() 函数：' 202 | print np.real(a) 203 | print '\n' 204 | print '调用 imag() 函数：' 205 | print np.imag(a) 206 | print '\n' 207 | print '调用 conj() 函数：' 208 | print np.conj(a) 209 | print '\n' 210 | print '调用 angle() 函数：' 211 | print np.angle(a) 212 | print '\n' 213 | print '再次调用 angle() 函数（以角度制返回）：' 214 | print np.angle(a, deg = True) 215 | ``` 216 | 217 | 输出如下： 218 | 219 | ``` 220 | 我们的数组是： 221 | [ 0.-5.6j 0.+0.2j 11.+0.j 1.+1.j ] 222 | 223 | 调用 real() 函数： 224 | [ 0. 0. 11. 1.] 225 | 226 | 调用 imag() 函数： 227 | [-5.6 0.2 0. 1. ] 228 | 229 | 调用 conj() 函数： 230 | [ 0.+5.6j 0.-0.2j 11.-0.j 1.-1.j ] 231 | 232 | 调用 angle() 函数： 233 | [-1.57079633 1.57079633 0. 0.78539816] 234 | 235 | 再次调用 angle() 函数（以角度制返回）： 236 | [-90. 90. 0. 45.] 237 | 238 | ``` 239 | 240 | 241 | -------------------------------------------------------------------------------- /17.md: -------------------------------------------------------------------------------- 1 | 2 | 3 | # NumPy - 统计函数 4 | 5 | NumPy 有很多有用的统计函数，用于从数组中给定的元素中查找最小，最大，百分标准差和方差等。 函数说明如下： 6 | 7 | ## `numpy.amin()` 和 `numpy.amax()` 8 | 9 | 这些函数从给定数组中的元素沿指定轴返回最小值和最大值。 10 | 11 | ### 示例 12 | 13 | ``` 14 | import numpy as np 15 | a = np.array([[3,7,5],[8,4,3],[2,4,9]]) 16 | print '我们的数组是：' 17 | print a 18 | print '\n' 19 | print '调用 amin() 函数：' 20 | print np.amin(a,1) 21 | print '\n' 22 | print '再次调用 amin() 函数：' 23 | print np.amin(a,0) 24 | print '\n' 25 | print '调用 amax() 函数：' 26 | print np.amax(a) 27 | print '\n' 28 | print '再次调用 amax() 函数：' 29 | print np.amax(a, axis = 0) 30 | ``` 31 | 32 | 输出如下： 33 | 34 | ``` 35 | 我们的数组是： 36 | [[3 7 5] 37 | [8 4 3] 38 | [2 4 9]] 39 | 40 | 调用 amin() 函数： 41 | [3 3 2] 42 | 43 | 再次调用 amin() 函数： 44 | [2 4 3] 45 | 46 | 调用 amax() 函数： 47 | 9 48 | 49 | 再次调用 amax() 函数： 50 | [8 7 9] 51 | 52 | ``` 53 | 54 | ## `numpy.ptp()` 55 | 56 | `numpy.ptp()`函数返回沿轴的值的范围（最大值 - 最小值）。 57 | 58 | ``` 59 | import numpy as np 60 | a = np.array([[3,7,5],[8,4,3],[2,4,9]]) 61 | print '我们的数组是：' 62 | print a 63 | print '\n' 64 | print '调用 ptp() 函数：' 65 | print np.ptp(a) 66 | print '\n' 67 | print '沿轴 1 调用 ptp() 函数：' 68 | print np.ptp(a, axis = 1) 69 | print '\n' 70 | print '沿轴 0 调用 ptp() 函数：' 71 | print np.ptp(a, axis = 0) 72 | ``` 73 | 74 | 输出如下： 75 | 76 | ``` 77 | 我们的数组是： 78 | [[3 7 5] 79 | [8 4 3] 80 | [2 4 9]] 81 | 82 | 调用 ptp() 函数： 83 | 7 84 | 85 | 沿轴 1 调用 ptp() 函数： 86 | [4 5 7] 87 | 88 | 沿轴 0 调用 ptp() 函数： 89 | [6 3 6] 90 | 91 | ``` 92 | 93 | ## `numpy.percentile()` 94 | 95 | 百分位数是统计中使用的度量，表示小于这个值得观察值占某个百分比。 函数` numpy.percentile()`接受以下参数。 96 | 97 | ``` 98 | numpy.percentile(a, q, axis) 99 | 100 | ``` 101 | 102 | 其中： 103 | 104 | | 序号 | 参数及描述 | 105 | | --- | --- | 106 | | 1. | `a` 输入数组 | 107 | | 2. | `q` 要计算的百分位数，在 0 ~ 100 之间 | 108 | | 3. | `axis` 沿着它计算百分位数的轴 | 109 | 110 | ### 示例 111 | 112 | ``` 113 | import numpy as np 114 | a = np.array([[30,40,70],[80,20,10],[50,90,60]]) 115 | print '我们的数组是：' 116 | print a 117 | print '\n' 118 | print '调用 percentile() 函数：' 119 | print np.percentile(a,50) 120 | print '\n' 121 | print '沿轴 1 调用 percentile() 函数：' 122 | print np.percentile(a,50, axis = 1) 123 | print '\n' 124 | print '沿轴 0 调用 percentile() 函数：' 125 | print np.percentile(a,50, axis = 0) 126 | ``` 127 | 128 | 输出如下： 129 | 130 | ``` 131 | 我们的数组是： 132 | [[30 40 70] 133 | [80 20 10] 134 | [50 90 60]] 135 | 136 | 调用 percentile() 函数： 137 | 50.0 138 | 139 | 沿轴 1 调用 percentile() 函数： 140 | [ 40. 20. 60.] 141 | 142 | 沿轴 0 调用 percentile() 函数： 143 | [ 50. 40. 60.] 144 | 145 | ``` 146 | 147 | ## `numpy.median()` 148 | 149 | **中值**定义为将数据样本的上半部分与下半部分分开的值。 `numpy.median()`函数的用法如下面的程序所示。 150 | 151 | ### 示例 152 | 153 | ``` 154 | import numpy as np 155 | a = np.array([[30,65,70],[80,95,10],[50,90,60]]) 156 | print '我们的数组是：' 157 | print a 158 | print '\n' 159 | print '调用 median() 函数：' 160 | print np.median(a) 161 | print '\n' 162 | print '沿轴 0 调用 median() 函数：' 163 | print np.median(a, axis = 0) 164 | print '\n' 165 | print '沿轴 1 调用 median() 函数：' 166 | print np.median(a, axis = 1) 167 | ``` 168 | 169 | 输出如下： 170 | 171 | ``` 172 | 我们的数组是： 173 | [[30 65 70] 174 | [80 95 10] 175 | [50 90 60]] 176 | 177 | 调用 median() 函数： 178 | 65.0 179 | 180 | 沿轴 0 调用 median() 函数： 181 | [ 50. 90. 60.] 182 | 183 | 沿轴 1 调用 median() 函数： 184 | [ 65. 80. 60.] 185 | 186 | ``` 187 | 188 | ## `numpy.mean()` 189 | 190 | 算术平均值是沿轴的元素的总和除以元素的数量。 ` numpy.mean()`函数返回数组中元素的算术平均值。 如果提供了轴，则沿其计算。 191 | 192 | ### 示例 193 | 194 | ``` 195 | import numpy as np 196 | a = np.array([[1,2,3],[3,4,5],[4,5,6]]) 197 | print '我们的数组是：' 198 | print a 199 | print '\n' 200 | print '调用 mean() 函数：' 201 | print np.mean(a) 202 | print '\n' 203 | print '沿轴 0 调用 mean() 函数：' 204 | print np.mean(a, axis = 0) 205 | print '\n' 206 | print '沿轴 1 调用 mean() 函数：' 207 | print np.mean(a, axis = 1) 208 | ``` 209 | 210 | 输出如下： 211 | 212 | ``` 213 | 我们的数组是： 214 | [[1 2 3] 215 | [3 4 5] 216 | [4 5 6]] 217 | 218 | 调用 mean() 函数： 219 | 3.66666666667 220 | 221 | 沿轴 0 调用 mean() 函数： 222 | [ 2.66666667 3.66666667 4.66666667] 223 | 224 | 沿轴 1 调用 mean() 函数： 225 | [ 2. 4. 5.] 226 | 227 | ``` 228 | 229 | ## `numpy.average()` 230 | 231 | 加权平均值是由每个分量乘以反映其重要性的因子得到的平均值。 ` numpy.average()`函数根据在另一个数组中给出的各自的权重计算数组中元素的加权平均值。 该函数可以接受一个轴参数。 如果没有指定轴，则数组会被展开。 232 | 233 | 考虑数组`[1,2,3,4]`和相应的权重`[4,3,2,1]`，通过将相应元素的乘积相加，并将和除以权重的和，来计算加权平均值。 234 | 235 | ``` 236 | 加权平均值 = (1*4+2*3+3*2+4*1)/(4+3+2+1) 237 | ``` 238 | 239 | ### 示例 240 | 241 | ``` 242 | import numpy as np 243 | a = np.array([1,2,3,4]) 244 | print '我们的数组是：' 245 | print a 246 | print '\n' 247 | print '调用 average() 函数：' 248 | print np.average(a) 249 | print '\n' 250 | # 不指定权重时相当于 mean 函数 251 | wts = np.array([4,3,2,1]) 252 | print '再次调用 average() 函数：' 253 | print np.average(a,weights = wts) 254 | print '\n' 255 | # 如果 returned 参数设为 true，则返回权重的和 256 | print '权重的和：' 257 | print np.average([1,2,3, 4],weights = [4,3,2,1], returned = True) 258 | ``` 259 | 260 | 输出如下： 261 | 262 | ``` 263 | 我们的数组是： 264 | [1 2 3 4] 265 | 266 | 调用 average() 函数： 267 | 2.5 268 | 269 | 再次调用 average() 函数： 270 | 2.0 271 | 272 | 权重的和： 273 | (2.0, 10.0) 274 | 275 | ``` 276 | 277 | 在多维数组中，可以指定用于计算的轴。 278 | 279 | ### 示例 280 | 281 | ``` 282 | import numpy as np 283 | a = np.arange(6).reshape(3,2) 284 | print '我们的数组是：' 285 | print a 286 | print '\n' 287 | print '修改后的数组：' 288 | wt = np.array([3,5]) 289 | print np.average(a, axis = 1, weights = wt) 290 | print '\n' 291 | print '修改后的数组：' 292 | print np.average(a, axis = 1, weights = wt, returned = True) 293 | ``` 294 | 295 | 输出如下： 296 | 297 | ``` 298 | 我们的数组是： 299 | [[0 1] 300 | [2 3] 301 | [4 5]] 302 | 303 | 修改后的数组： 304 | [ 0.625 2.625 4.625] 305 | 306 | 修改后的数组： 307 | (array([ 0.625, 2.625, 4.625]), array([ 8., 8., 8.])) 308 | 309 | ``` 310 | 311 | ## 标准差 312 | 313 | 标准差是与均值的偏差的平方的平均值的平方根。 标准差公式如下： 314 | ``` 315 | std = sqrt(mean((x - x.mean())**2)) 316 | 317 | ``` 318 | 319 | 如果数组是`[1，2，3，4]`，则其平均值为`2.5`。 因此，差的平方是`[2.25,0.25,0.25,2.25]`，并且其平均值的平方根除以4，即`sqrt(5/4)`是`1.1180339887498949`。 320 | 321 | ### 示例 322 | 323 | ``` 324 | import numpy as np 325 | print np.std([1,2,3,4]) 326 | ``` 327 | 328 | 输出如下： 329 | 330 | ``` 331 | 1.1180339887498949 332 | 333 | ``` 334 | 335 | ## 方差 336 | 337 | 方差是偏差的平方的平均值，即`mean((x - x.mean())** 2)`。 换句话说，标准差是方差的平方根。 338 | 339 | ### 示例 340 | 341 | ``` 342 | import numpy as np 343 | print np.var([1,2,3,4]) 344 | ``` 345 | 346 | 输出如下： 347 | 348 | ``` 349 | 1.25 350 | 351 | ``` 352 | 353 | 354 | -------------------------------------------------------------------------------- /18.md: -------------------------------------------------------------------------------- 1 | 2 | 3 | # NumPy - 排序、搜索和计数函数 4 | 5 | NumPy中提供了各种排序相关功能。 这些排序函数实现不同的排序算法，每个排序算法的特征在于执行速度，最坏情况性能，所需的工作空间和算法的稳定性。 下表显示了三种排序算法的比较。 6 | 7 | | 种类 | 速度 | 最坏情况 | 工作空间 | 稳定性 | 8 | | --- | --- | --- | --- | --- | 9 | | `'quicksort'`（快速排序） | 1 | `O(n^2)` | 0 | 否 | 10 | | `'mergesort'`（归并排序） | 2 | `O(n*log(n))` | ~n/2 | 是 | 11 | | `'heapsort'`（堆排序） | 3 | `O(n*log(n))` | 0 | 否 | 12 | 13 | ## `numpy.sort()` 14 | 15 | `sort()`函数返回输入数组的排序副本。 它有以下参数： 16 | 17 | ``` 18 | numpy.sort(a, axis, kind, order) 19 | 20 | ``` 21 | 22 | 其中： 23 | 24 | | 序号 | 参数及描述 | 25 | | --- | --- | 26 | | 1. | `a` 要排序的数组 | 27 | | 2. | `axis` 沿着它排序数组的轴，如果没有数组会被展开，沿着最后的轴排序 | 28 | | 3. | `kind` 默认为`'quicksort'`（快速排序） | 29 | | 4. | `order` 如果数组包含字段，则是要排序的字段 | 30 | 31 | ### 示例 32 | 33 | ``` 34 | import numpy as np 35 | a = np.array([[3,7],[9,1]]) 36 | print '我们的数组是：' 37 | print a 38 | print '\n' 39 | print '调用 sort() 函数：' 40 | print np.sort(a) 41 | print '\n' 42 | print '沿轴 0 排序：' 43 | print np.sort(a, axis = 0) 44 | print '\n' 45 | # 在 sort 函数中排序字段 46 | dt = np.dtype([('name', 'S10'),('age', int)]) 47 | a = np.array([("raju",21),("anil",25),("ravi", 17), ("amar",27)], dtype = dt) 48 | print '我们的数组是：' 49 | print a 50 | print '\n' 51 | print '按 name 排序：' 52 | print np.sort(a, order = 'name') 53 | ``` 54 | 55 | 输出如下： 56 | 57 | ``` 58 | 我们的数组是： 59 | [[3 7] 60 | [9 1]] 61 | 62 | 调用 sort() 函数： 63 | [[3 7] 64 | [1 9]] 65 | 66 | 沿轴 0 排序： 67 | [[3 1] 68 | [9 7]] 69 | 70 | 我们的数组是： 71 | [('raju', 21) ('anil', 25) ('ravi', 17) ('amar', 27)] 72 | 73 | 按 name 排序： 74 | [('amar', 27) ('anil', 25) ('raju', 21) ('ravi', 17)] 75 | 76 | ``` 77 | 78 | ## `numpy.argsort()` 79 | 80 | `numpy.argsort()`函数对输入数组沿给定轴执行间接排序，并使用指定排序类型返回数据的索引数组。 这个索引数组用于构造排序后的数组。 81 | 82 | ### 示例 83 | 84 | ``` 85 | import numpy as np 86 | x = np.array([3, 1, 2]) 87 | print '我们的数组是：' 88 | print x 89 | print '\n' 90 | print '对 x 调用 argsort() 函数：' 91 | y = np.argsort(x) 92 | print y 93 | print '\n' 94 | print '以排序后的顺序重构原数组：' 95 | print x[y] 96 | print '\n' 97 | print '使用循环重构原数组：' 98 | for i in y: 99 | print x[i], 100 | ``` 101 | 102 | 输出如下： 103 | 104 | ``` 105 | 我们的数组是： 106 | [3 1 2] 107 | 108 | 对 x 调用 argsort() 函数： 109 | [1 2 0] 110 | 111 | 以排序后的顺序重构原数组： 112 | [1 2 3] 113 | 114 | 使用循环重构原数组： 115 | 1 2 3 116 | 117 | ``` 118 | 119 | ## `numpy.lexsort()` 120 | 121 | 函数使用键序列执行间接排序。 键可以看作是电子表格中的一列。 该函数返回一个索引数组，使用它可以获得排序数据。 注意，最后一个键恰好是 sort 的主键。 122 | 123 | ### 示例 124 | 125 | ``` 126 | import numpy as np 127 | 128 | nm = ('raju','anil','ravi','amar') 129 | dv = ('f.y.', 's.y.', 's.y.', 'f.y.') 130 | ind = np.lexsort((dv,nm)) 131 | print '调用 lexsort() 函数：' 132 | print ind 133 | print '\n' 134 | print '使用这个索引来获取排序后的数据：' 135 | print [nm[i] + ", " + dv[i] for i in ind] 136 | ``` 137 | 138 | 输出如下： 139 | 140 | ``` 141 | 调用 lexsort() 函数： 142 | [3 1 0 2] 143 | 144 | 使用这个索引来获取排序后的数据： 145 | ['amar, f.y.', 'anil, s.y.', 'raju, f.y.', 'ravi, s.y.'] 146 | 147 | ``` 148 | 149 | NumPy 模块有一些用于在数组内搜索的函数。 提供了用于找到最大值，最小值以及满足给定条件的元素的函数。 150 | 151 | ## `numpy.argmax()` 和 `numpy.argmin()` 152 | 153 | 这两个函数分别沿给定轴返回最大和最小元素的索引。 154 | 155 | ### 示例 156 | 157 | ``` 158 | import numpy as np 159 | a = np.array([[30,40,70],[80,20,10],[50,90,60]]) 160 | print '我们的数组是：' 161 | print a 162 | print '\n' 163 | print '调用 argmax() 函数：' 164 | print np.argmax(a) 165 | print '\n' 166 | print '展开数组：' 167 | print a.flatten() 168 | print '\n' 169 | print '沿轴 0 的最大值索引：' 170 | maxindex = np.argmax(a, axis = 0) 171 | print maxindex 172 | print '\n' 173 | print '沿轴 1 的最大值索引：' 174 | maxindex = np.argmax(a, axis = 1) 175 | print maxindex 176 | print '\n' 177 | print '调用 argmin() 函数：' 178 | minindex = np.argmin(a) 179 | print minindex 180 | print '\n' 181 | print '展开数组中的最小值：' 182 | print a.flatten()[minindex] 183 | print '\n' 184 | print '沿轴 0 的最小值索引：' 185 | minindex = np.argmin(a, axis = 0) 186 | print minindex 187 | print '\n' 188 | print '沿轴 1 的最小值索引：' 189 | minindex = np.argmin(a, axis = 1) 190 | print minindex 191 | ``` 192 | 193 | 输出如下： 194 | 195 | ``` 196 | 我们的数组是： 197 | [[30 40 70] 198 | [80 20 10] 199 | [50 90 60]] 200 | 201 | 调用 argmax() 函数： 202 | 7 203 | 204 | 展开数组： 205 | [30 40 70 80 20 10 50 90 60] 206 | 207 | 沿轴 0 的最大值索引： 208 | [1 2 0] 209 | 210 | 沿轴 1 的最大值索引： 211 | [2 0 1] 212 | 213 | 调用 argmin() 函数： 214 | 5 215 | 216 | 展开数组中的最小值： 217 | 10 218 | 219 | 沿轴 0 的最小值索引： 220 | [0 1 1] 221 | 222 | 沿轴 1 的最小值索引： 223 | [0 2 0] 224 | 225 | ``` 226 | 227 | ## `numpy.nonzero()` 228 | 229 | `numpy.nonzero()`函数返回输入数组中非零元素的索引。 230 | 231 | ### 示例 232 | 233 | ``` 234 | import numpy as np 235 | a = np.array([[30,40,0],[0,20,10],[50,0,60]]) 236 | print '我们的数组是：' 237 | print a 238 | print '\n' 239 | print '调用 nonzero() 函数：' 240 | print np.nonzero (a) 241 | ``` 242 | 243 | 输出如下： 244 | 245 | ``` 246 | 我们的数组是： 247 | [[30 40 0] 248 | [ 0 20 10] 249 | [50 0 60]] 250 | 251 | 调用 nonzero() 函数： 252 | (array([0, 0, 1, 1, 2, 2]), array([0, 1, 1, 2, 0, 2])) 253 | 254 | ``` 255 | 256 | ## `numpy.where()` 257 | 258 | `where()`函数返回输入数组中满足给定条件的元素的索引。 259 | 260 | ### 示例 261 | 262 | ``` 263 | import numpy as np 264 | x = np.arange(9.).reshape(3, 3) 265 | print '我们的数组是：' 266 | print x 267 | print '大于 3 的元素的索引：' 268 | y = np.where(x > 3) 269 | print y 270 | print '使用这些索引来获取满足条件的元素：' 271 | print x[y] 272 | ``` 273 | 274 | 输出如下： 275 | 276 | ``` 277 | 我们的数组是： 278 | [[ 0. 1. 2.] 279 | [ 3. 4. 5.] 280 | [ 6. 7. 8.]] 281 | 282 | 大于 3 的元素的索引： 283 | (array([1, 1, 2, 2, 2]), array([1, 2, 0, 1, 2])) 284 | 285 | 使用这些索引来获取满足条件的元素： 286 | [ 4. 5. 6. 7. 8.] 287 | 288 | ``` 289 | 290 | ## `numpy.extract()` 291 | 292 | `extract()`函数返回满足任何条件的元素。 293 | 294 | ``` 295 | import numpy as np 296 | x = np.arange(9.).reshape(3, 3) 297 | print '我们的数组是：' 298 | print x 299 | # 定义条件 300 | condition = np.mod(x,2) == 0 301 | print '按元素的条件值：' 302 | print condition 303 | print '使用条件提取元素：' 304 | print np.extract(condition, x) 305 | ``` 306 | 307 | 输出如下： 308 | 309 | ``` 310 | 我们的数组是： 311 | [[ 0. 1. 2.] 312 | [ 3. 4. 5.] 313 | [ 6. 7. 8.]] 314 | 315 | 按元素的条件值： 316 | [[ True False True] 317 | [False True False] 318 | [ True False True]] 319 | 320 | 使用条件提取元素： 321 | [ 0. 2. 4. 6. 8.] 322 | 323 | ``` 324 | 325 | 326 | -------------------------------------------------------------------------------- /19.md: -------------------------------------------------------------------------------- 1 | 2 | 3 | # NumPy - 字节交换 4 | 5 | 我们已经看到，存储在计算机内存中的数据取决于 CPU 使用的架构。 它可以是小端（最小有效位存储在最小地址中）或大端（最小有效字节存储在最大地址中）。 6 | 7 | ## `numpy.ndarray.byteswap()` 8 | 9 | `numpy.ndarray.byteswap()`函数在两个表示：大端和小端之间切换。 10 | 11 | ``` 12 | import numpy as np 13 | a = np.array([1, 256, 8755], dtype = np.int16) 14 | print '我们的数组是：' 15 | print a 16 | print '以十六进制表示内存中的数据：' 17 | print map(hex,a) 18 | # byteswap() 函数通过传入 true 来原地交换 19 | print '调用 byteswap() 函数：' 20 | print a.byteswap(True) 21 | print '十六进制形式：' 22 | print map(hex,a) 23 | # 我们可以看到字节已经交换了 24 | ``` 25 | 26 | 输出如下： 27 | 28 | ``` 29 | 我们的数组是： 30 | [1 256 8755] 31 | 32 | 以十六进制表示内存中的数据： 33 | ['0x1', '0x100', '0x2233'] 34 | 35 | 调用 byteswap() 函数： 36 | [256 1 13090] 37 | 38 | 十六进制形式： 39 | ['0x100', '0x1', '0x3322'] 40 | 41 | ``` 42 | 43 | 44 | -------------------------------------------------------------------------------- /2.md: -------------------------------------------------------------------------------- 1 | 2 | 3 | # NumPy - Ndarray 对象 4 | 5 | NumPy 中定义的最重要的对象是称为 `ndarray` 的 N 维数组类型。 它描述相同类型的元素集合。 可以使用基于零的索引访问集合中的项目。 6 | 7 | `ndarray`中的每个元素在内存中使用相同大小的块。 `ndarray`中的每个元素是数据类型对象的对象（称为 `dtype`）。 8 | 9 | 从`ndarray`对象提取的任何元素（通过切片）由一个数组标量类型的 Python 对象表示。 下图显示了`ndarray`，数据类型对象（`dtype`）和数组标量类型之间的关系。 10 | 11 | ![Ndarray](https://www.tutorialspoint.com//numpy/images/ndarray.jpg) 12 | 13 | `ndarray`类的实例可以通过本教程后面描述的不同的数组创建例程来构造。 基本的`ndarray`是使用 NumPy 中的数组函数创建的，如下所示： 14 | 15 | ``` 16 | numpy.array 17 | 18 | ``` 19 | 20 | 它从任何暴露数组接口的对象，或从返回数组的任何方法创建一个ndarray。 21 | 22 | ``` 23 | numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0) 24 | 25 | ``` 26 | 27 | 上面的构造器接受以下参数： 28 | 29 | | 序号 | 参数及描述 | 30 | | --- | --- | 31 | | 1. | `object` 任何暴露数组接口方法的对象都会返回一个数组或任何（嵌套）序列。 | 32 | | 2. | `dtype` 数组的所需数据类型，可选。 | 33 | | 3. | `copy` 可选，默认为`true`，对象是否被复制。 | 34 | | 4. | `order` `C`（按行）、`F`（按列）或`A`（任意，默认）。 | 35 | | 5. | `subok` 默认情况下，返回的数组被强制为基类数组。 如果为`true`，则返回子类。 | 36 | | 6. | `ndimin` 指定返回数组的最小维数。 | 37 | 38 | 看看下面的例子来更好地理解。 39 | 40 | ## 示例 1 41 | 42 | ``` 43 | import numpy as np 44 | a = np.array([1,2,3]) 45 | print a 46 | ``` 47 | 48 | 输出如下： 49 | 50 | ``` 51 | [1, 2, 3] 52 | 53 | ``` 54 | 55 | ## 示例 2 56 | 57 | ``` 58 | # 多于一个维度 59 | import numpy as np 60 | a = np.array([[1, 2], [3, 4]]) 61 | print a 62 | ``` 63 | 64 | 输出如下： 65 | 66 | ``` 67 | [[1, 2] 68 | [3, 4]] 69 | 70 | ``` 71 | 72 | ## 示例 3 73 | 74 | ``` 75 | # 最小维度 76 | import numpy as np 77 | a = np.array([1, 2, 3,4,5], ndmin = 2) 78 | print a 79 | ``` 80 | 81 | 输出如下： 82 | 83 | ``` 84 | [[1, 2, 3, 4, 5]] 85 | 86 | ``` 87 | 88 | ## 示例 4 89 | 90 | ``` 91 | # dtype 参数 92 | import numpy as np 93 | a = np.array([1, 2, 3], dtype = complex) 94 | print a 95 | ``` 96 | 97 | 输出如下： 98 | 99 | ``` 100 | [ 1.+0.j, 2.+0.j, 3.+0.j] 101 | 102 | ``` 103 | 104 | **ndarray ** 对象由计算机内存中的一维连续区域组成，带有将每个元素映射到内存块中某个位置的索引方案。 内存块以按行（C 风格）或按列（FORTRAN 或 MatLab 风格）的方式保存元素。 105 | 106 | 107 | -------------------------------------------------------------------------------- /20.md: -------------------------------------------------------------------------------- 1 | 2 | 3 | # NumPy - 副本和视图 4 | 5 | 在执行函数时，其中一些返回输入数组的副本，而另一些返回视图。 当内容物理存储在另一个位置时，称为**副本**。 另一方面，如果提供了相同内存内容的不同视图，我们将其称为**视图**。 6 | 7 | ## 无复制 8 | 9 | 简单的赋值不会创建数组对象的副本。 相反，它使用原始数组的相同`id()`来访问它。 `id()`返回 Python 对象的通用标识符，类似于 C 中的指针。 10 | 11 | 此外，一个数组的任何变化都反映在另一个数组上。 例如，一个数组的形状改变也会改变另一个数组的形状。 12 | 13 | ### 示例 14 | 15 | ``` 16 | import numpy as np 17 | a = np.arange(6) 18 | print '我们的数组是：' 19 | print a 20 | print '调用 id() 函数：' 21 | print id(a) 22 | print 'a 赋值给 b：' 23 | b = a 24 | print b 25 | print 'b 拥有相同 id()：' 26 | print id(b) 27 | print '修改 b 的形状：' 28 | b.shape = 3,2 29 | print b 30 | print 'a 的形状也修改了：' 31 | print a 32 | ``` 33 | 34 | 输出如下： 35 | 36 | ``` 37 | 我们的数组是： 38 | [0 1 2 3 4 5] 39 | 40 | 调用 id() 函数： 41 | 139747815479536 42 | 43 | a 赋值给 b： 44 | [0 1 2 3 4 5] 45 | b 拥有相同 id()： 46 | 139747815479536 47 | 48 | 修改 b 的形状： 49 | [[0 1] 50 | [2 3] 51 | [4 5]] 52 | 53 | a 的形状也修改了： 54 | [[0 1] 55 | [2 3] 56 | [4 5]] 57 | 58 | ``` 59 | 60 | ## 视图或浅复制 61 | 62 | NumPy 拥有`ndarray.view()`方法，它是一个新的数组对象，并可查看原始数组的相同数据。 与前一种情况不同，新数组的维数更改不会更改原始数据的维数。 63 | 64 | ### 示例 65 | 66 | ``` 67 | import numpy as np 68 | # 最开始 a 是个 3X2 的数组 69 | a = np.arange(6).reshape(3,2) 70 | print '数组 a：' 71 | print a 72 | print '创建 a 的视图：' 73 | b = a.view() 74 | print b 75 | print '两个数组的 id() 不同：' 76 | print 'a 的 id()：' 77 | print id(a) 78 | print 'b 的 id()：' 79 | print id(b) 80 | # 修改 b 的形状，并不会修改 a 81 | b.shape = 2,3 82 | print 'b 的形状：' 83 | print b 84 | print 'a 的形状：' 85 | print a 86 | ``` 87 | 88 | 输出如下： 89 | 90 | ``` 91 | 数组 a： 92 | [[0 1] 93 | [2 3] 94 | [4 5]] 95 | 96 | 创建 a 的视图： 97 | [[0 1] 98 | [2 3] 99 | [4 5]] 100 | 101 | 两个数组的 id() 不同： 102 | a 的 id()： 103 | 140424307227264 104 | b 的 id()： 105 | 140424151696288 106 | 107 | b 的形状： 108 | [[0 1 2] 109 | [3 4 5]] 110 | 111 | a 的形状： 112 | [[0 1] 113 | [2 3] 114 | [4 5]] 115 | 116 | ``` 117 | 118 | 数组的切片也会创建视图： 119 | 120 | ### 示例 121 | 122 | ``` 123 | import numpy as np 124 | a = np.array([[10,10], [2,3], [4,5]]) 125 | print '我们的数组：' 126 | print a 127 | print '创建切片：' 128 | s = a[:, :2] 129 | print s 130 | ``` 131 | 132 | 输出如下： 133 | 134 | ``` 135 | 我们的数组： 136 | [[10 10] 137 | [ 2 3] 138 | [ 4 5]] 139 | 140 | 创建切片： 141 | [[10 10] 142 | [ 2 3] 143 | [ 4 5]] 144 | 145 | ``` 146 | 147 | ## 深复制 148 | 149 | `ndarray.copy()`函数创建一个深层副本。 它是数组及其数据的完整副本，不与原始数组共享。 150 | 151 | ### 示例 152 | 153 | ``` 154 | import numpy as np 155 | a = np.array([[10,10], [2,3], [4,5]]) 156 | print '数组 a：' 157 | print a 158 | print '创建 a 的深层副本：' 159 | b = a.copy() 160 | print '数组 b：' 161 | print b 162 | # b 与 a 不共享任何内容 163 | print '我们能够写入 b 来写入 a 吗？' 164 | print b is a 165 | print '修改 b 的内容：' 166 | b[0,0] = 100 167 | print '修改后的数组 b：' 168 | print b 169 | print 'a 保持不变：' 170 | print a 171 | ``` 172 | 173 | 输出如下： 174 | 175 | ``` 176 | 数组 a： 177 | [[10 10] 178 | [ 2 3] 179 | [ 4 5]] 180 | 181 | 创建 a 的深层副本： 182 | 数组 b： 183 | [[10 10] 184 | [ 2 3] 185 | [ 4 5]] 186 | 我们能够写入 b 来写入 a 吗？ 187 | False 188 | 189 | 修改 b 的内容： 190 | 修改后的数组 b： 191 | [[100 10] 192 | [ 2 3] 193 | [ 4 5]] 194 | 195 | a 保持不变： 196 | [[10 10] 197 | [ 2 3] 198 | [ 4 5]] 199 | 200 | ``` 201 | 202 | 203 | -------------------------------------------------------------------------------- /21.md: -------------------------------------------------------------------------------- 1 | 2 | 3 | # NumPy - 矩阵库 4 | 5 | NumPy 包包含一个 Matrix库`numpy.matlib`。此模块的函数返回矩阵而不是返回`ndarray`对象。 6 | 7 | 8 | ## `matlib.empty()` 9 | 10 | `matlib.empty()`函数返回一个新的矩阵，而不初始化元素。 该函数接受以下参数。 11 | 12 | ``` 13 | numpy.matlib.empty(shape, dtype, order) 14 | 15 | ``` 16 | 17 | 其中： 18 | 19 | | 序号 | 参数及描述 | 20 | | --- | --- | 21 | | 1. | `shape` 定义新矩阵形状的整数或整数元组 | 22 | | 2. | `Dtype` 可选，输出的数据类型 | 23 | | 3. | `order` `C` 或者 `F` | 24 | 25 | ### 示例 26 | 27 | ``` 28 | import numpy.matlib 29 | import numpy as np 30 | print np.matlib.empty((2,2)) 31 | # 填充为随机数据 32 | ``` 33 | 34 | 输出如下： 35 | 36 | ``` 37 | [[ 2.12199579e-314, 4.24399158e-314] 38 | [ 4.24399158e-314, 2.12199579e-314]] 39 | 40 | ``` 41 | 42 | ## `numpy.matlib.zeros()` 43 | 44 | 此函数返回以零填充的矩阵。 45 | 46 | ``` 47 | import numpy.matlib 48 | import numpy as np 49 | print np.matlib.zeros((2,2)) 50 | ``` 51 | 52 | 输出如下： 53 | 54 | ``` 55 | [[ 0. 0.] 56 | [ 0. 0.]]) 57 | 58 | ``` 59 | 60 | ## `numpy.matlib.ones()` 61 | 62 | 此函数返回以一填充的矩阵。 63 | 64 | ``` 65 | import numpy.matlib 66 | import numpy as np 67 | print np.matlib.ones((2,2)) 68 | ``` 69 | 70 | 输出如下： 71 | 72 | ``` 73 | [[ 1. 1.] 74 | [ 1. 1.]] 75 | 76 | ``` 77 | 78 | ## `numpy.matlib.eye()` 79 | 80 | 这个函数返回一个矩阵，对角线元素为 1，其他位置为零。 该函数接受以下参数。 81 | 82 | ``` 83 | numpy.matlib.eye(n, M,k, dtype) 84 | 85 | ``` 86 | 87 | 其中： 88 | 89 | | 序号 | 参数及描述 | 90 | | --- | --- | 91 | | 1. | `n` 返回矩阵的行数 | 92 | | 2. | `M` 返回矩阵的列数，默认为`n` | 93 | | 3. | `k` 对角线的索引 | 94 | | 4. | `dtype` 输出的数据类型 | 95 | 96 | ### 示例 97 | 98 | ``` 99 | import numpy.matlib 100 | import numpy as np 101 | print np.matlib.eye(n = 3, M = 4, k = 0, dtype = float) 102 | ``` 103 | 104 | 输出如下： 105 | 106 | ``` 107 | [[ 1. 0. 0. 0.] 108 | [ 0. 1. 0. 0.] 109 | [ 0. 0. 1. 0.]]) 110 | 111 | ``` 112 | 113 | ## `numpy.matlib.identity()` 114 | 115 | `numpy.matlib.identity()`函数返回给定大小的单位矩阵。单位矩阵是主对角线元素都为 1 的方阵。 116 | 117 | ``` 118 | import numpy.matlib 119 | import numpy as np 120 | print np.matlib.identity(5, dtype = float) 121 | ``` 122 | 123 | 输出如下： 124 | 125 | ``` 126 | [[ 1. 0. 0. 0. 0.] 127 | [ 0. 1. 0. 0. 0.] 128 | [ 0. 0. 1. 0. 0.] 129 | [ 0. 0. 0. 1. 0.] 130 | [ 0. 0. 0. 0. 1.]] 131 | 132 | ``` 133 | 134 | ## `numpy.matlib.rand()` 135 | 136 | ·numpy.matlib.rand()`函数返回给定大小的填充随机值的矩阵。 137 | 138 | ### 示例 139 | 140 | ``` 141 | import numpy.matlib 142 | import numpy as np 143 | print np.matlib.rand(3,3) 144 | ``` 145 | 146 | 输出如下： 147 | 148 | ``` 149 | [[ 0.82674464 0.57206837 0.15497519] 150 | [ 0.33857374 0.35742401 0.90895076] 151 | [ 0.03968467 0.13962089 0.39665201]] 152 | 153 | ``` 154 | 155 | 注意，矩阵总是二维的，而`ndarray`是一个 n 维数组。 两个对象都是可互换的。 156 | 157 | ### 示例 158 | 159 | ``` 160 | import numpy.matlib 161 | import numpy as np 162 | 163 | i = np.matrix('1,2;3,4') 164 | print i 165 | ``` 166 | 167 | 输出如下： 168 | 169 | ``` 170 | [[1 2] 171 | [3 4]] 172 | 173 | ``` 174 | 175 | ### 示例 176 | 177 | ``` 178 | import numpy.matlib 179 | import numpy as np 180 | 181 | j = np.asarray(i) 182 | print j 183 | ``` 184 | 185 | 输出如下： 186 | 187 | ``` 188 | [[1 2] 189 | [3 4]] 190 | 191 | ``` 192 | 193 | ### 示例 194 | 195 | ``` 196 | import numpy.matlib 197 | import numpy as np 198 | 199 | k = np.asmatrix (j) 200 | print k 201 | ``` 202 | 203 | 输出如下： 204 | 205 | ``` 206 | [[1 2] 207 | [3 4]] 208 | 209 | ``` 210 | 211 | 212 | -------------------------------------------------------------------------------- /22.md: -------------------------------------------------------------------------------- 1 | 2 | 3 | # NumPy - 线性代数 4 | 5 | NumPy 包包含`numpy.linalg`模块，提供线性代数所需的所有功能。 此模块中的一些重要功能如下表所述。 6 | 7 | | 序号 | 函数及描述 | 8 | | --- | --- | 9 | | 1. | `dot` 两个数组的点积 | 10 | | 2. | `vdot` 两个向量的点积 | 11 | | 3. | `inner` 两个数组的内积 | 12 | | 4. | `matmul` 两个数组的矩阵积 | 13 | | 5. | `determinant` 数组的行列式 | 14 | | 6. | `solve` 求解线性矩阵方程 | 15 | | 7. | `inv` 寻找矩阵的乘法逆矩阵 | 16 | 17 | ## `numpy.dot()` 18 | 19 | 此函数返回两个数组的点积。 对于二维向量，其等效于矩阵乘法。 对于一维数组，它是向量的内积。 对于 N 维数组，它是`a`的最后一个轴上的和与`b`的倒数第二个轴的乘积。 20 | 21 | ``` 22 | import numpy.matlib 23 | import numpy as np 24 | 25 | a = np.array([[1,2],[3,4]]) 26 | b = np.array([[11,12],[13,14]]) 27 | np.dot(a,b) 28 | ``` 29 | 30 | 输出如下： 31 | 32 | ``` 33 | [[37 40] 34 | [85 92]] 35 | ``` 36 | 37 | 要注意点积计算为： 38 | 39 | ``` 40 | [[1*11+2*13, 1*12+2*14],[3*11+4*13, 3*12+4*14]] 41 | ``` 42 | 43 | ## `numpy.vdot()` 44 | 45 | 此函数返回两个向量的点积。 如果第一个参数是复数，那么它的共轭复数会用于计算。 如果参数`id`是多维数组，它会被展开。 46 | 47 | 例子 48 | 49 | ``` 50 | import numpy as np 51 | a = np.array([[1,2],[3,4]]) 52 | b = np.array([[11,12],[13,14]]) 53 | print np.vdot(a,b) 54 | ``` 55 | 56 | 输出如下： 57 | 58 | ``` 59 | 130 60 | ``` 61 | 62 | 注意：`1*11 + 2*12 + 3*13 + 4*14 = 130`。 63 | 64 | ## `numpy.inner()` 65 | 66 | 此函数返回一维数组的向量内积。 对于更高的维度，它返回最后一个轴上的和的乘积。 67 | 68 | 例子 69 | 70 | ``` 71 | import numpy as np 72 | print np.inner(np.array([1,2,3]),np.array([0,1,0])) 73 | # 等价于 1*0+2*1+3*0 74 | ``` 75 | 76 | 输出如下： 77 | 78 | ``` 79 | 2 80 | ``` 81 | 82 | 例子 83 | 84 | ``` 85 | # 多维数组示例 86 | import numpy as np 87 | a = np.array([[1,2], [3,4]]) 88 | 89 | print '数组 a：' 90 | print a 91 | b = np.array([[11, 12], [13, 14]]) 92 | 93 | print '数组 b：' 94 | print b 95 | 96 | print '内积：' 97 | print np.inner(a,b) 98 | ``` 99 | 100 | 输出如下： 101 | 102 | ``` 103 | 数组 a： 104 | [[1 2] 105 | [3 4]] 106 | 107 | 数组 b： 108 | [[11 12] 109 | [13 14]] 110 | 111 | 内积： 112 | [[35 41] 113 | [81 95]] 114 | ``` 115 | 116 | 上面的例子中，内积计算如下： 117 | 118 | 119 | ``` 120 | 1*11+2*12, 1*13+2*14 121 | 3*11+4*12, 3*13+4*14 122 | ``` 123 | 124 | ## `numpy.matmul` 125 | 126 | `numpy.matmul()`函数返回两个数组的矩阵乘积。 虽然它返回二维数组的正常乘积，但如果任一参数的维数大于2，则将其视为存在于最后两个索引的矩阵的栈，并进行相应广播。 127 | 128 | 另一方面，如果任一参数是一维数组，则通过在其维度上附加 1 来将其提升为矩阵，并在乘法之后被去除。 129 | 130 | 例子 131 | 132 | ``` 133 | # 对于二维数组，它就是矩阵乘法 134 | import numpy.matlib 135 | import numpy as np 136 | 137 | a = [[1,0],[0,1]] 138 | b = [[4,1],[2,2]] 139 | print np.matmul(a,b) 140 | ``` 141 | 142 | 输出如下： 143 | 144 | ``` 145 | [[4 1] 146 | [2 2]] 147 | ``` 148 | 149 | 例子 150 | 151 | ``` 152 | # 二维和一维运算 153 | import numpy.matlib 154 | import numpy as np 155 | 156 | a = [[1,0],[0,1]] 157 | b = [1,2] 158 | print np.matmul(a,b) 159 | print np.matmul(b,a) 160 | ``` 161 | 162 | 输出如下： 163 | 164 | ``` 165 | [1 2] 166 | [1 2] 167 | ``` 168 | 169 | 例子 170 | 171 | ``` 172 | # 维度大于二的数组 173 | import numpy.matlib 174 | import numpy as np 175 | 176 | a = np.arange(8).reshape(2,2,2) 177 | b = np.arange(4).reshape(2,2) 178 | print np.matmul(a,b) 179 | ``` 180 | 181 | 输出如下： 182 | 183 | ``` 184 | [[[2 3] 185 | [6 11]] 186 | [[10 19] 187 | [14 27]]] 188 | ``` 189 | 190 | ## `numpy.linalg.det()` 191 | 192 | 行列式在线性代数中是非常有用的值。 它从方阵的对角元素计算。 对于 2×2 矩阵，它是左上和右下元素的乘积与其他两个的乘积的差。 193 | 194 | 换句话说，对于矩阵`[[a，b]，[c，d]]`，行列式计算为`ad-bc`。 较大的方阵被认为是 2×2 矩阵的组合。 195 | 196 | `numpy.linalg.det()`函数计算输入矩阵的行列式。 197 | 198 | 例子 199 | 200 | ``` 201 | import numpy as np 202 | a = np.array([[1,2], [3,4]]) 203 | print np.linalg.det(a) 204 | ``` 205 | 206 | 输出如下： 207 | 208 | ``` 209 | -2.0 210 | ``` 211 | 212 | 例子 213 | 214 | ``` 215 | b = np.array([[6,1,1], [4, -2, 5], [2,8,7]]) 216 | print b 217 | print np.linalg.det(b) 218 | print 6*(-2*7 - 5*8) - 1*(4*7 - 5*2) + 1*(4*8 - -2*2) 219 | ``` 220 | 221 | 输出如下： 222 | 223 | ``` 224 | [[ 6 1 1] 225 | [ 4 -2 5] 226 | [ 2 8 7]] 227 | 228 | -306.0 229 | 230 | -306 231 | ``` 232 | 233 | ## `numpy.linalg.solve()` 234 | 235 | `numpy.linalg.solve()`函数给出了矩阵形式的线性方程的解。 236 | 237 | 考虑以下线性方程： 238 | 239 | ``` 240 | x + y + z = 6 241 | 242 | 2y + 5z = -4 243 | 244 | 2x + 5y - z = 27 245 | ``` 246 | 247 | 可以使用矩阵表示为： 248 | 249 | ![](http://upload-images.jianshu.io/upload_images/118142-7ab3daa7f65551e6.jpg) 250 | 251 | 如果矩阵成为`A`、`X`和`B`，方程变为： 252 | 253 | ``` 254 | AX = B 255 | ``` 256 | 257 | 或 258 | 259 | ``` 260 | X = A^(-1)B 261 | ``` 262 | 263 | ## `numpy.linalg.inv()` 264 | 265 | 我们使用`numpy.linalg.inv()`函数来计算矩阵的逆。 矩阵的逆是这样的，如果它乘以原始矩阵，则得到单位矩阵。 266 | 267 | 例子 268 | 269 | ``` 270 | import numpy as np 271 | 272 | x = np.array([[1,2],[3,4]]) 273 | y = np.linalg.inv(x) 274 | print x 275 | print y 276 | print np.dot(x,y) 277 | ``` 278 | 279 | 输出如下： 280 | 281 | ``` 282 | [[1 2] 283 | [3 4]] 284 | [[-2. 1. ] 285 | [ 1.5 -0.5]] 286 | [[ 1.00000000e+00 1.11022302e-16] 287 | [ 0.00000000e+00 1.00000000e+00]] 288 | ``` 289 | 290 | 例子 291 | 292 | 现在让我们在示例中创建一个矩阵A的逆。 293 | 294 | ``` 295 | import numpy as np 296 | a = np.array([[1,1,1],[0,2,5],[2,5,-1]]) 297 | 298 | print '数组 a：' 299 | print a 300 | ainv = np.linalg.inv(a) 301 | 302 | print 'a 的逆：' 303 | print ainv 304 | 305 | print '矩阵 b：' 306 | b = np.array([[6],[-4],[27]]) 307 | print b 308 | 309 | print '计算：A^(-1)B：' 310 | x = np.linalg.solve(a,b) 311 | print x 312 | # 这就是线性方向 x = 5, y = 3, z = -2 的解 313 | ``` 314 | 315 | 输出如下： 316 | 317 | ``` 318 | 数组 a： 319 | [[ 1 1 1] 320 | [ 0 2 5] 321 | [ 2 5 -1]] 322 | 323 | a 的逆： 324 | [[ 1.28571429 -0.28571429 -0.14285714] 325 | [-0.47619048 0.14285714 0.23809524] 326 | [ 0.19047619 0.14285714 -0.0952381 ]] 327 | 328 | 矩阵 b： 329 | [[ 6] 330 | [-4] 331 | [27]] 332 | 333 | 计算：A^(-1)B： 334 | [[ 5.] 335 | [ 3.] 336 | [-2.]] 337 | ``` 338 | 339 | 结果也可以使用下列函数获取 340 | 341 | ``` 342 | x = np.dot(ainv,b) 343 | ``` 344 | 345 | 346 | 347 | -------------------------------------------------------------------------------- /23.md: -------------------------------------------------------------------------------- 1 | 2 | 3 | # NumPy - Matplotlib 4 | 5 | Matplotlib 是 Python 的绘图库。 它可与 NumPy 一起使用，提供了一种有效的 MatLab 开源替代方案。 它也可以和图形工具包一起使用，如 PyQt 和 wxPython。 6 | 7 | Matplotlib 模块最初是由 John D. Hunter 编写的。 自 2012 年以来，Michael Droettboom 是主要开发者。 目前，Matplotlib 1.5.1 是可用的稳定版本。 该软件包可以二进制分发，其源代码形式在 [www.matplotlib.org](http://www.matplotlib.org) 上提供。 8 | 9 | 通常，通过添加以下语句将包导入到 Python 脚本中： 10 | 11 | ``` 12 | from matplotlib import pyplot as plt 13 | 14 | ``` 15 | 16 | 这里`pyplot()`是 matplotlib 库中最重要的函数，用于绘制 2D 数据。 以下脚本绘制方程`y = 2x + 5`： 17 | 18 | 19 | 20 | ### 示例 21 | 22 | ``` 23 | import numpy as np 24 | from matplotlib import pyplot as plt 25 | 26 | x = np.arange(1,11) 27 | y = 2 * x + 5 28 | plt.title("Matplotlib demo") 29 | plt.xlabel("x axis caption") 30 | plt.ylabel("y axis caption") 31 | plt.plot(x,y) plt.show() 32 | ``` 33 | 34 | `ndarray`对象`x`由`np.arange()`函数创建为`x`轴上的值。`y`轴上的对应值存储在另一个数组对象`y`中。 这些值使用`matplotlib`软件包的`pyplot`子模块的`plot()`函数绘制。 35 | 36 | 图形由`show()`函数展示。 37 | 38 | 上面的代码应该产生以下输出： 39 | 40 | ![Matplotlib Demo](https://www.tutorialspoint.com//numpy/images/matplotlib_demo.jpg) 41 | 42 | 作为线性图的替代，可以通过向`plot()`函数添加格式字符串来显示离散值。 可以使用以下格式化字符。 43 | 44 | | 字符 | 描述 | 45 | | --- | --- | 46 | | `'-'` | 实线样式 | 47 | | `'--'` | 短横线样式 | 48 | | `'-.'` | 点划线样式 | 49 | | `':'` | 虚线样式 | 50 | | `'.'` | 点标记 | 51 | | `','` | 像素标记 | 52 | | `'o'` | 圆标记 | 53 | | `'v'` | 倒三角标记 | 54 | | `'^'` | 正三角标记 | 55 | | `'<'` | 左三角标记 | 56 | | `'>'` | 右三角标记 | 57 | | `'1'` | 下箭头标记 | 58 | | `'2'` | 上箭头标记 | 59 | | `'3'` | 左箭头标记 | 60 | | `'4'` | 右箭头标记 | 61 | | `'s'` | 正方形标记 | 62 | | `'p'` | 五边形标记 | 63 | | `'*'` | 星形标记 | 64 | | `'h'` | 六边形标记 1 | 65 | | `'H'` | 六边形标记 2 | 66 | | `'+'` | 加号标记 | 67 | | `'x'` | X 标记 | 68 | | `'D'` | 菱形标记 | 69 | | `'d'` | 窄菱形标记 | 70 | | `'|'` | 竖直线标记 | 71 | | `'_'` | 水平线标记 | 72 | 73 | 还定义了以下颜色缩写。 74 | 75 | | 字符 | 颜色 | 76 | | --- | --- | 77 | | `'b'` | 蓝色 | 78 | | `'g'` | 绿色 | 79 | | `'r'` | 红色 | 80 | | `'c'` | 青色 | 81 | | `'m'` | 品红色 | 82 | | `'y'` | 黄色 | 83 | | `'k'` | 黑色 | 84 | | `'w'` | 白色 | 85 | 86 | 要显示圆来代表点，而不是上面示例中的线，请使用`ob`作为`plot()`函数中的格式字符串。 87 | 88 | ### 示例 89 | 90 | ``` 91 | import numpy as np 92 | from matplotlib import pyplot as plt 93 | 94 | x = np.arange(1,11) 95 | y = 2 * x + 5 96 | plt.title("Matplotlib demo") 97 | plt.xlabel("x axis caption") 98 | plt.ylabel("y axis caption") 99 | plt.plot(x,y,"ob") 100 | plt.show() 101 | ``` 102 | 103 | 上面的代码应该产生以下输出： 104 | 105 | ![Color Abbreviation](https://www.tutorialspoint.com//numpy/images/color_abbreviation.jpg) 106 | 107 | ## 绘制正弦波 108 | 109 | 以下脚本使用 matplotlib 生成**正弦波图**。 110 | 111 | ### 示例 112 | 113 | ``` 114 | import numpy as np 115 | import matplotlib.pyplot as plt 116 | # 计算正弦曲线上点的 x 和 y 坐标 117 | x = np.arange(0, 3 * np.pi, 0.1) 118 | y = np.sin(x) 119 | plt.title("sine wave form") 120 | # 使用 matplotlib 来绘制点 121 | plt.plot(x, y) 122 | plt.show() 123 | ``` 124 | 125 | ![Sine Wave](https://www.tutorialspoint.com//numpy/images/sine_wave.jpg) 126 | 127 | ## `subplot()` 128 | 129 | `subplot()`函数允许你在同一图中绘制不同的东西。 在下面的脚本中，绘制**正弦**和**余弦**值。 130 | 131 | ### 示例 132 | 133 | ``` 134 | import numpy as np 135 | import matplotlib.pyplot as plt 136 | # 计算正弦和余弦曲线上的点的 x 和 y 坐标 137 | x = np.arange(0, 3 * np.pi, 0.1) 138 | y_sin = np.sin(x) 139 | y_cos = np.cos(x) 140 | # 建立 subplot 网格，高为 2，宽为 1 141 | # 激活第一个 subplot 142 | plt.subplot(2, 1, 1) 143 | # 绘制第一个图像 144 | plt.plot(x, y_sin) 145 | plt.title('Sine') 146 | # 将第二个 subplot 激活，并绘制第二个图像 147 | plt.subplot(2, 1, 2) 148 | plt.plot(x, y_cos) 149 | plt.title('Cosine') 150 | # 展示图像 151 | plt.show() 152 | ``` 153 | 154 | 上面的代码应该产生以下输出： 155 | 156 | ![Sub Plot](https://www.tutorialspoint.com//numpy/images/sub_plot.jpg) 157 | 158 | ## `bar()` 159 | 160 | `pyplot`子模块提供`bar()`函数来生成条形图。 以下示例生成两组`x`和`y`数组的条形图。 161 | 162 | ### 示例 163 | 164 | ``` 165 | from matplotlib import pyplot as plt 166 | x = [5,8,10] 167 | y = [12,16,6] 168 | x2 = [6,9,11] 169 | y2 = [6,15,7] 170 | plt.bar(x, y, align = 'center') 171 | plt.bar(x2, y2, color = 'g', align = 'center') 172 | plt.title('Bar graph') 173 | plt.ylabel('Y axis') 174 | plt.xlabel('X axis') 175 | plt.show() 176 | ``` 177 | 178 | 179 | -------------------------------------------------------------------------------- /24.md: -------------------------------------------------------------------------------- 1 | 2 | 3 | # NumPy - 使用 Matplotlib 绘制直方图 4 | 5 | NumPy 有一个`numpy.histogram()`函数，它是数据的频率分布的图形表示。 水平尺寸相等的矩形对应于类间隔，称为`bin`，变量`height`对应于频率。 6 | 7 | ## `numpy.histogram()` 8 | 9 | `numpy.histogram()`函数将输入数组和`bin`作为两个参数。 `bin`数组中的连续元素用作每个`bin`的边界。 10 | 11 | ``` 12 | import numpy as np 13 | 14 | a = np.array([22,87,5,43,56,73,55,54,11,20,51,5,79,31,27]) ] 15 | np.histogram(a,bins = [0,20,40,60,80,100]) 16 | hist,bins = np.histogram(a,bins = [0,20,40,60,80,100]) 17 | print hist 18 | print bins 19 | ``` 20 | 21 | 输出如下： 22 | 23 | ``` 24 | [3 4 5 2 1] 25 | [0 20 40 60 80 100] 26 | 27 | ``` 28 | 29 | ## `plt()` 30 | 31 | Matplotlib 可以将直方图的数字表示转换为图形。 `pyplot`子模块的`plt()`函数将包含数据和`bin`数组的数组作为参数，并转换为直方图。 32 | 33 | ``` 34 | from matplotlib import pyplot as plt 35 | import numpy as np 36 | 37 | a = np.array([22,87,5,43,56,73,55,54,11,20,51,5,79,31,27]) 38 | plt.hist(a, bins = [0,20,40,60,80,100]) 39 | plt.title("histogram") 40 | plt.show() 41 | ``` 42 | 43 | 输出如下： 44 | 45 | 46 | ![Histogram Plot](https://www.tutorialspoint.com//numpy/images/histogram_plot.jpg) 47 | -------------------------------------------------------------------------------- /25.md: -------------------------------------------------------------------------------- 1 | 2 | 3 | # NumPy - IO 4 | 5 | `ndarray`对象可以保存到磁盘文件并从磁盘文件加载。 可用的 IO 功能有： 6 | 7 | * `load()`和`save()`函数处理 numPy 二进制文件（带`npy`扩展名） 8 | 9 | * `loadtxt()`和`savetxt()`函数处理正常的文本文件 10 | 11 | NumPy 为`ndarray`对象引入了一个简单的文件格式。 这个`npy`文件在磁盘文件中，存储重建`ndarray`所需的数据、图形、`dtype`和其他信息，以便正确获取数组，即使该文件在具有不同架构的另一台机器上。 12 | 13 | ## `numpy.save()` 14 | 15 | `numpy.save()`文件将输入数组存储在具有`npy`扩展名的磁盘文件中。 16 | 17 | ``` 18 | import numpy as np 19 | a = np.array([1,2,3,4,5]) 20 | np.save('outfile',a) 21 | ``` 22 | 23 | 为了从`outfile.npy`重建数组，请使用`load()`函数。 24 | 25 | ``` 26 | import numpy as np 27 | b = np.load('outfile.npy') 28 | print b 29 | ``` 30 | 31 | 输出如下： 32 | 33 | ``` 34 | array([1, 2, 3, 4, 5]) 35 | 36 | ``` 37 | 38 | `save()`和`load()`函数接受一个附加的布尔参数`allow_pickles`。 Python 中的`pickle`用于在保存到磁盘文件或从磁盘文件读取之前，对对象进行序列化和反序列化。 39 | 40 | ## `savetxt()` 41 | 42 | 以简单文本文件格式存储和获取数组数据，是通过`savetxt()`和`loadtx()`函数完成的。 43 | 44 | ### 示例 45 | 46 | ``` 47 | import numpy as np 48 | 49 | a = np.array([1,2,3,4,5]) 50 | np.savetxt('out.txt',a) 51 | b = np.loadtxt('out.txt') 52 | print b 53 | ``` 54 | 55 | 输出如下： 56 | 57 | ``` 58 | [ 1. 2. 3. 4. 5.] 59 | 60 | ``` 61 | 62 | `savetxt()`和`loadtxt()`数接受附加的可选参数，例如页首，页尾和分隔符。 63 | 64 | -------------------------------------------------------------------------------- /26.md: -------------------------------------------------------------------------------- 1 | 2 | 3 | # NumPy - 实用资源 4 | 5 | 以下资源包含有关 NumPy 的其他信息。 请使用它们获得更多的深入知识。 6 | 7 | + [试验性 Numpy 教程](http://reverland.org/python/2012/08/22/numpy) 8 | + [100 numpy exercises](http://www.labri.fr/perso/nrougier/teaching/numpy.100/) 9 | + [From Python to Numpy](http://www.labri.fr/perso/nrougier/from-python-to-numpy/) 10 | + [Matplotlib 教程](http://liam0205.me/2014/09/11/matplotlib-tutorial-zh-cn/) 11 | -------------------------------------------------------------------------------- /3.md: -------------------------------------------------------------------------------- 1 | 2 | 3 | # NumPy - 数据类型 4 | 5 | NumPy 支持比 Python 更多种类的数值类型。 下表显示了 NumPy 中定义的不同标量数据类型。 6 | 7 | | 序号 | 数据类型及描述 | 8 | | --- | --- | 9 | | 1. | `bool_` 存储为一个字节的布尔值（真或假） | 10 | | 2. | `int_` 默认整数，相当于 C 的`long`，通常为`int32`或`int64` | 11 | | 3. | `intc` 相当于 C 的`int`，通常为`int32`或`int64` | 12 | | 4. | `intp` 用于索引的整数，相当于 C 的`size_t`，通常为`int32`或`int64` | 13 | | 5. | `int8` 字节（-128 ~ 127） | 14 | | 6. | `int16` 16 位整数（-32768 ~ 32767） | 15 | | 7. | `int32` 32 位整数（-2147483648 ~ 2147483647） | 16 | | 8. | `int64` 64 位整数（-9223372036854775808 ~ 9223372036854775807） | 17 | | 9. | `uint8` 8 位无符号整数（0 ~ 255） | 18 | | 10. | `uint16` 16 位无符号整数（0 ~ 65535） | 19 | | 11. | `uint32` 32 位无符号整数（0 ~ 4294967295） | 20 | | 12. | `uint64` 64 位无符号整数（0 ~ 18446744073709551615） | 21 | | 13. | `float_` `float64`的简写 | 22 | | 14. | `float16` 半精度浮点：符号位，5 位指数，10 位尾数 | 23 | | 15. | `float32` 单精度浮点：符号位，8 位指数，23 位尾数 | 24 | | 16. | `float64` 双精度浮点：符号位，11 位指数，52 位尾数 | 25 | | 17. | `complex_` `complex128`的简写 | 26 | | 18. | `complex64` 复数，由两个 32 位浮点表示（实部和虚部） | 27 | | 19. | `complex128` 复数，由两个 64 位浮点表示（实部和虚部） | 28 | 29 | NumPy 数字类型是`dtype`（数据类型）对象的实例，每个对象具有唯一的特征。 这些类型可以是`np.bool_`，`np.float32`等。 30 | 31 | ## 数据类型对象 (`dtype`) 32 | 33 | 数据类型对象描述了对应于数组的固定内存块的解释，取决于以下方面： 34 | 35 | * 数据类型（整数、浮点或者 Python 对象） 36 | 37 | * 数据大小 38 | 39 | * 字节序（小端或大端） 40 | 41 | * 在结构化类型的情况下，字段的名称，每个字段的数据类型，和每个字段占用的内存块部分。 42 | 43 | * 如果数据类型是子序列，它的形状和数据类型。 44 | 45 | 字节顺序取决于数据类型的前缀`<`或`>`。 `<`意味着编码是小端（最小有效字节存储在最小地址中）。 `>`意味着编码是大端（最大有效字节存储在最小地址中）。 46 | 47 | `dtype`可由一下语法构造： 48 | 49 | ``` 50 | numpy.dtype(object, align, copy) 51 | 52 | ``` 53 | 54 | 参数为： 55 | 56 | * `Object`：被转换为数据类型的对象。 57 | 58 | * `Align`：如果为`true`，则向字段添加间隔，使其类似 C 的结构体。 59 | 60 | * `Copy` ? 生成`dtype`对象的新副本，如果为`flase`，结果是内建数据类型对象的引用。 61 | 62 | ### 示例 1 63 | 64 | ``` 65 | # 使用数组标量类型 66 | import numpy as np 67 | dt = np.dtype(np.int32) 68 | print dt 69 | ``` 70 | 71 | 输出如下： 72 | 73 | ``` 74 | int32 75 | 76 | ``` 77 | 78 | ### 示例 2 79 | 80 | ``` 81 | #int8，int16，int32，int64 可替换为等价的字符串 'i1'，'i2'，'i4'，以及其他。 82 | import numpy as np 83 | 84 | dt = np.dtype('i4') 85 | print dt 86 | ``` 87 | 88 | 输出如下： 89 | 90 | ``` 91 | int32 92 | 93 | ``` 94 | 95 | ### 示例 3 96 | 97 | ``` 98 | # 使用端记号 99 | import numpy as np 100 | dt = np.dtype('>i4') 101 | print dt 102 | ``` 103 | 104 | 输出如下： 105 | 106 | ``` 107 | >i4 108 | 109 | ``` 110 | 111 | 下面的例子展示了结构化数据类型的使用。 这里声明了字段名称和相应的标量数据类型。 112 | 113 | ### 示例 4 114 | 115 | ``` 116 | # 首先创建结构化数据类型。 117 | import numpy as np 118 | dt = np.dtype([('age',np.int8)]) 119 | print dt 120 | ``` 121 | 122 | 输出如下： 123 | 124 | ``` 125 | [('age', 'i1')] 126 | 127 | ``` 128 | 129 | ### 示例 5 130 | 131 | ``` 132 | # 现在将其应用于 ndarray 对象 133 | import numpy as np 134 | 135 | dt = np.dtype([('age',np.int8)]) 136 | a = np.array([(10,),(20,),(30,)], dtype = dt) 137 | print a 138 | ``` 139 | 140 | 输出如下： 141 | 142 | ``` 143 | [(10,) (20,) (30,)] 144 | 145 | ``` 146 | 147 | ### 示例 6 148 | 149 | ``` 150 | # 文件名称可用于访问 age 列的内容 151 | import numpy as np 152 | 153 | dt = np.dtype([('age',np.int8)]) 154 | a = np.array([(10,),(20,),(30,)], dtype = dt) 155 | print a['age'] 156 | ``` 157 | 158 | 输出如下： 159 | 160 | ``` 161 | [10 20 30] 162 | 163 | ``` 164 | 165 | ### 示例 7 166 | 167 | 以下示例定义名为 **student** 的结构化数据类型，其中包含字符串字段`name`，**整数字段**`age`和**浮点字段**`marks`。 此`dtype`应用于`ndarray`对象。 168 | 169 | ``` 170 | import numpy as np 171 | student = np.dtype([('name','S20'), ('age', 'i1'), ('marks', 'f4')]) 172 | print student 173 | ``` 174 | 175 | 输出如下： 176 | 177 | ``` 178 | [('name', 'S20'), ('age', 'i1'), ('marks', ' 5] 128 | ``` 129 | 130 | 输出如下： 131 | 132 | ``` 133 | 我们的数组是： 134 | [[ 0 1 2] 135 | [ 3 4 5] 136 | [ 6 7 8] 137 | [ 9 10 11]] 138 | 139 | 大于 5 的元素是： 140 | [ 6 7 8 9 10 11] 141 | 142 | ``` 143 | 144 | ### 示例 2 145 | 146 | 这个例子使用了`~`（取补运算符）来过滤`NaN`。 147 | 148 | ``` 149 | import numpy as np 150 | a = np.array([np.nan, 1,2,np.nan,3,4,5]) 151 | print a[~np.isnan(a)] 152 | ``` 153 | 154 | 输出如下： 155 | 156 | ``` 157 | [ 1. 2. 3. 4. 5.] 158 | 159 | ``` 160 | 161 | ### 示例 3 162 | 163 | 以下示例显示如何从数组中过滤掉非复数元素。 164 | 165 | ``` 166 | import numpy as np 167 | a = np.array([1, 2+6j, 5, 3.5+5j]) 168 | print a[np.iscomplex(a)] 169 | ``` 170 | 171 | 输出如下： 172 | 173 | ``` 174 | [2.0+6.j 3.5+5.j] 175 | 176 | ``` 177 | 178 | 179 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # TutorialsPoint NumPy 教程 2 | 3 | > 来源：[NumPy Tutorial - TutorialsPoint](https://www.tutorialspoint.com/numpy/index.htm) 4 | 5 | > 译者：[飞龙](https://github.com/) 6 | 7 | > 协议：[CC BY-NC-SA 4.0](http://creativecommons.org/licenses/by-nc-sa/4.0/) 8 | 9 | + [在线阅读](https://www.gitbook.com/book/wizardforcel/ts-numpy-tut/details) 10 | + [PDF格式](https://www.gitbook.com/download/pdf/book/wizardforcel/ts-numpy-tut) 11 | + [EPUB格式](https://www.gitbook.com/download/epub/book/wizardforcel/ts-numpy-tut) 12 | + [MOBI格式](https://www.gitbook.com/download/mobi/book/wizardforcel/ts-numpy-tut) 13 | + [代码仓库](https://github.com/wizardforcel/ts-numpy-tut-zh) 14 | 15 | ## 赞助我 16 | 17 | ![](http://upload-images.jianshu.io/upload_images/118142-fe132ca3591a3d52.png) -------------------------------------------------------------------------------- /SUMMARY.md: -------------------------------------------------------------------------------- 1 | + [TutorialsPoint NumPy 教程](README.md) 2 | + [NumPy - 简介](0.md) 3 | + [NumPy - 环境](1.md) 4 | + [NumPy - Ndarray 对象](2.md) 5 | + [NumPy - 数据类型](3.md) 6 | + [NumPy - 数组属性](4.md) 7 | + [NumPy - 数组创建例程](5.md) 8 | + [NumPy - 来自现有数据的数组](6.md) 9 | + [NumPy - 来自数值范围的数组](7.md) 10 | + [NumPy - 切片和索引](8.md) 11 | + [NumPy - 高级索引](9.md) 12 | + [NumPy - 广播](10.md) 13 | + [NumPy - 数组上的迭代](11.md) 14 | + [NumPy - 数组操作](12.md) 15 | + [NumPy - 位操作](13.md) 16 | + [NumPy - 字符串函数](14.md) 17 | + [NumPy - 算数函数](15.md) 18 | + [NumPy - 算数运算](16.md) 19 | + [NumPy - 统计函数](17.md) 20 | + [NumPy - 排序、搜索和计数函数](18.md) 21 | + [NumPy - 字节交换](19.md) 22 | + [NumPy - 副本和视图](20.md) 23 | + [NumPy - 矩阵库](21.md) 24 | + [NumPy - 线性代数](22.md) 25 | + [NumPy - Matplotlib](23.md) 26 | + [NumPy - 使用 Matplotlib 绘制直方图](24.md) 27 | + [NumPy - IO](25.md) 28 | + [NumPy - 实用资源](26.md) 29 | -------------------------------------------------------------------------------- /styles/ebook.css: -------------------------------------------------------------------------------- 1 | /* GitHub stylesheet for MarkdownPad (http://markdownpad.com) */ 2 | /* Author: Nicolas Hery - http://nicolashery.com */ 3 | /* Version: b13fe65ca28d2e568c6ed5d7f06581183df8f2ff */ 4 | /* Source: https://github.com/nicolahery/markdownpad-github */ 5 | 6 | /* RESET 7 | =============================================================================*/ 8 | 9 | html, body, div, span, applet, object, iframe, h1, h2, h3, h4, h5, h6, p, blockquote, pre, a, abbr, acronym, address, big, cite, code, del, dfn, em, img, ins, kbd, q, s, samp, small, strike, strong, sub, sup, tt, var, b, u, i, center, dl, dt, dd, ol, ul, li, fieldset, form, label, legend, table, caption, tbody, tfoot, thead, tr, th, td, article, aside, canvas, details, embed, figure, figcaption, footer, header, hgroup, menu, nav, output, ruby, section, summary, time, mark, audio, video { 10 | margin: 0; 11 | padding: 0; 12 | border: 0; 13 | } 14 | 15 | /* BODY 16 | =============================================================================*/ 17 | 18 | body { 19 | font-family: Helvetica, arial, freesans, clean, sans-serif; 20 | font-size: 14px; 21 | line-height: 1.6; 22 | color: #333; 23 | background-color: #fff; 24 | padding: 20px; 25 | max-width: 960px; 26 | margin: 0 auto; 27 | } 28 | 29 | body>*:first-child { 30 | margin-top: 0 !important; 31 | } 32 | 33 | body>*:last-child { 34 | margin-bottom: 0 !important; 35 | } 36 | 37 | /* BLOCKS 38 | =============================================================================*/ 39 | 40 | p, blockquote, ul, ol, dl, table, pre { 41 | margin: 15px 0; 42 | } 43 | 44 | /* HEADERS 45 | =============================================================================*/ 46 | 47 | h1, h2, h3, h4, h5, h6 { 48 | margin: 20px 0 10px; 49 | padding: 0; 50 | font-weight: bold; 51 | -webkit-font-smoothing: antialiased; 52 | } 53 | 54 | h1 tt, h1 code, h2 tt, h2 code, h3 tt, h3 code, h4 tt, h4 code, h5 tt, h5 code, h6 tt, h6 code { 55 | font-size: inherit; 56 | } 57 | 58 | h1 { 59 | font-size: 24px; 60 | border-bottom: 1px solid #ccc; 61 | color: #000; 62 | } 63 | 64 | h2 { 65 | font-size: 18px; 66 | color: #000; 67 | } 68 | 69 | h3 { 70 | font-size: 14px; 71 | } 72 | 73 | h4 { 74 | font-size: 14px; 75 | } 76 | 77 | h5 { 78 | font-size: 14px; 79 | } 80 | 81 | h6 { 82 | color: #777; 83 | font-size: 14px; 84 | } 85 | 86 | body>h2:first-child, body>h1:first-child, body>h1:first-child+h2, body>h3:first-child, body>h4:first-child, body>h5:first-child, body>h6:first-child { 87 | margin-top: 0; 88 | padding-top: 0; 89 | } 90 | 91 | a:first-child h1, a:first-child h2, a:first-child h3, a:first-child h4, a:first-child h5, a:first-child h6 { 92 | margin-top: 0; 93 | padding-top: 0; 94 | } 95 | 96 | h1+p, h2+p, h3+p, h4+p, h5+p, h6+p { 97 | margin-top: 10px; 98 | } 99 | 100 | /* LINKS 101 | =============================================================================*/ 102 | 103 | a { 104 | color: #4183C4; 105 | text-decoration: none; 106 | } 107 | 108 | a:hover { 109 | text-decoration: underline; 110 | } 111 | 112 | /* LISTS 113 | =============================================================================*/ 114 | 115 | ul, ol { 116 | padding-left: 30px; 117 | } 118 | 119 | ul li > :first-child, 120 | ol li > :first-child, 121 | ul li ul:first-of-type, 122 | ol li ol:first-of-type, 123 | ul li ol:first-of-type, 124 | ol li ul:first-of-type { 125 | margin-top: 0px; 126 | } 127 | 128 | ul ul, ul ol, ol ol, ol ul { 129 | margin-bottom: 0; 130 | } 131 | 132 | dl { 133 | padding: 0; 134 | } 135 | 136 | dl dt { 137 | font-size: 14px; 138 | font-weight: bold; 139 | font-style: italic; 140 | padding: 0; 141 | margin: 15px 0 5px; 142 | } 143 | 144 | dl dt:first-child { 145 | padding: 0; 146 | } 147 | 148 | dl dt>:first-child { 149 | margin-top: 0px; 150 | } 151 | 152 | dl dt>:last-child { 153 | margin-bottom: 0px; 154 | } 155 | 156 | dl dd { 157 | margin: 0 0 15px; 158 | padding: 0 15px; 159 | } 160 | 161 | dl dd>:first-child { 162 | margin-top: 0px; 163 | } 164 | 165 | dl dd>:last-child { 166 | margin-bottom: 0px; 167 | } 168 | 169 | /* CODE 170 | =============================================================================*/ 171 | 172 | pre, code, tt { 173 | font-size: 12px; 174 | font-family: Consolas, "Liberation Mono", Courier, monospace; 175 | } 176 | 177 | code, tt { 178 | margin: 0 0px; 179 | padding: 0px 0px; 180 | white-space: nowrap; 181 | border: 1px solid #eaeaea; 182 | background-color: #f8f8f8; 183 | border-radius: 3px; 184 | } 185 | 186 | pre>code { 187 | margin: 0; 188 | padding: 0; 189 | white-space: pre; 190 | border: none; 191 | background: transparent; 192 | } 193 | 194 | pre { 195 | background-color: #f8f8f8; 196 | border: 1px solid #ccc; 197 | font-size: 13px; 198 | line-height: 19px; 199 | overflow: auto; 200 | padding: 6px 10px; 201 | border-radius: 3px; 202 | } 203 | 204 | pre code, pre tt { 205 | background-color: transparent; 206 | border: none; 207 | } 208 | 209 | kbd { 210 | -moz-border-bottom-colors: none; 211 | -moz-border-left-colors: none; 212 | -moz-border-right-colors: none; 213 | -moz-border-top-colors: none; 214 | background-color: #DDDDDD; 215 | background-image: linear-gradient(#F1F1F1, #DDDDDD); 216 | background-repeat: repeat-x; 217 | border-color: #DDDDDD #CCCCCC #CCCCCC #DDDDDD; 218 | border-image: none; 219 | border-radius: 2px 2px 2px 2px; 220 | border-style: solid; 221 | border-width: 1px; 222 | font-family: "Helvetica Neue",Helvetica,Arial,sans-serif; 223 | line-height: 10px; 224 | padding: 1px 4px; 225 | } 226 | 227 | /* QUOTES 228 | =============================================================================*/ 229 | 230 | blockquote { 231 | border-left: 4px solid #DDD; 232 | padding: 0 15px; 233 | color: #777; 234 | } 235 | 236 | blockquote>:first-child { 237 | margin-top: 0px; 238 | } 239 | 240 | blockquote>:last-child { 241 | margin-bottom: 0px; 242 | } 243 | 244 | /* HORIZONTAL RULES 245 | =============================================================================*/ 246 | 247 | hr { 248 | clear: both; 249 | margin: 15px 0; 250 | height: 0px; 251 | overflow: hidden; 252 | border: none; 253 | background: transparent; 254 | border-bottom: 4px solid #ddd; 255 | padding: 0; 256 | } 257 | 258 | /* TABLES 259 | =============================================================================*/ 260 | 261 | table th { 262 | font-weight: bold; 263 | } 264 | 265 | table th, table td { 266 | border: 1px solid #ccc; 267 | padding: 6px 13px; 268 | } 269 | 270 | table tr { 271 | border-top: 1px solid #ccc; 272 | background-color: #fff; 273 | } 274 | 275 | table tr:nth-child(2n) { 276 | background-color: #f8f8f8; 277 | } 278 | 279 | /* IMAGES 280 | =============================================================================*/ 281 | 282 | img { 283 | max-width: 100% 284 | } --------------------------------------------------------------------------------