跳到主要内容

NumPy 数组创建

本章将详细介绍 NumPy 中创建数组的各种方法。

创建函数一览​

NumPy 提供了丰富的数组创建函数，适用于不同的场景：

函数说明示例
array从 Python 列表或元组创建np.array([1, 2, 3])
zeros创建全零数组np.zeros((3, 4))
ones创建全一数组np.ones((3, 4))
full创建填充指定值的数组np.full((3, 4), 99)
eye创建单位矩阵np.eye(4)
identity创建单位矩阵（同 eye）np.identity(4)
arange创建等差数组np.arange(0, 10, 2)
linspace创建等间隔数组np.linspace(0, 1, 5)
logspace创建对数间隔数组np.logspace(0, 2, 5)
meshgrid创建网格坐标矩阵np.meshgrid(x, y)
diag创建对角矩阵np.diag([1, 2, 3])
random.rand均匀分布随机数np.random.rand(3, 4)
random.randn标准正态分布随机数np.random.randn(3, 4)
random.randint整数随机数np.random.randint(0, 10, (3, 4))
random.random[0, 1) 随机数np.random.random((3, 4))
random.choice从数组中随机选择np.random.choice(a, 3)
fromfunction通过函数创建np.fromfunction(fn, shape)
fromfile从文件读取np.fromfile('data.bin')

详细用法​

array 函数​

array 是最基础的创建函数，可以从 Python 序列创建 NumPy 数组：

import numpy as np

# 从列表创建
arr1 = np.array([1, 2, 3, 4, 5])
print(f"从列表创建: {arr1}")

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

# 从元组创建
arr3 = np.array((1, 2, 3, 4))
print(f"从元组创建: {arr3}")

# 指定数据类型
arr4 = np.array([1, 2, 3], dtype=np.float32)
print(f"指定 float32: {arr4}, dtype: {arr4.dtype}")

# 创建复数数组
arr5 = np.array([1+2j, 3+4j])
print(f"复数数组: {arr5}")

# 创建结构化数组
dt = np.dtype([('name', 'U10'), ('age', 'i4')])
arr6 = np.array([('Alice', 25), ('Bob', 30)], dtype=dt)
print(f"结构化数组:\n{arr6}")

zeros 和 ones​

创建全零或全一数组：

import numpy as np

# 一维全零数组
zeros_1d = np.zeros(5)
print(f"一维全零: {zeros_1d}")

# 二维全零数组（形状用元组指定）
zeros_2d = np.zeros((3, 4))
print(f"二维全零:\n{zeros_2d}")

# 三维全零数组
zeros_3d = np.zeros((2, 3, 4))
print(f"三维全零形状: {zeros_3d.shape}")

# 全一数组
ones_int = np.ones((2, 3), dtype=np.int32)
print(f"全一整数:\n{ones_int}")

# ones_like: 创建与给定数组相同形状的全一数组
arr = np.array([[1, 2, 3], [4, 5, 6]])
ones_like_arr = np.ones_like(arr)
print(f"ones_like:\n{ones_like_arr}")

zeros_like_arr = np.zeros_like(arr)
print(f"zeros_like:\n{zeros_like_arr}")

full 和 full_like​

创建填充指定值的数组：

import numpy as np

# 创建全部填充为 7 的数组
arr = np.full((3, 4), 7)
print(f"full((3, 4), 7):\n{arr}")

# 创建全部填充为 True 的布尔数组
bool_arr = np.full((2, 3), True, dtype=bool)
print(f"布尔全 True:\n{bool_arr}")

# 创建填充为字符串的数组
str_arr = np.full((2, 2), 'x')
print(f"字符串填充:\n{str_arr}")

# full_like: 基于现有数组创建
original = np.array([[1, 2], [3, 4]])
filled = np.full_like(original, 99)
print(f"full_like: {filled}")

arange 函数​

arange 类似于 Python 的 range 函数，但返回 NumPy 数组：

