NumPy - 从现有数据创建数组

上一个
下一个

在 NumPy 中从现有数据创建数组

您可以通过使用 Python 中已存在的数据结构初始化 NumPy 数组，或者将其转换为与 NumPy 兼容的格式来从现有数据创建 NumPy 数组。以下是实现此目的的一些常见方法：

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

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

# Convert list to array
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]

示例：保留数据类型

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

import numpy as np

# Convert list with different data types to array
my_mixed_list = [1, 2.5, True, 'hello']
arr_from_mixed = np.asarray(my_mixed_list)

print("Array from mixed list:", arr_from_mixed)

这将产生以下结果：

Array from mixed list: ['1' '2.5' 'True' 'hello']

使用 numpy.frombuffer() 函数

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

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

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

其中，

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

  • dtype（可选） - 结果数组中元素所需的数据类型。默认为 float。

  • count（可选） - 从缓冲区读取的项目数。默认为 -1，表示读取所有数据。

  • offset（可选） - 开始读取数据的缓冲区内的起始位置。默认为 0。

示例

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

import numpy as np

# Create bytes object
my_bytes = b'hello world'

# Create array from bytes object
arr_from_bytes = np.frombuffer(my_bytes, dtype='S1')

print("Array from bytes object:",arr_from_bytes)

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

Array from bytes object: [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

# Generator function that yields numbers
def my_generator(n):
   for i in range(n):
      yield i

# Create array from generator
gen_array = np.fromiter(my_generator(5), dtype=int)

print("Array from generator:",gen_array)

在生成的数组中，每个元素对应于生成器函数产生的转换为整数的值：

Array from generator: [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

# Convert list to array
my_list = [1, 2, 3, 4, 5]
arr_from_list = np.array(my_list)

print("Array from list:",arr_from_list)

执行上述代码后，我们将获得以下输出：

Array from list: [1 2 3 4 5]

从嵌套列表

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

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

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

import numpy as np

# Convert nested list to array 
nested_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
arr_from_nested_list = np.array(nested_list)

print("Array from nested list:")
print(arr_from_nested_list)

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

Array from nested list:
[[1 2 3]
 [4 5 6]
 [7 8 9]]

示例：转换具有不同数据类型的嵌套列表

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

import numpy as np

# Convert nested list with different data types to array
nested_mixed_list = [[1, 2.5], [True, 'hello']]
arr_from_nested_mixed_list = np.array(nested_mixed_list)

print("Array from nested mixed list:")
print(arr_from_nested_mixed_list)

产生的结果如下：

Array from nested mixed list:
[['1' '2.5']
 ['True' 'hello']]

从 Python 元组

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

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

示例

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

import numpy as np

# Convert tuple to array
my_tuple = (1, 2, 3, 4, 5)
arr_from_tuple = np.array(my_tuple)

print("Array from tuple:",arr_from_tuple)

我们将获得如下所示的输出：

Array 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
original_array = np.array([1, 2, 3, 4, 5])

# Create a copy of the array
copied_array = np.copy(original_array)

print("Original array:",original_array)
print("Copied array:",copied_array)

获得的输出如下：

Original array: [1 2 3 4 5]
Copied array: [1 2 3 4 5]

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

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

import numpy as np

# Original array
original_array = np.array([1, 2, 3, 4, 5])

# Create an array from the existing array
new_array = np.asarray(original_array, dtype=float)

print("Original array:",original_array)
print("New array:",new_array)

这将产生以下结果：

Original array: [1 2 3 4 5]
New array: [1. 2. 3. 4. 5.]

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

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

import numpy as np

# Original array
original_array = np.array([1, 2, 3, 4, 5], dtype=np.int32)

# Create a view of the array with a different dtype
viewed_array = original_array.view(dtype=np.float32)

print("Original array:",original_array)
print("Viewed array with dtype float32:",viewed_array)

以下是上述代码的输出结果 -

Original array: [1 2 3 4 5]
Viewed array with dtype 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
original_array = np.array([1, 2, 3, 4, 5, 6])

# Reshape the array to 2x3
reshaped_array = original_array.reshape((2, 3))

print("Original array:",original_array)
print("Reshaped array (2x3):",reshaped_array)

获得的输出结果如下所示 -

Original array: [1 2 3 4 5 6]
Reshaped array (2x3): [[1 2 3]
 [4 5 6]]

示例：使用切片

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

import numpy as np

# Original array
original_array = np.array([1, 2, 3, 4, 5])

# Slice the array to get a subarray
sliced_array = original_array[1:4]

print("Original array:",original_array)
print("Sliced array (elements 1 to 3):",sliced_array)

获得的输出结果如下所示 -

原始数组：[1 2 3 4 5] 切片数组（元素 1 到 3）：[2 3 4]

使用范围对象

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

示例

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

import numpy as np

# Create a range object
my_range = range(1, 10)
# Convert range object to array
arr_from_range = np.array(my_range)

print("Array from range object:",arr_from_range)

执行上述代码后，我们将获得以下输出：

Array from range object: [1 2 3 4 5 6 7 8 9]
打印页面
上一页
下一页
广告