Python 11_Python数据处理之NumPy库

一、NumPy库简介

1.1 什么是 NumPy

NumPy 是 Python 中科学计算的基础包。它是一个 Python库，提供多维数组对象、各种派生对象（如掩码数组和矩阵）、以及用于快速操作数组的各种API，包括数学、逻辑、形状、排序、选择、输入输出(I/O)、离散傅立叶变换、基本线性代数、基本统计运算和随机模拟等操作。

NumPy 包的核心是 ndarray 对象。它封装了python原生的同数据类型的 n 维数组，为了保证其性能优良，其中有许多操作都是代码在本地进行编译后执行的。

Tips: NumPy数组在底层使用了C语言实现，并且采用了预编译的代码优化技术。

NumPy数组对象和原生Python Array（数组）之间有几个重要的区别：

NumPy 数组在创建时具有固定的大小，与Python的原生数组(list)对象（可以动态增长）不同。更改ndarray的大小将创建一个新数组并删除原来的数组。
NumPy 数组中的元素都具有相同的数据类型，因此在内存中的大小相同。例外情况：Python的原生数组里包含了NumPy的对象的时候，这种情况下就允许不同大小元素的数组。
NumPy 数组有助于对大量数据进行高级数学和其它类型的操作。通常，这些操作的执行效率更高，比使用Python原生数组的代码更少。
越来越多的基于Python的科学和数学软件包使用NumPy数组; 虽然这些工具通常都支持Python的原生数组作为参数，但它们在处理之前还是会将输入的数组转换为NumPy的数组，而且通常输出也为NumPy数组。换句话说，为了高效地使用当今基于Python的科学/数学工具（大部分的科学计算工具），只知道如何使用Python的原生数组类型是不够的 - 还需要知道如何使用 NumPy 数组。

NumPy的广播功能使得对不同形状的数组进行运算变得更加容易和高效。在进行算术运算、逻辑运算或者其它数组操作时，NumPy会自动调整参与运算的数组的形状，使其能够兼容，从而简化了代码编写和理解。

1.2 NumPy打印数组

当print打印数组时，NumPy以与嵌套列表类似的方式显示它，但具有以下布局：

最后一个轴从左到右打印，
倒数第二个从上到下打印，
其余部分也从上到下打印，每个切片用空行分隔。

然后将一维数组打印为行，将二维数据打印为矩阵，将三维数据打印为矩数组表。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


>>> a = np.arange(6)                         # 1d array
>>> print(a)
[0 1 2 3 4 5]
>>>
>>> b = np.arange(12).reshape(4,3)           # 2d array
>>> print(b)
[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]]
>>>
>>> c = np.arange(24).reshape(2,3,4)         # 3d array
>>> print(c)
[[[ 0  1  2  3]
  [ 4  5  6  7]
  [ 8  9 10 11]]
 [[12 13 14 15]
  [16 17 18 19]
  [20 21 22 23]]]

如果数组太大而无法打印，NumPy会自动跳过数组的中心部分并仅打印角点：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


>>> print(np.arange(10000))
[   0    1    2 ..., 9997 9998 9999]
>>>
>>> print(np.arange(10000).reshape(100,100))
[[   0    1    2 ...,   97   98   99]
 [ 100  101  102 ...,  197  198  199]
 [ 200  201  202 ...,  297  298  299]
 ...,
 [9700 9701 9702 ..., 9797 9798 9799]
 [9800 9801 9802 ..., 9897 9898 9899]
 [9900 9901 9902 ..., 9997 9998 9999]]

要禁用此行为并强制NumPy打印整个数组，可以使用更改打印选项set_printoptions。

1

np.set_printoptions(threshold=sys.maxsize)       # sys module should be imported

二、NumPy库的核心对象 ndarray数组

2.1 NumPy库的核心对象 ndarray 数组概述

NumPy库 的核心对象是 ndarray 同构多维数组，它是一个元素表/集合（通常是数字），集合中的所有元素类型都相同，ndarray 对象以 [0 : (n-1)] 下标为集合中的元素进行索引，在NumPy维度中称为轴。

例如，3D空间中的点的坐标[1, 2, 1]具有一个轴。该轴有3个元素，所以我们说它的长度为3。在下面所示的例子中，line可以表示3D空间中的一条线段，数组有2个轴。第一轴的长度为2，第二轴的长度为3。

1
2
3
4


line = [
    [1, 0, 0], 
    [0, 1, 2]
]

NumPy 的数组类 ndarray 也被别名为 array。请注意：numpy.array 这与标准Python库类 array.array 不同，后者只处理一维数组并提供较少的功能。ndarray对象更重要的属性是：

ndarray.ndim: 数组的轴（维度）的个数。在Python世界中，维度的数量被称为rank。
ndarray.shape: 数组的维度。这是一个整数的元组，表示每个维度中数组的大小。对于有 n 行和 m 列的矩阵，shape 将是 (n,m)。因此，shape 元组的长度就是rank或维度的个数 ndim。
ndarray.size: 数组元素的总数。这等于 shape 的元素的乘积。
ndarray.dtype: 一个描述数组中元素类型的对象。可以使用标准的Python类型创建或指定dtype。另外NumPy提供它自己的类型。例如numpy.int32、numpy.int16和numpy.float64。
ndarray.itemsize: 数组中每个元素的字节大小。例如，元素为 float64 类型的数组的 itemsize 为8（=64/8），而 complex32 类型的数组的 itemsize 为4（=32/8）。它等于 ndarray.dtype.itemsize 。
ndarray.data: 该缓冲区包含数组的实际元素。通常，我们不需要使用此属性，因为我们将使用索引访问数组中的元素。

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


