深入理解NumPy库：常用函数详解与数组操作指南

     在数据科学和数值计算领域，NumPy无疑是一个强大的工具，它为Python提供了高效的多维数

组处理能力。无论是进行数据分析、构建机器学习模型，还是进行复杂的科学计算，NumPy都是

不可或缺的核心库之一。

        numpy.array 是 NumPy 库中的一个基本对象，它提供了一个多维数组对象，可以用来存储

同类型数据的集合。

        NumPy 是 Python 中进行科学计算的基础库之一，它提供了大量的数值计算功能。

1. 数据结构

        numpy.array 是一个多维数组，它由元素（通常是数字）组成，这些元素在内存中是连续存

储的。

        数组可以是任意维度的，例如一维数组（向量）、二维数组（矩阵）、三维数组等。

2. 类型

        NumPy 数组中的所有元素必须是同一类型，例如整数、浮点数、复数等。

        数组的数据类型可以通过 dtype 属性来查看，例如 int32、float64、complex128 等。

3. 属性

        ndim：数组的维度。

        shape：数组的形状，即每个维度的大小。

        size：数组中元素的总数。

        dtype：数组元素的数据类型。

4. 创建数组

        可以通过传递一个 Python 列表（或其它可迭代对象）给 numpy.array 来创建一个数组。

        可以指定数组的 dtype，如果不指定，NumPy 会根据输入数据的类型自动推断。

import numpy as np

# 创建一个一维数组

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

# 创建一个二维数组

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

print(a)

print(b)

运行结果 

为什么要使用 numpy.array？

        1. 性能

        NumPy 数组在执行数学运算时比 Python 内置的列表要快得多，因为 NumPy 的操作是在底

层执行的，这些底层是用 C 语言写的。

        2. 功能

        NumPy 提供了大量方便的数学函数和线性代数运算功能，可以直接在数组上使用。

        3. 内存效率

        NumPy 数组在存储数据时比 Python 列表更加紧凑，特别是对于大型数据集。

        4. 广播

        NumPy 支持广播规则，这使得在不同形状的数组之间进行操作成为可能，而无需显式地扩展

它们的大小。

        numpy.zeros 是 NumPy 库中的一个函数，它用于创建一个指定形状和数据类型的新数组，

并将其所有元素初始化为 0。

        1. 用途

        numpy.zeros 用于创建一个零矩阵或零向量，这在初始化数据结构、创建占位符数组等场景

中非常有用。

        2. 参数

        shape：一个整数或整数元组，指定输出数组的形状。例如，5 表示一维数组，(2, 3) 表示二

维数组，其中有 2 行 3 列。

        dtype：可选参数，指定数组元素的数据类型。默认是 float，即 float64。

        order：可选参数，指定数组数据在内存中的存储顺序，可以是 'C'（按行，C-style）或

'F'（按列，Fortran-style）。默认是 'C'。

import numpy as np

# 创建一个一维数组，5个元素，数据类型默认为float64

x = np.zeros(5)

# 创建一个二维数组，2行3列，数据类型为整型

y = np.zeros((2, 3), dtype=int)

# 创建一个三维数组，2页3行4列，数据类型为float32

z = np.zeros((2, 3, 4), dtype=np.float32)

print(x, y, z)  # 打印结果

运行结果

        注意事项

        如果 shape 参数是一个整数，numpy.zeros 会创建一个一维数组。

        如果 shape 参数是一个元组，numpy.zeros 会创建一个多维数组，其形状与元组中的值相对

应。

        如果 dtype 参数未指定，默认创建的数组元素类型是 float64。

        numpy.zeros 创建的数组元素总是填充为 0，如果需要填充其他值，可以使用 numpy.ones

（填充为 1）或 numpy.full（填充为指定值）。

        numpy.ones 是 NumPy 库中的一个函数，用于创建一个指定形状和数据类型的新数组，并

将其所有元素初始化为 1。

        1. 用途

        numpy.ones 用于创建一个元素全部为 1 的矩阵或向量，这在初始化权重矩阵、创建单位矩阵

等场景中非常有用。

        2. 参数

        shape：一个整数或整数元组，指定输出数组的形状。

        dtype：可选参数，指定数组元素的数据类型。默认是 float，即 float64。

        order：可选参数，指定数组数据在内存中的存储顺序，可以是 'C'（按行，C-style）

或 'F'（按列，Fortran-style）。默认是 'C'。

import numpy as np

ones_arr = np.ones((2, 3))  # 创建一个2行3列的二维数组，并将所有元素都初始化为1

print(ones_arr)  # 打印结果

