Python3 Numpy模块详解

参考链接：https://blog.csdn.net/a373595475/article/details/79580734 ### 一、Numpy - 简介 Numpy 是一个 Python 包。 它代表 “Numeric Python”。 它是一个由多维数组对象和用于处理数组的例程集合组成的库。

Numeric，即 NumPy 的前身，是由 Jim Hugunin 开发的。 也开发了另一个包 Numarray ，它拥有一些额外的功能。 2005年，Travis Oliphant 通过将 Numarray 的功能集成到 Numeric 包中来创建 NumPy 包。 这个开源项目有很多贡献者。 ****** ### 二、Numpy 操作 使用Numpy，开发人员可以执行以下操作：

• 数组的算数和逻辑运算。

• 傅立叶变换和用于图形操作的例程。

• 与线性代数有关的操作。 Numpy 拥有线性代数和随机数生成的内置函数。

---

三、Numpy – matlab 的替代之一

Numpy 通常与 Scipy（Scientific Python）和 Matplotlib（绘图库）一起使用。 这种组合广泛用于替代 Matlab，是一个流行的技术计算平台。 但是，Python 作为 Matlab 的替代方案，现在被视为一种更加现代和完整的编程语言。

Numpy 是开源的，这是它的一个额外的优势。 ******

四、Numpy - Ndarray 对象

Numpy 中定义的最重要的对象是称为 ndarray 的 N 维数组类型。 它描述相同类型的元素集合。 可以使用基于零的索引访问集合中的项目。

ndarray中的每个元素在内存中使用相同大小的块。 ndarray中的每个元素是数据类型对象的对象（称为 dtype）。

从ndarray对象提取的任何元素（通过切片）由一个数组标量类型的 Python 对象表示。 下图显示了ndarray，数据类型对象（dtype）和数组标量类型之间的关系。

基本的ndarray是使用 Numpy 中的数组函数创建的，它从任何暴露数组接口的对象，或从返回数组的任何方法创建一个ndarray。如下所示：

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

上面的构造器接受以下参数： 　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

序号	参数及描述
1.	object 任何暴露数组接口方法的对象都会返回一个数组或任何（嵌套）序列。
2.	dtype 数组的所需数据类型，可选。
3.	copy 可选，默认为true，对象是否被复制。
4.	order C（按行）、F（按列）或A（任意，默认）。
5.	subok 默认情况下，返回的数组被强制为基类数组。 如果为true，则返回子类。
6.	ndmin 指定返回数组的最小维数。

看看下面的例子来更好地理解:

示例一：

import numpy as np
a = np.array([1,2,3])
print(a)

输出如下：

[1 2 3]

示例二：

#多一个维度
import numpy as np
a = np.array([[1,2],[3,4]])
print(a)

输出如下：

[[1 2]
 [3 4]]

示例三：

#指定数组维度ndmin
import numpy as np
a = np.array([1,2,3,4,5],ndmin=2)
print(a)

输出如下：

[[1 2 3 4 5]]

示例四：

#指定存储类型dtype
import numpy as np
a = np.array([1,2,3,4,5],dtype=complex)
print(a)

输出如下：

[1.+0.j 2.+0.j 3.+0.j 4.+0.j 5.+0.j]

ndarray对象由计算机内存中的一维连续区域组成，带有将每个元素映射到内存块中某个位置的索引方案。 内存块以按行（C 风格）或按列（FORTRAN 或 Matlab 风格）的方式保存元素。 ****** ### 五、Numpy - 数据类型 Numpy 支持比 Python 更多种类的数值类型，下表显示了 Numpy 中定义的不同标量数据类型。 　　　　　　　　　　　　　　　　　　　　　　　　　　　

序号	数据类型及描述
1.	bool— 存储为一个字节的布尔值（真或假）
2.	int—默认整数，相当于 C 的long，通常为int32或int64
3.	intc 相当于 C 的int，通常为int32或int64
4.	intp 用于索引的整数，相当于 C 的size_t，通常为int32或int64
5.	int8 字节（-128 ~ 127）
6.	int16 16 位整数（-32768 ~ 32767）
7.	int32 32 位整数（-2147483648 ~ 2147483647）
8.	int64 64 位整数（-9223372036854775808 ~ 9223372036854775807）
9.	uint8 8 位无符号整数（0 ~ 255）
10.	uint16 16 位无符号整数（0 ~ 65535）
11.	uint32 32 位无符号整数（0 ~ 4294967295）
12.	uint64 64 位无符号整数（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 位浮点表示（实部和虚部）

---

六、数据类型对象 (dtype)

数据类型对象描述了对应于数组的固定内存块的解释，取决于以下方面：

• 数据类型（整数、浮点或者 Python 对象）

• 数据大小

• 字节序（小端或大端）

• 在结构化类型的情况下，字段的名称，每个字段的数据类型，和每个字段占用的内存块部分。

• 如果数据类型是子序列，它的形状和数据类型。

字节顺序取决于数据类型的前缀<或>。 <意味着编码是小端（最小有效字节存储在最小地址中）。 >意味着编码是大端（最大有效字节存储在最小地址中）。

常见用法：

import numpy as np
#dtype=int dtype="int8" dtype=np.int8
a = np.array([1,2,3,4,5],dtype=float)
print(a)

输出结果：

[1. 2. 3. 4. 5.]

每个内建类型都有一个唯一定义它的字符代码：

• ‘b’：布尔值

• ‘i’：符号整数

• ‘u’：无符号整数

• ‘f’：浮点

• ‘c’：复数浮点

• ‘m’：时间间隔

• ‘M’：日期时间

• ‘O’：Python 对象

• ‘S’, ‘a’：字节串

• ‘U’：Unicode

• ‘V’：原始数据（void）

---

七、Numpy - 数组属性

这一章中，我们会讨论 Numpy 的多种数组属性。

7.1 ndarray.shape

这一数组属性返回一个包含数组维度的元组，它也可以用于调整数组大小。 示例一

import numpy as np
a = np.array([[1,2,3],[4,5,6]])
print(a.shape)

输出结果：

(2, 3)

示例二

import numpy as np
a = np.array([[1,2,3],[4,5,6]])
print(a)
a.shape = (3,2)
print(a)

输出结果：

[[1 2 3]
 [4 5 6]]
[[1 2]
 [3 4]
 [5 6]]

示例三 Numpy 也提供了reshape函数来调整数组大小。

import numpy as np
a = np.array([[1,2,3],[4,5,6]])
print(a)
b = a.reshape(3,2)
print(b)

输出结果：

[[1 2 3]
 [4 5 6]]
[[1 2]
 [3 4]
 [5 6]]

7.2 ndarray.ndim

这一数组属性返回数组的维数。

# 一维数组
import numpy as np
a = np.arange(24)
print(a)
print(a.ndim)
# 现在调整其大小
b = a.reshape(2,4,3)
print(b)
print(b.ndim)
# b现在拥有三个维度

输出结果：

[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]
1
[[[ 0  1  2]
  [ 3  4  5]
  [ 6  7  8]
  [ 9 10 11]]

 [[12 13 14]
  [15 16 17]
  [18 19 20]
  [21 22 23]]]
3

7.3 numpy.itemsize

这一数组属性返回数组中每个元素的字节单位长度。

示例一

import numpy as np
a = np.array([1,2,3,4],dtype="int")
print(a.itemsize)

输出结果：

4

示例二

import numpy as np
a = np.array([1,2,3,4],dtype="float")
print(a.itemsize)

输出结果：

8

---

八、Numpy - 数组创建例程

新的ndarray对象可以通过任何下列数组创建例程或使用低级ndarray构造函数构造。 #### 8.1 numpy.empty 它创建指定形状和dtype的未初始化数组，它使用以下构造函数：

numpy.empty(shape, dtype = float, order = 'C')

构造器接受下列参数： 　　　　　　　　　　　　　

序号	参数及描述
1.	Shape 空数组的形状，整数或整数元组
2.	Dtype 所需的输出数组类型，可选
3.	Order ’C’为按行的 C 风格数组，’F’为按列的 Fortran 风格数组

示例

下面的代码展示空数组的例子：

import numpy as np
a = np.empty([3,3],dtype=int)
print(a)

输出结果：

[[1869438820 1701606756      10354]
 [   3961344   98172928 1936682083]
 [1913137509         61      15986]]

注意：数组元素为随机值，因为它们未初始化 #### 8.2 numpy.zeros 返回特定大小，以 0 填充的新数组。

示例1

# 含有 5 个 0 的数组，默认类型为 float
import numpy as np
x = np.zeros(5)
print(x)

输出结果：

[ 0.  0.  0.  0.  0.]

示例2

