---

NumPy - 快速指南

NumPy - 简介

NumPy 是一个 Python 包。它代表"Numerical Python"。它是一个由多维数组对象和一系列用于处理数组的例程组成的库。

Numeric 是 NumPy 的前身，由 Jim Hugunin 开发。此外，还开发了另一个包 Numarray，它具有一些附加功能。2005 年，Travis Oliphant 将 Numarray 的功能融入 Numeric 包，创建了 NumPy 包。这个开源项目有很多贡献者。

使用 NumPy 进行运算

使用 NumPy，开发者可以执行以下操作:

• 对数组进行数学和逻辑运算。

• 傅里叶变换和形状操作例程。

• 与线性代数相关的运算。NumPy 内置了用于线性代数和随机数生成的函数。

NumPy:MatLab 的替代品

NumPy 通常与 SciPy(科学 Python)和 Matplotlib(绘图库)等软件包一起使用。这种组合被广泛用于替代流行的技术计算平台 MatLab。然而，Python 现已被视为 MatLab 的替代方案，它是一种更现代、更完善的编程语言。

它是开源的，这是 NumPy 的额外优势。

NumPy - 环境

标准 Python 发行版不包含 NumPy 模块。一种轻量级的替代方案是使用流行的 Python 包安装程序 pip 安装 NumPy。

pip install numpy

启用 NumPy 的最佳方法是使用特定于您的操作系统的可安装二进制包。这些二进制文件包含完整的 SciPy 技术栈(包括 NumPy、SciPy、matplotlib、IPython、SymPy 和 nose 软件包以及核心 Python)。

Windows

