NumPy数组的基本操作（附带实例）

NumPy 中包含了一些函数用于处理数组，大概可分为以下几类：

• 修改数组形状；
• 翻转数组；
• 连接数组；
• 分割数组；
• 数组元素的添加与删除。

NumPy修改数组形状

在 NumPy 中，提供了几个函数用于修改数组的形状，下面对这几个函数进行介绍。

1) reshape()函数

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

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

• arr 为要修改形状的数组；
• newshape 为整数或者整数数组，新的形状应当兼容原有形状；
• order 为排列的顺序，取值为 'C' 时，按行；取值为 'F' 时，按列；取值为 'A' 时，按原顺序；取值为 'K' 时，按元素在内存中的出现顺序。

【实例】利用 reshape() 函数改变数组的形状。

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

运行程序，输出如下：

原始数组:
[0 1 2 3 4 5 6 7]
修改后的数组:
[[0 1]
[2 3]
[4 5]
[6 7]]

2) flat()函数

numpy.ndarray.flat() 是一个数组元素迭代器，作用类似于 nditer。

【实例】利用 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, end=" ")

运行程序，输出如下：

原始数组:
[0 1 2]
[3 4 5]
[6 7 8]
迭代后的数组:
0 1 2 3 4 5 6 7 8

3) flatten()函数

numpy.ndarray.flatten() 返回一份数组拷贝，对拷贝所做的修改不会影响原始数组，格式如下：

ndarray.flatten(order='C')

参数 order 取 'C' 时，按行；取 'F' 时，按列；取 'A' 时，按原顺序；取 'K' 时，按元素在内存中的出现顺序。

【实例】利用 flatten() 函数改变数组形状。

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'))

运行程序，输出如下：

原数组:
[[0 1 2 3]
[4 5 6 7]]
展开的数组:
[0 1 2 3 4 5 6 7]
以F风格顺序展开的数组:
[0 4 1 5 2 6 3 7]

4) ravel()函数

numpy.ravel() 实现将数组维度拉成一维数组，顺序通常是 "C风格"，返回的是数组视图（有点类似 C/C++ 引用的 reference），修改会影响原始数组。

ravel() 函数的调用格式为：

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

order 取 'C' 时，按行；取 'F' 时，按列；取 'A' 时，按原顺序；取 'K' 时，按元素在内存中的出现顺序。

【实例】利用 ravel() 函数修改数组形状。

import numpy as np
a = np.arange(8).reshape(2,4)
print ('原数组：')
print (a)
print ('\n')
print ('调用 ravel()函数之后：')
print (a.ravel())
print ('\n')
print ('以 F 风格顺序调用 ravel()函数之后：')
print (a.ravel(order = 'F'))

运行程序，输出如下：

原数组:
[[0 1 2 3]
[4 5 6 7]]
调用r ave l()函数之后：
[0 1 2 3 4 5 6 7]
以F风格顺序调用r ave l()函数之后：
[0 4 1 5 2 6 3 7]

NumPy翻转数组

在 NumPy 中，提供了 4 个函数用于翻转数组，下面对这几个函数进行介绍。

1) transpose()函数

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

numpy.transpose(arr, axes)

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

【实例】利用 transpose() 函数对数组进行翻转。

import numpy as np

a = np.arange(10).reshape(2,5)
print ('原数组：')
print (a)
print ('\n')
print ('对换数组：')
print (np.transpose(a))

运行程序，输出如下：

原数组:
[[0 1 2 3 4]
[5 6 7 8 9]]
对换数组:
[[0 5]
[1 6]
[2 7]
[3 8]
[4 9]]

2) ndarray.T()函数

numpy.ndarray.T() 类似于 numpy.transpose()。

【实例】利用 ndarray.T() 函数翻转数组。

import numpy as np
a = np.arange(10).reshape(2,5)
print ('原数组：')
print (a)
print ('\n')
print ('转置数组：')
print (a.T)

运行程序，输出如下：

原数组:
[[0 1 2 3 4]
[5 6 7 8 9]]
转置数组:
[[0 5]
[1 6]
[2 7]
[3 8]
[4 9]]

3) rollaxis()函数

numpy.rollaxis() 函数向后滚动特定的轴到一个特定位置，格式如下：