import numpy as np
x = np.zeros((5,), dtype = np.int)
print(x)

输出结果：

[ 0  0  0  0  0]

8.3 numpy.ones

返回特定大小，以 1 填充的新数组。

示例1

# 含有 5 个 1 的数组，默认类型为 float
import numpy as np
x = np.ones(5)
print(x)

输出结果：

[ 1.  1.  1.  1.  1.]

示例2

import numpy as np
x = np.ones((5,), dtype = np.int)
print(x)

输出结果：

[ 1  1  1  1  1]

---

九、Numpy - 来自数值范围的数组

这一章中，我们会学到如何从数值范围创建数组。 #### 9.1 numpy.arange 这个函数返回ndarray对象，包含给定范围内的等间隔值。

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

构造器接受下列参数： 　　　　　　　　　　　　　　　　　　　　　　　　　

序号	参数及描述
1.	start 范围的起始值，默认为0
2.	stop 范围的终止值（不包含）
3.	step 两个值的间隔，默认为1
4.	dtype 返回ndarray的数据类型，如果没有提供，则会使用输入数据的类型。

下面的例子展示了如何使用该函数：

示例1

import numpy as np
x = np.arange(5)
print(x)

输出结果：

[0  1  2  3  4]

示例2

import numpy as np
x = np.arange(5,dtype=float)
print(x)

输出结果：

[0.  1.  2.  3.  4.]

示例3

import numpy as np
x = np.arange(10,20,2)
print(x)

输出结果：

[10  12  14  16  18]

9.2 numpy.linspace

此函数类似于arange()函数。 在此函数中，指定了范围之间的均匀间隔数量，而不是步长。 此函数的用法如下。

numpy.linspace(start, stop, num, endpoint, retstep, dtype)

构造器接受下列参数： 　　　　　　　　　　　　　　　　　

序号	参数及描述
1.	start 序列的起始值
2.	stop 序列的终止值，如果endpoint为true，该值包含于序列中
3.	num 要生成的等间隔样例数量，默认为50
4.	endpoint 序列中是否包含stop值，默认为ture
5.	retstep 如果为true，返回样例，以及连续数字之间的步长
6.	dtype 输出ndarray的数据类型

下面的例子展示了linspace函数的用法:

示例1

import numpy as np
x = np.linspace(10,20,5)
print(x)

输出结果：

[10.   12.5   15.   17.5  20.]

示例2

# 将 endpoint 设为 false
import numpy as np
x = np.linspace(10,20,5, endpoint = False)
print(x)

输出结果：

[10.   12.   14.   16.   18.]

示例3

# 输出 retstep 值
import numpy as np

x = np.linspace(1,2,5, retstep =  True)
print(x)
# 这里的 retstep 为 0.25

输出结果：

(array([ 1.  ,  1.25,  1.5 ,  1.75,  2.  ]), 0.25)

---

十、Numpy - 切片和索引

ndarray对象的内容可以通过索引或切片来访问和修改，就像 Python 的内置容器对象一样。

如前所述，ndarray对象中的元素遵循基于零的索引。 有三种可用的索引方法类型： 字段访问，基本切片和高级索引。

基本切片是 Python 中基本切片概念到 n 维的扩展。 通过将start，stop和step参数提供给内置的slice函数来构造一个 Python slice对象。 此slice对象被传递给数组来提取数组的一部分。

示例1

import numpy as np
a = np.arange(10)
s = slice(2,7,2)
print(a[s])

输出结果：

[2  4  6]

在上面的例子中，ndarray对象由arange()函数创建。 然后，分别用起始，终止和步长值2，7和2定义切片对象。 当这个切片对象传递给ndarray时，会对它的一部分进行切片，从索引2到7，步长为2。

通过将由冒号分隔的切片参数（start:stop:step）直接提供给ndarray对象，也可以获得相同的结果。

示例2

import numpy as np
a = np.arange(10)
b = a[2:7:2]
print(b)

输出结果：

[2  4  6]

如果只输入一个参数，则将返回与索引对应的单个项目。 如果使用a:，则从该索引向后的所有项目将被提取。 如果使用两个参数（以:分隔），则对两个索引（不包括停止索引）之间的元素以默认步骤进行切片。

示例3

# 对单个元素进行切片
import numpy as np
a = np.arange(10)
b = a[5]
print(b)

输出结果：

5

示例4

# 对始于索引的元素进行切片
import numpy as np
a = np.arange(10)
print(a[2:])

输出结果：

[2  3  4  5  6  7  8  9]

示例5

# 对索引之间的元素进行切片
import numpy as np
a = np.arange(10)
print(a[2:5])

输出结果：

[2  3  4]

上面的描述也可用于多维ndarray。

示例6

import numpy as np
a = np.array([[1,2,3],[3,4,5],[4,5,6]])
print(a)
# 对始于索引的元素进行切片
print(a[1:])

输出结果：

[[1 2 3]
 [3 4 5]
 [4 5 6]]

[[3 4 5]
 [4 5 6]]

切片还可以包括省略号（…），来使选择元组的长度与数组的维度相同。 如果在行位置使用省略号，它将返回包含行中元素的ndarray。

示例7

# 最开始的数组
import numpy as np
a = np.array([[1,2,3],[3,4,5],[4,5,6]])
print('我们的数组是：')
print(a)
print('\n')
# 这会返回第二列元素的数组：
print('第二列的元素是：')
print(a[...,1])
print('\n')
# 现在我们从第二行切片所有元素：
print('第二行的元素是：')
print(a[1,...])
print('\n')
# 现在我们从第二列向后切片所有元素：
print('第二列及其剩余元素是：')
print(a[...,1:])

输出结果：

我们的数组是：
[[1 2 3]
 [3 4 5]
 [4 5 6]]

第二列的元素是：
[2 4 5]

第二行的元素是：
[3 4 5]

第二列及其剩余元素是：
[[2 3]
 [4 5]
 [5 6]]

---

十一、Numpy - 高级索引

如果一个ndarray是非元组序列，数据类型为整数或布尔值的ndarray，或者至少一个元素为序列对象的元组，我们就能够用它来索引ndarray。高级索引始终返回数据的副本。 与此相反，切片只提供了一个视图。

有两种类型的高级索引：整数和布尔值。

整数索引

这种机制有助于基于 N 维索引来获取数组中任意元素。 每个整数数组表示该维度的下标值。 当索引的元素个数就是目标ndarray的维度时，会变得相当直接。

以下示例获取了ndarray对象中每一行指定列的一个元素。 因此，行索引包含所有行号，列索引指定要选择的元素。

示例1

import numpy as np
x = np.array([[1,2],[3,4],[5,6]])
y = x[[0,1,2],[0,1,0]]
print(y)

输出如下：

[1  4  5]

该结果包括数组中(0,0)，(1,1)和(2,0)位置处的元素。

下面的示例获取了 4x3 数组中的每个角处的元素。 行索引是[0,0]和[3,3]，而列索引是[0,2]和[0,2]。

示例2

import numpy as np
x = np.array([[0,1,2],[3,4,5],[6,7,8],[9,10,11]])
print('我们的数组是：')
print(x)
print('\n')
rows = np.array([[0,0],[3,3]])
cols = np.array([[0,2],[0,2]])
y = x[rows,cols]
print('这个数组的每个角处的元素是：')
print(y)

输出如下：

我们的数组是：
[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]]

这个数组的每个角处的元素是：
[[ 0  2]
 [ 9 11]]

返回的结果是包含每个角元素的ndarray对象。

高级和基本索引可以通过使用切片:或省略号…与索引数组组合。 以下示例使用slice作为列索引和高级索引。 当切片用于两者时，结果是相同的。 但高级索引会导致复制，并且可能有不同的内存布局。

示例3

import numpy as np
x = np.array([[0,1,2],[3,4,5],[6,7,8],[9,10,11]])
print('我们的数组是：')
print(x)
print('\n')
# 切片
z = x[1:4,1:3]
print('切片之后，我们的数组变为：')
print(z)
print('\n')
# 对列使用高级索引
y = x[1:4,[1,2]]
print('对列使用高级索引来切片：')
print(y)

输出如下：

我们的数组是：
[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]]

切片之后，我们的数组变为：
[[ 4  5]
 [ 7  8]
 [10 11]]

对列使用高级索引来切片：
[[ 4  5]
 [ 7  8]
 [10 11]]

#### 布尔索引 当结果对象是布尔运算（例如比较运算符）的结果时，将使用此类型的高级索引。

示例1

import numpy as np
x = np.array([[0,1,2],[3,4,5],[6,7,8],[9,10,11]])
print('我们的数组是：')
print(x)
print('\n')
# 现在我们会打印出大于 5 的元素
print('大于 5 的元素是：')
print(x[x > 5])

