NumPy 使用教程

灰太狼 2022-04-06 07:10 394阅读 0赞

# NumPy 基础使用教程（1）- 数值类型及多维数组 #

## 一、介绍 ##

### 1.1 基础内容 ###

如果你使用 Python 语言进行科学计算，那么一定会接触到 [NumPy][]。NumPy 是支持 Python 语言的数值计算扩充库，其拥有强大的多维数组处理与矩阵运算能力。除此之外，NumPy 还内建了大量的函数，方便你快速构建数学模型。

### 1.2 知识点 ###

*  NumPy 安装
 *  NumPy 数值类型介绍

### 1.3 环境 ###

*  Python3
 *  Jupyter Notebook

### 1.4 适合人群 ###

本课程难度为一般，属于初级级别课程，适合具有 Python 基础，并对使用 NumPy 进行科学计算感兴趣的用户。

# 二、NumPy 简介 #

![此处输入图片的描述][format_png]

NumPy 的英文全称为 Numerical Python，意味 Python 面向数值计算的第三方库。NumPy 的特点在于，针对 Python 内建的数组类型做了扩充，支持更高维度的数组和矩阵运算，以及更丰富的数学函数。

NumPy 是 Scipy.org 中最重要的库之一，它同时也被 Pandas，Matplotlib 等我们熟知的第三方库作为核心计算库。当你在单独安装这些库时，你会发现同时会安装 NumPy 作为依赖。

## 2.1 NumPy 安装 ##

实验楼的在线环境中已经内置了 NumPy，无需手动安装。如果你需要在本地安装 NumPy。最方便地，就是通过 pip 来进行安装了。我们只需要打开终端，键入下面的命令就可以完成安装了。

sudo pip install numPy

Windows 用户只需要以管理员身份打开系统命令行工具，输入 `pip install NumPy` 即可。

当然，Ubuntu & Debian 用户还可以用 apt-get 安装：

sudo apt-get install python-numpy

## 2.2 NumPy 数值类型 ##

安装完毕之后，我们先来了解 NumPy 支持的数据类型。Python 本身支持的数值类型有 `int`（整型，Python 2 中存在 long 长整型）、`float`（浮点型）、`bool`（布尔型） 和 `complex`（复数型）。

而 NumPy 支持比 Python 本身更为丰富的数值类型，细分如下：

1.  `bool`：布尔类型，1 个字节，值为 True 或 False。
2.  `int`：整数类型，通常为 int64 或 int32 。
3.  `intc`：与 C 里的 int 相同，通常为 int32 或 int64。
4.  `intp`：用于索引，通常为 int32 或 int64。
5.  `int8`：字节（从 -128 到 127）
6.  `int16`：整数（从 -32768 到 32767）
7.  `int32`：整数（从 -2147483648 到 2147483647）
8.  `int64`：整数（从 -9223372036854775808 到 9223372036854775807）
9.  `uint8`：无符号整数（从 0 到 255）
10. `uint16`：无符号整数（从 0 到 65535）
11. `uint32`：无符号整数（从 0 到 4294967295）
12. `uint64`：无符号整数（从 0 到 18446744073709551615）
13. `float`：float64 的简写。
14. `float16`：半精度浮点，5 位指数，10 位尾数
15. `float32`：单精度浮点，8 位指数，23 位尾数
16. `float64`：双精度浮点，11 位指数，52 位尾数
17. `complex`：complex128 的简写。
18. `complex64`：复数，由两个 32 位浮点表示。
19. `complex128`：复数，由两个 64 位浮点表示。

在 NumPy 中，上面提到的这些数值类型都被归于 `dtype（data-type）` 对象的实例。 我们可以用 `numpy.dtype(object, align, copy)` 来指定数值类型。而在数组里面，可以用 `dtype=` 参数。

下面，我们就开始学习 NumPy，首先需要导入 NumPy。

**☞ 示例代码：**

import numpy as np # 导入 NumPy 模块
    
    a = np.array([1.1, 2.2, 3.3], dtype=np.float64) # 指定 1 维数组的数值类型为 float64
    
    a, a.dtype # 查看 a 及 dtype 类型

**☞ 动手练习：**

你可以使用 `.astype()` 方法在不同的数值类型之间相互转换。

**☞ 示例代码：**

a.astype(int).dtype # 将 a 的数值类型从 float64 转换为 int，并查看 dtype 类型

**☞ 动手练习：**

## 三、NumPy 多维数组 ##

### 3.1 `ndarray` 介绍 ###

在 python 内建对象中，数组有三种形式：

1.  `list` 列表：`[1, 2, 3]`
2.  `Tuple` 元组：`(1, 2, 3, 4, 5)`
3.  `Dict` 字典：`{A:1, B:2}`

其中，元组与列表相似，不同之处在于元组的元素不能修改。而字典由键和值构成。 python 标准类针对数组的处理局限于 1 维，并仅提供少量的功能。

而 NumPy 最核心且最重要的一个特性就是 `ndarray` 多维数组对象，它区别于 Python 的标准类，拥有对高维数组的处理能力，这也是数值计算过程中缺一不可的重要特性。

NumPy 中，`ndarray` 类具有六个参数，它们分别为：

1.  `shape`：数组的形状。
2.  `dtype`：数据类型。
3.  `buffer`：对象暴露缓冲区接口。
4.  `offset`：数组数据的偏移量。
5.  `strides`：数据步长。
6.  `order`：`{'C'，'F'}`，以行或列为主排列顺序。

下面，我们来了解创建 ndarray 的一些方法。在 NumPy 中，我们主要通过以下 5 种途径创建数组，它们分别是：

1.  从 Python 数组结构列表，元组等转换。
2.  使用 `np.arange`、`np.ones`、`np.zeros` 等 NumPy 原生方法。
3.  从存储空间读取数组。
4.  通过使用字符串或缓冲区从原始字节创建数组。
5.  使用特殊函数，如 `random`。

### 3.2 从列表或元组转换 ###

在 NumPy 中，我们使用 `numpy.array` 将列表或元组转换为 ndarray 数组。其方法为：