Anaconda(来自 https://www.continuum.io)是适用于 SciPy 技术栈的免费 Python 发行版。它也适用于 Linux 和 Mac。

Canopy (https://www.enthought.com/products/canopy/) 提供免费和商业发行版，其中包含适用于 Windows、Linux 和 Mac 的完整 SciPy 技术栈。

Python (x,y):它是一个免费的 Python 发行版，包含适用于 Windows 操作系统的 SciPy 技术栈和 Spyder IDE。 (可从 https://www.python-xy.github.io/ 下载)

Linux

使用相应 Linux 发行版的软件包管理器在 SciPy 技术栈中安装一个或多个软件包。

Ubuntu 系统

sudo apt-get install python-numpy
python-scipy python-matplotlibipythonipythonnotebook python-pandas
python-sympy python-nose

Fedora 系统

sudo yum install numpyscipy python-matplotlibipython
python-pandas sympy python-nose atlas-devel

从源代码构建

必须使用 distutils 安装核心 Python(2.6.x、2.7.x 和 3.2.x 及以上版本)，并且启用 zlib 模块。

必须有 GNU gcc(4.2 及以上版本)C 编译器。

要安装 NumPy，请运行以下命令。

Python setup.py install

要测试 NumPy 模块是否正确安装，请尝试在 Python 命令行中导入它。

import numpy

如果未安装，将显示以下错误消息。

Traceback (most recent call last): 
   File "<pyshell#0>", line 1, in <module> 
      import numpy 
ImportError: No module named 'numpy'

或者，使用以下语法导入 NumPy 包 -

import numpy as np

NumPy - Ndarray 对象

NumPy 中定义的最重要的对象是一种称为 ndarray 的 N 维数组类型。它描述了相同类型项的集合。可以使用从零开始的索引访问集合中的项。

ndarray 中的每个项在内存中占用相同大小的块。ndarray 中的每个元素都是一个数据类型对象(称为 dtype)。

从 ndarray 对象中提取的任何项(通过切片)都由数组标量类型之一的 Python 对象表示。下图展示了 ndarray、数据类型对象 (dtype) 和数组标量类型之间的关系 -

ndarray 类的实例可以通过本教程后面描述的不同数组创建例程来构造。基本的 ndarray 是使用 NumPy 中的数组函数创建的，如下所示 -

numpy.array

它可以从任何公开数组接口的对象或任何返回数组的方法创建 ndarray。

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

上述构造函数采用以下参数 -

查看以下示例以更好地理解。

示例 1

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

输出如下 −

[1, 2, 3]

示例 2

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

输出如下 -

[[1, 2]
[3, 4]]

示例 3

# 最小维度
import numpy as np
a = np.array([1, 2, 3,4,5], ndmin = 2)
打印 a

输出如下 -

[[1, 2, 3, 4, 5]]

示例 4

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

输出如下:-

[ 1.+0.j, 2.+0.j, 3.+0.j]

ndarray 对象由连续的一维计算机内存段组成，并结合索引机制将每个项映射到内存块中的相应位置。内存块按行优先顺序(C 语言风格)或列优先顺序(FORTRAN 或 MatLab 语言风格)保存元素。

NumPy - 数据类型

NumPy 数据类型

NumPy 支持的数值类型比 Python 多得多。下表列出了 NumPy 中定义的各种标量数据类型。

NumPy 数值类型是 dtype(数据类型)对象的实例，每个对象都具有独特的特性。可用的数据类型包括 np.bool_、np.float32 等。

数据类型对象 (dtype)

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

• 数据类型(整数、浮点数或 Python 对象)

• 数据大小

• 字节顺序(小端或大端)

• 如果是结构化类型，则字段名称、每个字段的数据类型以及每个字段占用的内存块部分。

• 如果数据类型是子数组，则其形状和数据类型

字节顺序通过在数据类型前添加 '<' 或 '>' 前缀来决定。'<' 表示编码为小端序(最低有效位存储在最小地址中)。'>' 表示编码为大端序(最高有效位存储在最小地址中)。

使用以下语法构造 dtype 对象 -

numpy.dtype(object, align, copy)

参数如下 -

• Object - 待转换为数据类型 object

• Align - 如果为 true，则向字段添加填充，使其类似于 C 结构体

• Copy - 复制 dtype 对象。如果为 false，则结果为对内置数据类型对象的引用

示例:使用数组标量类型

import numpy as np
dt = np.dtype(np.int32)
print(dt)

以下是获得的输出 -

int32

示例:使用等效字符串作为数据类型

import numpy as np
dt = np.dtype('i4')
print(dt)

这将产生以下结果 -

int32

示例:使用 Endian 表示法

import numpy as np
dt = np.dtype('>i4')
print(dt)

以下是上述代码的输出 -

>i4

示例:创建结构化数据类型

以下示例展示了结构化数据类型的用法。这里需要声明字段名称和对应的标量数据类型 -

import numpy as np
dt = np.dtype([('age', np.int8)])
print(dt)

输出结果如下 -

[('age', 'i1')]

示例:将结构化数据类型应用于 ndarray

import numpy as np
dt = np.dtype([('age', np.int8)])
a = np.array([(10,), (20,), (30,)], dtype=dt)
print(a)

执行上述代码后，我们得到以下输出 -

[(10,) (20,) (30,)]

示例:访问结构化数据类型的字段内容

import numpy as np
dt = np.dtype([('age', np.int8)])
a = np.array([(10,), (20,), (30,)], dtype=dt)
print(a['age'])

生成的结果如下 -

[10 20 30]

示例:定义复杂的结构化数据类型

以下示例定义了一个名为 student 的结构化数据类型，其中包含一个字符串字段"name"，一个整数字段"age"和一个浮点型字段"marks"。此数据类型应用于 ndarray 对象 -

import numpy as np
student = np.dtype([('name', 'S20'), ('age', 'i1'), ('marks', 'f4')])
print(student)

我们得到如下所示的输出 -

[('name', 'S20'), ('age', 'i1'), ('marks', '<f4')])

示例:将复杂结构化数据类型应用于 ndarray

import numpy as np
student = np.dtype([('name', 'S20'), ('age', 'i1'), ('marks', 'f4')])
a = np.array([('abc', 21, 50), ('xyz', 18, 75)], dtype=student)
print(a)

输出如下 −

[('abc', 21, 50.0), ('xyz', 18, 75.0)]

每个内置数据类型都有一个唯一标识它的字符代码。

• 'b' − 布尔值

• 'i' − (有符号)整数

• 'u' − 无符号整数

• 'f' − 浮点数

• 'c' − 复数浮点数

• 'm' − 时间增量

• 'M' − 日期时间

• 'O' − (Python) 对象

• 'S', 'a' − (字节)字符串

• 'U' − Unicode

• 'V' − 原始数据 (void)

NumPy - 数组属性

NumPy 数组属性

在 NumPy 中，属性是数组对象的属性，提供有关数组及其数据的重要信息。这些属性用于访问数组结构和配置的各种细节，而无需修改数组。

在本章中，我们将讨论 NumPy 的各种数组属性。

NumPy Shape 属性

NumPy shape 属性提供数组的维度。它返回一个元组，表示数组沿每个维度的大小。它还可以用于调整数组大小。

示例 1

在下面的示例中，我们使用 shape 属性检索 NumPy 数组的形状 -

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

以下是获得的输出 -

(2, 3)

示例 2

在这里，我们使用 NumPy 中的 shape 属性调整数组的大小 -

import numpy as np

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

这将产生以下结果 -

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

示例 3

NumPy 还提供了一个 reshape() 函数来调整数组大小 -

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

NumPy Dimensions 属性

ndim 属性返回数组的维度(轴)数量。

在 NumPy 中，数组的维度称为其秩。NumPy 数组中的每个轴对应一个维度。轴的数量(维度)称为数组的秩。

数组可以是任意维度，从一维 (1D) 数组(也称为向量)到多维数组(例如二维数组(矩阵)，甚至更高维的数组。

示例 1

在此示例中，我们使用 arange() 函数创建一个 NumPy 数组 a，其中包含从"0"到"23"的 24 个等距整数 -

import numpy as np
a = np.arange(24)
print (a)

获得的输出如下所示 -

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

示例 2

在这里，我们使用 arange() 函数创建一个包含"24"个元素的一维 NumPy 数组 a，然后将其重塑为具有指定形状的三维数组"b"，从而得到一个三维数组 -

# 这是一个一维数组
import numpy as np
a = np.arange(24)
a.ndim

# 现在重塑它
b = a.reshape(2,4,3)
print (b)
# 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]]]

NumPy 大小属性

size 属性返回数组中元素的总数。在 NumPy 中，数组的大小指的是数组中包含的元素总数。

• 对于一维数组，大小就是元素的数量。
• 对于二维数组，大小是行数和列数的乘积。
• 对于三维数组，大小是所有三维元素大小的乘积。

示例

在下面的示例中，我们使用 NumPy 中的"size"属性来获取三维数组的大小 -

import numpy as np
# 创建三维数组
array_3d = np.array([[[1, 2, 3], [4, 5, 6]],
[[7, 8, 9], [10, 11, 12]]])
print("3D 数组:
", array_3d)
print("数组大小:", array_3d.size)

以下是得到的输出 -

3D 数组:
[[[ 1 2 3]
[ 4 5 6]]

[[ 7 8 9]
[10 11 12]]]
数组大小:12

NumPy 数据类型属性

dtype 属性描述数组中元素的数据类型。在 NumPy 中，数组的数据类型是指存储在数组中的元素的类型。

NumPy 支持多种数据类型，包括整数、浮点数、复数、布尔值等等。每种数据类型都由一个 dtype 对象表示。 "dtype"不仅指定了数据的类型，还指定了其大小和字节顺序。

示例

在此示例中，我们在创建 NumPy 数组时使用"dtype"属性指定其数据类型 -

import numpy as np

# 创建整数数组
int_array = np.array([1, 2, 3], dtype=np.int32)
print("整数数组:", int_array)
print("int_array 的数据类型:", int_array.dtype)

# 创建浮点数数组
float_array = np.array([1.1, 2.2, 3.3], dtype=np.float64)
print("浮点数组:", float_array)
print("float_array 的数据类型:", float_array.dtype)

# 创建复数数组
complex_array = np.array([1 + 2j, 3 + 4j], dtype=np.complex128)
print("复数数组:", complex_array)
print("complex_array 的数据类型:", complex_array.dtype)

这将产生以下结果 -

整数数组:[1 2 3]
int_array 的数据类型:int32
浮点数组:[1.1 2.2 3.3]
float_array 的数据类型:float64
复数数组:[1.+2.j 3.+4.j]
complex_array 的数据类型:complex128

NumPy Itemsize 属性

itemsize 属性返回数组中每个元素的长度(以字节为单位)。

元素大小由数组的数据类型 (dtype) 决定。不同的数据类型需要不同的内存大小。例如，int32 类型每个元素需要 4 个字节，而 float64 类型每个元素需要 8 个字节。

示例 1

在以下示例中，我们检查整数数据类型为"int8"的数组的项目大小 -

# 数组的 dtype 为 int8(1 字节)
import numpy as np
x = np.array([1,2,3,4,5], dtype = np.int8)
print (x.itemsize)

我们得到如下所示的输出 -

1

示例 2

现在，我们检查浮点数据类型为"float32"的数组的项目大小 -

# 数组的 dtype 现在是 float32(4 字节)
import numpy as np
x = np.array([1,2,3,4,5], dtype = np.float32)
print (x.itemsize)

结果如下 -

4

NumPy 缓冲区信息属性

nbytes 属性返回数组元素消耗的总字节数。

在 NumPy 中，数组的缓冲区信息提供了有关底层内存结构的详细信息用于存储数组数据。这包括内存布局、数据类型以及缓冲区内的字节偏移量等信息。

示例

在本例中，我们使用"nbytes"属性来检索数组数据缓冲区使用的总内存 -

import numpy as np
# 创建数组
array = np.array([1, 2, 3, 4, 5], dtype=np.int32)

# 检查数组的总内存大小
print("数组的总内存大小:", array.nbytes, "bytes")

获得的输出如下所示 -

数组的总内存大小:20 字节

NumPy 步长属性

strides 属性提供遍历数组时在每个维度上步进的字节数。

Strides 指定沿每个轴从一个元素移动到下一个元素时必须在内存中跳过的字节数。它们有助于确定数组在内存中的布局以及如何访问元素。

示例

在下面的示例中，我们使用"strides"属性计算内存地址来访问二维数组中的元素 -

import numpy as np

# 创建二维数组
array = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])

# 检查步幅
print("Array shape:", array.shape)
print("Array strides:", array.strides)

第一个轴(行)的步幅为 16 个字节，这意味着从一行移动到下一行，NumPy 会跳过 16 个字节内存。第二个轴(列)的步长为 4 个字节，表示在同一行内从一列移动到下一列时，NumPy 会跳过 4 个字节 -

数组形状:(3, 4)
数组步长:(32, 8)

NumPy Flags 属性

flags 属性返回有关数组内存布局的信息，例如它在内存中是否连续。

NumPy 提供了多个标志，用于描述数组内存布局和属性的不同方面 -

示例

以下示例显示了数组标志的当前值 -

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

以下是获得的输出 -

C_CONTIGUOUS : True
F_CONTIGUOUS : True
OWNDATA : True
WRITEABLE : True
ALIGNED : True
UPDATEIFCOPY : False

NumPy - 数组创建例程

创建 NumPy 数组

我们可以使用 Python NumPy 库提供的各种函数创建 NumPy 数组。此包提供了一个多维数组对象以及各种其他必要的对象和例程，以实现高效的功能。以下是创建 NumPy 数组所需的函数 -

• 使用 numpy.array() 函数
• 使用 numpy.zeros() 函数
• 使用 numpy.ones() 函数
• 使用 numpy.arange() 函数
• 使用 numpy.linspace() 函数
• 使用 numpy.random.rand() 函数
• 使用 numpy.empty() 函数
• 使用 numpy.full() 函数

与 Python 列表不同，NumPy 数组支持元素级操作，并且更节省内存，非常适合进行数学计算。

使用 numpy.array() 函数

我们可以使用使用 numpy.array() 函数，通过将 Python 列表或元组作为参数传递给该函数来创建数组。

此函数将输入数据(如列表、元组等)转换为 ndarray(NumPy 数组)。语法如下:-

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

示例:创建一维 NumPy 数组

在以下示例中，我们使用 numpy.array() 函数从整数列表创建一维 NumPy 数组:-

import numpy as np

# 从列表创建一维数组
my_list = [1, 2, 3, 4, 5]
my_array = np.array(my_list)

print("一维数组:", my_array)

以下是得到的输出 -

一维数组:[1 2 3 4 5]

示例:创建二维 NumPy 数组

在这里，我们使用 numpy.array() 函数从列表列表创建一个二维 NumPy 数组 -

import numpy as np

# 从列表列表创建二维数组
arr = np.array([[1, 2, 3], [4, 5, 6]])

print("二维数组:
", arr)

这将产生以下结果 -

二维数组:
[[1 2 3]
[4 5 6]]

使用 numpy.zeros() 函数

我们还可以使用 numpy.zeros() 函数创建数组，只需指定所需的数组形状为元组或整数即可。

此函数创建一个填充零的 NumPy 数组。它接受数组的形状作为参数，并可选地接受数据类型 (dtype)。默认情况下，数据类型为 float64。语法如下:-

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

示例

在本例中，我们创建一个包含 5 个元素的 NumPy 数组，所有元素均使用 numpy.zeros() 函数初始化为零。-

import numpy as np

# 创建一个零数组
arr = np.zeros(5)
print(arr)

以上代码的输出如下:-

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

使用 numpy.ones() 函数

另一方面，numpy.ones() 函数创建一个所有元素都设置为 1 的数组。它接受三个主要参数:shape、dtype 和 order。

• shape 参数可以是整数或整数元组，用于定义数组的维度。
• dtype 参数指定数组元素所需的数据类型，如果未提供，则默认为"float64"。
• order 参数确定数组的内存布局，可以是行优先(C 语言风格)或列优先(Fortran 语言风格)，默认为"C"。

语法如下:

numpy.ones(shape, dtype=None, order='C')

示例:创建一维 1 数组

在下面的示例中，我们将创建一个包含 3 个元素的一维 NumPy 数组，所有元素均使用 numpy.ones() 函数初始化为 1 -

import numpy as np

# 创建一个 1 数组
arr = np.ones(3)
print(arr)

执行上述代码后，我们得到以下输出 -

[1. 1. 1.]

示例:创建全 1 的二维数组

在这里，我们使用 np.ones() 函数创建一个 2 行 3 列的二维 NumPy 数组，所有元素均为 1 -

import numpy as np

# 创建全 1 的二维数组
array_2d = np.ones((4, 3))
print(array_2d)

结果如下 -

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

示例:创建一个 Fortran 排序的 1 数组

现在，我们使用 np.ones() 函数，以 Fortran 风格(列优先)排序，创建一个 2 行 3 列的二维 NumPy 数组，所有元素均为 1 -

import numpy as np

# 创建 Fortran 排序的 1 数组
array_F = np.ones((4, 3), order='F')
print(array_F)

我们得到如下所示的输出 -

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

使用 numpy.arange() 函数

numpy.arange() 函数通过根据指定的起始值、终止值和步长生成数字序列来创建数组。它类似于 Python 的内置 range() 函数。

此函数创建一个在给定间隔内等距分布的数组。它允许指定起始值、终止值和步长，并返回一个 NumPy 数组。

• start − 序列的起始值。如果未指定，则默认为 0。

• stop − 序列的结束值。此值不包含在序列中。

• step − 序列中每对连续值之间的步长或间隔。如果未指定，则默认为 1。

以下是语法 -

numpy.arange([start,] stop[, step,] dtype=None, *, like=None)

示例

在下面的示例中，我们首先创建一个从 0 到 9 的 NumPy 数组"array1"。然后，我们使用 np.arange() 函数创建另一个数组"array2"，其值从 1 到(但不包括)10，步长为 2 -

import numpy as np

# 仅提供停止值
array1 = np.arange(10)
print("array1:", array1)

# 提供起始值、终止值和步长值
array2 = np.arange(1, 10, 2)
print("array2:",array2)

以下是得到的输出 −

array1: [0 1 2 3 4 5 6 7 8 9]
array2: [1 3 5 7 9]

使用 numpy.linspace() 函数

我们甚至可以使用 numpy.linspace() 函数通过指定起始值、终止值和所需的元素数量来创建数组。

此函数创建的数组由指定间隔内均匀分布的值组成。该函数接受起始值、终止值和元素数量的参数，并生成在起始值和终止值之间(含起始值和终止值)均匀分布的值。以下是语法 -

numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0)

当您需要在两个端点之间设置一定数量的点来进行绘图或数值计算时，numpy.linspace() 函数特别有用。

示例

在下面的示例中，我们使用 numpy.linspace() 函数创建三个具有指定范围和配置的数组(array1、array2 和 array3)。

"array1"由 10 个等距值组成，范围从 0 到 5(含 0 和 5)。 "array2"由 5 个值组成，范围从 1 到略小于 2，不包括端点。"array3"由 5 个值(范围从 0 到 10)创建，并返回数组以及连续值之间的步长 -

import numpy as np

# 创建一个包含 10 个值(范围从 0 到 5)的数组
array1 = np.linspace(0, 5, num=10)
print("array1:",array1)

# 创建一个包含 5 个值(范围从 1 到 2，不包括端点)的数组
array2 = np.linspace(1, 2, num=5, end=False)
print("array2:",array2)

# 创建一个数组并返回步长
array3, step = np.linspace(0, 10, num=5, retstep=True)
print("array3:",array3)
print("步长:", step)

这将产生以下结果 -

array1: [0.          0.55555556 1.11111111 1.66666667 2.22222222 2.77777778
3.33333333 3.88888889 4.44444444 5.         ]
array2: [1.   1.2 1.4 1.6 1.8]
array3: [ 0.   2.5 5.   7.5 10. ]
步长: 2.5

使用 random.rand() 函数

或者，我们可以使用 numpy.random.rand() 函数，通过指定数组的维度作为参数来创建数组。

此函数用于创建一个指定形状的数组，该数组填充从 [0, 1) 上的均匀分布中采样的随机值。

它接受数组维度的参数(例如 numpy.random.rand(rows, columns))，并生成一个指定形状的数组，其中包含 0 到 1 之间的随机值。如果没有提供参数，则返回一个随机浮点值。语法如下:-

numpy.random.rand(d0, d1, ..., dn)

示例

在以下示例中，我们使用 numpy.random.rand() 函数生成不同维度的随机浮点数数组:-

import numpy as np

# 生成单个随机浮点数
random_float = np.random.rand()
print("random_float:",random_float)

# 生成一维随机浮点数数组
array_1d = np.random.rand(5)
print("array_1d:",array_1d)

# 生成二维随机浮点数数组浮点数
array_2d = np.random.rand(2, 3)
print("array_2d:",array_2d)

# 生成一个随机浮点数的三维数组
array_3d = np.random.rand(2, 3, 4)
print("array_3d:",array_3d)

以下是上述代码的输出 -

random_float: 0.5030496450079744
array_1d: [0.19476581 0.54430648 0.64571106 0.27443774 0.71874319]
array_2d: [[0.91141582 0.58847504 0.37284854]
 [0.0715398  0.21305363 0.766954  ]]
array_3d: [[[0.7295106  0.1582053  0.91376381 0.14099229]
  [0.6876814  0.19351871 0.18056163 0.61370308]
  [0.42382443 0.6665121  0.42322218 0.11707395]]
[[0.60883975 0.01724199 0.95753734 0.17805716]
  [0.47770594 0.55840874 0.7375783  0.50512301]
  [0.73730351 0.85900855 0.16472072 0.2338285 ]]]

使用 numpy.empty() 函数

我们可以使用 numpy.empty() 函数创建一个 NumPy 数组，并将数组的形状指定为参数。

此函数初始化数组但不初始化其元素;数组的内容是任意的，并且可能会有所不同。当您需要一个特定大小和数据类型的数组，但打算稍后用数据填充它时，它非常有用。以下是语法:

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

与 numpy.zeros() 函数和 numpy.ones() 函数(它们分别将数组元素初始化为零和一)不同，numpy.empty() 函数不会初始化元素。相反，它会分配数组所需的内存，而不设置任何值。

示例

在此示例中，我们使用 numpy.empty() 函数创建一个包含 2 行 3 列的二维数组 (empty_array) -

import numpy as np

empty_array = np.empty((2, 3))
print(empty_array)

获得的输出如下所示 -

[[1.13750619e-313 0.00000000e+000 0.00000000e+000]
[0.00000000e+000 0.00000000e+000 0.00000000e+000]]

与 numpy.zeros() 不同，此函数使用未初始化的值初始化数组，这些值可以是内存中剩余的任何随机数据，因此适用于不需要立即初始化的情况。

使用 numpy.full() 函数

使用 numpy.full() 函数，我们可以创建一个具有所需形状的数组，并将其中的所有元素设置为特定值。语法如下:-

numpy.full(shape, fill_value, dtype=None, order='C')

示例

在下面的示例中，我们使用 numpy.full() 函数创建一个维度为 2x3 的二维数组，并全部填充值 5:-

import numpy as np

array1 = np.full((2, 3), 5)
print(array1)

执行上述代码后，我们得到以下输出:-

[[5 5 5]
[5 5 5]]

用于NumPy 数组的创建

在 NumPy 模块中，有多种创建 NumPy 数组的方法，包括基本创建方法、通过重塑和修改数据创建、使用序列创建以及使用随机函数创建。以下是用于创建 NumPy 数组的不同函数 -

基本数组创建

以下是创建数组的基本函数 -

Sr.No.	功能 &说明
1	array() 用于创建 NumPy 数组
2	asarray() 将输入转换为数组
3	asanyarray() 将输入转换为 ndarray，但传递 ndarray 子类至
4	copy() 返回给定对象的数组副本

使用特定形状和数据创建数组

以下是用于创建具有指定形状和数据的数组的函数 -

Sr.No.	函数 &说明
1	zeros() 返回一个给定形状和类型的新数组，并用零填充
2	ones() 返回一个给定形状和类型的新数组，并用一填充
3	empty() 返回一个给定形状和类型的新数组，但不初始化元素
4	full() 返回一个具有给定形状和类型的新数组，并使用 fill_value 进行填充

使用序列创建数组

以下是用于创建带有序列的数组的函数 -

Sr.No.	函数 &说明
1	arange() 返回给定区间内等距的值
2	linspace() 返回指定区间内等距的数字。
3	logspace() 返回对数尺度上等距的数字。

特殊数组

以下是创建数组的特殊函数 -

Sr.No.	函数 &说明
1	eye() 返回一个二维数组，对角线上为 1，其他位置为 0
2	identity() 返回恒等数组。
3	diag() 提取对角线或构建对角数组
4	fromfunction() 通过在每个坐标上执行函数来构建数组
5	fromfile() 根据文本或二进制文件中的数据构建数组

随机数组

以下是创建数组的随机函数 -

Sr.No.	函数 &说明
1	random.rand() 给定形状的随机值
2	random.randn() 返回标准正态分布的样本
3	random.randint() 返回从低(含)到高的随机整数(独占)
4	random.random() 返回半开区间 [0.0, 1.0) 内的随机浮点数
5	random.choice() 从给定的一维数组生成随机样本

结构化数组

以下是用于创建数组的结构化函数 -

序号	功能与说明
1	zeros_like() 返回一个由零元素组成的数组，其形状和类型与给定数组相同
2	ones_like() 返回一个由一元素组成的数组，其形状和类型与给定数组相同。
3	empty_like() 返回一个新数组，其与给定数组具有相同形状和类型
4	full_like() 返回与给定数组具有相同形状和类型的完整数组

NumPy - 基于现有数据创建数组

在 NumPy 中基于现有数据创建数组

您可以使用 Python 中已有的数据结构初始化 NumPy 数组，或者将其转换为与 NumPy 兼容的格式，从而基于 NumPy 中的现有数据创建数组。以下是实现此目的的几种常用方法 -

• 使用 numpy.asarray() 函数
• 使用 numpy.frombuffer() 函数
• 使用 numpy.fromiter() 函数
• 从 Python 列表
• 从嵌套列表
• 从 Python 元组
• 从现有的 NumPy 数组
• 使用 Range 对象

NumPy 快速运行并对数组执行复杂操作的能力在数据处理和执行科学计算等领域非常重要。

使用 numpy.asarray() 函数

numpy.asarray() 函数用于将各种 Python 对象转换为 NumPy 数组。这些对象包括 Python 列表、元组、其他数组，甚至标量值。

此函数确保结果始终为 NumPy 数组，方便数据操作和数值计算。语法如下:

numpy.asarray(a, dtype=None, order=None)

其中:

• a − 表示输入数据，可以是列表、元组、数组或任何可转换为数组的对象。

• dtype(可选)− 表示数组的所需数据类型。如果未指定，NumPy 将根据输入确定数据类型。

• order(可选)- 指定是否按行优先 (C) 或列优先 (F) 顺序存储数组。默认值为 None，这意味着 NumPy 根据输入进行判断。

示例:将 Python 列表转换为 NumPy 数组

在以下示例中，我们使用 numpy.asarray() 函数将 Python 列表转换为 NumPy 数组 -

import numpy as np

# 将列表转换为数组
my_list = [1, 2, 3, 4, 5]
arr_from_list = np.asarray(my_list)

print("Array from list:",arr_from_list)

以下是获得的输出 -

Array from list: [1 2 3 4 5]

示例:保留数据类型

在这里，我们使用 numpy.asarray() 函数将包含不同数据类型(int、float、bool、str)元素的 Python 列表转换为 NumPy 数组 -

import numpy as np

# 将包含不同数据类型的列表转换为数组
my_mixed_list = [1, 2.5, True, 'hello']
arr_from_mixed = np.asarray(my_mixed_list)

print("混合列表数组:", arr_from_mixed)

这将产生以下结果 -

混合列表数组:['1' '2.5' 'True' 'hello']

使用numpy.frombuffer()函数

numpy.frombuffer()函数用于从缓冲区对象(例如字节对象或字节数组)创建数组。这在处理原始二进制数据或内存缓冲区时非常有用。

此函数将缓冲区对象解释为一维数组数据。它允许您指定结果数组中元素的数据类型。语法如下:

numpy.frombuffer(buffer, dtype=float, count=-1, offset=0)

其中:

• buffer − 是包含要解释为数组的数据的缓冲区对象。

• dtype(可选)− 是结果数组中元素所需的数据类型。默认为浮点型。

• count(可选)− 表示从缓冲区读取的数据项数量。默认值为 -1，表示读取所有数据。

• offset(可选)− 表示缓冲区中开始读取数据的起始位置。默认值为 0。

示例

在此示例中，我们使用 numpy.frombuffer() 函数将字节对象"my_bytes"解析为一维字节数组 −

import numpy as np

# 创建字节对象
my_bytes = b'hello world'

# 从字节对象创建数组
arr_from_bytes = np.frombuffer(my_bytes, dtype='S1')

print("从字节对象创建的数组:",arr_from_bytes)

生成的 NumPy 数组包含原始字节对象"hello world"的每个字节 -

从字节对象创建的数组:[b'h' b'e' b'l' b'l' b'o' b' ' b'w' b'o' b'r' b'l' b'd']

使用 numpy.fromiter() 函数

numpy.fromiter() 函数从一个可迭代对象创建一个新的一维数组。它迭代可迭代对象，将每个元素转换为数组元素。语法如下:

numpy.fromiter(iterable, dtype, count=-1)

其中:

• iterable - 可迭代对象，可逐个返回元素。

• dtype - 结果数组中元素的数据类型。

• count(可选)- 从可迭代对象中读取的项目数。默认值为 -1，表示读取所有项目。

示例

在下面的示例中，我们使用 numpy.fromiter() 函数从生成器"my_generator"创建一个 NumPy 数组"gen_array"，该生成器的数值范围为 0 到 4 -

import numpy as np

# 生成数值的生成器函数
def my_generator(n):
   for i in range(n):
      yield i

# 从生成器创建数组
gen_array = np.fromiter(my_generator(5), dtype=int)

print("从生成器生成的数组:",gen_array)

在生成的数组中，每个元素都对应一个由生成器函数转换为整数后的值 -

从生成器生成的数组:[0 1 2 3 4]

Python 中的生成器是一次生成一个值序列的函数。NumPy 提供了 np.fromiter() 函数来从生成器创建数组。

从 Python 列表创建

创建 NumPy 数组的最常见方法之一是转换 Python 列表。此方法提供 numpy.array() 函数或 numpy.asarray() 函数，用于将 Python 中常用的数据结构列表转换为 NumPy 数组。

语法如下:-

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

其中:

• object - 输入数据，在本例中为 Python 列表。

• dtype(可选)- 数组所需的数据类型。如果未指定，NumPy 会根据输入数据解释数据类型。

• copy(可选)- 如果为 True，则确保复制输入数据。如果为 False，则尽可能避免不必要的复制。

• order(可选)- 指定数组的内存布局顺序。"C"表示行优先(C 风格)，"F"表示列优先(Fortran 风格)，"K"表示输入数组的布局(默认)。

• subok(可选)- 如果为 True，则传递子类;否则，返回的数组将被强制为基类数组。

• ndmin(可选)- 指定结果数组应具有的最小维数。

示例

在下面的示例中，我们使用 numpy.array() 函数将包含整数的 Python 列表"my_list"转换为 NumPy 数组 -

import numpy as np

# 将列表转换为数组
my_list = [1, 2, 3, 4, 5]
arr_from_list = np.array(my_list)

print("来自列表的数组:",arr_from_list)

执行上述代码后，我们得到以下输出 -

来自列表的数组:[1 2 3 4 5]

来自嵌套列表

Python 中的嵌套列表是列表中的列表，可以表示多维数据结构。NumPy 提供了 array() 函数将这些嵌套列表转换为多维数组。

示例:将嵌套列表转换为二维 NumPy 数组

在此示例中，嵌套列表"nested_list"表示二维结构(列表的列表)。array() 函数将其转换为二维 NumPy 数组"arr_from_nested_list"-

import numpy as np

# 将嵌套列表转换为数组
nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
arr_from_nested_list = np.array(nested_list)

print("嵌套列表的数组:")
print(arr_from_nested_list)

生成的数组保留了二维结构，并包含与原始嵌套列表相同的元素，如下图所示 -

嵌套列表的数组:
[[1 2 3]
[4 5 6]
[7 8 9]]

示例:转换包含不同数据类型的嵌套列表

此处，嵌套列表包含不同数据类型的元素(整数、浮点数、布尔值和字符串)。 array() 函数将所有元素转换为字符串，从而生成一个具有字符串数据类型的同构二维数组 -

import numpy as np

# 将不同数据类型的嵌套列表转换为数组
nested_mixed_list = [[1, 2.5], [True, 'hello']]
arr_from_nested_mixed_list = np.array(nested_mixed_list)

print("嵌套混合列表的数组:")
print(arr_from_nested_mixed_list)

生成的结果如下 -

嵌套混合列表的数组:
[['1' '2.5']
['True' 'hello']]

来自 Python元组

Python 元组是另一种常用的数据结构，可以转换为 NumPy 数组。与列表类似，元组可用于存储多个项目，但它们是不可变的，这意味着其内容在创建后无法更改。

它可以使用 numpy.array() 函数来表示一维和多维数据。

示例

在以下示例中，我们使用 array() 函数将包含整数的 Python 元组转换为 NumPy 数组 -

import numpy as np

# 将元组转换为数组
my_tuple = (1, 2, 3, 4, 5)
arr_from_tuple = np.array(my_tuple)

print("元组创建数组:",arr_from_tuple)

我们得到如下所示的输出 -

元组创建数组:[1 2 3 4 5]

从现有 NumPy 数组创建

NumPy 提供了几种从现有 NumPy 数组创建新数组的方法。它们是:-

• numpy.copy() 函数
• numpy.asarray() 函数
• numpy.view() 函数
• numpy.reshape() 函数
• 切片

切片可用于各种任务，例如复制数据、更改数据类型或创建具有从原始数组派生的特定属性的新数组。

示例:使用 numpy.copy() 函数

numpy.copy() 函数创建一个新数组，它是原始数组的副本。这确保对新数组的任何修改都不会影响原始数组 -

import numpy as np

# 原始数组
original_array = np.array([1, 2, 3, 4, 5])

# 创建数组副本
copied_array = np.copy(original_array)

print("原始数组:",original_array)
print("复制后的数组:",copied_array)

以下是得到的输出 -

原始数组:[1 2 3 4 5]
复制后的数组:[1 2 3 4 5]

示例:使用 numpy.asarray() 函数

numpy.asarray() 函数将输入转换为数组，但如果输入已经是数组，则除非必要(例如，指定了不同的数据类型)，否则它不会创建副本。 −

import numpy as np

# 原始数组
original_array = np.array([1, 2, 3, 4, 5])

# 根据现有数组创建一个数组
new_array = np.asarray(original_array, dtype=float)

print("原始数组:",original_array)
print("新数组:",new_array)

这将产生以下结果 −

原始数组:[1 2 3 4 5]
新数组:[1. 2. 3. 4. 5.]

示例:使用 numpy.view() 函数

numpy.view() 函数创建一个新的数组对象，该对象查看与原始数组相同的数据。这对于使用不同的数据类型查看数据非常有用 -

import numpy as np

# 原始数组
original_array = np.array([1, 2, 3, 4, 5], dtype=np.int32)

# 使用不同的数据类型创建数组的视图
viewed_array = original_array.view(dtype=np.float32)

print("原始数组:",original_array)
print("使用 float32 数据类型查看后的数组:",viewed_array)

以下是上述代码的输出 -

原始数组:[1 2 3 4 5]
使用 float32 数据类型查看后的数组:[1.e-45 3.e-45 4.e-45 6.e-45 7.e-45]

示例:使用 numpy.reshape() 函数

numpy.reshape() 函数将现有数组重塑为新形状，而不更改其数据 -

import numpy as np

# 原始数组
original_array = np.array([1, 2, 3, 4, 5, 6])

# 将数组重塑为 2x3
reshaped_array = original_array.reshape((2, 3))

print("原始数组:",original_array)
print("重塑后的数组 (2x3):",reshaped_array)

得到的输出如下所示−

原始数组:[1 2 3 4 5 6]
重构数组 (2x3):[[1 2 3]
[4 5 6]]

示例:使用切片

对现有数组进行切片会创建一个新数组，该数组是原始数组的子集 −

import numpy as np

# 原始数组
original_array = np.array([1, 2, 3, 4, 5])

# 对数组进行切片以获取子数组
sliced_array = original_array[1:4]

print("原始数组:",original_array)
print("切片后的数组(元素 1 至3):",sliced_array)

输出结果如下 -

原始数组:[1 2 3 4 5] 切片数组(元素 1 至 3):[2 3 4]

使用 Range 对象

Python range 对象生成指定范围内的数字，可以使用 numpy.array() 函数或 numpy.fromiter() 函数将其转换为 NumPy 数组。当你需要创建大型序列，而无需先将所有数字显式存储在内存中时，这非常有用。

示例

在此示例中，range() 对象生成从 1 到 9 的数字。numpy.array() 函数将此范围对象转换为 NumPy 数组 -

import numpy as np

# 创建范围对象
my_range = range(1, 10)
# 将范围对象转换为数组
arr_from_range = np.array(my_range)

print("来自范围对象的数组:",arr_from_range)

执行上述代码后，我们得到以下输出 -

来自范围对象的数组:[1 2 3 4 5 6 7 8 9]

NumPy - 基于数值范围的数组

NumPy 中的基于数值范围的数组

在 NumPy 中，基于数值范围创建数组是指生成包含指定范围内数字序列的数组。NumPy 提供了几个用于创建此类数组的函数，如下所示:

• 使用 numpy.arange() 函数
• 使用 numpy.linspace() 函数
• 使用 numpy.logspace() 函数
• 使用 numpy.meshgrid() 函数

使用 numpy.arange() 函数

numpy.arange() 函数通过根据指定的起始值、终止值和步长值生成数字序列来创建数组。它类似于 Python 内置的 range() 函数，但返回一个 NumPy 数组。语法如下:-

numpy.arange([start, ]stop, [step, ]dtype=None, *, like=None)

其中:

• start(可选)- 区间的起始值。默认值为 0。

• stop - 区间的结束值(不包含)。

• step(可选)- 值之间的间隔。默认值为 1。

• dtype(可选)- 数组所需的数据类型。如果未指定，NumPy 会根据输入值解析数据类型。

示例:基本用法

在下面的示例中，我们使用 numpy.arange() 函数生成一个从 0 到(但不包括)10 的数组 -

import numpy as np

# 创建一个从 0 到 9 的数组
arr = np.arange(10)
print("使用 arange() 的数组:", arr)

以下是得到的输出 -

使用 arange() 的数组:[0 1 2 3 4 5 6 7 8 9]

示例:指定起始、终止和终止步长

在这里，我们使用 numpy.arange() 函数生成一个从 1 开始，直到(但不包括)10 的数组，步长为 2 -

import numpy as np

# 创建一个从 1 到 9 的数组，步长为 2
arr = np.arange(1, 10, 2)
print("包含起始值、终止值和步长的数组:", arr)

这将产生以下结果 -

包含起始值、终止值和步长的数组:[1 3 5 7 9]

使用 numpy.linspace() 函数

numpy.linspace() 函数生成一个在指定间隔内具有均匀分布值的数组。当你需要两个值之间指定特定数量的点时，它非常有用。

此函数类似于 arange() 函数。在此函数中，指定的不是步长，而是间隔之间等距值的数量。语法如下:

numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None, axis=0)

其中:

• start − 间隔的起始值。

• stop − 间隔的结束值。

• num(可选)− 要生成的均匀间隔样本数。默认值为 50。

• endpoint(可选)− 如果为 True，则 stop 为最后一个样本。如果为 False，则不包含该样本。默认值为 True。

• retstep(可选)− 如果为 True，则返回 (samples, step)，其中 step 为样本之间的间隔。默认值为 False。

• dtype(可选)− 数组所需的数据类型。如果未指定，NumPy 会根据输入值解释数据类型。

• axis(可选)− 结果中用于存储样本的轴。默认值为 0。

示例:基本用法

在本例中，我们使用 numpy.linspace() 函数生成一个包含 10 个从 0 到 1(默认包含 0 和 1)等距值的数组 -

import numpy as np

# 创建一个包含 10 个从 0 到 1 等距值的数组
arr = np.linspace(0, 1, 10)
print("Array using linspace():", arr)

以下是上述代码的输出 -

Array using linspace(): [0.0.11111111 0.22222222 0.33333333 0.44444444 0.55555556
0.66666667 0.77777778 0.88888889 1.         ]

示例:排除端点

在这里，我们生成一个包含 10 个等距值的数组，这些值的范围从 0 到略小于 1，并使用 numpy.linspace() 函数排除端点 -

import numpy as np

# 创建数组
arr = np.linspace(0, 1, 10, end=False)
print("endpoint=False 的数组:", arr)

得到的输出如下所示 −

endpoint=False 的数组:[0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]

示例:返回步长

现在，我们生成一个包含 10 个等距值的数组，这些值的范围从 0 到 1(默认包含 0 和 1)，并返回步长 -

import numpy as np

# 创建数组
arr, step = np.linspace(0, 1, 10, retstep=True)
print("步长数组:", arr)
print("步长:", step)

执行上述代码后，我们得到以下输出 -

步长数组:[0.0.11111111 0.22222222 0.33333333 0.44444444 0.55555556
0.66666667 0.77777778 0.88888889 1.        ]
步长:0.11111111111111111

使用 numpy.logspace() 函数

numpy.logspace() 函数生成一个数组，其值在对数尺度上均匀分布。这对于生成跨越多个数量级的值非常有用。语法如下:

numpy.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None, axis=0)

