- 0. 基本数据类型
- 0.1 Ndarray 对象
- 0.2 常用 NumPy 基本类型
- 0.2.1 数据类型对象 (dtype)
- 0.3 数组属性
- 1. 创建数组
- 1.1 普通创建数组
- 1.2 从已有的数组创建数组
- 1.3 从数值范围创建数组
- 1.4 切片和索引
- 1.5 高级索引
- 2. 数组操作
- 2.1 广播(Broadcast)
- 2.2 迭代数组
- 2.3 数组操作
- 2.3.1 修改数组形状
- 2.3.2 翻转数组
- 2.3.3 修改数组维度
- 2.3.4 连接数组
- 2.3.5 分割数组
- 2.3.6 数组元素的添加与删除
- 2.4 位运算
- 3. 相关函数
- 3.1 字符串函数
- 3.2 数学函数
- 3.3 算术函数
- 3.4 统计函数
- 3.5 排序、条件刷选函数
- 4. 其他
- 4.1 字节交换
- 4.2 副本和视图
- 4.3 矩阵库(Matrix)
- 4.4 线性代数
- 4.5 IO
- 4.6 Matplotlib
基于菜鸟教程和平时学习的经验和实操记录汇集而成。 0. 基本数据类型 0.1 Ndarray 对象
NumPy 最重要的一个特点是其 N 维数组对象 ndarray，它是一系列同类型数据的集合，以 0 下标为开始进行集合中元素的索引。
ndarray 对象是用于存放同类型元素的多维数组。
ndarray 中的每个元素在内存中都有相同存储大小的区域。
ndarray 内部由以下内容组成：
- 一个指向数据（内存或内存映射文件中的一块数据）的指针。
- 数据类型或 dtype，描述在数组中的固定大小值的格子。
- 一个表示数组形状（shape）的元组，表示各维度大小的元组。
- 一个跨度元组（stride），其中的整数指的是为了前进到当前维度下一个元素需要"跨过"的字节数。
ndarray 的内部结构:
跨度可以是负数，这样会使数组在内存中后向移动，切片中 obj[::-1] 或 obj[:,::-1] 就是如此。
创建一个 ndarray 只需调用 NumPy 的 array 函数即可：
numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)
| 名称 | 描述 |
|---|---|
| object | 数组或嵌套的数列 |
| dtype | 数组元素的数据类型，可选 |
| copy | 对象是否需要复制，可选 |
| order | 创建数组的样式，C为行方向，F为列方向，A为任意方向（默认） |
| subok | 默认返回一个与基类类型一致的数组 |
| ndmin | 指定生成数组的最小维度 |
常用 NumPy 基本类型
0.2.1 数据类型对象 (dtype)数据类型对象（numpy.dtype 类的实例）用来描述与数组对应的内存区域是如何使用，它描述了数据的以下几个方面：：
- 数据的类型（整数，浮点数或者 Python 对象）
- 数据的大小（例如， 整数使用多少个字节存储）
- 数据的字节顺序（小端法或大端法）
在结构化类型的情况下，字段的名称、每个字段的数据类型和每个字段所取的内存块的部分
如果数据类型是子数组，那么它的形状和数据类型是什么。
字节顺序是通过对数据类型预先设定 < 或 > 来决定的。 < 意味着小端法(最小值存储在最小的地址，即低位组放在最前面)。> 意味着大端法(最重要的字节存储在最小的地址，即高位组放在最前面)。
dtype 对象是使用以下语法构造的：
numpy.dtype(object, align, copy)
- object - 要转换为的数据类型对象
- align - 如果为 true，填充字段使其类似 C 的结构体。
- copy - 复制 dtype 对象 ，如果为 false，则是对内置数据类型对象的引用
NumPy 数组的一些基本属性
| 属性 | 说明 |
|---|---|
| ndarray.ndim | 秩，即轴的数量或维度的数量 |
| ndarray.shape | 数组的维度，对于矩阵，n 行 m 列 |
| ndarray.size | 数组元素的总个数，相当于 .shape 中 n*m 的值 |
| ndarray.dtype | ndarray 对象的元素类型 |
| ndarray.itemsize | ndarray 对象中每个元素的大小，以字节为单位 |
| ndarray.flags | ndarray 对象的内存信息 |
| ndarray.real | ndarray 元素的实部 |
| ndarray.imag | ndarray 元素的虚部 |
| ndarray.data | 包含实际数组元素的缓冲区，由于一般通过数组的索引获取元素，所以通常不需要使用这个属性。 |
普通创建数组
- numpy.empty
- numpy.zeros
- numpy.ones
numpy.empty
numpy.empty 方法用来创建一个指定形状（shape）、数据类型（dtype）且未初始化（填充的数字是任意值）的数组：
numpy.empty(shape, dtype = float, order = 'C')
参数说明：
| 参数 | 描述 |
|---|---|
| shape | 数组形状 |
| dtype | 数据类型，可选 |
| order | 有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。 |
numpy.zeros
创建指定大小的数组，数组元素以 0 来填充：
numpy.zeros(shape, dtype = float, order = 'C')
参数说明：
| 参数 | 描述 |
|---|---|
| shape | 数组形状 |
| dtype | 数据类型，可选 |
| order | ‘C’ 用于 C 的行数组，或者 ‘F’ 用于 FORTRAN 的列数组 |
numpy.ones
创建指定形状的数组，数组元素以 1 来填充：
numpy.ones(shape, dtype = None, order = 'C')
参数说明：
| 参数 | 描述 |
|---|---|
| shape | 数组形状 |
| dtype | 数据类型，可选 |
| order | ‘C’ 用于 C 的行数组，或者 ‘F’ 用于 FORTRAN 的列数组 |
从已有的数组创建数组
- numpy.asarray
- numpy.frombuffer
- numpy.fromiter
numpy.asarray
numpy.asarray 类似 numpy.array，但 numpy.asarray 参数只有三个，比 numpy.array 少两个。
numpy.asarray(a, dtype = None, order = None)
参数说明：
| 参数 | 描述 |
|---|---|
| a | 任意形式的输入参数，可以是，列表, 列表的元组, 元组, 元组的元组, 元组的列表，多维数组 |
| dtype | 数据类型，可选 |
| order | 可选，有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。 |
numpy.frombuffer
numpy.frombuffer 用于实现动态数组。
numpy.frombuffer 接受 buffer 输入参数，以流的形式读入转化成 ndarray 对象。
numpy.fromiter
numpy.fromiter 方法从可迭代对象中建立 ndarray 对象，返回一维数组。
从数值范围创建数组
- numpy.arange
- numpy.linspace
- numpy.logspace
numpy.arange
numpy 包中的使用 arange 函数创建数值范围并返回 ndarray 对象，函数格式如下：
numpy.arange(start, stop, step, dtype)
根据 start 与 stop 指定的范围以及 step 设定的步长，生成一个 ndarray。
参数说明：
| 参数 | 描述 |
|---|---|
| start | 起始值，默认为0 |
| stop | 终止值（不包含） |
| step | 步长，默认为1 |
| dtype | 返回ndarray的数据类型，如果没有提供，则会使用输入数据的类型。 |
numpy.linspace
numpy.linspace 函数用于创建一个一维数组，数组是一个等差数列构成的，格式如下：
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 的数据类型 |
numpy.logspace
numpy.logspace 函数用于创建一个于等比数列。格式如下：
np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)
base 参数意思是取对数的时候 log 的下标。
| 参数 | 描述 |
|---|---|
| start | 序列的起始值为：base ** start |
| stop | 序列的终止值为：base ** stop。如果endpoint为true，该值包含于数列中 |
| num | 要生成的等步长的样本数量，默认为50 |
| endpoint | 该值为 true 时，数列中中包含stop值，反之不包含，默认是True。 |
| base | 对数 log 的底数。 |
| dtype | ndarray 的数据类型 |
切片和索引
- 设置 start, stop 及 step 参数进行
- 通过slice()函数、[:]冒号
- 省略号 …，来使选择元组的长度与数组的维度相同
ndarray对象的内容可以通过索引或切片来访问和修改，与 Python 中 list 的切片操作一样。
ndarray 数组可以基于 0 - n 的下标进行索引，切片对象可以通过内置的 slice 函数，并设置 start, stop 及 step 参数进行，从原数组中切割出一个新数组。
a = np.arange(10) s = slice(2,7,2) # 从索引 2 开始到索引 7 停止，间隔为2 print (a[s]) 输出结果为： [2 4 6]
我们也可以通过冒号分隔切片参数 start:stop:step 来进行切片操作：
a = np.arange(10) b = a[2:7:2] # 从索引 2 开始到索引 7 停止，间隔为 2 print(b) 输出结果为： [2 4 6]
冒号 : 的解释：如果只放置一个参数，如 [2]，将返回与该索引相对应的单个元素。如果为 [2:]，表示从该索引开始以后的所有项都将被提取。如果使用了两个参数，如 [2:7]，那么则提取两个索引(不包括停止索引)之间的项。
多维数组同样适用上述索引提取方法：
a = np.array([[1,2,3],[3,4,5],[4,5,6]])
print(a)
# 从某个索引处开始切割
print('从数组索引 a[1:] 处开始切割')
print(a[1:])
输出结果为：
[[1 2 3]
[3 4 5]
[4 5 6]]
从数组索引 a[1:] 处开始切割
[[3 4 5]
[4 5 6]]
切片还可以包括省略号 …，来使选择元组的长度与数组的维度相同。 如果在行位置使用省略号，它将返回包含行中元素的 ndarray。
a = np.array([[1,2,3],[3,4,5],[4,5,6]]) print (a[...,1]) # 第2列元素 print (a[1,...]) # 第2行元素 print (a[...,1:]) # 第2列及剩下的所有元素 输出结果为： [2 4 5] [3 4 5] [[2 3] [4 5] [5 6]]1.5 高级索引
高级索引
NumPy 比一般的 Python 序列提供更多的索引方式。除了之前看到的用整数和切片的索引外，数组可以由整数数组索引、布尔索引及花式索引。
整数数组索引
以下实例获取数组中(0,0)，(1,1)和(2,0)位置处的元素。
x的第一个参数是所有行索引汇集的数组，第二个参数是所有列索引汇集的数组。
x = np.array([[1, 2], [3, 4], [5, 6]]) y = x[[0,1,2], [0,1,0]] print (y) 输出结果为： [1 4 5]
以下实例获取了 4X3 数组中的四个角的元素。 行索引是 [0,0] 和 [3,3]，而列索引是 [0,2] 和 [0,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 对象。
可以借助切片 : 或 … 与索引数组组合。如下面例子：
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 6] [8 9]] [[5 6] [8 9]] [[2 3] [5 6] [8 9]]
布尔索引
我们可以通过一个布尔数组来索引目标数组。
布尔索引通过布尔运算（如：比较运算符）来获取符合指定条件的元素的数组。
以下实例获取大于 5 的元素：
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]
以下实例使用了 ~（取补运算符）来过滤 NaN。
a = np.array([np.nan, 1,2,np.nan,3,4,5]) print (a[~np.isnan(a)]) 输出结果为： [ 1. 2. 3. 4. 5.]
以下实例演示如何从数组中过滤掉非复数元素。
a = np.array([1, 2+6j, 5, 3.5+5j]) print (a[np.iscomplex(a)]) 输出如下： [2.0+6.j 3.5+5.j]
花式索引
花式索引指的是利用整数数组进行索引。
花式索引根据索引数组的值作为目标数组的某个轴的下标来取值。对于使用一维整型数组作为索引，如果目标是一维数组，那么索引的结果就是对应下标的行，如果目标是二维数组，那么就是对应位置的元素。
花式索引跟切片不一样，它总是将数据复制到新数组中。
1、传入顺序索引数组 import numpy as np x=np.arange(32).reshape((8,4)) print (x[[4,2,1,7]]) 输出结果为： [[16 17 18 19] [ 8 9 10 11] [ 4 5 6 7] [28 29 30 31]] 2、传入倒序索引数组 import numpy as np x=np.arange(32).reshape((8,4)) print (x[[-4,-2,-1,-7]]) 输出结果为： [[16 17 18 19] [24 25 26 27] [28 29 30 31] [ 4 5 6 7]] 3、传入多个索引数组（要使用np.ix_） import numpy as np x=np.arange(32).reshape((8,4)) print (x[np.ix_([1,5,7,2],[0,3,1,2])]) 输出结果为： [[ 4 7 5 6] [20 23 21 22] [28 31 29 30] [ 8 11 9 10]]
x[np.ix_([1,5,7,2],[0,3,1,2])]这句话会输出一个4*4的矩阵，其中的元素分别是：
x[1,0] x[1,3] x[1,1] x[1,2] x[5,0] x[5,3] x[5,1] x[5,2] x[7,0] x[7,3] x[7,1] x[7,2] x[2,0] x[2,3] x[2,1] x[2,2]
相当于：
y=np.array([[x[1,0], x[1,3], x[1,1], x[1,2]],
[x[5,0], x[5,3], x[5,1],x[5,2]],
[x[7,0] ,x[7,3], x[7,1], x[7,2]],
[x[2,0], x[2,3], x[2,1], x[2,2]]])
就是说，如果 np.xi_ 中输入两个列表，则第一个列表存的是待提取元素的行标，第二个列表存的是待提取元素的列标，第一个列表中的每个元素都会遍历第二个列表中的每个值，构成新矩阵的一行元素。
2. 数组操作 2.1 广播(Broadcast)广播(Broadcast)
广播(Broadcast)是 numpy 对不同形状(shape)的数组进行数值计算的方式， 对数组的算术运算通常在相应的元素上进行。
如果两个数组 a 和 b 形状相同，即满足 a.shape == b.shape，那么 a*b 的结果就是 a 与 b 数组对应位相乘。这要求维数相同，且各维度的长度相同。
当运算中的 2 个数组的形状不同时，numpy 将自动触发广播机制。如：
a = np.array([[ 0, 0, 0],
[10,10,10],
[20,20,20],
[30,30,30]])
b = np.array([1,2,3])
print(a + b)
输出结果为：
[[ 1 2 3]
[11 12 13]
[21 22 23]
[31 32 33]]
下面的图片展示了数组 b 如何通过广播来与数组 a 兼容。
4x3 的二维数组与长为 3 的一维数组相加，等效于把数组 b 在二维上重复 4 次再运算：
a = np.array([[ 0, 0, 0],
[10,10,10],
[20,20,20],
[30,30,30]])
b = np.array([1,2,3])
bb = np.tile(b, (4, 1)) # 重复 b 的各个维度
print(a + bb)
输出结果为：
[[ 1 2 3]
[11 12 13]
[21 22 23]
[31 32 33]]
广播的规则:
- 让所有输入数组都向其中形状最长的数组看齐，形状中不足的部分都通过在前面加 1 补齐。
- 输出数组的形状是输入数组形状的各个维度上的最大值。
- 如果输入数组的某个维度和输出数组的对应维度的长度相同或者其长度为 1 时，这个数组能够用来计算，否则出错。
- 当输入数组的某个维度的长度为 1 时，沿着此维度运算时都用此维度上的第一组值。
简单理解：对两个数组，分别比较他们的每一个维度（若其中一个数组没有当前维度则忽略），满足：
- 数组拥有相同形状。
- 当前维度的值相等。
- 当前维度的值有一个是 1。
若条件不满足，抛出 “ValueError: frames are not aligned” 异常。
补充：
numpy.tile(A , reps)
这里的 A 就是数组，reps 可以是一个数，一个列表、元组或者数组等，就是类数组的类型。先要理解准确，先把 A 当作一个块（看作一个整体，别分开研究每个元素）。
（1）如果 reps 是一个数，就是简单的将 A 向右复制 reps - 1 次形成新的数组，就是 reps 个 A 横向排列：
import numpy as np a = np.array([[1,2],[3,4]],dtype='i1') print(a,'n') b = np.tile(a,2) #向右复制，两个 A 横向排列 print(b) 结果： [[1 2] [3 4]] [[1 2 1 2] [3 4 3 4]]
（2）如果 reps 是一个 array-like（类数组的，如列表，元组，数组）类型的，它有两个元素，如 [m , n]，实际上就是将 A 这个块变成 m * n 个 A 组成的新数组，有 m 行，n 列 A：
import numpy as np a = np.array([[1,2],[3,4]],dtype='i1') print(a,'n') b = np.tile(a,(2,3)) #2 * 3 个 A 组成新数组 print(b) 结果： [[1 2] [3 4]] [[1 2 1 2 1 2] [3 4 3 4 3 4] [1 2 1 2 1 2] [3 4 3 4 3 4]]2.2 迭代数组
迭代数组
NumPy 迭代器对象 numpy.nditer 提供了一种灵活访问一个或者多个数组元素的方式。
迭代器最基本的任务的可以完成对数组元素的访问。
实例不是使用标准 C 或者 Fortran 顺序，选择的顺序是和数组内存布局一致的，这样做是为了提升访问的效率，默认是行序优先（row-major order，或者说是 C-order）。
这反映了默认情况下只需访问每个元素，而无需考虑其特定顺序。我们可以通过迭代上述数组的转置来看到这一点，并与以 C 顺序访问数组转置的 copy 方式做对比。
a 和 a.T 的遍历顺序是一样的，也就是他们在内存中的存储顺序也是一样的，但是 a.T.copy(order = ‘C’) 的遍历结果是不同的，那是因为它和前两种的存储方式是不一样的，默认是按行访问。
控制遍历顺序
- for x in np.nditer(a, order=‘F’):Fortran order，即是列序优先；
- for x in np.nditer(a.T, order=‘C’):C order，即是行序优先；
修改数组中元素的值
nditer 对象有另一个可选参数 op_flags。 默认情况下，nditer 将视待迭代遍历的数组为只读对象（read-only），为了在遍历数组的同时，实现对数组元素值得修改，必须指定 read-write 或者 write-only 的模式。
使用外部循环
nditer 类的构造器拥有 flags 参数，它可以接受下列值：
| 参数 | 描述 |
|---|---|
| c_index | 可以跟踪 C 顺序的索引 |
| f_index | 可以跟踪 Fortran 顺序的索引 |
| multi_index | 每次迭代可以跟踪一种索引类型 |
| external_loop | 给出的值是具有多个值的一维数组，而不是零维数组 |
广播迭代
如果两个数组是可广播的，nditer 组合对象能够同时迭代它们。 假设数组 a 的维度为 3X4，数组 b 的维度为 1X4 ，则使用以下迭代器（数组 b 被广播到 a 的大小）。
2.3 数组操作数组操作
Numpy 中包含了一些函数用于处理数组，大概可分为以下几类：
- 修改数组形状
- 翻转数组
- 修改数组维度
- 连接数组
- 分割数组
- 数组元素的添加与删除
- reshape:不改变数据的条件下修改形状
- flat:数组元素迭代器
- flatten:返回一份数组拷贝，对拷贝所做的修改不会影响原始数组
- ravel:返回展开数组
numpy.reshape
numpy.reshape 函数可以在不改变数据的条件下修改形状，格式如下： numpy.reshape(arr, newshape, order=‘C’)
- arr：要修改形状的数组
- newshape：整数或者整数数组，新的形状应当兼容原有形状
- order：‘C’ – 按行，‘F’ – 按列，‘A’ – 原顺序，‘k’ – 元素在内存中的出现顺序。
numpy.ndarray.flat
numpy.ndarray.flat 是一个数组元素迭代器，实例如下:
import numpy as np
a = np.arange(9).reshape(3,3)
print ('原始数组：')
for row in a:
print (row)
#对数组中每个元素都进行处理，可以使用flat属性，该属性是一个数组元素迭代器：
print ('迭代后的数组：')
for element in a.flat:
print (element)
输出结果如下：
原始数组：
[0 1 2]
[3 4 5]
[6 7 8]
迭代后的数组：
0
1
2
3
4
5
6
7
8
numpy.ndarray.flatten
numpy.ndarray.flatten 返回一份数组拷贝，对拷贝所做的修改不会影响原始数组，格式如下：
ndarray.flatten(order='C')
numpy.ravel
numpy.ravel() 展平的数组元素，顺序通常是"C风格"，返回的是数组视图（view，有点类似 C/C++引用reference的意味），修改会影响原始数组。
该函数接收两个参数：
numpy.ravel(a, order='C')
参数说明：
- order：‘C’ – 按行，‘F’ – 按列，‘A’ – 原顺序，‘K’ – 元素在内存中的出现顺序。
- transpose:对换数组的维度
- ndarray.T 和 self.transpose() 相同
- rollaxis:向后滚动指定的轴
- swapaxes:对换数组的两个轴
numpy.transpose
numpy.transpose 函数用于对换数组的维度，格式如下：
numpy.transpose(arr, axes)
参数说明:
- arr：要操作的数组
- axes：整数列表，对应维度，通常所有维度都会对换。
numpy.rollaxis
numpy.rollaxis 函数向后滚动特定的轴到一个特定位置，格式如下：
numpy.rollaxis(arr, axis, start)
参数说明：
- arr：数组
- axis：要向后滚动的轴，其它轴的相对位置不会改变
- start：默认为零，表示完整的滚动。会滚动到特定位置。
import numpy as np
# 创建了三维的 ndarray
a = np.arange(8).reshape(2,2,2)
print ('原数组：')
print (a)
print ('获取数组中一个值：')
print(np.where(a==6))
print(a[1,1,0]) # 为 6
print ('n')
# 将轴 2 滚动到轴 0（宽度到深度）
print ('调用 rollaxis 函数：')
b = np.rollaxis(a,2,0)
print (b)
# 查看元素 a[1,1,0]，即 6 的坐标，变成 [0, 1, 1]
# 最后一个 0 移动到最前面
print(np.where(b==6))
print ('n')
# 将轴 2 滚动到轴 1：（宽度到高度）
print ('调用 rollaxis 函数：')
c = np.rollaxis(a,2,1)
print (c)
# 查看元素 a[1,1,0]，即 6 的坐标，变成 [1, 0, 1]
# 最后的 0 和 它前面的 1 对换位置
print(np.where(c==6))
print ('n')
输出结果如下：
原数组：
[[[0 1]
[2 3]]
[[4 5]
[6 7]]]
获取数组中一个值：
(array([1]), array([1]), array([0]))
6
调用 rollaxis 函数：
[[[0 2]
[4 6]]
[[1 3]
[5 7]]]
(array([0]), array([1]), array([1]))
调用 rollaxis 函数：
[[[0 2]
[1 3]]
[[4 6]
[5 7]]]
(array([1]), array([0]), array([1]))
numpy.swapaxes
numpy.swapaxes 函数用于交换数组的两个轴，格式如下：
numpy.swapaxes(arr, axis1, axis2)
- arr：输入的数组
- axis1：对应第一个轴的整数
- axis2：对应第二个轴的整数
import numpy as np
# 创建了三维的 ndarray
a = np.arange(8).reshape(2,2,2)
print ('原数组：')
print (a)
print ('n')
# 现在交换轴 0（深度方向）到轴 2（宽度方向）
print ('调用 swapaxes 函数后的数组：')
print (np.swapaxes(a, 2, 0))
输出结果如下：
原数组：
[[[0 1]
[2 3]]
[[4 5]
[6 7]]]
调用 swapaxes 函数后的数组：
[[[0 4]
[2 6]]
[[1 5]
[3 7]]]
2.3.3 修改数组维度
- broadcast:产生模仿广播的对象
- broadcast_to 将数组广播到新形状
- expand_dims:扩展数组的形状
- squeeze:从数组的形状中删除一维条目
2.3.4 连接数组
- concatenate:连接沿现有轴的数组序列
- stack:沿着新的轴加入一系列数组。
- hstack:水平堆叠序列中的数组（列方向）
- vstack:竖直堆叠序列中的数组（行方向）
2.3.5 分割数组
- split:将一个数组分割为多个子数组
- hsplit:将一个数组水平分割为多个子数组（按列）
- vsplit:将一个数组垂直分割为多个子数组（按行）
2.3.6 数组元素的添加与删除
- resize:返回指定形状的新数组
- append:将值添加到数组末尾
- insert:沿指定轴将值插入到指定下标之前
- delete:删掉某个轴的子数组，并返回删除后的新数组
- unique:查找数组内的唯一元素
2.4 位运算
位运算
NumPy “bitwise_” 开头的函数是位运算函数。
NumPy 位运算包括以下几个函数：
| 函数 | 描述 |
|---|---|
| bitwise_and | 对数组元素执行位与操作 |
| bitwise_or | 对数组元素执行位或操作 |
| invert | 按位取反 |
| left_shift | 向左移动二进制表示的位 |
| right_shift | 向右移动二进制表示的位 |
注：也可以使用 “&”、 “~”、 “|” 和 “^” 等操作符进行计算。
3. 相关函数 3.1 字符串函数字符串函数
3.2 数学函数数学函数
3.3 算术函数算术函数
3.4 统计函数统计函数
3.5 排序、条件刷选函数排序、条件刷选函数
4. 其他 4.1 字节交换字节交换
4.2 副本和视图副本和视图
4.3 矩阵库(Matrix)矩阵库(Matrix)
4.4 线性代数线性代数
4.5 IOIO
4.6 MatplotlibMatplotlib