numpy.array(object, dtype=None, copy=True, order=None, subok=False, ndmin=0)

其中，参数：

*  `object`：列表、元组等。
 *  `dtype`：数据类型。如果未给出，则类型为被保存对象所需的最小类型。
 *  `copy`：布尔类型，默认 True，表示复制对象。
 *  `order`：顺序。
 *  `subok`：布尔类型，表示子类是否被传递。
 *  `ndmin`：生成的数组应具有的最小维数。

下面，通过列表创建一个 ndarray 数组。

**☞ 示例代码：**

np.array([[[1, 2, 3],[1, 2, 3],[1, 2, 3]],[[1, 2, 3],[1, 2, 3],[1, 2, 3]],[[1, 2, 3],[1, 2, 3],[1, 2, 3]]])

**☞ 动手练习：**

或者是列表和元组。

**☞ 示例代码：**

np.array([(1,2),(3,4),(5,6)])

**☞ 动手练习：**

### 3.3 `arange` 方法创建 ###

除了直接使用 array 方法创建 ndarray，在 NumPy 中还有一些方法可以创建一些有规律性的多维数。首先，我们来看一看 `arange()`。`arange()` 的功能是在给定区间内创建一系列均匀间隔的值。方法如下：

numpy.arange(start, stop, step, dtype=None)

你需要先设置值所在的区间，这里为 `[开始， 停止）`，你应该能发现这是一个半开半闭区间。然后，在设置 `step` 步长用于设置值之间的间隔。最后的可选参数 `dtype`可以设置返回`ndarray` 的值类型。

**☞ 示例代码：**

# 在区间 [3, 7) 中以 0.5 为步长新建数组
    np.arange(3, 7, 0.5, dtype='float32')

### 3.4 `linspace` 方法创建 ###

`linspace`方法也可以像`arange`方法一样，创建数值有规律的数组。`linspace` 用于在指定的区间内返回间隔均匀的值。其方法如下：

numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

*  `start`：序列的起始值。
 *  `stop`：序列的结束值。
 *  `num`：生成的样本数。默认值为50。
 *  `endpoint`：布尔值，如果为真，则最后一个样本包含在序列内。
 *  `retstep`：布尔值，如果为真，返回间距。
 *  `dtype`：数组的类型。

**☞ 示例代码：**

np.linspace(0, 10, 10, endpoint=True)

**☞ 动手练习：**

将 `endpoint` 参数改成 `False` 看看区别：

**☞ 示例代码：**

np.linspace(0, 10, 10, endpoint=False)

**☞ 动手练习：**

### 3.5 `ones` 方法创建 ###

`numpy.ones` 用于快速创建数值全部为 `1` 的多维数组。其方法如下：

numpy.ones(shape, dtype=None, order='C')

其中：

*  `shape`：用于指定数组形状，例如（1， 2）或 3。
 *  `dtype`：数据类型。
 *  `order`：`{'C'，'F'}`，按行或列方式储存数组。

**☞ 示例代码：**

np.ones((2,3))

**☞ 动手练习：**

### 3.6 `zeros` 方法创建 ###

`zeros` 方法和上面的 `ones` 方法非常相似，不同的地方在于，这里全部填充为 `0`。`zeros` 方法和 `ones` 是一致的。

numpy.zeros(shape, dtype=None, order='C')

其中：

*  `shape`：用于指定数组形状，例如`（1， 2）`或`3`。
 *  `dtype`：数据类型。
 *  `order`：`{'C'，'F'}`，按行或列方式储存数组。

**☞ 示例代码：**

np.zeros((3,2))

**☞ 动手练习：**

### 3.7 `eye` 方法创建 ###

`numpy.eye` 用于创建一个二维数组，其特点是`k` 对角线上的值为 `1`，其余值全部为`0`。方法如下：

numpy.eye(N, M=None, k=0, dtype=<type 'float'>)

其中：

*  `N`：输出数组的行数。
 *  `M`：输出数组的列数。
 *  `k`：对角线索引：0（默认）是指主对角线，正值是指上对角线，负值是指下对角线。

**☞ 示例代码：**

np.eye(5, 4, 3)

**☞ 动手练习：**

### 3.8 从已知数据创建 ###

我们还可以从已知数据文件、函数中创建 `ndarray`。NumPy 提供了下面 `5` 个方法：

1.  `frombuffer（buffer）`：将缓冲区转换为 `1` 维数组。
2.  `fromfile（file，dtype，count，sep）`：从文本或二进制文件中构建多维数组。
3.  `fromfunction（function，shape）`：通过函数返回值来创建多维数组。
4.  `fromiter（iterable，dtype，count）`：从可迭代对象创建 `1` 维数组。
5.  `fromstring（string，dtype，count，sep）`：从字符串中创建 `1` 维数组。

**☞ 示例代码：**

np.fromfunction(lambda a, b: a + b, (5, 4))

**☞ 动手练习：**

## 四、`ndarray` 数组属性 ##

首先，我们创建一个 `ndarray` 数组，首先，新建 `b` 并随意设定为一个 2 维数组。

**☞ 示例代码：**

b = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
    
    b # 查看 b 的值

**☞ 动手练习：**

ndarray 多维数组支持下面这些属性：

### 4.1 `ndarray.T` ###

`ndarray.T`用于数组的转置，与 `.transpose()` 相同。

**☞ 示例代码：**

b.T

**☞ 动手练习：**

### 4.2 `ndarray.dtype` ###

`ndarray.dtype` 用来输出数组包含元素的数据类型。

**☞ 示例代码：**

b.dtype

**☞ 动手练习：**

### 4.3 `ndarray.imag` ###

`ndarray.imag` 用来输出数组包含元素的虚部。

**☞ 示例代码：**

b.imag

**☞ 动手练习：**

### 4.4`ndarray.real` ###

`ndarray.real`用来输出数组包含元素的实部。

**☞ 示例代码：**

b.real

**☞ 动手练习：**

### 4.5 `ndarray.size` ###

`ndarray.size`用来输出数组中的总包含元素数。

**☞ 示例代码：**

b.size