其中:

• start − 序列的起始值(以基数的幂为单位)。

• stop − 序列的终止值(以基数的幂为单位)。

• num(可选)− 要生成的样本数。默认为 50。

• endpoint(可选)− 如果为 True，则 stop 为最后一个样本。如果为 False，则不包含该样本。默认值为 True。

• base(可选)− 对数空间的底数。默认值为 10.0。

• dtype(可选)− 数组所需的数据类型。如果未指定，NumPy 会根据输入值解析数据类型。

• axis(可选)− 结果中用于存储样本的轴。默认值为 0。

示例

在下面的示例中，我们使用 numpy.logspace() 函数生成一个包含 10 个值的数组，这些值以对数刻度均匀分布，范围从 2¹ 到 2¹⁰，底数为 2。-

import numpy as np

# 创建数组
arr = np.logspace(1, 10, 10, base=2)
print("以 2 为底的数组:", arr)

输出结果如下 -

以 2 为底的数组:[   2.    4.    8.   16.   32.   64.  128.  256.  512. 1024.]

使用 numpy.meshgrid() 函数

numpy.meshgrid() 函数可以根据坐标向量生成坐标矩阵。这对于创建点网格以在二维或三维空间中计算函数非常有用。语法如下:

numpy.meshgrid(*xi, copy=True, sparse=False, indexing='xy')

其中:

• *xi - 表示网格坐标的一维数组。

• copy(可选)- 如果为 True，则复制输入数组。默认为 True。

• sparse(可选)- 如果为 True，则返回稀疏网格以节省内存。默认值为 False。

• 索引(可选)- 指定笛卡尔坐标("xy"，默认值)或矩阵坐标("ij")的索引约定。

示例:创建二维网格

在下面的示例中，我们使用 numpy.meshgrid() 函数从一维数组"x"和"y"生成坐标矩阵"X"和"Y"，其中 X 表示二维网格的 x 坐标，Y 表示 y 坐标 -

import numpy as np

# 创建 x 和 y 坐标的一维数组
x = np.arange(1, 4)
y = np.arange(1, 3)

# 生成坐标矩阵
X, Y = np.meshgrid(x, y)

print("X grid:")
print(X)
print("Y grid:")
print(Y)

以下是得到的输出 -

X grid:
[[1 2 3]
[1 2 3]]
Y grid:
[[1 1 1]
[2 2 2]]

示例:创建 3D 网格

现在，我们使用矩阵索引 ('ij')，从一维数组 x、y 和 z 生成 3D 网格的坐标矩阵 X、Y 和 Z -

import numpy as np

# 创建 x、 y 和 z 坐标
x = np.arange(1, 4)
y = np.arange(1, 3)
z = np.arange(1, 3)

# 生成坐标矩阵
X, Y, Z = np.meshgrid(x, y, z, indexing='ij')

print("X grid:")
print(X)
print("Y grid:")
print(Y)
print("Z grid:")
print(Z)

执行上述代码后，我们得到以下输出 -

X grid:
[[[1 1]
  [1 1]]
[[2 2]
  [2 2]]
[[3 3]
  [3 3]]]
Y grid:
[[[1 1]
  [2 2]]
[[1 1]
  [2 2]]
[[1 1]
  [2 2]]]
Z grid:
[[[1 2]
  [1 2]]
[[1 2]
  [1 2]]
[[1 2]
  [1 2]]]

NumPy - 索引与切片

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

NumPy 索引

NumPy 索引用于访问或修改数组中的元素。索引方法有三种:字段访问、基本切片和高级索引。

示例 1

在下面的示例中，我们使用 arange() 函数创建了一个数组，让我们看看如何从数组中访问单个元素，即 6。

import numpy as np
a = np.arange(10)
b = a[6]
print(b)

以下是上述代码的输出 -

6

示例 2

假设我们有一个包含 5 名学生英语成绩的列表，我们需要访问第三名学生的成绩，我们使用 arr[2] 作为索引的起始位置'0'。

import numpy as np
scores = ['86', '98', '100', '65', '75']
arr = np.array(scores)
print("第三名学生的成绩是:", arr[2])

以下是上述代码的输出 -

第三名学生的成绩是:100

NumPy 中的切片

NumPy 切片是 Python 基本 n 维切片概念的扩展。通过向内置切片函数提供开始、停止和步骤参数来构造 Python 切片对象。此切片对象被传递给数组，以提取数组的一部分。

示例 1

在下面的代码中，我们将看到如何使用 arr[-2:] 访问数组中的最后两个元素。由于我们没有指定 stop 参数，因此它会访问从倒数第二个元素到数组末尾的元素。

import numpy as np
arr = np.arange(6)
print(arr[-2:])

以下是上述代码的输出 -

[4 5]

示例 2

假设我们有一个包含 1 到 12 的数字的数组，并且只需要访问偶数，我们使用带有 step 参数的切片'arr[::2]' 因为它会切片数组中的每个第二个元素。

import numpy as np
arr = np.arange(12)
even_num = arr[::2]
print("偶数:", even_num)

以下是上述代码的输出 -

偶数:[ 0 2 4 6 8 10]

示例 3

让我们创建一个二维数组，并使用切片访问数组中的第二列。要访问所有行 (:) 但仅访问第二列(索引 1)，我们使用 arr[:, 1]

import numpy as np
arr = np.array([[10, 20, 30], [40, 50, 60], [70, 80, 90]])
print(arr[:, 1])

以下是上述代码的输出 -

[20 50 80]

示例 4

在下面的代码中，我们创建了一个二维数组，让我们看看如何访问从第 2 行(索引 1)开始的所有元素，并使用 a[1:]。其中，a[1:] 选择从第二行(索引 1)开始到最后一行的所有行，包括所有列。

import numpy as np
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]]

示例 5

让我们看看如何在索引之间对数组进行切片 -

import numpy as np
a = np.arange(10)
print("从索引 1 到 6 的数组:", a[1:7])

运行上述程序，结果如下 -

从索引 1 到 6 的数组:[1 2 3 4 5 6]

NumPy - 高级索引

高级索引提供了一种强大的方法，可以根据预定条件或准则从 NumPy 数组中选择特定元素。

虽然基本索引(例如 array[1:4])为您提供了原始数组的"视图"(对切片的修改会影响原始数据)，但高级索引始终会创建所选数据的副本。

它允许您从非元组序列的 ndarray、整数或布尔数据类型的 ndarray 对象或至少有一个项是序列对象的元组中选择元素。此方法有助于动态数据选择以及条件数据提取。

高级索引有两种类型 -

• 整数索引
• 布尔数组索引

整数索引

