Python Numpy 数组教程

使用 Python Wheels 安装

首先确保您已安装 Python。如果仍需安装，可以查看我们的 Python 安装指南 :)

如果您在 Windows 上工作，请确保已将 Python 添加到 PATH 环境变量。然后别忘了安装包管理器，如 pip，它可确保您能使用 Python 的开源库。

请注意，较新的 Python 3 版本自带 pip，因此请先检查是否已安装；如果已安装，请在安装 NumPy 前先升级它：

pip install pip --upgrade
pip --version

从 PyPI 网站下载适用于您系统的 NumPy wheel 文件。您可以在 Python 包索引上找到可用的 NumPy wheel 列表。

 

下载好 NumPy wheel 文件后，使用命令提示符或终端窗口导航到保存该文件的目录。

 

使用以下命令安装 NumPy，将 "numpy-<version>-<architecture>.whl" 替换为您下载的 NumPy wheel 文件名：

pip install numpy-<version>-<architecture>.whl

例如，如果您下载的是适用于 64 位 Windows 系统的 NumPy 1.20.3 版本，命令如下：

安装完成后，您可以打开 Python 解释器运行以下命令以验证 NumPy 是否安装成功：

import numpy

如果没有报错消息，说明 NumPy 已安装并可使用！

使用 Anaconda Python 发行版安装

您也可以通过下载 Anaconda Python 发行版来获取 NumPy。这种方式简单快捷！如果尚未下载，请前往官方网站获取。按照安装指引操作即可开始！

您或许会好奇为什么这更容易？

好处在于，使用该 Python 发行版，您无需为单独安装 NumPy 或数据分析中会用到的主要包（如 pandas、scikit-learn 等）而费心。

尤其是当您对 Python、编程或终端还很陌生时，Anaconda 已包含 最受欢迎的 100 个用于数据科学的 Python、R 与 Scala 包，这将让人如释重负。但即便对更有经验的数据科学家而言，如果您想快速开始解决数据科学问题，Anaconda 也是不错的选择。

此外，Anaconda 还包含多个开源开发环境，如 Jupyter 和 Spyder。如果您希望在本教程后开始使用 Jupyter Notebook，请参阅我们的 Jupyter Notebook 教程。

简言之，考虑下载 Anaconda，以便开始使用 numpy 及其他与数据科学相关的包！

import numpy as np

# Make the array `my_array`
my_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Print `my_array`
print(my_array)

如何创建“空”的 NumPy 数组

人们常说要创建“空”数组，通常是指想使用可在之后填充的初始占位符。您可以用全 1 或全 0 初始化数组，也可以创建带有等间距值、常数或随机值的数组。

当然，您也可以创建完全空的数组。

幸运的是，NumPy 提供了相当多的创建函数。

在下面试一试吧！

import numpy as np

# Create an array of ones
ones_array = np.ones((3, 4))
print("Ones Array:")
print(ones_array)
print()

# Create an array of zeros
zeros_array = np.zeros((2, 3, 4), dtype=np.int16)
print("Zeros Array:")
print(zeros_array)
print()

# Create an array with random values
random_array = np.random.random((2, 2))
print("Random Array:")
print(random_array)
print()

# Create an empty array
empty_array = np.empty((3, 2))
print("Empty Array:")
print(empty_array)
print()

# Create a full array
full_array = np.full((2, 2), 7)
print("Full Array:")
print(full_array)
print()

# Create an array of evenly-spaced values
arange_array = np.arange(10, 25, 5)
print("Arange Array:")
print(arange_array)
print()

# Create an array of evenly-spaced values
np.linspace(0,2,9)

提示：多尝试上述函数，以便理解其工作方式！

• 对于 np.ones()、np.random.random()、np.empty()、np.full() 或 np.zeros() 等函数，要创建全 1 或全 0 数组，只需传入您想要的数组形状。作为 np.ones() 与 np.zeros() 的可选参数，您还可以指定数据类型。使用 np.full() 时，您还需要指定要填入数组的常数值。
• 使用 np.linspace() 和 np.arange() 可以创建等间距值的数组。二者的区别在于，上述代码片段中传入的第三个值，对 np.linspace() 来说表示样本数量，对 np.arange() 来说表示步长。前者例如是要一个在 0 与 2 之间包含 9 个值的数组。后者则指定从 10 开始，以步长 5 生成数组值。

