使用Numba优化for-enumerate循环反而变慢的原因及优化建议

• 你当前用的是Numba的对象模式（nopython=False, forceobj=True），这种模式下Numba不会将代码编译为机器码，只是在Python对象层面做封装执行，反而额外增加了Numba的调度开销，比纯Python代码跑得还慢。
• 函数依赖的Python原生容器（List[str]、Dict[str, int]）在Numba的nopython模式下支持有限，你被迫开启对象模式，等于放弃了Numba真正的编译优化优势。
• 循环中的动态操作（比如list.append、dict.get）在对象模式下无法被优化，依然是纯Python的执行效率，再加上Numba的额外封装层，导致整体速度下降。

方案1：改用Pandas的factorize（最简便高效） #

Pandas的factorize专门用于将字符串序列映射为整数索引，底层是C实现，速度远快于纯Python循环，还能自动处理重复值：

import pandas as pd
import numpy as np

def packing_with_pandas(data: list[str]):
    # 处理空字符串：用None标记，factorize后再转-1
    temp_data = [s if s else None for s in data]
    indices, unique_strings = pd.factorize(temp_data, use_na_sentinel=True)
    
    # 将空字符串对应的索引设为-1
    indices[temp_data == None] = -1
    
    # 计算offsets
    acc_len = 0
    offsets = []
    for s in unique_strings:
        if s is not None:
            acc_len += len(s)
            offsets.append(acc_len)
    
    return indices, unique_strings.tolist(), offsets

这个方法几乎不用手写循环，完全利用Pandas的底层优化，处理大规模数据时速度提升非常明显。

方案2：纯Python手动优化循环 #

如果不想依赖Pandas，可以通过拆分循环减少字典操作开销，同时预分配数组提升效率：

import numpy as np

def optimized_packing(data: list[str]):
    # 第一步：收集所有唯一非空字符串，建立映射
    str_map = {}
    unique_strings = []
    for s in data:
        if s and s not in str_map:
            str_map[s] = len(unique_strings)
            unique_strings.append(s)
    
    # 第二步：预分配indices数组（比动态赋值更快）
    indices = np.full(len(data), -1, dtype=np.int32)
    for i, s in enumerate(data):
        if s:
            indices[i] = str_map[s]
    
    # 第三步：计算offsets
    acc_len = 0
    offsets = []
    for s in unique_strings:
        acc_len += len(s)
        offsets.append(acc_len)
    
    return indices, unique_strings, offsets

拆分循环后，字典的查询和插入操作次数减少，预分配numpy数组避免了循环中动态赋值的开销，比原函数效率高很多。

方案3：正确使用Numba（仅当必须用Numba时） #

如果一定要用Numba，必须切换到nopython模式，同时使用Numba的typed容器替代Python原生容器：

from numba import jit
from numba.typed import Dict, List
from numba.types import unicode_type, int64

@jit(nopython=True)
def numba_packing(data: List[str], indices: np.ndarray, strings: List[str], offsets: List[int], str_map: Dict[str, int], acc_len: int):
    for i in range(len(data)):
        s = data[i]
        if not s:
            indices[i] = -1
            continue
        
        if s not in str_map:
            acc_len += len(s)
            index = len(strings)
            strings.append(s)
            str_map[s] = index
            offsets.append(acc_len)
            indices[i] = index
        else:
            indices[i] = str_map[s]
    return acc_len

# 包装函数：初始化Numba的typed容器
def numba_wrapper(data: list[str]):
    data_typed = List(data)
    indices = np.full(len(data), -1, dtype=np.int64)
    strings_typed = List.empty_list(unicode_type)
    offsets_typed = List.empty_list(int64)
    str_map_typed = Dict.empty(unicode_type, int64)
    acc_len = 0
    
    acc_len = numba_packing(data_typed, indices, strings_typed, offsets_typed, str_map_typed, acc_len)
    
    return indices, list(strings_typed), list(offsets_typed)

注意：Numba对字符串的支持有限，这种方式的性能提升可能不如前两种方案，仅适合必须依赖Numba的场景。

内容的提问来源于stack exchange，提问作者aaxx