输出如下：

我们的数组是：
[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]]

大于 5 的元素是：
[ 6  7  8  9 10 11]

### 十二、Numpy - 广播 术语广播是指 Numpy 在算术运算期间处理不同形状的数组的能力。 对数组的算术运算通常在相应的元素上进行。 如果两个阵列具有完全相同的形状，则这些操作被无缝执行。

示例1

import numpy as np
a = np.array([1,2,3,4])
b = np.array([10,20,30,40])
c = a * b
print(c)

输出如下：

[10   40   90   160]

如果两个数组的维数不相同，则元素到元素的操作是不可能的。 然而，在 Numpy 中仍然可以对形状不相似的数组进行操作，因为它拥有广播功能。 较小的数组会广播到较大数组的大小，以便使它们的形状可兼容。

如果满足以下规则，可以进行广播：

• ndim较小的数组会在前面追加一个长度为 1 的维度。

• 输出数组的每个维度的大小是输入数组该维度大小的最大值。

• 如果输入在每个维度中的大小与输出大小匹配，或其值正好为 1，则在计算中可它。

• 如果输入的某个维度大小为 1，则该维度中的第一个数据元素将用于该维度的所有计算。

如果上述规则产生有效结果，并且满足以下条件之一，那么数组被称为可广播的。

• 数组拥有相同形状。

• 数组拥有相同的维数，每个维度拥有相同长度，或者长度为 1。

• 数组拥有极少的维度，可以在其前面追加长度为 1 的维度，使上述条件成立。

下面的例称展示了广播的示例。

示例2

import numpy as np
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]])
b = np.array([1.0,2.0,3.0])
print('第一个数组：')
print(a)
print('\n')
print('第二个数组：')
print(b)
print('\n')
print('第一个数组加第二个数组：')
print(a + b)

输出如下：

第一个数组：
[[ 0. 0. 0.]
 [ 10. 10. 10.]
 [ 20. 20. 20.]
 [ 30. 30. 30.]]

第二个数组：
[ 1. 2. 3.]

第一个数组加第二个数组：
[[ 1. 2. 3.]
 [ 11. 12. 13.]
 [ 21. 22. 23.]
 [ 31. 32. 33.]]

下面的图片展示了数组b如何通过广播来与数组a兼容。

---

十三、Numpy - 数组上的迭代

Numpy 包含一个迭代器对象numpy.nditer。 它是一个有效的多维迭代器对象，可以用于在数组上进行迭代。 数组的每个元素可使用 Python 的标准Iterator接口来访问。

让我们使用arange()函数创建一个 3x4 数组，并使用nditer对它进行迭代。

示例1

import numpy as np
a = np.arange(0,60,5)
a = a.reshape(3,4)
print('原始数组是：')
print(a)
print('\n')
print('修改后的数组是：')
for x in np.nditer(a):
    print(x,)

输出如下：

原始数组是：
[[ 0 5 10 15]
 [20 25 30 35]
 [40 45 50 55]]

修改后的数组是：
0 5 10 15 20 25 30 35 40 45 50 55

示例2 迭代的顺序匹配数组的内容布局，而不考虑特定的排序。 这可以通过迭代上述数组的转置来看到。

import numpy as np
a = np.arange(0,60,5)
a = a.reshape(3,4)
print('原始数组是：')
print(a)
print('\n')
print('原始数组的转置是：')
b = a.T
print(b)
print('\n')
print('修改后的数组是：')
for x in np.nditer(b):
    print(x,)

输出如下：

原始数组是：
[[ 0 5 10 15]
 [20 25 30 35]
 [40 45 50 55]]

原始数组的转置是：
[[ 0 20 40]
 [ 5 25 45]
 [10 30 50]
 [15 35 55]]

修改后的数组是：
0 5 10 15 20 25 30 35 40 45 50 55

迭代顺序

如果相同元素使用 F 风格顺序存储，则迭代器选择以更有效的方式对数组进行迭代。

示例1

import numpy as np
a = np.arange(0,60,5)
a = a.reshape(3,4)
print('原始数组是：')
print(a)
print('\n')
print('原始数组的转置是：')
b = a.T
print(b)
print('\n')
print('以 C 风格顺序排序：')
c = b.copy(order='C')
print(c)
for x in np.nditer(c):
    print(x,)
print('\n')
print('以 F 风格顺序排序：')
c = b.copy(order='F')
print(c)
for x in np.nditer(c):
    print(x,)

输出如下：

原始数组是：
[[ 0 5 10 15]
 [20 25 30 35]
 [40 45 50 55]]

原始数组的转置是：
[[ 0 20 40]
 [ 5 25 45]
 [10 30 50]
 [15 35 55]]

以 C 风格顺序排序：
[[ 0 20 40]
 [ 5 25 45]
 [10 30 50]
 [15 35 55]]
0 20 40 5 25 45 10 30 50 15 35 55

以 F 风格顺序排序：
[[ 0 20 40]
 [ 5 25 45]
 [10 30 50]
 [15 35 55]]
0 5 10 15 20 25 30 35 40 45 50 55

示例2

可以通过显式提醒，来强制nditer对象使用某种顺序：

import numpy as np
a = np.arange(0,60,5)
a = a.reshape(3,4)
print('原始数组是：')
print(a)
print('\n')
print('以 C 风格顺序排序：')
for x in np.nditer(a,order = 'C'):
    print(x,)
print('\n')
print('以 F 风格顺序排序：')
for x in np.nditer(a,order = 'F'):
    print(x,)

输出如下：

原始数组是：
[[ 0 5 10 15]
 [20 25 30 35]
 [40 45 50 55]]

以 C 风格顺序排序：
0 5 10 15 20 25 30 35 40 45 50 55

以 F 风格顺序排序：
0 20 40 5 25 45 10 30 50 15 35 55

有关C风格和F风格的说明: 　　　　　　　　　　 　 　　 　　　　　　 1. 比如二维数组 a[2][2]，使用 C，其在内存中存储为:

a[0][0] a[0][1] a[1][0] a[1][1] 　　　　　　　　　 2. 而在 Fortran 里，其顺序为:

a[0][0] a[1][0] a[0][1] a[1][1]

---

十四、Numpy - 数组操作

翻转操作

序号	操作及描述
1.	transpose 翻转数组的维度
2.	ndarray.T 和self.transpose()相同
3.	rollaxis 向后滚动指定的轴
4.	swapaxes 互换数组的两个轴

这里先介绍一下转置，其他的等碰到相关需求再说= =，因为我看不懂

numpy.ndarray.T

示例

import numpy as np
a = np.arange(12).reshape(3,4)

print('原数组：')
print(a)
print('\n')

print('转置数组：')
print(a.T)

输出结果：

原数组：
[[ 0 1 2 3]
 [ 4 5 6 7]
 [ 8 9 10 11]]

转置数组：
[[ 0 4 8]
 [ 1 5 9]
 [ 2 6 10]
 [ 3 7 11]]

数组的连接

序号	数组及描述
1.	concatenate 沿着现存的轴连接数据序列
2.	stack 沿着新轴连接数组序列
3.	hstack 水平堆叠序列中的数组（列方向）
4.	vstack 竖直堆叠序列中的数组（行方向）

这里先介绍一下concatenate，其他的等碰到相关需求再说= =，因为我还是看不懂

1. numpy.concatenate

数组的连接是指连接。 此函数用于沿指定轴连接相同形状的两个或多个数组。 该函数接受以下参数。

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

其中

• a1, a2, …：相同类型的数组序列
• axis：沿着它连接数组的轴，默认为 0

示例

import numpy as np
a = np.array([[1,2],[3,4]])

print('第一个数组：')
print(a)
print('\n')
b = np.array([[5,6],[7,8]])

print('第二个数组：')
print(b)
print('\n')
# 两个数组的维度相同

print('沿轴 0 连接两个数组：')
print(np.concatenate((a,b)))
print('\n')

print('沿轴 1 连接两个数组：')
print(np.concatenate((a,b),axis = 1))

输出结果：

第一个数组：
[[1 2]
 [3 4]]

第二个数组：
[[5 6]
 [7 8]]

沿轴 0 连接两个数组：
[[1 2]
 [3 4]
 [5 6]
 [7 8]]

沿轴 1 连接两个数组：
[[1 2 5 6]
 [3 4 7 8]]

有关数组维度axis的具体说明可以参考https://blog.csdn.net/fangjian1204/article/details/53055219

数组分割

序号	数组及描述
1.	split 将一个数组分割为多个子数组
2.	hsplit 将一个数组水平分割为多个子数组（按列）
3.	vsplit 将一个数组竖直分割为多个子数组（按行）

