Ruby嵌套哈希生成代码解析及Python等效实现咨询

一、原Ruby代码功能 #

你猜的没错，这段代码就是用来创建无限层级的自动嵌套哈希——访问任意不存在的键时，会自动生成新的嵌套哈希，不用手动初始化每一层结构。

逐行拆解逻辑：

• x = ->(h, k) { h[k] = Hash.new(&x) }：这是一个Ruby lambda（匿名函数），参数h是当前哈希，k是被访问的不存在的键。当哈希遇到未定义的键时，这个lambda会被触发，把k对应的值设为一个新哈希，而且这个新哈希的默认处理逻辑还是这个lambda，实现了递归嵌套的自动生成。
• @abc = Hash.new(&x)：创建根哈希@abc，把上面的lambda设为它的默认处理器。从此访问@abc里不存在的键，就会自动生成下一层嵌套哈希。

举个实际使用的例子：

@abc[:a][:b][:c] = 123
puts @abc[:a][:b][:c] # 输出 123
puts @abc[:a][:d]      # 输出一个空的嵌套哈希（自动生成的）

二、Python等价实现 #

Python没有Ruby哈希默认proc的直接对应，但可以通过两种方式实现相同的自动嵌套效果：

方式1：自定义字典类 #

通过重写__getitem__方法，让访问不存在的键时自动创建嵌套字典：

class NestedDict(dict):
    def __getitem__(self, key):
        if key not in self:
            self[key] = NestedDict()
        return super().__getitem__(key)

# 使用示例
abc = NestedDict()
abc['a']['b']['c'] = 123
print(abc['a']['b']['c'])  # 输出 123
print(abc['a']['d'])       # 输出空的NestedDict对象

方式2：用collections.defaultdict递归定义 #

利用defaultdict的默认工厂函数特性，递归生成嵌套结构：

from collections import defaultdict

def nested_dict():
    return defaultdict(nested_dict)

# 使用示例
abc = nested_dict()
abc['a']['b']['c'] = 123
print(abc['a']['b']['c'])  # 输出 123

如果需要把嵌套结构转成普通字典，可以加个辅助函数：

def to_regular_dict(nested):
    if isinstance(nested, defaultdict):
        return {k: to_regular_dict(v) for k, v in nested.items()}
    return nested

print(to_regular_dict(abc))  # 输出 {'a': {'b': {'c': 123}, 'd': {}}}

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