运行结果

        numpy.empty 是 NumPy 库中的一个函数，用于创建一个指定形状的新数组，但不初始化其

元素。这意味着数组中的元素将包含内存中的随机值。

        1. 用途

        numpy.empty 用于创建一个未初始化的数组，其元素值是未定义的。

        当性能至关重要且不需要预先填充数据时，使用 numpy.empty 可以节省初始化数组的时间。

        2. 参数

        shape：一个整数或整数元组，指定输出数组的形状。

        dtype：可选参数，指定数组元素的数据类型。默认是 float，即 float64。

        order：可选参数，指定数组数据在内存中的存储顺序，可以是 'C' 或 'F'。默认是 'C'。

import numpy as np

empty_arr = np.empty((2, 3))  # 创建一个 2 行 3 列的二维数组，其元素包含内存中的随机值

print(empty_arr)  # 打印结果

运行结果

注意事项

        numpy.empty 不会初始化数组元素，因此数组中的值是未定义的，可能是任何值。

        使用 numpy.empty 时，应该立即用有效的数据填充数组，以避免在后续的计算中出现不可预

测的结果。

        numpy.empty 通常用于创建大型数组，并且当数组将被立即填充时使用，以节省初始化时

间。

        numpy.arange 是 NumPy 库中的一个函数，用于创建一个一维数组，数组元素是在给定间隔

内的均匀间隔的值。

        1. 用途

        numpy.arange 用于生成一系列数字，类似于 Python 内置的 range 函数，但它返回的是一个

NumPy 数组。

        2. 参数

        start：可选参数，序列的起始值，默认为 0。

        stop：序列的结束值，生成的序列不包括此值。

        step：可选参数，序列中的步长，默认为 1。

        dtype：可选参数，指定返回数组的数据类型。

import numpy as np

range_arr = np.arange(10)

print(range_arr)  # 打印结果

运行结果

        numpy.linspace 是 NumPy 库中的一个函数，用于创建一个一维数组，数组元素在指定的起

始值和结束值之间均匀分布。

        1. 用途

        numpy.linspace 用于在指定的起始值和结束值之间生成指定数量的均匀间隔的样本。

        2. 参数

        start：序列的起始值。

        stop：序列的结束值。

        num：生成的样本数量，默认为 50。如果 num 是 1，则返回 start 和 stop 之间的单个值。

        endpoint：可选参数，如果为 True，则 stop 是最后一个样本。默认为 True。

        retstep：可选参数，如果为 True，则返回样本和步长。

import numpy as np

lin_space_arr = np.linspace(0, 10, num=5)  # linspace_arr 是一个包含 5 个元素的数组，这些元素

在 0 到 10 之间均匀分布。

print(lin_space_arr)    # 打印输出结果

运行结果

        

        numpy.logspace 是 NumPy 库中的一个函数，用于创建一个一维数组，数组元素在指定的

起始值和结束值之间按对数刻度均匀分布。

1. 用途

   numpy.logspace 用于在指定的起始值和结束值之间生成指定数量的对数刻度上的均匀间隔的样本。

2. 参数

   start：起始值的对数值。

   stop：结束值的对数值。

   num：生成的样本数量。

   endpoint：可选参数，如果为 True，则 stop 是最后一个样本。

   base：对数的底数，默认为 10。

   dtype：可选参数，指定返回数组的数据类型。

import numpy as np

logspace_arr = np.logspace(0, 10, num=5, base=10)    # logspace_arr 是一个包含 5 个元素的数

组，这些元素在 10^0 到 10^10 之间按对数刻度均匀分布。

# 默认情况下 base 参数是 10，所以这里实际上是从 1 到 10^10。

print(logspace_arr)    # 打印结果

运行结果

        numpy.shape 返回一个表示数组维度的元组。

        用途：获取数组的维度信息，这对于理解数据的结构非常重要。

        工作原理：它不改变数组本身，而是提供了一个元组，元组中的每个元素对应数组在该维度

上的大小。

import numpy as np

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

arr_2 = np.array([4, 5, 6, 7, 8, 9])

print(arr_1.shape)  # 打印数组的形状，即每个维度的大小

运行结果

        numpy.reshape 改变数组的形状而不改变其数据。

        用途：当你需要改变数组的维度以适应不同的计算需求时，reshape 非常有用。

        工作原理：它返回一个新的数组对象，其数据与原始数组相同，但形状不同。

        如果新形状的总大小与原始数组相同，则操作成功；否则，会抛出错误。

import numpy as np

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

arr_2 = np.array([4, 5, 6, 7, 8, 9])

print(arr_1.shape)  # 打印数组的形状，即每个维度的大小