这里先介绍一下split，其他的等碰到相关需求再说= =，因为我还是看不懂

1. numpy.split

该函数沿特定的轴将数组分割为子数组。函数接受三个参数：

numpy.split(ary, indices_or_sections, axis)

其中：

• ary：被分割的输入数组
• indices_or_sections：可以是整数，表明要从输入数组创建的，等大小的子数组的数量。 如果此参数是一维数组，则其元素表明要创建新子数组的点。
• axis：默认为 0 > 有关数组维度axis的具体说明可以参考https://blog.csdn.net/fangjian1204/article/details/53055219

示例

import numpy as np
a = np.arange(9)

print('第一个数组：')
print(a)
print('\n')

print('将数组分为三个大小相等的子数组：')
b = np.split(a,3)
print(b)
print('\n')

print('将数组在一维数组中表明的位置分割：')
b = np.split(a,[4,7])
print(b)

输出结果：

第一个数组：
[0 1 2 3 4 5 6 7 8]

将数组分为三个大小相等的子数组：
[array([0, 1, 2]), array([3, 4, 5]), array([6, 7, 8])]

将数组在一维数组中表明的位置分割：
[array([0, 1, 2, 3]), array([4, 5, 6]), array([7, 8])]

添加/删除元素

序号	元素及描述
1.	resize 返回指定形状的新数组
2.	append 将值添加到数组末尾
3.	insert 沿指定轴将值插入到指定下标之前
4.	delete 返回删掉某个轴的子数组的新数组
5.	unique 寻找数组内的唯一元素

1. numpy.resize

此函数返回指定大小的新数组。 如果新大小大于原始大小，则包含原始数组中的元素的重复副本。 该函数接受以下参数。

numpy.resize(arr, shape)

其中：

• arr：要修改大小的输入数组
• shape：返回数组的新形状

示例

import numpy as np
a = np.array([[1,2,3],[4,5,6]])

print('第一个数组：')
print(a)
print('\n')

print('第一个数组的形状：')
print(a.shape)
print('\n')
b = np.resize(a,(3,2))

print('第二个数组：')
print(b)
print('\n')

print('第二个数组的形状：')
print(b.shape)
print('\n')
# 要注意 a 的第一行在 b 中重复出现，因为尺寸变大了

print('修改第二个数组的大小：')
b = np.resize(a,(3,3))
print(b)

输出结果：

第一个数组：
[[1 2 3]
 [4 5 6]]

第一个数组的形状：
(2, 3)

第二个数组：
[[1 2]
 [3 4]
 [5 6]]

第二个数组的形状：
(3, 2)

修改第二个数组的大小：
[[1 2 3]
 [4 5 6]
 [1 2 3]]

2. numpy.append

此函数在输入数组的末尾添加值。 附加操作不是原地的，而是分配新的数组。 此外，输入数组的维度必须匹配否则将生成ValueError。

函数接受下列函数：

numpy.append(arr, values, axis)

其中：

• arr：输入数组
• values：要向arr添加的值，比如和arr形状相同（除了要添加的轴）
• axis：沿着它完成操作的轴。如果没有提供，两个参数都会被展开。

示例

import numpy as np
a = np.array([[1,2,3],[4,5,6]])

print('第一个数组：')
print(a)
print('\n')

print('向数组添加元素：')
print(np.append(a, [7,8,9]))
print('\n')

print('沿轴 0 添加元素：')
print(np.append(a, [[7,8,9]],axis = 0))
print('\n')

print('沿轴 1 添加元素：')
print(np.append(a,[[5,5,5],[7,8,9]],axis = 1))

输出结果：

第一个数组：
[[1 2 3]
 [4 5 6]]

向数组添加元素：
[1 2 3 4 5 6 7 8 9]

沿轴 0 添加元素：
[[1 2 3]
 [4 5 6]
 [7 8 9]]

沿轴 1 添加元素：
[[1 2 3 5 5 5]
 [4 5 6 7 8 9]]

3. numpy.insert

此函数在给定索引之前，沿给定轴在输入数组中插入值。 如果值的类型转换为要插入，则它与输入数组不同。 插入没有原地的，函数会返回一个新数组。 此外，如果未提供轴，则输入数组会被展开。

insert()函数接受以下参数：

numpy.insert(arr, obj, values, axis)

其中：

• arr：输入数组
• obj：在其之前插入值的索引
• values：要插入的值
• axis：沿着它插入的轴，如果未提供，则输入数组会被展开

示例

import numpy as np
a = np.array([[1,2],[3,4],[5,6]])

print('第一个数组：')
print(a)
print('\n')

print('未传递 Axis 参数。 在插入之前输入数组会被展开。')
print(np.insert(a,3,[11,12]))
print('\n')
print('传递了 Axis 参数。 会广播值数组来配输入数组。')

print('沿轴 0 广播：')
print(np.insert(a,1,[11],axis = 0))
print('\n')

print('沿轴 1 广播：')
print(np.insert(a,1,11,axis = 1))

输出结果：

第一个数组：
[[1 2]
 [3 4]
 [5 6]]


未传递 Axis 参数。 在插入之前输入数组会被展开。
[ 1  2  3 11 12  4  5  6]


传递了 Axis 参数。 会广播值数组来配输入数组。
沿轴 0 广播：
[[ 1  2]
 [11 11]
 [ 3  4]
 [ 5  6]]


沿轴 1 广播：
[[ 1 11  2]
 [ 3 11  4]
 [ 5 11  6]]

4. numpy.delete

此函数返回从输入数组中删除指定子数组的新数组。 与insert()函数的情况一样，如果未提供轴参数，则输入数组将展开。 该函数接受以下参数：

Numpy.delete(arr, obj, axis)

其中：

• arr：输入数组
• obj：可以被切片，整数或者整数数组，表明要从输入数组删除的子数组
• axis：沿着它删除给定子数组的轴，如果未提供，则输入数组会被展开

示例

import numpy as np
a = np.arange(12).reshape(3,4)

print('第一个数组：')
print(a)
print('\n')

print('未传递 Axis 参数。 在插入之前输入数组会被展开。')
print(np.delete(a,5))
print('\n')

print('删除第二列：')
print(np.delete(a,1,axis = 1))
print('\n')

print('包含从数组中删除的替代值的切片：')
a = np.array([1,2,3,4,5,6,7,8,9,10])
print(np.delete(a, np.s_[::2]))

输出结果：

第一个数组：
[[ 0 1 2 3]
 [ 4 5 6 7]
 [ 8 9 10 11]]

未传递 Axis 参数。 在插入之前输入数组会被展开。
[ 0 1 2 3 4 6 7 8 9 10 11]

删除第二列：
[[ 0 2 3]
 [ 4 6 7]
 [ 8 10 11]]

包含从数组中删除的替代值的切片：
[ 2 4 6 8 10]

5. numpy.unique

此函数返回输入数组中的去重元素数组。 该函数能够返回一个元组，包含去重数组和相关索引的数组。 索引的性质取决于函数调用中返回参数的类型。

numpy.unique(arr, return_index, return_inverse, return_counts)

其中：

• arr：输入数组，如果不是一维数组则会展开
• return_index：如果为true，返回输入数组中的元素下标
• return_inverse：如果为true，返回去重数组的下标，它可以用于重构输入数组
• return_counts：如果为true，返回去重数组中的元素在原数组中的出现次数

示例

import numpy as np
a = np.array([5,2,6,2,7,5,6,8,2,9])

print('第一个数组：')
print(a)
print('\n')

print('第一个数组的去重值：')
u = np.unique(a)
print(u)
print('\n')

print('去重数组的索引数组：')
u,indices = np.unique(a, return_index = True)
print(indices)
print('\n')

print('我们可以看到每个和原数组下标对应的数值：')
print(a)
print('\n')

print('去重数组的下标：')
u,indices = np.unique(a,return_inverse = True)
print(u)
print('\n')

print('下标为：')
print(indices)
print('\n')

print('使用下标重构原数组：')
print(u[indices])
print('\n')

print('返回去重元素的重复数量：')
u,indices = np.unique(a,return_counts = True)
print(u)
print(indices)

输出结果：

第一个数组：
[5 2 6 2 7 5 6 8 2 9]


第一个数组的去重值：
[2 5 6 7 8 9]


去重数组的索引数组：
[1 0 2 4 7 9]


我们可以看到每个和原数组下标对应的数值：
[5 2 6 2 7 5 6 8 2 9]


去重数组的下标：
[2 5 6 7 8 9]


下标为：
[1 0 2 0 3 1 2 4 0 5]


使用下标重构原数组：
[5 2 6 2 7 5 6 8 2 9]


