python中如何使用numpy创建数组_Numpy创建数组(array)基础教程（数组.创建.如何使用.基础教程.array...）

wufei123 发布于 2025-09-17 阅读（10）
NumPy提供多种创建数组的方法，包括从列表转换、生成特定值数组及指定形状和数据类型。1. 使用np.array()将列表或元组转为数组，并可指定dtype；2. np.zeros()和np.ones()创建全0或全1数组；3. np.empty()创建未初始化的空数组以提升性能；4. np.arange()生成等步长数组，np.linspace()生成等间隔数值；5. np.full()用指定值填充数组；6. 多维数组可通过嵌套列表或reshape()构建；7. 高级方法如np.eye()创建单位矩阵，适用于线性代数运算。选择合适方法能优化内存与计算效率。

python中如何使用numpy创建数组_numpy创建数组(array)基础教程

在Python中，使用NumPy创建数组是进行科学计算和数据分析的基础，它提供了多种高效的方法来初始化和构建数组。最直接的方式是利用

numpy.array()
函数将Python列表或元组转换为NumPy数组，此外，还可以通过
numpy.zeros()
、
numpy.ones()
、
numpy.arange()
、
numpy.linspace()
等函数根据特定的形状和值快速生成数组，从而满足不同的数据初始化需求。 解决方案

NumPy作为Python科学计算的核心库，其数组（

ndarray
）是处理大量数值数据的基石。创建这些数组的方式多种多样，每种都适用于不同的场景。

1. 从Python列表或元组创建数组：

np.array()
这是最常用也最直观的方法。你可以将一个普通的Python列表（或嵌套列表）传递给
np.array()
来创建一个NumPy数组。
import numpy as np

# 创建一维数组
list_1d = [1, 2, 3, 4, 5]
arr_1d = np.array(list_1d)
print("一维数组:", arr_1d)
print("类型:", type(arr_1d))

# 创建二维数组 (从嵌套列表)
list_2d = [[1, 2, 3], [4, 5, 6]]
arr_2d = np.array(list_2d)
print("\n二维数组:\n", arr_2d)

# 指定数据类型 (dtype)
arr_float = np.array([1, 2, 3], dtype=float)
print("\n指定float类型的数组:", arr_float)

arr_int8 = np.array([100, 200, 50], dtype=np.int8)
print("指定int8类型的数组:", arr_int8)

这里有个小细节，如果你不指定

dtype
，NumPy会根据输入数据自动推断一个最合适的数据类型。但有时候，为了内存效率或者确保精度，手动指定
dtype
是非常有必要的。

2. 创建全零数组：

np.zeros()
当你需要一个特定形状的数组，并希望所有元素都初始化为零时，
np.zeros()
是你的首选。
# 创建一个3x4的全零数组
zeros_arr = np.zeros((3, 4))
print("\n全零数组 (3x4):\n", zeros_arr)

# 创建一个一维的全零数组，并指定数据类型
zeros_int = np.zeros(5, dtype=int)
print("全零整数数组 (1x5):", zeros_int)

3. 创建全壹数组：

np.ones()
与
np.zeros()
类似，
np.ones()
用于创建所有元素都是1的数组。
# 创建一个2x3的全壹数组
ones_arr = np.ones((2, 3))
print("\n全壹数组 (2x3):\n", ones_arr)

# 创建一个三维全壹数组
ones_3d = np.ones((2, 2, 2), dtype=np.float32)
print("三维全壹数组:\n", ones_3d)

4. 创建空数组：

np.empty()
np.empty()
会创建一个给定形状和数据类型的新数组，但不初始化其元素。这意味着数组中的值是内存中当前存在的任意值，可能看起来是随机的。这种方法比
np.zeros()
或
np.ones()
稍快，因为它不需要填充值。
# 创建一个2x2的空数组
empty_arr = np.empty((2, 2))
print("\n空数组 (2x2):\n", empty_arr) # 注意：输出的值是未初始化的，每次运行可能不同

在我看来，

np.empty()
在需要一个占位符，然后立即用其他计算结果填充数组的场景下特别有用，可以避免不必要的初始化开销。

5. 创建指定范围的数组：

np.arange()
np.arange()
类似于Python内置的
range()
函数，但它返回的是一个NumPy数组。
# 从0到9的数组
arr_range = np.arange(10)
print("\narange(10):", arr_range)

# 从5到15，步长为2的数组
arr_step = np.arange(5, 16, 2)
print("arange(5, 16, 2):", arr_step)

6. 创建等间隔数组：

