这情况我太懂了——4万多张医学图像逐个读写，光IO开销就能把时间拉到24小时以上。咱们直接上几个能把速度提上去的实招，核心都是减少不必要的IO操作和利用HDF5的底层优化：

1. 先预计算总容量，一次性创建目标数据集 #

HDF5动态扩容的开销极大，如果你每次写一张图就扩容一次，光是磁盘寻址的时间就够喝一壶的。所以第一步先统计所有源文件里的图像总数，然后直接创建一个固定大小的目标数据集，后续只需要往里面填数据就行。

统计总图像数的代码： #

import h5py
import numpy as np

# 替换成你的源文件列表，可以用glob批量获取
source_files = ["data1.h5", "data2.h5", "data3.h5"]
total_images = 0

for fname in source_files:
    with h5py.File(fname, "r") as f_in:
        # 遍历文件内所有数据集
        for dset_name in f_in:
            dset = f_in[dset_name]
            # 图像数量 = 前N-2维的乘积（最后两维是761x761）
            num_imgs = np.prod(dset.shape[:-2])
            total_images += num_imgs

print(f"总图像数：{total_images}")

2. 用批量复制替代逐张读写，优先用HDF5内部复制 #

逐张读写的IO次数是4万次，而批量复制能把IO次数降到源文件数×数据集数，效率提升几个数量级。更狠的是用HDF5的内部复制（不用把数据读到Python内存），直接在磁盘层面完成数据转移，速度更快。

批量写入的示例代码（结合内存优化）： #

with h5py.File("merged_images.h5", "w") as f_out:
    # 创建目标数据集：设置合适的块大小和压缩（可选）
    merged_dset = f_out.create_dataset(
        "images",
        shape=(total_images, 761, 761),
        dtype=np.float32,  # 替换成你的数据类型
        chunks=(64, 761, 761),  # 块大小适配磁盘IO，可根据内存调整
        compression="lzf"  # 轻量压缩，减少磁盘IO量，可选
    )

    current_idx = 0
    for fname in source_files:
        with h5py.File(fname, "r") as f_in:
            for dset_name in f_in:
                src_dset = f_in[dset_name]
                num_imgs = np.prod(src_dset.shape[:-2])
                
                # 分块处理（避免大数据集占满内存）
                batch_size = 1000  # 每次处理1000张，可根据内存调整
                for i in range(0, num_imgs, batch_size):
                    end_i = min(i + batch_size, num_imgs)
                    # 把源数据集的多维结构转成图像序列切片，写入目标数据集
                    # 这里用切片直接赋值，h5py会自动处理底层复制
                    merged_dset[current_idx+i : current_idx+end_i] = src_dset[()].reshape(-1, 761, 761)[i:end_i]
                
                current_idx += num_imgs
                print(f"已完成：{current_idx}/{total_images} 张")

如果你的数据集特别大（单数据集就有几万张图），可以用HDF5区域复制完全绕开内存：

# 替换上面的分块循环部分
src_shape = src_dset.shape
# 构造源数据集的选择区域：展开前N-2维为一维序列
src_sel = h5py.MultiBlockSlice(
    tuple([slice(None)]*(len(src_shape)-2)) + (slice(None), slice(None)),
    start=0,
    count=num_imgs
)
# 直接复制到目标数据集的对应区间
merged_dset[current_idx : current_idx+num_imgs] = src_dset[src_sel]

3. 可选：多进程并行读取（注意写入单线程） #

如果你的CPU和磁盘IO有闲置，可以用多进程读取源文件，把数据块传给主进程统一写入目标文件（HDF5不支持多进程同时写同一个文件，所以写入必须单线程）。

多进程示例简化版： #

from multiprocessing import Pool

def process_file(fname):
    """子进程处理单个源文件，返回图像数据块和起始索引"""
    data_blocks = []
    with h5py.File(fname, "r") as f_in:
        for dset_name in f_in:
            src_dset = f_in[dset_name]
            num_imgs = np.prod(src_dset.shape[:-2])
            data = src_dset[()].reshape(-1, 761, 761)
            data_blocks.append((data, num_imgs))
    return data_blocks

# 启动多进程池
with Pool(processes=4) as pool:
    results = pool.map(process_file, source_files)

# 主进程统一写入
with h5py.File("merged_images.h5", "w") as f_out:
    merged_dset = f_out.create_dataset(
        "images", shape=(total_images, 761, 761), dtype=np.float32
    )
    current_idx = 0
    for file_blocks in results:
        for data, num_imgs in file_blocks:
            merged_dset[current_idx : current_idx+num_imgs] = data
            current_idx += num_imgs

关键注意事项 #

• 数据类型统一：确保所有源数据集的 dtype 和目标数据集一致，避免转换开销。
• 块大小调优：chunks参数不要设太小（会增加IO次数），也不要太大（占用内存多），比如64张图一块是比较常用的选择。
• 压缩选择：lzf是轻量压缩，几乎不占CPU；如果追求更高压缩比可以用gzip，但CPU开销会增加，需要根据你的硬件权衡。
• 先小量测试：先用几个小文件验证代码正确性，再跑全量数据，避免白跑十几个小时。

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