Python处理大规模对象时间序列：更高效的数据结构选型咨询

你的核心问题在于：嵌套字典用np.savez存储时，内层字典会被numpy通过pickle序列化，导致读写慢、文件体积大。下面针对你的场景，给出几种适配的高效方案，附代码示例和优缺点对比：

一、NumPy结构化数组（固定序列长度场景首选） #

如果所有对象的时间序列长度完全一致（比如你提到的每个属性约1000个时间点），结构化数组是最优选择——它把每个对象的所有属性打包成统一结构，直接用numpy原生序列化，完全避免pickle开销。

import numpy as np

# 假设所有对象的时间序列长度固定为1000
seq_len = 1000
# 定义结构化数据类型：包含对象ID和所有属性数组
dtype = [
    ('obj_id', 'U20'),          # 对象名称（字符串类型）
    ('time', f'f8({seq_len})'), # 时间序列（float64数组）
    ('x', f'f8({seq_len})'),    # 属性x的序列
    ('vx', f'f8({seq_len})'),   # 属性vx的序列
    # 其余97个属性按此格式添加
]

# 初始化十万个对象的结构化数组
num_objs = 100000
data = np.zeros(num_objs, dtype=dtype)

# 填充数据（示例逻辑）
for i in range(num_objs):
    obj_id = f'obj{i}'
    data['obj_id'][i] = obj_id
    data['time'][i] = np.arange(seq_len)
    data['x'][i] = np.random.randn(seq_len)
    data['vx'][i] = np.random.randn(seq_len)

# 保存与读取
np.save('structured_ts_data.npy', data)
loaded_data = np.load('structured_ts_data.npy')

# 访问方式
# 取第0个对象的x属性序列
print(loaded_data['x'][0])
# 通过对象ID查找属性（需自行构建索引映射）
obj_idx = np.where(loaded_data['obj_id'] == 'obj123')[0][0]
print(loaded_data['vx'][obj_idx])

优点：读写速度最快，存储体积最小，完全保留属性名称与对象-属性映射；内存占用极低。
缺点：强制要求所有对象的时间序列长度一致；按对象名称查找需要额外构建索引，不如字典直接按键访问便捷。

二、HDF5文件（h5py，兼容原字典逻辑首选） #

如果要完全保留你原来的嵌套字典访问习惯，同时解决存储效率问题，HDF5是最佳选择——它支持嵌套分组结构，直接存储numpy数组，还能启用压缩，完全规避pickle的开销。

import h5py
import numpy as np

# 模拟你原有的嵌套字典数据
properties = {
    'obj1':{'time':np.arange(10),'x':np.random.randn(10),'vx':np.random.randn(10)},
    'obj2': {'time':np.arange(15),'x':np.random.randn(15),'vx':np.random.randn(15)}
}

# 保存数据（启用gzip压缩）
with h5py.File('ts_data.h5', 'w') as f:
    for obj_id, attrs in properties.items():
        obj_group = f.create_group(obj_id)
        for attr_name, arr in attrs.items():
            obj_group.create_dataset(attr_name, data=arr, compression='gzip')

# 读取数据（完全还原嵌套字典结构）
loaded_properties = {}
with h5py.File('ts_data.h5', 'r') as f:
    for obj_id in f.keys():
        obj_group = f[obj_id]
        loaded_properties[obj_id] = {
            attr_name: obj_group[attr_name][:] for attr_name in obj_group.keys()
        }

# 访问方式和原字典完全一致
print(loaded_properties['obj1']['x'])

优点：100%兼容原有代码的字典访问逻辑，无需大幅修改；支持压缩，文件体积远小于np.savez；支持部分读取（比如只加载某个对象的单个属性，不用读整个文件）。
缺点：需要额外安装h5py库；HDF5是二进制格式，无法用文本编辑器直接查看。

三、Pandas分层索引+Parquet（序列长度不一致+数据分析场景首选） #

如果对象的时间序列长度不一致，且后续需要做数据分析、筛选操作，用Pandas的分层索引（对象ID+时间点）结合Parquet列式存储是合适的选择。

import pandas as pd
import numpy as np

# 生成示例数据（支持不同长度的时间序列）
objects = []
for obj_id in ['obj1', 'obj2']:
    seq_len = 10 if obj_id == 'obj1' else 15
    time = np.arange(seq_len)
    x = np.random.randn(seq_len)
    vx = np.random.randn(seq_len)
    df_obj = pd.DataFrame({
        'obj_id': [obj_id]*seq_len,
        'time': time,
        'x': x,
        'vx': vx
    })
    objects.append(df_obj)

# 合并为总表并设置分层索引
df = pd.concat(objects, ignore_index=True)
df = df.set_index(['obj_id', 'time'])

# 保存为Parquet格式（压缩率高、读写快）
df.to_parquet('multi_ts_data.parquet')
# 读取
loaded_df = pd.read_parquet('multi_ts_data.parquet')

# 访问方式
# 取单个对象的所有属性
obj1_data = loaded_df.loc['obj1']
# 取单个对象的某个属性
obj1_x = loaded_df.loc['obj1', 'x']
# 取所有对象在某个时间点的x属性
time_5_x = loaded_df.x.xs(5, level='time')

优点：完美支持不同长度的时间序列；Parquet列式存储压缩率高，读写速度快；访问方式灵活，支持按对象、时间、属性快速筛选。
缺点：超大规模数据（如1e8条记录）会占用较多内存，需分块读写；与原字典访问逻辑差异较大，需要修改代码。

方案选择总结 #

1. 若所有对象时间序列长度固定：优先选NumPy结构化数组，效率最高。
2. 若要保留原字典访问逻辑：优先选HDF5（h5py），零适配成本且解决存储问题。
3. 若需后续数据分析+序列长度不一致：选Pandas+Parquet。
4. 完全不建议继续用嵌套字典+np.savez，也不推荐记录数组（与结构化数组无本质差异）、表结构对象列表（内存占用高、序列化效率低）。

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