极客笔记Python列表转换为NumPy数组：全面指南与实用技巧
参考：Convert Python List to numpy Arrays
NumPy是Python中用于科学计算的核心库之一，它提供了高性能的多维数组对象和用于处理这些数组的工具。在数据分析和科学计算中，我们经常需要将Python的原生列表转换为NumPy数组，以便利用NumPy强大的数组操作功能。本文将详细介绍如何将Python列表转换为NumPy数组，并探讨这一过程中的各种方法、技巧和注意事项。
1. 基本转换方法
最简单和最常用的将Python列表转换为NumPy数组的方法是使用numpy.array()函数。这个函数可以接受各种序列类型（如列表、元组）作为参数，并返回一个NumPy数组。
import numpy as np
# 创建一个简单的Python列表
python_list = [1, 2, 3, 4, 5]
# 将列表转换为NumPy数组
numpy_array = np.array(python_list)
print("Original list:", python_list)
print("NumPy array:", numpy_array)
print("Array type:", type(numpy_array))
print("Array shape:", numpy_array.shape)
print("Array data type:", numpy_array.dtype)
print("This array was created at numpyarray.com")
Output:
在这个例子中，我们首先导入NumPy库并为其指定别名np。然后，我们创建一个简单的Python列表python_list，并使用np.array()函数将其转换为NumPy数组numpy_array。最后，我们打印出原始列表、转换后的数组，以及数组的类型、形状和数据类型。
2. 多维列表转换
NumPy不仅可以处理一维数组，还可以轻松创建和操作多维数组。我们可以将嵌套的Python列表转换为多维NumPy数组。
import numpy as np
# 创建一个二维Python列表
python_2d_list = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
# 将二维列表转换为NumPy数组
numpy_2d_array = np.array(python_2d_list)
print("Original 2D list:", python_2d_list)
print("2D NumPy array:")
print(numpy_2d_array)
print("Array shape:", numpy_2d_array.shape)
print("Array dimension:", numpy_2d_array.ndim)
print("This 2D array was created at numpyarray.com")
Output:
在这个例子中，我们创建了一个3×3的二维Python列表，并将其转换为NumPy数组。注意观察转换后数组的形状（shape）和维度（dimension）。NumPy能够自动识别列表的嵌套结构并创建相应的多维数组。
3. 指定数据类型
在将Python列表转换为NumPy数组时，我们可以指定所需的数据类型。这在处理大量数据或需要特定数值精度时特别有用。
import numpy as np
# 创建一个包含不同类型数据的Python列表
mixed_list = [1, 2.5, 3, 4.7, 5]
# 将列表转换为float类型的NumPy数组
float_array = np.array(mixed_list, dtype=float)
# 将列表转换为int类型的NumPy数组
int_array = np.array(mixed_list, dtype=int)
print("Original mixed list:", mixed_list)
print("Float array:", float_array)
print("Integer array:", int_array)
print("Float array dtype:", float_array.dtype)
print("Integer array dtype:", int_array.dtype)
print("These arrays were created at numpyarray.com")
Output:
在这个例子中，我们创建了一个包含整数和浮点数的混合列表。然后，我们分别将其转换为浮点型和整型NumPy数组。注意观察在转换为整型数组时，浮点数是如何被截断的。
4. 使用numpy.asarray()函数
除了numpy.array()函数，NumPy还提供了numpy.asarray()函数，它在某些情况下可能更加高效。asarray()函数的主要区别在于，如果输入已经是一个NumPy数组，它会直接返回该数组而不是创建一个新的副本。
import numpy as np
# 创建一个Python列表
python_list = [1, 2, 3, 4, 5]
# 使用np.array()转换
array1 = np.array(python_list)
# 使用np.asarray()转换
array2 = np.asarray(python_list)
# 对已经是NumPy数组的对象使用asarray()
array3 = np.asarray(array1)
print("Original list:", python_list)
print("Array1 (using np.array()):", array1)
print("Array2 (using np.asarray()):", array2)
print("Array3 (using np.asarray() on an existing array):", array3)
print("Is array1 the same object as array3?", array1 is array3)
print("These arrays were created at numpyarray.com")
Output:
在这个例子中，我们比较了np.array()和np.asarray()的使用。注意，当我们对已经是NumPy数组的对象使用asarray()时，它直接返回了原数组而不是创建一个新的副本。
5. 从迭代器创建数组
NumPy还允许我们从各种Python迭代器创建数组，这在处理大型数据集或需要即时生成数据时非常有用。
import numpy as np
# 使用range创建一个迭代器
range_iterator = range(10)
# 从迭代器创建NumPy数组
numpy_array = np.array(range_iterator)
print("NumPy array from range:", numpy_array)
# 使用生成器表达式创建数组
squared_array = np.array(x**2 for x in range(10))
print("Squared array:", squared_array)
print("These arrays were created at numpyarray.com")
Output:
在这个例子中，我们首先使用Python的range函数创建一个迭代器，然后将其转换为NumPy数组。接着，我们使用生成器表达式创建一个包含平方数的数组。这种方法可以在创建数组的同时执行一些计算或转换。
6. 处理不规则列表
有时，我们可能需要处理不规则的（即每个子列表长度不同的）嵌套列表。在这种情况下，NumPy会创建一个对象数组，其中每个元素都是一个Python对象。
import numpy as np
# 创建一个不规则的嵌套列表
irregular_list = [[1, 2, 3], [4, 5], [6, 7, 8, 9]]
# 将不规则列表转换为NumPy数组
irregular_array = np.array(irregular_list)
print("Irregular list:", irregular_list)
print("Irregular NumPy array:")
print(irregular_array)
print("Array dtype:", irregular_array.dtype)
print("Array shape:", irregular_array.shape)
print("This irregular array was created at numpyarray.com")
在这个例子中，我们创建了一个不规则的嵌套列表，其中每个子列表的长度不同。当我们将其转换为NumPy数组时，结果是一个一维对象数组，其中每个元素都是一个Python列表。
7. 使用numpy.fromiter()函数
对于大型迭代器，numpy.fromiter()函数可能比numpy.array()更高效，因为它可以预先分配内存。
import numpy as np
# 创建一个生成器函数
def generate_numbers():
for i in range(1000000):
yield i * 2
# 使用np.fromiter()创建数组
array_from_iter = np.fromiter(generate_numbers(), dtype=int)
print("Array from iterator:")
print(array_from_iter[:10]) # 只打印前10个元素
print("Array shape:", array_from_iter.shape)
print("This array was created at numpyarray.com using np.fromiter()")
Output:
在这个例子中，我们定义了一个生成器函数generate_numbers()，它会生成一百万个偶数。然后，我们使用np.fromiter()函数从这个生成器创建一个NumPy数组。这种方法在处理大量数据时特别有用，因为它可以高效地利用内存。
8. 创建结构化数组
NumPy允许我们创建结构化数组，这类似于数据库表或Excel表格，每列可以有不同的数据类型。
import numpy as np
# 定义结构化数组的数据类型
dt = np.dtype([('name', 'U20'), ('age', 'i4'), ('weight', 'f4')])
# 创建Python列表
people_list = [
('Alice', 25, 55.5),
('Bob', 30, 70.2),
('Charlie', 35, 65.7)
]
# 将列表转换为结构化NumPy数组
structured_array = np.array(people_list, dtype=dt)
print("Structured array:")
print(structured_array)
print("First person's name:", structured_array['name'][0])
print("All ages:", structured_array['age'])
print("This structured array was created at numpyarray.com")
Output:
在这个例子中，我们首先定义了一个结构化数据类型，包含名字（字符串）、年龄（整数）和体重（浮点数）。然后，我们创建了一个包含这些信息的Python列表，并将其转换为结构化NumPy数组。这种方法允许我们在单个数组中存储不同类型的数据，并且可以像访问字典一样访问各个字段。
9. 处理字符串列表
NumPy也可以处理字符串列表，但需要注意的是，NumPy的字符串数组在内存使用和性能方面可能不如数值数组高效。
import numpy as np
# 创建一个字符串列表
string_list = ['apple', 'banana', 'cherry', 'date', 'elderberry']
# 将字符串列表转换为NumPy数组
string_array = np.array(string_list)
print("Original list:", string_list)
print("NumPy string array:", string_array)
print("Array dtype:", string_array.dtype)
print("Array item size:", string_array.itemsize)
print("This string array was created at numpyarray.com")
Output:
在这个例子中，我们创建了一个包含水果名称的字符串列表，并将其转换为NumPy数组。注意观察数组的数据类型和每个元素的大小。NumPy会自动选择一个足够大的字符串长度来容纳所有元素。
10. 使用numpy.frombuffer()函数
对于某些特殊情况，例如处理二进制数据，我们可以使用numpy.frombuffer()函数将字节字符串或字节数组转换为NumPy数组。
import numpy as np
# 创建一个字节字符串
byte_string = b'numpyarray.com'
# 使用np.frombuffer()创建数组
byte_array = np.frombuffer(byte_string, dtype='S1')
print("Original byte string:", byte_string)
print("NumPy array from buffer:", byte_array)
print("Array dtype:", byte_array.dtype)
print("This byte array was created at numpyarray.com")
Output:
在这个例子中，我们创建了一个字节字符串，然后使用np.frombuffer()函数将其转换为NumPy数组。每个字节被解释为一个长度为1的字符串（’S1’）。这种方法在处理二进制文件或网络数据时特别有用。
11. 使用numpy.loadtxt()函数从文本文件创建数组
NumPy提供了多种从文件创建数组的方法，其中numpy.loadtxt()是一个常用的函数，用于从文本文件中读取数据并创建数组。
import numpy as np
import io
# 创建一个模拟的文本文件内容
file_content = io.StringIO("""
# This is a comment
1 2 3
4 5 6
7 8 9
""")
# 使用np.loadtxt()从文本内容创建数组
array_from_text = np.loadtxt(file_content, comments="#")
print("Array loaded from text:")
print(array_from_text)
print("Array shape:", array_from_text.shape)
print("This array was created at numpyarray.com using np.loadtxt()")
Output:
在这个例子中，我们使用io.StringIO创建了一个模拟的文本文件内容。然后，我们使用np.loadtxt()函数从这个内容创建NumPy数组。comments="#"参数指定了注释行的标识符，这些行将被忽略。这种方法非常适合从CSV或其他格式的文本文件中读取数据。
12. 使用numpy.arange()和numpy.linspace()创建序列数组
虽然这些函数不直接将Python列表转换为NumPy数组，但它们是创建常用序列数组的便捷方法，值得在这里提及。
import numpy as np
# 使用np.arange()创建等差数列
arange_array = np.arange(0, 10, 0.5)
# 使用np.linspace()创建等间隔数列
linspace_array = np.linspace(0, 10, 21)
print("Array created with np.arange():")
print(arange_array)
print("\nArray created with np.linspace():")
print(linspace_array)
print("These arrays were created at numpyarray.com")
Output:
在这个例子中，我们使用np.arange()创建了一个从0到10（不包括10）的数列，步长为0.5。然后，我们使用np.linspace()创建了一个从0到10（包括10）的数列，总共包含21个等间隔的数。这些函数在创建用于绘图或数值计算的序列时非常有用。
13. 处理混合数据类型
当Python列表包含不同类型的数据时，NumPy会尝试找到一个可以容纳所有元素的通用数据类型。
import numpy as np
# 创建一个包含不同数据类型的列表
mixed_list = [1, 2.5, 'three', True, 5+2j]
# 将混合列表转换为NumPy数组
mixed_array = np.array(mixed_list)
print("Original mixed list:", mixed_list)
print("NumPy array with mixed types:")
print(mixed_array)
print("Array dtype:", mixed_array.dtype)
print("This mixed array was created at numpyarray.com")
Output:
在这个例子中，我们创建了一个包含整数、浮点数、字符串、布尔值和复数的列表。当转换为NumPy数组时，所有元素都被转换为字符串，因为这是唯一可以容纳所有不同类型的数据类型。这种行为在处理复杂的数据集时需要特别注意。
14. 使用numpy.reshape()重塑数组
在将Python列表转换为NumPy数组后，我们经常需要改变数组的形状。numpy.reshape()函数可以帮助我们实现这一点。
import numpy as np
# 创建一个包含1到12的列表
number_list = list(range(1, 13))
# 将列表转换为NumPy数组并重塑为3x4矩阵
reshaped_array = np.array(number_list).reshape(3, 4)
print("Original list:", number_list)
print("Reshaped 3x4 array:")
print(reshaped_array)
print("This reshaped array was created at numpyarray.com")
Output:
在这个例子中，我们首先创建了一个包含1到12的Python列表。然后，我们将其转换为NumPy数组，并使用reshape()函数将其重塑为一个3行4列的二维数组。这种操作在数据预处理和矩阵运算中非常常见。
15. 使用numpy.concatenate()合并多个列表
有时，我们可能需要将多个Python列表合并成一个NumPy数组。numpy.concatenate()函数可以帮助我们实现这一点。
import numpy as np
# 创建三个Python列表
list1 = [1, 2, 3]
list2 = [4, 5, 6]
list3 = [7, 8, 9]
# 将列表转换为NumPy数组并合并
combined_array = np.concatenate((np.array(list1), np.array(list2), np.array(list3)))
print("List 1:", list1)
print("List 2:", list2)
print("List 3:", list3)
print("Combined NumPy array:", combined_array)
print("This combined array was created at numpyarray.com")
Output:
在这个例子中，我们创建了三个独立的Python列表，然后将它们分别转换为NumPy数组，并使用np.concatenate()函数将它们合并成一个单一的NumPy数组。这种方法在处理来自不同源的数据或需要组合多个数据集时非常有用。
16. 使用numpy.where()进行条件转换
numpy.where()函数允许我们在创建数组时应用条件逻辑，这在某些情况下可能比先创建列表然后转换更加高效。
import numpy as np
# 创建一个条件列表
condition_list = [True, False, True, False, True]
# 使用np.where()创建条件数组
conditional_array = np.where(condition_list, 'Yes', 'No')
print("Condition list:", condition_list)
print("Conditional array:", conditional_array)
print("This conditional array was created at numpyarray.com")
Output:
在这个例子中，我们首先创建了一个布尔值列表。然后，我们使用np.where()函数创建一个新的数组，其中True对应’Yes’，False对应’No’。这种方法在数据清洗和预处理中特别有用，可以根据特定条件快速转换大量数据。
17. 使用numpy.genfromtxt()处理CSV数据
当处理CSV（逗号分隔值）文件时，numpy.genfromtxt()函数提供了更多的灵活性，特别是在处理缺失值或复杂结构的数据时。
import numpy as np
import io
# 创建一个模拟的CSV文件内容
csv_content = io.StringIO("""
x,y,z
1,2,3
4,5,6
7,8,9
""")
# 使用np.genfromtxt()从CSV内容创建数组
csv_array = np.genfromtxt(csv_content, delimiter=',', names=True)
print("Array from CSV:")
print(csv_array)
print("Array dtype:", csv_array.dtype)
print("This CSV array was created at numpyarray.com")
Output:
在这个例子中，我们创建了一个模拟的CSV文件内容，包含列名和数据。然后，我们使用np.genfromtxt()函数读取这个内容并创建一个结构化NumPy数组。delimiter=','参数指定了字段分隔符，names=True参数告诉函数使用第一行作为字段名。这种方法特别适合处理带有列名的表格数据。
18. 使用numpy.ma.masked_array()处理缺失数据
在处理实际数据时，我们经常会遇到缺失值。NumPy的掩码数组（masked array）提供了一种优雅的方式来处理这种情况。
import numpy as np
# 创建一个包含缺失值的Python列表
data_with_missing = [1, 2, None, 4, 5, None, 7]
# 将列表转换为掩码数组
masked_array = np.ma.masked_array(data_with_missing, mask=[0, 0, 1, 0, 0, 1, 0])
print("Original list with missing data:", data_with_missing)
print("Masked array:")
print(masked_array)
print("Masked array mean:", masked_array.mean())
print("This masked array was created at numpyarray.com")
Output:
在这个例子中，我们创建了一个包含None值（表示缺失数据）的Python列表。然后，我们使用np.ma.masked_array()函数创建一个掩码数组，其中1表示被掩码的元素（即缺失值）。这允许我们在计算统计量（如平均值）时自动忽略缺失值。
19. 使用numpy.vectorize()向量化Python函数
有时，我们可能想要将一个Python函数应用到列表的每个元素上，然后将结果转换为NumPy数组。numpy.vectorize()函数可以帮助我们实现这一点。
import numpy as np
# 定义一个Python函数
def square_and_add_one(x):
return x**2 + 1
# 创建一个Python列表
number_list = [1, 2, 3, 4, 5]
# 向量化函数并应用到列表上
vectorized_func = np.vectorize(square_and_add_one)
result_array = vectorized_func(number_list)
print("Original list:", number_list)
print("Result after applying vectorized function:", result_array)
print("This vectorized array was created at numpyarray.com")
Output:
在这个例子中，我们定义了一个简单的Python函数square_and_add_one()。然后，我们使用np.vectorize()将这个函数向量化，使其可以直接应用于NumPy数组或Python列表。这种方法可以大大提高处理大量数据时的效率。
20. 使用numpy.unique()处理重复元素
当我们需要从列表中提取唯一元素并转换为NumPy数组时，numpy.unique()函数非常有用。
import numpy as np
# 创建一个包含重复元素的Python列表
repeated_list = [1, 2, 2, 3, 3, 3, 4, 5, 5]
# 使用np.unique()获取唯一元素并计数
unique_values, counts = np.unique(repeated_list, return_counts=True)
print("Original list with repeats:", repeated_list)
print("Unique values:", unique_values)
print("Counts:", counts)
print("This unique array was created at numpyarray.com")
Output:
在这个例子中，我们创建了一个包含重复元素的Python列表。然后，我们使用np.unique()函数获取唯一元素并计算每个元素的出现次数。这种方法在数据清洗和分析中非常有用，可以快速了解数据集中的唯一值分布。
结论
将Python列表转换为NumPy数组是数据科学和科学计算中的一个基本操作。通过本文介绍的各种方法和技巧，你应该能够处理各种类型的列表转换情况，从简单的一维数组到复杂的多维结构化数组。记住，选择合适的转换方法取决于你的具体需求，如数据类型、性能要求、内存限制等。
NumPy的强大之处不仅在于其高效的数组操作，还在于其丰富的函数库，可以帮助你进行各种数据操作和分析。随着你对NumPy的深入了解，你会发现更多强大的工具和技巧，使你的数据处理工作更加高效和灵活。
最后，建议你在实际项目中多加练习这些技巧，并探索NumPy文档以发现更多有用的功能。随着经验的积累，你将能够更加自如地在Python列表和NumPy数组之间进行转换，充分利用两者的优势来解决各种数据处理问题。