np.linspace()
np.linspace()
用于在指定区间内创建指定数量的均匀分布的数值。
# 在0到10之间生成5个等间隔的数
arr_linspace = np.linspace(0, 10, 5)
print("\nlinspace(0, 10, 5):", arr_linspace)

# 默认包含终点，可以通过endpoint=False排除
arr_linspace_no_end = np.linspace(0, 10, 5, endpoint=False)
print("linspace(0, 10, 5, endpoint=False):", arr_linspace_no_end)

linspace
在绘制函数图像、模拟物理过程时非常方便，因为它能保证数据的均匀分布。

7. 创建填充指定值的数组：

np.full()
如果你想用一个特定的常数值填充整个数组，
np.full()
是最佳选择。
# 创建一个3x3的数组，所有元素都为7
full_arr = np.full((3, 3), 7)
print("\n全7数组 (3x3):\n", full_arr)

# 创建一个一维数组，所有元素都为True
full_bool = np.full(4, True, dtype=bool)
print("全True布尔数组:", full_bool)
NumPy数组与Python列表有何本质区别，为何选择NumPy？

我刚开始用Python处理数据时，也觉得列表挺好用，直到数据量一大，才体会到NumPy的“真香”定律。NumPy数组和Python列表在表面上看起来都能存储一系列数据，但它们在底层实现、性能、内存使用以及功能上有着天壤之别。

本质区别：

  1. 数据类型统一性： NumPy数组要求所有元素都是同一数据类型（例如，全部是整数，或全部是浮点数）。这使得NumPy在内存中能以连续、紧凑的方式存储数据，从而实现高效的存取和计算。而Python列表可以存储不同类型的对象，它实际上存储的是指向这些对象的指针，而不是对象本身。
  2. 内存连续性： NumPy数组在内存中是连续存储的，这对于CPU缓存优化和矢量化操作至关重要。Python列表的元素则可能分散在内存各处。
  3. 性能： NumPy的底层是用C语言实现的，针对数值计算进行了高度优化。它支持矢量化操作，这意味着你可以在整个数组上执行操作，而无需编写显式的Python循环。Python列表的循环操作则是在解释器层面执行，效率远低于NumPy。
  4. 功能性： NumPy提供了大量的数学函数和线性代数操作，这些都是针对数组设计的，可以直接应用于整个数组，而无需手动遍历。Python列表虽然也有一些方法，但远不及NumPy在数值计算方面的丰富和高效。

为何选择NumPy：

  • 效率与速度： 当你处理百万甚至上亿级别的数据时，NumPy的矢量化操作和C语言底层实现能带来数量级的性能提升。我记得有一次需要对一个大矩阵进行元素级乘法，用Python列表循环了几分钟，换成NumPy一行代码瞬间完成，那感觉真是震撼。
  • 内存优化： 统一的数据类型和连续的内存布局使得NumPy数组比同等数据量的Python列表占用更少的内存。这对于内存受限的环境尤其重要。
  • 强大的数学工具： NumPy是科学计算的基石，它提供了丰富的数学函数、傅里叶变换、随机数生成、线性代数等功能。这些功能让数据分析、机器学习和科学建模变得更加简单高效。
  • 生态系统集成： 几乎所有Python数据科学库（如Pandas、SciPy、Matplotlib、Scikit-learn）都以NumPy数组作为其核心数据结构，学习NumPy是进入这些领域的必经之路。

简单来说，如果你只是需要一个通用容器来存储不同类型的少量数据，Python列表足够了。但一旦涉及到数值计算、大数据处理或者需要高性能的场景，NumPy数组几乎是唯一的、也是最佳的选择。

创建不同维度（一维、二维、三维）的NumPy数组有哪些实用技巧？

刚接触多维数组时，脑子里总有点打结，但多练几次，就会发现其实就是列表的嵌套。NumPy数组的维度（

ndim
）和形状（
shape
）是理解其结构的关键。 Post AI Post AI

博客文章AI生成器

Post AI50 查看详情 Post AI

1. 创建一维数组： 一维数组是最简单的形式，可以看作是数学中的向量。

  • 从Python列表： 直接传入一个非嵌套的列表。
    import numpy as np
vec = np.array([10, 20, 30, 40])
print("一维数组:\n", vec)
print("维度 (ndim):", vec.ndim) # 输出: 1
print("形状 (shape):", vec.shape) # 输出: (4,)
  • 使用
    np.arange()
    或
    np.linspace()
    ： 这些函数默认创建的就是一维数组。
    vec_range = np.arange(5)
print("\narange创建的一维数组:", vec_range)

2. 创建二维数组： 二维数组可以理解为数学中的矩阵，它是由行和列组成的。

  • 从嵌套列表： 传入一个包含等长列表的列表。每个内部列表代表矩阵的一行。
    matrix = np.array([[1, 2, 3],
                   [4, 5, 6],
                   [7, 8, 9]])