**☞ 动手练习：**

### 4.6`ndarray.itemsize` ###

`ndarray.itemsize`输出一个数组元素的字节数。

**☞ 示例代码：**

b.itemsize

**☞ 动手练习：**

### 4.7 `ndarray.nbytes` ###

`ndarray.nbytes`用来输出数组的元素总字节数。

**☞ 示例代码：**

b.nbytes

**☞ 动手练习：**

### 4.8 `ndarray.ndim` ###

`ndarray.ndim`用来输出数组尺寸。

**☞ 示例代码：**

b.ndim

**☞ 动手练习：**

### 4.9 `ndarray.shape` ###

`ndarray.shape`用来输出数组维数组.

**☞ 示例代码：**

b.shape

**☞ 动手练习：**

### 4.10 `ndarray.strides` ###

`ndarray.strides`用来遍历数组时，输出每个维度中步进的字节数组。

**☞ 示例代码：**

b.strides

**☞ 动手练习：**

## 五、实验总结 ##

Ndarray 是 NumPy 的灵魂和核心，本章节介绍了 Ndarray 的生成或转换方法，这是了解并熟练使用 NumPy 的前提。

# NumPy 基础使用教程（2）- 数组操作及随机抽样 #

## 一、介绍 ##

### 1.1 基础内容 ###

### 1.2 实验知识点 ###

*  NumPy 安装
 *  NumPy 数值类型介绍

### 1.3 环境 ###

*  Python3
 *  Jupyter Notebook

### 1.4 适合人群 ###

本课程难度为一般，属于初级级别课程，适合具有 Python 基础，并对使用 NumPy 进行科学计算感兴趣的用户。

## 二、NumPy 数组的基本操作 ##

上一个章节，我们了解了如何利用 NumPy 创建各式各样的 ndarray。本章节，我们将利用学会针对 ndarray 的各种花式操作技巧。

### 2.1 重设形状 ###

`reshape` 可以在不改变数组数据的同时，改变数组的形状。其中，`numpy.reshape()` 等效于 `ndarray.reshape()`。`reshape` 方法非常简单：

numpy.reshape(a, newshape)

其中，a 表示原数组，`newshape` 用于指定新的形状(整数或者元组)。

**☞ 示例代码：**

import numpy as np
    
    np.arange(10).reshape((5, 2))

**☞ 动手练习：**

### 2.2 数组展开 ###

`ravel` 的目的是将任意形状的数组扁平化，变为 1 维数组。`ravel` 方法如下：

numpy.ravel(a, order='C')

其中，a 表示需要处理的数组。`order` 表示变换时的读取顺序，默认是按照行依次读取，当 `order='F'` 时，可以按列依次读取排序。

**☞ 示例代码：**

a = np.arange(10).reshape((2, 5))
    
    np.ravel(a)
    np.ravel(a, order='F')

**☞ 动手练习：**

**☞ 示例代码：**

np.ravel(a, order='F')

**☞ 动手练习：**

### 2.3 轴移动 ###

`moveaxis` 可以将数组的轴移动到新的位置。其方法如下：

numpy.moveaxis(a, source, destination)

其中：

*  `a`：数组。
 *  `source`：要移动的轴的原始位置。
 *  `destination`：要移动的轴的目标位置。

**☞ 示例代码：**

a = np.ones((1, 2, 3))
    np.moveaxis(a, 0, -1)

**☞ 动手练习：**

你可能没有看明白是什么意思，我们可以输出二者的 `shape`属性：

**☞ 示例代码：**

a.shape, np.moveaxis(a, 0, -1).shape

**☞ 动手练习：**

### 2.4 轴交换 ###

和 `moveaxis` 不同的是，`swapaxes` 可以用来交换数组的轴。其方法如下：

numpy.swapaxes(a, axis1, axis2)

其中：

*  `a`：数组。
 *  `axis1`：需要交换的轴 1 位置。
 *  `axis2`：需要与轴 1 交换位置的轴 1 位置。

**☞ 示例代码：**

a = np.ones((1, 4, 3))
    np.swapaxes(a, 0, 2)

**☞ 动手练习：**

### 2.5 数组转置 ###

`transpose` 类似于矩阵的转置，它可以将 2 维数组的横轴和纵轴交换。其方法如下：

numpy.transpose(a, axes=None)

其中：

*  `a`：数组。
 *  `axis`：该值默认为 `none`，表示转置。如果有值，那么则按照值替换轴。

**☞ 示例代码：**

a = np.arange(4).reshape(2,2)
    np.transpose(a)

**☞ 动手练习：**

### 2.6 维度改变 ###

`atleast_xd` 支持将输入数据直接视为 `x`维。这里的 `x` 可以表示：`1，2，3`。方法分别维：

numpy.atleast_1d()
    numpy.atleast_2d()
    numpy.atleast_3d()

**☞ 示例代码：**

np.atleast_1d([1])
    np.atleast_2d([1])
    np.atleast_3d([1])

**☞ 动手练习：**

### 2.7 类型转变 ###

在 NumPy 中，还有一系列以 as 开头的方法，它们可以将特定输入转换为数组，亦可将数组转换为矩阵、标量，`ndarray` 等。如下：

*  `asarray(a，dtype，order)`：将特定输入转换为数组。
 *  `asanyarray(a，dtype，order)`：将特定输入转换为 `ndarray`。
 *  `asmatrix(data，dtype)`：将特定输入转换为矩阵。
 *  `asfarray(a，dtype)`：将特定输入转换为 `float` 类型的数组。
 *  `asarray_chkfinite(a，dtype，order)`：将特定输入转换为数组，检查 `NaN` 或 `infs`。
 *  `asscalar(a)`：将大小为 1 的数组转换为标量。

这里以 `asmatrix(data，dtype)` 方法举例：

**☞ 示例代码：**

a = np.arange(4).reshape(2,2)
    np.asmatrix(a)

**☞ 动手练习：**

### 2.8 数组连接 ###

`concatenate` 可以将多个数组沿指定轴连接在一起。其方法为：

numpy.concatenate((a1, a2, ...), axis=0)

其中：

