掌握NumPy：基础代码与数组操作

本文还有配套的精品资源，点击获取

简介：NumPy是Python中进行高效数据计算的核心库，提供了多维数组对象和大量数学函数。本文将详细介绍NumPy的基础使用，包括安装导入、数组创建、数据类型、数组属性、索引切片、广播机制、堆栈拼接、重塑转置、数学统计函数、随机数生成、排序和布尔索引。通过这些内容的学习，读者将能掌握NumPy的基础代码，并应用于数据处理和科学计算中。

1. NumPy基础介绍与安装导入

NumPy 是一个开源的 Python 扩展包，它提供了强大的 N 维数组对象以及用于快速操作这些数组的各种方法。它是科学计算的基础库，被广泛应用于数据分析、机器学习以及深度学习等多个领域。

要开始使用 NumPy，首先需要确保已经安装了 Python。之后，通过 Python 的包管理工具 pip 安装 NumPy，执行以下命令：

pip install numpy

安装完成后，我们可以使用 Python 的交互式解释器来导入 NumPy 库，并检查是否正确安装：

import numpy
print(numpy.__version__)

执行上述代码后，如果成功打印了 NumPy 的版本号，则说明 NumPy 已经安装好，我们可以开始进行后续的学习和实践。NumPy 的高效性能很大程度上依赖于其 C 语言的后端，因此理解其数据结构和基本操作对利用 NumPy 进行数据处理至关重要。

2. 创建NumPy数组与数据类型

2.1 NumPy数组的创建

2.1.1 从列表或元组创建数组

NumPy 数组的创建是进行数值计算的第一步。从Python中的列表或元组创建数组是基础操作之一。

import numpy as np

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

# 从元组创建二维数组
tuple_array = np.array([(1.5, 2.5, 3.5), (4.5, 5.5, 6.5)])
print(tuple_array)

列表和元组转换为NumPy数组的操作非常简单， np.array() 函数可以接受Python列表和元组作为参数，并返回一个新的NumPy数组。

2.1.2 从文件读取数据创建数组

从文件读取数据创建数组通常用在处理大量数据集时，常见的文件格式包括CSV、文本文件、二进制文件等。

# 读取CSV文件创建数组
csv_array = np.loadtxt('data.csv', delimiter=',')

# 读取二进制文件创建数组
binary_array = np.fromfile('data.bin', dtype=float)

np.loadtxt() 函数用于从文本文件读取数据并创建数组，而 np.fromfile() 函数用于从二进制文件读取数据。两者都允许我们指定数据类型（dtype），这对于保证数据读取的正确性非常关键。

2.1.3 使用NumPy内置函数创建数组

NumPy 提供了许多内置函数，可以直接生成具有特定结构的数组。

# 创建等差数列数组
arange_array = np.arange(10, 20, dtype=int)

# 创建指定形状的全零数组
zero_array = np.zeros((3, 4), dtype=int)

# 创建指定形状的全一数组
one_array = np.ones((2, 3), dtype=float)

# 创建单位矩阵
identity_matrix = np.eye(3)

np.arange() 生成等差数列的数组， np.zeros() 和 np.ones() 分别创建全零和全一数组，这对于初始化数据非常有用。 np.eye() 函数用于创建单位矩阵，该矩阵在机器学习和线性代数中特别常见。

2.2 NumPy数组的数据类型

2.2.1 数据类型的定义

NumPy 提供了多种数据类型，用以适应不同大小和精度的数据。

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

# 创建浮点类型的数组
float_array = np.array([1.0, 2.0, 3.0], dtype=np.float64)

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

NumPy 数组可以指定数据类型，这有助于内存的优化和计算性能的提升。数据类型（dtype）可以是Python原生的数据类型，也可以是NumPy中定义的特殊数据类型。

2.2.2 数据类型的转换

数据类型转换通常在数据预处理阶段进行，以满足特定算法的需求。

# 将浮点数组转换为整数数组
int_from_float = float_array.astype(np.int32)

# 将整数数组转换为浮点数组
float_from_int = int_array.astype(np.float64)

astype() 函数用于数组的数据类型转换。在进行转换时，需要确保数据类型转换不会导致数据精度的丢失。例如，从浮点数转换到整数时，小数部分会被舍去。

2.2.3 数据类型的查询和设置

查询和设置数据类型是理解和优化数据处理过程的关键步骤。

