Python怎么定义数组· 全面指南

Python怎么定义数组?

在Python编程中,数组是存储多个同类型或不同类型数据的基础结构。与C语言等传统语言不同,Python怎么定义数组并非仅有一种方式,而是提供了多种数据结构以满足不同场景需求。理解这些差异是高效编程的关键。本文将系统讲解Python中定义数组的三种主流方式:内置list、标准库array.array及第三方库NumPy ndarray,涵盖其定义方法、特性对比、性能表现、使用陷阱及实战案例。

许多初学者误以为Python没有数组类型,实则不然。Python虽未将数组作为内置基本类型(如int、str),但通过list、tuple、array模块及NumPy等库,提供了功能完备的数组式数据结构。其中,list是最常用且最灵活的,但若涉及数值计算、大规模数据处理或高性能需求,array.array与numpy.ndarray则更具优势。

📌 核心要点

  • Python中定义数组需明确目标:通用容器选list,数值计算选NumPy
  • list可存放任意类型对象,支持动态扩容,但内存开销较大
  • array模块提供紧凑型数组,元素类型受限(如i、f、d),内存效率高
  • NumPy ndarray是科学计算基石,支持向量化运算、广播机制及高效底层实现

Python中数组的三大主流类型

在Python生态中,真正可视为“数组”的类型主要有三种:内置list(列表)、标准库array.array(数组)、以及第三方numpy.ndarray(多维数组)。它们在设计目标、内存布局、功能特性上存在显著差异,需根据具体需求选择。

类型 来源 元素类型 内存效率 支持维度 核心优势
list 内置 任意类型混合 低(对象指针存储) 一维(嵌套实现多维) 灵活、易用、功能丰富
array.array 标准库 单一基本类型 高(紧凑存储) 一维 内存紧凑、类型安全
numpy.ndarray NumPy库 同质(通常为数值) 极高(连续内存块) 任意维度(1D~ND) 向量化运算、高性能计算

选择建议:日常开发优先用list;需节省内存且元素类型单一时用array.array;涉及科学计算、机器学习、图像处理等需大量数值运算时,必须用numpy.ndarray。

用list定义数组:最常用方式

list是Python中最基础的序列类型,本质上是动态数组(动态扩容的顺序表),可存放任意类型对象,支持索引、切片、追加、删除等丰富操作。虽然技术上list不是“数组”(因元素类型不固定),但在日常语境中常被称作“Python数组”。

基本定义方法

定义数组最直接的方式是用方括号:

# 用方括号直接定义
numbers = [1, 2, 3, 4, 5]
fruits = ['apple', 'banana', 'cherry']
mixed = [1, 'two', 3.0, True, None]  # 混合类型

使用list()构造函数

# 从可迭代对象创建
nums_from_range = list(range(1, 6))  # [1, 2, 3, 4, 5]
chars_from_str = list('hello')       # ['h', 'e', 'l', 'l', 'o']
empty_list = list()                  # []

列表推导式(高效初始化)

列表推导式是Python中简洁创建列表的语法糖,特别适合定义数组时进行初始化计算:

# 创建0~9的平方数列表
squares = [x**2 for x in range(10)]  # [0, 1, 4, 9, 16, ..., 81]
# 条件过滤:仅保留偶数的平方
even_squares = [x**2 for x in range(10) if x % 2 == 0]  # [0, 4, 16, 36, 64]
# 嵌套循环:生成坐标点
points = [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]  # [(1,3),(1,4),(2,3),(2,1),(2,4),(3,1),(3,4)]

多维“数组”的模拟

Python的list本身不支持多维数组原生语法,但可通过嵌套list实现二维或更高维结构:

# 二维列表(3行4列)
matrix = [[0]*4 for _ in range(3)]  # [[0,0,0,0], [0,0,0,0], [0,0,0,0]]
# 注意:禁止用 [[0]*4]*3!会导致行引用同一对象
bad_matrix = [[0]*4]*3  # ❌ 修改一行会影响所有行
bad_matrix[0][0] = 1
print(bad_matrix)  # [[1,0,0,0], [1,0,0,0], [1,0,0,0]]

⚠️ 常见误区:浅拷贝陷阱

使用`[[0]*4]*3`初始化二维list时,所有行共享同一子列表对象,导致修改一行影响全局。正确做法是用列表推导式`[[0]*4 for _ in range(3)]`,确保每行独立创建。

常见操作速查

访问与修改

arr = [10, 20, 30, 40]
print(arr[1])       # 20
arr[2] = 35         # 修改第三个元素
print(arr)          # [10, 20, 35, 40]

切片操作

arr = [0,1,2,3,4,5,6,7,8,9]
print(arr[2:7:2])   # [2, 4, 6]
print(arr[::-1])    # 反转 [9,8,...,0]

增删元素