*  `(a1, a2, ...)`：需要连接的数组。
 *  `axis`：指定连接轴。

**☞ 示例代码：**

a = np.array([[1, 2], [3, 4], [5, 6]])
    b = np.array([[7, 8], [9, 10]])
    c = np.array([[11, 12]])
    
    np.concatenate((a, b, c), axis=0)

**☞ 动手练习：**

这里，我们可以尝试沿着横轴连接。但要保证连接处的维数一致，所以这里用到了 `.T` 转置。

**☞ 示例代码：**

a = np.array([[1, 2], [3, 4], [5, 6]])
    b = np.array([[7, 8, 9]])
    
    np.concatenate((a, b.T), axis=1)

**☞ 动手练习：**

### 2.9 数组堆叠 ###

在 NumPy 中，以下方法可用于数组的堆叠：

*  `stack(arrays，axis)`：沿着新轴连接数组的序列。
 *  `column_stack()`：将 1 维数组作为列堆叠到 2 维数组中。
 *  `hstack()`：按水平方向堆叠数组。
 *  `vstack()`：按垂直方向堆叠数组。
 *  `dstack()`：按深度方向堆叠数组。

这里以 `stack(arrays，axis)` 方法举例：

**☞ 示例代码：**

a = np.array([1, 2, 3])
    b = np.array([4, 5, 6])
    np.stack((a, b))

**☞ 动手练习：**

当然，也可以横着堆叠。

**☞ 示例代码：**

np.stack((a, b), axis=-1)

**☞ 动手练习：**

### 2.10 拆分 ###

`split` 及与之相似的一系列方法主要是用于数组的拆分，列举如下：

*  `split(ary，indices_or_sections，axis)`：将数组拆分为多个子数组。
 *  `dsplit(ary，indices_or_sections)`：按深度方向将数组拆分成多个子数组。
 *  `hsplit(ary，indices_or_sections)`：按水平方向将数组拆分成多个子数组。
 *  `vsplit(ary，indices_or_sections)`：按垂直方向将数组拆分成多个子数组。

下面，我们看一看 `split` 到底有什么效果：

**☞ 示例代码：**

a = np.arange(10)
    np.split(a, 5)

**☞ 动手练习：**

除了 1 维数组，更高维度也是可以直接拆分的。例如，我们可以将下面的数组按行拆分为 2。

**☞ 示例代码：**

a = np.arange(10).reshape(2,5)
    np.split(a, 2)

**☞ 动手练习：**

NumPy 中还有针对数组元素添加或移除的一些方法。

### 2.11 删除 ###

*  `delete(arr，obj，axis)`：沿特定轴删除数组中的子数组。

下面，依次对 4 种方法进行示例，首先是 `delete` 删除：

**☞ 示例代码：**

a = np.arange(12).reshape(3,4)
    np.delete(a, 2, 1)

**☞ 动手练习：**

这里代表沿着横轴，将第 3 列(索引 2)删除。当然，你也可以沿着纵轴，将第三行删除。

**☞ 示例代码：**

np.delete(a, 2, 0)

**☞ 动手练习：**

### 2.12 数组插入 ###

*  `insert(arr，obj，values，axis)`：依据索引在特定轴之前插入值。

再看一看 `insert`插入, 用法和 `delete` 很相似，只是需要在第三个参数位置设置需要插入的数组对象：

**☞ 示例代码：**

a = np.arange(12).reshape(3,4)
    b = np.arange(4)
    
    np.insert(a, 2, b, 0)

**☞ 动手练习：**

### 2.13 附加 ###

*  `append(arr，values，axis)`：将值附加到数组的末尾，并返回 1 维数组。

`append` 的用法也非常简单。只需要设置好需要附加的值和轴位置就好了。它其实相当于只能在末尾插入的 `insert`，所以少了一个指定索引的参数。

**☞ 示例代码：**

a = np.arange(6).reshape(2,3)
    b = np.arange(3)
    
    np.append(a, b)

**☞ 动手练习：**

注意 `append`方法返回值，默认是展平状态下的 1 维数组。

### 2.14 重设尺寸 ###

*  `resize(a，new_shape)`：对数组尺寸进行重新设定。

`resize` 就很好理解了，直接举例子吧：

**☞ 示例代码：**

a = np.arange(10)
    a.resize(2,5)

**☞ 动手练习：**

你可能会纳闷了，这个 `resize` 看起来和上面的 `reshape` 一样呢，都是改变数组原有的形状。

其实，它们是有区别的，区别在于对原数组的影响。`reshape` 在改变形状时，不会影响原数组，相当于对原数组做了一份拷贝。而 `resize` 则是对原数组执行操作。

### 2.15 翻转数组 ###

在 NumPy 中，我们还可以对数组进行翻转操作：

*  `fliplr(m)`：左右翻转数组。
 *  `flipud(m)`：上下翻转数组。

**☞ 示例代码：**

a = np.arange(16).reshape(4,4)
    np.fliplr(a)
    np.flipud(a)

**☞ 动手练习：**

## 三、NumPy 随机抽样 ##

NumPy 的随机抽样功能非常强大，主要由 `numpy.random` 模块完成。

首先，我们需要了解如何使用 NumPy 也就是生成一些满足基本需求的随机数据。主要由以下一些方法完成：

### 3.1 `numpy.random.rand` ###

`numpy.random.rand(d0, d1, ..., dn)` 方法的作用为：指定一个数组，并使用 `[0, 1)` 区间随机数据填充，这些数据均匀分布。

**☞ 示例代码：**

np.random.rand(2,5)

**☞ 动手练习：**

### 3.2 `numpy.random.randn` ###

`numpy.random.randn(d0, d1, ..., dn)` 与 `numpy.random.rand(d0, d1, ..., dn)` 的区别在于，前者是从标准正态分布中返回一个或多个样本值。

**☞ 示例代码：**

np.random.randn(1,10)

**☞ 动手练习：**

### 3.3 `numpy.random.randint` ###

`randint(low, high, size, dtype)` 方法将会生成 \[low, high) 的随机整数。注意这是一个半开半闭区间。

