在算法题目中，处理数组（List）、字符串、矩阵等可迭代对象时，“同时获取索引和元素值” 是高频需求 —— 比如找目标元素的位置、双指针遍历标记、矩阵行列定位等。Python 内置的 enumerate 函数正是用来解决这类问题的。
一、enumerate 函数的核心基础
1. 什么是 enumerate？
enumerate 直译是 “枚举”，是 Python 内置函数，核心作用是遍历可迭代对象时，同时返回元素的 “索引” 和 “值”。它底层由 C 实现，执行效率略高于手动维护索引的写法，是刷题时的首选。
2. 基础语法
|
1 |
enumerate(iterable, start=0) |
- 参数：
- iterable：必需，可迭代对象（List、字符串、元组、矩阵等）；
- start：可选，索引起始值，默认 0（可根据题目需求设为 1、-1 等）。
- 返回值：枚举对象（迭代器），每次迭代返回 (索引, 元素值) 元组。
3. 告别手动索引
|
1 2 3 4 5 6 7 8 9 10 11 12 |
# 传统写法 nums = [1, 3, 5, 7] i = 0 for val in nums: print(f"索引 {i}：值 {val}") i += 1 # enumerate 写法 for idx, val in enumerate(nums): print(f"索引 {idx}：值 {val}") # 自定义索引起始值（比如题目要求索引从 1 开始） for idx, val in enumerate(nums, start=1): print(f"索引 {idx}：值 {val}") |
二、LeetCode Hot100 中的高频应用场景
一、题目 1：两数之和（LeetCode 1，Hot100 长期在榜）
题目原文：
给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出和为目标值 target 的那两个整数，并返回它们的数组下标。假设每种输入只会对应一个答案，数组中同一个元素在答案里不能重复出现，可按任意顺序返回答案。
传统暴力解法：
|
1 2 3 4 5 6 7 8 9 10 11 12 |
class Solution(object): def twoSum(self, nums, target): """ :type nums: List[int] :type target: int :rtype: List[int] """ n=len(nums) for i in range(n): for j in range(i+1,n): if target == nums[i]+nums[j]: return[i,j] |
传统暴力解法需要两层循环（时间复杂度 O(n2)），而哈希表可以将「查找另一个数」的操作从 O(n) 降到 O(1)，整体时间复杂度优化为 O(n)，空间复杂度 O(n)（存储哈希表）：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
from typing import List # 导入List类型注解，用于指定参数和返回值类型 class Solution: def twoSum(self, nums: List[int], target: int) -> List[int]: """ 给定一个整数数组 nums 和一个整数目标值 target， 请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。 你可以假设每种输入只会对应一个答案，且同一个元素不能使用两遍。 你可以按任意顺序返回答案。 :param nums: 整数数组，存储待查找的数字 :param target: 目标和，需要找到两个数相加等于该值 :return: 包含两个数下标List[int]，顺序无要求 """ # 初始化一个空字典（哈希表），用于存储「数字: 下标」的映射 # 作用：将遍历过的数字和其下标记录下来，后续可以O(1)时间查询是否存在目标差值 hashtable = dict() # 遍历数组，enumerate同时返回下标i和对应数字num for i, num in enumerate(nums): # 计算目标差值：target - 当前数字 = 需要找的另一个数 complement = target - num # 检查哈希表中是否已经存在这个差值 # 如果存在，说明之前遍历过的某个数字和当前数字相加等于target if complement in hashtable: # 返回「差值对应的下标」和「当前数字的下标」，即为答案 return [hashtable[complement], i] # 如果不存在，将当前数字和其下标存入哈希表，供后续遍历查询 # 注意：先检查再存入，避免同一个元素被重复使用（比如num=3, target=6时，不会匹配到自己） hashtable[nums[i]] = i # 题目保证有且仅有一个答案，理论上不会执行到这里，返回空列表作为兜底 return [] |
核心场景：需要 “值 + 下标” 绑定且下标是答案的一部分
enumerate的核心作用：遍历数组时，既要获取元素值（计算补数target-num），又要记录该值对应的下标（最终需要返回下标作为答案）。
适用细节：
- 题目要求返回 “满足条件的元素下标”，而非元素值，因此必须把 “值” 和 “其原始下标” 绑定；
- enumerate省去了 “手动维护下标变量i+i+=1” 的操作，且让 “值 - 下标” 的映射在循环中直接可用，避免先存所有 “值 - 下标” 再二次遍历的冗余。
二、题目 2：移动零（LeetCode 283，Hot100 高频数组题）
题目原文：
给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。要求原地操作，不拷贝额外数组，尽量减少操作次数。
非enumerate解法：
|
1 2 3 4 5 6 7 8 9 |
class Solution(object): def moveZeroes(self, nums): n=len(nums) left = right = 0 while right<n: if nums[right]!=0: nums[left],nums[right]=nums[right],nums[left] left+=1 right+=1 |
enumerate解法：
|
1 2 3 4 5 6 7 8 |
class Solution(object): def moveZeroes(self, nums): slow = 0 # 慢指针：记录非零元素应存放的位置，初始为0 # enumerate的fast_idx作为快指针，遍历数组筛选非零元素 for fast_idx, val in enumerate(nums): if val != 0: # 遇到非零元素，与慢指针位置交换并后移慢指针 nums[slow], nums[fast_idx] = nums[fast_idx], nums[slow] slow += 1 |
核心场景：双指针遍历，快指针需同时获取 “索引 + 值” 做筛选
enumerate的核心作用：快指针遍历数组时，既要通过val判断 “是否为 0”（筛选非零元素），又要通过fast_idx（enumerate 的索引）与慢指针交换元素（原地修改数组）。
适用细节：
- 题目要求 “原地修改数组”，需要通过索引定位元素位置进行交换；
- enumerate让快指针的 “索引（交换位置）” 和 “值（筛选条件）” 在同一循环变量中，无需单独通过nums[i]取值，逻辑更紧凑。
三、题目 3：找到字符串中所有字母异位词（LeetCode 438，Hot100 滑动窗口题）
题目原文
给定两个字符串 s 和 p，找到 s 中所有 p 的 字母异位词 的子串，返回这些子串的起始索引。字母异位词指由相同字母重排列形成的字符串（包括相同字符串），不考虑答案输出的顺序。
非enumerate写法：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 |
class Solution(object): def findAnagrams(self, s, p): """ :type s: str # 原字符串 :type p: str # 目标异位词的基准字符串 :rtype: List[int] # 返回所有异位词在s中的起始索引 """ # 初始化结果列表 result = [] # 获取p和s的长度 len_p, len_s = len(p), len(s) # 边界条件：如果p比s长，不可能有异位词，直接返回空列表 if len_p > len_s: return result # 初始化两个数组，统计26个小写字母的出现次数（ASCII码映射） # ord('a') = 97，所以用 ord(c) - ord('a') 得到0-25的索引 count_p = [0] * 26 count_window = [0] * 26 # 第一步：统计p的字符计数，同时初始化滑动窗口的初始状态（前len_p个字符） for i in range(len_p): # 统计p的字符 count_p[ord(p[i]) - ord('a')] += 1 # 统计s前len_p个字符（初始窗口） count_window[ord(s[i]) - ord('a')] += 1 # 检查初始窗口是否匹配 if count_p == count_window: result.append(0) # 第二步：滑动窗口遍历s的剩余部分（从len_p到len_s-1） # 窗口起始索引从1开始，结束索引从len_p开始 for right in range(len_p, len_s): # 移出窗口左侧的字符（窗口起始索引是 right - len_p） left_char = s[right - len_p] count_window[ord(left_char) - ord('a')] -= 1 # 移入窗口右侧的新字符 right_char = s[right] count_window[ord(right_char) - ord('a')] += 1 # 检查当前窗口是否匹配p的字符计数 if count_p == count_window: # 记录当前窗口的起始索引 result.append(right - len_p + 1) return result |
enumerate写法：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 |
class Solution(object): def findAnagrams(self, s, p): """ :type s: str :type p: str :rtype: List[int] """ result = [] len_p, len_s = len(p), len(s) # 边界条件：p比s长直接返回空 if len_p > len_s: return result # 初始化26字母计数数组 count_p = [0] * 26 count_window = [0] * 26 # 第一步：统计p的字符，同时初始化窗口前len_p个字符（用enumerate遍历） # 遍历p的字符，统计计数 for idx, char in enumerate(p): count_p[ord(char) - ord('a')] += 1 # 遍历s前len_p个字符，初始化窗口（用enumerate更清晰） for idx, char in enumerate(s[:len_p]): count_window[ord(char) - ord('a')] += 1 # 检查初始窗口是否匹配 if count_p == count_window: result.append(0) # 第二步：滑动窗口（用enumerate遍历s中从len_p开始的部分） # 遍历的是s[len_p:]，enumerate的start参数指定索引从len_p开始（对应原s的索引） for right_idx, right_char in enumerate(s[len_p:], start=len_p): # 计算要移出窗口的左侧字符的索引 left_idx = right_idx - len_p left_char = s[left_idx] # 移出左侧字符：计数-1 count_window[ord(left_char) - ord('a')] -= 1 # 移入右侧新字符：计数+1 count_window[ord(right_char) - ord('a')] += 1 # 检查当前窗口是否匹配，匹配则记录起始索引（left_idx + 1） if count_p == count_window: result.append(left_idx + 1) return result |
核心场景：滑动窗口遍历，需索引计算窗口边界 + 值维护窗口状态
enumerate的核心作用：遍历字符串时，既要通过char（值）更新窗口字符计数，又要通过idx（索引）计算窗口左边界（idx - p_len + 1）、判断窗口长度是否达标。
适用细节：
- 题目要求返回 “异位词子串的起始索引”，需要通过索引定位窗口位置；
- enumerate让 “当前字符” 和 “当前位置” 直接绑定，避免手动计算索引时的错位（比如窗口左边界计算错误）。
四、题目4：矩阵置零（LeetCode 73）
题目原文
给定一个 m x n 的矩阵，如果一个元素为 0，则将其所在行和列的所有元素都设为 0。请使用 原地 算法。
进阶：能否使用 O (1) 额外空间？
非enumerate解法：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
class Solution(object): def setZeroes(self, matrix): """ :type matrix: List[List[int]] :rtype: None Do not return anything, modify matrix in-place instead. """ # 初始化两个集合，分别存储需要置零的行和列 rows = set() cols = set() # 第一步：遍历矩阵，标记需要置零的行和列 m = len(matrix) # 矩阵的行数 if m == 0: return n = len(matrix[0]) # 矩阵的列数 for i in range(m): for j in range(n): if matrix[i][j] == 0: rows.add(i) cols.add(j) # 第二步：根据标记的行和列，将对应位置置零 for i in range(m): for j in range(n): if i in rows or j in cols: matrix[i][j] = 0 |
enumerate解法：
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
class Solution(object): def setZeroes(self, matrix): """ :type matrix: List[List[int]] :rtype: None Do not return anything, modify matrix in-place instead. """ # 初始化两个集合，分别存储需要置零的行和列 rows = set() cols = set() # 第一步：遍历矩阵，用enumerate获取行索引+行数据，标记需要置零的行和列 # 外层enumerate：i是行索引，row是当前行的所有元素 for i, row in enumerate(matrix): # 内层enumerate：j是列索引，val是当前位置的元素值 for j, val in enumerate(row): if val == 0: rows.add(i) # 标记需要置零的行 cols.add(j) # 标记需要置零的列 # 第二步：再次遍历矩阵，根据标记置零（同样用enumerate） for i, row in enumerate(matrix): for j, _ in enumerate(row): # 只需要列索引j，元素值用_占位即可 if i in rows or j in cols: matrix[i][j] = 0 |
- 遍历需同时用 “索引 + 值”：
- 外层enumerate(matrix)：i是行索引（用于标记首列matrix[i][0]），row是行元素（用于内层遍历）；
- 内层enumerate(row)：j是列索引（用于标记首行matrix[0][j]），val是元素值（判断是否为 0）；两者缺一不可，完全符合 “要值也要索引” 的核心场景。
- 原地修改依赖索引定位：题目要求 “原地算法”，置零操作需要通过行索引i、列索引j精准定位元素位置（如matrix[i][j] = 0），enumerate省去了手动维护i/j自增的麻烦。
三、enumerate 进阶技巧
1. 与列表推导式结合：一行生成 “值 - 索引” 映射
刷题中常需要快速查找元素的位置，用 enumerate + 字典推导式可一键生成映射表：
|
1 2 3 4 5 |
# 生成“元素值: 作为字典的“键”（适用于无重复元素的数组） nums = [2, 7, 11, 15] # 字典推导式 + enumerate：键是元素值，值是对应索引 val2idx = {val: idx for idx, val in enumerate(nums)} print(val2idx[7]) # 输出：1（快速找到7的索引） |
适用场景：Hot100 两数之和（快速通过值找索引，时间复杂度从 O (n²) 降为 O (n)）。
2. 转换为列表：查看枚举结果（调试 / 验证用）
enumerate 返回的是迭代器，只能遍历一次；若需多次使用，可转为列表：
|
1 2 3 4 |
nums = [10, 20, 30] # 将枚举对象转为列表，方便查看所有（索引，值）对 enum_list = list(enumerate(nums)) print(enum_list) # 输出：[(0, 10), (1, 20), (2, 30)] |
3. 自定义 start：适配题目索引要求
部分题目要求索引从 1 开始（如 “第 k 个元素”），只需设置 start=1：
|
1 2 3 4 |
nums = [5, 3, 8] # start=1 让索引从1开始，符合题目“第k个元素”的表述习惯 for idx, val in enumerate(nums, start=1): print(f"第 {idx} 个元素：{val}") # 输出：第1个元素：5，第2个元素：3... |
四、使用 enumerate 的注意事项
- 索引是 “遍历顺序” 而非 “原数组实际索引”：若遍历的是切片 / 过滤后的数组，索引是相对索引，而非原数组索引：
1
2
3
4
nums = [1, 2, 3, 4]
# 遍历切片 nums[2:]（元素是3、4），enumerate 的索引从0开始，而非原数组的2
for idx, val in enumerate(nums[2:]):
print(idx, val) # 输出：0 3；1 4
- 不要遍历中修改原对象：与普通 for 循环同理，遍历 List / 矩阵时增删元素，会导致枚举异常；
- 多维数组注意索引层级：嵌套 enumerate 时，外层 i 是行索引，内层 j 是列索引，避免混淆。