>>> import numpy as np
>>> a = np.arange(15).reshape(3, 5)
>>> a
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14]])
>>> a.shape
(3, 5)
>>> a.ndim
2
>>> a.dtype.name
'int64'
>>> a.itemsize
8
>>> a.size
15
>>> type(a)
<type 'numpy.ndarray'>
>>> b = np.array([6, 7, 8])
>>> b
array([6, 7, 8])
>>> type(b)
<type 'numpy.ndarray'>

ndarray 内部由以下内容组成：

一个指向数据（内存或内存映射文件中的一块数据）的指针。
数据类型或 dtype，描述在数组中的固定的内存单元（格子）。
一个表示数组形状（shape）的元组，表示各维度大小的元组。

2.2 创建 ndarray 数组

调用 NumPy 的 array 函数使用底层 ndarray 构造器可以创建一个 ndarray 数组，该函数从常规Python列表或元组中创建数组。得到的数组的类型是从Python列表中元素的类型推导出来的:

1
2
3


array(object, dtype = None, *, copy = True, order = 'K', subok = False, ndmin = 0, like=None)

ndarray(shape, dtype=float, buffer=None, offset=0, strides=None, order=None)

参数说明：

名称	描述
object	数组或嵌套的数列
dtype	数组元素的数据类型，可选
copy	对象是否需要复制，可选
order	创建数组的内存存储样式，C为行方向，F为列方向（默认），A为任意方向
subok	默认返回一个与基类类型一致的数组
ndmin	指定生成数组的最小维度

示例：

一个维度

1
2
3
4
5
6


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

多于一个维度

1
2
3
4
5


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

最小维度

1
2
3
4


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

dtype 参数

1
2
3
4


import numpy as np 
a = np.array([1,  2,  3], dtype = complex)  
print (a)
# [1.+0.j 2.+0.j 3.+0.j]

ndarray 数组除了可以使用底层 ndarray 构造器来创建外，也可以通过以下几种方式来创建：

Tips: 通常，数组的元素最初是未知的，但它的大小是已知的。因此，NumPy提供了几个函数来创建具有初始占位符内容的数组。这就减少了数组增长的必要，因为数组增长的操作花费很大。

numpy.empty 函数用来创建一个指定形状（shape）、数据类型（dtype）且未初始化的数组

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


# 函数原型
numpy.empty(shape, dtype = float, order = 'C')
'''
参数说明：
shape：数组形状
dtype：数据类型，可选
order：有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。
'''
# 示例：
import numpy as np 
x = np.empty([3,2], dtype = int) 
print (x)
# 注：数组元素为随机值，因为它们未初始化。

numpy.empty_like 用于创建一个与给定数组具有相同形状且未初始化的数组

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


# 函数原型
numpy.empty_like(a, dtype=None, order='K', subok=True)
'''
参数说明：
a：给定要创建相同形状的数组
dtype：创建的数组的数据类型
order：数组在内存中的存储顺序，可选值为 'C'（按行优先）或 'F'（按列优先），默认为 'K'（保留输入数组的存储顺序）
subok：是否允许返回子类，如果为 True，则返回一个子类对象，否则返回一个与 a 数组具有相同数据类型和存储顺序的数组
shape：创建的数组的形状，如果不指定，则默认为 a 数组的形状。
'''
# 示例
import numpy as np 
# 创建一个 3x3 的二维数组
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) 
# 创建一个与 arr 形状相同的，所有元素都为 0 的数组
empty_like = np.empty_like(arr)
print(empty_like)

Tips：numpy.empty 和 numpy.empty_like 都是用于创建一个指定形状的数组，其中所有元素都是未初始化的，它们之间的区别在于：

numpy.empty 可以直接指定要创建的数组的形状；

numpy.empty_like 则是创建一个与给定数组具有相同形状的数组。

numpy.zeros 创建指定大小的数组，数组元素以 0 来填充

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


# 函数原型
numpy.zeros(shape, dtype = float, order = 'C')
'''
参数说明：
shape：数组形状
dtype：数据类型，可选
order：'C' 用于 C 的行数组，或者 'F' 用于 FORTRAN 的列数组
'''
# 示例
import numpy as np
# 默认为浮点数
x = np.zeros(5)
print(x)
# 设置类型为整数
y = np.zeros((5,), dtype = int)
print(y)

numpy.zeros_like 用于创建一个与给定数组具有相同形状的数组，数组元素以 0 来填充

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


# 函数原型
numpy.zeros_like(a, dtype=None, order='K', subok=True, shape=None)
'''
参数说明：
a：给定要创建相同形状的数组
dtype：创建的数组的数据类型
order：数组在内存中的存储顺序，可选值为 'C'（按行优先）或 'F'（按列优先），默认为 'K'（保留输入数组的存储顺序）
subok：是否允许返回子类，如果为 True，则返回一个子类对象，否则返回一个与 a 数组具有相同数据类型和存储顺序的数组
shape：创建的数组的形状，如果不指定，则默认为 a 数组的形状。
'''
# 示例
import numpy as np 
# 创建一个 3x3 的二维数组
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) 
# 创建一个与 arr 形状相同的，所有元素都为 0 的数组
zeros_arr = np.zeros_like(arr)
print(zeros_arr)

Tips：numpy.zeros 和 numpy.zeros_like 都是用于创建一个指定形状的数组，其中所有元素都是 0，它们之间的区别在于：

