深入解析NumPy的核心函数np.array()

NumPy为Python提供了高效的多维数组对象以及一系列用于处理这些数组的工具，极大地简化了数值计算的过程。而np.array()作为NumPy库的核心函数之一，是创建和操作数组的基础。

NumPy与np.array()简介

NumPy（Numerical Python的简称）是Python中用于处理数组运算的扩展库，它提供了大量的数学函数来操作数组，使得数组的处理变得高效且简洁。np.array()则是NumPy库中的一个基础函数，用于创建数组。

NumPy的重要性

NumPy在科学计算、数据分析、机器学习等众多领域都有着广泛的应用。它的高效性源于其底层使用C语言实现，能够充分利用计算机的硬件资源，对数组进行快速的运算。与Python原生的列表相比，NumPy数组在内存中是连续存储的，这使得数组元素之间的访问和计算更为高效。例如，在进行大规模的数据处理时，使用NumPy数组可以显著提高程序的运行速度。

np.array()的作用

np.array()函数的主要作用是将Python中的各种数据结构（如列表、元组等）转换为NumPy数组，或者根据指定的参数创建一个新的数组。通过np.array()创建的数组可以方便地进行各种数学运算、索引和切片操作，为后续的数据处理和分析提供了基础。

np.array()函数的详细参数

np.array()函数的完整语法为：numpy.array(object, dtype = None, *, copy = True, order = 'K', subok = False, ndmin = 0, like = None)。下面我们来详细介绍每个参数的含义和用法。

object参数

object参数是必填项，它表示要转换为数组的对象，可以是一个数组、任何暴露数组接口的对象、其__array__方法返回数组的对象，或者任何（嵌套的）序列。如果object是一个标量，则返回一个包含该标量的0维数组。

例如，我们可以使用列表来创建一个一维数组：

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

输出结果为：[1 2 3 4 5]

也可以使用嵌套列表来创建一个二维数组：

arr_2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(arr_2d)

输出结果为：

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

dtype参数

dtype参数用于指定数组的数据类型，它是可选的。如果不指定dtype，NumPy会根据传入的数据自动推断出合适的数据类型。例如：

arr = np.array([1, 2, 3])
print(arr.dtype)

输出结果为：int64

在这个例子中，由于传入的数据都是整数，NumPy自动推断出数组的数据类型为int64。

然而，在某些情况下，我们可能需要显式地指定数据类型，以满足特定的需求。比如，当我们需要创建一个包含浮点数的数组时，可以这样做：

arr_float = np.array([1, 2, 3], dtype = np.float32)
print(arr_float.dtype)

输出结果为：float32

通过指定dtype = np.float32，我们创建了一个数据类型为32位浮点数的数组。

指定数据类型的好处之一是可以优化内存使用。例如，如果我们知道数组中的数据范围较小，并且不需要高精度的计算，可以使用较小的数据类型，如int8或float16，这样可以减少内存的占用。

copy参数

copy参数用于控制是否复制数据，它是一个布尔值，默认为True。当copy = True时，无论输入数据的来源如何，都会创建一个数据的副本；当copy = False时，如果输入数据本身就是一个NumPy数组，并且不需要进行任何数据类型转换或其他修改，那么将不会复制数据，而是直接使用原数组的引用。

需要注意的是，当copy = None时，只有在__array__返回副本、obj是嵌套序列或需要满足其他要求（如dtype、order等）时才会进行复制。

例如，下面的代码中，由于输入数据是一个列表，所以无论copy参数的值如何，都会创建一个新的数组副本：

list_data = [1, 2, 3]
arr1 = np.array(list_data, copy = True)
arr2 = np.array(list_data, copy = False)
arr3 = np.array(list_data, copy = None)
print(arr1 is arr2)  # False
print(arr1 is arr3)  # False

输出结果均为False，说明arr1、arr2和arr3都是不同的数组对象。

而当输入数据是一个NumPy数组时，如果copy = False且不需要进行其他修改，那么将不会复制数据：

arr4 = np.array([1, 2, 3])
arr5 = np.array(arr4, copy = False)
print(arr4 is arr5)  # True

输出结果为True，说明arr4和arr5指向同一个数组对象。

order参数

order参数用于指定数组在内存中的存储顺序，它有四个可选值：'K'、'A'、'C'、'F'。

• 'C'表示按C语言的行优先顺序存储，即先存储第一行，再存储第二行，以此类推。
• 'F'表示按Fortran语言的列优先顺序存储，即先存储第一列，再存储第二列，以此类推。
• 'A'表示如果输入数据是Fortran连续的，则按'F'顺序存储，否则按'C'顺序存储。
• 'K'表示尽可能保持输入数据的原始顺序。

默认情况下，order = 'K'。

例如，我们可以通过order参数来控制二维数组的存储顺序：

arr_2d_c = np.array([[1, 2, 3], [4, 5, 6]], order = 'C')
arr_2d_f = np.array([[1, 2, 3], [4, 5, 6]], order = 'F')
print(arr_2d_c.flags)
print(arr_2d_f.flags)

输出结果分别为：

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

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

从输出结果可以看出，arr_2d_c是按行优先顺序存储的（C_CONTIGUOUS : True），而arr_2d_f是按列优先顺序存储的（F_CONTIGUOUS : True）。

subok参数