numpy.rollaxis(arr, axis, start)

arr 为数组；axis 为要向后滚动的轴，其他轴的相对位置不会改变；start 默认为 0，表示完整的滚动，会滚动到特定位置。

【实例】利用 rollaxis() 函数翻转数组。

import numpy as np
# 创建了三维的 ndarray
a = np.arange(8).reshape(2,2,2)
print ('原数组：')
print (a)
print ('\n')
# 将轴 2 滚动到轴 0 (宽度到深度)
print ('调用 rollaxis() 函数：')
print (np.rollaxis(a,2))
print ('\n')
# 将轴 0 滚动到轴 1 (宽度到高度)
print ('调用 rollaxis() 函数：')
print (np.rollaxis(a,2,1))

运行程序，输出如下：

原数组:
[[[0 1]
  [2 3]]
[[4 5]
  [6 7]]]
调用rollaxis()函数：
[[[0 2]
  [4 6]]
[[1 3]
  [5 7]]]
调用rollaxis()函数：
[[[0 2]
  [1 3]]
[[4 6]
  [5 7]]]

4) swapaxes()函数

numpy.swapaxes() 函数用于交换数组的两个轴，格式如下：

numpy.swapaxes(arr, axis1, axis2)

arr 为输入的数组；axis1 为对应第一个轴的整数；axis2 为对应第二个轴的整数。

【实例】利用 swapaxes() 函数实现数组翻转。

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]]]

NumPy连接数组

在 NumPy 中，提供了 4 个函数实现数组的连接，下面对这几个函数进行介绍。

1) concatenate()函数

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

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

a1，a2，... 表示相同类型的数组；axis 为沿着它连接数组的轴，默认为 0。

【实例】利用 concatenate() 函数实现数组的连接。

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]]

2) stack()函数

numpy.stack() 函数用于沿新轴连接数组序列，函数格式如下：

numpy.stack(arrays, axis)

arrays 为相同形状的数组序列；axis 为返回数组中的轴，输入数组沿着它来堆叠。

【实例】利用 stack() 函数实现数组的连接。

import numpy as np
a = np.array([[1, 4], [3, 5]])
print ('第一个数组：')
print (a)
print ('\n')
b = np.array([[6, 8], [7, 9]])
print ('第二个数组：')
print (b)
print ('\n')
print ('沿轴 0 堆叠两个数组：')
print (np.stack(((a, b), 0))
print ('\n')
print ('沿轴 1 堆叠两个数组：')
print (np.stack(((a, b), 1))

运行程序，输出如下：

第一个数组:
[[1 4]
[3 5]]
第二个数组:
[[6 8]
[7 9]]
沿轴0堆叠两个数组:
[[[1 4]
  [3 5]]
[[6 8]
  [7 9]]]
沿轴1堆叠两个数组:
[[[1 4]
  [6 8]]
[[3 5]
  [7 9]]]

3) hstack()函数

numpy.hstack() 是 numpy.stack() 函数的变体，它通过水平堆叠来生成数组。

【实例】利用 hstack() 函数实现数组的连接。

import numpy as np
a = np.array([[1, 4], [3, 5]])
print ('第一个数组：')
print (a)
print ('\n')
b = np.array([[6, 8], [7, 9]])
print ('第二个数组：')
print (b)
print ('\n')
print ('水平堆叠：')
c = np.hstack((((a, b))
print (c)
print ('\n')

运行程序，输出如下：

第一个数组:
[[1 4]
[3 5]]
第二个数组:
[[6 8]
[7 9]]
水平堆叠:
[[1 4 6 8]
[3 5 7 9]]

4) vstack()函数

numpy.vstack() 是 numpy.stack() 函数的变体，它通过垂直堆叠来生成数组。

【实例】利用 vstack() 函数实现数组的连接。

import numpy as np
a = np.array([[1, 4], [3, 5]])
print ('第一个数组：')
print (a)
print ('\n')
b = np.array([[6, 8], [7, 9]])
print ('第二个数组：')
print (b)
print ('\n')
print ('竖直堆叠：')
c = np.vstack(((a, b))
print (c)

运行程序，输出如下：

第一个数组:
[[1 4]
[3 5]]
第二个数组:
[[6 8]
[7 9]]
竖直堆叠:
[[1 4]
[3 5]
[6 8]
[7 9]]

NumPy分割数组

在 NumPy 中，提供了相关函数实现分割数组，下面对这几个函数进行介绍。

1) split()函数

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

numpy.split(ary, indices_or_sections, axis)

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

【实例】利用 split() 函数对数组进行分割。

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])]