记住，NumPy 还允许您使用 np.eye() 和 np.identity() 创建单位数组或单位矩阵。单位矩阵是一个方阵，其主对角线上所有元素为 1，其他元素为 0。当您将一个矩阵与单位矩阵相乘时，该矩阵保持不变。

换言之，按照标准的矩阵乘法约定，如果将一个矩阵与单位矩阵相乘，所得结果仍是该矩阵本身。

尽管本教程不以演示单位矩阵工作原理为重点，但可以说，当您开始进行矩阵计算时，单位矩阵会很有用：它可以简化数学方程，使计算更高效、更稳健。

如何从文本加载 NumPy 数组

借助初始占位符或示例数据创建数组，是开始学习 numpy 的极佳方式。但当您想开始数据分析时，就需要从文本文件加载数据。

仅凭目前所学，您做不了太多。请使用一些特定函数从文件加载数据，例如 loadtxt() 或 genfromtxt()。

假设您有以下包含数据的文本文件，您需要将下面代码中的注释值复制粘贴到文本文件中，并将其保存为 “data.txt”。然后即可使用如下代码：

# This is your data in the text file
# Value1  Value2  Value3
# 0.2536  0.1008  0.3857
# 0.4839  0.4536  0.3561
# 0.1292  0.6875  0.5929
# 0.1781  0.3049  0.8928
# 0.6253  0.3486  0.8791

# Import your data
x, y, z = np.loadtxt('data.txt',
                    skiprows=1,
                    unpack=True)

在上述代码中，您使用 loadtxt() 将数据加载到环境中。可以看到，两者的第一个参数都是文本文件 data.txt。接下来是各自特定的参数：在第一条语句中，您跳过第一行，并使用 unpack=TRUE 将列作为单独的数组返回。这意味着 Value1 列的值会放入 x，依此类推。

请注意，如果您有逗号分隔的数据，或想指定数据类型，还可以在 loadtxt() 的参数中添加 delimiter 与 dtype。

很简单、很直接，对吧？

让我们看看第二个数据文件：

# Your data in the text file
# Value1  Value2  Value3
# 0.4839  0.4536  0.3561
# 0.1292  0.6875  MISSING
# 0.1781  0.3049  0.8928
# MISSING 0.5801  0.2038
# 0.5993  0.4357  0.7410

my_array2 = np.genfromtxt('data2.txt',
                      skip_header=1,
                      filling_values=-999)

您会看到，这里使用 genfromtxt() 来加载数据。在该情况下，您需要处理由字符串 'MISSING' 表示的缺失值。

由于 genfromtxt() 函数会将数值列中的字符串转换为 nan，您可以通过指定 filling_values 参数将这些值转换成其他值。在这里，您选择将这些缺失值设为 -999。

如果恰好有一些值不会被 genfromtxt() 转换为 nan，您还可以使用 missing_values 参数来指定数据中究竟哪些是缺失值。

但这还不止如此。

提示：查看 numpy.genfromtxt 页面，了解还能添加哪些参数以成功导入数据。

您现在可能想知道这两个函数之间的区别。

示例或许已隐含指出：总体而言，genfromtxt() 给予您更大的灵活性；它比 loadtxt() 更健壮。

让我们更具体些：后者 loadtxt() 仅在文本文件中每一行具有相同数量的值时才奏效，因此当您希望轻松处理缺失值时，通常会发现使用 genfromtxt() 更容易。

但这绝不是唯一原因。

简要查看 genfromtxt() 提供的参数数量，您会发现确实可以在导入时指定更多内容，例如读取的最大行数，或自动去除变量空白的选项。

如何保存 NumPy 数组

当您完成对数组的所有操作后，也可以将它们保存到文件。如果您想将数组保存为文本文件，可以使用 savetxt() 函数：

import numpy as np
x = np.arange(0.0,5.0,1.0)
np.savetxt('test.out', x, delimiter=',')

请记住，np.arange() 会创建一个等间距值的 NumPy 数组。传递给该函数的第三个值是步长。

当然，还有其他方式将 NumPy 数组保存为文本文件。如果您想将数据保存为二进制文件或归档，请查看下表中的函数：

save()	将数组保存为 NumPy .npy 格式的二进制文件
savez()	将多个数组保存到未压缩的 .npz 归档中
savez_compressed()	将多个数组保存到压缩的 .npz 归档中

有关如何使用上述函数保存数据的更多信息或示例，请参阅 NumPy 参考页面，或使用 NumPy 提供的帮助函数即时了解更多！