**☞ 示例代码：**

np.random.randint(2,5,10)

**☞ 动手练习：**

### 3.4 `numpy.random.random_integers` ###

`random_integers(low, high, size)` 方法将会生成 `[low, high]` 的 `np.int` 类型随机整数。注意这是一个闭区间。

**☞ 示例代码：**

np.random.random_integers(2,5,10)

**☞ 动手练习：**

### 3.5 `numpy.random.random_sample` ###

`random_sample(size)` 方法将会在 `[0, 1)` 区间内生成指定 `size` 的随机浮点数。

**☞ 示例代码：**

np.random.random_sample([10])

**☞ 动手练习：**

与 `numpy.random.random_sample` 类似的方法还有：

*  `numpy.random.random([size])`
 *  `numpy.random.ranf([size])`
 *  `numpy.random.sample([size])`

它们 4 个的效果都差不多。

### 3.6 `numpy.random.choice` ###

`choice(a, size, replace, p)` 方法将会给定的 1 维数组里生成随机数。

**☞ 示例代码：**

np.random.choice(10,5)

**☞ 动手练习：**

上面的代码将会在 `np.arange(10)` 中生成 5 个随机数。

### 3.7 概率密度分布 ###

除了上面介绍的 6 中随机数生成方法，NumPy 还提供了大量的满足特定概率密度分布的样本生成方法。它们的使用方法和上面非常相似，这里就不再一一介绍了。列举如下：

1.  `numpy.random.beta(a，b，size)`：从 Beta 分布中生成随机数。
2.  `numpy.random.binomial(n, p, size)`：从二项分布中生成随机数。
3.  `numpy.random.chisquare(df，size)`：从卡方分布中生成随机数。
4.  `numpy.random.dirichlet(alpha，size)`：从 Dirichlet 分布中生成随机数。
5.  `numpy.random.exponential(scale，size)`：从指数分布中生成随机数。
6.  `numpy.random.f(dfnum，dfden，size)`：从 F 分布中生成随机数。
7.  `numpy.random.gamma(shape，scale，size)`：从 Gamma 分布中生成随机数。
8.  `numpy.random.geometric(p，size)`：从几何分布中生成随机数。
9.  `numpy.random.gumbel(loc，scale，size)`：从 Gumbel 分布中生成随机数。
10. `numpy.random.hypergeometric(ngood, nbad, nsample, size)`：从超几何分布中生成随机数。
11. `numpy.random.laplace(loc，scale，size)`：从拉普拉斯双指数分布中生成随机数。
12. `numpy.random.logistic(loc，scale，size)`：从逻辑分布中生成随机数。
13. `numpy.random.lognormal(mean，sigma，size)`：从对数正态分布中生成随机数。
14. `numpy.random.logseries(p，size)`：从对数系列分布中生成随机数。
15. `numpy.random.multinomial(n，pvals，size)`：从多项分布中生成随机数。
16. `numpy.random.multivariate_normal(mean, cov, size)`：从多变量正态分布绘制随机样本。
17. `numpy.random.negative_binomial(n, p, size)`：从负二项分布中生成随机数。
18. `numpy.random.noncentral_chisquare(df，nonc，size)`：从非中心卡方分布中生成随机数。
19. `numpy.random.noncentral_f(dfnum, dfden, nonc, size)`：从非中心 F 分布中抽取样本。
20. `numpy.random.normal(loc，scale，size)`：从正态分布绘制随机样本。
21. `numpy.random.pareto(a，size)`：从具有指定形状的 Pareto II 或 Lomax 分布中生成随机数。
22. `numpy.random.poisson(lam，size)`：从泊松分布中生成随机数。
23. `numpy.random.power(a，size)`：从具有正指数 a-1 的功率分布中在 0，1 中生成随机数。
24. `numpy.random.rayleigh(scale，size)`：从瑞利分布中生成随机数。
25. `numpy.random.standard_cauchy(size)`：从标准 Cauchy 分布中生成随机数。
26. `numpy.random.standard_exponential(size)`：从标准指数分布中生成随机数。
27. `numpy.random.standard_gamma(shape，size)`：从标准 Gamma 分布中生成随机数。
28. `numpy.random.standard_normal(size)`：从标准正态分布中生成随机数。
29. `numpy.random.standard_t(df，size)`：从具有 df 自由度的标准学生 t 分布中生成随机数。
30. `numpy.random.triangular(left，mode，right，size)`：从三角分布中生成随机数。
31. `numpy.random.uniform(low，high，size)`：从均匀分布中生成随机数。
32. `numpy.random.vonmises(mu，kappa，size)`：从 von Mises 分布中生成随机数。
33. `numpy.random.wald(mean，scale，size)`：从 Wald 或反高斯分布中生成随机数。
34. `numpy.random.weibull(a，size)`：从威布尔分布中生成随机数。
35. `numpy.random.zipf(a，size)`：从 Zipf 分布中生成随机数。

## 四、实验总结 ##

本章节介绍了针对 Ndarray 的常用操作，并了解了 `numpy.random` 类下的随机抽样方法。这两点内容都非常重要，也非常实用。由于随机抽样的方法太多，全部记忆下来不太实际，你可以多浏览几遍留下印象，需要时再查阅官方文档。

# NumPy 基础使用教程（3）- 数学函数及代数运算 #

## 一、介绍 ##

### 1.1 基础内容 ###

### 1.2 知识点 ###

*  NumPy 安装
 *  NumPy 数值类型介绍

### 1.3 环境 ###

*  Python3
 *  Jupyter Notebook

### 1.4 适合人群 ###

本课程难度为一般，属于初级级别课程，适合具有 Python 基础，并对使用 NumPy 进行科学计算感兴趣的用户。

## 二、数学函数 ##

使用 python 自带的运算符，你可以完成数学中的加减乘除，以及取余、取整，幂次计算等。导入自带的 math 模块之后，里面又包含绝对值、阶乘、开平方等一些常用的数学函数。不过，这些函数仍然相对基础。如果要完成更加复杂一些的数学计算，就会显得捉襟见肘了。