2) hsplit()函数

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

【实例】利用 hsplit() 函数对数组进行水平分割。

import numpy as np
harr = np.arange(16).reshape(4, 4)
print('原 array:')
print(harr)
print('拆分后:')
print(np.hsplit(harr, 2))

运行程序，输出如下：

原 array:
[[ 0  1  2  3]
[ 4  5  6  7]
[ 8  9 10 11]
[12 13 14 15]]
拆分后：
[array([[ 0,  1],
   [ 4,  5],
   [ 8,  9],
   [12, 13]]), array([[ 2,  3],
   [ 6,  7],
   [10, 11],
   [14, 15]])]

同时，在 NumPy 中，numpy.vsplit() 沿着垂直轴分割，其分割方式与 hsplit() 相同。

NumPy数组元素的添加与删除

与其他语言一样，在 NumPy 中，也提供了相关函数用于实现数组元素的添加和删除。下面对相关函数进行介绍。

1) resize()函数

numpy.resize() 函数返回指定大小的新数组。如果新数组大小大于原始大小，则包含原始数组中的元素的副本。

resize() 函数的格式为：

numpy.resize(arr, shape)

arr 为要修改大小的数组；shape 为返回数组的新形状。

【实例】利用 resize() 函数返回指定大小的新数组。

import numpy as np
a = np.array([[1, 4, 7], [3, 6, 9]])
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 4 7]
[3 6 9]]
第一个数组的形状:
(2,3)
改变第一个数组的形状:
[[1 4]
[7 3]
[6 9]]
改变后的形状:
(3,2)
修改新数组的大小:
[[1 4 7]
[3 6 9]
[1 4 7]]

2) append()函数

numpy.append() 函数在数组的末尾添加值，添加操作会分配整个数组，并把原来的数组复制到新数组中。此外，输入数组的维度必须匹配否则将生成 ValueError。append() 函数返回的始终是一个一维数组。

append() 函数的格式为：

numpy.append(arr, values, axis=None)

• arr 为输入数组；
• values 为要向 arr 添加的值，需要和 arr 形状相同（除了要添加的轴）；
• axis 默认为 None，当 axis 无定义时，是横向操作，返回总是为一维数组；当 axis 有定义的时候，取值为 0 和 1，当 axis 为 0 时，数组按列进行操作（列数要相同）。当 axis 为 1 时，数组按行进行操作（行数要相同）。

【实例】利用 append() 函数在数组末尾添加值。

import numpy as np
a = np.array([[1, 4, 7], [3, 6, 9]])
print('第一个数组:')
print(a)
print('\n')
print('向数组添加元素:')
print(np.append(a, [2, 5, 8]))
print('\n')
print('沿轴 0 添加元素:')
print(np.append(a, [[2, 5, 8]], axis = 0))
print('\n')
print('沿轴 1 添加元素:')
print(np.append(a, [[3, 3, 3], [2, 5, 8]], axis = 1))

运行程序，输出如下：

第一个数组:
[[1 4 7]
[3 6 9]]
向数组添加元素:
[1 4 7 3 6 9 2 5 8]
沿轴0添加元素:
[[1 4 7]
[3 6 9]
[2 5 8]]
沿轴1添加元素:
[[1 4 7 3 3 3]
[3 6 9 2 5 8]]

3) insert()函数

numpy.insert() 函数实现沿给定轴在给定索引之前插入值。

insert() 函数的格式为：

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

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

【实例】利用 insert() 函数在给定轴的数组中插入值。

import numpy as np
a = np.array([[1, 4], [2, 5], [3, 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 4]
[2 5]
[3 6]]
未传递ax is参数。在插入之前输入数组会被展开。
[1 4 2 11 12 5 3 6]
传递了ax is参数。会广播值数组来使其与输入数组形状吻合。沿轴0广播:
[[1 4]
[11 11]
[2 5]
[3 6]]
沿轴1广播:
[[1 11 4]
[2 11 5]
[3 11 6]]

4) delete()函数