这允许您根据数组的 N 维索引，使用其确切位置(索引)从数组中选择特定元素。每个整数数组代表该维度的索引数量。

如果整数数组的数量与目标 ndarray 的维度相对应，则选择项目将变得简单直接。这就像在 x、y、z 位置选择项目一样。

示例:按索引选择元素

以下示例使用整数数组作为行和列，从数组的每一行中选择一个元素。选择包括第一个数组中 (0,0)、(1,1) 和 (2,0) 处的元素。以下是代码 -

import numpy as np
x = np.array([[1, 2], [3, 4], [5, 6]])
y = x[[0,1,2], [0,1,0]]
print(x)
print('新数组为:
', y)

以下是上述代码的输出 -

[[1 2]
[3 4]
[5 6]]
新数组为:
[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('我们的数组是:
', x)
rows = np.array([[0,0],[3,3]])
cols = np.array([[0,2],[0,2]])
y = x[rows,cols]
print('此数组的角元素是:
', y)

以下是上述代码的输出代码 −

我们的数组是:
[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]
此数组的角元素是:
[[ 0 2]
[ 9 11]]

示例:访问特定分数

在此示例中，我们有一个二维数组，其中包含三个不同学生的分数，行表示三个学生的分数，三列表示三个不同科目(印地语、数学和英语)的分数。

现在，我们将了解如何访问学生 1 的印地语成绩和学生 2 的数学成绩。以下是代码 −

import numpy as np
marks = np.array([[85, 99, 88], [78, 93, 85], [86, 45, 90]])
specific_results = marks[[0, 1], [0, 1]]
print('分数:
', marks)
print('选定分数:
', specific_results)

以上代码的输出如下 -

分数:
[[85 99 88]
[78 93 85]
[86 45 90]]
选定分数:
[85 93]

示例:索引越界错误

在 NumPy 中，当你尝试使用超出数组维度有效范围的索引访问数组中的元素时，会发生索引错误(索引越界)。

让我们通过一个示例来理解这一点:一个数组包含 3 行，但代码尝试访问第 4 行(索引 3)，抛出了索引错误 -

import numpy as np
x = np.array([[0, 1], [2, 3], [4, 65]])
print('二维数组为:
', x)
print(x[3,1])

以下是上述代码的输出 -

二维数组为:
[[ 0 1]
[ 2 3]
[ 4 65]]
Traceback (most recent call last):
  File "/home/cg/root/22245/main.py", line 4, in 
    print(x[3,1])
IndexError: index 3 is out of bounds for axis 0 with size 3

布尔数组索引

NumPy 的布尔索引功能允许您选择满足特定条件的数组元素。它涉及创建一个布尔数组，其中每个元素都与 True 或 False 条件匹配。当布尔数组显示 True 时，将选择原始数组中的元素。

此方法非常适合使用逻辑条件(例如比较运算)过滤数据。它是从数组中提取特定值的强大工具。

示例:使用布尔数组选择特定元素

此代码演示了如何使用布尔数组作为掩码来从 NumPy 数组中选择特定元素。布尔数组指定最终数组中哪些元素应包含 (True) 或排除 (False)。

import numpy as np

arr = np.array([10, 20, 30, 40, 50])
bool_array = np.array([True, False, True, False, True])
selected_elements = arr[bool_array]

print("原始数组:", arr)
print("布尔数组:", bool_array)
print("选定元素:", selected_elements)

以上代码的输出如下 -

原始数组:[10 20 30 40 50]
布尔数组:[ True False True False True]
选定元素:[10 30 50]

示例:过滤大于 5 的项目

在此示例中，大于 5 的项目将通过布尔索引返回。

import numpy as np
x = np.array([[ 0, 1, 2],[ 3, 4, 5],[ 6, 7, 8],[ 9, 10, 11]])
print('我们的数组是:
', x)
print('大于 5 的项目是:' , x[x > 5])

运行上述程序，结果如下:

我们的数组是:
[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]
大于 5 的项目是:[ 6 7 8 9 10 11]

示例:删除 NaN 值

在此示例中，使用 ~(补码运算符)省略 NaN(非数字)元素。

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

运行上述程序，结果如下:-

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

示例:过滤复数

以下示例演示如何从数组中过滤掉复数。

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

上述代码的输出如下:-

[2. +6.j 3.5+5.j]

示例:提取偶数

让我们看看如何使用布尔索引从数组中提取偶数 -

import numpy as np
x = np.array([1, 2, 3, 4, 5, 6, 7, 8])
print('偶数为:', x[x % 2 == 0])

以下是上述代码的输出 -

偶数为:[2 4 6 8]

NumPy - 广播

NumPy 广播

NumPy 中的广播功能是指能够对不同形状的数组执行运算，即自动扩展较小数组的形状以匹配较大数组的形状。这在执行算术运算或将函数应用于不同维度的数组时非常有用。

执行算术运算时，NumPy 会对数组的对应元素进行运算。如果数组形状相同，则运算可以顺利进行。但是，如果数组的形状不同，NumPy 会使用广播来对齐它们，从而轻松进行元素级操作。

广播规则

要使广播正常工作，必须满足以下规则 -

• 如果数组的维数不同，则在较小维数组的左侧用 1 填充，直到两个数组的长度相同。
• 每个维度的大小必须相同，或者其中一个必须为 1。
• 广播从最后一个维度应用到第一个维度。

例如，考虑两个形状分别为 (3, 4) 和 (4,) 的数组。广播规则将按如下方式对齐形状 -

• 填充较小数组的形状: 较小数组的形状 (4,) 填充为 (1, 4)。

• 对齐维度: 形状 (3, 4) 和 (1, 4) 分别对齐为 (3, 4) 和 (3, 4)。

• 执行元素级运算: 该运算应用于对齐的形状。

向数组添加标量

向数组添加标量时，NumPy 使用广播将标量应用于数组的每个元素。广播会扩展标量以匹配数组的形状，从而实现逐元素操作。

示例

在下面的示例中，我们将标量"10"广播到数组的每个元素，导致每个元素增加 10 -

import numpy as np

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

# 添加标量
result = array + 10
print(result)

以下是获得的输出 -

[[11 12 13][14 15 16]]

添加不同元素的数组形状

当添加不同形状的数组时，NumPy 会应用广播规则来确保它们的形状兼容。广播的工作原理是将较小的数组扩展到较大的数组上，这样两个数组在进行元素相加时具有相同的形状。

此过程消除了在执行操作之前手动重塑数组的需要。

示例 1

在此示例中，我们广播第二个数组"array2"，使其与第一个数组"array1"的形状匹配 -

import numpy as np

# 创建两个不同形状的数组
array1 = np.array([[1, 2, 3], [4, 5, 6]])
array2 = np.array([10, 20, 30])

# 使用广播添加数组
result = array1 + array2
print(result)

这将产生结果如下 -

[[11 22 33]
[14 25 36]]

示例 2

以下是另一个在 NumPy 中广播两个不同形状数组的示例 -

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

print ('第二个数组:')
print (b)
print ('
')

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 兼容。

多维数组的广播

在不同形状的多维数组之间执行运算时，广播规则会对齐它们的维度，以便可以逐元素地进行运算。

此过程涉及拉伸较小的数组以匹配较大数组的形状，从而使运算能够顺利执行。

示例

在下面的示例中，我们创建两个三维数组，然后使用广播将它们相加 -

import numpy as np

# 创建两个三维数组
array1 = np.ones((2, 3, 4))
array2 = np.arange(4)

# 使用广播添加数组
result = array1 + array2
print(result)

以下是上述代码的输出 -

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

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

使用广播应用函数

广播不仅简化了不同形状数组之间的算术运算，还允许跨数组应用函数。这些函数包括:-

• 数学函数:执行数学运算的函数，例如加法、减法、乘法和除法。

• 统计函数:计算统计属性的函数，例如平均值、中位数、方差和标准差。

• 缩减函数:通过执行诸如求和、求积或求最大值之类的运算来缩减数组维度的函数。

• 逻辑运算:执行逻辑运算的函数，例如比较和逻辑运算(例如，与、或、非)。

当将函数应用于不同形状的数组时，广播可确保函数按元素应用。

示例

在此示例中，我们使用numpy.maximum() 函数用于对两个数组进行逐元素比较。该函数将"array1"中的每个元素与"array2"中的对应元素进行比较，结果是一个数组，其中每个元素都是输入数组中对应元素的最大值 -

import numpy as np

# 创建数组
array1 = np.array([[1, 2, 3], [4, 5, 6]])
array2 = np.array([[10], [20]])

# 使用广播函数
result = np.maximum(array1, array2)
print(result)

执行上述代码后，我们得到以下输出 -

[[10 10 10]
 [20 20 20]]

NumPy - 数组迭代

NumPy 中的数组迭代

NumPy 中的数组迭代是指以系统的方式逐个访问数组中每个元素的过程。这通常使用循环来完成。迭代用于对每个元素执行操作，例如计算、修改或检查。

NumPy 提供了几种迭代数组的方法 -

• 使用 for 循环
• 使用 'nditer()' 迭代器对象
• 平面迭代
• 迭代顺序
• 控制迭代顺序
• 广播迭代
• 使用向量化操作
• 外部循环
• 修改数组值

使用 for 循环

在 NumPy 中，您可以使用基本的 Python for 循环 来迭代数组。 for 循环是一种用于迭代序列(例如列表、元组、字典、集合或字符串)的控制流语句。它允许您对序列中的每个元素重复执行一段代码。

迭代一维数组

一维数组本质上是一个元素列表。对其进行迭代很简单，类似于对常规 Python 列表进行迭代。

示例

在下面的示例中，我们根据元素列表创建一个 NumPy 数组，并使用 for 循环对每个元素进行迭代 -

import numpy as np

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

# 迭代数组
for element in arr:
    print(element)

以下是得到的输出 -

1
2
3
4
5

迭代多维数组

NumPy 数组可以有任意数量的维度，通常称为轴。例如 -

• 一维数组是元素的列表。
• 二维数组就像一个有行和列的矩阵。
• 三维数组可以可视化为二维矩阵的集合。

示例:迭代二维数组

迭代二维数组时，每次迭代都会访问数组的一整行，如下例所示 -

import numpy as np

# 创建二维 NumPy 数组(3x3 矩阵)
arr_2d = np.array([[1, 2, 3],
                   [4, 5, 6],
                   [7, 8, 9]])

# 迭代数组
for row in arr_2d:
    print(row)

这将产生以下结果 -

[1 2 3]
[4 5 6]
[7 8 9]

示例:迭代三维数组

迭代三维数组时，每次迭代都会访问一个完整的二维子数组(矩阵)，如下例所示 -

import numpy as np

# 创建一个三维 NumPy 数组 (2x2x3)
arr_3d = np.array([[[1, 2, 3],
                    [4, 5, 6]],
                   [[7, 8, 9],
                    [10, 11, 12]]])

# 迭代数组
for matrix in arr_3d:
    print(matrix)

以下是上述代码的输出 -

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

迭代多维数组中的元素

在 NumPy 中，迭代多维数组中的元素是一种访问每个单独元素的方法，无论数组的维度是多少。此过程需要嵌套循环来遍历数组结构的每个维度。

示例

在此示例中，我们使用嵌套循环遍历每一行 (i) 和列 (j)，以使用索引访问和打印每个元素 -

import numpy as np

# 创建一个二维 NumPy 数组
arr_2d = np.array([[1, 2, 3],
                   [4, 5, 6],
                   [7, 8, 9]])

# 迭代二维数组中的元素
# 迭代行
for i in range(arr_2d.shape[0]):
    # 迭代列
    for j in range(arr_2d.shape[1]):
        print(arr_2d[i, j])

输出结果如下 -

1
2
3
4
5
6
7
8
9

使用索引进行迭代

使用索引对 NumPy 数组进行迭代，用于根据数组元素在数组每个维度中的特定位置进行访问。

在 NumPy 中，数组的每个维度都从 0 开始索引。使用索引进行迭代需要使用嵌套循环遍历数组的每个维度，并使用其特定索引访问元素。

与简单的元素迭代相比，这种方法可以更精确地控制元素的访问和操作。

示例

在下面的示例中，我们使用嵌套循环对二维数组的每个元素进行迭代。我们访问并打印每个元素的值及其索引 -

import numpy as np

# 创建一个二维 NumPy 数组
arr_2d = np.array([[1, 2, 3],
                   [4, 5, 6],
                   [7, 8, 9]])

# 获取数组的维度
rows, cols = arr_2d.shape

# 使用索引遍历数组
for i in range(rows):
   for j in range(cols):
      print(f"元素位于 ({i}, {j}): {arr_2d[i, j]}")

执行上述代码后，我们得到以下输出 -

元素位于 (0, 0):1
元素位于 (0, 1):2
元素位于 (0, 2):3
元素位于 (1, 0):4
元素位于 (1, 1):5
元素位于 (1, 2):6
元素位于 (2, 0):7
元素位于 (2, 1):8
元素位于 (2, 2):9

使用 'nditer' 迭代器对象

NumPy 中的 nditer() 函数提供了一个高效的多维迭代器对象，可用于迭代数组的元素。它使用 Python 的标准迭代器接口来访问数组中的每个元素。

示例

在此示例中，nditer() 函数用于按扁平顺序迭代数组"arr"的所有元素，并按顺序打印每个元素 -

import numpy as np

# 数组示例
arr = np.array([[1, 2], [3, 4]])

# 使用 nditer 进行迭代
for x in np.nditer(arr):
    print(x)

结果如下:-

1234

平面迭代

平面迭代是指将多维数组的所有元素像一维数组一样进行迭代。当您需要处理或操作数组中的每个元素，而无需明确考虑其原始形状或尺寸时，这种方法非常有用。

示例

在此示例中，我们创建一个二维 NumPy 数组。然后，我们使用带有"buffered"标志的 np.nditer 函数，以扁平化序列的形式迭代该数组，并按顺序打印每个元素 -

import numpy as np

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

# 使用带有"buffered"标志的 nditer 进行平面迭代
print("迭代数组:")
for x in np.nditer(arr, flags=['buffered']):
    print(x, end=' ')

我们得到如下所示的输出 -

迭代数组:
1 2 3 4 5 6

迭代顺序

NumPy 中的迭代顺序是指在迭代过程中访问数组元素的顺序。默认情况下，NumPy 数组以行优先顺序进行迭代，也称为C 风格顺序。

这意味着对于多维数组，迭代从第一维(行)开始，沿最后一维(列)迭代所有元素。

示例

在此示例中，我们使用 numpy.nditer() 函数迭代数组，以默认的行优先顺序(C 风格)访问每个元素，并按顺序打印它们 -

import numpy as np

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

# 迭代数组
print("默认迭代顺序 (C 风格，行优先):")
for x in np.nditer(arr):
    print(x, end=' ')

以下是得到的输出 −

默认迭代顺序 (C 风格，行优先):
1 2 3 4 5 6

控制迭代顺序

在 NumPy 中控制迭代顺序允许您指定在迭代期间访问数组元素的方式。 NumPy 提供了基于内存布局和性能考虑来控制迭代顺序的选项 -

• Fortran 风格顺序 - 按列(列优先顺序)迭代元素。

for x in np.nditer(arr, order='F'):
...

外部循环 - 在迭代外部维度时保持内部维度不变。

for row in np.nditer(arr, flags=['external_loop']):
...

示例

在此示例中，我们使用numpy.nditer() 函数，以 Fortran 风格顺序(F 风格)访问每个元素 −

import numpy as np

# 数组
arr = np.array([[1, 2], [3, 4]])

# 按指定顺序迭代(F 风格)
for x in np.nditer(arr, order='F'):
    print(x)

这将产生以下结果 -

1
3
2
4

广播迭代

NumPy 中的广播迭代是指同时迭代多个数组，其中数组被广播以具有兼容的形状。

这使得元素级操作可以高效地应用于数组，而无需明确对齐它们的维度。

示例

在下面的示例中，我们通过迭代两个数组 arr1 和 arr2 来演示 NumPy 中的广播迭代。同时执行。

使用 nditer() 函数对"arr1"和"arr2"中的每一对对应元素进行求和，展示了无需明确对齐数组维度的逐元素运算 -

import numpy as np

# 数组
arr1 = np.array([1, 2, 3])
arr2 = np.array([10, 20, 30])

# 广播加法运算
print("广播迭代:")
for x, y in np.nditer([arr1, arr2]):
    print(x + y, end=' ')

以下是上述代码的输出 -

广播迭代:
11 22 33 

使用向量化运算

NumPy 中的向量化运算是指一次性对整个数组执行运算，而不是对单个元素进行迭代。

示例

在下面的示例中，我们通过对两个数组 arr1 和 arr2 执行逐元素加法来演示 NumPy 中的向量化运算。只需在数组之间使用 + 运算符即可实现 -

import numpy as np

# 数组示例
arr1 = np.array([1, 2, 3, 4])
arr2 = np.array([10, 20, 30, 40])

# 向量化加法运算
result = arr1 + arr2

print("向量化运算:")
print("加法结果:", result)

输出结果如下所示 -

向量化运算:加法结果:[11 22 33 44]

外部循环

在 NumPy 中，外部循环的概念loop 指的是在保持特定维度不变的情况下迭代数组。这允许你迭代具有嵌套结构的数组，而不会将内部维度折叠成单个序列。

numpy.nditer() 函数与 external_loop 标志一起使用时，允许在保留数组行结构的情况下迭代数组元素。这确保了每一行都被单独处理，并展示了如何在整个迭代过程中保持维度的完整性。

示例

在下面的示例中，我们通过迭代二维数组来演示 NumPy 中的外部循环迭代 -

import numpy as np

# 多维数组
arr = np.array([[1, 2, 3],
                [4, 5, 6]])

# 外部循环迭代
print("外部循环:")
for row in np.nditer(arr, flags=['external_loop']):
    print(row)

执行上述代码后，我们得到以下输出 -

外部循环:[1 2 3 4 5 6]

修改数组值

在 NumPy 中，修改数组值是指直接将新值赋给数组中的特定元素或切片。这有助于在无需重新创建整个数组的情况下就地更新数据。

nditer 对象还有另一个可选参数，称为 op_flags。其默认值为只读，但可以设置为读写或只写模式。这将允许使用此迭代器修改数组元素。

示例

在下面的示例中，我们使用 nditer() 函数修改 NumPy 中的数组值。通过将"op_flags"参数设置为"readwrite"，迭代器会将数组 arr 的每个元素乘以 2 -

import numpy as np

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

# 修改数组元素
with np.nditer(arr, flags=['buffered'], op_flags=['readwrite']) as it:
   for x in it:
      # 将每个元素乘以 2
      x[...] = x * 2  

print("修改后的数组示例:",arr)

生成的结果如下 -

修改后的数组示例:[ 2 4 6 8 10]

NumPy - 数组操作

NumPy 包中提供了多种用于操作 ndarray 对象元素的例程。它们可分为以下类型:-

改变形状

在 NumPy 中，改变形状是指在不改变数据的情况下改变数组的形状 -

转置操作

NumPy 转置操作可以交换二维数组中的行和列，或重新排列高维数组中的轴 -

更改维度

在 NumPy 中更改数组的维度涉及重塑或重构数组以满足特定需求，而无需更改数据 -

连接数组

NumPy 中的连接数组沿指定轴连接多个数组 -

拆分数组

NumPy 中的拆分数组功能会将数组沿指定轴拆分为更小的数组 -

添加/删除元素

在 NumPy 中添加或删除元素 - 将元素附加到数组或删除元素 -

重复和平铺数组

在 Numpy 中，重复和平铺数组是通过以各种模式复制现有数组元素来创建更大数组的技术 -

重新排列元素

在 NumPy 中，可以使用各种方法重新排列数组的元素，以达到所需的顺序或结构。以下是常见的操作 -

排序和搜索

NumPy 提供了强大的数组排序和搜索工具，可实现高效的数据操作和分析 -

集合运算

NumPy 中的集合运算涉及对数组执行数学集合运算，例如并集、交集、差集以及检查唯一元素。这些运算对于处理和分析数据集中的不同值特别有用 -

其他数组操作

以下Numpy 中的 a=other arryas 操作是 -

NumPy - 二元运算符

NumPy 中的二元运算符

NumPy 中的二元运算符是指接受两个操作数(通常是数组)并在数组的相应元素之间执行逐元素运算的运算。这些运算包括加法、减法、乘法、除法、逻辑运算等等。

例如，如果您有两个数组，则可以将它们相加、相减、相乘等等。这些操作都是逐元素执行的，这意味着操作应用于两个数组中每个对应的元素对。

以下是 NumPy 包中可用的按位运算函数。

NumPy - 字符串函数

NumPy 中的字符串函数旨在对字符串数组进行操作。它们是 NumPy char 模块的一部分，该模块提供了一组可应用于字符串数组每个元素的向量化字符串操作。

NumPy 字符串函数的主要特性

以下是 NumPy 字符串函数的主要特性 -

• 逐元素操作:NumPy 字符串函数的核心优势在于它们能够独立地对数组的每个元素执行操作。这使得高效地处理大型数据集成为可能。
• 向量化:通过使用 NumPy 库，操作可以被向量化，与传统的 Python 字符串处理方法相比，这提高了性能。矢量化利用优化的 C 库来执行计算，从而显著缩短执行时间。
• 与数组的兼容性:NumPy 字符串函数可以直接处理字符串数组，从而更轻松地处理大量文本数据，而无需将其转换为列表或其他格式。

字符串操作在数组上逐元素执行。它们对于低级数据操作和高效计算特别有用。

字符串函数列表

以下函数用于对 dtype 为 numpy.string_ 或 numpy.unicode_ 的数组执行矢量化字符串操作。它们基于 Python 内置库中的标准字符串函数。

NumPy - 数学函数

NumPy 数学函数

NumPy 提供了丰富的数学函数，这些函数对于对数组执行数值运算至关重要。这些函数包括基本算术、三角函数、指数、对数和统计运算等等。

在本教程中，我们将探索 NumPy 中最常用的数学函数，并通过示例帮助您理解它们的应用。

基本算术运算

在 NumPy 中，基本算术运算包括对数组进行加法、减法、乘法和除法。这些运算是逐元素的，这意味着它们会应用于数组中每个对应的元素。

例如，将两个数组相加会生成一个新数组，其中每个元素都是输入数组中对应元素的和。

NumPy 还支持标量运算，允许你直接将数字应用于数组的每个元素。

示例:加法、减法、乘法和除法

在下面的示例中，我们对两个 NumPy 数组执行加法、减法、乘法和除法等基本算术运算 -

import numpy as np

# 定义两个数组
a = np.array([10, 20, 30])
b = np.array([5, 10, 15])

# 执行基本算术运算
加法 = a + b
减法 = a - b
乘法 = a * b
除法 = a / b

print("加法:", 加法)
print("减法:", 减法)
print("乘法:", 乘法)
print("除法:", 除法)

我们得到如下所示的输出 -

加法:[15 30 45]
减法:[ 5 10 15]
乘法:[ 50 200 450]
除法:[2. 2. 2.]

三角函数

NumPy 还提供了几个对数组执行三角运算的函数。这些函数包括正弦、余弦和正切等基本三角函数，它们对数组进行逐元素运算。

示例:正弦、余弦和正切

让我们探索如何在 NumPy 中计算数组的正弦、余弦和正切 -

import numpy as np

# 定义一个以弧度为单位的角度数组
angles = np.array([0, np.pi/4, np.pi/2, np.pi])

# 计算正弦、余弦和正切
sine_values = np.sin(angles)
cosine_values = np.cos(angles)
tangent_values = np.tan(角度)

print("正弦值:", sine_values)
print("余弦值:", cosine_values)
print("正切值:", tangent_values)

以下是得到的输出 -

正弦值:[0.00000000e+00 7.07106781e-01 1.00000000e+00 1.22464680e-16]
余弦值:[ 1.00000000e+00  7.07106781e-01  6.12323400e-17 -1.00000000e+00]
正切值:[ 0.00000000e+00  1.00000000e+00  1.63312394e+16 -1.22464680e-16]

请注意，pi/2 的正切为无穷大，因为 pi/2 的余弦为零，而除以零是未定义的。

指数和对数函数

NumPy 还提供了用于计算指数值和对数的函数，这些函数用于各种科学和工程计算。这些函数可用于计算数组的幂、根和对数。

指数运算

numpy.exp() 函数计算输入数组中所有元素的指数。以下是一个示例 -

import numpy as np

# 创建数组
arr = np.array([1, 2, 3])

# 计算数组的指数
exp_array = np.exp(arr)
print("指数值:", exp_array)

这将产生以下结果 -

指数值:[ 2.71828183  7.3890561  20.08553692]

对数

NumPy 提供了 numpy.log() 函数来计算自然对数(底数为 e)，并且numpy.log10() 函数用于计算以 10 为底的对数。以下是示例 -

import numpy as np

# 创建数组
arr = np.array([1, 2, 10])

# 计算自然对数和以 10 为底的对数
log_array = np.log(arr)
log10_array = np.log10(arr)

print("自然对数值:", log_array)
print("以 10 为底的对数值:", log10_array)

以下是上述代码的输出 -

自然对数值:[0.0.69314718 2.30258509]
以 10 为底的对数值:[0.       0.30103 1.     ]

NumPy 中的统计函数

NumPy 还提供了各种各样的统计函数。这些函数包括计算平均值、中位数、方差、标准差等等。这些函数在分析数据和对数组进行统计分析时非常有用。

平均值和中位数

numpy.mean() 函数计算算术平均值，numpy.median() 函数计算数组的中位数，如下例所示 -

import numpy as np

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

# 计算数组的平均值和中位数
mean_value = np.mean(arr)
median_value = np.median(arr)

print("平均值:", mean_value)
print("中位数:", median_value)

得到的输出如下所示−

平均值:3.0
中位数:3.0

标准差和方差

numpy.std() 函数计算标准差，numpy.var() 函数计算数组的方差 −

import numpy as np

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

# 计算标准差和方差
std_dev = np.std(arr)
variance = np.var(arr)

print("标准差:", std_dev)
print("方差:", variance)

执行上述代码后，我们得到以下输出 -

标准差:1.4142135623730951
方差:2.0

线性代数函数

NumPy 还提供了一组线性代数函数，例如矩阵乘法、点积和矩阵行列式，这些函数对于向量和矩阵的运算非常重要。

点积

numpy.dot() 函数用于计算两个数组的点积。它常用于机器学习、物理学和工程学 −

import numpy as np

# 创建两个数组
arr1 = np.array([1, 2])
arr2 = np.array([3, 4])

# 计算点积
dot_product = np.dot(arr1, arr2)
print("点积:", dot_product)

结果如下 −

点积: 11

矩阵乘法

NumPy 中的矩阵乘法使用 @ 运算符或 numpy.matmul() 函数执行。它计算两个数组的点积，其中第一个矩阵的列数必须等于第二个矩阵的行数。

结果是一个新矩阵，其中每个元素都是相应行和列元素乘积的总和。矩阵乘法在线性代数和机器学习任务中非常常用。

示例

在此示例中，矩阵 A 与矩阵 B 相乘得到矩阵 C，其中每个元素均由 A 的行和 B 的列的点积计算得出 -

import numpy as np

# 定义两个矩阵
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])

# 执行矩阵乘法
C = np.matmul(A, B)

# 打印结果
print(C)

我们得到如下所示的输出 -

[[19 22]
 [43 50]]

NumPy - 算术运算

NumPy 算术运算

NumPy 使对数组执行算术运算变得简单易行。使用 NumPy，您可以逐个元素对整个数组进行加、减、乘、除运算，这意味着一个数组中的每个元素都会被另一个数组中的对应元素运算。

在对不同形状的数组执行算术运算时，NumPy 使用一种称为"广播"的功能。它会自动调整数组的形状以便执行运算，并根据需要将较小的数组扩展到较大的数组。

NumPy 基本算术运算

NumPy 提供了几种对数组逐个元素执行的算术运算。这些运算包括加法、减法、乘法、除法和幂运算。

NumPy 数组加法

NumPy 中的加法是逐元素执行的。当两个相同形状的数组相加时，相应的元素会被相加。当数组具有不同形状时，广播规则适用 -

import numpy as np

# 创建两个数组
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

# 数组相加
result = a + b
print(result)

以下是得到的输出 -

[5 7 9]

NumPy 数组减法

NumPy 中的减法也是逐元素的。将两个形状相同的数组相减，返回一个数组，其中每个元素等于输入数组中对应元素的差值 -

import numpy as np

# 创建两个数组
a = np.array([10, 20, 30])
b = np.array([1, 2, 3])

# 数组相减
result = a - b
print(result)

这将产生以下结果 -

[ 9 18 27]

NumPy 数组乘法

在 NumPy 中使用 * 运算符执行元素级乘法。数组相乘时，第一个数组的每个元素都会与第二个数组中对应的元素相乘 -

import numpy as np

# 创建两个数组
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

# 数组相乘
result = a * b
print(result)

以下是上述代码的输出 -

[ 4 10 18]

NumPy 数组除法

在 NumPy 中，除法是使用 / 运算符逐个元素执行的。结果是一个数组，其中每个元素都是输入数组中对应元素的商 - ...

[10. 10.  6.]

NumPy 数组幂运算

幂运算是使用 NumPy 中的 ** 运算符逐个元素执行的。将基数组的每个元素提升为指数数组中相应元素的幂 -

import numpy as np

# 创建两个数组
a = np.array([2, 3, 4])
b = np.array([1, 2, 3])

# 执行幂运算
result = a ** b
print(result)

执行上述代码后，我们得到以下输出 -

[ 2 9 64]

我们还可以使用 numpy.power() 函数将数组元素提升到指定的幂。此函数将第一个输入数组中的元素作为基数，并返回其第二个输入数组中对应元素的幂 -

import numpy as np
a = np.array([10,100,1000])

print ('我们的数组是:')
print (a)
print ('
')

print ('应用幂函数:')
print (np.power(a,2))
print ('
')

print ('第二个数组:')
b = np.array([1,2,3])
print (b)
print ('
')

print ('再次应用幂函数:')
print (np.power(a,b))

它将产生以下输出 -

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

应用幂函数:
[    100   10000 1000000]

第二个数组:
[1 2 3]

再次应用幂函数:
[       10      10000 1000000000]

NumPy 高级算术运算

NumPy 中的高级算术运算包括模、地板除法和幂等运算。这些运算可以处理更复杂的数学任务，并且以元素为单位执行，类似于基本算术运算，但具有模运算和指数运算的附加功能。

NumPy 模运算

模运算在 NumPy 中使用 % 运算符执行。当应用于数组时，它会按元素进行运算，即用第一个数组中的每个元素除以第二个数组中对应的元素，然后计算余数 -

import numpy as np

# 创建两个数组
a = np.array([10, 20, 30])
b = np.array([3, 7, 8])

# 应用模运算
result = a % b
print(result)

结果如下 -

[1 6 6]

我们还可以使用 numpy.mod() 函数来计算两个数组元素之间或一个数组和一个数组元素之间除法(模运算)的元素余数。标量。

此函数返回一个数组除以另一个数组或标量后的余数，并逐个元素应用模运算。

import numpy as np
a = np.array([10,20,30])
b = np.array([3,5,7])

print ('第一个数组:')
print (a)
print ('
')

print ('第二个数组:')
print (b)
print ('
')

print ('调用 mod() 函数:')
print (np.mod(a,b))
print ('
')

print ('调用 remainder() 函数:')
print (np.remainder(a,b))

以下是上述代码的输出 −

第一个数组:
[10 20 30]

第二个数组:
[3 5 7]

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

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

NumPy 向下取整除

NumPy 中的向下取整除是使用 // 运算符逐个元素执行的。返回小于或等于除法结果的最大整数 -

import numpy as np

# 创建两个数组
a = np.array([10, 20, 30])
b = np.array([3, 7, 8])

# 应用向下取整除法
result = a // b
print(result)

我们得到如下所示的输出 -

[3 2 3]

使用广播进行 NumPy 算术运算

广播允许 NumPy 通过虚拟扩展较小数组以匹配较大数组的形状，对不同形状的数组执行算术运算。

NumPy 中的标量和数组运算NumPy

当标量与数组一起使用时，广播会扩展标量以匹配数组的形状，从而允许逐元素运算 -

import numpy as np

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

# 标量值
scalar = 10

# 将标量添加到数组
result = a + scalar
print(result)

以下是获得的输出 -

[[11 12 13]
[14 15 16]]

NumPy 中不同形状的数组

当两个不同形状的数组在 NumPy 中使用，广播会根据广播规则对齐数组的形状 -

import numpy as np

# 创建不同形状的数组
a = np.array([[1, 2, 3], [4, 5, 6]])
b = np.array([10, 20, 30])

# 添加数组
result = a + b
print(result)

这将产生以下结果 -

[[11 22 33]
[14 25 36]]

NumPy 聚合函数

NumPy 中的聚合函数通常会对数组执行求和、求平均值、求最小值和求最大值等操作。使用广播处理不同形状的数组。

NumPy 求和运算

NumPy 求和运算计算指定轴上数组元素的总和;如果未指定轴，则计算整个数组元素的总和。 −

import numpy as np

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

# 对元素求和
result = np.sum(a)
print(result)

# 沿轴 0(列)求和
result_axis0 = np.sum(a, axis=0)
print(result_axis0)

# 沿轴 1(行)求和
result_axis1 = np.sum(a, axis=1)
print(result_axis1)

以下是上述代码的输出 −

21
[5 7 9]
[ 6 15]

NumPy 均值运算

NumPy 均值运算计算数组元素在指定轴或整个数组上的平均值(算术平均值)-

import numpy as np

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

# 元素平均值
result = np.mean(a)
print(result)

# 沿轴 0(列)的平均值
result_axis0 = np.mean(a, axis=0)
print(result_axis0)

# 沿轴 1(行)的平均值
result_axis1 = np.mean(a, axis=1)
print(result_axis1)

得到的输出如下所示 -

3.5
[2.5 3.5 4.5]
[2. 5.]

NumPy 数组与复数运算

以下函数用于对包含复数的数组执行运算。

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

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

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

• numpy.angle(): 返回复数参数的角度。该函数包含 degree 参数。如果为真，则返回以度为单位的角度，否则返回以弧度为单位的角度。

示例

在下面的示例中，我们使用 NumPy 函数:real()、imag()、conj() 和 angle() 对复数数组执行运算 -

import numpy as np
a = np.array([-5.6j, 0.2j, 11. , 1+1j])

print ('我们的数组是:')
print (a)
print ('
')

print ('调用 real() 函数:')
print (np.real(a))
print ('
')

print ('调用 imag() 函数:')
print (np.imag(a))
print ('
')

print ('调用 conj() 函数:')
print (np.conj(a))
print ('
')

print ('调用 angle() 函数:')
print (np.angle(a))
print ('
')

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 数组支持加法、减法和索引等运算，以实现高效的数据操作 -

NumPy - 统计函数

NumPy 中的统计函数

NumPy 提供了丰富的统计函数，可用于对数组执行各种统计计算。这些函数可以计算平均值、中位数、方差、标准差、最小值、最大值等指标。

NumPy 的 amin() 和 amax() 函数

numpy.amin() 函数返回给定数组中沿指定轴的元素的最小值。而 numpy.amax() 函数则返回给定数组中沿指定轴的元素的最大值。

示例

以下示例演示了如何在 NumPy 数组上使用 amin() 和 amax() 函数 -

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

print('我们的数组是:')
print(a)
print('
')

print('调用 amin() 函数:')
print(np.amin(a,1))
print('
')

print('再次调用 amin() 函数:')
print(np.amin(a,0))
print('
')

print('调用 amax() 函数:')
print(np.amax(a))
print('
')

print('再次调用 amax() 函数:')
print(np.amax(a, axis=0))

它将产生以下输出 -

我们的数组是:
[[3 7 5]
[8 4 3]
[2 4 9]]
调用 amin() 函数:[3 3 2]
再次调用 amin() 函数:[2 4 3]
调用 amax() 函数:9
再次调用 amax() 函数:[8 7 9]

numpy.ptp() 函数

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

示例

在下面的示例中，我们使用 ptp() 函数计算 NumPy 数组中值的范围 -

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

print('我们的数组是:')
print(a)
print('
')

print('调用 ptp() 函数:')
print(np.ptp(a))
print('
')

print('沿轴 1 调用 ptp() 函数:')
print(np.ptp(a, axis=1))
print('
')

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]

numpy.percentile() 函数

百分位数(或百分位数)是统计学中使用的一种度量，表示一组观测值中给定百分比的观测值低于该值。

numpy.percentile() 函数计算数据沿指定轴的第 q 个百分位数。它采用以下参数 -

numpy.percentile(a, q, axis)

其中:

• a: 输入数组。
• q: 需要计算的百分位数，必须介于 0-100 之间。
• axis: 计算百分位数的轴。

示例

在此示例中，我们使用 percentile() 函数计算 NumPy 数组的第 50 个百分位数(中位数)-

import numpy as np
a = np.array([[30,40,70],[80,20,10],[50,90,60]])

print('我们的数组是:')
print(a)
print('
')

print('调用 percentile() 函数:')
print(np.percentile(a,50))
print('
')

print('沿轴 1 调用 percentile() 函数:')
print(np.percentile(a,50, axis=1))
print('
')

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

数组元素的和与积

numpy.sum() 函数计算数组中所有元素的和，而 numpy.prod() 函数计算数组中所有元素的乘积。

示例

在下面的示例中，我们使用 sum() 和 prod() 函数计算 NumPy 数组中元素的和与乘积 -

import numpy as np 

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

# 计算数组的和
sum_value = np.sum(data)

# 计算数组的乘积
prod_value = np.prod(data)

print(f"数组的和:{sum_value}")
print(f"数组的乘积:{prod_value}")

它将产生以下输出 -

数组的和:10
数组的乘积:24

numpy.median() 函数

numpy.median() 函数计算沿指定轴的中位数。如果未指定轴，则计算展平数组的中位数。中位数定义为分隔数据样本上半部分和下半部分的值。

示例

在下面的示例中，我们使用 median() 函数查找 NumPy 数组中元素的中位数 -

import numpy as np
a = np.array([[30,65,70],[80,95,10],[50,90,60]])

print('我们的数组是:')
print(a)
print('
')

print('调用 median() 函数:')
print(np.median(a))
print('
')

print('沿轴 0 调用 median() 函数:')
print(np.median(a, axis=0))
print('
')

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

numpy.mean() 函数

numpy.mean() 函数返回数组中元素的算术平均值。如果没有指定轴，则计算扁平数组的平均值。算术平均值是沿某个轴的元素之和除以元素数量。

示例

在下面的示例中，我们使用 mean() 函数计算 NumPy 数组中元素的平均值 -

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

print('我们的数组是:')
print(a)
print('
')

print('调用 mean() 函数:')
print(np.mean(a))
print('
')

print('沿 0 轴调用 mean() 函数:')
print(np.mean(a, axis=0))
print('
')

print('沿轴 1 应用 mean() 函数:')
print(np.mean(a, axis=1))

得到的输出如下所示 -

我们的数组是:
[[1 2 3]
[3 4 5]
[4 5 6]]
应用 mean() 函数:3.666666666666665
沿轴 0 应用 mean() 函数:[2.66666667 3.66666667 4.66666667]
沿轴 1 应用 mean() 函数:[2. 4. 5.]

numpy.average() 函数

numpy.average() 函数根据数组中元素各自的权重计算它们的加权平均值。加权平均值是将每个元素乘以一个因子得到的平均值。

示例

在下面的示例中，我们使用 average() 函数(带权重和不带权重)计算 NumPy 数组中元素的平均值 -

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

print('我们的数组是:')
print(a)
print('
')

print('不带权重调用 average() 函数:')
print(np.average(a))
print('
')

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

print('带权重调用 average() 函数:')
print(np.average(a,weights=wts))
print('
')

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)

numpy.std() 函数

numpy.std() 函数返回数组中元素的标准差。 标准差是与均值的平方差的平均值的平方根，即 std = sqrt(mean(abs(x - x.mean())**2))。

示例

在下面的示例中，我们使用 std() 函数计算 NumPy 数组的标准差 -

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

执行上述代码后，我们得到以下输出 -

1.118033988749895

numpy.var() 函数

numpy.var() 函数返回数组中元素的方差。方差是方差的平均值，即 var = mean(abs(x - x.mean())**2)。

示例

在以下示例中，我们使用 var() 函数计算 NumPy 数组的方差 -

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

我们得到如下所示的输出 -

1.25

相关系数

numpy.corrcoef() 函数返回输入数组的皮尔逊相关系数。它对于确定两个变量之间的关系非常有用。

示例

在下面的示例中，我们使用 corrcoef() 函数计算两个数组的相关系数矩阵 -

import numpy as np

# 定义两个数组
data1 = np.array([1, 2, 3, 4, 5])
data2 = np.array([5, 4, 3, 2, 1])

# 计算相关系数
corr_coef = np.corrcoef(data1, data2)

print("相关系数矩阵:")
print(corr_coef)

结果如下所示 -

相关系数矩阵:
[[ 1. -1.]
[-1. 1.]]

统计函数

以下是 Numpy 中不同的统计函数 -

序号	函数及说明
1	amin() 返回数组的最小值或沿某个轴的最小值
2	amax() 返回数组的最大值或沿某个轴的最大值
3	nanmin() 返回数组的最小值或沿某个轴的最小值，忽略任何 NaN
4	nanmax() 返回数组的最大值或沿某个轴的最大值，忽略任何 NaN
5	ptp() 沿某个轴的值范围(最大值 - 最小值)
6	percentile() 计算数据沿指定轴的第 q 个百分位数
7	nanpercentile() 计算数据沿指定轴的第 q 个百分位数，同时忽略 nan 值
8	quantile() 计算数据沿指定轴的第 q 个分位数
9	nanquantile() 计算数据沿指定轴的第 q 个分位数指定的轴，同时忽略 nan 值。返回数组元素的第 q 个分位数
10	median() 沿指定轴计算中位数
11	average() 沿指定轴计算加权平均值
12	mean() 沿指定轴
13	std() 计算指定轴的标准差
14	var() 计算指定轴的方差
15	nanmean() 计算指定轴的算术平均值，忽略NaN
16	nanstd() 计算指定轴的标准差，同时忽略 NaN
17	nanvar() 计算指定轴的方差，同时忽略 NaN

NumPy - 排序、搜索和计数函数

NumPy 提供了多种用于对数组中的元素进行排序、搜索和计数的函数。这些函数对于数据操作和分析非常有用。

NumPy 提供了多种排序算法，每种算法都有其特点。以下是三种常见排序算法的比较 -

numpy.sort() 函数

sort() 函数返回输入数组的排序副本。它可以沿任何指定的轴对数组进行排序，并支持不同的排序算法。语法如下:

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

其中，

示例

在下面的示例中，我们将按默认方式和特定轴对二维 NumPy 数组进行排序。我们还演示了如何按特定字段(例如"name")对结构化数组进行排序 -

import numpy as np

# 创建二维数组
a = np.array([[3, 7], [9, 1]])

print("我们的数组是:",a)

# 默认排序
print("调用 sort() 函数:",np.sort(a))

# 沿轴 0 排序
print("沿轴 0 排序:",np.sort(a, axis=0))

# sort 函数中的 order 参数
dt = np.dtype([('name', 'S10'), ('age', int)])
a = np.array([("raju", 21), ("anil", 25), ("ravi", 17), ("amar", 27)], dtype=dt)

print("我们的数组是:",a)

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

按名称排序:
[('amar', 27) ('anil', 25) ('raju', 21) ('ravi', 17)]

numpy.argsort() 函数

numpy.argsort() 函数对输入数组进行间接排序，沿给定轴并使用指定的排序类型返回数据索引数组。此索引数组用于构造排序后的数组。

示例

在此示例中，我们使用 argsort() 函数检索索引，即已排序元素在原始数组中的位置。使用这些索引，你可以重建已排序的数组 -

import numpy as np

# 创建数组
x = np.array([3, 1, 2])

print("我们的数组是:",x)

# 获取对数组进行排序的索引
y = np.argsort(x)

print("对 x 应用 argsort():",y)

# 使用索引重建已排序的数组
print("按排序顺序重建原始数组:",x[y])

# 使用循环重建原始数组
print("使用循环重建原始数组:")
for i in y:
print(x[i], end=' ')

它将产生以下输出 -

我们的数组是:
[3 1 2]

对 x 应用 argsort():
[1 2 0]

按排序顺序重建原始数组:
[1 2 3]

使用循环重建原始数组:
1 2 3

numpy.lexsort() 函数

NumPy lexsort() 函数使用一系列键执行间接排序。这些键可以看作电子表格中的一列。该函数返回一个索引数组，使用该数组可以获取排序后的数据。注意，最后一个键恰好是 sort 的主键。

示例

在此示例中，我们使用 np.lexsort() 函数基于多个键对数据集进行排序，其中最后一个键"nm"是主要排序条件。然后，使用排序后的索引，通过组合名称和相应字段来显示排序后的数据 -

import numpy as np

# 定义键
nm = ('raju', 'anil', 'ravi', 'amar')
dv = ('f.y.', 's.y.', 's.y.', 'f.y.')

# 获取排序后的索引
ind = np.lexsort((dv, nm))

print("调用 lexsort() 函数:",ind)

# 使用索引获取排序后的数据
print("使用此索引获取排序后的数据:",[nm[i] + ", " + dv[i] for i in ind])

将产生以下输出−

应用 lexsort() 函数:
[3 1 0 2]

使用此索引获取已排序数据:
['amar, f.y.', 'anil, s.y.', 'raju, f.y.', 'ravi, s.y.']

NumPy 提供了查找最大值、最小值和非零元素以及满足条件的元素的索引的函数。

numpy.argmax() 和 numpy.argmin() 函数

NumPy argmax() 和 argmin() 函数分别返回沿给定轴的最大和最小元素的索引。

示例

在此示例中，我们使用 np.argmax() 和 np.argmin() 函数来查找二维数组中最大值和最小值的索引，包括扁平数组和特定轴上的索引 -

import numpy as np 

# 创建二维数组
a = np.array([[30, 40, 70], [80, 20, 10], [50, 90, 60]])

print("我们的数组是:",a)

# 调用 argmax() 函数
print("调用 argmax() 函数:",np.argmax(a))

# 展平数组中最大值的索引
print("展平数组中最大值的索引:",a.flatten())

# 包含沿轴 0 最大值的索引的数组
print("包含沿轴 0 最大值的索引的数组:")
maxindex = np.argmax(a, axis=0)
print(maxindex)

# 包含沿轴 1 最大值的索引的数组
print("包含沿轴 1 最大值的索引的数组:")
maxindex = np.argmax(a, axis=1)
print(maxindex)

# 调用 argmin() 函数
print("调用 argmin() 函数:")
minindex = np.argmin(a)
print(minindex)

# 展平数组
print("展平数组:",a.flatten()[minindex])

# 沿轴 0 展平数组
print("沿轴 0 展平数组:")
minindex = np.argmin(a, axis=0)
print(minindex)

# 沿轴 1 展平数组
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]

numpy.nonzero() 函数

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

示例

在下面的示例中，我们使用 nonzero() 函数检索数组"a"中非零元素的索引 -

import numpy as np
a = np.array([[30,40,0],[0,20,10],[50,0,60]])

print ('我们的数组是:',a)
print ('应用 nonzero() 函数:',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]))

numpy.where() 函数

where() 函数返回输入数组中满足给定条件的元素的索引，如下例所示 -

import numpy as np
x = np.arange(9.).reshape(3, 3)

print ('我们的数组是:',x)

print ('元素的索引 > 3')
y = np.where(x > 3)
print (y)

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

numpy.extract() 函数

extract() 函数返回满足以下示例所示任何条件的元素 -

import numpy as np
x = np.arange(9.).reshape(3, 3)

print ('我们的数组是:',x)

# 定义一个条件
condition = np.mod(x,2) == 0

print ('条件的逐元素值',condition)

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 - 字节交换

在 NumPy 中交换数组的轴

字节交换是在不同字节顺序(也称为字节序)之间转换数据的过程。在计算领域，不同的系统可能使用不同的字节序来表示多字节数据类型(例如，整数、浮点数)。字节交换可确保在不同字节序的系统之间传输数据时，数据能够被正确解释。

NumPy 提供了 byteswap() 函数来交换数组的字节。当需要将数据转换为正确的字节序以兼容其他系统或格式时，此功能尤其有用。

理解字节序

字节序(字节序)是指在较大的数据类型中，字节的排列顺序。字节顺序主要有两种: -

• Little-Endian - 最低有效字节存储在最小地址。例如，对于数字 0x1234，0x34 将首先存储。
• Big-Endian - 最高有效字节存储在最小地址。对于相同的数字 0x1234，0x12 将首先存储。

numpy.ndarray.byteswap() 函数

numpy.ndarray.byteswap() 函数用于交换 NumPy 数组中元素的字节顺序。此函数在两种表示形式之间切换:大端字节序 (bigendian) 和小端字节序 (little-endian)。

byteswap() 函数用于特定数据类型的数组，不会影响数组的形状或大小。语法如下:

numpy.ndarray.byteswap(inplace=False)

其中，如果 inplace 为"True"，则数组将进行原地修改。如果为"False"(默认值)，则返回一个已交换字节的新数组。

示例:在简单数组中交换字节

在以下示例中，我们使用 NumPy 中的 byteswap() 函数交换数组中的字节 -

import numpy as np
a = np.array([1, 256, 8755], dtype = np.int16)

print ('我们的数组是:', a)

print ('内存中数据的十六进制表示:', map(hex,a))
# 我们可以看到被交换的字节
print ('调用 byteswap() 函数:', a.byteswap())
print ('十六进制表示:', map(hex,a))

以下是得到的输出 -

我们的数组是:[   1  256 8755]
内存中数据的十六进制表示:<map object at 0x7fdfa46a3370>
调用 byteswap() 函数:[  256     1 13090]
十六进制表示:<map object at 0x7fdff5867190>

示例:原地字节交换

我们可以通过将 byteswap() 函数中的 "inplace" 参数设置为 "True" 来原地修改数组，直接在原始数组内交换字节 -

import numpy as np

# 创建一个包含 32 位整数的 NumPy 数组
arr = np.array([1, 256, 65535], dtype=np.int32)

print("原始数组:")
print(arr)

# 执行原地字节交换
arr.byteswap()

print("
原地字节交换后的数组:")
print(arr)

生成的结果如下 -

原始数组:
[    1   256 65535]

原位字节交换后的数组:
[    1   256 65535]

何时使用字节交换

我们可以在以下场景中使用字节交换 -

• 互操作性 - 当数据在不同字节顺序的系统之间交换时，字节交换可确保正确解释。
• 数据读写 - 处理使用不同字节顺序的原始二进制文件或网络协议时，字节交换对于正确读取或写入数据是必要的。
• 遗留系统 - 使用特定字节顺序的遗留系统或文件格式可能需要进行字节交换才能正确处理数据。

NumPy - 副本与视图

在 NumPy 中，对数组执行操作时，结果可能是原始数据的副本，也可能只是原始数据的视图。了解两者之间的区别对于高效的内存管理和避免代码中出现意外的副作用至关重要。

在 NumPy 中创建副本

我们可以使用 copy() 函数在 NumPy 中显式创建数组的副本。此函数会生成一个新数组，并将原始数组中的数据复制到这个新数组中。

在 NumPy 中创建数组副本时，数据会被完全复制。这意味着对副本所做的更改不会影响原始数组，反之亦然。当您需要处理数组的修改版本而不更改原始数据时，副本非常有用。

示例

在以下示例中，修改 copied_array 不会影响 original_array，从而证明了两个数组的独立性 -

import numpy as np

# 原始数组
original_array = np.array([1, 2, 3])

# 创建副本
copied_array = original_array.copy()

# 修改副本
copied_array[0] = 10

print("原始数组:", original_array)
print("复制的数组:", duplicated_array)

以下是获得的输出−

原始数组:[1 2 3]
复制后的数组:[10 2 3]

浅拷贝 vs. 深拷贝

在 NumPy 数组的语境中，浅拷贝和深拷贝之间的区别对于理解数据在复制时的处理方式至关重要。

浅拷贝

数组的浅拷贝会创建一个新的数组对象，但如果原始数组中的元素本身是数组或其他复杂对象，则不会创建这些元素的副本。

相反，新数组仍然引用与原始数组相同的元素。这意味着对元素内容的更改将同时影响原始数组和复制的数组。

• 数组级复制 − 对于 NumPy 数组，浅拷贝意味着虽然复制了顶层数组对象，但不会复制底层数据缓冲区。新数组只是相同数据的新视图。
• 用法 - 当您需要一个新的数组对象，但又想避免复制大量数据的开销时，浅拷贝非常有用。

示例

在此示例中，修改 shallow_copy 也会修改 original_array，因为它们共享相同的底层数据 -

import numpy as np

# 原始数组
original_array = np.array([[1, 2, 3], [4, 5, 6]])

# 浅拷贝
shallow_copy = original_array.view()

# 修改浅拷贝中的元素
shallow_copy[0, 0] = 100

print("原始数组:")
print(original_array)

print("
浅拷贝:")
print(shallow_copy)

这将产生以下结果 -

原始数组:
[[100 2 3]
[ 4 5 6]]

浅拷贝:
[[100 2 3]
[ 4 5 6]]

深拷贝

另一方面，深拷贝会创建一个新的数组对象，并复制其包含的所有数据。这意味着对新数组的任何更改都不会影响原始数组，反之亦然。新数组中的数据与原始数组中的数据完全独立。

• 完全复制 − 在 NumPy 中，深层复制涉及复制数组的整个数据缓冲区，以确保新数组与原始数组完全独立。
• 用法 − 当你需要独立于原始数组处理数据时，深层复制非常重要，尤其是在修改数据时不会影响原始数组。

示例

在本例中，修改 deep_copy 不会影响 original_array，从而证明了两个数组的独立性 −

import numpy as np

# 原始数组
original_array = np.array([[1, 2, 3], [4, 5, 6]])

# 深层复制
deep_copy = original_array.copy()

# 修改深层复制中的元素
deep_copy[0, 0] = 100

print("原始数组:")
print(original_array)

print("
深层复制:")
print(deep_copy)

以下是上述代码的输出 -

原始数组:
[[1 2 3]
[4 5 6]]

深层复制:
[[100 2 3]
[ 4 5 6]]

复制子数组

为了避免在处理子数组时修改原始数组，您应该创建子数组。当您需要独立于原始数据操作或分析子数组时，这非常有用。

子数组只是现有 NumPy 数组的一部分。您可以使用切片技术提取子数组。

例如，如果您有一个二维数组，您可以通过沿其行和列进行切片来提取一个较小的二维子数组。但是，默认情况下，切片会创建原始数组的视图，而不是单独的副本。这意味着，除非您明确创建副本，否则对子数组的更改也会影响原始数组。

示例

在下面的示例中，由于使用了 copy() 函数，sub_array 是一个完全独立的数组 -

import numpy as np

# 原始二维数组
original_array = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# 创建子数组的副本
sub_array = original_array[0:2].copy()
sub_array[0] = 20

print("复制子数组后的原始数组:", original_array)
print("子数组:", sub_array)

得到的输出如下所示 -

复制子数组后的原始数组:
[[1 2 3]
[4 5 6]
[7 8 9]]
子数组:
[[20 20 20]
[ 4 5 6]]

在 NumPy 中创建视图

视图是在对数组进行切片或执行某些操作(例如重塑)时创建的。数据不会被复制;相反，新数组只是查看原始数据的另一种方式。

换句话说，视图是一个新的数组对象，它查看与原始数组相同的数据。这意味着，如果您修改视图，更改将反映在原始数组中，反之亦然。

示例

在此示例中，修改 view_array 会直接影响 original_array，表明它们共享相同的数据 -

import numpy as np

# 原始数组
original_array = np.array([1, 2, 3])

view_array = original_array[0:2]

# 修改视图
view_array[0] = 30

print("视图修改后的原始数组:", original_array)
print("视图数组:", view_array)

执行上述代码后，我们得到以下输出 -

视图修改后的原始数组:[30 2 3]
视图数组:[30 2]

何时返回视图?

并非所有切片或操作都会生成视图。如果数组的内存布局发生变化，NumPy 可能会返回副本而不是视图。

切片生成的视图

NumPy 中返回视图的最常见场景是对数组进行切片。切片是一种通过指定索引范围来提取数组一部分的方法。NumPy 不会创建一个包含自身数据的新数组，而是返回一个视图，这意味着切片后的数组与原始数组共享相同的数据。

示例

在此示例中，view_array 是 original_array 的视图。数据不会被复制，并且两个数组共享相同的底层内存。这意味着对"view_array"所做的任何更改都会影响"original_array" -

import numpy as np

# 原始数组
original_array = np.array([1, 2, 3, 4, 5])

# 通过切片原始数组创建视图
view_array = original_array[1:4]

print("原始数组:")
print(original_array)

print("
切片后的视图数组:")
print(view_array)

结果如下 -

原始数组:
[1 2 3 4 5]

切片后的视图数组:
[2 3 4]

来自重塑

另一种返回视图的常见场景是重塑数组。重塑会改变数组的形状(即每个维度的元素数量)，而不会更改底层数据。如果可能，NumPy 会返回原始数组的新形状视图。

示例

此处，reshaped_array 是 original_array 的视图，以"2x3"格式简单呈现。数据保持不变，修改"reshaped_array"也会修改"original_array" -

import numpy as np

# 原始一维数组
original_array = np.array([1, 2, 3, 4, 5, 6])

# 将数组重塑为 2x3 矩阵
reshaped_array = original_array.reshape(2, 3)

print("原始数组:")
print(original_array)

print("
重塑后的数组(视图):")
print(reshaped_array)

我们得到如下所示的输出 -

原始数组:[1 2 3 4 5 6]
重塑后的数组(视图):
[[1 2 3]
[4 5 6]]

转置后的视图

转置数组涉及沿对角线翻转，将行转换为列，反之亦然。使用 np.transpose() 等函数或 .T 属性转置数组时，NumPy 会尽可能返回视图，而不是副本。

示例

在本例中，transposed_array 是 original_array 的视图，但轴方向已互换。底层数据保持不变，对"transposed_array"的更改将反映在"original_array"中 -

import numpy as np

# 原始二维数组
original_array = np.array([[1, 2, 3], [4, 5, 6]])

# 转置数组
transposed_array = original_array.T

print("原始数组:")
print(original_array)

print("
转置数组(视图):")
print(transposed_array)

以下是获得的输出 -

原始数组:
[[1 2 3]
[4 5 6]]

转置数组(视图):
[[1 4]
[2 5]
[3 6]]

Base 属性

在 NumPy 中，数组的 base 属性用于检查该数组是另一个数组的视图还是副本。它是对派生当前数组的原始数组的引用。

如果当前数组是另一个数组的视图，则 "base" 将指向该原始数组。如果当前数组不是视图(即，它是原始数组或深层副本)，则 "base" 将为 None。

示例:原始数组的 ba​​se 属性

创建数组时，其 base 属性将为 None，因为它是原始数组 -

import numpy as np

# 创建原始数组
original_array = np.array([10, 20, 30, 40, 50])

# 检查 base 属性
print("原始数组的 Base:", original_array.base)

这将产生以下结果 -

原始数组的 Base: None

示例:视图的 base 属性

创建数组的视图(例如，通过切片)时，视图的 base 属性将指向原始数组 -

import numpy as np

# 创建原始数组
original_array = np.array([10, 20, 30, 40, 50])

# 创建原始数组的视图
view_array = original_array[1:4]

# 检查 base 属性
print("视图数组的 Base:", view_array.base)

以下是上述代码的输出 -

视图数组的 Base: [10 20 30 40 50]

示例:副本的 base 属性

如果创建数组的副本，则 base 属性将为 None，表示复制的数组与原始数组无关 -

import numpy as np

# 创建原始数组
original_array = np.array([10, 20, 30, 40, 50])

# 创建原始数组的副本
copy_array = original_array.copy()

# 检查 base 属性
print("复制数组的 Base:", copy_array.base)

以下是上述代码的输出 -

复制数组的 Base: None

NumPy - 矩阵库

NumPy 矩阵库

NumPy 矩阵库提供了用于创建和操作矩阵的函数。该库允许您执行各种矩阵运算，包括矩阵乘法、求逆和分解。

在 NumPy 中，可以使用 numpy.matrix() 函数或通过将现有数组转换为矩阵来创建矩阵。本教程将介绍创建矩阵的不同方法。

使用 numpy.matrix() 函数

numpy.matrix() 函数用于从字符串表示形式或现有数据结构创建矩阵。此函数最适合快速创建小型矩阵。

示例

在下面的示例中，我们将从字符串表示形式和现有数组创建一个矩阵。 np.matrix() 函数将字符串解释为 2x2 矩阵，并将数组直接转换为矩阵格式 -

import numpy as np

# 从字符串创建矩阵
matrix_str = np.matrix('1 2; 3 4')
print("Matrix from string:
", matrix_str)

# 从数组创建矩阵
array_data = np.array([[1, 2], [3, 4]])
matrix_from_array = np.matrix(array_data)
print("Matrix from array:
", matrix_from_array)

以下是得到的输出 -

Matrix from string:
[[1 2]
[3 4]]
从数组转换为矩阵:
[[1 2]
[3 4]]

使用 numpy.array() 函数

你可以使用 numpy.asmatrix() 函数将 NumPy 数组转换为矩阵。当您拥有数组形式的现有数据并希望对其进行矩阵运算时，这非常有用。

示例

在下面的示例中，我们创建一个数组，然后使用 np.asmatrix() 函数将其转换为矩阵 -

import numpy as np

# 创建数组
array_data = np.array([[5, 6], [7, 8]])

# 将数组转换为矩阵
matrix_data = np.asmatrix(array_data)
print("转换后的矩阵:
", matrix_data)

这将产生以下结果 -

转换后的矩阵:
[[5 6]
[7 8]]

矩阵运算NumPy

创建矩阵后，您可以执行各种矩阵运算，例如加法、乘法、转置、求逆等等。

矩阵加法

两个矩阵的加法涉及将相应的元素相加。如果两个矩阵形状相同，则可以按元素方式将它们相加。

示例

在此示例中，"matrix_1"和"matrix_2"按元素方式相加，这意味着"matrix_1"中的每个元素都会添加到"matrix_2"中的相应元素中 -

import numpy as np

# 将两个矩阵相加
matrix_1 = np.array([[1, 2], [3, 4]])
matrix_2 = np.array([[5, 6], [7, 8]])

result = matrix_1 + matrix_2
print(result)

以下是上述代码的输出 -

[[ 6 8]
[10 12]]

矩阵乘法

我们可以使用以下方式执行矩阵乘法 -

• 使用 * 运算符
• 使用 @ 运算符(Python 3.5+)
• 使用 np.dot() 函数
• 使用numpy.matmul() 函数

与逐元素乘法不同，矩阵乘法遵循线性代数规则。

示例

在本例中，我们使用上述所有方法对两个矩阵进行乘法运算 -

import numpy as np

matrix_1 = np.array([[1, 2], [3, 4]])
matrix_2 = np.array([[5, 6], [7, 8]])

# 使用 * 进行矩阵乘法
matrix_product1 = matrix_1 * matrix_2
print("矩阵乘法 (*):
", matrix_product1)

# 使用 @ 进行矩阵乘法
matrix_product2 = matrix_1 @ matrix_2
print("矩阵乘法 (@):
", matrix_product2)

# 使用 np.dot() 进行矩阵乘法
matrix_product3 = np.dot(matrix_1, matrix_2)
print("矩阵乘法 (np.dot()):
", matrix_product3)

# 使用 np.matmul() 进行矩阵乘法
matrix_product4 = np.matmul(matrix_1, matrix_2)
print("矩阵乘法 (np.matmul()):
", matrix_product4)

得到的输出如下所示 -

矩阵乘法 (*):
[[ 5 12]
[21 32]]
矩阵乘法 (@):
[[19 22]
[43 50]]
矩阵乘法 (np.dot()):
[[19 22]
[43 50]]
矩阵乘法 (np.matmul()):
[[19 22]
[43 50]]

矩阵求逆

矩阵求逆是一种运算，求出一个矩阵，当该矩阵与原矩阵相乘时，会得到单位矩阵。可以使用 np.linalg.inv() 函数计算矩阵的逆。

然而，并非所有矩阵都是可逆的。矩阵必须是方阵，并且行列式非零才能可逆。

示例

在以下示例中，我们使用 np.linalg.inv() 函数对一个 2x2 矩阵进行求逆。输出是一个新矩阵，与原矩阵相乘后得到单位矩阵 -

import numpy as np

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

inverse_matrix = np.linalg.inv(matrix)
print(inverse_matrix)

执行上述代码后，我们得到以下输出 -

[[-2. 1. ]
[ 1.5 -0.5]]

矩阵转置

转置矩阵涉及沿对角线翻转矩阵，交换行和列的索引。我们可以使用 NumPy 中的 .T 属性转置矩阵。

示例

在下面的示例中，我们使用 ".T" 属性转置一个 2x2 矩阵 -

import numpy as np

# 矩阵转置
matrix = np.array([[1, 2], [3, 4]])

transposed = matrix.T
print(transposed)

结果如下 -

[[1 3]
[2 4]]

矩阵行列式

矩阵的行列式是一个标量值，可以使用 np.linalg.det() 函数计算函数。它提供有关矩阵属性的信息，例如矩阵是否可逆。

非零行列式表示矩阵可逆，而行列式为零则表示矩阵为奇异矩阵。

示例

在此示例中，np.linalg.det() 函数计算给定矩阵的行列式 -

import numpy as np

# 计算行列式
matrix = np.array([[1, 2], [3, 4]])

det = np.linalg.det(matrix)
print("行列式:", det)

我们得到如下所示的输出 −

行列式: -2.0000000000000004

特征值和特征向量

numpy.linalg.eig() 函数用于计算方阵的特征值和右特征向量。特征值表示向量的大小，而特征向量则提供方向。

特征值和特征向量是线性代数中的基本概念，在主成分分析 (PCA) 和求解微分方程等许多领域都很重要。

示例

在此示例中，np.linalg.eig() 函数计算矩阵的特征值和特征向量。特征值表示沿每个特征向量方向的缩放幅度 -

import numpy as np

# 计算特征值和特征向量
matrix = np.array([[4, -2], [1, 1]])

eigvals, eigvecs = np.linalg.eig(matrix)
print("特征值:", eigvals)
print("特征向量:", eigvecs)

以下是得到的输出 -

特征值:[3. 2.]
特征向量:
[[0.89442719 0.70710678]
[0.4472136 0.70710678]]

奇异值分解 (SVD)

SVD 是一种矩阵分解方法，它将方阵的特征分解推广到任何 m x n 矩阵。我们可以在 NumPy 中使用 numpy.linalg.svd() 函数实现这一点。

特征分解是将矩阵分解为特征值和特征向量的过程。这些特征值表示缩放因子，而特征向量则表示矩阵拉伸或压缩的方向。

示例

在下面的示例中，我们使用 np.linalg.svd() 函数对"2x2"矩阵执行奇异值分解。结果包括 U 矩阵、奇异值和 V 矩阵，它们共同表示原始矩阵 -

import numpy as np

matrix_a = np.matrix('1 2; 3 4')

# 执行 SVD
U, S, V = np.linalg.svd(matrix_a)
print("U 矩阵:
", U)
print("奇异值:
", S)
print("V 矩阵:
", V)

这将产生以下结果 -

U 矩阵:
[[-0.40455358 -0.9145143 ]
[-0.9145143 0.40455358]]
奇异值:
[5.4649857 0.36596619]
V 矩阵:
[[-0.57604844 -0.81741556]
 [ 0.81741556 -0.57604844]]

NumPy - 线性代数

NumPy 中的线性代数

线性代数是数学的一个分支，它处理向量、矩阵和线性变换。

NumPy 包包含 numpy.linalg 模块，该模块提供了线性代数所需的所有功能。下表列出了该模块中的一些重要函数。

NumPy - Matplotlib

NumPy 和 Matplotlib

NumPy 是一个用于数值计算的 Python 库，支持数组、数学函数以及对大型数据集的高效操作。

Matplotlib 是一个用于创建静态、交互式和动画可视化效果(例如绘图和图表)的 Python 库。

它们经常一起使用，因为 NumPy 生成和处理数据数组，而 Matplotlib 对其进行可视化。例如，您可以使用 NumPy 创建数据点，然后使用 Matplotlib 将其绘制为图形。

什么是 Matplotlib?

Matplotlib 是一个用于创建高质量绘图和图表的 Python 库。它高度可定制，可以生成各种类型的图表，例如线图、散点图、条形图和直方图。

Matplotlib 与 NumPy 无缝协作，让您可以轻松地可视化数值数据数组或在绘制结果之前执行操作。

设置 Matplotlib

在开始使用 Matplotlib 之前，请确保已安装该库。您可以使用 pip 安装它，如下所示 -

# 安装 Matplotlib
!pip install matplotlib

安装完成后，您可以将其与 NumPy 一起导入，开始创建可视化效果，如下所示 -

import numpy as np
import matplotlib.pyplot as plt

现在库已经准备就绪，让我们深入了解使用 Matplotlib 和 NumPy 可以创建的各种可视化效果。

线图

线图是最简单、最常用的可视化效果之一。它用于显示数据点之间的趋势或关系。

示例

在以下示例中，我们将使用 Matplotlib 和 NumPy 创建线图 -

import numpy as np
import matplotlib.pyplot as plt

# 使用 NumPy 生成数据
# 100 个介于 0 到 10 之间的等距点
x = np.linspace(0, 10, 100)
# 计算 x 的正弦值
y = np.sin(x)

# 创建线图
plt.plot(x, y, label='sin(x)', color='blue', linestyle='--')
plt.title('线图sin(x)')
plt.xlabel('X 轴')
plt.ylabel('Y 轴')
plt.legend()
plt.grid(True)
plt.show()

我们可以看到一个线图，其中显示了一个正弦波，并带有标记轴、图例和网格，以便更好地进行可视化 -

散点图

散点图用于通过显示单个数据点来显示两个变量之间的关系。它们对于识别数据中的模式、相关性或异常值非常有用。

示例

以下是创建散点图的示例，该散点图以透明绿色显示随机点 -

import numpy as np
import matplotlib.pyplot as plt

# 生成随机数据
x = np.random.rand(50)
y = np.random.rand(50)

# 创建散点图
plt.scatter(x, y, color='green', alpha=0.7)
plt.title('随机点散点图')
plt.xlabel('X 轴')
plt.ylabel('Y 轴')
plt.show()

我们得到如下所示的输出 -

条形图

条形图用于比较不同的类别或组。它们使用矩形条形显示数据，其中高度代表值。

示例

以下是创建条形图的示例，该图使用橙色条形显示每个类别的值 -

import numpy as np
import matplotlib.pyplot as plt

# 条形图数据
categories = ['A', 'B', 'C', 'D']
values = [10, 20, 15, 25]

# 创建条形图
plt.bar(categories, values, color='orange')
plt.title('条形图示例')
plt.xlabel('Categories')
plt.ylabel('Values')
plt.show()

获得的输出如下所示−

直方图

直方图用于可视化数据集的频率分布。它们将数据划分为区间(bin)，并显示每个区间内数据点的数量。

示例

以下示例创建了一个直方图，用于显示随机生成数据的频率分布 -

import numpy as np
import matplotlib.pyplot as plt

# 生成随机数据
# 从正态分布中抽取 1000 个样本
data = np.random.randn(1000)

# 创建直方图
plt.hist(data, bins=30, color='purple', alpha=0.8)
plt.title('随机数据直方图')
plt.xlabel('Bins')
plt.ylabel('Frequency')
plt.show()

执行上述代码后，我们得到以下输出 −

饼图

饼图用于将数据表示为圆形的切片，以显示比例或百分比。虽然它们并不总是用于精确比较的最佳方式，但在特定用例中，它们在视觉上很有吸引力。

示例

以下是创建饼图的示例，该饼图以百分比形式显示每种编程语言的比例 -

import numpy as np
import matplotlib.pyplot as plt

# 饼图数据
labels = ['Python', 'Java', 'C++', 'Ruby']
sizes = [50, 30, 15, 5]

# 创建饼图
plt.pie(sizes, label=labels, autopct='%1.1f%%', startangle=140)
plt.title('饼图示例')
plt.show()

生成的结果如下−

自定义 Matplotlib 可视化

Matplotlib 提供了丰富的选项来自定义您的可视化效果。您可以调整颜色、线型、标记、字体等。

示例

以下是使用不同的线型、颜色和标记创建自定义正弦波和余弦波图的示例 -

import numpy as np
import matplotlib.pyplot as plt

# 自定义线图
x = np.linspace(0, 10, 100)
y1 = np.sin(x)
y2 = np.cos(x)

plt.plot(x, y1, label='sin(x)', color='red', linewidth=2, marker='o')
plt.plot(x, y2, label='cos(x)', color='blue', linestyle='dotted')
plt.title('自定义线图')
plt.xlabel('X 轴')
plt.ylabel('Y 轴')
plt.legend()
plt.grid(True, linestyle='--', color='gray', alpha=0.6)
plt.show()

我们得到如下所示的输出 −

结合使用 NumPy 和 Matplotlib

结合使用 NumPy 和 Matplotlib 可以增强您的分析和可视化工作流程。 NumPy 可用于预处理和操作数据，而 Matplotlib 可用于可视化结果。

例如，您可以使用 NumPy 生成数据转换或统计分析，然后使用 Matplotlib 进行可视化。

示例

以下是创建表示二次函数的抛物线图的示例 -

import numpy as np
import matplotlib.pyplot as plt

# 生成并可视化二次函数
x = np.linspace(-10, 10, 200)
y = x**2 - 5*x + 6

plt.plot(x, y, label='y = x^2 - 5x + 6', color='magenta')
plt.title('二次函数可视化')
plt.xlabel('X轴')
plt.ylabel('Y轴')
plt.legend()
plt.show()

得到的输出如下所示 −

NumPy - 使用 Matplotlib 绘制直方图

NumPy 有一个 numpy.histogram() 函数，它可以以图形方式表示数据的频率分布。水平方向大小相等的矩形对应于类距，称为bin，高度变量对应于频率。

numpy.histogram()

numpy.histogram() 函数将输入数组和 bin 作为两个参数。 bin 数组中连续的元素充当每个 bin 的边界。

import numpy as np

a = np.array([22,87,5,43,56,73,55,54,11,20,51,5,79,31,27])
np.histogram(a,bins = [0,20,40,60,80,100])
hist,bins = np.histogram(a,bins = [0,20,40,60,80,100])
print hist 
print bins 

将产生以下输出 -

[3 4 5 2 1]
[0 20 40 60 80 100]

plt()

Matplotlib 可以将这种直方图的数值表示转换为图形。 pyplot 子模块的 plt() 函数 接收包含数据和 bin 数组的数组作为参数，并将其转换为直方图。

from matplotlib import pyplot as plt
import numpy as np

a = np.array([22,87,5,43,56,73,55,54,11,20,51,5,79,31,27])
plt.hist(a, bins = [0,20,40,60,80,100])
plt.title("histogram")
plt.show()

输出结果如下:

NumPy 的 I/O 操作

NumPy 的 I/O 操作

NumPy 中的 I/O 指的是输入/输出操作，允许你将数组保存到文件或从文件中加载数组。np.save() 和 np.load() 等函数处理二进制文件，而 np.savetxt() 和 np.loadtxt() 则处理文本文件。

文本文件的读写

文本文件是存储数据的最常用方式之一。NumPy 提供了读写文本文件的函数。这些操作的主要函数是 numpy.loadtxt() 和 numpy.savetxt()。

numpy.loadtxt() 函数

numpy.loadtxt() 函数将文本文件中的数据加载到 NumPy 数组中。它可以处理不同的数据类型，并允许自定义分隔符和跳过标题行。

示例:读取文本文件

在以下示例中，我们使用 np.loadtxt() 函数从 NumPy 中的文本文件加载数据 -

import numpy as np

# 创建示例文本文件
with open('data.txt', 'w') as f:
   f.write("1.0 2.0 3.0
4.0 5.0 6.0
7.0 8.0 9.0")

# 从文本文件加载数据
data = np.loadtxt('data.txt')
print("从文本文件加载的数据:")
print(data)

以下是得到的输出 -

从文本文件加载的数据:
[[1. 2. 3.]
[4. 5. 6.]
[7. 8. 9.]]

numpy.savetxt() 函数

numpy.savetxt() 函数将 NumPy 数组保存到文本文件。它允许自定义输出文件的分隔符、格式和标头信息。

示例:写入文本文件

在本例中，我们使用 np.savetxt() 函数将 NumPy 数组保存到文本文件 -

import numpy as np

# 创建数组
data = np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]])

# 将数组保存到文本文件
np.savetxt('output.txt', data, delimiter=' ', fmt='%1.1f')
print("数据已保存到文本文件'output.txt'")

数据以空格作为分隔符，小数点后一位保存到文件 'output.txt' 中 -

数据已保存到文本文件 'output.txt'

读取和写入二进制文件

二进制文件存储大型数据集更高效，因为与文本文件相比，它们更紧凑，读写速度更快。NumPy 提供了 numpy.save() 函数和 numpy.load() 函数用于二进制 I/O 操作。

numpy.save() 函数

numpy.save() 函数将 NumPy 数组保存为 .npy 格式的二进制文件。此函数保留数组的数据、形状和数据类型，以便高效存储和检索。

示例:写入二进制文件

在下面的示例中，我们使用 np.save() 函数将 NumPy 数组保存到二进制文件 -

import numpy as np

# 创建数组
data = np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]])

# 将数组保存到二进制文件
np.save('data.npy', data)
print("数据已保存到二进制文件 'data.npy'")

以下是上述代码的输出−

数据已保存到二进制文件"data.npy"

numpy.load() 函数

numpy.load() 函数可从以 .n​​py 或 .npz 格式保存的二进制文件中加载数组。它可以高效地恢复已保存的数据，包括其形状和数据类型。

示例:读取二进制文件

在本例中，我们使用 np.load() 函数从 NumPy 中的二进制文件加载数组 −

import numpy as np

# 从二进制文件加载数组
data = np.load('data.npy')
print("从二进制文件加载的数据:")
print(data)

输出结果如下 -

从二进制文件加载的数据:
[[1. 2. 3.]
[4. 5. 6.]
[7. 8. 9.]]

处理 CSV 文件

逗号分隔值 (CSV) 文件广泛用于数据存储和交换。 NumPy 可以使用 numpy.genfromtxt() 和 numpy.savetxt() 函数读取和写入 CSV 文件。

numpy.genfromtxt() 函数

numpy.genfromtxt() 函数从文本文件加载数据，处理缺失值和非数字数据。它比 loadtxt() 函数更灵活，允许进行高级自定义，例如填充缺失值和指定数据类型。

示例:读取 CSV 文件

在下面的示例中，我们将创建一个包含示例数据的 CSV 文件并保存它。然后，我们使用 np.genfromtxt() 将 CSV 文件中的数据加载到 NumPy 数组中并打印出来 -

import numpy as np

# 创建示例 CSV 文件
with open('data.csv', 'w') as f:
   f.write("1.0,2.0,3.0
4.0,5.0,6.0
7.0,8.0,9.0")

# 从 CSV 文件加载数据
data = np.genfromtxt('data.csv', delimiter=',')
print("从 CSV 文件加载的数据:")
print(data)

执行上述代码后，我们得到以下输出 -

从 CSV 文件加载的数据:
[[1. 2. 3.]
[4. 5. 6.]
[7. 8. 9.]]

示例:写入 CSV 文件

在此示例中，我们创建一个 NumPy 数组，并使用 np.savetxt() 将其保存到 CSV 文件中。数据以逗号分隔符保存，并格式化为小数点后一位 -

import numpy as np

# 创建数组
data = np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]])

# 将数组保存到 CSV 文件
np.savetxt('output.csv', data, delimiter=',', fmt='%1.1f')
print("数据已保存到 CSV 文件 'output.csv'")

我们得到如下所示的输出 -

数据已保存到 CSV 文件 'output.csv'

使用NumPy 的 NPZ 文件

NumPy 的 NPZ 格式允许您将多个数组保存在一个文件中，从而方便地将相关数据存储在一起。您可以使用 numpy.savez() 和 numpy.load() 函数执行这些操作。

numpy.savez() 函数

numpy.savez() 函数将多个 NumPy 数组保存到一个压缩的 .npz 文件中。它允许您使用自定义名称存储多个数组，并在以后高效地检索它们。

示例:写入 NPZ 文件

在下面的示例中，我们将创建两个 NumPy 数组，并使用 np.savez() 函数将它们保存到一个压缩的 .npz 文件中。数组以自定义名称 array1 和 array2 存储在文件中 -

import numpy as np

# 创建数组
array1 = np.array([1, 2, 3])
array2 = np.array([[4, 5, 6], [7, 8, 9]])

# 将数组保存到 NPZ 文件
np.savez('data.npz', array1=array1, array2=array2)
print("数组已保存到 NPZ 文件 'data.npz'")

以下是输出结果 −

数组已保存到 NPZ 文件 'data.npz'

示例:从 NPZ 文件读取

在本例中，我们使用 np.load() 函数加载存储在 .npz 文件中的数组。我们通过引用加载文件中的名称来访问并打印数组"array1"和"array2" -

import numpy as np

# 从 NPZ 文件加载数组
data = np.load('data.npz')
print("从 NPZ 文件加载的数组 1:")
print(data['array1'])
print("从 NPZ 文件加载的数组 2:")
print(data['array2'])

结果如下 -

从 NPZ 文件加载的数组 1:
[1 2 3]
从 NPZ 文件加载的数组 2:
[[4 5 6]
[7 8 9]]

使用内存处理大型数据集映射

内存映射允许您通过将文件映射到内存来处理无法放入内存的大型数据集。NumPy 提供了 numpy.memmap() 函数来实现此目的。

示例:使用内存映射

在下面的示例中，我们将创建一个大型 NumPy 数组，并使用 np.save() 函数将其保存到二进制文件中。然后我们使用 np.memmap() 函数对文件进行内存映射，这样我们就可以访问大数据，而无需将其完全加载到内存中，并打印前 10 个元素 -

import numpy as np

# 创建一个大数组并将其保存到二进制文件
data = np.arange(1e7)
np.save('large_data.npy', data)

# 对二进制文件进行内存映射
mmapped_data = np.memmap('large_data.npy', dtype='float64', mode='r', shape=(int(1e7),))
print("内存映射数据:")
print(mmapped_data[:10])

上述代码的输出如下所示 -

内存映射数据:
[1.87585069e-309 1.17119999e+171 5.22741680e-037 8.44740097e+252
 2.65141232e+180 9.92152605e+247 2.16209968e+233 1.39837001e-076
 5.89250072e-096 6.01347002e-154]

---