# 查询数组的数据类型
print("Data type of int_array:", int_array.dtype)

# 设置数组的数据类型
int_array = int_array.astype(np.float64)
print("Data type of int_array after conversion:", int_array.dtype)

通过 dtype 属性可以查询和设置数组的数据类型。理解数据类型对于选择正确的数值算法和优化内存使用非常关键。

以上是对NumPy数组创建和数据类型定义、转换、查询的详细介绍。通过从列表或元组创建数组、从文件读取数据创建数组和使用内置函数创建数组，我们可以开始构建复杂的数值计算任务。了解和掌握数据类型的定义、转换和查询对于优化性能和确保数据处理的准确性至关重要。接下来，我们将继续深入探讨NumPy数组属性与操作，以及如何通过索引和切片来访问数组中的数据。

3. NumPy数组属性与操作

在上一章中，我们深入探讨了NumPy数组的创建方法以及数据类型的细节。接下来，我们将注意力转移到NumPy数组的属性和基本操作上，这两个方面是使用NumPy进行数据科学和数值计算时不可或缺的技能。

3.1 NumPy数组的基本属性

3.1.1 数组的形状和维度

在NumPy中，数组的形状和维度是理解数据结构的关键。形状由数组的维度大小组成，每个维度的大小可以通过 shape 属性获得，而维度的数量可以通过 ndim 属性查询。

import numpy as np

# 创建一个3x4的数组
array_2d = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
print("Array shape:", array_2d.shape)
print("Number of dimensions:", array_2d.ndim)

解释代码逻辑：上述代码首先导入了NumPy库，并创建了一个3行4列的二维数组。通过 shape 属性可以获取到一个元组 (3, 4) ，表示数组有3行和4列；而 ndim 属性返回的整数值 2 告诉我们这个数组是一个二维数组。

3.1.2 数组的数据类型和字节序

NumPy数组可以存储各种数据类型，如整数、浮点数、复数等。数据类型可以通过 dtype 属性获得。

# 创建一个浮点数数组
float_array = np.array([1.0, 2.0, 3.0], dtype=np.float64)
print("Data type:", float_array.dtype)

解释代码逻辑：这段代码创建了一个包含三个浮点数的一维数组，并指定了数据类型为64位浮点数（ np.float64 ）。 dtype 属性将返回数据类型 float64 。

3.1.3 数组的内存大小和地址

了解数组占用的内存大小以及其在内存中的具体位置可以帮助我们优化内存使用，甚至在需要时利用这些信息进行底层操作。

# 获取数组所占用的字节大小
size_in_bytes = array_2d.nbytes
print("Array size in bytes:", size_in_bytes)

# 获取数组内存地址
memory_address = array_2d.__array_interface__['data'][0]
print("Array memory address:", hex(memory_address))

解释代码逻辑：通过 nbytes 属性，我们可以得到数组占用的字节数。而通过 __array_interface__ 字典中的 data 项，我们可以获取到数组在内存中的地址。在这个例子中， memory_address 变量会打印出一个十六进制的地址值。

3.2 NumPy数组的基本操作

3.2.1 数组的算术运算

NumPy提供了丰富的算术运算函数，支持数组之间的运算，这在科学计算中尤为常见。

# 两个数组相加
add_result = array_2d + float_array
print("Addition result:\n", add_result)

# 两个数组相乘
multiply_result = array_2d * float_array
print("Multiplication result:\n", multiply_result)

解释代码逻辑：这里展示了两个数组的加法和乘法运算。 add_result 数组的每个元素是 array_2d 和 float_array 对应位置元素的和； multiply_result 数组的每个元素是对应位置元素的积。

3.2.2 数组的位运算

位运算在处理二进制数据时非常有用，NumPy同样提供了各种位运算支持。

# 两个数组的按位与操作
bitwise_and = np.bitwise_and(array_2d, float_array)
print("Bitwise AND result:\n", bitwise_and)

解释代码逻辑：这里使用了 np.bitwise_and 函数来进行数组间的按位与操作。 bitwise_and 数组的每个元素是 array_2d 和 float_array 对应位置元素进行按位与后的结果。

3.2.3 数组的逻辑运算

逻辑运算常用于数组的条件筛选，NumPy的逻辑运算可以帮助我们快速得到满足条件的元素位置。