numpy.delete() 函数返回从输入数组中删除指定子数组的新数组。与 insert() 函数的情况一样，如果未提供轴参数，则输入数组将展开。

delete() 函数的格式为：

numpy.delete(arr, obj, axis)

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

【实例】利用 delete() 函数从输入数组中删除指定数组。

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('删除第三行:')
print(np.delete(a, 2, axis = 0))
print('\n')

运行程序，输出如下：

第一个数组:
[[0    1    2   3]
[4    5    6   7]
[8    9  10   11]]
未传递ax is参数。在删除之前输入数组会被展开。
[0 1 2 3 4 6 7 8 9 10 11]
删除第二列:
[[0     2    3]
[4     6    7]
[8    10   11]]
删除第三行:
[[0 1 2 3]
[4 5 6 7]]

5) unique()函数

numpy.unique() 函数用于去除数组中的重复元素。函数的格式为：

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

• arr 为输入数组，如果不是一维数组则会展开；
• return_index 如果为True，返回新列表元素在旧列表中的位置（下标），并以列表形式存储；
• return_inverse 如果为 True，返回旧列表元素在新列表中的位置（下标），并以列表形式存储；
• return_counts 如果为True，返回去重数组中的元素在原数组中的出现次数。

【实例】利用 unique() 函数去除数组中的重复元素。

import numpy as np
a = np.array([5, 2, 6, 2, 7, 2, 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)
for x, y in zip(u, indices):
    print(x, ": 重复数量", y)

运行程序，输出如下：

第一个数组:
[5 2 6 2 7 2 6 8 2 9]
第一个数组去重后:
[2 5 6 7 8 9]
去重数组的索引数组（新列表元素在旧列表中的位置）:
[1 0 2 4 7 9]
可以看到每个和原数组下标对应的数值:
[5 2 6 2 7 2 6 8 2 9]
去重后的数组:
[2 5 6 7 8 9]
下标（旧列表元素在新列表中的位置）为：
[1 0 2 0 3 0 2 4 0 5]
使用下标重构原数组:
[5 2 6 2 7 2 6 8 2 9]
返回去重元素的重复数量:
2:重复数量4
5:重复数量1
6:重复数量2
7:重复数量1
8:重复数量1
9:重复数量1

NumPy算术函数

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([9, 9, 9])
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.]]
第二个数组:
[9 9 9]
两个数组相加:
[[9.10.11.]
[12.13.14.]
[15.16.17.]]
两个数组相减:
[[-9.-8.-7.]
[-6.-5.-4.]
[-3.-2.-1.]]
两个数组相乘:
[[0. 9.18.]
[27.36.45.]
[54.63.72.]]
两个数组相除:
[[0.    0.11111111 0.22222222]
[0.33333333 0.44444444 0.55555556]
[0.66666667 0.77777778 0.88888889]]

此外 NumPy 也包含了其他重要的算术函数，下面对一些常用的算术函数进行介绍。

1) reciprocal()函数

numpy.reciprocal() 函数返回参数逐元素的倒数。如 1/4 倒数为 4/1。

【实例】利用 reciprocal() 函数返回逐元素的倒数。

import numpy as np
a = np.array([1.25, 1.33, 1, 100])
print('数组是:')
print(a)
print('\n')
print('调用 reciprocal() 函数:')
print(np.reciprocal(a))

运行程序，输出如下：

数组是:
[ 1.25 1.33 1. 100. ]
调用reciprocal()函数：
[0.8   0.7518797 1.    0.01  ]

2) power()函数

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

【实例】利用 power() 函数将第一个输入数作为底数，计算相应元素的幂。

import numpy as np
a = np.array([10, 500, 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 500 1000]
调用power()函数：
[  100 250000 1000000]
第二个数组:
[1 2 3]
再次调用power()函数：
[    10  250000 1000000000]

3) mod()函数

numpy.mod() 函数计算输入数组中相应元素相除后的余数。函数 numpy.remainder() 也产生相同的结果。

【实例】利用 mod() 函数求相应元素相除后的余数。

import numpy as np
a = np.array([10, 30, 60])
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 30 60]
第二个数组:
[3 5 7]
调用mod()函数：
[1 0 4]
调用remainder()函数：
[1 0 4]