numpy 为我们提供了更多的数学函数，以帮助我们更好地完成一些数值计算。下面就依次来看一看。

### 2.1 三角函数 ###

首先, 看一看 numpy 提供的三角函数功能。这些方法有：

1.  `numpy.sin(x)`：三角正弦。
2.  `numpy.cos(x)`：三角余弦。
3.  `numpy.tan(x)`：三角正切。
4.  `numpy.arcsin(x)`：三角反正弦。
5.  `numpy.arccos(x)`：三角反余弦。
6.  `numpy.arctan(x)`：三角反正切。
7.  `numpy.hypot(x1,x2)`：直角三角形求斜边。
8.  `numpy.degrees(x)`：弧度转换为度。
9.  `numpy.radians(x)`：度转换为弧度。
10. `numpy.deg2rad(x)`：度转换为弧度。
11. `numpy.rad2deg(x)`：弧度转换为度。

比如，我们可以用上面提到的 `numpy.rad2deg(x)` 将弧度转换为度。

**☞ 示例代码：**

import numpy as np
    
    np.rad2deg(np.pi)

**☞ 动手练习：**

上面的这些函数非常简单，就不再一一举例了。你可以自己新建一些空白单元格练习。

### 2.2 双曲函数 ###

在数学中，双曲函数是一类与常见的三角函数类似的函数。双曲函数经常出现于某些重要的线性微分方程的解中，使用 numpy 计算它们的方法为：

1.  `numpy.sinh(x)`：双曲正弦。
2.  `numpy.cosh(x)`：双曲余弦。
3.  `numpy.tanh(x)`：双曲正切。
4.  `numpy.arcsinh(x)`：反双曲正弦。
5.  `numpy.arccosh(x)`：反双曲余弦。
6.  `numpy.arctanh(x)`：反双曲正切。

### 2.3 数值修约 ###

数值修约, 又称数字修约, 是指在进行具体的数字运算前, 按照一定的规则确定一致的位数, 然后舍去某些数字后面多余的尾数的过程\[via. 维基百科\]。比如, 我们常听到的「4 舍 5 入」就属于数值修约中的一种。

1.  `numpy.around(a)`：平均到给定的小数位数。
2.  `numpy.round_(a)`：将数组舍入到给定的小数位数。
3.  `numpy.rint(x)`：修约到最接近的整数。
4.  `numpy.fix(x, y)`：向 0 舍入到最接近的整数。
5.  `numpy.floor(x)`：返回输入的底部(标量 x 的底部是最大的整数 i)。
6.  `numpy.ceil(x)`：返回输入的上限(标量 x 的底部是最小的整数 i).
7.  `numpy.trunc(x)`：返回输入的截断值。

随机选择几个浮点数，看一看上面方法的区别。

**☞ 示例代码：**

a = np.random.randn(5) # 生成 5 个随机数
    
    a # 输出 a 的值

**☞ 动手练习：**

np.around(a)

np.round_(a)

np.rint(a)

np.fix(a)

np.floor(a)

np.ceil(a)

np.trunc(a)

### 2.4 求和、求积、差分 ###

下面这些方法用于数组内元素或数组间进行求和、求积以及进行差分。