返回去重元素的重复数量：
[2 5 6 7 8 9]
[3 2 2 1 1 1]

---

十五、Numpy - 字符串函数

待补充…

---

十六、Numpy - 算数函数

很容易理解的是，Numpy 包含大量的各种数学运算功能。 Numpy 提供标准的三角函数，算术运算的函数，复数处理函数等。 ### 三角函数 Numpy 拥有标准的三角函数，它为弧度制单位的给定角度返回三角函数比值。

示例

import numpy as np
a = np.array([0,30,45,60,90])
print('不同角度的正弦值：')
# 通过乘 pi/180 转化为弧度
print(np.sin(a*np.pi/180))
print('\n')
print('数组中角度的余弦值：')
print(np.cos(a*np.pi/180))
print('\n')
print('数组中角度的正切值：')
print(np.tan(a*np.pi/180))

输出结果：

不同角度的正弦值：
[ 0.          0.5         0.70710678  0.8660254   1.        ]

数组中角度的余弦值：
[  1.00000000e+00   8.66025404e-01   7.07106781e-01   5.00000000e-01
   6.12323400e-17]

数组中角度的正切值：
[  0.00000000e+00   5.77350269e-01   1.00000000e+00   1.73205081e+00
   1.63312394e+16]

arcsin，arccos，和arctan函数返回给定角度的sin，cos和tan的反三角函数。 这些函数的结果可以通过numpy.degrees()函数通过将弧度制转换为角度制来验证。

示例

import numpy as np
a = np.array([0,30,45,60,90])
print('含有正弦值的数组：')
sin = np.sin(a*np.pi/180)
print(sin)
print('\n')
print('计算角度的反正弦，返回值以弧度为单位：')
inv = np.arcsin(sin)
print(inv)
print('\n')
print('通过转化为角度制来检查结果：')
print(np.degrees(inv))
print('\n')
print('arccos 和 arctan 函数行为类似：')
cos = np.cos(a*np.pi/180)
print(cos)
print('\n')
print('反余弦：')
inv = np.arccos(cos)
print(inv)
print('\n')
print('角度制单位：')
print(np.degrees(inv))
print('\n')
print('tan 函数：')
tan = np.tan(a*np.pi/180)
print(tan)
print('\n')
print('反正切：')
inv = np.arctan(tan)
print(inv)
print('\n')
print('角度制单位：')
print(np.degrees(inv))

输出结果：

含有正弦值的数组：
[ 0.          0.5         0.70710678  0.8660254   1.        ]

计算角度的反正弦，返回值以弧度制为单位：
[ 0.          0.52359878  0.78539816  1.04719755  1.57079633]

通过转化为角度制来检查结果：
[  0.  30.  45.  60.  90.]

arccos 和 arctan 函数行为类似：
[  1.00000000e+00   8.66025404e-01   7.07106781e-01   5.00000000e-01
   6.12323400e-17]

反余弦：
[ 0.          0.52359878  0.78539816  1.04719755  1.57079633]

角度制单位：
[  0.  30.  45.  60.  90.]

tan 函数：
[  0.00000000e+00   5.77350269e-01   1.00000000e+00   1.73205081e+00
   1.63312394e+16]

反正切：
[ 0.          0.52359878  0.78539816  1.04719755  1.57079633]

角度制单位：
[  0.  30.  45.  60.  90.]

舍入函数

1. numpy.around()

这个函数返回四舍五入到所需精度的值。 该函数接受以下参数。

numpy.around(a,decimals)

其中：

• a 输入数组
• decimals 要舍入的小数位数。 默认值为0。 如果为负，整数将四舍五入到小数点左侧的位置

示例

import numpy as np
a = np.array([1.0,5.55,  123,  0.567,  25.532])
print('原数组：')
print(a)
print('\n')
print('舍入后：')
print(np.around(a))
print(np.around(a, decimals =  1))
print(np.around(a, decimals =  -1))

输出结果：

原数组：
[   1.       5.55   123.       0.567   25.532]

舍入后：
[   1.    6.   123.    1.   26. ]
[   1.    5.6  123.    0.6  25.5]
[   0.    10.  120.    0.   30. ]

2.numpy.floor()

此函数返回不大于输入参数的最大整数。 即标量x 的下限是最大的整数i ，使得i <= x。 注意在Python中，向下取整总是从 0 舍入。

示例

import numpy as np
a = np.array([-1.7,  1.5,  -0.2,  0.6,  10])
print('提供的数组：')
print(a)
print('\n')
print('修改后的数组：')
print(np.floor(a))

输出结果：

提供的数组：
[ -1.7   1.5  -0.2   0.6  10. ]

修改后的数组：
[ -2.   1.  -1.   0.  10.]

3.numpy.ceil()

ceil()函数返回输入值的上限，即，标量x的上限是最小的整数i ，使得i >= x。

示例

import numpy as np
a = np.array([-1.7,  1.5,  -0.2,  0.6,  10])
print('提供的数组：')
print(a)
print('\n')
print('修改后的数组：')
print(np.ceil(a))

输出结果：

提供的数组：
[ -1.7   1.5  -0.2   0.6  10. ]

修改后的数组：
[ -1.   2.  -0.   1.  10.]

---

十七、Numpy - 算数运算

用于执行算术运算（如add()，subtract()，multiply()和divide()）的输入数组必须具有相同的形状或符合数组广播规则。

示例

import numpy as np
a = np.arange(9, dtype = np.float_).reshape(3,3)
print('第一个数组：')
print(a)
print('\n')
print('第二个数组：')
b = np.array([10,10,10])
print(b)
print('\n')
print('两个数组相加：')
print(np.add(a,b))
print('\n')
print('两个数组相减：')
print(np.subtract(a,b))
print('\n')
print('两个数组相乘：')
print(np.multiply(a,b))
print('\n')
print('两个数组相除：')
print(np.divide(a,b))

输出结果：

第一个数组：
[[ 0. 1. 2.]
 [ 3. 4. 5.]
 [ 6. 7. 8.]]

第二个数组：
[10 10 10]

两个数组相加：
[[ 10. 11. 12.]
 [ 13. 14. 15.]
 [ 16. 17. 18.]]

两个数组相减：
[[-10. -9. -8.]
 [ -7. -6. -5.]
 [ -4. -3. -2.]]

两个数组相乘：
[[ 0. 10. 20.]
 [ 30. 40. 50.]
 [ 60. 70. 80.]]

两个数组相除：
[[ 0. 0.1 0.2]
 [ 0.3 0.4 0.5]
 [ 0.6 0.7 0.8]]

让我们现在来讨论 NumPy 中提供的一些其他重要的算术函数。

1. numpy.power()

此函数将第一个输入数组中的元素作为底数，计算它与第二个输入数组中相应元素的幂。

示例

import numpy as np
a = np.array([10,100,1000])
print('我们的数组是；')
print(a)
print('\n')
print('调用 power 函数：')
print(np.power(a,2))
print('\n')
print('第二个数组：')
b = np.array([1,2,3])
print(b)
print('\n')
print('再次调用 power 函数：')
print(np.power(a,b))

输出如下：

我们的数组是；
[  10  100 1000]

调用 power 函数：
[    100   10000 1000000]

第二个数组：
[1 2 3]

再次调用 power 函数：
[        10      10000 1000000000]

#### numpy.mod()

此函数返回输入数组中相应元素的除法余数。 函数numpy.remainder()也产生相同的结果。

示例

import numpy as np
a = np.array([10,20,30])
b = np.array([3,5,7])
print('第一个数组：')
print(a)
print('\n')
print('第二个数组：')
print(b)
print('\n')
print('调用 mod() 函数：')
print(np.mod(a,b))
print('\n')
print('调用 remainder() 函数：')
print(np.remainder(a,b))

输出如下：

第一个数组：
[10 20 30]

第二个数组：
[3 5 7]

调用 mod() 函数：
[1 0 2]

调用 remainder() 函数：
[1 0 2]

以下函数用于对含有复数的数组执行操作。

• numpy.real() 返回复数类型参数的实部。

• numpy.imag() 返回复数类型参数的虚部。

• numpy.conj() 返回通过改变虚部的符号而获得的共轭复数。

• numpy.angle() 返回复数参数的角度。 函数的参数是degree。 如果为true，返回的角度以角度制来表示，否则为以弧度制来表示。

import numpy as np
a = np.array([-5.6j,  0.2j,  11.  ,  1+1j])
print('我们的数组是：')
print(a)
print('\n')
print('调用 real() 函数：')
print(np.real(a))
print('\n')
print('调用 imag() 函数：')
print(np.imag(a))
print('\n')
print('调用 conj() 函数：')
print(np.conj(a))
print('\n')
print('调用 angle() 函数：')
print(np.angle(a))
print('\n')
print('再次调用 angle() 函数（以角度制返回）：')
print(np.angle(a,deg =  True))