print("\n二维数组 (矩阵):\n", matrix)
print("维度 (ndim):", matrix.ndim) # 输出: 2
print("形状 (shape):", matrix.shape) # 输出: (3, 3)

    这里，

    shape
    是
    (3, 3)
    ，表示3行3列。
  • 使用
    np.zeros()
    , 
    np.ones()
    , 
    np.full()
    等： 传入一个表示形状的元组，如
    (rows, cols)
    。
    zeros_2d = np.zeros((2, 5)) # 2行5列的全零矩阵
print("\n2x5全零数组:\n", zeros_2d)
  • reshape()
    函数： 可以将一维数组重新塑形为二维数组。这是一个非常灵活的技巧。
    arr_1d_large = np.arange(12) # 0到11的一维数组
arr_2d_reshaped = arr_1d_large.reshape(3, 4) # 重新塑形为3行4列
print("\n通过reshape创建的二维数组:\n", arr_2d_reshaped)

    reshape
    操作非常强大，只要总元素数量匹配，你就可以随意改变数组的形状。使用
    -1
    作为
    reshape
    的一个维度参数，NumPy会自动计算该维度的大小，这在处理不确定行数或列数时非常方便。比如
    arr.reshape(-1, 4)
    表示“让它有4列，行数你来算”。

3. 创建三维数组： 三维数组可以想象成多个二维矩阵堆叠在一起，或者是一个立方体，每个维度代表一个轴（深度、行、列）。

  • 从嵌套列表： 传入一个包含嵌套列表的列表，最外层列表包含多个二维数组结构。
    tensor = np.array([[[1, 2], [3, 4]],
                   [[5, 6], [7, 8]],
                   [[9, 10], [11, 12]]])
print("\n三维数组 (张量):\n", tensor)
print("维度 (ndim):", tensor.ndim) # 输出: 3
print("形状 (shape):", tensor.shape) # 输出: (3, 2, 2)

    这里的

    shape
    是
    (3, 2, 2)
    ，表示有3个“层”（或深度），每层是2行2列的矩阵。
  • 使用
    np.zeros()
    , 
    np.ones()
    , 
    np.full()
    等： 传入一个三元组作为形状参数，如
    (depth, rows, cols)
    。
    ones_3d = np.ones((2, 3, 4)) # 2个3行4列的矩阵
print("\n2x3x4全壹三维数组:\n", ones_3d)
  • reshape()
    函数： 同样可以将一维或二维数组重新塑形为三维。
    arr_1d_large_24 = np.arange(24) # 0到23的一维数组
arr_3d_reshaped = arr_1d_large_24.reshape(2, 3, 4) # 重新塑形为2个3行4列的矩阵
print("\n通过reshape创建的三维数组:\n", arr_3d_reshaped)

掌握这些技巧后，无论数据以何种形式呈现，你都能灵活地将其组织成NumPy数组，为后续的计算和分析打下坚实基础。

如何在创建NumPy数组时指定数据类型（dtype）？这对性能和内存有何影响？

数据类型这东西，一开始可能觉得没那么重要，但当你处理大量图像像素或者金融数据时，一个合适的

dtype
能帮你省下不少麻烦，无论是内存还是计算精度。在创建NumPy数组时，通过
dtype
参数明确指定数据类型是一个非常好的习惯。

如何指定数据类型： 几乎所有的数组创建函数，如

np.array()
, 
np.zeros()
, 
np.ones()
, 
np.empty()
, 
np.full()
等，都接受一个
dtype
参数。你可以传入Python内置类型（如
int
, 
float
, 
bool
）或者NumPy特有的数据类型对象（如
np.int8
, 
np.float32
, 
np.complex64
）。
import numpy as np

# 使用Python内置类型
arr_int = np.array([1, 2, 3], dtype=int)
arr_float = np.array([1.0, 2.5, 3.7], dtype=float)
arr_bool = np.array([0, 1, 0], dtype=bool) # 0会被转为False，非0转为True
print("int数组:", arr_int, arr_int.dtype)
print("float数组:", arr_float, arr_float.dtype)
print("bool数组:", arr_bool, arr_bool.dtype)