numpy.zeros 可以直接指定要创建的数组的形状；

numpy.zeros_like 则是创建一个与给定数组具有相同形状的数组。

numpy.ones 创建指定形状的数组，数组元素以 1 来填充

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


# 函数原型
numpy.ones(shape, dtype = float, order = 'C')
'''
参数说明：
shape：数组形状
dtype：数据类型，可选
order：'C' 用于 C 的行数组，或者 'F' 用于 FORTRAN 的列数组
'''
# 示例
import numpy as np 
# 默认为浮点数
x = np.ones(5) 
print(x) 
# 自定义类型
x = np.ones([2,2], dtype = int)
print(x)

numpy.ones_like 用于创建一个与给定数组具有相同形状的数组，数组元素以 1 来填充

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


# 函数原型
numpy.ones_like(a, dtype=None, order='K', subok=True, shape=None)
'''
参数说明：
a：给定要创建相同形状的数组
dtype：创建的数组的数据类型
order：数组在内存中的存储顺序，可选值为 'C'（按行优先）或 'F'（按列优先），默认为 'K'（保留输入数组的存储顺序）
subok：是否允许返回子类，如果为 True，则返回一个子类对象，否则返回一个与 a 数组具有相同数据类型和存储顺序的数组
shape：创建的数组的形状，如果不指定，则默认为 a 数组的形状。
'''
# 示例
import numpy as np 
# 默认为浮点数
x = np.ones_like(5) 
print(x) 
# 自定义类型
x = np.ones_like([2,2], dtype = int)
print(x)

Tips: numpy.ones 和 numpy.ones_like 都是用于创建一个指定形状的数组，其中所有元素都是 1。它们之间的区别在于：

numpy.ones 可以直接指定要创建的数组的形状;

numpy.ones_like 则是创建一个与给定数组具有相同形状的数组。

numpy.asarray 类似 numpy.array，但 numpy.asarray 参数只有三个，比 numpy.array 少两个。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


# 函数原型
numpy.asarray(a, dtype = None, order = None)
'''
参数说明：
a：任意形式的输入参数，可以是，列表, 列表的元组, 元组, 元组的元组, 元组的列表，多维数组
dtype：数据类型，可选
order：可选，有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。
'''
# 示例
import numpy as np  
x =  [1,2,3] 
a = np.asarray(x, dtype =  float)  
print(a)
# [ 1.  2.  3.]

numpy.fromiter 方法从可迭代对象中建立 ndarray 对象，返回一维数组。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


# 函数原型
numpy.fromiter(iterable, dtype, count=-1)
'''
参数说明：
iterable：可迭代对象
dtype：返回数组的数据类型
count：读取的数据数量，默认为-1，读取所有数据
'''
# 示例
import numpy as np
# 使用 range 函数创建列表对象
list=range(5)
it=iter(list)
# 使用迭代器创建 ndarray
x=np.fromiter(it, dtype=float)
print(x)
# [0. 1. 2. 3. 4.]

numpy.arange 函数根据 start 与 stop 指定的范围以及 step 设定的步长，生成一个 ndarray。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


# 函数原型
numpy.arange([start,] stop[, step,], dtype=None, *, like=None)
'''
参数说明：
start：起始值，默认为0
stop：终止值（不包含）
step：步长，默认为1
dtype：返回ndarray的数据类型，如果没有提供，则会使用输入数据的类型。
'''
# 示例
import numpy as np 
# 设置了 dtype
x = np.arange(5, dtype =  float) 
print (x)
x = np.arange(10,20,2)  
print (x)

numpy.linspace 函数用于创建一个一维数组，数组是一个等差数列构成的

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


# 函数原型
np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
'''
参数说明：
start：序列的起始值
stop：序列的终止值，如果endpoint为true，该值包含于数列中
num：要生成的等步长的样本数量，默认为50
endpoint：该值为 true 时，数列中包含stop值，反之不包含，默认是True。
retstep：如果为 True 时，生成的数组中会显示间距，反之不显示。
dtype：ndarray 的数据类型
'''
# 示例
import numpy as np 
# 设置了 dtype
x = np.linspace(5, 10, dtype =  float) 
print (x)
x = np.linspace(10,20,2)  
print (x)

numpy.random.random

1

b = np.random.random((2,3))

numpy.random.mtrand.RandomState.rand
numpy.random.mtrand.RandomState.randn
numpy.fromfunction

2.3 ndarray 数组的属性

NumPy 数组的维数称为秩（rank），秩就是轴的数量，即数组的维度，一维数组的秩为 1，二维数组的秩为 2，以此类推。

在 NumPy中，每一个线性的数组称为是一个轴（axis），也就是维度（dimensions）。比如说，二维数组相当于是两个一维数组，其中第一个一维数组中每个元素又是一个一维数组。所以一维数组就是 NumPy 中的轴（axis），第一个轴相当于是底层数组，第二个轴是底层数组里的数组。而轴的数量——秩，就是数组的维数。

很多时候可以声明 axis=0，表示沿着第 0 轴进行操作，即对每一列进行操作；axis=1，表示沿着第1轴进行操作，即对每一行进行操作。

NumPy 的数组中比较重要 ndarray 对象属性有：

属性	说明
ndarray.ndim	秩，即轴的数量或维度的数量
ndarray.shape	数组的维度，对于矩阵，n 行 m 列
ndarray.size	数组元素的总个数，相当于 .shape 中 n*m 的值
ndarray.dtype	ndarray 对象的元素类型
ndarray.itemsize	ndarray 对象中每个元素的大小，以字节为单位
ndarray.flags	ndarray 对象的内存信息