print(arr_2.reshape((2, 3)))

运行结果

        numpy.resize 改变数组的大小，必要时会重复或截断数据。

        用途：当你需要一个具有特定大小的新数组，并且不介意填充或丢失数据时。

        工作原理：如果新大小大于原始大小，它会重复原始数组中的数据以填充新数组。

        如果新大小小于原始大小，它将截断数据。

import numpy as np

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

arr_2 = np.array([4, 5, 6, 7, 8, 9])

print(arr_1.shape)  # 打印数组的形状，即每个维度的大小

print(arr_2.reshape((2, 3)))

print(np.resize(arr_2, (3, 3)))

运行结果

        numpy.flatten 将多维数组转换为一维数组。

        用途：当你需要将多维数据简化为一维数据时。

        工作原理：它返回一个一维数组，该数组按C风格顺序（行优先）展开原始数组的元素。

import numpy as np

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

arr_2 = np.array([4, 5, 6, 7, 8, 9])

print(arr_1.shape)  # 打印数组的形状，即每个维度的大小

print(arr_2.reshape((2, 3)))

arr_3 = np.resize(arr_2, (3, 3))

print(arr_3.flatten())

运行结果

        

        numpy.concatenate 沿现有轴连接两个或多个数组。

        用途：当你需要将多个数组沿某个轴合并时。

        工作原理：它接受一个元组或列表作为输入，其中包含要连接的数组，以及一个可选的 axis

参数，指定连接的轴。

        示例：如果 arr1 和 arr2 都是长度为 3 的一维数组，np.concatenate((arr1, arr2)) 将返回一个

长度为 6 的新数组。       

        numpy.stack 沿新轴连接两个或多个数组。       

        用途：当你需要创建一个新的维度来组合多个数组时。

        工作原理：与 concatenate 不同，stack 创建一个新的轴，所有输入数组都沿着这个新轴堆

叠。

        示例：如果 arr1 和 arr2 都是长度为 3 的一维数组，np.stack((arr1, arr2), axis=0) 将返回一个

2x3 的二维数组。       

        numpy.split 将一个数组分割成多个子数组。       

        用途：当你需要根据指定的索引将数组分割成多个部分时。

        工作原理：它接受一个数组和一个索引列表，根据这些索引将数组分割成多个子数组。

        索引指定了分割点。

        示例：如果 arr 是一个长度为 6 的一维数组，np.split(arr, [2, 4]) 将返回三个子数组，分别包

含前两个元素、接下来的两个元素和最后两个元素。       

        numpy.sort 对数组进行排序。      

        用途：当你需要对数组中的元素进行排序时。

        工作原理：它返回数组的排序副本，原始数组保持不变。可以指定排序的轴，默认情况下，

一维数组沿着 0 轴排序。

        示例：如果 arr 是一个未排序的数组，np.sort(arr) 将返回一个排序后的数组。

备注

1.  对 dtype 属性确定和识别存储的数据类型的理解

        在 NumPy 库中，每个数组都有一个与之关联的数据类型，称为  dtype （数据类型）。

        这个  dtype  属性告诉我们数组中的元素属于哪种数据类型，例如整数、浮点数、复数等，以

及这些数据类型占用的内存大小。

数据类型

        int32：表示数组中的元素是32位整数。

        这意味着每个整数元素占用32位的内存空间，能够表示的整数范围是从 2^31 到 2^31  1。

        float64：表示数组中的元素是64位浮点数，也称为双精度浮点数。

        每个浮点数元素占用64位的内存空间，能够表示非常大或非常小的数值，以及很高的数值精

度。
        complex128：表示数组中的元素是128位复数。

        每个复数元素由两个64位浮点数组成，分别表示复数的实部和虚部。

import numpy as np

# 创建一个整数类型的数组

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

print(array_int.dtype)  # 输出

# 创建一个浮点类型的数组

array_float = np.array([1.0, 2.0, 3.0])

print(array_float.dtype)  # 输出

# 创建一个复数类型的数组

array_complex = np.array([1+2j, 3+4j])

print(array_complex.dtype)  # 输出

2. 对数组形状的理解

数组形状的定义

        数组的形状指的是数组在每个维度上的大小。

        简单来说，它描述了数组是如何排列和组织的。

维度和形状

        一维数组：只有一个维度，形状是一个数字，表示数组中元素的数量。

        二维数组：有两个维度，形状是两个数字的元组，分别表示行数和列数。

        三维数组：有三个维度，形状是三个数字的元组，可以理解为一系列的“页”，每一页是一个二

维数组。

        更高维数组：以此类推，每个额外的维度都会增加一个数字到形状元组中。