嘿，这个需求非常贴合实际场景——百万级字符串记录、明确的主键和查询需求，嵌套字典虽然能凑合用，但在内存效率、可维护性和扩展性上确实有更好的替代方案。下面给你几个靠谱的选项，按从简单到专业的顺序排列：

这是嵌套字典的升级版本，用两个独立的字典分别维护主键索引和辅助查询索引，既保持O(1)的主键操作效率，又能满足(A,C)的快速查询需求：

• 主索引：用元组(A, B)作为键，直接映射到整条记录（或C字段值），比如primary_index: dict[tuple[str, str], str]。主键的新增、查询、更新、删除都是标准字典操作，天然O(1)复杂度。
• 辅助索引：用collections.defaultdict构建二级映射，结构是secondary_index: defaultdict[str, defaultdict[str, list[str]]]，其中secondary_index[A][C]存储所有匹配该(A,C)组合的B值列表。这样当你需要查询A="spam"且C="foo"的记录时，直接取secondary_index["spam"]["foo"]得到所有B，再遍历这些B去主索引拿完整记录，复杂度就是O(k)（k为结果行数）。

操作示例：

from collections import defaultdict

# 初始化索引
primary_index = {}
secondary_index = defaultdict(lambda: defaultdict(list))

# 新增记录（含更新逻辑）
def add_record(A: str, B: str, C: str):
    if (A, B) in primary_index:
        # 处理主键重复：先移除旧C对应的B记录
        old_C = primary_index[(A, B)]
        secondary_index[A][old_C].remove(B)
        # 清理空列表节省内存
        if not secondary_index[A][old_C]:
            del secondary_index[A][old_C]
    # 更新主索引
    primary_index[(A, B)] = C
    # 更新辅助索引
    secondary_index[A][C].append(B)

# 主键查询
def get_by_primary(A: str, B: str) -> str | None:
    return primary_index.get((A, B))

# (A,C)组合查询
def get_by_A_C(A: str, C: str) -> list[tuple[str, str, str]]:
    B_list = secondary_index.get(A, {}).get(C, [])
    return [(A, B, primary_index[(A, B)]) for B in B_list]

优缺点：

• ✅ 无第三方依赖，代码简单直观
• ✅ 严格符合你要求的复杂度
• ❌ 需要手动维护双索引一致性，增删改时要同步更新两个索引
• ❌ 百万级数据下内存占用比列式存储高，但大多数场景下完全可接受

Python自带的sqlite3支持内存模式，相当于把轻量数据库放在内存中运行，不用自己管理索引逻辑，用SQL语法就能搞定所有操作：

1. 先创建内存数据库和表，定义主键并建立辅助索引：

import sqlite3

# 连接内存数据库
conn = sqlite3.connect(':memory:')
cursor = conn.cursor()

# 创建表，(A,B)为主键
cursor.execute('''
CREATE TABLE records (
    A TEXT,
    B TEXT,
    C TEXT,
    PRIMARY KEY (A, B)
)
''')

# 建立(A,C)的辅助索引，加速查询
cursor.execute('CREATE INDEX idx_a_c ON records(A, C)')
conn.commit()

2. 核心操作示例：

# 新增记录（主键重复时自动更新）
def add_record(A: str, B: str, C: str):
    cursor.execute('INSERT OR REPLACE INTO records VALUES (?, ?, ?)', (A, B, C))
    conn.commit()

# 主键查询
def get_by_primary(A: str, B: str) -> tuple[str, str, str] | None:
    cursor.execute('SELECT * FROM records WHERE A=? AND B=?', (A, B))
    return cursor.fetchone()

# (A,C)组合查询
def get_by_A_C(A: str, C: str) -> list[tuple[str, str, str]]:
    cursor.execute('SELECT * FROM records WHERE A=? AND C=?', (A, C))
    return cursor.fetchall()

优缺点：

• ✅ 不用手动维护索引，SQLite自动处理一致性
• ✅ 支持事务、复杂查询（比如多条件组合、排序），扩展性强
• ✅ 百万级数据下性能接近原生字典，内存效率不错
• ❌ 有轻微的SQL解析开销，但对于百万级数据可忽略不计
• ❌ 操作不如原生字典灵活，需要写SQL语句

如果你的数据量接近千万级，或者对内存效率要求极高，PyArrow是更好的选择——它是专门为大数据设计的内存列式存储，比原生字典节省50%以上的内存，而且查询速度更快：

1. 安装PyArrow：pip install pyarrow
2. 核心操作示例：

import pyarrow as pa

# 初始化表结构
schema = pa.schema([
    ('A', pa.string()),
    ('B', pa.string()),
    ('C', pa.string())
])

# 初始空表
table = pa.Table.from_pylist([], schema=schema)

# 批量新增记录（单条写入也支持，批量更高效）
def add_records(records: list[tuple[str, str, str]]):
    global table
    new_data = pa.Table.from_pylist(records, schema=schema)
    table = pa.concat_tables([table, new_data])

# 主键查询
def get_by_primary(A: str, B: str):
    mask = (table['A'] == A) & (table['B'] == B)
    result = table.filter(mask)
    return result.to_pylist()[0] if result.num_rows > 0 else None

# (A,C)组合查询
def get_by_A_C(A: str, C: str):
    mask = (table['A'] == A) & (table['C'] == C)
    result = table.filter(mask)
    return result.to_pylist()

优缺点：

• ✅ 极致的内存效率，适合超大规模数据
• ✅ 支持序列化到磁盘，方便持久化和跨进程共享
• ✅ 内置并行处理能力，查询速度快
• ❌ 需要学习PyArrow的API，有一定学习成本
• ❌ 单条记录的增删改不如原生字典灵活，批量操作更高效

• 如果是中小规模百万级数据，优先选双索引原生字典或内存SQLite，前者代码更轻量，后者不用管索引维护
• 如果是超大规模数据（千万级+）或对内存敏感，选PyArrow
• 如果需要面向对象的记录封装，可以把方案1中的主索引值换成dataclasses或attrs定义的类实例，代码可读性更好

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