# 使用NumPy特有类型
arr_int8 = np.array([10, 20, 30], dtype=np.int8) # 8位带符号整数，范围-128到127
arr_uint16 = np.zeros(5, dtype=np.uint16) # 16位无符号整数，范围0到65535
arr_float32 = np.ones((2,2), dtype=np.float32) # 32位浮点数
arr_complex = np.array([1+2j, 3+4j], dtype=np.complex64) # 64位复数 (32位实部+32位虚部)
print("\nint8数组:", arr_int8, arr_int8.dtype)
print("uint16数组:", arr_uint16, arr_uint16.dtype)
print("float32数组:\n", arr_float32, arr_float32.dtype)
print("complex64数组:", arr_complex, arr_complex.dtype)

NumPy提供了非常丰富的数据类型，从布尔值到各种位宽的整数（

int8
, 
int16
, 
int32
, 
int64
, 
uint8
等）、浮点数（
float16
, 
float32
, 
float64
, 
float128
）、复数（
complex64
, 
complex128
），甚至还有字符串和自定义结构体。

对性能和内存的影响：

  1. 内存使用：

    • 显著影响： 这是
      dtype
      最直接的影响。一个
      np.int8
      类型的数组，每个元素只占用1字节内存；而
      np.int64
      则占用8字节。对于包含数百万甚至数十亿元素的数组，这种差异会带来巨大的内存消耗差距。
    • 例子： 假设你有一个包含1亿个整数的数组，如果所有整数都在0-255之间，使用
      np.uint8
      只需要100MB内存。但如果默认使用
      np.int64
      （在64位系统上通常是Python整数的默认转换），则需要800MB内存。这对于内存受限的系统或者需要处理超大数据集时，是决定性的。
    • 避免浪费： 明确指定最小且足够的数据类型可以有效减少内存占用，这在嵌入式系统、移动设备或云服务器上都是非常重要的优化手段。

  2. 计算性能：

    • 处理器效率： 现代CPU通常对特定位宽的数据类型（如32位或64位整数/浮点数）有优化指令集。使用与CPU架构匹配的数据类型，可以加速计算。
    • 缓存命中率： 内存占用越小，相同大小的缓存能容纳更多的数据。这意味着CPU在进行计算时，更有可能从高速缓存中获取数据，而不是从较慢的主内存中读取，从而提高计算速度。
    • 精度与溢出：
      • 精度： 浮点数的精度（
        float32
        vs 
        float64
        ）会影响计算结果的准确性。
        float64
        提供更高的精度，但占用更多内存和计算资源。在科学计算中，通常默认使用
        float64
        以保证精度，但在深度学习等领域，
        float32
        甚至
        float16
        已足够，且能大幅提升训练速度。
      • 溢出： 整数类型有其最大最小值。如果计算结果超出了数据类型能表示的范围，就会发生溢出。例如，
        np.int8
        的最大值是127，如果你将100+30存储到一个
        np.int8
        数组中，结果可能会“溢出”变成-126（取决于具体实现，通常是循环）。明确
        dtype
        可以帮助你预判并避免这类错误。

在我看来，选择合适的

dtype
是NumPy编程中一个不可忽视的优化点。它不仅关乎程序的健壮性，更是大数据时代提升效率、降低成本的关键所在。在不确定时，
np.float64
和
np.int64
通常是安全的默认选择，但一旦数据量变大或对资源有严格要求，就应该仔细考虑更精细的
dtype
管理。 除了基本创建，NumPy还有哪些高级的数组生成方式？

有时候，我们需要的数组并不是那么规整，比如单位矩阵，或者需要一些随机数来模拟实验，NumPy也都有很方便的接口。除了前面提到的那些基础方法，NumPy还提供了一些针对特定场景的高级数组生成方式，它们能帮助我们更高效地构建复杂的数组结构。

1. 创建单位矩阵：

np.eye()
单位矩阵是一个对角线元素为1，其余元素为0的方阵。在线性代数中，它扮演着非常重要的角色。
# 创建一个3x3的单位

以上就是python中如何使用numpy创建数组_Numpy创建数组(array)基础教程的详细内容，更多请关注知识资源分享宝库其它相关文章！

相关标签： python c语言 处理器 大数据 工具 深度学习 云服务器 区别 内存占用 Python c语言 架构 numpy scipy pandas matplotlib 数据类型 Float Array 多维数组 三维数组 字符串 结构体 bool int 循环 指针 数据结构 接口 堆 整数类型 float32 对象 数据分析 嵌入式系统 云服务器 大家都在看： Python 实战：招聘网站数据分析案例 python中怎么进行类型转换_Python常见数据类型转换方法 Python解释器解析器中无限循环错误的诊断与修复 Python 实战：猜数字小游戏 Python Web Scraping技巧：处理同名类标签并精确筛选数据

标签:  数组 创建 如何使用 

相关阅读

发表评论:

◎欢迎参与讨论，请在这里发表您的看法、交流您的观点。

最近发表

标签列表