ndarray.ndim 用于返回数组的维数，等于秩

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


import numpy as np  
a = np.arange(24) 
print (a.ndim)
# 1             
# a只有一个维度

b = np.array([[1,2],[1,2]])
print (b.ndim)
# 2
# b是二维数组

ndarray.shape 表示数组的维度

1
2
3
4


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

.shape 为一个元组，这个元组的长度就是维度的数目，即 ndim 属性(秩)。比如，一个二维数组，其维度表示"行数"和"列数"。ndarray.shape 也可以用于调整数组大小。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


import numpy as np  
a = np.array([[1,2,3],[4,5,6]]) 
a.shape = (3,2)  
print(a)
# a被调整为里面有3个数组, 每个数组有2个元素
"""
输出
[[1 2]
 [3 4]
 [5 6]]
"""

NumPy 也提供了 reshape 函数来调整数组形状。

1
2
3
4
5
6
7
8
9


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

2.4 ndarray 数组索引、切片和迭代

ndarray对象的内容可以通过索引、切片和迭代来访问或修改，与 Python 中 list 的索引、切片和迭代操作类似。

ndarray 数组可以基于 0 - n 的下标进行索引，切片对象可以通过内置的 slice 函数，并设置 start, stop 及 step 参数进行，从原数组中切割出一个新数组。

1
2
3
4
5
6
7


import numpy as np 
a = np.arange(10)
a[3]
# 3
s = slice(2,7,2)   # 从索引 2 开始到索引 7 停止，间隔为2
print (a[s])
# [2  4  6]

以上实例中，首先通过 arange() 函数创建 ndarray 对象。然后，分别设置起始，终止和步长的参数为 2，7 和 2。

也可以通过冒号分隔切片参数 start:stop:step 来进行切片操作：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


import numpy as np 
a = np.arange(10)  
a[ : :-1]          # reversed a
a[:6:2] = -1000    # equivalent to a[0:6:2] = -1000; from start to position 6, exclusive, set every 2nd element to -1000
b = a[2:7:2]   # 从索引 2 开始到索引 7 停止，间隔为 2
print(b)
# [2  4  6]

# 迭代
for i in a:
    print(i**(1/3.))

冒号 : 的解释：如果只放置一个参数，如 [2]，将返回与该索引相对应的单个元素。如果为 [2:]，表示从该索引开始以后的所有项都将被提取。如果使用了两个参数，如 [2:7]，那么则提取两个索引(不包括停止索引)之间的项。

多维的数组每个轴可以有一个索引，这些索引以逗号分隔的元组或 : 连接的方式给出。

多维数组同样适用上述索引提取方法：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


import numpy as np 

def f(x,y):
    return 10*x+y

b = np.fromfunction(f,(5,4),dtype=int)
b[2,3]  # 23

b[(0, 5), 1]
b[0:5, 1]                       # each row in the second column of b
# array([ 1, 11, 21, 31, 41])

b[ : ,1]                        # equivalent to the previous example
# array([ 1, 11, 21, 31, 41])

b[1:3, : ]                      # each column in the second and third row of b
# array([[10, 11, 12, 13],
#        [20, 21, 22, 23]])

# 从数组索引 a[1:] 处开始切割
print(a[1:])
"""
Output：
[[3 4 5]
 [4 5 6]]
"""

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

三个点（ … ）表示产生完整索引元组所需的冒号。例如，如果 x 是rank为5的数组（即，它具有5个轴），则：

x[1,2,…] 相当于 x[1,2,:,:,:]，
x[…,3] 等效于 x[:,:,:,:,3]
x[4,…,5,:] 等效于 x[4,:,:,5,:]。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


>>> c = np.array( [[[  0,  1,  2],               # a 3D array (two stacked 2D arrays)
...                 [ 10, 12, 13]],
...                [[100,101,102],
...                 [110,112,113]]])
>>> c.shape
(2, 2, 3)
>>> c[1,...]                                   # same as c[1,:,:] or c[1]
array([[100, 101, 102],
       [110, 112, 113]])
>>> c[...,2]                                   # same as c[:,:,2]
array([[  2,  13],
       [102, 113]])

1
2
3
4
5


import numpy as np 
a = np.array([[1,2,3],[3,4,5],[4,5,6]])  
print (a[...,1])   # 第2列元素
print (a[1,...])   # 第2行元素
print (a[...,1:])  # 第2列及剩下的所有元素

对多维数组进行迭代（Iterating）是相对于第一个轴完成的：

1
2
3
4
5
6
7
8


>>> for row in b:
...     print(row)
...
[0 1 2 3]
[10 11 12 13]
[20 21 22 23]
[30 31 32 33]
[40 41 42 43]

如果想要对数组中的每个元素执行操作，可以使用flat属性，该属性是数组的所有元素的迭代器：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


>>> for element in b.flat:
...     print(element)
...
0
1
2
3
.
.
.

Tips: 索引相关另见 Indexing, Indexing (reference), newaxis, ndenumerate, indices 等

2.5 NumPy 高级索引

除了用整数和切片的索引外，numpy 数组还提供更多的索引方式，如整数数组索引、布尔索引及花式索引等。

NumPy 中的高级索引指的就是使用整数数组、布尔数组或者其他序列来访问数组的元素。相比于基本索引，高级索引可以访问到数组中的任意元素，并且可以用来对数组进行复杂的操作和修改。