输出结果：

我们的数组是：
[ 0.-5.6j 0.+0.2j 11.+0.j 1.+1.j ]

调用 real() 函数：
[ 0. 0. 11. 1.]

调用 imag() 函数：
[-5.6 0.2 0. 1. ]

调用 conj() 函数：
[ 0.+5.6j 0.-0.2j 11.-0.j 1.-1.j ]

调用 angle() 函数：
[-1.57079633 1.57079633 0. 0.78539816]

再次调用 angle() 函数（以角度制返回）：
[-90. 90. 0. 45.]

---

十八、Numpy - 统计函数

Numpy 有很多有用的统计函数，用于从数组中给定的元素中查找最小，最大，百分标准差和方差等。 函数说明如下：

1. numpy.amin() 和 2. numpy.amax()

这些函数从给定数组中的元素沿指定轴返回最小值和最大值。

示例

import numpy as np
a = np.array([[3,7,5],[8,4,3],[2,4,9]])
print('我们的数组是：')
print(a)
print('\n')
print('调用 amin() 函数：')
print(np.amin(a,1))
print('\n')
print('再次调用 amin() 函数：')
print(np.amin(a,0))
print('\n')
print('调用 amax() 函数：')
print(np.amax(a))
print('\n')
print('再次调用 amax() 函数：')
print(np.amax(a,axis = 0))

3. numpy.ptp()

numpy.ptp()函数返回沿轴的值的范围（最大值 - 最小值）。

示例

import numpy as np
a = np.array([[3,7,5],[8,4,3],[2,4,9]])
print('我们的数组是：')
print(a)
print('\n')
print('调用 ptp() 函数：')
print(np.ptp(a))
print('\n')
print('沿轴 1 调用 ptp() 函数：')
print(np.ptp(a, axis =  1))
print('\n')
print('沿轴 0 调用 ptp() 函数：')
print(np.ptp(a, axis = 0))

输出结果：

我们的数组是：
[[3 7 5]
[8 4 3]
[2 4 9]]

调用 ptp() 函数：
7

沿轴 1 调用 ptp() 函数：
[4 5 7]

沿轴 0 调用 ptp() 函数：
[6 3 6]

4. numpy.percentile()

百分位数是统计中使用的度量，表示小于这个值得观察值占某个百分比。 函数numpy.percentile()接受以下参数。

numpy.percentile(a, q, axis)

其中： + a 输入数组 + q 要计算的百分位数，在 0 ~ 100 之间 + axis 沿着它计算百分位数的轴

示例

import numpy as np
a = np.array([[30,40,70],[80,20,10],[50,90,60]])
print('我们的数组是：')
print(a)
print('\n')
print('调用 percentile() 函数：')
print(np.percentile(a,50))
print('\n')
print('沿轴 1 调用 percentile() 函数：')
print(np.percentile(a,50, axis = 1))
print('\n')
print('沿轴 0 调用 percentile() 函数：')
print(np.percentile(a,50, axis = 0))

输出结果：

我们的数组是：
[[30 40 70]
 [80 20 10]
 [50 90 60]]

调用 percentile() 函数：
50.0

沿轴 1 调用 percentile() 函数：
[ 40. 20. 60.]

沿轴 0 调用 percentile() 函数：
[ 50. 40. 60.]

5. numpy.median()

中值定义为将数据样本的上半部分与下半部分分开的值。 numpy.median()函数的用法如下面的程序所示。

示例

import numpy as np
a = np.array([[30,65,70],[80,95,10],[50,90,60]])
print('我们的数组是：')
print(a)
print('\n')
print('调用 median() 函数：')
print(np.median(a))
print('\n')
print('沿轴 0 调用 median() 函数：')
print(np.median(a,axis = 0))
print('\n')
print('沿轴 1 调用 median() 函数：')
print(np.median(a,axis = 1))

输出结果：

我们的数组是：
[[30 65 70]
 [80 95 10]
 [50 90 60]]

调用 median() 函数：
65.0

沿轴 0 调用 median() 函数：
[ 50. 90. 60.]

沿轴 1 调用 median() 函数：
[ 65. 80. 60.]

6. numpy.mean()

算术平均值是沿轴的元素的总和除以元素的数量。 numpy.mean()函数返回数组中元素的算术平均值。 如果提供了轴，则沿其计算。

示例

import numpy as np
a = np.array([[1,2,3],[3,4,5],[4,5,6]])
print('我们的数组是：')
print(a)
print('\n')
print('调用 mean() 函数：')
print(np.mean(a))
print('\n')
print('沿轴 0 调用 mean() 函数：')
print(np.mean(a, axis = 0))
print('\n')
print('沿轴 1 调用 mean() 函数：')
print(np.mean(a, axis = 1))

输出结果：

我们的数组是：
[[1 2 3]
 [3 4 5]
 [4 5 6]]

调用 mean() 函数：
3.66666666667

沿轴 0 调用 mean() 函数：
[ 2.66666667 3.66666667 4.66666667]

沿轴 1 调用 mean() 函数：
[ 2. 4. 5.]

7. numpy.average()

加权平均值是由每个分量乘以反映其重要性的因子得到的平均值。 numpy.average()函数根据在另一个数组中给出的各自的权重计算数组中元素的加权平均值。 该函数可以接受一个轴参数。 如果没有指定轴，则数组会被展开。

考虑数组[1,2,3,4]和相应的权重[4,3,2,1]，通过将相应元素的乘积相加，并将和除以权重的和，来计算加权平均值。

加权平均值 = (1*4+2*3+3*2+4*1)/(4+3+2+1)

示例

import numpy as np
a = np.array([1,2,3,4])
print('我们的数组是：')
print(a)
print('\n')
print('调用 average() 函数：')
print(np.average(a))
print('\n')
# 不指定权重时相当于 mean 函数
wts = np.array([4,3,2,1])
print('再次调用 average() 函数：')
print(np.average(a,weights = wts))
print('\n')
# 如果 returned 参数设为 true，则返回权重的和
print('权重的和：')
print(np.average([1,2,3,4],weights = [4,3,2,1], returned = True))

输出结果：

我们的数组是：
[1 2 3 4]

调用 average() 函数：
2.5

再次调用 average() 函数：
2.0

权重的和：
(2.0, 10.0)

　　　　　　 ### 标准差 标准差是与均值的偏差的平方的平均值的平方根。 标准差公式如下：

std = sqrt(mean((x - x.mean())**2))

如果数组是[1，2，3，4]，则其平均值为2.5。 因此，差的平方是[2.25,0.25,0.25,2.25]，并且其平均值的平方根除以4，即sqrt(5/4)是1.1180339887498949。

示例

import numpy as np
print(np.std([1,2,3,4]))

输出结果：

1.1180339887498949

　　　　　　 ### 方差 方差是偏差的平方的平均值，即mean((x - x.mean())** 2)。 换句话说，标准差是方差的平方根。

示例

import numpy as np
print(np.var([1,2,3,4]))

输出结果：

1.25

---

十九、Numpy - 排序、搜索和计数函数

Numpy中提供了各种排序相关功能。 这些排序函数实现不同的排序算法，每个排序算法的特征在于执行速度，最坏情况性能，所需的工作空间和算法的稳定性。 下表显示了三种排序算法的比较。 　　　　　　　　　　　 　　 　　　 　　　　

种类	速度	最坏情况	工作空间	稳定性
quicksort（快速排序）	1	O(n^2)	0	否
mergesort（归并排序	2	O(n*log(n))	~n/2	是
heapsort（堆排序）	3	O(n*log(n))	0	否

1.numpy.sort()

sort()函数返回输入数组的排序副本。 它有以下参数：

numpy.sort(a, axis, kind, order)

其中：

• a 要排序的数组
• axis 沿着它排序数组的轴，如果没有数组会被展开，沿着最后的轴排序
• kind 默认为’quicksort’（快速排序）
• order 如果数组包含字段，则是要排序的字段

示例

import numpy as np
a = np.array([[3,7],[9,1]])
print('我们的数组是：')
print(a)
print('\n')
print('调用 sort() 函数：')
print(np.sort(a))
print('\n')
print('沿轴 0 排序：')
print(np.sort(a, axis =  0))
print('\n')
# 在 sort 函数中排序字段
dt = np.dtype([('name','S10'),('age',int)])
a = np.array([("raju",21),("anil",25),("ravi",17),("amar",27)], dtype = dt)
print('我们的数组是：')
print(a)
print('\n')
print('按 name 排序：')
print(np.sort(a, order =  'name'))