import numpy as np

# 基本用法（类似 range）
print(f"np.arange(5): {np.arange(5)}")          # [0, 1, 2, 3, 4]
print(f"np.arange(2, 5): {np.arange(2, 5)}")    # [2, 3, 4]
print(f"np.arange(0, 10, 2): {np.arange(0, 10, 2)}")  # [0, 2, 4, 6, 8]

# 浮点数 arange（注意精度问题）
print(f"np.arange(0.0, 1.0, 0.1): {np.arange(0.0, 1.0, 0.1)}")

# 负数
print(f"np.arange(-5, 5): {np.arange(-5, 5)}")

# 浮点数步长（使用 linspace 更精确）
print(f"np.arange(-5, 5, 0.5): {np.arange(-5, 5, 0.5)}")

linspace 函数​

创建在指定范围内均匀分布的数组：

import numpy as np

# 基本用法：在 0 到 10 之间创建 5 个均匀分布的点
arr = np.linspace(0, 10, 5)
print(f"linspace(0, 10, 5): {arr}")
# 结果: [ 0.   2.5  5.   7.5 10. ]

# 不包含端点
arr2 = np.linspace(0, 10, 5, endpoint=False)
print(f"endpoint=False: {arr2}")
# 结果: [0.  2.  4.  6.  8.]

# 计算步骤
arr3 = np.linspace(0, 10, 50)
print(f"步骤数: {len(arr3)}")

# retstep 参数：返回 (数组, 步长)
arr4, step = np.linspace(0, 10, 5, retstep=True)
print(f"数组: {arr4}, 步长: {step}")

meshgrid 函数​

创建网格坐标矩阵，常用于绘制三维图形：

import numpy as np

# 一维网格
x = np.linspace(0, 3, 4)  # [0, 1, 2, 3]
y = np.linspace(0, 2, 3)  # [0, 1, 2]

# 创建网格
X, Y = np.meshgrid(x, y)
print(f"X:\n{X}")
print(f"Y:\n{Y}")

# 计算网格上的函数值
Z = X + Y
print(f"X + Y:\n{Z}")

# indexing='ij' 使用矩阵索引顺序
X2, Y2 = np.meshgrid(x, y, indexing='ij')
print(f"X (ij 模式):\n{X2}")
print(f"Y (ij 模式):\n{Y2}")

随机数组​

NumPy 的 random 模块提供了丰富的随机数组生成函数：

import numpy as np

# 设置随机种子（保证结果可复现）
np.random.seed(42)

# rand: [0, 1) 均匀分布
print(f"rand(2, 3):\n{np.random.rand(2, 3)}")

# randn: 标准正态分布（均值0，方差1）
print(f"randn(2, 3):\n{np.random.randn(2, 3)}")

# randint: 随机整数
print(f"randint(1, 10, (3, 3)):\n{np.random.randint(1, 10, (3, 3))}")

# random_sample: [0, 1) 随机浮点数
print(f"random_sample((2, 2)):\n{np.random.random_sample((2, 2))}")

# choice: 从数组中随机选择
arr = np.array([1, 2, 3, 4, 5])
print(f"choice: {np.random.choice(arr, 3)}")
print(f"choice (不重复): {np.random.choice(arr, 5, replace=False)}")

# 使用 Generator（NumPy 1.17+ 推荐）
rng = np.random.default_rng(42)
print(f"Generator rand: {rng.random(5)}")
print(f"Generator integers: {rng.integers(0, 100, size=5)}")

特殊数组​

import numpy as np

# 单位矩阵
eye_3x3 = np.eye(3)
print(f"eye(3):\n{eye_3x3}")

# 非方阵单位矩阵
eye_mxn = np.eye(3, 5)
print(f"eye(3, 5):\n{eye_mxn}")

# 对角矩阵
diag = np.diag([1, 2, 3, 4])
print(f"diag([1,2,3,4]):\n{diag}")