不确定这些 NumPy 帮助函数是什么？

别担心！您将在接下来的某一节中进一步了解它们！

如何检查您的 NumPy 数组

除了上文提到的数组属性（data、shape、dtype、strides）之外，还有一些属性可帮助您轻松了解数组。对于初学者，以下这些可能比较有用：

import numpy as np

# Create a numpy array with shape (2,4) and dtype int64
my_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Print the number of dimensions of `my_array`
print("Number of dimensions of my_array:")
print(my_array.ndim)
print()

# Print the number of elements in `my_array`
print("Number of elements in my_array:")
print(my_array.size)
print()

# Print information about the memory layout of `my_array`
print("Information about the memory layout of my_array:")
print(my_array.flags)
print()

# Print the length of one array element in bytes
print("Length of one array element in bytes:")
print(my_array.itemsize)
print()

# Print the total consumed bytes by `my_array`'s elements
print("Total consumed bytes by my_array's elements:")
print(my_array.nbytes)
print()

这些几乎涵盖了数组可能具有的所有属性。

如果此时觉得并非都对您有用，也不要担心。这很正常，因为正如上一节所述，只有在处理大型数据集时，您才会开始关心内存。

另请注意，除了这些属性，您还可以通过其他方式获取更多信息，甚至稍微调整数组：

import numpy as np
my_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Print the length of `my_array`
print(len(my_array))

# Change the data type of `my_array`
my_array.astype(float)

现在，您已经通过 np.array() 或初始占位符函数自行创建了数组，或者通过 loadtxt() 或 genfromtxt() 函数加载了数据，是时候更深入地了解真正定义 NumPy 库的第二个关键元素：科学计算。

如何转置数组

转置数组的本质是对其维度进行置换。换句话说，您在交换数组的形状。让我们用一个小例子来展示转置的效果：

import numpy as np
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Print `my_2d_array`
print(my_2d_array)

# Transpose `my_2d_array`
print(np.transpose(my_2d_array))

# Or use `T` to transpose `my_2d_array`
print(my_2d_array.T)

提示：如果数组与其转置版本的直观对比不够清晰，请检查两个数组的形状，以确保理解为何维度发生置换。

请注意，这里有两种转置方式。两者做同样的事，区别不大。需要注意的是，T 更像是便利函数，而 np.transpose() 则灵活性更高。因此，若您需要更多参数，建议优先使用 np.transpose()。

对于一维以上的数组，转置一切顺利，但如果只是一个一维数组，会有任何效果吗？

请在下面的代码片段中自行尝试。您的一维数组已经加载好了：

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

# Print `my_2d_array
print(my_array)

# Transpose `my_2d_array
print(np.transpose(my_array))

# Or use `T` to transpose `my_2d_array
print(my_array.T)

您完全正确！转置一维数组并无效果！

重塑（Reshape）与调整大小（Resize）的区别

您可能已在广播部分读到，若要进行算术运算，数组的维度需要兼容。但当维度不兼容时该怎么办，这个问题尚未回答。

现在就来解答！

当数组的维度不一致时，您可以调整数组大小。此时返回一个新数组，其形状为您传递给 np.resize() 的形状。如果将原数组与新维度一起传入，且新数组大于原始数组，则新数组会用原数组的拷贝重复填充，直到满足大小为止。

但是，如果只是对数组调用 np.resize() 并传入新形状，新数组将用零填充。

让我们用一个示例来试试：

import numpy as np
x = np.ones((3,4))

# Print the shape of `x`
print(x.shape)

# Resize `x` to ((6,4))
np.resize(x, (6,4))

# Try out this as well
x.resize((6,4))

# Print out `x`
print(x)

除了调整大小，您还可以重塑数组。这意味着在不改变数据的情况下为数组赋予新形状。重塑的关键是确保新数组的总大小不变。以数组 x 为例，上文中它的大小为 3 × 4 或 12，您必须确保新数组的大小也为 12。

嘘……如果您想通过代码计算数组大小，请使用 size 属性：x.size 或 x.reshape((2,6)).size：

import numpy as np

# Initialize array with shape (3,4) containing all ones
x = np.ones((3,4))

# Print the shape of `x`
print("Shape of x:", x.shape)

# Resize `x` to ((6,4))
np.resize(x, (6,4))

# Try out this as well
x.resize((6,4))

# Print out `x` before and after resizing
print("Array before transposing:\n", x)
print("Shape of array before transposing:", x.shape)