输出结果：

我们的数组是：
[[3 7]
 [9 1]]

调用 sort() 函数：
[[3 7]
 [1 9]]

沿轴 0 排序：
[[3 1]
 [9 7]]

我们的数组是：
[('raju',21) ('anil',25) ('ravi',17) ('amar',27)]

按 name 排序：
[('amar',27) ('anil',25) ('raju',21) ('ravi',17)]

2. numpy.argmax() 和 3. numpy.argmin()

这两个函数分别沿给定轴返回最大和最小元素的索引。

示例

import numpy as np
a = np.array([[30,40,70],[80,20,10],[50,90,60]])
print('我们的数组是：')
print(a)
print('\n')
print('调用 argmax() 函数：')
print(np.argmax(a))
print('\n')
print('展开数组：')
print(a.flatten())
print('\n')
print('沿轴 0 的最大值索引：')
maxindex = np.argmax(a,axis = 0)
print(maxindex)
print('\n')
print('沿轴 1 的最大值索引：')
maxindex = np.argmax(a, axis =  1)
print(maxindex)
print('\n')
print('调用 argmin() 函数：')
minindex = np.argmin(a)
print(minindex)
print('\n')
print('展开数组中的最小值：')
print(a.flatten()[minindex])
print('\n')
print('沿轴 0 的最小值索引：')
minindex = np.argmin(a,axis = 0)
print(minindex)
print('\n')
print('沿轴 1 的最小值索引：')
minindex = np.argmin(a,axis = 1)
print(minindex)

输出结果:

我们的数组是：
[[30 40 70]
 [80 20 10]
 [50 90 60]]

调用 argmax() 函数：
7

展开数组：
[30 40 70 80 20 10 50 90 60]

沿轴 0 的最大值索引：
[1 2 0]

沿轴 1 的最大值索引：
[2 0 1]

调用 argmin() 函数：
5

展开数组中的最小值：
10

沿轴 0 的最小值索引：
[0 1 1]

沿轴 1 的最小值索引：
[0 2 0]

4. numpy.nonzero()

numpy.nonzero()函数返回输入数组中非零元素的索引。

示例

import numpy as np
a = np.array([[30,40,0],[0,20,10],[50,0,60]])
print('我们的数组是：')
print(a)
print('\n')
print('调用 nonzero() 函数：')
print(np.nonzero(a))

输出结果:

我们的数组是：
[[30 40 0]
 [ 0 20 10]
 [50 0 60]]

调用 nonzero() 函数：
(array([0, 0, 1, 1, 2, 2]), array([0, 1, 1, 2, 0, 2]))

5. numpy.where()

where()函数返回输入数组中满足给定条件的元素的索引。

示例

import numpy as np
x = np.arange(9.).reshape(3,3)
print('我们的数组是：')
print(x)
print('大于 3 的元素的索引：')
y = np.where(x > 3)
print(y)
print('使用这些索引来获取满足条件的元素：')
print(x[y])

输出结果:

我们的数组是：
[[ 0. 1. 2.]
 [ 3. 4. 5.]
 [ 6. 7. 8.]]

大于 3 的元素的索引：
(array([1, 1, 2, 2, 2]), array([1, 2, 0, 1, 2]))

使用这些索引来获取满足条件的元素：
[ 4. 5. 6. 7. 8.]

6. numpy.extract()

extract()函数返回满足任何条件的元素。

示例

import numpy as np
x = np.arange(9.).reshape(3,3)
print('我们的数组是：')
print(x)
# 定义条件
condition = np.mod(x,2)  ==  0
print('按元素的条件值：')
print(condition)
print('使用条件提取元素：')
print(np.extract(condition,x))

输出结果:

我们的数组是：
[[ 0. 1. 2.]
 [ 3. 4. 5.]
 [ 6. 7. 8.]]

按元素的条件值：
[[ True False True]
 [False True False]
 [ True False True]]

使用条件提取元素：
[ 0. 2. 4. 6. 8.]

---

二十、Numpy - 副本和视图

在执行函数时，其中一些返回输入数组的副本，而另一些返回视图。 当内容物理存储在另一个位置时，称为副本。 另一方面，如果提供了相同内存内容的不同视图，我们将其称为视图。 ### 无复制 简单的赋值不会创建数组对象的副本。 相反，它使用原始数组的相同id()来访问它。 id()返回 Python 对象的通用标识符，类似于 C 中的指针。

此外，一个数组的任何变化都反映在另一个数组上。 例如，一个数组的形状改变也会改变另一个数组的形状。

示例

import numpy as np
a = np.arange(6)
print('我们的数组是：')
print(a)
print('调用 id() 函数：')
print(id(a))
print('a 赋值给 b：')
b = a
print(b)
print('b 拥有相同 id()：')
print(id(b))
print('修改 b 的形状：')
b.shape = (3,2)
print(b)
print('a 的形状也修改了：')
print(a)

输出结果：

我们的数组是：
[0 1 2 3 4 5]

调用 id() 函数：
139747815479536

a 赋值给 b：
[0 1 2 3 4 5]
b 拥有相同 id()：
139747815479536

修改 b 的形状：
[[0 1]
 [2 3]
 [4 5]]

a 的形状也修改了：
[[0 1]
 [2 3]
 [4 5]]

视图或浅复制

Numpy 拥有ndarray.view()方法，它是一个新的数组对象，并可查看原始数组的相同数据。 与前一种情况不同，新数组的维数更改不会更改原始数据的维数。

示例

import numpy as np
# 最开始 a 是个 3x2 的数组
a = np.arange(6).reshape(3,2)
print('数组 a：')
print(a)
print('创建 a 的视图：')
b = a.view()
print(b)
print('两个数组的 id() 不同：')
print('a 的 id()：')
print(id(a))
print('b 的 id()：')
print(id(b))
# 修改 b 的形状，并不会修改 a
b.shape = (2,3)
print('b 的形状：')
print(b)
print('a 的形状：')
print(a)

输出结果：

数组 a：
[[0 1]
 [2 3]
 [4 5]]

创建 a 的视图：
[[0 1]
 [2 3]
 [4 5]]

两个数组的 id() 不同：
a 的 id()：
140424307227264
b 的 id()：
140424151696288

b 的形状：
[[0 1 2]
 [3 4 5]]

a 的形状：
[[0 1]
 [2 3]
 [4 5]]

深复制

ndarray.copy()函数创建一个深层副本。 它是数组及其数据的完整副本，不与原始数组共享。 示例

import numpy as np
a = np.array([[10,10],[2,3],[4,5]])
print('数组 a：')
print(a)
print('创建 a 的深层副本：')
b = a.copy()
print('数组 b：')
print(b)
# b 与 a 不共享任何内容
print('我们能够写入 b 来写入 a 吗？')
print(b is a)
print('修改 b 的内容：')
b[0,0] = 100
print('修改后的数组 b：')
print(b)
print('a 保持不变：')
print(a)

输出结果：

数组 a：
[[10 10]
 [ 2 3]
 [ 4 5]]

创建 a 的深层副本：
数组 b：
[[10 10]
 [ 2 3]
 [ 4 5]]
我们能够写入 b 来写入 a 吗？
False

修改 b 的内容：
修改后的数组 b：
[[100 10]
 [ 2 3]
 [ 4 5]]

a 保持不变：
[[10 10]
 [ 2 3]
 [ 4 5]]

---

二十一、Numpy - 矩阵库

Numpy 包包含一个 Matrix库numpy.matlib。此模块的函数返回矩阵而不是返回ndarray对象。 #### 1. matlib.empty()

matlib.empty()函数返回一个新的矩阵，而不初始化元素。 该函数接受以下参数。

numpy.matlib.empty(shape, dtype, order)

其中：

• shape 定义新矩阵形状的整数或整数元组
• Dtype 可选，输出的数据类型
• order C 或者 F

示例

import numpy.matlib
import numpy as np
print(np.matlib.empty((2,2)))
# 填充为随机数据

输出结果：

[[ 2.12199579e-314,   4.24399158e-314]
 [ 4.24399158e-314,   2.12199579e-314]]

2. numpy.matlib.zeros()

此函数返回以零填充的矩阵。

示例

import numpy.matlib
import numpy as np
print(np.matlib.zeros((2,2)))

输出结果：

[[ 0.  0.]
 [ 0.  0.]]

3. numpy.matlib.ones()

此函数返回以一填充的矩阵。

示例

import numpy.matlib
import numpy as np
print(np.matlib.ones((2,2)))

输出结果：

[[ 1.  1.]
 [ 1.  1.]]

4. numpy.matlib.eye()

这个函数返回一个矩阵，对角线元素为 1，其他位置为零。 该函数接受以下参数。