# 创建一个布尔索引数组
logical_index = array_2d > 5
print("Logical index array:\n", logical_index)

# 使用逻辑索引进行筛选
filtered_elements = array_2d[logical_index]
print("Filtered elements:", filtered_elements)

解释代码逻辑：这里创建了一个布尔数组 logical_index ，该数组的每个元素表示 array_2d 中的对应元素是否大于5。然后，使用这个布尔数组作为索引来获取 array_2d 中所有大于5的元素。

Mermaid流程图示例

为了更好地解释逻辑索引的使用，可以借助Mermaid流程图来表示这个过程：

flowchart TD
    A[Start] --> B[Create Array]
    B --> C[Create Logical Index]
    C --> D[Filter Elements]
    D --> E[End]

解释流程图：流程图从开始到结束，逐步描述了创建数组、生成逻辑索引、应用逻辑索引进行筛选的步骤。

以上就是本章节的核心内容，通过本章节的介绍，我们已经对NumPy数组的基本属性和操作有了全面的了解。在后续章节中，我们将继续深入探讨数组索引与切片、广播机制、堆栈拼接等高级特性，这些都将为进行更复杂的数据分析和科学计算打下坚实的基础。

4. 数组索引与切片

在处理数据时，能够有效地访问和修改NumPy数组中的特定元素或元素集合是一项基本且关键的技能。索引和切片是NumPy数组操作的核心，允许我们从数组中提取信息或更新数据。本章节将深入探讨如何使用索引和切片来访问和操作NumPy数组。

4.1 数组索引

4.1.1 一维数组的索引

对于一维数组，索引的工作方式类似于Python中的标准列表。索引从0开始，并且可以使用正数或负数。正数索引用于从前向后获取元素，而负数索引则从后向前获取元素。使用方括号“[]”来索引数组，并且可以使用逗号分隔的索引来访问多维数组中的元素。

import numpy as np

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

# 访问第一个元素
print(a[0])  # 输出：1

# 访问最后一个元素
print(a[-1])  # 输出：5

4.1.2 多维数组的索引

在多维数组中，每个维度的索引对应一个轴。例如，二维数组可以看作一个表格，索引每个元素需要指定行和列。使用逗号分隔的索引序列，每个索引对应一个维度。索引的顺序通常遵循“先行后列”的规则。

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

# 访问第二行第一列的元素
print(b[1, 0])  # 输出：4

# 访问第三行第三列的元素
print(b[2, 2])  # 输出：9

4.2 数组切片

切片是索引的一个扩展，允许我们获取数组的子集。切片操作可以让我们访问数组的连续区间，并且可以用于多维数组的每一个维度。

4.2.1 一维数组的切片

切片语法是 array[start:stop:step] ，其中 start 是切片开始的索引， stop 是切片结束的索引（但不包括该索引处的元素）， step 是步长，表示选取元素的间隔。

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

# 获取第二个到第四个元素（包含第二个，不包含第四个）
print(a[1:4])  # 输出：[2 3 4]

# 获取偶数索引处的元素
print(a[::2])  # 输出：[1 3 5]

4.2.2 多维数组的切片

多维数组的切片操作类似，不过每个维度都可以有自己独立的切片规则。切片顺序依然是“先行后列”。

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

# 获取第二行的元素
print(b[1, :])  # 输出：[4 5 6]

# 获取第三列的元素
print(b[:, 2])  # 输出：[3 6 9]

# 获取第二行第三列的元素
print(b[1:, 2])  # 输出：[6 9]

结构化数组索引与切片

除了使用索引和切片获取元素之外，还可以使用高级索引和布尔索引来获取复杂的数组切片。这在处理大型数据集时尤为有用。

# 使用高级索引
idx = [1, 2]
print(b[idx, :])  # 输出：[[4 5 6]
                 #       [7 8 9]]

# 使用布尔索引
mask = b % 2 == 0
print(b[mask])  # 输出：[2 4 6 8]

总结

索引和切片是NumPy数组操作中最基础且强大的特性之一。通过本节的介绍，我们了解了如何使用索引来访问NumPy数组中的元素，并通过切片来获取数组的子集。这为后续章节中关于数组的重塑、数学计算及统计分析等操作提供了基础。掌握索引和切片的使用，对于进行高效的数据操作和分析至关重要。

