编辑:NeoBunch是废弃的，Munch(上面提到过)可以作为一个替代品。不过，我把这个解决方案留在这里，它可能对某些人有用。

正如Doug所指出的，有一个Bunch包，你可以使用它来实现obj。关键功能。实际上有一个更新的版本叫做

尼奥邦克·蒙克

它有一个伟大的功能，通过neobunchify函数将你的字典转换为NeoBunch对象。我经常使用Mako模板，将数据作为NeoBunch对象传递使它们更具可读性，所以如果你碰巧在你的Python程序中使用了一个普通的字典，但想要在Mako模板中使用点符号，你可以这样使用:

from mako.template import Template
from neobunch import neobunchify

mako_template = Template(filename='mako.tmpl', strict_undefined=True)
data = {'tmpl_data': [{'key1': 'value1', 'key2': 'value2'}]}
with open('out.txt', 'w') as out_file:
    out_file.write(mako_template.render(**neobunchify(data)))

Mako模板看起来像这样:

% for d in tmpl_data:
Column1     Column2
${d.key1}   ${d.key2}
% endfor

我发现自己想知道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，那么为了您自己(和您的队友)的理智，有必要记录期望哪些字段。

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

其中我回答了被问到的问题

为什么Python不开箱即用呢?

我怀疑这与Python的禅意有关:“应该有一种——最好只有一种——明显的方法来做到这一点。”这将创建两种明显的方法来访问字典中的值:obj['key']和obj.key。

注意事项和陷阱

这包括代码中可能缺乏清晰性和混乱。也就是说，下面的内容可能会让以后要维护您的代码的人感到困惑，如果您暂时不回去的话，甚至会让您感到困惑。禅宗说:“可读性很重要!”

>>> KEY = 'spam'
>>> d[KEY] = 1
>>> # Several lines of miscellaneous code here...
... assert d.spam == 1

如果d被实例化，或者KEY被定义，或者d[KEY]被赋值的位置远离d.s spam的使用位置，那么很容易导致对正在执行的操作的混淆，因为这不是一个常用的习惯用法。我知道这可能会让我感到困惑。

另外，如果你像下面这样改变KEY的值(但是没有改变d.s rspam)，你现在得到:

>>> KEY = 'foo'
>>> d[KEY] = 1
>>> # Several lines of miscellaneous code here...
... assert d.spam == 1
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
AttributeError: 'C' object has no attribute 'spam'

在我看来，不值得这么努力。

其他物品

正如其他人所注意到的，您可以使用任何可哈希对象(不仅仅是字符串)作为dict键。例如,

>>> d = {(2, 3): True,}
>>> assert d[(2, 3)] is True
>>> 

是合法的，但是

>>> C = type('C', (object,), {(2, 3): True})
>>> d = C()
>>> assert d.(2, 3) is True
  File "<stdin>", line 1
  d.(2, 3)
    ^
SyntaxError: invalid syntax
>>> getattr(d, (2, 3))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: getattr(): attribute name must be string
>>> 

不是。这使您可以访问字典键的整个范围的可打印字符或其他可哈希对象，而在访问对象属性时则没有这些权限。这使得缓存对象元类这样的魔法成为可能，就像Python Cookbook(第9章)中的食谱一样。

其中我发表评论

我更喜欢垃圾邮件的美感。eggs over spam['eggs'](我认为它看起来更干净)，当我遇到namedtuple时，我真的开始渴望这个功能。但是能够做以下事情的便利性胜过它。

>>> KEYS = 'spam eggs ham'
>>> VALS = [1, 2, 3]
>>> d = {k: v for k, v in zip(KEYS.split(' '), VALS)}
>>> assert d == {'spam': 1, 'eggs': 2, 'ham': 3}
>>>

这是一个简单的例子，但我经常发现自己在不同的情况下使用字典，而不是使用obj。键符号(即，当我需要从XML文件中读取prefs时)。在其他情况下，当我想实例化一个动态类并为其添加一些属性时，我继续使用字典来保持一致性，以增强可读性。

我相信OP早就解决了这个问题，让他满意了，但如果他仍然想要这个功能，那么我建议他从pypi下载一个提供该功能的包:

邦奇是我更熟悉的人。dict的子类，所以你有所有的功能。 AttrDict看起来也很不错，但我对它不熟悉，也没有像我对Bunch那样详细地查看源代码。 上瘾是积极维护，并提供attrlike访问和更多。 正如Rotareti在评论中提到的，Bunch已经被弃用了，但是有一个活跃的分支叫做Munch。

但是，为了提高代码的可读性，我强烈建议他不要混合使用他的符号风格。如果他喜欢这种表示法，那么他应该简单地实例化一个动态对象，添加他想要的属性，然后收工:

>>> C = type('C', (object,), {})
>>> d = C()
>>> d.spam = 1
>>> d.eggs = 2
>>> d.ham = 3
>>> assert d.__dict__ == {'spam': 1, 'eggs': 2, 'ham': 3}

其中我更新，在评论中回答一个后续问题

在下面的评论中，Elmo问道:

如果你想再深入一点呢?(指类型(…))

虽然我从未使用过这个用例(同样，我倾向于使用嵌套的dict，对于 一致性)，下面的代码工作:

>>> C = type('C', (object,), {})
>>> d = C()
>>> for x in 'spam eggs ham'.split():
...     setattr(d, x, C())
...     i = 1
...     for y in 'one two three'.split():
...         setattr(getattr(d, x), y, i)
...         i += 1
...
>>> assert d.spam.__dict__ == {'one': 1, 'two': 2, 'three': 3}

为了给答案增加一些变化，sci-kit learn将其实现为一串:

class Bunch(dict):                                                              
    """ Scikit Learn's container object                                         

    Dictionary-like object that exposes its keys as attributes.                 
    >>> b = Bunch(a=1, b=2)                                                     
    >>> b['b']                                                                  
    2                                                                           
    >>> b.b                                                                     
    2                                                                           
    >>> b.c = 6                                                                 
    >>> b['c']                                                                  
    6                                                                           
    """                                                                         

    def __init__(self, **kwargs):                                               
        super(Bunch, self).__init__(kwargs)                                     

    def __setattr__(self, key, value):                                          
        self[key] = value                                                       

    def __dir__(self):                                                          
        return self.keys()                                                      

    def __getattr__(self, key):                                                 
        try:                                                                    
            return self[key]                                                    
        except KeyError:                                                        
            raise AttributeError(key)                                           

    def __setstate__(self, state):                                              
        pass                       

您所需要的是获取setattr和getattr方法—getattr检查字典键，然后继续检查实际属性。setstaet是针对pickle /unpickling“bunch”的修复-如果感兴趣，请检查https://github.com/scikit-learn/scikit-learn/issues/6196

买者自负:出于某些原因，这样的类似乎会破坏多处理包。我只是在发现这个bug之前挣扎了一段时间，所以: 在python multiprocessing中查找异常

一般情况下它不成立。不是所有有效的dict键都有可寻址的属性(“键”)。所以，你要小心。

Python对象基本上都是字典。所以我怀疑会有什么表现或其他惩罚。