1.  `numpy.prod(a, axis, dtype, keepdims)`：返回指定轴上的数组元素的乘积。
2.  `numpy.sum(a, axis, dtype, keepdims)`：返回指定轴上的数组元素的总和。
3.  `numpy.nanprod(a, axis, dtype, keepdims)`：返回指定轴上的数组元素的乘积, 将 NaN 视作 1。
4.  `numpy.nansum(a, axis, dtype, keepdims)`：返回指定轴上的数组元素的总和, 将 NaN 视作 0。
5.  `numpy.cumprod(a, axis, dtype)`：返回沿给定轴的元素的累积乘积。
6.  `numpy.cumsum(a, axis, dtype)`：返回沿给定轴的元素的累积总和。
7.  `numpy.nancumprod(a, axis, dtype)`：返回沿给定轴的元素的累积乘积, 将 NaN 视作 1。
8.  `numpy.nancumsum(a, axis, dtype)`：返回沿给定轴的元素的累积总和, 将 NaN 视作 0。
9.  `numpy.diff(a, n, axis)`：计算沿指定轴的第 n 个离散差分。
10. `numpy.ediff1d(ary, to_end, to_begin)`：数组的连续元素之间的差异。
11. `numpy.gradient(f)`：返回 N 维数组的梯度。
12. `numpy.cross(a, b, axisa, axisb, axisc, axis)`：返回两个(数组）向量的叉积。
13. `numpy.trapz(y, x, dx, axis)`：使用复合梯形规则沿给定轴积分。

下面，我们选取几个举例测试一下：

**☞ 示例代码：**

b = np.arange(10) # 生成 0-9
    
    b # 输出 b 的值

**☞ 动手练习：**

np.prod(b)

np.sum(b)

np.nanprod(b)

np.nansum(b)

np.cumprod(b)

np.diff(b)

### 2.5 指数和对数 ###

如果你需要进行指数或者对数求解，可以用到以下这些方法。

1.  `numpy.exp(x)`：计算输入数组中所有元素的指数。
2.  `numpy.expm1(x)`：对数组中的所有元素计算 exp(x） - 1.
3.  `numpy.exp2(x)`：对于输入数组中的所有 p, 计算 2 \*\* p。
4.  `numpy.log(x)`：计算自然对数。
5.  `numpy.log10(x)`：计算常用对数。
6.  `numpy.log2(x)`：计算二进制对数。
7.  `numpy.log1p(x)`：`log(1 + x)`。
8.  `numpy.logaddexp(x1, x2)`：`log2(2**x1 + 2**x2)`。
9.  `numpy.logaddexp2(x1, x2)`：`log(exp(x1) + exp(x2))`。

### 2.6 算术运算 ###

当然，numpy 也提供了一些用于算术运算的方法，使用起来会比 python 提供的运算符灵活一些，主要是可以直接针对数组。

1.  `numpy.add(x1, x2)`：对应元素相加。
2.  `numpy.reciprocal(x)`：求倒数 1/x。
3.  `numpy.negative(x)`：求对应负数。
4.  `numpy.multiply(x1, x2)`：求解乘法。
5.  `numpy.divide(x1, x2)`：相除 x1/x2。
6.  `numpy.power(x1, x2)`：类似于 x1^x2。
7.  `numpy.subtract(x1, x2)`：减法。
8.  `numpy.fmod(x1, x2)`：返回除法的元素余项。
9.  `numpy.mod(x1, x2)`：返回余项。
10. `numpy.modf(x1)`：返回数组的小数和整数部分。
11. `numpy.remainder(x1, x2)`：返回除法余数。

**☞ 示例代码：**

a1 = np.random.randint(0, 10, 5) # 生成 5 个从 0-10 的随机整数
    a2 = np.random.randint(0, 10, 5)
    
    a1, a2 # 输出 a1, a2

**☞ 动手练习：**

np.add(a1, a2)

np.reciprocal(a1)

np.negative(a1)

np.multiply(a1, a2)

np.divide(a1, a2)

np.power(a1, a2)

np.subtract(a1, a2)

np.fmod(a1, a2)

np.mod(a1, a2)

np.modf(a1)

np.remainder(a1, a2)

### 2.7 矩阵和向量积 ###

求解向量、矩阵、张量的点积等同样是 numpy 非常强大的地方。

1.  `numpy.dot(a,b)`：求解两个数组的点积。
2.  `numpy.vdot(a,b)`：求解两个向量的点积。
3.  `numpy.inner(a,b)`：求解两个数组的内积。
4.  `numpy.outer(a,b)`：求解两个向量的外积。
5.  `numpy.matmul(a,b)`：求解两个数组的矩阵乘积。
6.  `numpy.tensordot(a,b)`：求解张量点积。
7.  `numpy.kron(a,b)`：计算 Kronecker 乘积。

### 2.8 其他 ###

除了上面这些归好类别的方法，numpy 中还有一些用于数学运算的方法，归纳如下：

1.  `numpy.angle(z, deg)`：返回复参数的角度。
2.  `numpy.real(val)`：返回数组元素的实部。
3.  `numpy.imag(val)`：返回数组元素的虚部。
4.  `numpy.conj(x)`：按元素方式返回共轭复数。
5.  `numpy.convolve(a, v, mode)`：返回线性卷积。
6.  `numpy.sqrt(x)`：平方根。
7.  `numpy.cbrt(x)`：立方根。
8.  `numpy.square(x)`：平方。
9.  `numpy.absolute(x)`：绝对值, 可求解复数。
10. `numpy.fabs(x)`：绝对值。
11. `numpy.sign(x)`：符号函数。
12. `numpy.maximum(x1, x2)`：最大值。
13. `numpy.minimum(x1, x2)`：最小值。
14. `numpy.nan_to_num(x)`：用 0 替换 NaN。
15. `numpy.interp(x, xp, fp, left, right, period)`：线性插值。

## 三、代数运算 ##

上面，我们分为 8 个类别，介绍了 numpy 中常用到的数学函数。这些方法让复杂的计算过程表达更为简单。除此之外，numpy 中还包含一些代数运算的方法，尤其是涉及到矩阵的计算方法，求解特征值、特征向量、逆矩阵等，非常方便。

1.  `numpy.linalg.cholesky(a)`：Cholesky 分解。
2.  `numpy.linalg.qr(a ,mode)`：计算矩阵的 QR 因式分解。
3.  `numpy.linalg.svd(a ,full_matrices,compute_uv)`：奇异值分解。
4.  `numpy.linalg.eig(a)`：计算正方形数组的特征值和右特征向量。
5.  `numpy.linalg.eigh(a, UPLO)`：返回 Hermitian 或对称矩阵的特征值和特征向量。
6.  `numpy.linalg.eigvals(a)`：计算矩阵的特征值。
7.  `numpy.linalg.eigvalsh(a, UPLO)`：计算 Hermitian 或真实对称矩阵的特征值。
8.  `numpy.linalg.norm(x ,ord,axis,keepdims)`：计算矩阵或向量范数。
9.  `numpy.linalg.cond(x ,p)`：计算矩阵的条件数。
10. `numpy.linalg.det(a)`：计算数组的行列式。
11. `numpy.linalg.matrix_rank(M ,tol)`：使用奇异值分解方法返回秩。
12. `numpy.linalg.slogdet(a)`：计算数组的行列式的符号和自然对数。
13. `numpy.trace(a ,offset,axis1,axis2,dtype,out)`：沿数组的对角线返回总和。
14. `numpy.linalg.solve(a,b)`：求解线性矩阵方程或线性标量方程组。
15. `numpy.linalg.tensorsolve(a,b ,axes)`：为 x 解出张量方程a x = b
16. `numpy.linalg.lstsq(a,b ,rcond)`：将最小二乘解返回到线性矩阵方程。
17. `numpy.linalg.inv(a)`：计算逆矩阵。
18. `numpy.linalg.pinv(a ,rcond)`：计算矩阵的（Moore-Penrose）伪逆。
19. `numpy.linalg.tensorinv(a ,ind)`：计算N维数组的逆。

## 四、实验总结 ##

数学函数和代数运算方法是使用 numpy 进行数值计算中的利器，numpy 针对矩阵的高效率处理，往往可以达到事半功倍的效果。

# NumPy 基础使用教程（4）- 数组索引及其他用法 #

## 一、介绍 ##

### 1.1 基础内容 ###

### 1.2 知识点 ###

*  NumPy 安装
 *  NumPy 数值类型介绍

### 1.3 环境 ###

*  Python3
 *  Jupyter Notebook

### 1.4 适合人群 ###

本课程难度为一般，属于初级级别课程，适合具有 Python 基础，并对使用 NumPy 进行科学计算感兴趣的用户。

## 二、Numpy 数组索引和切片 ##

我们已经明确了，Ndarray 是 Numpy 的组成核心，那么对于 Numpy 的多维数组，其实它完整集成了 python 对于数组的索引语法 array\[obj\]。随着 obj 的不同，我们可以实现字段访问、数组切片、以及其他高级索引功能。

### 2.1 数组索引 ###

我们可以通过索引值（从 0 开始）来访问 Ndarray 中的特定位置元素。Numpy 中的索引和 python 对 list 索引的方式非常相似，但又有所不同。我们一起来看一下：

首先是，一维数据索引：

**☞ 示例代码：**

import numpy as np
    
    a = np.arange(10) # 生成 0-9
    a

**☞ 动手练习：**

# 获取索引值为 1 的数据
    a[1]

# 分别获取索引值为 1，2，3 的数据
    a[[1, 2, 3]]

对于二维数据而言：

**☞ 示例代码：**

b = np.arange(20).reshape(4,5)
    b

**☞ 动手练习：**

# 获取第 2 行，第 3 列的数据
    b[1,2]

如果，我们使用 python 中的 list 索引同样的值，看看有什么区别：

**☞ 示例代码：**

# 创建一个数据相同的 list
    c = [[ 0,  1,  2,  3,  4],[ 5,  6,  7,  8,  9],[10, 11, 12, 13, 14],[15, 16, 17, 18, 19]]

**☞ 动手练习：**

# 按照上面的方法获取第 2 行，第 3 列的数据
    c[1,2]

> 报错

# python 中 list 索引 2 维数据的方法
    c[1][2]

如何索引二维 Ndarray 中的多个元素值，这里使用逗号`,`分割：

**☞ 示例代码：**

d = np.arange(20).reshape(4,5)
    d

**☞ 动手练习：**

# 索引
    d[[1,2],[3,4]]

这里需要注意索引的对应关系。我们实际获取的是`[1,3]`，也就是第`2`行和第`4`列对于的值`8`。以及`[2, 4]`，也就是第`3`行和第`5`列对于的值`14`。

那么，三维数据呢？

**☞ 示例代码：**

e = np.arange(30).reshape(2,5,3)
    
    e

**☞ 动手练习：**

# 索引
    e[[0,1],[1,2],[1,2]]

### 2.2 数组切片 ###

Numpy 里面针对`Ndarray`的数组切片和 python 里的`list` 切片操作是一样的。其语法为：

Ndarray[start:stop:step]

\[`start:stop:step`\] 分布代表 \[`起始索引：截至索引：步长`\]。对于一维数组：

**☞ 示例代码：**

f = np.arange(10)
    f

**☞ 动手练习：**

f[:5]

f[5:10]

f[0:10:2]

对于多维数组，我们只需要用逗号`,`分割不同维度即可：

**☞ 示例代码：**

g = np.arange(20).reshape(4,5)
    g

**☞ 动手练习：**

# 先取第 3，4 列（第一个维度），再取第 1，2，3 行（第二个维度）。
    g[0:3,2:4]

# 按步长为 2 取所有列和所有行的数据。
    g[:,::2]

当超过 3 维或更多维时，用 2 维数据的切片方式类推即可。

### 2.3 索引与切片区别 ###

你可能有点疑问，上面的索引和切片怎么看起来这么相似呢？

它们的语法的确很相似，但实际上有区别：

**1. 修改切片中的内容会影响原始数组。**

**☞ 示例代码：**

h = np.arange(10)
    h

**☞ 动手练习：**

# 修改 h[1] 为 100
    h[1] = 100
    h

除此之外，切片只能通过步长控制得到连续的值，而索引可以得到任意值。也就是说，索引的自由度更大。

## 三、排序、搜索、计数 ##

最后，再介绍几个 numpy 针对数组元素的使用方法，分别是排序、搜索和计数。

### 3.1 排序 ###

我们可以使用 `numpy.sort`方法对多维数组元素进行排序。其方法为：

numpy.sort(a, axis=-1, kind='quicksort', order=None)

其中：

*  `a`：数组。
 *  `axis`：要排序的轴。如果为`None`，则在排序之前将数组铺平。默认值为 `-1`，沿最后一个轴排序。
 *  `kind`：`{'quicksort'，'mergesort'，'heapsort'}`，排序算法。默认值为 `quicksort`。

举个例子：

**☞ 示例代码：**

i = np.random.rand(20).reshape(4,5)
    i

**☞ 动手练习：**

np.sort(i)

除了 numpy.sort，还有这样一些对数组进行排序的方法：

1.  `numpy.lexsort(keys ,axis)`：使用多个键进行间接排序。
2.  `numpy.argsort(a ,axis,kind,order)`：沿给定轴执行间接排序。
3.  `numpy.msort(a)`：沿第 1 个轴排序。
4.  `numpy.sort_complex(a)`：针对复数排序。

### 3.2 搜索和计数 ###

除了排序，我们可以通过下面这些方法对数组中元素进行搜索和计数。列举如下：

1.  `argmax(a ,axis,out)`：返回数组中指定轴的最大值的索引。
2.  `nanargmax(a ,axis)`：返回数组中指定轴的最大值的索引,忽略 NaN。
3.  `argmin(a ,axis,out)`：返回数组中指定轴的最小值的索引。
4.  `nanargmin(a ,axis)`：返回数组中指定轴的最小值的索引,忽略 NaN。
5.  `argwhere(a)`：返回数组中非 0 元素的索引,按元素分组。
6.  `nonzero(a)`：返回数组中非 0 元素的索引。
7.  `flatnonzero(a)`：返回数组中非 0 元素的索引,并铺平。
8.  `where(条件,x,y)`：根据指定条件,从指定行、列返回元素。
9.  `searchsorted(a,v ,side,sorter)`：查找要插入元素以维持顺序的索引。
10. `extract(condition,arr)`：返回满足某些条件的数组的元素。
11. `count_nonzero(a)`：计算数组中非 0 元素的数量。

选取其中的一些方法举例：

**☞ 示例代码：**

j = np.random.randint(0,10,20)
    j

**☞ 动手练习：**

np.argmax(j)

np.nanargmax(j)

np.argmin(j)

np.nanargmin(j)

np.argwhere(j)

np.nonzero(j)

np.flatnonzero(j)

np.count_nonzero(j)