NumPy数组创建方法多样，适用于不同场景：1. np.array()可将列表或元组转换为数组，支持指定数据类型，自动进行类型向上转型；2. np.zeros()、np.ones()、np.empty()和np.full()用于创建特定填充值的数组，其中np.empty()不初始化内存，性能更高但需谨慎使用；3. np.arange()和np.linspace()分别生成等差数列和均匀分布数值，适合数值序列构建；4. np.random模块函数可创建各种随机分布的多维数组，常用于模拟和模型初始化。多维数组可通过嵌套列表、reshape()或直接指定形状创建，shape参数定义各维度大小。常见陷阱包括dtype隐式转换、np.empty()未初始化数据误用、reshape元素数不匹配及大数组内存溢出，建议显式指定dtype、合理选择初始化函数、利用-1自动计算维度并注意内存管理。
在Python中创建NumPy数组，我们通常会借助
numpy
库提供的多种便捷函数。最直接的方式是利用现有的Python列表或元组进行转换，而更高效或特定用途的场景，则会用到像
np.zeros()
,
np.ones()
,
np.arange()
，甚至是
np.random
模块中的函数来直接生成。选择哪种方法，往往取决于你数据的来源、期望的形状以及初始化的需求。
解决方案
创建NumPy数组的方法多种多样，每种都有其独特的适用场景。这里我将分享几种我个人最常用且认为效率最高的几种：
1. 从Python列表或元组创建：
np.array()
这是最基础也最直观的方式。如果你手头已经有了一些数据，比如一个列表或嵌套列表，想把它转换成NumPy数组，
np.array()
就是你的首选。
立即学习“Python免费学习笔记（深入）”；
import numpy as np# 从一维列表创建list_data = [1, 2, 3, 4, 5]arr_1d = np.array(list_data)print(f"一维数组: {arr_1d}")# 输出: 一维数组: [1 2 3 4 5]# 从嵌套列表创建二维数组nested_list_data = [[1, 2, 3], [4, 5, 6]]arr_2d = np.array(nested_list_data)print(f"二维数组:n{arr_2d}")# 输出:# 二维数组:# [[1 2 3]# [4 5 6]]# 你也可以指定数据类型，这在处理特定精度要求时很有用arr_float = np.array([1, 2, 3], dtype=float)print(f"指定浮点类型的数组: {arr_float}")# 输出: 指定浮点类型的数组: [1. 2. 3.]
我个人觉得，
np.array()
的便利性在于它的“万能”，几乎任何序列类型的数据都能往里扔，NumPy会尽力帮你转换。但要注意，如果序列中的元素类型不一致，NumPy会向上转型（upcasting），比如整数和浮点数混在一起，最终数组会是浮点型。
2. 使用占位符函数创建：
np.zeros()
,
np.ones()
,
np.empty()
,
np.full()
这些函数在你需要一个特定形状的数组，并且想用特定值（0、1、空值或自定义值）填充时非常有用。
np.zeros(shape, dtype=float)
: 创建一个指定形状和数据类型的全零数组。
np.ones(shape, dtype=float)
: 创建一个指定形状和数据类型的全一数组。
np.empty(shape, dtype=float)
: 创建一个指定形状和数据类型的空数组。这里的“空”意味着数组中的值是未初始化的，它们可能是内存中残留的随机值。这在需要高性能、且你知道后续会立即填充所有值时非常有用，因为它省去了初始化的开销。
np.full(shape, fill_value, dtype=None)
: 创建一个指定形状，并用
fill_value
填充的数组。
# 创建一个3x4的全零数组zeros_arr = np.zeros((3, 4))print(f"全零数组:n{zeros_arr}")# 创建一个2x2x2的全一整型数组ones_arr = np.ones((2, 2, 2), dtype=int)print(f"全一整型数组:n{ones_arr}")# 创建一个2x3的空数组 (内容是随机的)empty_arr = np.empty((2, 3))print(f"空数组 (内容随机):n{empty_arr}") # 每次运行结果可能不同# 创建一个2x2的数组，全部填充为7full_arr = np.full((2, 2), 7)print(f"填充为7的数组:n{full_arr}")
np.empty()
这个函数我个人觉得有点意思，它不像
zeros
或
ones
那么“干净”，它只是给你一块内存，里面有什么完全是随机的，所以用起来得格外小心。但正是这种“不负责任”，让它在需要极致性能、且你知道后续会立即覆盖所有值的场景下显得特别有用。
3. 使用序列生成函数：
np.arange()
,
np.linspace()
当你需要生成一个等差数列或者在指定范围内均匀分布的数值时，这两个函数非常方便。
np.arange(start, stop, step, dtype=None)
: 返回一个在半开区间
[start, stop)
内，以
step
为步长，生成等差数列的数组。
np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
: 返回在指定区间
[start, stop]
内，均匀分布的
num
个样本。
# 生成从0到9的数组 (不包含10)range_arr = np.arange(10)print(f"arange生成: {range_arr}")# 输出: arange生成: [0 1 2 3 4 5 6 7 8 9]# 生成从1到10，步长为2的数组step_arr = np.arange(1, 11, 2)print(f"arange带步长: {step_arr}")# 输出: arange带步长: [1 3 5 7 9]# 生成从0到10之间，包含10个点的均匀分布数组linspace_arr = np.linspace(0, 10, 10)print(f"linspace生成: {linspace_arr}")# 输出: linspace生成: [ 0. 1.11111111 2.22222222 3.33333333 4.44444444 5.55555556# 6.66666667 7.77777778 8.88888889 10. ]
linspace
在科学计算和绘图时尤其好用，比如你想在某个区间内采样函数值，它能保证采样点均匀分布，省去了手动计算步长的麻烦。
4. 随机数数组：
np.random
模块
NumPy的
np.random
模块提供了各种创建随机数数组的函数，这在模拟、机器学习模型初始化等场景下非常重要。
# 创建一个3x3的随机浮点数数组 (0到1之间均匀分布)random_uniform_arr = np.random.rand(3, 3)print(f"均匀分布随机数组:n{random_uniform_arr}")# 创建一个2x4的标准正态分布随机数数组 (均值为0，标准差为1)random_normal_arr = np.random.randn(2, 4)print(f"正态分布随机数组:n{random_normal_arr}")# 创建一个指定范围的随机整数数组 (low <= x < high)random_int_arr = np.random.randint(0, 10, size=(2, 5)) # 0到9之间的整数print(f"随机整数数组:n{random_int_arr}")
随机数的使用，我个人觉得需要注意
seed
的设置，尤其是在需要结果可复现的实验中。
np.random.seed(42)
这样的操作，能保证每次运行代码，生成的随机数序列都是一样的，这对于调试和论文复现至关重要。
NumPy数组与Python列表：性能与用途的深度解析
当我们谈论Python中的数据结构，NumPy数组和Python列表是两个绕不开的话题，尤其是在数值计算领域。它们都能存储数据，但底层实现和设计哲学却大相径庭，这直接影响了它们的性能和最佳使用场景。我个人在初学NumPy时，也曾纠结过什么时候该用列表，什么时候该用数组，后来才慢慢体会到它们各自的“脾气”。
首先，最核心的区别在于数据存储。Python列表是一个高度灵活的容器，它可以存储不同类型的数据（整数、浮点数、字符串甚至是其他对象），并且在内存中这些元素可能分散存储，列表只存储指向这些元素的指针。这种灵活性是以牺牲性能为代价的。每次访问或操作元素，Python都需要进行类型检查和指针解引用。
而NumPy数组，则追求的是同质性和紧凑性。它要求所有元素都具有相同的数据类型（例如，全部是32位整数或64位浮点数），并且在内存中是连续存储的。这种连续存储带来了巨大的优势：
内存效率：由于所有元素类型相同且连续，NumPy数组不需要存储每个元素的类型信息，也不需要存储指向分散内存地址的指针，大大减少了内存开销。计算性能：连续存储允许CPU的缓存机制高效工作，减少了缓存未命中的情况。更重要的是，NumPy的底层操作很多是用C或Fortran等编译型语言实现的，这些高度优化的代码可以进行向量化操作。这意味着，对整个数组进行某种操作（比如所有元素加1），NumPy可以一次性处理多个数据，而Python列表则需要通过循环逐个处理，效率低下。
举个例子，如果你要对两个包含一百万个数字的列表进行逐元素相加，Python列表可能需要几秒钟，而NumPy数组可能只需几毫秒。这种量级的差异在处理大数据时是决定性的。
用途方面：
Python列表：适用于存储异构数据、需要频繁添加/删除元素（动态大小）、或者数据量不大且对性能要求不高的场景。比如，你可能用列表来存储一个用户的个人信息（姓名、年龄、邮箱等不同类型的数据），或者作为队列、栈等数据结构的底层实现。NumPy数组：是数值计算、科学计算、机器学习和数据分析的基石。它适用于存储同构的数值数据，需要进行大量的数学运算（加减乘除、矩阵乘法、统计分析等）、线性代数操作、傅里叶变换等。在图像处理、信号处理、深度学习等领域，NumPy数组（通常是多维的）更是不可或缺。
我个人的经验是，只要是涉及到数值运算，尤其是当数据量开始变大时，第一时间就应该考虑NumPy数组。列表的灵活性固然好，但在性能面前，往往不得不让位给NumPy的“专一”和高效。
创建多维NumPy数组：从一维到高维的实践指南
NumPy数组的魅力之一就在于它能轻松处理多维数据，这在表示图像（2D）、视频（3D）、时间序列（1D或2D）甚至更复杂的张量数据时至关重要。从一维到高维，NumPy提供了一套直观的创建和操作方式。
1. 从嵌套Python列表创建：
np.array()
这是创建多维数组最直接的方法。通过提供嵌套的列表，NumPy会自动推断出数组的维度和形状。
import numpy as np# 创建一个2x3的二维数组two_d_array = np.array([[1, 2, 3], [4, 5, 6]])print(f"二维数组:n{two_d_array}")print(f"形状: {two_d_array.shape}") # (2, 3)# 创建一个2x2x3的三维数组three_d_array = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])print(f"三维数组:n{three_d_array}")print(f"形状: {three_d_array.shape}") # (2, 2, 3)
这种方式的优点是直观，但缺点是当维度和大小变大时，手动编写嵌套列表会变得非常繁琐且容易出错。我个人在使用这种方式时，一般只用于创建小型的、测试用的多维数组。
2. 使用占位符函数创建：
np.zeros()
,
np.ones()
,
np.empty()
,
np.full()
这些函数在创建多维数组时，只需要将形状参数
shape
传入一个元组，元组的每个元素代表对应维度的大小。
# 创建一个3x2的全零数组zeros_2d = np.zeros((3, 2))print(f"3x2全零数组:n{zeros_2d}")# 创建一个2x3x4的全一数组ones_3d = np.ones((2, 3, 4))print(f"2x3x4全一数组:n{ones_3d}")# 创建一个4x4的空数组empty_2d = np.empty((4, 4))print(f"4x4空数组:n{empty_2d}")# 创建一个2x2x2的数组，所有元素填充为pifull_3d = np.full((2, 2, 2), np.pi)print(f"填充pi的三维数组:n{full_3d}")
这种方式是我创建大型多维数组时最常用的。它简洁明了，只需要指定形状，NumPy就能帮你搞定内存分配和初始化。
3. 使用
np.arange()
结合
reshape()
np.arange()
通常用于生成一维等差数列，但结合
.reshape()
方法，可以非常灵活地创建各种形状的多维数组。
.reshape()
不会改变数组的数据，只是改变其视图。
# 生成0到11的序列，然后重塑为3x4的二维数组reshaped_arr = np.arange(12).reshape(3, 4)print(f"arange后重塑为3x4:n{reshaped_arr}")# 输出:# [[ 0 1 2 3]# [ 4 5 6 7]# [ 8 9 10 11]]# 重塑为2x2x3的三维数组reshaped_3d = np.arange(12).reshape(2, 2, 3)print(f"arange后重塑为2x2x3:n{reshaped_3d}")# 输出:# [[[ 0 1 2]# [ 3 4 5]]## [[ 6 7 8]# [ 9 10 11]]]
使用
reshape
时，需要确保新形状的元素总数与原始数组的元素总数一致。一个很有用的技巧是，可以在
reshape
中用
-1
来让NumPy自动计算某个维度的大小，只要其他维度是确定的。比如
np.arange(12).reshape(3, -1)
会自动计算出第二个维度是4。这个小技巧在处理不确定某个维度大小，但总元素数已知时，特别方便。
4. 随机数生成器的多维应用
np.random
模块中的函数也普遍支持多维形状参数。
# 创建一个2x3的0到1之间均匀分布的随机浮点数数组random_2d_uniform = np.random.rand(2, 3)print(f"2x3随机均匀分布数组:n{random_2d_uniform}")# 创建一个2x2x2的标准正态分布随机数数组random_3d_normal = np.random.randn(2, 2, 2)print(f"2x2x2随机正态分布数组:n{random_3d_normal}")# 创建一个3x3的0到9之间随机整数数组random_2d_int = np.random.randint(0, 10, size=(3, 3))print(f"3x3随机整数数组:n{random_2d_int}")
创建多维数组的核心在于理解
shape
元组的含义，它定义了数组在每个维度上的大小。一旦掌握了这一点，无论是从现有数据转换，还是从零开始创建，NumPy都能提供高效且灵活的解决方案。
NumPy数组创建中常见的陷阱与优化策略
在NumPy数组的创建和初始化过程中，虽然API设计得相当直观，但仍然存在一些常见的陷阱，尤其对于初学者而言。同时，为了确保代码的高效运行，我们也有一些优化策略可以遵循。我个人在处理一些大型数据集或者需要高性能计算的项目时，就曾因为这些细节而踩过坑，所以总结了一些经验。
常见的陷阱：
数据类型（
dtype
）的隐式转换或不匹配：当你从Python列表创建NumPy数组时，NumPy会尝试推断最佳的数据类型。如果列表中混合了不同类型（例如整数和浮点数），NumPy通常会向上转型到能容纳所有数据的类型（如从
int
到
float
）。但这有时可能不是你想要的，或者会导致意想不到的精度损失。
import numpy as np# 陷阱示例：整数和浮点数混合，导致全部变为浮点数mixed_list = [1, 2, 3.0]arr_mixed = np.array(mixed_list)print(f"混合类型推断: {arr_mixed}, dtype: {arr_mixed.dtype}") # float64# 陷阱示例：字符串和数字混合，导致全部变为字符串str_num_list = [1, 'hello']arr_str_num = np.array(str_num_list)print(f"字符串和数字混合: {arr_str_num}, dtype: {arr_str_num.dtype}") # <U21 (Unicode string)
策略： 始终明确指定
dtype
，特别是在数据类型敏感的场景。例如，
np.array([1, 2, 3], dtype=np.int32)
。
np.empty()
的使用不当：
np.empty()
用于创建未初始化的数组，它不会填充0或1，而是直接分配内存。这意味着数组中可能包含任何值（通常是内存中残留的旧数据）。如果你忘记在使用前对数组进行完全填充，可能会导致计算结果不准确或难以调试的错误。
# 陷阱示例：未初始化数组的值是随机的empty_arr = np.empty((2, 2))print(f"未初始化的empty数组:n{empty_arr}") # 值随机
策略： 只有当你确定会立即用自己的数据完全覆盖
np.empty()
创建的数组时才使用它，以获取性能优势。否则，优先使用
np.zeros()
或
np.ones()
。
reshape
时的元素总数不匹配：在使用
.reshape()
方法时，新形状的元素总数必须与原始数组的元素总数完全一致。如果不是，NumPy会抛出
ValueError
。
# 陷阱示例：元素总数不匹配try: np.arange(10).reshape(3, 3) # 10个元素无法重塑为3x3 (9个元素)except ValueError as e: print(f"重塑错误: {e}")
策略： 在
reshape
时，仔细检查新旧形状的元素总数是否一致。利用
-1
参数让NumPy自动计算一个维度的大小是一个很好的辅助方法。
创建大型数组时的内存考量：虽然NumPy很高效，但创建非常大的数组（例如，几GB甚至几十GB）仍然可能导致内存不足（
MemoryError
）。
策略： 在创建大型数组前，估算所需的内存量。如果内存是瓶颈，考虑使用稀疏矩阵（
scipy.sparse
）或者分块处理（chunking）数据，而不是一次性加载所有数据。
优化策略：
优先使用NumPy内置函数和向量化操作：这是NumPy性能优化的核心。避免使用Python的
for
循环来处理数组元素，因为这会丧失NumPy的性能优势。尽可能使用NumPy提供的函数和运算符，它们都是经过高度优化的C/Fortran实现。
# 避免：使用
以上就是Python怎么创建一个NumPy数组_NumPy数组的创建与初始化的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/1371622.html
微信扫一扫 
支付宝扫一扫 
![Go语言接口与切片：如何识别和操作[]interface{}](https://cdn.chuangxiangniao.com/www/2025/12/176369856569294-1.jpg?imageMogr2/crop/480x300/gravity/center)