# 从数组提取对角线
arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(f"对角线: {np.diag(arr)}")

# 创建带偏移的对角矩阵
offset_diag = np.diag([1, 2, 3], k=1)  # 主对角线上方偏移1
print(f"偏移对角线 (k=1):\n{offset_diag}")

# 空数组（未初始化）
empty_arr = np.empty((2, 3))
print(f"empty((2, 3)):\n{empty_arr}")
# 注意：empty 创建的数组值是未定义的，不要假设是0

# 空_like
base = np.array([[1, 2], [3, 4]])
empty_like_arr = np.empty_like(base)
print(f"empty_like:\n{empty_like_arr}")

fromfunction 和 fromiter​

import numpy as np

# fromfunction: 通过函数创建数组
def my_function(x, y):
    return x + y

# 函数接收索引作为参数
coords = np.fromfunction(my_function, (3, 4), dtype=int)
print(f"fromfunction:\n{coords}")

# 更常见的用法：创建坐标网格
def distance(x, y):
    return np.sqrt(x**2 + y**2)

x = np.linspace(-2, 2, 5)
y = np.linspace(-2, 2, 5)
X, Y = np.meshgrid(x, y)
Z = distance(X, Y)
print(f"距离矩阵:\n{Z}")

# fromiter: 从迭代器创建
gen = (x**2 for x in range(5))
arr = np.fromiter(gen, dtype=int)
print(f"fromiter: {arr}")

结构化数组​

import numpy as np

# 方法1：使用 dtype 字符串
dt = np.dtype('i4, f8, U10')
arr1 = np.array([(1, 2.0, 'hello'), (2, 3.0, 'world')], dtype=dt)
print(f"结构化数组1:\n{arr1}")

# 方法2：使用字段列表
dt2 = np.dtype([
    ('name', 'U20'),
    ('age', 'i4'),
    ('weight', 'f4')
])
arr2 = np.array([
    ('Alice', 25, 55.5),
    ('Bob', 30, 75.0)
], dtype=dt2)
print(f"结构化数组2:\n{arr2}")
print(f"姓名: {arr2['name']}")
print(f"年龄: {arr2['age']}")

# 创建空结构化数组
empty_struct = np.zeros(3, dtype=dt2)
empty_struct['name'] = ['X', 'Y', 'Z']
empty_struct['age'] = [20, 25, 30]
print(f"空结构化数组:\n{empty_struct}")

数值范围数组函数对比​

函数说明是否均匀分布
arange(start, stop, step)等差数列，可能不均匀（浮点）取决于步长
linspace(start, stop, num)精确均匀分布是
logspace(start, stop, num)对数尺度均匀分布对数空间均匀
geomspace(start, stop, num)几何级数均匀分布几何空间均匀
import numpy as np

# arange: 浮点精度问题
print(f"arange: {np.arange(0, 1, 0.1)}")
# 注意：最后可能不包含 1.0

# linspace: 精确控制点数
print(f"linspace: {np.linspace(0, 1, 11)}")
# 精确包含 0.0 和 1.0

# logspace: 对数空间
print(f"logspace: {np.logspace(0, 2, 5)}")
# 10^0 到 10^2 之间的 5 个点

# geomspace: 几何级数
print(f"geomspace: {np.geomspace(1, 1000, 4)}")
# [1, 10, 100, 1000]

小结​

本章介绍了 NumPy 中创建数组的各种方法：

  1. 基础方法：array 函数从 Python 序列创建
  2. 常数数组：zeros、ones、full 创建填充固定值的数组
  3. 特殊矩阵：eye、identity、diag 创建矩阵
  4. 等差数列：arange 和 linspace 创建等差数组
  5. 随机数组：random 模块的各种函数
  6. 结构化数组：创建包含多个字段的数组

熟练掌握这些创建方法，能够让你根据不同的需求选择最合适的方式。