subok参数是一个布尔值，默认为False。当subok = True时，返回的数组将保留输入数据的子类类型；当subok = False时，无论输入数据的类型如何，返回的数组都将被强制转换为基类ndarray类型。

例如，假设我们有一个自定义的数组子类MyArray，它继承自np.ndarray：

class MyArray(np.ndarray):pass
data = MyArray([1, 2, 3])
arr1 = np.array(data, subok = True)
arr2 = np.array(data, subok = False)
print(type(arr1))  # <class '__main__.MyArray'>
print(type(arr2))  # <class 'numpy.ndarray'>

输出结果表明，当subok = True时，arr1仍然是MyArray类型；而当subok = False时，arr2被转换为了np.ndarray类型。

ndmin参数

ndmin参数用于指定返回数组的最小维度，它是一个整数，默认为0。如果输入数据的维度小于ndmin，则会在数组的形状前面添加一维，直到满足最小维度的要求。

例如：

arr1 = np.array([1, 2, 3], ndmin = 1)
arr2 = np.array([1, 2, 3], ndmin = 2)
arr3 = np.array([1, 2, 3], ndmin = 3)
print(arr1.shape)  # (3,)
print(arr2.shape)  # (1, 3)
print(arr3.shape)  # (1, 1, 3)

在这个例子中，输入数据[1, 2, 3]是一个一维数组。当ndmin = 1时，数组形状不变；当ndmin = 2时，在前面添加了一维，变成了二维数组(1, 3)；当ndmin = 3时，在前面添加了两维，变成了三维数组(1, 1, 3)。

like参数

like参数是在NumPy 1.20.0版本中新增的，它用于指定一个参考对象，以便创建与该对象兼容的数组。如果传入的like参数支持__array_function__协议，那么结果将由该协议定义。

例如：

arr = np.array([1, 2, 3])
new_arr = np.array([4, 5, 6], like = arr)
print(type(new_arr))  # <class 'numpy.ndarray'>

在这个例子中，我们以arr为参考对象，创建了一个新的数组new_arr，new_arr的类型与arr相同，都是np.ndarray。

np.array()函数的使用示例

创建基本的一维和二维数组

如前文所述，使用np.array()函数可以很方便地创建一维和二维数组。
创建一维数组：

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

创建二维数组：

arr_2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(arr_2d)

创建具有特定数据类型的数组

通过dtype参数，我们可以创建具有特定数据类型的数组。
创建整数类型的数组：

arr_int = np.array([1, 2, 3], dtype = np.int16)
print(arr_int.dtype)

创建浮点数类型的数组：

arr_float = np.array([1.0, 2.0, 3.0], dtype = np.float64)
print(arr_float.dtype)

创建复数类型的数组：

arr_complex = np.array([1 + 1j, 2 + 2j, 3 + 3j], dtype = np.complex128)
print(arr_complex.dtype)

创建多维数组

np.array()函数不仅可以创建一维和二维数组，还可以创建更高维度的数组。只需在传入的序列中嵌套更多的层级即可。
创建三维数组：

arr_3d = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
print(arr_3d)

输出结果为：

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

从其他数据结构转换为数组

除了使用列表和元组来创建数组外，np.array()函数还可以将其他数据结构转换为数组。
将集合转换为数组：

set_data = {1, 2, 3, 3}  # 集合会自动去重
arr_set = np.array(set_data)
print(arr_set)

输出结果为：[1 2 3]

将字符串转换为数组：

str_data = "hello"
arr_str = np.array(list(str_data))
print(arr_str)

输出结果为：['h' 'e' 'l' 'l' 'o']

使用ndmin参数创建具有最小维度的数组

通过ndmin参数，我们可以确保创建的数组具有指定的最小维度。

arr1 = np.array([1, 2, 3], ndmin = 2)
print(arr1.shape)  # (1, 3)
arr2 = np.array([1, 2, 3], ndmin = 3)
print(arr2.shape)  # (1, 1, 3)

np.array()函数与与Python原生列表的比较

虽然Python原生列表也可以存储多个元素，但与NumPy数组相比，它们有很多不同之处。

1. 内存存储：NumPy数组在内存中是连续存储的，而Python列表是离散存储的。这使得NumPy数组在进行数值计算时能够更高效地利用内存，提高计算速度。
2. 数据类型：NumPy数组中的所有元素必须是同一数据类型，而Python列表可以包含不同数据类型的元素。这使得NumPy数组在进行数学运算时更加高效，因为不需要进行类型检查和转换。
3. 运算效率：由于NumPy数组的内存存储方式和数据类型的一致性，NumPy提供了大量的优化函数，能够对数组进行快速的数学运算。相比之下，使用Python原生列表进行相同的运算需要编写循环，效率较低。

例如，计算两个数组的元素之和：

import numpy as np
arr1 = np.array([1, 2, 3])
arr2 = np.array([4, 5, 6])
result_np = arr1 + arr2
print(result_np)

输出结果为：[5 7 9]

而使用Python原生列表实现相同的功能：

list1 = [1, 2, 3]
list2 = [4, 5, 6]
result_list = []
for i in range(len(list1)):result_list.append(list1[i] + list2[i])
print(result_list)

输出结果为：[5, 7, 9]

可以看到，使用NumPy数组的代码更加简洁，且在处理大规模数据时，运算效率会更高。

That’s all, thanks for reading!
觉得有用就点个赞、收进收藏夹吧！关注我，获取更多干货～