像属性一样访问字典键？

这并没有回答原问题，但对于像我一样在寻找提供此功能的库时来到这里的人们应该很有用。

Addict 是一个很棒的库，可以解决之前回答中提到的许多问题：https://github.com/mewwts/addict

以下是文档中的一个示例：

body = {
    'query': {
        'filtered': {
            'query': {
                'match': {'description': 'addictive'}
            },
            'filter': {
                'term': {'created_by': 'Mats'}
            }
        }
    }
}

使用 addict:

from addict import Dict
body = Dict()
body.query.filtered.query.match.description = 'addictive'
body.query.filtered.filter.term.created_by = 'Mats'

通常情况下，它并不起作用。并非所有有效的字典键都可以成为可寻址属性（“键”）。因此，您需要小心处理。

Python对象基本上都是字典。因此，我怀疑没有太多性能或其他惩罚。

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

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是修复"bunches"的pickle / unpickle问题的方法-如果有兴趣，请查看https://github.com/scikit-learn/scikit-learn/issues/6196。

这是一个使用内置 collections.namedtuple 的不可变记录的简短示例：

def record(name, d):
    return namedtuple(name, d.keys())(**d)

和一个用法示例：

rec = record('Model', {
    'train_op': train_op,
    'loss': loss,
})

print rec.loss(..)

由于以下原因，我对现有的选项不满意，于是开发了MetaDict。它与dict完全相同，但可以使用点符号和IDE自动完成，避免了其他解决方案的潜在命名空间冲突和缺陷。所有功能和用法示例都可以在GitHub上找到（请参阅上面的链接）。

完全透明披露：我是MetaDict的作者。

我尝试其他解决方案时遇到的缺陷/限制：

• Addict
  • 没有IDE中的键自动完成
  • 无法关闭嵌套键分配
  • 新分配的dict对象未转换为支持属性样式键访问
  • 会覆盖内置类型Dict
• Prodict
  • 没有定义静态架构(类似于dataclass)，IDE中没有键自动完成
  • 在内置可迭代对象list或其他嵌套在其中的dict对象中没有递归转换
• AttrDict
  • 没有IDE中的键自动完成
  • 在幕后将list对象转换为tuple
• Munch
  • items()，update()等内置方法可以被obj.items=[1,2,3]重写
  • 在内置可迭代对象list或其他嵌套在其中的dict对象中没有递归转换
• EasyDict
  • 只有字符串是有效键，但dict接受所有可哈希对象作为键
  • items()，update()等内置方法可以被obj.items=[1,2,3]重写
  • 内置方法的行为与预期不同：obj.pop('unknown_key', None)会引发AttributeError

显然，现在有一个库可以实现这个功能 - https://pypi.python.org/pypi/attrdict - 它不仅实现了这个功能，还包括递归合并和json加载。值得一看。

使用SimpleNamespace：

from types import SimpleNamespace

obj = SimpleNamespace(color="blue", year=2050)

print(obj.color) #> "blue"
print(obj.year) #> 2050

编辑 / 更新：从词典开始更接近回答OP的问题：

from types import SimpleNamespace

params = {"color":"blue", "year":2020}

obj = SimpleNamespace(**params)

print(obj.color) #> "blue"
print(obj.year) #> 2050

这是我使用的内容。

args = {
        'batch_size': 32,
        'workers': 4,
        'train_dir': 'train',
        'val_dir': 'val',
        'lr': 1e-3,
        'momentum': 0.9,
        'weight_decay': 1e-4
    }
args = namedtuple('Args', ' '.join(list(args.keys())))(**args)

print (args.lr)

你可以使用我刚刚制作的这个类来完成。使用这个类，你可以像使用另一个字典一样（包括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']

最简单的方法是定义一个称为 Namespace 的类，并在字典上使用 dict.update() 方法。然后，该字典将被视为一个对象。

class Namespace(object):
    '''
    helps referencing object in a dictionary as dict.key instead of dict['key']
    '''
    def __init__(self, adict):
        self.__dict__.update(adict)



Person = Namespace({'name': 'ahmed',
                     'age': 30}) #--> added for edge_cls


print(Person.name)