numpy.matlib.eye(n,M,k,dtype)

其中：

• n 返回矩阵的行数
• M 返回矩阵的列数，默认为n
• k 对角线的索引
• dtype 输出的数据类型

示例

import numpy.matlib
import numpy as np
print(np.matlib.eye(n = 3,M = 4,k = 0,dtype = float))

输出结果：

[[ 1.  0.  0.  0.]
 [ 0.  1.  0.  0.]
 [ 0.  0.  1.  0.]]

5. numpy.matlib.identity()

numpy.matlib.identity()函数返回给定大小的单位矩阵。单位矩阵是主对角线元素都为 1 的方阵。

示例

import numpy.matlib
import numpy as np
print(np.matlib.identity(5,dtype = float))

输出结果：

[[ 1.  0.  0.  0.  0.]
 [ 0.  1.  0.  0.  0.]
 [ 0.  0.  1.  0.  0.]
 [ 0.  0.  0.  1.  0.]
 [ 0.  0.  0.  0.  1.]]

6. numpy.matlib.rand()

numpy.matlib.rand()函数返回给定大小的填充随机值的矩阵。

示例

import numpy.matlib
import numpy as np
print(np.matlib.rand(3,3))

输出结果：

[[ 0.82674464  0.57206837  0.15497519]
 [ 0.33857374  0.35742401  0.90895076]
 [ 0.03968467  0.13962089  0.39665201]]

注意，矩阵总是二维的，而ndarray是一个 n 维数组。 两个对象都是可互换的。

---

二十二、Numpy - 线性代数

Numpy 包包含numpy.linalg模块，提供线性代数所需的所有功能，此模块中的一些重要功能如下表所述。 　　　　　　　　　 　　　　　　　　 　　　

序号	函数及描述
1.	dot 两个数组的点积
2.	vdot 两个向量的点积
3.	inner 两个数组的内积
4.	matmul 两个数组的矩阵积
5.	determinant 数组的行列式
6.	solve 求解线性矩阵方程
7.	inv 寻找矩阵的乘法逆矩阵

1. numpy.dot()

此函数返回两个数组的点积。 对于二维向量，其等效于矩阵乘法。 对于一维数组，它是向量的内积。 对于 N 维数组，它是a的最后一个轴上的和与b的倒数第二个轴的乘积。

示例

import numpy.matlib
import numpy as np

a = np.array([[1,2],[3,4]])
b = np.array([[11,12],[13,14]])
print(np.dot(a,b))

输出结果：

[[37  40]
 [85  92]]

2. numpy.vdot()

此函数返回两个向量的点积。 如果第一个参数是复数，那么它的共轭复数会用于计算， 如果参数id是多维数组，它会被展开。

示例

import numpy as np
a = np.array([[1,2],[3,4]])
b = np.array([[11,12],[13,14]])
print(np.vdot(a,b))

输出结果：

130

注意：1*11 + 2*12 + 3*13 + 4*14 = 130。

3. numpy.inner()

此函数返回一维数组的向量内积。 对于更高的维度，它返回最后一个轴上的和的乘积。

示例1

import numpy as np
print(np.inner(np.array([1,2,3]),np.array([0,1,0])))
# 等价于 1*0+2*1+3*0

输出结果：

2

示例2

# 多维数组示例
import numpy as np
a = np.array([[1,2], [3,4]])

print('数组 a：')
print(a)
b = np.array([[11, 12], [13, 14]])

print('数组 b：')
print(b)

print('内积：')
print(np.inner(a,b))

输出结果：

数组 a：
[[1 2]
[3 4]]

数组 b：
[[11 12]
[13 14]]

内积：
[[35 41]
[81 95]]

上面的例子中，内积计算如下：

1*11+2*12, 1*13+2*14
3*11+4*12, 3*13+4*14

4. numpy.matmul

numpy.matmul()函数返回两个数组的矩阵乘积。 虽然它返回二维数组的正常乘积，但如果任一参数的维数大于2，则将其视为存在于最后两个索引的矩阵的栈，并进行相应广播。

另一方面，如果任一参数是一维数组，则通过在其维度上附加 1 来将其提升为矩阵，并在乘法之后被去除。

示例1

# 对于二维数组，它就是矩阵乘法
import numpy.matlib
import numpy as np

a = [[1,0],[0,1]]
b = [[4,1],[2,2]]
print(np.matmul(a,b))

输出结果：

[[4  1]
 [2  2]]

示例2

# 二维和一维运算
import numpy.matlib
import numpy as np

a = [[1,0],[0,1]]
b = [1,2]
print(np.matmul(a,b))
print(np.matmul(b,a))

输出结果：

[1  2]
[1  2]

示例3

# 维度大于二的数组
import numpy.matlib
import numpy as np

a = np.arange(8).reshape(2,2,2)
b = np.arange(4).reshape(2,2)
print(np.matmul(a,b))

输出结果：

[[[ 2  3]
  [ 6 11]]

 [[10 19]
  [14 27]]]

5. numpy.linalg.det()

行列式在线性代数中是非常有用的值。 它从方阵的对角元素计算。 对于 2×2 矩阵，它是左上和右下元素的乘积与其他两个的乘积的差。

换句话说，对于矩阵[[a，b]，[c，d]]，行列式计算为ad-bc。 较大的方阵被认为是 2×2 矩阵的组合。

numpy.linalg.det()函数计算输入矩阵的行列式。

示例1

import numpy as np
a = np.array([[1,2], [3,4]])
print(np.linalg.det(a))

输出结果：

-2.0

示例2

import numpy as np
b = np.array([[6,1,1], [4, -2, 5], [2,8,7]])
print(b)
print(np.linalg.det(b))
print(6*(-2*7 - 5*8) - 1*(4*7 - 5*2) + 1*(4*8 - -2*2))

输出结果：

[[ 6  1  1]
 [ 4 -2  5]
 [ 2  8  7]]
-306.0
-306

6. numpy.linalg.solve()

numpy.linalg.solve()函数给出了矩阵形式的线性方程的解。

示例

# numpy.linalg中的函数solve可以求解形如 Ax = b 的线性方程组，其中 A 为矩阵，b 为一维或二维的数组，x 是未知变量

import numpy as np

#创建矩阵和数组
B = np.mat("1 -2 1;0 2 -8;-4 5 9")
b = np.array([0,8,-9])

# 调用solve函数求解线性方程
x = np.linalg.solve(B,b)
print (x)
#[ 29. 16. 3.]

# 使用dot函数检查求得的解是否正确
print (np.dot(B , x))
# [[ 0. 8. -9.]]

#### 7. numpy.linalg.inv()

我们使用numpy.linalg.inv()函数来计算矩阵的逆。 矩阵的逆是这样的，如果它乘以原始矩阵，则得到单位矩阵。

示例1

import numpy as np

x = np.array([[1,2],[3,4]])
y = np.linalg.inv(x)
print(x)
print(y)
print(np.dot(x,y))

输出结果：

[[1 2]
 [3 4]]
[[-2.   1. ]
 [ 1.5 -0.5]]
[[  1.00000000e+00   1.11022302e-16]
 [  0.00000000e+00   1.00000000e+00]]

示例2

现在让我们在示例中创建一个矩阵A的逆。

import numpy as np
a = np.array([[1,1,1],[0,2,5],[2,5,-1]])

print('数组 a：')
print(a)
ainv = np.linalg.inv(a)

print('a 的逆：')
print(ainv)

print('矩阵 b：')
b = np.array([[6],[-4],[27]])
print(b)

print('计算：A^(-1)B：')
x = np.linalg.solve(a,b)
print(x)
# 这就是线性方向 x = 5, y = 3, z = -2 的解

输出结果：

数组 a：
[[ 1 1 1]
 [ 0 2 5]
 [ 2 5 -1]]

a 的逆：
[[ 1.28571429 -0.28571429 -0.14285714]
 [-0.47619048 0.14285714 0.23809524]
 [ 0.19047619 0.14285714 -0.0952381 ]]

矩阵 b：
[[ 6]
 [-4]
 [27]]

计算：A^(-1)B：
[[ 5.]
 [ 3.]
 [-2.]]

结果也可以使用下列函数获取

x = np.dot(ainv,b)

8. numpy.random.randint

生成n行m列的数组，数组元素通过randint随机生成。 例如：

# 生成四行三列的随机整数数组，元素范围为[0,10]
import numpy as np
>>> np.random.randint(0,10,(4,3))

****** #### 2019/1/27更新： 将多维数组展平变成一维： + np.ravel() # 只提供试图 + np.flatten() # 请求分配内存来保存结果 ****** ### 之后有空会学习下Matplotlib，待更新…