在下一章中，我们将探讨NumPy中的广播机制，这是一种强大的数组操作方式，能够使具有不同形状的数组以特定规则进行运算，极大地简化了数组间的运算操作。同时，我们还将学习如何使用堆栈与拼接来合并多个数组。

5. NumPy的广播机制与堆栈拼接

NumPy库不仅提供了高性能的数组对象，还内置了一系列强大的数组操作方法。本章将探讨NumPy的广播机制，这是一种让不同形状的数组进行算术运算的方法，以及数组的堆栈拼接操作，包括垂直和水平拼接等。

5.1 广播机制

NumPy的广播机制是处理不同形状数组进行算术运算的一种约定。这个机制可以简化数组操作，让我们无需创建相同形状的数组就可以直接进行运算。

5.1.1 广播规则

在NumPy中，广播允许较小的数组在较大的数组上进行运算。这个过程遵循以下规则：

1. 如果数组的维数不同，则扩展较小的数组，使得每个数组都有与较大数组相同的维度。
2. 如果两个数组在某个维度上的大小相同，或者其中一个数组在该维度上的大小为1，则认为它们在该维度上是兼容的。
3. 如果在任何维度上大小不匹配，并且没有大小为1的维度，则发生错误。
4. 在大小为1的维度上，较小数组被视为沿该维度复制。

下面是一个简单的示例，展示如何使用广播来计算每个元素与一个常数向量的和：

import numpy as np

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

print(a + b)

在这个例子中， b 是一个一维数组，但在进行加法运算时，NumPy自动将其“广播”到与 a 相同的形状，即二维数组。结果如下：

array([[2, 4, 6],
       [5, 7, 9]])

5.1.2 广播的应用实例

广播机制广泛应用于科学计算和数据分析中。例如，在处理图像数据时，我们经常需要给每个像素添加一个常数值来调整亮度或对比度。这种情况下，广播机制可以让我们无需创建新的数组就可以实现这一点。

下面的代码展示了如何对图像数据进行简单操作：

# 假设img是一个具有高度和宽度的二维图像数据数组
# brightness是一个一维数组，包含要增加的亮度值

def adjust_brightness(img, brightness):
    return img + brightness

# 假设亮度增加值为10
brightness = 10
adjusted_img = adjust_brightness(img, brightness)

在这个函数中， brightness 数组会自动广播到 img 数组的每个通道上。

5.2 堆栈与拼接

NumPy提供了多种函数来沿着特定轴将数组堆栈或拼接起来。这允许我们构建更高维的数据结构或组合已有的数据。

5.2.1 垂直堆栈与水平堆栈

• vstack 函数：垂直堆栈，沿着第一个轴堆叠数组。
• hstack 函数：水平堆栈，沿着最后一个轴堆叠数组。

下面展示了如何使用这些函数：

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

# 垂直堆栈
c = np.vstack((a, b))

# 水平堆栈
d = np.hstack((a, b))

堆栈后的数组 c 和 d 将分别如下：

c =
array([[1, 2],
       [3, 4],
       [5, 6],
       [7, 8]])

d =
array([[1, 2, 5, 6],
       [3, 4, 7, 8]])

5.2.2 垂直拼接与水平拼接

• concatenate 函数：提供了更灵活的方式来沿着指定的轴拼接数组。
• column_stack 和 row_stack ：在 concatenate 的基础上提供列拼接和行拼接的便利。

以下是使用 concatenate 的示例：

# 创建两个二维数组
e = np.array([[1, 2], [3, 4]])
f = np.array([[5, 6], [7, 8]])

# 沿着水平轴拼接
g = np.concatenate((e, f), axis=1)

拼接后的数组 g 结果为：

array([[1, 2, 5, 6],
       [3, 4, 7, 8]])

表格展示

为了更好地理解不同拼接函数之间的差异，以下是一个表格总结：

函数名	描述	示例
vstack	沿着第一个轴（垂直方向）堆栈数组。	np.vstack
hstack	沿着最后一个轴（水平方向）堆栈数组。	np.hstack
concatenate	灵活地沿着任意轴拼接数组序列。需要指定轴。	np.concatenate
column_stack	将输入作为列堆栈到一起，总是沿着第一个轴。	np.column_stack
row_stack	将输入作为行堆栈到一起，总是沿着最后一个轴。	np.row_stack

