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)

输出结果如下 -

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