从文件名列表创建嵌套字典的实用指南

import os
from pathlib import Path

def extract_keys_from_filename(filename, root_key='vz'):
    """从文件名中提取键，移除文件扩展名和根键."""
    file_no_ext = Path(filename).stem  # 移除文件扩展名
    keys = file_no_ext.split('_')
    if root_key in keys:
        keys.remove(root_key)
    return keys

# 示例
filename = 'vz_ERA_Neural_Water_Forecast.npy'
keys = extract_keys_from_filename(filename)
print(keys)  # 输出: ['ERA', 'Neural', 'Water', 'Forecast']

def create_empty_nested_dict(structure):
    """根据给定的结构创建空的嵌套字典."""
    result = {}
    for key1, sub_dict1 in structure.items():
        result[key1] = {}
        for key2, sub_dict2 in sub_dict1.items():
            result[key1][key2] = {}
            for key3 in sub_dict2:
                result[key1][key2][key3] = None  # 或者任何默认值
    return result

# 示例结构
structure = {
    'Q': {
        'Polynomial': ['Reof', 'Training_Data'],
        'Neural': ['Reof', 'Training_Data']
    },
    'ERA': {
        'Polynomial': ['Reof', 'Training_Data'],
        'Neural': ['Reof', 'Training_Data']
    }
}

# 创建空的嵌套字典
vz_reloaded = create_empty_nested_dict(structure)
print(vz_reloaded)

import os
from pathlib import Path
import numpy as np
import xarray as xr

def populate_dictionary(directory, vz_reloaded, fileNamesAndTypes_check, root_key='vz'):
    """遍历目录，读取文件，并填充字典."""
    files = os.listdir(directory)
    # 移除不需要的文件
    if 'fileNamesAndTypes.txt' in files:
        files.remove('fileNamesAndTypes.txt')
    files = [f for f in files if not f.startswith('.')]

    for file in files:
        keys = extract_keys_from_filename(file, root_key)
        file_path = Path(directory, file)
        fileNoExt = Path(file).stem
        reloadedType = fileNamesAndTypes_check[fileNoExt]

        try:
            if reloadedType == str:
                with open(file_path, 'rb') as f:
                    contents = f.read()
            elif reloadedType == xr.core.dataset.Dataset:
                contents = xr.open_dataset(file_path)
            elif reloadedType == xr.core.dataarray.DataArray:
                contents = xr.open_dataarray(file_path)
            elif reloadedType == int:
                contents = np.load(file_path).item()
            elif reloadedType == list:
                contents = np.load(file_path).tolist()
            elif reloadedType == np.ndarray:
                contents = np.load(file_path)
            else:
                contents = None  # Handle other types as needed

            # 根据键的长度动态赋值
            if len(keys) == 3:
                vz_reloaded[keys[0]][keys[1]][keys[2]] = contents
            elif len(keys) == 4:
                vz_reloaded[keys[0]][keys[1]][keys[2]][keys[3]] = contents
            elif len(keys) == 5:
                vz_reloaded[keys[0]][keys[1]][keys[2]][keys[3]][keys[4]] = contents
            # 可以根据需要添加更多的嵌套层级
        except Exception as e:
            print(f"Error processing file {file}: {e}")
            print(f"Problematic keys: {keys}")

    return vz_reloaded

# 示例用法
# 假设 fc.selected 是你的根目录
#directory = Path(fc.selected, 'vz_save')
# 使用示例数据，替换为你的真实目录
directory = 'vz_save'

# 假设 fileNamesAndTypes_check 已经定义
#fileNamesAndTypes_check = ...
fileNamesAndTypes_check = {
    'ERA_Neural_Reof': str,
    'ERA_Neural_Training_Data': np.ndarray,
    'Q_Polynomial_Reof': str,
    'Q_Polynomial_Training_Data': np.ndarray,
}

# 确保目录存在
os.makedirs(directory, exist_ok=True)

# 创建示例文件
with open(Path(directory, 'ERA_Neural_Reof.txt'), 'w') as f:
    f.write("ERA Neural Reof Content")
np.save(Path(directory, 'ERA_Neural_Training_Data.npy'), np.array([1, 2, 3]))
with open(Path(directory, 'Q_Polynomial_Reof.txt'), 'w') as f:
    f.write("Q Polynomial Reof Content")
np.save(Path(directory, 'Q_Polynomial_Training_Data.npy'), np.array([4, 5, 6]))

vz_reloaded = create_empty_nested_dict(structure)
vz_reloaded = populate_dictionary(directory, vz_reloaded, fileNamesAndTypes_check)

print(vz_reloaded)