这些操作对于数据预处理、特征工程以及生成合成数据集等任务都至关重要。掌握这些工具将使你的数据处理工作更加高效和灵活。

6. 数组重塑与转置、数学与统计函数应用

在处理科学计算和数据分析任务时，对数组形状的调整是经常需要的操作。NumPy 提供了强大的函数来重塑数组，以及便捷的转置功能以满足不同的数据处理需求。此外，NumPy 的数学和统计函数能够高效地对数组进行各种数学运算和统计分析，是数据分析不可或缺的工具。

6.1 数组的重塑与转置

6.1.1 数组的重塑

重塑数组意味着改变数组的形状而不改变其数据。 reshape 方法是最常用的函数之一，它允许你指定新的形状，只要新旧形状的元素总数一致即可。如果一个维度设置为 -1，NumPy 将自动计算这个维度的大小。

import numpy as np

# 创建一个1维数组
arr = np.arange(6)
print("原始数组:", arr)

# 将数组重塑为2x3的2维数组
reshaped_arr = arr.reshape(2, 3)
print("重塑后的数组:\n", reshaped_arr)

执行上述代码后，会看到输出：

原始数组: [0 1 2 3 4 5]
重塑后的数组:
 [[0 1 2]
 [3 4 5]]

在NumPy中， reshape 可以使用 -1 来自动计算某个维度的大小。例如，如果我们知道数据总量是 N ，我们想要将数组重塑为一行，可以使用 (-1, N) 来指定。

6.1.2 数组的转置

转置是改变数组维度顺序的操作。对于二维数组，可以使用 .T 属性来转置数组，或使用 transpose 方法，并提供一个维度顺序的元组。

# 创建一个2x3的2维数组
arr = np.array([[0, 1, 2], [3, 4, 5]])
print("原始数组:\n", arr)

# 使用.T属性转置
transposed_arr = arr.T
print("转置后的数组:\n", transposed_arr)

# 使用transpose方法转置
transposed_arr_method = arr.transpose((1, 0))
print("使用方法转置后的数组:\n", transposed_arr_method)

输出结果将是：

原始数组:
 [[0 1 2]
 [3 4 5]]
转置后的数组:
 [[0 3]
 [1 4]
 [2 5]]
使用方法转置后的数组:
 [[0 3]
 [1 4]
 [2 5]]

6.2 数学与统计函数应用

6.2.1 常用数学函数

NumPy 提供了大量的数学函数，比如三角函数、指数函数、对数函数等，这些都是在数据分析中常用的操作。

# 示例：计算数组元素的正弦值
import numpy as np

arr = np.array([0, np.pi/4, np.pi/2, np.pi])
sin_arr = np.sin(arr)
print("sin函数计算结果:\n", sin_arr)

执行上述代码后，将看到输出：

sin函数计算结果:
 [0.         0.70710678 1.         1.2246468e-16]

6.2.2 常用统计函数

NumPy 提供了多个统计函数，如求和（ sum ）、平均值（ mean ）、标准差（ std ）、最小值（ min ）、最大值（ max ）等，这些函数可以在单个数组或多个数组的维度上操作。

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

# 计算每列的平均值
mean_per_column = np.mean(stats_arr, axis=0)
print("每列平均值:\n", mean_per_column)

# 计算每行的总和
sum_per_row = np.sum(stats_arr, axis=1)
print("每行总和:\n", sum_per_row)

输出结果为：

每列平均值:
 [4. 5. 6.]
每行总和:
 [ 6 15 24]

以上章节中，我们探讨了如何重塑和转置NumPy数组，以及如何使用NumPy的数学和统计函数进行高效计算。这些技能对于数据科学和工程领域的从业者来说是非常重要的。接下来的章节，我们将进一步深入探讨随机数生成、数组排序、布尔索引以及高级函数的使用。这些操作为数据分析带来了更多灵活性和强大的数据处理能力。

本文还有配套的精品资源，点击获取

简介：NumPy是Python中进行高效数据计算的核心库，提供了多维数组对象和大量数学函数。本文将详细介绍NumPy的基础使用，包括安装导入、数组创建、数据类型、数组属性、索引切片、广播机制、堆栈拼接、重塑转置、数学统计函数、随机数生成、排序和布尔索引。通过这些内容的学习，读者将能掌握NumPy的基础代码，并应用于数据处理和科学计算中。

本文还有配套的精品资源，点击获取