arr.append(10)     # 尾部添加
arr.insert(1, 99)   # 在索引1插入99
arr.extend([11,12]) # 批量追加
arr.pop(1)          # 删除并返回索引1元素
del arr[2:5]        # 删除切片

用array.array定义数组:标准库紧凑型

当需要更高效的内存使用且元素类型固定时,Python标准库提供了array.array模块。它与list类似,但所有元素必须是相同基本类型(如整数、浮点数),并以紧凑二进制格式存储,显著减少内存开销。

定义与类型码

定义数组需导入array模块,并指定类型码(type code):

from array import array
# 整型数组(有符号int,类型码'i')
int_arr = array('i', [1, 2, 3, 4])
# 浮点型数组(双精度,类型码'd')
float_arr = array('d', [1.1, 2.2, 3.3])
# 字符数组(不推荐,Python3中已弃用)

常用类型码:`'b'`(signed char)、`'B'`(unsigned char)、`'h'`(signed short)、`'H'`(unsigned short)、`'i'`(signed int)、`'I'`(unsigned int)、`'l'`(signed long)、`'L'`(unsigned long)、`'f'`(float)、`'d'`(double)。

💡 为什么需要类型码?

类型码确保数组元素以固定大小二进制格式存储,避免了list中每个元素作为独立对象存储的指针开销。例如,int数组用`'i'`时,每个元素占4字节(32位系统),而list中每个int对象需约28字节(对象头+值+引用)。

特性与操作

arr = array('i', [10, 20, 30])
# 支持索引、切片、len()等标准序列操作
print(arr[1])       # 20
print(arr[1:3])     # array('i', [20, 30])
print(len(arr))     # 3
# 但仅支持同类型赋值
arr[0] = 100        # ✅ OK
arr.append(40)      # ✅ OK
arr.append(3.14)    # ❌ TypeError: 'float' object cannot be interpreted as an integer
# 与list互转
list_from_arr = list(arr)  # [10, 20, 30]
arr_from_list = array('i', [1,2,3])  # 直接传入list

内存效率实测对比

📊 内存占用对比(100万个整数)

  • list:约 8,000,000 字节(每个元素≈8字节指针 + 对象开销)
  • array('i'):约 4,000,000 字节(每个元素固定4字节)
  • 节省约 50% 内存!

适用场景

当满足以下条件时,优先考虑array.array:

用numpy.ndarray定义数组:科学计算基石

对于数值计算、数据分析、机器学习等领域,numpy.ndarray是事实上的标准数组类型。NumPy是Python科学计算生态的核心库,其ndarray通过C语言实现,支持向量化运算、广播机制、多维索引及高效内存布局,性能远超纯Python实现。

安装与导入

# 安装(终端执行)
pip install numpy
# 导入(约定俗成缩写np)
import numpy as np

基本定义数组方法

# 从Python列表创建
arr1 = np.array([1, 2, 3, 4])  # 一维数组
# 创建二维数组
matrix = np.array([[1,2,3], [4,5,6]])
# 使用内置函数初始化
zeros = np.zeros((3, 4))        # 3行4列全0
ones = np.ones((2, 3, 4))       # 2×3×4全1(三维)
identity = np.eye(3)            # 3阶单位矩阵
arange = np.arange(0, 10, 2)    # [0,2,4,6,8]
linspace = np.linspace(0, 1, 5) # [0.0, 0.25, 0.5, 0.75, 1.0]

核心特性详解

dtype属性
shape属性
reshape方法
向量化运算

元素类型(dtype)

ndarray要求所有元素类型一致,通过dtype属性查看或指定:

arr = np.array([1, 2, 3])
print(arr.dtype)  # int64(或int32,取决于平台)
# 创建时指定dtype
float_arr = np.array([1, 2, 3], dtype=np.float32)
print(float_arr.dtype)  # float32
# 类型转换
int_arr = np.array([1.5, 2.7, 3.9], dtype=np.int32)
print(int_arr)  # [1, 2, 3](截断小数)

数组形状(shape)

shape属性返回各维度大小,是多维数组的核心标识:

arr = np.array([[1,2,3], [4,5,6]])
print(arr.shape)  # (2, 3) → 2行3列
# 修改形状(需保持元素总数不变)
arr_reshaped = arr.reshape(3, 2)
print(arr_reshaped)
# [[1,2], [3,4], [5,6]]

形状变换技巧

reshape()返回视图(不复制数据),避免内存浪费:

# 1D转2D
vec = np.arange(12)
mat = vec.reshape(3, 4)
print(mat.shape)  # (3, 4)
# 3D数组展平
arr3d = np.ones((2,3,4))
flat = arr3d.reshape(-1)  # -1自动计算维度 → 长度24的一维数组

向量化运算(性能关键!)