整数数组索引

整数数组索引是指使用一个数组来访问另一个数组的元素。这个数组中的每个元素都是目标数组中某个维度上的索引值。

1
2
3
4
5


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]

获取 4 X 3 数组中的四个角的元素。行索引是 [0,0] 和 [3,3]，而列索引是 [0,2] 和 [0,2]。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


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 2 ]
 [ 9 11]]
"""
y2 = x[[0,0,3,3], [0,2,0,2]]
"""
[ 0 2 9 11]
"""

还可以借助切片 : 或 … 与索引数组组合。

1
2
3
4
5
6
7
8


import numpy as np 
a = np.array([[1,2,3], [4,5,6],[7,8,9]])
b = a[1:3, 1:3]
c = a[1:3,[1,2]]
d = a[...,1:]
print(b)
print(c)
print(d)

布尔索引

布尔索引也叫逻辑索引，可以通过一个布尔数组来索引目标数组。

布尔索引通过布尔运算（如：比较运算符）来获取符合指定条件的元素的数组。

取大于 5 的元素：

1
2
3
4
5
6


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 (x[x >  5])

使用 ~（取补运算符）来过滤 NaN。

1
2
3


import numpy as np  
a = np.array([np.nan,  1,2,np.nan,3,4,5])  
print (a[~np.isnan(a)])

从数组中过滤掉非复数元素。

1
2
3


import numpy as np  
a = np.array([1,  2+6j,  5,  3.5+5j])  
print (a[np.iscomplex(a)])

花式索引

花式索引指的是利用整数数组进行索引。花式索引根据索引数组的值作为目标数组的某个轴的下标来取值。

对于使用一维整型数组作为索引，如果目标是一维数组，那么索引的结果就是对应位置的元素，如果目标是二维数组，那么就是对应下标的行。

花式索引跟切片不一样，它总是将数据复制到新数组中。

一维数组只有一个轴 axis = 0，所以一维数组就在 axis = 0 这个轴上取值：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


import numpy as np
x = np.arange(9) + 10
print(x)
# 一维数组读取指定下标对应的元素
print("-------读取下标对应的元素-------")
x2 = x[[4, 2, 7, 0]] # 使用花式索引获取（顺序索引数组） 第4, 2, 7，0 个元素： [14 12 17, 0]
x2 = x[[-4, -2, -7, -0]] # 使用花式索引获取（倒序索引数组） 第4, 2, 7，0 个元素： [14 12 17, 0]
print(x2)
print(x2[0])
print(x2[1])

二维数组

1
2
3
4
5
6


import numpy as np  
x=np.arange(32).reshape((8,4))
print(x)
print("-------读取下标对应的行-------")
print (x[[4,2,1,7]])        # 二维数组读取指定下标对应的行, 顺序索引数组
print (x[[-4,-2,-1,-7]])    # 二维数组读取指定下标对应的行, 倒序索引数组

传入多个索引数组（要使用 np.ix_）

np.ix_() 函数就是输入两个数组，产生笛卡尔积的映射关系。

笛卡尔乘积是指在数学中，两个集合 X 和 Y 的笛卡尔积（Cartesian product），又称直积，表示为 X×Y，第一个对象是X的成员而第二个对象是 Y 的所有可能有序对的其中一个成员。

例如 A={a,b}, B={0,1,2}，则：

1
2


A×B={(a, 0), (a, 1), (a, 2), (b, 0), (b, 1), (b, 2)} 
B×A={(0, a), (0, b), (1, a), (1, b), (2, a), (2, b)}

2.6 NumPy 广播(Broadcast)

广播(Broadcast)是 numpy 对不同形状(shape)的数组进行数值计算的方式，对数组的算术运算通常在相应的元素上进行。

如果两个数组 a 和 b 形状相同，即满足 a.shape == b.shape，那么 a*b 的结果就是 a 与 b 数组对应位置的元素相乘。这要求维数相同，且各维度的长度相同。

1
2
3
4
5


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

当运算中的 2 个数组的形状不同时，numpy 将自动触发广播机制。

1
2
3
4
5
6
7


import numpy as np  
a = np.array([[ 0, 0, 0], [10,10,10],[20,20,20],[30,30,30]])
b = np.array([0,1,2])
c = np.array([2])
print(a + b)
print(a + c)
print(b + c)

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

让所有输入数组都向其中形状最长的数组看齐，形状中不足的部分都通过复制前面的进行补齐。
输出数组的形状是输入数组形状的各个维度上的最大值。
如果输入数组的某个维度和输出数组的对应维度的长度相同或者其长度为 1 时，这个数组能够用来计算，否则出错。
当输入数组的某个维度的长度为 1 时，沿着此维度运算时都用此维度上的第一组值。

简单理解：对两个数组，分别比较它们的每一个维度（若其中一个数组没有当前维度则忽略），满足：

数组拥有相同形状。

当前维度的值相等。

当前维度的值有一个是 1。

若条件不满足，抛出 “ValueError: operands could not be broadcast with shape () ()” 异常。

2.7 Numpy 数组操作

修改数组形状

ndarray.reshape 函数可以在不改变数据的条件下修改形状，格式如下：

1

numpy.reshape(arr, newshape, order='C')

arr：要修改形状的数组
newshape：整数或者整数数组，新的形状应当兼容原有形状
order：‘C’ – 按行，‘F’ – 按列，‘A’ – 原顺序，‘k’ – 元素在内存中的出现顺序。

1
2
3
4
5
6
7
8


import numpy as np 
a = np.arange(8)
print ('原始数组：')
print (a)
print ('\n') 
b = a.reshape(4,2) # 参数也可写作元组 b = a.reshape((4,2)) 
print ('修改后的数组：')
print (b)

numpy.ndarray.flat 数组元素迭代器

1
2
3
4
5
6
7
8


import numpy as np 
a = np.arange(9).reshape(3,3) 
 
for row in a:
  print (row)
 
for element in a.flat:
    print (element)

numpy.ndarray.flatten 返回一份数组拷贝

对拷贝所做的修改不会影响原始数组，格式如下：

1

ndarray.flatten(order='C')

参数说明：

order(可选)：‘C’ – 按行，‘F’ – 按列，‘A’ – 原顺序，‘K’ – 元素在内存中的出现顺序。

1
2
3
4
5
6
7
8
9


import numpy as np 
a = np.arange(8).reshape(2,4) 
print ('原数组：')
print (a)
print ('\n')# 默认按行 print ('展开的数组：')
print (a.flatten())
print ('\n') 
print ('以 F 风格顺序展开的数组：')
print (a.flatten(order = 'F'))

numpy.ravel() 展平的数组元素(扁平化)

顺序通常是"C风格"，返回的是数组视图（view，有点类似 C/C++引用reference的意味），修改会影响原始数组。

1

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

参数说明：

order：‘C’ – 按行，‘F’ – 按列，‘A’ – 原顺序，‘K’ – 元素在内存中的出现顺序。

1
2
3
4
5
6


import numpy as np 
a = np.arange(8).reshape(2,4) 
print ('原数组：')
print (a)
print (a.ravel())
print (a.ravel(order = 'F'))

numpy.transpose 和 ndarray.T 翻转数组

numpy.transpose 函数用于对换数组的维度，格式如下：

1

numpy.transpose(arr, axes)

参数说明:

arr：要操作的数组
axes：整数列表，对应维度，通常所有维度都会对换。

1
2
3
4


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

ndarray.T 类似 numpy.transpose：

1
2
3
4
5
6


import numpy as np 
a = np.arange(12).reshape(3,4) 
print ('原数组：')
print (a)
print ('转置数组：')
print (a.T)

numpy.concatenate 连接数组

numpy.concatenate 函数用于沿指定轴连接相同形状的两个或多个数组，格式如下：

1

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

参数说明：

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

1
2
3
4
5
6
7


import numpy as np 
a = np.array([[1,2],[3,4]]) 
print (a)
b = np.array([[5,6],[7,8]]) 
print (b)
print (np.concatenate((a,b)))#沿轴 0 连接两个数组
print (np.concatenate((a,b),axis = 1))#沿轴 1 连接两个数组

分割数组

函数	数组及操作
split	将一个数组分割为多个子数组
hsplit	将一个数组水平分割为多个子数组（按列）
vsplit	将一个数组垂直分割为多个子数组（按行）

numpy.split 函数沿特定的轴将数组分割为子数组，格式如下：

1

numpy.split(ary, indices_or_sections, axis)

参数说明：

ary：被分割的数组
indices_or_sections：如果是一个整数，就用该数平均切分，如果是一个数组，为沿轴切分的位置（左开右闭）
axis：设置沿着哪个方向进行切分，默认为 0，横向切分，即水平方向。为 1 时，纵向切分，即竖直方向。

1
2
3
4
5
6
7
8
9


import numpy as np a = np.arange(9)
 print (a)
#[0 1 2 3 4 5 6 7 8]
​b = np.split(a,3)
#将数组分为三个大小相等的子数组
print (b)#[array([0, 1, 2]), array([3, 4, 5]), array([6, 7, 8])]​
b = np.split(a,[4,7])
#将数组在一维数组中表明的位置分割
print (b)#[array([0, 1, 2, 3]), array([4, 5, 6]), array([7, 8])]

axis 为 0 时在水平方向分割，axis 为 1 时在垂直方向分割：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


import numpy as np
a = np.arange(16).reshape(4, 4)
print('第一个数组：')
print(a)
print('\n')
print('默认分割（0轴）：')
b = np.split(a,2)
print(b)
print('\n')
print('沿水平方向分割：')
c = np.split(a,2,1)
print(c)
print('\n')
print('沿水平方向分割：')
d= np.hsplit(a,2)
print(d)

numpy.hsplit 函数用于水平分割数组，通过指定要返回的相同形状的数组数量来拆分原数组。

1
2
3
4
5
6
7


import numpy as np 
 
a = np.arange(16).reshape(4,4) 
print (a)
 
b = np.hsplit(a,2)
print (b)

numpy.vsplit 沿着垂直轴分割，其分割方式与hsplit用法相同。

1
2
3
4
5
6
7


import numpy as np 
 
a = np.arange(16).reshape(4,4) 
print (a)
 
b = np.vsplit(a,2)
print (b)

三、npy格式文件

3.1 npy格式文件概述

NumPy提供了多种存取数组内容的文件操作函数。保存数组数据的文件可以是二进制格式或者文本格式。二进制格式的文件又分为NumPy专用的 npy 格式化二进制类型和无格式二进制类型。

npy 格式文件(通常文件名后缀为 .npy ) 是 NumPy库用于保存 NumPy数组数据的 二进制文件格式。设计该格式文件目的在于高效地保存和读取NumPy的多维数组。这个格式成为了科学计算和数据分析中的一个标准，特别是在需要将数据快速保存到磁盘或者在不同环境间共享NumPy数组时。

npy格式文件以二进制形式存储数据，这意味着它能够比文本文件（如CSV）更加高效地保存大型数组数据。二进制格式允许直接映射到内存，从而加快了读写速度。

该格式不仅保存数组的数据，还包含了数组的形状（维度）、数据类型以及其它必要的元数据信息，确保了数据的完整性。这意味着在加载数据时，可以完全重现保存时的数组，而无需任何额外的转换或解析。

Tips: npy文件能够保存NumPy数组的结构、数据类型以及数据内容，使得我们可以方便地持久化数组数据并在需要时重新加载。

npy文件的优点在于其高效性、易用性和通用性。通过将数组数据保存为 npy文件，可以避免在每次程序运行时重新计算或生成数组数据，从而提高程序的运行效率。

同时，npy格式文件的设计考虑到了跨平台的兼容性问题，确保在不同的操作系统和硬件架构之间能够正确地读写文件。这包括了对字节序（大端或小端）的处理，使得在不同架构之间共享文件时不会出现问题。

npy文件格式设计了版本控制机制，即使格式在未来进行更新，旧版的NumPy库仍然能够读取新版保存的文件，保证了向后兼容性。

npy文件由以下几个主要部分组成：

魔术字符串：文件的开头是一个固定的ASCII字符串，用来标识该文件为.npy格式。
版本号：紧接着魔术字符串的是格式版本号，它告诉NumPy如何解析剩余的文件内容。
头部长度：指出头部信息（元数据）的长度。
头部数据：一个包含数组元数据的字典序列化为字符串的形式，例如数组的形状、数据类型等。这部分使用JSON或Python字典的形式存储。
数组数据：数组的实际数据部分，直接以二进制形式存储。

3.2 npy格式文件的读写

保存NumPy数组为npy文件可以使用 NumPy库中的 numpy.save() 函数

1
2


# 函数原型：
numpy.save(file, arr, allow_pickle=True, fix_imports=<no value>)

下面是一个简单的示例：

1
2
3
4
5
6
7


import numpy as np

# 创建一个NumPy数组
arr = np.array([[1, 2, 3], [4, 5, 6]])

# 将数组保存为npy文件
np.save('array.npy', arr)

在上面的代码中，首先导入了NumPy库，并创建了一个二维数组 arr。然后，使用 np.save() 函数将该数组保存到名为 array.npy 的文件中。保存的文件将包含数组的结构、数据类型和数据内容。

np.save 除了可以保存整个数组外，还可以只保存数组的一部分。例如，可以保存数组的一个切片或选择特定行或列的数据进行保存。这可以通过在 np.save() 函数中指定要保存的数组切片或索引来实现。

读取（加载）npy文件可以使用 NumPy库中的 numpy.load() 函数

1
2


# 函数原型：
numpy.load(file, mmap_mode=None, allow_pickle=False, fix_imports=True, encoding='ASCII', *, max_header_size=10000)

下面是一个加载npy文件的示例：

1
2
3
4
5
6
7


import numpy as np

# 加载npy文件
loaded_arr = np.load('array.npy')

# 打印加载的数组
print(loaded_arr)

在上面的代码中，使用 np.load() 函数加载了 array.npy 文件，并将其内容赋值给变量loaded_arr。加载得到的 loaded_arr 是一个与原始写入array.npy 文件数组结构和内容相同的NumPy数组对象。可以通过打印loaded_arr来验证加载的结果。

Tips: 加载 npy文件时不需要指定数组的形状或数据类型，因为这些信息在保存文件时已经包含在内。加载函数会自动根据文件中的信息还原出原始的NumPy数组。

npz 文件：

对于需要同时保存多个数组的场景，可以使用 npz格式文件进行保存，它可以通过 np.savez() 或 np.savez_compressed() 函数来实现，后者提供了压缩功能以进一步节省存储空间。

npz 文件 实际上是一个压缩的文件包，内部可以包含多个 npy 文件，每个 npy 文件存储一个数组。当需要保存多个 NumPy 数组时，就可以使用 npz 格式文件进行存储。

保存到多个数组到 npz 文件

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


import numpy as np

# 创建一个数组
arr = np.array([1, 2, 3, 4, 5])
# 创建另一个数组
arr2 = np.array([10, 20, 30, 40, 50])

# 保存多个数组到一个.npz文件
np.savez('my_arrays.npz', arr1=arr, arr2=arr2)

# 或者保存为压缩文件
np.savez_compressed('my_arrays_compressed.npz', arr1=arr, arr2=arr2)

从 npz 文件加载数组

1
2
3
4
5
6
7
8


import numpy as np

# 从.npz文件加载数据
data = np.load('my_arrays.npz')

# 访问保存的数组
arr1_loaded = data['arr1']
arr2_loaded = data['arr2']

使用这些方法，NumPy 能够高效地保存和加载数据，方便数据的持久化存储和传输。

3.3 numpy 写/读无格式二进制类型文件

tofile() 将数组中的数据以二进制格式写进文件，输出的数据不保存数组形状和元素类型等信息。
fromfile() 函数读回数据时需要用户指定元素类型，并对数组的形状进行适当的修改。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


# 函数原型：
ndarray.tofile(fid, sep='', format='%s')
numpy.fromfile(file, dtype=float, count=-1, sep='', offset=0, *, like=None)

# 示例
import numpy as np

a = np.arange(0,12)
a.shape = 3,4

a.tofile("a.bin")
print(a.dtype) # int32
b = np.fromfile("a.bin", dtype=np.float)    # 按照float类型读入数据，是错误的
c = np.fromfile("a.bin", dtype=np.int32)    # 按照int32类型读入数据是一维的
c.shape = 3,4   # 修改数组形状

从上面的例子可以看出，在读入数据时: 需要正确设置dtype参数，并修改数组的shape属性才能得到和原始数据一致的结果。

无论数据的排列顺序是C语言格式还是Fortran语言格式，tofile()都统一使用C语言格式输出。此外如果指定了sep 参数，则fromfile()和tofile()将以文本格式对数组进行输入输出。sep参数指定的是文本数据中数值的分隔符。

3.4 loadtxt()、savetxt() 读写文本文件

savetxt() 函数是以简单的文本文件格式存储数据，对应的使用 loadtxt() 函数来获取数据。可以用 .txt 或者 .csv 为扩展名。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47


# 函数原型
np.loadtxt(FILENAME, dtype=int, delimiter=' ',skiprows=0, usecols=None,unpack=False)
np.savetxt(FILENAME, a, fmt="%d", delimiter=",")
# 参数 delimiter 可以指定各种分隔符、针对特定列的转换器函数、需要跳过的行数等。

# 示例:
import numpy as np

a = np.array([[1, 2, 3, 4, 5], [7, 8, 9, 10, 11]])
# delimiter 用什么分割数据
# fmt  保存的数据格式
# skiprows 跳过前几行。一般跳过表头
# dtype 指定数据类型
# usecols 取哪几列
# unpack 转置 效果 类似 numpy.transpose   ndarray.T
np.savetxt('out.txt', a, delimiter=",", fmt="%d,%d,%.3f,%.3f,%.3f")
b = np.loadtxt('out.txt', delimiter=",", skiprows=0, dtype=np.int32, usecols=(0,1,2))
b1 = np.loadtxt('out.txt', delimiter=",", skiprows=0, dtype=np.int32, usecols=(0,1,2), unpack=True)
print(b)
print("*"*20)
print(b1)
print("*"*20)
a = np.array([1, 2, 3, 4, 5])
np.savetxt('out1.txt', a, delimiter=",", fmt="%d")
b = np.loadtxt('out1.txt', delimiter=",")

print(b)
"""
[[1 2 3]
 [7 8 9]]
