numpy创建数组入门教程

从现在开始，努力学习吧！本文《Python中用numpy创建数组教程》主要讲解了等等相关知识点，我会在golang学习网中持续更新相关的系列文章，欢迎大家关注并积极留言建议。下面就先一起来看一下本篇正文内容吧，希望能帮到你！

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.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）是理解其结构的关键。

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的单位

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于文章的相关知识，也可关注golang学习网公众号。