# Transpose `x`
x = x.T

# Print out `x` after transposing
print("Array after transposing:\n", x)
print("Shape of array after transposing:", x.shape)

输出： 

Shape of x: (3, 4)
Array before transposing:
 [[1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]]
Shape of array before transposing: (6, 4)
Array after transposing:
 [[1. 1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1. 1.]]
Shape of array after transposing: (4, 6)

如果上述方法都不奏效，您还可以将一个数组追加到原数组，或插入、删除数组元素，以确保维度与您要用于计算的另一个数组相匹配。

在更改数组形状时，另一个可能派上用场的操作是 ravel()。该函数可将数组扁平化。也就是说，如果您有二维、三维或 n 维数组，可以直接用它将数组展平成一维数组。

相当方便，不是吗？

如何追加数组

当您将数组追加到原数组时，它们会“粘”在原数组的末尾。如果希望追加的内容不是放在末尾，可以考虑插入。若想了解更多，请前往下一节。

得益于 NumPy，追加操作非常简单；您可以直接使用 np.append()。

请在下面的代码片段中查看其用法。别忘了，您可以随时在 IPython 终端中输入例如 my_array 并按回车，检查已加载的数组。

import numpy as np

my_array = np.array([1,2,3,4])

# Print `my_array` before appending
print("my_array before appending:", my_array)

# Append a 1D array to `my_array`
new_array = np.append(my_array, [7, 8, 9, 10])

# Print `new_array`
print("new_array:", new_array)

# Print `my_array` after appending
print("my_array after appending:", my_array)

输出：

my_array before appending: [1 2 3 4]
new_array: [ 1  2  3  4  7  8  9 10]
my_array after appending: [1 2 3 4]

注意，my_array 在追加后保持不变，因为 np.append() 返回的是新数组，而不是就地修改原数组。

对 my_2d_array 进行追加：

import numpy as np

my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Print `my_2d_array` before appending
print("my_2d_array before appending:\n", my_2d_array)

# Append an extra column to `my_2d_array`
new_2d_array = np.append(my_2d_array, [[7], [8]], axis=1)

# Print `new_2d_array`
print("new_2d_array:\n", new_2d_array)

# Print `my_2d_array` after appending
print("my_2d_array after appending:\n", my_2d_array)

输出： 

my_2d_array before appending:
 [[1 2 3 4]
  [5 6 7 8]]
new_2d_array:
 [[1 2 3 4 7]
  [5 6 7 8 8]]
my_2d_array after appending:
 [[1 2 3 4]
  [5 6 7 8]]

请注意，在为 my_2d_array 追加额外一列时，指定了轴。记住，在二维数组中，axis 1 表示列，axis 0 表示行。

如何插入与删除数组元素

除了追加，您还可以插入与删除数组元素。您大概已经猜到，执行这些操作的函数分别是 np.insert() 与 np.delete()：

import numpy as np
my_array = np.array([1,2,3,4])
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Insert `5` at index 1
np.insert(my_array, 1, 5)

# Delete the value at index 1
np.delete(my_array,[1])

如何合并与拆分数组

您还可以“合并”或连接数组。为此有一组函数可用，其中大多数列示如下。

试一试它们，同时也请在 IPython 终端中查看数组的形状。已加载的数组包括 x、my_array、my_resized_array 与 my_2d_array。

import numpy as np 
x = np.ones((4,))
my_array = np.array([1,2,3,4])
my_resized_array=np.resize(my_array,(2,4))
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)

# Concatentate `my_array` and `x`
print(np.concatenate((my_array,x)))

# Stack arrays row-wise
print(np.vstack((my_array, my_2d_array)))

# Stack arrays row-wise
print(np.r_[my_resized_array, my_2d_array])

# Stack arrays horizontally
print(np.hstack((my_resized_array, my_2d_array)))

# Stack arrays column-wise
print(np.column_stack((my_resized_array, my_2d_array)))

# Stack arrays column-wise
print(np.c_[my_resized_array, my_2d_array])

在使用这些函数时，您会注意到以下几点：

