您可以使用dict_to_obj https://pypi.org/project/dict-to-obj/ 它完全符合你的要求

From dict_to_obj import DictToObj
a = {
'foo': True
}
b = DictToObj(a)
b.foo
True

class AttrDict(dict):

     def __init__(self):
           self.__dict__ = self

if __name__ == '____main__':

     d = AttrDict()
     d['ray'] = 'hope'
     d.sun = 'shine'  >>> Now we can use this . notation
     print d['ray']
     print d.sun

显然，现在有一个库- https://pypi.python.org/pypi/attrdict -实现了这个确切的功能，加上递归合并和json加载。也许值得一看。

这个答案摘自Luciano Ramalho的《流利的Python》一书。这要归功于那个家伙。

class AttrDict:
    """A read-only façade for navigating a JSON-like object
    using attribute notation
    """

    def __init__(self, mapping):
        self._data = dict(mapping)

    def __getattr__(self, name):
        if hasattr(self._data, name):
            return getattr(self._data, name)
        else:
            return AttrDict.build(self._data[name])

    @classmethod
    def build(cls, obj):
        if isinstance(obj, Mapping):
            return cls(obj)
        elif isinstance(obj, MutableSequence):
            return [cls.build(item) for item in obj]
        else:
            return obj

in the init we are taking the dict and making it a dictionary. when getattr is used we try to get the attribute from the dict if the dict already has that attribute. or else we are passing the argument to a class method called build. now build does the intresting thing. if the object is dict or a mapping like that, the that object is made an attr dict itself. if it's a sequence like list, it's passed to the build function we r on right now. if it's anythin else, like str or int. return the object itself.

我发现自己想知道python生态系统中“字典键作为attr”的当前状态。正如一些评论者所指出的，这可能不是你想要从头开始的东西，因为有几个陷阱和脚枪，其中一些非常微妙。此外，我不建议使用Namespace作为基类，我已经走上了那条路，它并不漂亮。

幸运的是，有几个开源包提供了这个功能，可以安装了!不幸的是，有几个包。以下是截至2019年12月的概要。

竞争者(最近提交到|#提交|#投稿|覆盖率%):

上瘾者(2021-01-05 | 229 | | 100%)22 蒙克(2021-01-22 | 166 | 17 | ?) easydict (2021-02-28 | 54 | 7% | ?) attrdict(| 108 | 5 |地址:100%) prodict (2021-03-06 | 100 | 2 | ?)

不再保养或保养不足:

treedict (2014-03-28 | 95 | 2 | ?) bunch (2012-03-12 | 20% | 2 | ?) NeoBunch

目前我推荐咀嚼或上瘾。它们拥有最多的提交、贡献者和发布，这意味着它们都有一个健康的开源代码库。他们有最干净的自述。Md, 100%的覆盖率，以及一组好看的测试。

我在这场比赛中没有一只狗(现在!)，除了滚动我自己的dict/attr代码，浪费了大量的时间，因为我不知道所有这些选项:)。我可能会在未来贡献给addict/munch，因为我宁愿看到一个完整的包，而不是一堆碎片化的包。如果你喜欢它们，就投稿吧!特别是，看起来munch可以使用codecov徽章，addict可以使用python版本徽章。

瘾君子优点:

递归初始化(foo.a.b.c = 'bar')，类字典参数成为成瘾。Dict

成瘾的缺点:

阴影打字。词典，如果你从成瘾进口词典 不检查密钥。由于允许递归init，如果你拼错了一个键，你只是创建一个新属性，而不是KeyError(感谢AljoSt)

蒙克优点:

独特的命名 内置的JSON和YAML的ser/de函数

蒙克缺点:

没有递归初始化(你不能构造foo.a.b.c = 'bar'，你必须设置foo.a.b.c = 'bar')。A，然后foo, A。b等。

其中我发表评论

Many moons ago, when I used text editors to write python, on projects with only myself or one other dev, I liked the style of dict-attrs, the ability to insert keys by just declaring foo.bar.spam = eggs. Now I work on teams, and use an IDE for everything, and I have drifted away from these sorts of data structures and dynamic typing in general, in favor of static analysis, functional techniques and type hints. I've started experimenting with this technique, subclassing Pstruct with objects of my own design:

class  BasePstruct(dict):
    def __getattr__(self, name):
        if name in self.__slots__:
            return self[name]
        return self.__getattribute__(name)

    def __setattr__(self, key, value):
        if key in self.__slots__:
            self[key] = value
            return
        if key in type(self).__dict__:
            self[key] = value
            return
        raise AttributeError(
            "type object '{}' has no attribute '{}'".format(type(self).__name__, key))


class FooPstruct(BasePstruct):
    __slots__ = ['foo', 'bar']

This gives you an object which still behaves like a dict, but also lets you access keys like attributes, in a much more rigid fashion. The advantage here is I (or the hapless consumers of your code) know exactly what fields can and can't exist, and the IDE can autocomplete fields. Also subclassing vanilla dict means json serialization is easy. I think the next evolution in this idea would be a custom protobuf generator which emits these interfaces, and a nice knock-on is you get cross-language data structures and IPC via gRPC for nearly free.

如果您决定使用attrt -dicts，那么为了您自己(和您的队友)的理智，有必要记录期望哪些字段。

请随意编辑/更新这篇文章，以保持它的最新!

你可以用我刚做的这个类来做。对于这个类，您可以像使用另一个字典(包括json序列化)一样使用Map对象，或者使用点表示法。希望对你有所帮助:

class Map(dict):
    """
    Example:
    m = Map({'first_name': 'Eduardo'}, last_name='Pool', age=24, sports=['Soccer'])
    """
    def __init__(self, *args, **kwargs):
        super(Map, self).__init__(*args, **kwargs)
        for arg in args:
            if isinstance(arg, dict):
                for k, v in arg.iteritems():
                    self[k] = v

        if kwargs:
            for k, v in kwargs.iteritems():
                self[k] = v

    def __getattr__(self, attr):
        return self.get(attr)

    def __setattr__(self, key, value):
        self.__setitem__(key, value)

    def __setitem__(self, key, value):
        super(Map, self).__setitem__(key, value)
        self.__dict__.update({key: value})

    def __delattr__(self, item):
        self.__delitem__(item)

    def __delitem__(self, key):
        super(Map, self).__delitem__(key)
        del self.__dict__[key]

使用例子:

m = Map({'first_name': 'Eduardo'}, last_name='Pool', age=24, sports=['Soccer'])
# Add new key
m.new_key = 'Hello world!'
print m.new_key
print m['new_key']
# Update values
m.new_key = 'Yay!'
# Or
m['new_key'] = 'Yay!'
# Delete key
del m.new_key
# Or
del m['new_key']