********************
[[1 7]
 [2 8]
 [3 9]]
********************
[1. 2. 3. 4. 5.]

out.txt:
1,2,3.000,4.000,5.000
7,8,9.000,10.000,11.000
out1.txt
1
2
3
4
5
"""

3.5 npy文件的使用场景

npy文件在数据科学、机器学习等领域有着广泛的应用场景。以下是一些常见的使用场景示例：

快速保存和加载数据：对于机器学习模型训练中的中间数据，或者科学计算中的大型数据集，npy格式提供了一种快速的数据保存和加载方法。
数据持久化：由于其向后兼容的设计，即使是未来的NumPy版本也能读取以前保存的 npy文件，使其成为一个稳定的长期数据存储方案。在数据分析和处理过程中，经常需要将中间结果或最终结果保存下来，以便后续使用或共享。通过将数组数据保存为npy文件，可以实现数据的持久化存储，避免重复计算或数据丢失。
模型参数保存：在机器学习中，模型的参数通常是以数组的形式存在的。可以将模型参数保存为npy文件，以便在训练完成后加载模型进行推理或进一步微调。
数据集处理：在处理大型数据集时，可能需要将数据集划分为多个部分，并将每部分保存为npy文件。这样，在后续的训练或评估过程中，可以按需加载数据集的不同部分，提高数据处理效率。
数据压缩：npy文件支持数据的压缩存储，可以在保存文件时选择使用压缩算法来减小文件大小。这对于存储大型数组数据特别有用，可以节省存储空间并提高数据传输效率。
数据共享：npy文件作为一种通用的数组数据格式，因其完整性和兼容性而成为一个理想的选择，可以方便地与其他人共享数据。通过保存数组为npy文件，我们可以轻松地将数据发送给其他使用NumPy的研究人员或开发人员，实现数据的快速共享和复用。
跨语言互操作性：尽管npy文件是NumPy特有的格式，但其它科学计算库或工具也提供了对npy文件的支持。例如，SciPy、Pandas等库都可以轻松地加载npy文件，这使得我们可以在不同的库和工具之间无缝地传递和使用数组数据。
并行计算和分布式处理：在处理大规模数据时，可能需要利用并行计算和分布式处理来提高计算效率。npy文件可以作为数据交换的中间格式，使得不同的计算节点或进程能够方便地共享和读取数组数据。通过将数据保存为npy文件，可以避免在不同节点之间进行复杂的数据传输和格式转换，提高并行处理的效率。

3.5 npy文件的使用注意事项

在使用npy文件时，需要注意以下几点：

版本兼容性：不同版本的NumPy在保存和加载npy文件时可能存在细微差异。因此，在保存npy文件时，最好注明所使用的NumPy版本，并在加载时确保使用兼容的NumPy版本。
文件安全性：npy文件包含了数组的数据和元数据，因此需要注意文件的安全性。避免将npy文件暴露在不安全的环境中，以免被他人恶意利用或篡改数据。
文件大小：对于包含大量数据的npy文件，其文件大小可能会很大。在保存和传输npy文件时，需要注意文件大小的问题，以免占用过多存储空间或传输带宽。

参考文档

NumPy官方的中文文档：https://www.numpy.org.cn/ Python NumPy 库详解：https://blog.csdn.net/u014548562/article/details/137874752