• 如果想用 np.concatenate() 连接两个数组，维度数量需要相同。因此，如果要与一维的 my_array 拼接，第二个数组也需要是一维。
• 使用 np.vstack()，您可以轻松将 my_array 与 my_2d_array 组合。只需确保在按行堆叠数组时，两数组的列数相同。因此，您也可以向 my_2d_array 添加形状为 (2,4) 或 (3,4) 的数组，只要列数匹配即可。换言之，除第一轴外，数组在其余各轴上的形状必须一致。使用 np.r[] 时同理。
• 对于 np.hstack()，需要确保维度数量相同，且两数组的行数一致。这意味着您可以将形状为 (2,3) 或 (2,4) 的数组与形状为 (2,4) 的 my_2d_array 横向堆叠。只要行数匹配，一切皆可。该函数仍受 NumPy 支持，但建议优先使用 np.concatenate() 或 np.stack()。
• 使用 np.column_stack() 时，需要确保输入数组的第一维相同。在此例中，两个形状相同；但即便 my_resized_array 为 (2,1) 或 (2,)，数组也仍会被堆叠。
• np.c_[] 是另一种连接方式。此处同样要求两个数组的第一维匹配。

当您合并了数组后，可能还希望在某个时刻将它们拆分。就像可以横向堆叠一样，也可以纵向进行。分别使用 np.hsplit() 与 np.vsplit()：

import numpy as np
my_array = np.array([1,2,3,4])
my_resized_array=np.resize(my_array,(2,4))
my_2d_array = np.array([[1,2,3,4], [5,6,7,8]], dtype=np.int64)
my_stacked_array = np.hstack((my_resized_array, my_2d_array))

# Split `my_stacked_array` horizontally at the 2nd index
print(np.hsplit(my_stacked_array, 2))

# Split `my_stacked_array` vertically at the 2nd index
print(np.vsplit(my_stacked_array, 2))

使用这两个拆分函数时，需要牢记的可能是数组的形状。以以上情况为例：my_stacked_array 的形状为 (2,8)。当您选择希望发生拆分的位置索引时，需要牢记其形状。

使用 np.histogram()

与函数名可能暗示的不同，np.histogram() 并不会绘制直方图，而是计算数组中落入各个箱（bin）的出现次数；这将决定直方图中每个条形的面积。

传入给 np.histogram() 的首先是输入数据或您正在处理的数组。在计算直方图时，数组会被扁平化。

# Import `numpy` as `np`
import numpy as np

# Initialize your array
my_3d_array = np.array([[[1,2,3,4], [5,6,7,8]], [[1,2,3,4], [9,10,11,12]]], dtype=np.int64)

# Pass the array to `np.histogram()`
print(np.histogram(my_3d_array))

# Specify the number of bins
print(np.histogram(my_3d_array, bins=range(0,13)))

您会看到，作为结果，直方图被计算出来：第一个数组列出数组全部元素的频率，第二个数组列出在未指定箱时将使用的箱。

如果指定了箱的数量，计算结果会不同：浮点数将消失，您将看到箱都是整数。

此外，还有一些其他参数可供指定，以影响计算出的直方图。您可以在这里找到它们。

但如果无法可视化，计算这样的直方图又有何意义？

借助 Matplotlib，可视化轻而易举，但您无需用 np.histogram() 来计算直方图。plt.hist() 在您传入（扁平化的）数据与箱时，会自行完成计算：

# Import numpy and matplotlib
import numpy as np
import matplotlib.pyplot as plt

# Construct the histogram with a flattened 3d array and a range of bins
plt.hist(my_3d_array.ravel(), bins=range(0,13))

# Add a title to the plot
plt.title('Frequency of My 3D Array Elements')

# Show the plot
plt.show()

上述代码将为您生成如下（基础）直方图：

使用 np.meshgrid()

另一种（间接）可视化数组的方式是使用 np.meshgrid()。使用数组面临的问题是，您需要 x 与 y 坐标值的二维数组。借助该函数，您可以从一维的 x 值数组与一维的 y 值数组创建一个矩形网格：np.meshgrid() 接受两个一维数组，生成两个二维矩阵，分别对应两个数组中所有 (x, y) 组合。随后，您可以使用这些矩阵绘制各种图形。

如果您想在网格上对函数进行求值，np.meshgrid() 尤其有用，如下代码所示：

# Import NumPy and Matplotlib
import numpy as np
import matplotlib.pyplot as plt

# Create an array
points = np.arange(-5, 5, 0.01)

# Make a meshgrid
xs, ys = np.meshgrid(points, points)
z = np.sqrt(xs ** 2 + ys ** 2)

# Display the image on the axes
plt.imshow(z, cmap=plt.cm.gray)

# Draw a color bar
plt.colorbar()

# Show the plot
plt.show()

上述代码给出如下结果：