ndarray支持对整个数组进行运算,无需显式循环:

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
# 元素级加法
c = a + b  # [5, 7, 9]
# 标量广播
d = a * 2  # [2, 4, 6]
# 数学函数
e = np.sqrt(a)  # [1.0, 1.414, 1.732]
# 多维矩阵乘法
A = np.array([[1,2],[3,4]])
B = np.array([[5,6],[7,8]])
C = A @ B  # [[19,22], [43,50]]

🚀 性能对比:向量化 vs 循环

对100万个元素求平方:

  • Python list + 循环:≈ 0.35 秒
  • NumPy ndarray(向量化):≈ 0.002 秒(快175倍!)

高级索引与切片

arr = np.array([[1,2,3], [4,5,6], [7,8,9]])
# 布尔索引:筛选大于3的元素
mask = arr > 3
print(arr[mask])  # [4,5,6,7,8,9]
# 花式索引:按指定顺序取行
rows = arr[[2,0,1]]  # 第2行、第0行、第1行 → [[7,8,9], [1,2,3], [4,5,6]]
# 切片与步长
sub = arr[0:3:2, 1:3]  # 第0、2行,列1~2 → [[2,3], [8,9]]

三者对比:何时选择哪种定义数组方式?

✅ 选list的情况

  • 元素类型混合(如[1, 'a', 3.0]
  • 需频繁增删元素
  • 数据量小(<1万)
  • 通用编程场景

✅ 选array.array的情况

  • 元素类型单一(如全整数)
  • 需节省内存(百万级元素)
  • 二进制I/O处理(如图像像素)
  • 标准库可用,无需第三方

✅ 选numpy.ndarray的情况

  • 科学计算/机器学习
  • 多维数组操作
  • 向量化运算需求
  • 需高性能数值计算

特别提醒:在数据分析、机器学习领域,numpy.ndarray是必选项。pandas、scikit-learn等库均以ndarray为底层数据结构,强行用list会导致性能骤降。

最佳实践与避坑指南

常见错误与解决方案

错误1:list与ndarray混用

将list直接传入NumPy函数时,可能触发隐式转换,导致意外类型提升:

# 错误示例
mixed_list = [1, 2, 3.0]  # 含int和float
arr = np.array(mixed_list)
print(arr.dtype)  # float64(所有元素转为float)

✅ 正确做法:显式指定dtype或确保输入类型一致:

arr = np.array([1, 2, 3], dtype=np.int32)  # 强制整型

错误2:修改list切片影响原数组

list的切片是浅拷贝,但ndarray切片是视图(共享内存):

# ndarray切片修改影响原数组
arr = np.array([1,2,3])
sub = arr[0:2]  # 视图
sub[0] = 99
print(arr)  # [99,2,3]!原数组被修改
# 解决方案:显式复制
sub = arr[0:2].copy()  # 独立副本

错误3:用list模拟多维数组性能差

嵌套list在数值计算中效率极低:

# 低效方式:双重循环
matrix = [[i+j for j in range(100)] for i in range(100)]
result = [[0]*100 for _ in range(100)]
for i in range(100):
  for j in range(100):
    result[i][j] = matrix[i][j] * 2  # 10,000次循环
# 高效方式:NumPy向量化
matrix = np.array([[i+j for j in range(100)] for i in range(100)])
result = matrix * 2  # 一行搞定,快100倍+

性能优化建议

⚡ 三大黄金法则

  1. 避免循环:能向量化就不用for/while
  2. 预分配空间:用np.zeros/ones提前分配大小
  3. 选择合适dtype:int32 vs int64,float32 vs float64

网友最常问的定义数组问题

Python有原生数组吗?
list和array的区别?
如何初始化空数组?
多维数组怎么定义?

Q:Python有原生数组吗?

A:严格来说,Python没有像C那样的原生数组类型,但通过list、array.array、numpy.ndarray提供了数组式功能。list是事实上的标准容器,而array和numpy是针对特定场景的增强版。

Q:list和array的区别?

A:关键差异如下:

特性 list array.array
元素类型 任意类型混合 单一基本类型
内存效率 低(对象指针) 高(紧凑二进制)
功能丰富度 高(方法多) 中(基础序列操作)
第三方依赖 无需 无需(标准库)

Q:如何初始化空数组?

A:根据不同类型:

# list
empty_list = [] 或 empty_list = list()
# array.array
empty_int_arr = array('i')  # 空整型数组
# numpy.ndarray
empty_arr = np.array([])  # 空一维数组
empty_2d = np.zeros((0, 3))  # 0行3列二维数组

Q:多维数组怎么定义?

A:

# list(嵌套)
matrix = [[1,2,3], [4,5,6], [7,8,9]]
# numpy.ndarray(原生多维)
matrix = np.array([[1,2,3], [4,5,6], [7,8,9]])
zeros_3d = np.zeros((2,3,4))  # 2×3×4三维数组
# array.array仅支持一维,多维需嵌套
row1 = array('i', [1,2,3])
row2 = array('i', [4,5,6])
matrix = [row1, row2]