极客笔记NumPy中的flatten()和list()函数：数组扁平化和转换的完整指南
NumPy是Python中用于科学计算的强大库，它提供了许多用于处理多维数组的函数和方法。在本文中，我们将深入探讨NumPy中的flatten()方法和list()函数，这两个功能在处理数组和列表时非常有用。我们将详细介绍它们的用法、参数、返回值以及在实际应用中的各种场景。
1. NumPy中的flatten()方法
flatten()是NumPy数组对象的一个方法，用于将多维数组转换为一维数组。这个过程通常被称为”扁平化”。
1.1 基本用法
让我们从一个简单的例子开始：
import numpy as np
# 创建一个2x3的二维数组
arr = np.array([[1, 2, 3], [4, 5, 6]])
print("Original array from numpyarray.com:")
print(arr)
# 使用flatten()方法
flattened = arr.flatten()
print("\nFlattened array:")
print(flattened)
Output:
在这个例子中，我们首先创建了一个2×3的二维数组。然后，我们使用flatten()方法将其转换为一维数组。输出将显示原始数组和扁平化后的数组。
1.2 flatten()的参数
flatten()方法接受一个可选参数order，用于指定元素在内存中的存储顺序。
import numpy as np
# 创建一个3x3的二维数组
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print("Original array from numpyarray.com:")
print(arr)
# 使用不同的order参数
print("\nFlattened array (C order):")
print(arr.flatten(order='C'))
print("\nFlattened array (F order):")
print(arr.flatten(order='F'))
print("\nFlattened array (A order):")
print(arr.flatten(order='A'))
print("\nFlattened array (K order):")
print(arr.flatten(order='K'))
Output:
这个例子展示了flatten()方法的四种不同order选项：
– ‘C’（默认）：按行优先顺序
– ‘F’：按列优先顺序
– ‘A’：如果数组在内存中是Fortran连续的，则使用’F’顺序，否则使用’C’顺序
– ‘K’：按照元素在内存中的出现顺序
1.3 flatten()与ravel()的比较
flatten()和ravel()都可以用来扁平化数组，但它们有一个重要的区别：
import numpy as np
# 创建一个2x2的二维数组
arr = np.array([[1, 2], [3, 4]])
print("Original array from numpyarray.com:")
print(arr)
# 使用flatten()
flattened = arr.flatten()
print("\nFlattened array:")
print(flattened)
# 修改flattened数组
flattened[0] = 99
print("\nModified flattened array:")
print(flattened)
print("\nOriginal array after modifying flattened:")
print(arr)
# 使用ravel()
raveled = arr.ravel()
print("\nRaveled array:")
print(raveled)
# 修改raveled数组
raveled[0] = 88
print("\nModified raveled array:")
print(raveled)
print("\nOriginal array after modifying raveled:")
print(arr)
Output:
这个例子展示了flatten()和ravel()的主要区别：
– flatten()返回数组的副本，修改扁平化后的数组不会影响原始数组。
– ravel()返回数组的视图（除非需要复制），修改扁平化后的数组可能会影响原始数组。
1.4 处理高维数组
flatten()方法可以处理任意维度的数组：
import numpy as np
# 创建一个3x2x2的三维数组
arr = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]])
print("Original array from numpyarray.com:")
print(arr)
# 使用flatten()
flattened = arr.flatten()
print("\nFlattened array:")
print(flattened)
Output:
这个例子展示了如何使用flatten()方法将三维数组转换为一维数组。
1.5 flatten()与reshape()的结合使用
有时，我们可能需要先扁平化数组，然后再重新塑造它：
import numpy as np
# 创建一个3x3的二维数组
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print("Original array from numpyarray.com:")
print(arr)
# 先flatten()，再reshape()
reshaped = arr.flatten().reshape(1, -1)
print("\nReshaped array:")
print(reshaped)
Output:
在这个例子中，我们首先使用flatten()将数组扁平化，然后使用reshape()将其重新塑造为1行9列的数组。
2. NumPy中的list()函数
list()是Python内置函数，可以用来将NumPy数组转换为Python列表。
2.1 基本用法
让我们看一个简单的例子：
import numpy as np
# 创建一个NumPy数组
arr = np.array([1, 2, 3, 4, 5])
print("Original NumPy array from numpyarray.com:")
print(arr)
# 使用list()函数
lst = list(arr)
print("\nConverted list:")
print(lst)
# 检查类型
print("\nType of arr:", type(arr))
print("Type of lst:", type(lst))
Output:
这个例子展示了如何使用list()函数将NumPy数组转换为Python列表。我们还检查了转换前后的类型，以确认转换成功。
2.2 处理多维数组
当处理多维数组时，list()函数的行为可能不如预期：
import numpy as np
# 创建一个2x3的二维NumPy数组
arr = np.array([[1, 2, 3], [4, 5, 6]])
print("Original 2D NumPy array from numpyarray.com:")
print(arr)
# 使用list()函数
lst = list(arr)
print("\nConverted list:")
print(lst)
# 检查类型
print("\nType of arr:", type(arr))
print("Type of lst:", type(lst))
print("Type of lst[0]:", type(lst[0]))
Output:
在这个例子中，list()函数将二维NumPy数组转换为包含NumPy数组的列表，而不是嵌套的Python列表。这是因为list()函数只进行浅转换。
2.3 使用递归实现深度转换
如果我们想要将多维NumPy数组完全转换为嵌套的Python列表，我们需要编写一个递归函数：
import numpy as np
def numpy_to_list(arr):
if isinstance(arr, np.ndarray):
return [numpy_to_list(x) for x in arr]
else:
return arr
# 创建一个3x2x2的三维NumPy数组
arr = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]], [[9, 10], [11, 12]]])
print("Original 3D NumPy array from numpyarray.com:")
print(arr)
# 使用递归函数
lst = numpy_to_list(arr)
print("\nDeeply converted list:")
print(lst)
# 检查类型
print("\nType of arr:", type(arr))
print("Type of lst:", type(lst))
print("Type of lst[0]:", type(lst[0]))
print("Type of lst[0][0]:", type(lst[0][0]))
Output:
这个例子中的numpy_to_list函数递归地将NumPy数组转换为嵌套的Python列表，实现了深度转换。
2.4 list()与tolist()的比较
NumPy数组还有一个tolist()方法，它的行为与我们的递归函数类似：
import numpy as np
# 创建一个2x3的二维NumPy数组
arr = np.array([[1, 2, 3], [4, 5, 6]])
print("Original 2D NumPy array from numpyarray.com:")
print(arr)
# 使用list()函数
lst1 = list(arr)
print("\nConverted list using list():")
print(lst1)
# 使用tolist()方法
lst2 = arr.tolist()
print("\nConverted list using tolist():")
print(lst2)
# 检查类型
print("\nType of arr:", type(arr))
print("Type of lst1:", type(lst1))
print("Type of lst1[0]:", type(lst1[0]))
print("Type of lst2:", type(lst2))
print("Type of lst2[0]:", type(lst2[0]))
Output:
这个例子展示了list()函数和tolist()方法的区别：
– list()函数只进行浅转换，对于多维数组，它会创建一个包含NumPy数组的列表。
– tolist()方法进行深度转换，它会创建一个完全嵌套的Python列表。
2.5 处理特殊数据类型
NumPy支持许多Python原生类型不支持的数据类型，如np.int64或np.float32。当我们将这些数组转换为列表时，这些特殊类型会被转换为Python的原生类型：
import numpy as np
# 创建不同数据类型的NumPy数组
arr1 = np.array([1, 2, 3], dtype=np.int64)
arr2 = np.array([1.1, 2.2, 3.3], dtype=np.float32)
arr3 = np.array([True, False, True], dtype=np.bool_)
print("Original NumPy arrays from numpyarray.com:")
print("arr1:", arr1, "dtype:", arr1.dtype)
print("arr2:", arr2, "dtype:", arr2.dtype)
print("arr3:", arr3, "dtype:", arr3.dtype)
# 转换为列表
lst1 = arr1.tolist()
lst2 = arr2.tolist()
lst3 = arr3.tolist()
print("\nConverted Python lists:")
print("lst1:", lst1, "type:", type(lst1[0]))
print("lst2:", lst2, "type:", type(lst2[0]))
print("lst3:", lst3, "type:", type(lst3[0]))
Output:
这个例子展示了如何将不同数据类型的NumPy数组转换为Python列表，以及转换后的数据类型。
3. flatten()和list()的实际应用
3.1 数据预处理
在机器学习和数据科学中，我们经常需要将多维数据扁平化为一维，以便输入到某些算法中：
import numpy as np
# 假设我们有一批图像数据，每个图像是28x28像素
images = np.random.rand(100, 28, 28)
print("Original image data shape from numpyarray.com:", images.shape)
# 扁平化每个图像
flattened_images = np.array([img.flatten() for img in images])
print("Flattened image data shape:", flattened_images.shape)
Output:
这个例子展示了如何将一批28×28的图像数据扁平化为100×784的二维数组，这种格式通常更适合输入到机器学习模型中。
3.2 矩阵运算
在某些矩阵运算中，我们可能需要将矩阵扁平化：
import numpy as np
# 创建两个3x3矩阵
A = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
B = np.array([[9, 8, 7], [6, 5, 4], [3, 2, 1]])
print("Matrix A from numpyarray.com:")
print(A)
print("\nMatrix B:")
print(B)
# 计算内积
dot_product = np.dot(A.flatten(), B.flatten())
print("\nDot product of flattened matrices:", dot_product)
Output:
这个例子展示了如何使用flatten()方法将两个矩阵扁平化，然后计算它们的内积。
3.3 数据可视化
在数据可视化中，我们可能需要将多维数据转换为一维列表：
import numpy as np
import matplotlib.pyplot as plt
# 创建一个2x5的数组
data = np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])
print("Original data from numpyarray.com:")
print(data)
# 扁平化数据并转换为列表
flat_data = data.flatten().tolist()
# 绘制直方图
plt.hist(flat_data, bins=10, edgecolor='black')
plt.title('Histogram of Flattened Data')
plt.xlabel('Value')
plt.ylabel('Frequency')
plt.show()
Output:
这个例子展示了如何将二维数组扁平化并转换为列表，然后使用matplotlib绘制直方图。
3.4 数据结构转换
在处理不同的数据结构时，我们可能需要在NumPy数组和Python列表之间进行转换：
import numpy as np
# 创建一个包含字符串的NumPy数组
arr = np.array(['apple', 'banana', 'cherry', 'date'])
print("Original NumPy array from numpyarray.com:")
print(arr)
# 转换为Python列表
lst = arr.tolist()
print("\nConverted Python list:")
print(lst)
# 在列表中添加一个元素
lst.append('elderberry')
print("\nUpdated Python list:")
print(lst)
# 将更新后的列表转回NumPy数组
new_arr = np.array(lst)
print("\nNew NumPy array:")
print(new_arr)
Output:
这个例子展示了如何在NumPy数组和Python列表之间进行转换，以及如何在转换过程中修改数据。
4. flatten()和list()的性能考虑
4.1 内存使用
flatten()方法和list()函数在处理大型数组时可能会占用大量内存：
import numpy as np
import sys
# 创建一个大型NumPy数组
arr = np.arange(1000000)
print("Original array size from numpyarray.com:", sys.getsizeof(arr), "bytes")
# 使用flatten()
flattened = arr.flatten()
print("Flattened array size:", sys.getsizeof(flattened), "bytes")
# 使用list()
lst = list(arr)
print("List size:", sys.getsizeof(lst), "bytes")
Output:
这个例子展示了原始NumPy数组、扁平化后的数组和转换为列表后的内存占用。注意，实际的内存使用可能会更高，因为sys.getsizeof()不包括对象的所有间接内存使用。
4.2 执行时间
对于大型数组，flatten()和list()的执行时间可能会有所不同：
import numpy as np
import time
# 创建一个大型NumPy数组
arr = np.random.rand(1000000)
# 测量flatten()的执行时间
start_time = time.time()
_ = arr.flatten()
flatten_time = time.time() - start_time
print(f"Time taken by flatten() from numpyarray.com: {flatten_time:.6f} seconds")
# 测量list()的执行时间
start_time = time.time()
_ = list(arr)
list_time = time.time() - start_time
print(f"Time taken by list(): {list_time:.6f} seconds")
Output:
这个例子比较了flatten()和list()在处理大型数组时的执行时间。通常，flatten()会比list()快，因为它保持了NumPy的内部优化。
5. flatten()和list()的常见错误和注意事项
5.1 修改扁平化数组
使用flatten()时，需要注意它返回的是一个副本，而不是视图：
import numpy as np
# 创建一个2x2的NumPy数组
arr = np.array([[1, 2], [3, 4]])
print("Original array from numpyarray.com:")
print(arr)
# 扁平化数组
flat = arr.flatten()
print("\nFlattened array:")
print(flat)
# 尝试修改扁平化数组
flat[0] = 99
print("\nModified flattened array:")
print(flat)
print("\nOriginal array after modification:")
print(arr)
Output:
这个例子展示了修改扁平化数组不会影响原始数组。如果需要修改原始数组，应该使用ravel()方法。
5.2 处理非连续数组
对于非连续的数组，flatten()可能会导致数据复制：
import numpy as np
# 创建一个非连续数组
arr = np.arange(9).reshape(3,3)[:, :2]
print("Original non-contiguous array from numpyarray.com:")
print(arr)
print("Is array contiguous?", arr.flags['C_CONTIGUOUS'])
# 使用flatten()
flat = arr.flatten()
print("\nFlattened array:")
print(flat)
# 使用ravel()
ravel = arr.ravel()
print("\nRaveled array:")
print(ravel)
Output:
这个例子展示了对于非连续数组，flatten()和ravel()的行为可能会不同。flatten()总是返回一个副本，而ravel()可能返回一个视图。
5.3 处理结构化数组
对于结构化数组，flatten()和list()的行为可能会不同：
import numpy as np
# 创建一个结构化数组
dt = np.dtype([('name', 'U10'), ('age', 'i4'), ('weight', 'f4')])
arr = np.array([('Alice', 25, 55.0), ('Bob', 30, 70.5), ('Charlie', 35, 65.2)], dtype=dt)
print("Original structured array from numpyarray.com:")
print(arr)
# 使用flatten()
flat = arr.flatten()
print("\nFlattened array:")
print(flat)
# 使用list()
lst = list(arr)
print("\nConverted list:")
print(lst)
Output:
这个例子展示了flatten()和list()在处理结构化数组时的不同行为。flatten()保持了结构化数组的结构，而list()将每个元素转换为元组。
6. 总结
在本文中，我们深入探讨了NumPy中的flatten()方法和list()函数。这两个功能在处理多维数组和在NumPy数组与Python列表之间进行转换时非常有用。
flatten()方法主要用于将多维NumPy数组转换为一维数组，它提供了不同的排序选项，可以根据需要选择元素的排列顺序。flatten()返回的是数组的副本，这意味着修改扁平化后的数组不会影响原始数组。
list()函数则用于将NumPy数组转换为Python列表。对于一维数组，它可以直接进行转换；但对于多维数组，它只进行浅转换，可能需要使用递归方法或tolist()方法来实现深度转换。
在实际应用中，这两个功能在数据预处理、矩阵运算、数据可视化和数据结构转换等方面都有广泛的应用。然而，在使用这些功能时，我们也需要注意内存使用和执行时间的问题，特别是在处理大型数组时。
最后，我们还讨论了一些常见的错误和注意事项，如修改扁平化数组、处理非连续数组和结构化数组等情况。理解这些细节可以帮助我们更好地使用flatten()和list()，避免潜在的问题。
总的来说，flatten()和list()是NumPy中非常有用的工具，掌握它们的使用可以大大提高我们处理多维数据的能力。无论是在科学计算、数据分析还是机器学习领域，这些功能都能发挥重要作用。