blocks|key|2684028|text|从dict派生，并实现__getattr__和__setattr__。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2684029|或者，您可以使用非常类似的Bunch。|2684030|我不认为monkeypatch内置的dict类是可能的。|2684031|entityMap|0|LINK|mutability|MUTABLE|url|http://code.activestate.com/recipes/52308-the-simple-but-handy-collector-of-a-bunch-of-named/^0|B|B|N|B|0|D|5|0|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@$9|S|A|T|B|C]|$9|U|A|V|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|W|8|@]|D|@$9|X|A|Y|1|Z]]|E|$]]|$1|H|3|I|5|6|7|10|8|@]|D|@]|E|$]]|$1|J|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|K|$L|$5|M|N|O|E|$P|Q]]]]

Derive from dict and and implement <code>__getattr__</code> and <code>__setattr__</code>.

Or you can use <a href="http://code.activestate.com/recipes/52308-the-simple-but-handy-collector-of-a-bunch-of-named/" rel="noreferrer">Bunch</a> which is very similar.

I don't think it's possible to monkeypatch built-in dict class.

blocks|key|156449|text|在Python中，属性访问和索引是两件不同的事情，您不应该希望它们执行相同的操作。如果你有一些东西应该有可访问的属性，那么创建一个类(可能是由namedtuple制作的)，并使用[]表示法从字典中获取一个条目。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|156450|entityMap^0|1Z|A|2H|2|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

Don't. Attribute access and indexing are separate things in Python, and you shouldn't want them to perform the same. Make a class (possibly one made by <code>namedtuple</code>) if you have something that should have accessible attributes and use <code>[]</code> notation to get an item from a dict.

blocks|key|2684104|text|语言本身不支持这一点，但有时这仍然是一个有用的需求。除了Bunch方法之外，您还可以编写一个小方法，该方法可以使用虚线字符串访问字典：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2684105|def+get_var(input_dict,+accessor_string):
++++"""Gets+data+from+a+dictionary+using+a+dotted+accessor-string"""
++++current_data+=+input_dict
++++for+chunk+in+accessor_string.split('.'):
++++++++current_data+=+current_data.get(chunk,+{})
++++return+current_data|code-block|syntax|javascript|2684106|它会支持这样的东西：|2684107|>>+test_dict+=+{'thing':+{'spam':+12,+'foo':+{'cheeze':+'bar'}}}
>>+output+=+get_var(test_dict,+'thing.spam.foo.cheeze')
>>+print+output
'bar'
>>|2684108|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

The language itself doesn't support this, but sometimes this is still a useful requirement. Besides the Bunch recipe, you can also write a little method which can access a dictionary using a dotted string:

<pre><code>def get_var(input_dict, accessor_string):
 """Gets data from a dictionary using a dotted accessor-string"""
 current_data = input_dict
 for chunk in accessor_string.split('.'):
 current_data = current_data.get(chunk, {})
 return current_data
</code></pre>

which would support something like this:

<pre><code>&gt;&gt; test_dict = {'thing': {'spam': 12, 'foo': {'cheeze': 'bar'}}}
&gt;&gt; output = get_var(test_dict, 'thing.spam.foo.cheeze')
&gt;&gt; print output
'bar'
&gt;&gt;
</code></pre>

blocks|key|155655|text|我试过这个：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|155656|class+dotdict(dict):
++++def+__getattr__(self,+name):
++++++++return+self[name]|code-block|syntax|javascript|155657|你也可以试试__getattribute__。|offset|length|style|CODE|155658|让每个字典都是一种点字典就足够了，如果你想从一个多层字典中初始化它，也可以尝试实现__init__。|155659|entityMap^0|0|0|6|G|0|15|8|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@$I|T|J|U|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|V|8|@$I|W|J|X|K|L]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|P|$]]

I tried this:

<pre><code>class dotdict(dict):
 def __getattr__(self, name):
 return self[name]
</code></pre>

you can try <code>__getattribute__</code> too.

make every dict a type of dotdict would be good enough, if you want to init this from a multi-layer dict, try implement <code>__init__</code> too.

blocks|key|901793|text|基于Kugel的回答，并考虑到Mike+Graham的警告，如果我们做一个包装器呢？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|901794|class+DictWrap(object):
++"""+Wrap+an+existing+dict,+or+create+a+new+one,+and+access+with+either+dot+
++++notation+or+key+lookup.

++++The+attribute+_data+is+reserved+and+stores+the+underlying+dictionary.
++++When+using+the+%2B=+operator+with+create=True,+the+empty+nested+dict+is+
++++replaced+with+the+operand,+effectively+creating+a+default+dictionary
++++of+mixed+types.

++++args:
++++++d({}):+Existing+dict+to+wrap,+an+empty+dict+is+created+by+default
++++++create(True):+Create+an+empty,+nested+dict+instead+of+raising+a+KeyError

++++example:
++++++>>>dw+=+DictWrap({'pp':3})
++++++>>>dw.a.b+%2B=+2
++++++>>>dw.a.b+%2B=+2
++++++>>>dw.a['c']+%2B=+'Hello'
++++++>>>dw.a['c']+%2B=+'+World'
++++++>>>dw.a.d
++++++>>>print+dw._data
++++++{'a':+{'c':+'Hello+World',+'b':+4,+'d':+{}},+'pp':+3}

++"""

++def+__init__(self,+d=None,+create=True):
++++if+d+is+None:
++++++d+=+{}
++++supr+=+super(DictWrap,+self)++
++++supr.__setattr__('_data',+d)
++++supr.__setattr__('__create',+create)

++def+__getattr__(self,+name):
++++try:
++++++value+=+self._data[name]
++++except+KeyError:
++++++if+not+super(DictWrap,+self).__getattribute__('__create'):
++++++++raise
++++++value+=+{}
++++++self._data[name]+=+value

++++if+hasattr(value,+'items'):
++++++create+=+super(DictWrap,+self).__getattribute__('__create')
++++++return+DictWrap(value,+create)
++++return+value

++def+__setattr__(self,+name,+value):
++++self._data[name]+=+value++

++def+__getitem__(self,+key):
++++try:
++++++value+=+self._data[key]
++++except+KeyError:
++++++if+not+super(DictWrap,+self).__getattribute__('__create'):
++++++++raise
++++++value+=+{}
++++++self._data[key]+=+value

++++if+hasattr(value,+'items'):
++++++create+=+super(DictWrap,+self).__getattribute__('__create')
++++++return+DictWrap(value,+create)
++++return+value

++def+__setitem__(self,+key,+value):
++++self._data[key]+=+value

++def+__iadd__(self,+other):
++++if+self._data:
++++++raise+TypeError("A+Nested+dict+will+only+be+replaced+if+it's+empty")
++++else:
++++++return+other|code-block|syntax|javascript|901795|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Building on Kugel's answer and taking Mike Graham's words of caution into consideration, what if we make a wrapper? 

<pre class="lang-py prettyprint-override"><code>class DictWrap(object):
 """ Wrap an existing dict, or create a new one, and access with either dot 
 notation or key lookup.

 The attribute _data is reserved and stores the underlying dictionary.
 When using the += operator with create=True, the empty nested dict is 
 replaced with the operand, effectively creating a default dictionary
 of mixed types.

 args:
 d({}): Existing dict to wrap, an empty dict is created by default
 create(True): Create an empty, nested dict instead of raising a KeyError

 example:
 &gt;&gt;&gt;dw = DictWrap({'pp':3})
 &gt;&gt;&gt;dw.a.b += 2
 &gt;&gt;&gt;dw.a.b += 2
 &gt;&gt;&gt;dw.a['c'] += 'Hello'
 &gt;&gt;&gt;dw.a['c'] += ' World'
 &gt;&gt;&gt;dw.a.d
 &gt;&gt;&gt;print dw._data
 {'a': {'c': 'Hello World', 'b': 4, 'd': {}}, 'pp': 3}

 """

 def __init__(self, d=None, create=True):
 if d is None:
 d = {}
 supr = super(DictWrap, self) 
 supr.__setattr__('_data', d)
 supr.__setattr__('__create', create)

 def __getattr__(self, name):
 try:
 value = self._data[name]
 except KeyError:
 if not super(DictWrap, self).__getattribute__('__create'):
 raise
 value = {}
 self._data[name] = value

 if hasattr(value, 'items'):
 create = super(DictWrap, self).__getattribute__('__create')
 return DictWrap(value, create)
 return value

 def __setattr__(self, name, value):
 self._data[name] = value 

 def __getitem__(self, key):
 try:
 value = self._data[key]
 except KeyError:
 if not super(DictWrap, self).__getattribute__('__create'):
 raise
 value = {}
 self._data[key] = value

 if hasattr(value, 'items'):
 create = super(DictWrap, self).__getattribute__('__create')
 return DictWrap(value, create)
 return value

 def __setitem__(self, key, value):
 self._data[key] = value

 def __iadd__(self, other):
 if self._data:
 raise TypeError("A Nested dict will only be replaced if it's empty")
 else:
 return other
</code></pre>

blocks|key|904632|text|我一直把它放在一个util文件中。你也可以在你自己的类中使用它作为混入。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|904633|class+dotdict(dict):
++++"""dot.notation+access+to+dictionary+attributes"""
++++__getattr__+=+dict.get
++++__setattr__+=+dict.__setitem__
++++__delattr__+=+dict.__delitem__

mydict+=+{'val':'it+works'}
nested_dict+=+{'val':'nested+works+too'}
mydict+=+dotdict(mydict)
mydict.val
#+'it+works'

mydict.nested+=+dotdict(nested_dict)
mydict.nested.val
#+'nested+works+too'|code-block|syntax|javascript|904634|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I've always kept this around in a util file. You can use it as a mixin on your own classes too.

<pre><code>class dotdict(dict):
 """dot.notation access to dictionary attributes"""
 __getattr__ = dict.get
 __setattr__ = dict.__setitem__
 __delattr__ = dict.__delitem__

mydict = {'val':'it works'}
nested_dict = {'val':'nested works too'}
mydict = dotdict(mydict)
mydict.val
# 'it works'

mydict.nested = dotdict(nested_dict)
mydict.nested.val
# 'nested works too'
</code></pre>

blocks|key|155749|text|通过pip安装dotmap|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|155750|pip+install+dotmap|code-block|syntax|javascript|155751|它可以做你想做的所有事情，并且是dict的子类，所以它的操作就像一个普通的字典：|155752|from+dotmap+import+DotMap

m+=+DotMap()
m.hello+=+'world'
m.hello
m.hello+%2B=+'!'
#+m.hello+and+m['hello']+now+both+return+'world!'
m.val+=+5
m.val2+=+'Sam'|155753|最重要的是，您可以将其与dict对象相互转换：|155754|d+=+m.toDict()
m+=+DotMap(d)+#+automatic+conversion+in+constructor|155755|这意味着如果您想要访问的内容已经在dict表单中，您可以将其转换为DotMap以便于访问：|155756|import+json
jsonDict+=+json.loads(text)
data+=+DotMap(jsonDict)
print+data.location.city|155757|最后，它会自动创建新的DotMap子实例，因此您可以执行以下操作：|155758|m+=+DotMap()
m.people.steve.age+=+31|155759|与Bunch的比较|155760|完全公开:我是DotMap的创建者。我创建它是因为Bunch缺少这些功能|155761|当您有大量来自order|155762|automatic的hierarchy|unordered-list-item|155763|
|155764|constructing并递归地将所有子DotMap实例转换为dict时，|155765|会记住项目的添加顺序并在创建DotMap|155766|子DotMap时进行迭代，这样可以节省时间并使代码更加整洁|155767|155768|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/drgrib/dotmap^0|2|3|7|6|0|0|G|4|0|0|C|4|0|0|H|4|X|6|0|0|B|6|0|0|0|P|5|7|6|0|0|0|0|0|K|6|V|4|0|E|6|0|1|6|0|0^^$0|@$1|2|3|4|5|6|7|1Q|8|@$9|1R|A|1S|B|C]|$9|1T|A|1U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|1V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1W|8|@$9|1X|A|1Y|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|1Z|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|20|8|@$9|21|A|22|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|H|7|23|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|24|8|@$9|25|A|26|B|C]|$9|27|A|28|B|C]]|D|@]|E|$]]|$1|U|3|V|5|H|7|29|8|@]|D|@]|E|$I|J]]|$1|W|3|X|5|6|7|2A|8|@$9|2B|A|2C|B|C]]|D|@]|E|$]]|$1|Y|3|Z|5|H|7|2D|8|@]|D|@]|E|$I|J]]|$1|10|3|11|5|6|7|2E|8|@]|D|@]|E|$]]|$1|12|3|13|5|6|7|2F|8|@$9|2G|A|2H|B|C]]|D|@$9|2I|A|2J|1|2K]]|E|$]]|$1|14|3|15|5|6|7|2L|8|@]|D|@]|E|$]]|$1|16|3|17|5|18|7|2M|8|@]|D|@]|E|$]]|$1|19|3|1A|5|6|7|2N|8|@]|D|@]|E|$]]|$1|1B|3|1C|5|18|7|2O|8|@$9|2P|A|2Q|B|C]|$9|2R|A|2S|B|C]]|D|@]|E|$]]|$1|1D|3|1E|5|18|7|2T|8|@$9|2U|A|2V|B|C]]|D|@]|E|$]]|$1|1F|3|1G|5|6|7|2W|8|@$9|2X|A|2Y|B|C]]|D|@]|E|$]]|$1|1H|3|-4|5|6|7|2Z|8|@]|D|@]|E|$]]|$1|1I|3|-4|5|6|7|30|8|@]|D|@]|E|$]]]|1J|$1K|$5|1L|1M|1N|E|$1O|1P]]]]

Install <code>dotmap</code> via <code>pip</code>

<pre><code>pip install dotmap
</code></pre>

It does everything you want it to do and subclasses <code>dict</code>, so it operates like a normal dictionary:

<pre><code>from dotmap import DotMap

m = DotMap()
m.hello = 'world'
m.hello
m.hello += '!'
# m.hello and m['hello'] now both return 'world!'
m.val = 5
m.val2 = 'Sam'
</code></pre>

On top of that, you can convert it to and from <code>dict</code> objects:

<pre><code>d = m.toDict()
m = DotMap(d) # automatic conversion in constructor
</code></pre>

This means that if something you want to access is already in <code>dict</code> form, you can turn it into a <code>DotMap</code> for easy access:

<pre><code>import json
jsonDict = json.loads(text)
data = DotMap(jsonDict)
print data.location.city
</code></pre>

Finally, it automatically creates new child <code>DotMap</code> instances so you can do things like this:

<pre><code>m = DotMap()
m.people.steve.age = 31
</code></pre>

<h2>Comparison to Bunch</h2>

Full disclosure: I am the creator of the <a href="https://github.com/drgrib/dotmap">DotMap</a>. I created it because <code>Bunch</code> was missing these features

<ul>
<li>remembering the order items are added and iterating in that order</li>
<li>automatic child <code>DotMap</code> creation, which saves time and makes for cleaner code when you have a lot of hierarchy</li>
<li>constructing from a <code>dict</code> and recursively converting all child <code>dict</code> instances to <code>DotMap</code></li>
</ul>

blocks|key|155791|text|我最终尝试了AttrDict和Bunch库，发现它们对我的使用来说太慢了。在我和一个朋友研究过后，我们发现编写这些库的main方法会导致库通过嵌套对象积极地递归，并从头到尾复制字典对象。考虑到这一点，我们做了两个关键的改变。1)我们创建了延迟加载的属性2)我们创建了轻量级代理对象的副本，而不是创建字典对象的副本。这是最终的实现。使用此代码的性能提升是难以置信的。当使用AttrDict或Bunch时，这两个库分别消耗了我请求时间的1/2和1/3+(什么！？)。这段代码将时间减少到几乎为零(在0.5ms范围内的某个地方)。当然，这取决于您的需求，但如果您在代码中经常使用此功能，则一定要使用类似下面这样的简单代码。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|155792|class+DictProxy(object):
++++def+__init__(self,+obj):
++++++++self.obj+=+obj

++++def+__getitem__(self,+key):
++++++++return+wrap(self.obj[key])

++++def+__getattr__(self,+key):
++++++++try:
++++++++++++return+wrap(getattr(self.obj,+key))
++++++++except+AttributeError:
++++++++++++try:
++++++++++++++++return+self[key]
++++++++++++except+KeyError:
++++++++++++++++raise+AttributeError(key)

++++#+you+probably+also+want+to+proxy+important+list+properties+along+like
++++#+items(),+iteritems()+and+__len__

class+ListProxy(object):
++++def+__init__(self,+obj):
++++++++self.obj+=+obj

++++def+__getitem__(self,+key):
++++++++return+wrap(self.obj[key])

++++#+you+probably+also+want+to+proxy+important+list+properties+along+like
++++#+__iter__+and+__len__

def+wrap(value):
++++if+isinstance(value,+dict):
++++++++return+DictProxy(value)
++++if+isinstance(value,+(tuple,+list)):
++++++++return+ListProxy(value)
++++return+value|code-block|syntax|javascript|155793|请参阅https://stackoverflow.com/users/704327/michael-merickel的原始实现here。|155794|另一件需要注意的事情是，这个实现非常简单，并没有实现您可能需要的所有方法。您需要根据需要在DictProxy或ListProxy对象上编写这些代码。|155795|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/bcj/AttrDict|1|https://github.com/dsc/bunch|2|https://stackoverflow.com/users/704327/michael-merickel|3|https://gist.github.com/mmerickel/ff4c6faf867d72c1f19c^0|6|8|0|F|5|1|0|0|3|1J|2|1R|4|3|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@$A|11|B|12|1|13]|$A|14|B|15|1|16]]|C|$]]|$1|D|3|E|5|F|7|17|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|18|8|@]|9|@$A|19|B|1A|1|1B]|$A|1C|B|1D|1|1E]]|C|$]]|$1|K|3|L|5|6|7|1F|8|@]|9|@]|C|$]]|$1|M|3|-4|5|6|7|1G|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]|U|$5|P|Q|R|C|$S|V]]|W|$5|P|Q|R|C|$S|X]]|Y|$5|P|Q|R|C|$S|Z]]]]

I ended up trying BOTH the <a href="https://github.com/bcj/AttrDict" rel="nofollow noreferrer">AttrDict</a> and the <a href="https://github.com/dsc/bunch" rel="nofollow noreferrer">Bunch</a> libraries and found them to be way to slow for my uses. After a friend and I looked into it, we found that the main method for writing these libraries results in the library aggressively recursing through a nested object and making copies of the dictionary object throughout. With this in mind, we made two key changes. 1) We made attributes lazy-loaded 2) instead of creating copies of a dictionary object, we create copies of a light-weight proxy object. This is the final implementation. The performance increase of using this code is incredible. When using AttrDict or Bunch, these two libraries alone consumed 1/2 and 1/3 respectively of my request time(what!?). This code reduced that time to almost nothing(somewhere in the range of 0.5ms). This of course depends on your needs, but if you are using this functionality quite a bit in your code, definitely go with something simple like this. 

<pre><code>class DictProxy(object):
 def __init__(self, obj):
 self.obj = obj

 def __getitem__(self, key):
 return wrap(self.obj[key])

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

 # you probably also want to proxy important list properties along like
 # items(), iteritems() and __len__

class ListProxy(object):
 def __init__(self, obj):
 self.obj = obj

 def __getitem__(self, key):
 return wrap(self.obj[key])

 # you probably also want to proxy important list properties along like
 # __iter__ and __len__

def wrap(value):
 if isinstance(value, dict):
 return DictProxy(value)
 if isinstance(value, (tuple, list)):
 return ListProxy(value)
 return value
</code></pre>

See the original implementation <a href="https://gist.github.com/mmerickel/ff4c6faf867d72c1f19c" rel="nofollow noreferrer">here</a> by <a href="https://stackoverflow.com/users/704327/michael-merickel">https://stackoverflow.com/users/704327/michael-merickel</a>.

The other thing to note, is that this implementation is pretty simple and doesn't implement all of the methods you might need. You'll need to write those as required on the DictProxy or ListProxy objects.

blocks|key|155810|text|您可以使用我刚刚创建的这个类来实现它。通过这个类，您可以像使用另一个字典(包括json序列化)一样使用Map对象，也可以使用点符号。我希望能帮助你：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|155811|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]|code-block|syntax|javascript|155812|用法示例：|BOLD|155813|m+=+Map({'first_name':+'Eduardo'},+last_name='Pool',+age=24,+sports=['Soccer'])
#+Add+new+key
m.new_key+=+'Hello+world!'
#+Or
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']|155814|entityMap^0|1F|3|0|0|0|5|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@$9|S|A|T|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|U|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|V|8|@$9|W|A|X|B|M]]|D|@]|E|$]]|$1|N|3|O|5|H|7|Y|8|@]|D|@]|E|$I|J]]|$1|P|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|Q|$]]

You can do it using this class I just made. With this class you can use the <code>Map</code> object like another dictionary(including json serialization) or with the dot notation. I hope to help you:

<pre><code>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]
</code></pre>

Usage examples:

<pre><code>m = Map({'first_name': 'Eduardo'}, last_name='Pool', age=24, sports=['Soccer'])
# Add new key
m.new_key = 'Hello world!'
# Or
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']
</code></pre>

blocks|key|2684417|text|此解决方案是对epool提供的解决方案的改进，以满足OP以一致的方式访问嵌套字典的需求。epool的解决方案不允许访问嵌套的字典。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2684418|class+YAMLobj(dict):
++++def+__init__(self,+args):
++++++++super(YAMLobj,+self).__init__(args)
++++++++if+isinstance(args,+dict):
++++++++++++for+k,+v+in+args.iteritems():
++++++++++++++++if+not+isinstance(v,+dict):
++++++++++++++++++++self[k]+=+v
++++++++++++++++else:
++++++++++++++++++++self.__setattr__(k,+YAMLobj(v))


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

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

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

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

++++def+__delitem__(self,+key):
++++++++super(YAMLobj,+self).__delitem__(key)
++++++++del+self.__dict__[key]|code-block|syntax|javascript|2684419|有了这个类，我们现在可以做一些类似的事情：A.B.C.D。|style|CODE|2684420|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/32107024/805357^0|7|5|0|0|0|L|7|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@$A|10|B|11|K|L]]|9|@]|C|$]]|$1|M|3|-4|5|6|7|12|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

This solution is a refinement upon the one offered by <a href="https://stackoverflow.com/a/32107024/805357">epool</a> to address the requirement of the OP to access nested dicts in a consistent manner. The solution by epool did not allow for accessing nested dicts.

<pre><code>class YAMLobj(dict):
 def __init__(self, args):
 super(YAMLobj, self).__init__(args)
 if isinstance(args, dict):
 for k, v in args.iteritems():
 if not isinstance(v, dict):
 self[k] = v
 else:
 self.__setattr__(k, YAMLobj(v))


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

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

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

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

 def __delitem__(self, key):
 super(YAMLobj, self).__delitem__(key)
 del self.__dict__[key]
</code></pre>

With this class, one can now do something like: <code>A.B.C.D</code>.

blocks|key|904731|text|def+dict_to_object(dick):
++++#+http://stackoverflow.com/a/1305663/968442

++++class+Struct:
++++++++def+__init__(self,+**entries):
++++++++++++self.__dict__.update(entries)

++++return+Struct(**dick)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|904732|如果决定永久地将dict转换为object，应该可以这样做。您可以在访问之前创建一个一次性对象。|unstyled|offset|length|style|CODE|904733|d+=+dict_to_object(d)|904734|entityMap^0|0|8|4|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|P|8|@$G|Q|H|R|I|J]]|9|@]|A|$]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$B|C]]|$1|M|3|-4|5|F|7|T|8|@]|9|@]|A|$]]]|N|$]]

<pre><code>def dict_to_object(dick):
 # http://stackoverflow.com/a/1305663/968442

 class Struct:
 def __init__(self, **entries):
 self.__dict__.update(entries)

 return Struct(**dick)
</code></pre>

If one decides to permanently convert that <code>dict</code> to object this should do. You can create a throwaway object just before accessing. 

<pre><code>d = dict_to_object(d)
</code></pre>

blocks|key|1275186|text|我想把我自己的解决方案抛到拳台上：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1275187|https://github.com/skorokithakis/jsane|offset|length|1275188|它允许您将JSON解析为可以访问with.attribute.lookups.like.this.r()的内容，这主要是因为我在开始研究之前没有看到这个答案。|style|CODE|1275189|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|12|0|0|G|10|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@$D|S|E|T|1|U]]|A|$]]|$1|F|3|G|5|6|7|V|8|@$D|W|E|X|H|I]]|9|@]|A|$]]|$1|J|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|K|$L|$5|M|N|O|A|$P|C]]]]

I'd like to throw my own solution into the ring:

<a href="https://github.com/skorokithakis/jsane" rel="nofollow">https://github.com/skorokithakis/jsane</a>

It allows you to parse JSON into something you can access <code>with.attribute.lookups.like.this.r()</code>, mostly because I hadn't seen this answer before starting to work on it.

blocks|key|2684505|text|如果你想要修改你的字典，你需要在上面的答案中添加一些状态方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2684506|class+DotDict(dict):
++++"""dot.notation+access+to+dictionary+attributes"""
++++def+__getattr__(self,+attr):
++++++++return+self.get(attr)
++++__setattr__=+dict.__setitem__
++++__delattr__=+dict.__delitem__

++++def+__getstate__(self):
++++++++return+self

++++def+__setstate__(self,+state):
++++++++self.update(state)
++++++++self.__dict__+=+self|code-block|syntax|javascript|2684507|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

If you want to pickle your modified dictionary, you need to add few state methods to above answers:

<pre><code>class DotDict(dict):
 """dot.notation access to dictionary attributes"""
 def __getattr__(self, attr):
 return self.get(attr)
 __setattr__= dict.__setitem__
 __delattr__= dict.__delitem__

 def __getstate__(self):
 return self

 def __setstate__(self, state):
 self.update(state)
 self.__dict__ = self
</code></pre>

blocks|key|156674|text|Fabric有一个非常好的，最小的implementation。将其扩展为允许嵌套访问，我们可以使用defaultdict，结果如下所示：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|156675|from+collections+import+defaultdict

class+AttributeDict(defaultdict):
++++def+__init__(self):
++++++++super(AttributeDict,+self).__init__(AttributeDict)

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

++++def+__setattr__(self,+key,+value):
++++++++self[key]+=+value|code-block|syntax|javascript|156676|如下所示使用它：|156677|keys+=+AttributeDict()
keys.abc.xyz.x+=+123
keys.abc.xyz.a.b.c+=+234|156678|这对库格尔的回答“从字典派生并实现__getattr__和__setattr____”进行了一点阐述。现在你知道该怎么做了！|156679|entityMap|0|LINK|mutability|MUTABLE|url|http://www.fabfile.org/|1|https://github.com/fabric/fabric/blob/1.13.1/fabric/utils.py#L186^0|1E|B|0|6|0|H|E|1|0|0|0|0|H|B|T|B|0^^$0|@$1|2|3|4|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@$9|13|A|14|1|15]|$9|16|A|17|1|18]]|E|$]]|$1|F|3|G|5|H|7|19|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1A|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|1B|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1C|8|@$9|1D|A|1E|B|C]|$9|1F|A|1G|B|C]]|D|@]|E|$]]|$1|Q|3|-4|5|6|7|1H|8|@]|D|@]|E|$]]]|R|$S|$5|T|U|V|E|$W|X]]|Y|$5|T|U|V|E|$W|Z]]]]

<a href="http://www.fabfile.org" rel="noreferrer">Fabric</a> has a really nice, minimal <a href="https://github.com/fabric/fabric/blob/1.13.1/fabric/utils.py#L186" rel="noreferrer">implementation</a>. Extending that to allow for nested access, we can use a <code>defaultdict</code>, and the result looks something like this:

<pre><code>from collections import defaultdict

class AttributeDict(defaultdict):
 def __init__(self):
 super(AttributeDict, self).__init__(AttributeDict)

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

 def __setattr__(self, key, value):
 self[key] = value
</code></pre>

Make use of it as follows:

<pre><code>keys = AttributeDict()
keys.abc.xyz.x = 123
keys.abc.xyz.a.b.c = 234
</code></pre>

That elaborates a bit on Kugel's answer of "Derive from dict and and implement <code>__getattr__</code> and <code>__setattr__</code>". Now you know how!

blocks|key|2684625|text|不是对OP问题的直接回答，但受到一些人的启发，也许对他们有用。我已经使用内部__dict__创建了一个基于对象的解决方案(绝对不是优化代码)|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2684626|payload+=+{
++++"name":+"John",
++++"location":+{
++++++++"lat":+53.12312312,
++++++++"long":+43.21345112
++++},
++++"numbers":+[
++++++++{
++++++++++++"role":+"home",
++++++++++++"number":+"070-12345678"
++++++++},
++++++++{
++++++++++++"role":+"office",
++++++++++++"number":+"070-12345679"
++++++++}
++++]
}


class+Map(object):
++++"""
++++Dot+style+access+to+object+members,+access+raw+values
++++with+an+underscore+e.g.

++++class+Foo(Map):
++++++++def+foo(self):
++++++++++++return+self.get('foo')+%2B+'bar'

++++obj+=+Foo(**{'foo':+'foo'})

++++obj.foo+=>+'foobar'
++++obj._foo+=>+'foo'

++++"""

++++def+__init__(self,+*args,+**kwargs):
++++++++for+arg+in+args:
++++++++++++if+isinstance(arg,+dict):
++++++++++++++++for+k,+v+in+arg.iteritems():
++++++++++++++++++++self.__dict__[k]+=+v
++++++++++++++++++++self.__dict__['_'+%2B+k]+=+v

++++++++if+kwargs:
++++++++++++for+k,+v+in+kwargs.iteritems():
++++++++++++++++self.__dict__[k]+=+v
++++++++++++++++self.__dict__['_'+%2B+k]+=+v

++++def+__getattribute__(self,+attr):
++++++++if+hasattr(self,+'get_'+%2B+attr):
++++++++++++return+object.__getattribute__(self,+'get_'+%2B+attr)()
++++++++else:
++++++++++++return+object.__getattribute__(self,+attr)

++++def+get(self,+key):
++++++++try:
++++++++++++return+self.__dict__.get('get_'+%2B+key)()
++++++++except+(AttributeError,+TypeError):
++++++++++++return+self.__dict__.get(key)

++++def+__repr__(self):
++++++++return+u"<{name}+object>".format(
++++++++++++name=self.__class__.__name__
++++++++)


class+Number(Map):
++++def+get_role(self):
++++++++return+self.get('role')

++++def+get_number(self):
++++++++return+self.get('number')


class+Location(Map):
++++def+get_latitude(self):
++++++++return+self.get('lat')+%2B+1

++++def+get_longitude(self):
++++++++return+self.get('long')+%2B+1


class+Item(Map):
++++def+get_name(self):
++++++++return+self.get('name')+%2B+"+Doe"

++++def+get_location(self):
++++++++return+Location(**self.get('location'))

++++def+get_numbers(self):
++++++++return+[Number(**n)+for+n+in+self.get('numbers')]


#+Tests

obj+=+Item({'foo':+'bar'},+**payload)

assert+type(obj)+==+Item
assert+obj._name+==+"John"
assert+obj.name+==+"John+Doe"
assert+type(obj.location)+==+Location
assert+obj.location._lat+==+53.12312312
assert+obj.location._long+==+43.21345112
assert+obj.location.latitude+==+54.12312312
assert+obj.location.longitude+==+44.21345112

for+n+in+obj.numbers:
++++assert+type(n)+==+Number
++++if+n.role+==+'home':
++++++++assert+n.number+==+"070-12345678"
++++if+n.role+==+'office':
++++++++assert+n.number+==+"070-12345679"|code-block|syntax|javascript|2684627|entityMap^0|12|8|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

Not a direct answer to the OP's question, but inspired by and perhaps useful for some.. I've created an object-based solution using the internal <code>__dict__</code> (In no way optimized code)

<pre><code>payload = {
 "name": "John",
 "location": {
 "lat": 53.12312312,
 "long": 43.21345112
 },
 "numbers": [
 {
 "role": "home",
 "number": "070-12345678"
 },
 {
 "role": "office",
 "number": "070-12345679"
 }
 ]
}


class Map(object):
 """
 Dot style access to object members, access raw values
 with an underscore e.g.

 class Foo(Map):
 def foo(self):
 return self.get('foo') + 'bar'

 obj = Foo(**{'foo': 'foo'})

 obj.foo =&gt; 'foobar'
 obj._foo =&gt; 'foo'

 """

 def __init__(self, *args, **kwargs):
 for arg in args:
 if isinstance(arg, dict):
 for k, v in arg.iteritems():
 self.__dict__[k] = v
 self.__dict__['_' + k] = v

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

 def __getattribute__(self, attr):
 if hasattr(self, 'get_' + attr):
 return object.__getattribute__(self, 'get_' + attr)()
 else:
 return object.__getattribute__(self, attr)

 def get(self, key):
 try:
 return self.__dict__.get('get_' + key)()
 except (AttributeError, TypeError):
 return self.__dict__.get(key)

 def __repr__(self):
 return u"&lt;{name} object&gt;".format(
 name=self.__class__.__name__
 )


class Number(Map):
 def get_role(self):
 return self.get('role')

 def get_number(self):
 return self.get('number')


class Location(Map):
 def get_latitude(self):
 return self.get('lat') + 1

 def get_longitude(self):
 return self.get('long') + 1


class Item(Map):
 def get_name(self):
 return self.get('name') + " Doe"

 def get_location(self):
 return Location(**self.get('location'))

 def get_numbers(self):
 return [Number(**n) for n in self.get('numbers')]


# Tests

obj = Item({'foo': 'bar'}, **payload)

assert type(obj) == Item
assert obj._name == "John"
assert obj.name == "John Doe"
assert type(obj.location) == Location
assert obj.location._lat == 53.12312312
assert obj.location._long == 43.21345112
assert obj.location.latitude == 54.12312312
assert obj.location.longitude == 44.21345112

for n in obj.numbers:
 assert type(n) == Number
 if n.role == 'home':
 assert n.number == "070-12345678"
 if n.role == 'office':
 assert n.number == "070-12345679"
</code></pre>

blocks|key|904813|text|为了构建epool的答案，此版本允许您通过点运算符访问内部的任何字典：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|904814|foo+=+{
++++"bar"+:+{
++++++++"baz"+:+[+{"boo"+:+"hoo"}+,+{"baba"+:+"loo"}+]
++++}
}|code-block|syntax|javascript|904815|例如，foo.bar.baz[1].baba返回"loo"。|offset|length|style|CODE|904816|class+Map(dict):
++++def+__init__(self,+*args,+**kwargs):
++++++++super(Map,+self).__init__(*args,+**kwargs)
++++++++for+arg+in+args:
++++++++++++if+isinstance(arg,+dict):
++++++++++++++++for+k,+v+in+arg.items():
++++++++++++++++++++if+isinstance(v,+dict):
++++++++++++++++++++++++v+=+Map(v)
++++++++++++++++++++if+isinstance(v,+list):
++++++++++++++++++++++++self.__convert(v)
++++++++++++++++++++self[k]+=+v

++++++++if+kwargs:
++++++++++++for+k,+v+in+kwargs.items():
++++++++++++++++if+isinstance(v,+dict):
++++++++++++++++++++v+=+Map(v)
++++++++++++++++elif+isinstance(v,+list):
++++++++++++++++++++self.__convert(v)
++++++++++++++++self[k]+=+v

++++def+__convert(self,+v):
++++++++for+elem+in+range(0,+len(v)):
++++++++++++if+isinstance(v[elem],+dict):
++++++++++++++++v[elem]+=+Map(v[elem])
++++++++++++elif+isinstance(v[elem],+list):
++++++++++++++++self.__convert(v[elem])

++++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]|904817|entityMap^0|0|0|3|J|O|5|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@$I|T|J|U|K|L]|$I|V|J|W|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|P|$]]

To build upon epool's answer, this version allows you to access any dict inside via the dot operator:
<pre><code>foo = {
 &quot;bar&quot; : {
 &quot;baz&quot; : [ {&quot;boo&quot; : &quot;hoo&quot;} , {&quot;baba&quot; : &quot;loo&quot;} ]
 }
}
</code></pre>
For instance, <code>foo.bar.baz[1].baba</code> returns <code>&quot;loo&quot;</code>.
<pre><code>class Map(dict):
 def __init__(self, *args, **kwargs):
 super(Map, self).__init__(*args, **kwargs)
 for arg in args:
 if isinstance(arg, dict):
 for k, v in arg.items():
 if isinstance(v, dict):
 v = Map(v)
 if isinstance(v, list):
 self.__convert(v)
 self[k] = v

 if kwargs:
 for k, v in kwargs.items():
 if isinstance(v, dict):
 v = Map(v)
 elif isinstance(v, list):
 self.__convert(v)
 self[k] = v

 def __convert(self, v):
 for elem in range(0, len(v)):
 if isinstance(v[elem], dict):
 v[elem] = Map(v[elem])
 elif isinstance(v[elem], list):
 self.__convert(v[elem])

 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]
</code></pre>

blocks|key|902038|text|我喜欢Munch，它在点访问的基础上提供了很多方便的选项。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|902039|902040|导入munch|blockquote|902041|902042|temp_1+=+{'person'：{+'fname'：'senthil'，'lname'：'ramalingam'}}|902043|dict_munch+=+munch.munchify(temp_1)|902044|dict_munch.person.fname|902045|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/Infinidat/munch^0|3|5|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@$A|X|B|Y|1|Z]]|C|$]]|$1|D|3|-4|5|6|7|10|8|@]|9|@]|C|$]]|$1|E|3|F|5|G|7|11|8|@]|9|@]|C|$]]|$1|H|3|-4|5|6|7|12|8|@]|9|@]|C|$]]|$1|I|3|J|5|6|7|13|8|@]|9|@]|C|$]]|$1|K|3|L|5|6|7|14|8|@]|9|@]|C|$]]|$1|M|3|N|5|6|7|15|8|@]|9|@]|C|$]]|$1|O|3|-4|5|6|7|16|8|@]|9|@]|C|$]]]|P|$Q|$5|R|S|T|C|$U|V]]]]

I like the <a href="https://github.com/Infinidat/munch" rel="noreferrer">Munch</a> and it gives lot of handy options on top of dot access.
<blockquote>
import munch
temp_1 = {'person': { 'fname': 'senthil', 'lname': 'ramalingam'}}
dict_munch = munch.munchify(temp_1)
dict_munch.person.fname
</blockquote>

blocks|key|902050|text|获取点访问(但不是数组访问)的一种简单方法是在Python中使用纯对象。如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|902051|class+YourObject:
++++def+__init__(self,+*args,+**kwargs):
++++++++for+k,+v+in+kwargs.items():
++++++++++++setattr(self,+k,+v)|code-block|syntax|javascript|902052|...and这样使用它：|902053|>>>+obj+=+YourObject(key="value")
>>>+print(obj.key)
"value"|902054|..。要将其转换为字典，请执行以下操作：|902055|>>>+print(obj.__dict__)
{"key":+"value"}|902056|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

One simple way to get dot access (but not array access), is to use a plain object in Python. Like this:

<pre><code>class YourObject:
 def __init__(self, *args, **kwargs):
 for k, v in kwargs.items():
 setattr(self, k, v)
</code></pre>

...and use it like this:

<pre><code>&gt;&gt;&gt; obj = YourObject(key="value")
&gt;&gt;&gt; print(obj.key)
"value"
</code></pre>

... to convert it to a dict:

<pre><code>&gt;&gt;&gt; print(obj.__dict__)
{"key": "value"}
</code></pre>

blocks|key|904846|text|使用__getattr__，非常简单，适用于Python3.4.3|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|904847|class+myDict(dict):
++++def+__getattr__(self,val):
++++++++return+self[val]


blockBody=myDict()
blockBody['item1']=10000
blockBody['item2']="StackOverflow"
print(blockBody.item1)
print(blockBody.item2)|code-block|syntax|javascript|904848|输出：|BOLD|904849|10000
StackOverflow|904850|entityMap^0|2|B|0|0|0|3|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@$9|S|A|T|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|U|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|V|8|@$9|W|A|X|B|M]]|D|@]|E|$]]|$1|N|3|O|5|H|7|Y|8|@]|D|@]|E|$I|J]]|$1|P|3|-4|5|6|7|Z|8|@]|D|@]|E|$]]]|Q|$]]

Use <code>__getattr__</code>, very simple, works in 
Python 3.4.3

<pre><code>class myDict(dict):
 def __getattr__(self,val):
 return self[val]


blockBody=myDict()
blockBody['item1']=10000
blockBody['item2']="StackOverflow"
print(blockBody.item1)
print(blockBody.item2)
</code></pre>

Output:

<pre><code>10000
StackOverflow
</code></pre>

blocks|key|1275407|text|一种微妙的解决方案|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1275408|class+DotDict(dict):

++++__setattr__+=+dict.__setitem__
++++__delattr__+=+dict.__delitem__

++++def+__getattr__(self,+key):

++++++++def+typer(candidate):
++++++++++++if+isinstance(candidate,+dict):
++++++++++++++++return+DotDict(candidate)

++++++++++++if+isinstance(candidate,+str):++#+iterable+but+no+need+to+iter
++++++++++++++++return+candidate

++++++++++++try:++#+other+iterable+are+processed+as+list
++++++++++++++++return+[typer(item)+for+item+in+candidate]
++++++++++++except+TypeError:
++++++++++++++++return+candidate

++++++++++++return+candidate

++++++++return+typer(dict.get(self,+key))|code-block|syntax|javascript|1275409|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

A solution kind of delicate

<pre class="lang-py prettyprint-override"><code>class DotDict(dict):

 __setattr__ = dict.__setitem__
 __delattr__ = dict.__delitem__

 def __getattr__(self, key):

 def typer(candidate):
 if isinstance(candidate, dict):
 return DotDict(candidate)

 if isinstance(candidate, str): # iterable but no need to iter
 return candidate

 try: # other iterable are processed as list
 return [typer(item) for item in candidate]
 except TypeError:
 return candidate

 return candidate

 return typer(dict.get(self, key))
</code></pre>

blocks|key|1275438|text|这也适用于嵌套的字典，并确保稍后附加的字典具有相同的行为：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1275439|class+DotDict(dict):

++++def+__init__(self,+*args,+**kwargs):
++++++++super().__init__(*args,+**kwargs)
++++++++#+Recursively+turn+nested+dicts+into+DotDicts
++++++++for+key,+value+in+self.items():
++++++++++++if+type(value)+is+dict:
++++++++++++++++self[key]+=+DotDict(value)

++++def+__setitem__(self,+key,+item):
++++++++if+type(item)+is+dict:
++++++++++++item+=+DotDict(item)
++++++++super().__setitem__(key,+item)

++++__setattr__+=+__setitem__
++++__getattr__+=+dict.__getitem__|code-block|syntax|javascript|1275440|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

This also works with nested dicts and makes sure that dicts which are appended later behave the same:

<pre><code>class DotDict(dict):

 def __init__(self, *args, **kwargs):
 super().__init__(*args, **kwargs)
 # Recursively turn nested dicts into DotDicts
 for key, value in self.items():
 if type(value) is dict:
 self[key] = DotDict(value)

 def __setitem__(self, key, item):
 if type(item) is dict:
 item = DotDict(item)
 super().__setitem__(key, item)

 __setattr__ = __setitem__
 __getattr__ = dict.__getitem__
</code></pre>

blocks|key|1275448|text|我最近偶然发现了'Box‘库，它做了同样的事情。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1275449|安装命令：pip+install+python-box|style|CODE|1275450|示例：|1275451|from+box+import+Box

mydict+=+{"key1":{"v1":0.375,
++++++++++++++++++++"v2":0.625},
++++++++++"key2":0.125,
++++++++++}
mydict+=+Box(mydict)

print(mydict.key1.v1)|code-block|syntax|javascript|1275452|我发现它比其他现有的库更有效，比如dotmap，当你有大的嵌套字典时，它会产生python递归错误。|1275453|库链接和详细信息：https://pypi.org/project/python-box/|1275454|entityMap|0|LINK|mutability|MUTABLE|url|https://pypi.org/project/python-box/|1^0|9|3|0|0|5|M|0|0|0|0|9|10|1|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@$A|12|B|13|1|14]]|C|$]]|$1|D|3|E|5|6|7|15|8|@$A|16|B|17|F|G]]|9|@]|C|$]]|$1|H|3|I|5|6|7|18|8|@]|9|@]|C|$]]|$1|J|3|K|5|L|7|19|8|@]|9|@]|C|$M|N]]|$1|O|3|P|5|6|7|1A|8|@]|9|@]|C|$]]|$1|Q|3|R|5|6|7|1B|8|@]|9|@$A|1C|B|1D|1|1E]]|C|$]]|$1|S|3|-4|5|6|7|1F|8|@]|9|@]|C|$]]]|T|$U|$5|V|W|X|C|$Y|Z]]|10|$5|V|W|X|C|$Y|Z]]]]

I recently came across the '<a href="https://pypi.org/project/python-box/" rel="noreferrer">Box</a>' library which does the same thing. 

Installation command : <code>pip install python-box</code>

Example:

<pre class="lang-py prettyprint-override"><code>from box import Box

mydict = {"key1":{"v1":0.375,
 "v2":0.625},
 "key2":0.125,
 }
mydict = Box(mydict)

print(mydict.key1.v1)
</code></pre>

I found it to be more effective than other existing libraries like dotmap, which generate python recursion error when you have large nested dicts.

link to library and details: <a href="https://pypi.org/project/python-box/" rel="noreferrer">https://pypi.org/project/python-box/</a>

blocks|key|902127|text|The+answer+of+@derek73非常整洁，但它不能被酸洗或(深度)复制，并且它会为缺少的键返回None。下面的代码修复了这个问题。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|902128|编辑：我没有看到the+answer+above解决了完全相同的问题(投票通过)。我把答案留在这里供参考。|BOLD|902129|class+dotdict(dict):
++++__setattr__+=+dict.__setitem__
++++__delattr__+=+dict.__delitem__

++++def+__getattr__(self,+name):
++++++++try:
++++++++++++return+self[name]
++++++++except+KeyError:
++++++++++++raise+AttributeError(name)|code-block|syntax|javascript|902130|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/23689767/6783015|1|https://stackoverflow.com/a/36968114/6783015^0|1H|4|0|M|0|0|0|3|8|G|1|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@$9|Y|A|Z|B|C]]|D|@$9|10|A|11|1|12]]|E|$]]|$1|F|3|G|5|6|7|13|8|@$9|14|A|15|B|H]]|D|@$9|16|A|17|1|18]]|E|$]]|$1|I|3|J|5|K|7|19|8|@]|D|@]|E|$L|M]]|$1|N|3|-4|5|6|7|1A|8|@]|D|@]|E|$]]]|O|$P|$5|Q|R|S|E|$T|U]]|V|$5|Q|R|S|E|$T|W]]]]

<a href="https://stackoverflow.com/a/23689767/6783015">The answer of @derek73</a> is very neat, but it cannot be pickled nor (deep)copied, and it returns <code>None</code> for missing keys. The code below fixes this.

Edit: I did not see <a href="https://stackoverflow.com/a/36968114/6783015">the answer above</a> that addresses the exact same point (upvoted). I'm leaving the answer here for reference.

<pre><code>class dotdict(dict):
 __setattr__ = dict.__setitem__
 __delattr__ = dict.__delitem__

 def __getattr__(self, name):
 try:
 return self[name]
 except KeyError:
 raise AttributeError(name)
</code></pre>

blocks|key|1275499|text|使用SimpleNamespace|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1275500|>>>+from+types+import+SimpleNamespace+++
>>>+d+=+dict(x=[1,+2],+y=['a',+'b'])
>>>+ns+=+SimpleNamespace(**d)
>>>+ns.x
[1,+2]
>>>+ns
namespace(x=[1,+2],+y=['a',+'b'])|code-block|syntax|javascript|1275501|entityMap^0|2|F|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

Use <code>SimpleNamespace</code>:

<pre><code>&gt;&gt;&gt; from types import SimpleNamespace 
&gt;&gt;&gt; d = dict(x=[1, 2], y=['a', 'b'])
&gt;&gt;&gt; ns = SimpleNamespace(**d)
&gt;&gt;&gt; ns.x
[1, 2]
&gt;&gt;&gt; ns
namespace(x=[1, 2], y=['a', 'b'])
</code></pre>

blocks|key|156856|text|使用namedtuple允许点访问。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|156857|它就像一个轻量级对象，它也具有元组的属性。|156858|它允许定义属性并使用点运算符访问它们。|BOLD|156859|from+collections+import+namedtuple
Data+=+namedtuple('Data',+['key1',+'key2'])

dataObj+=+Data(val1,+key2=val2)+#+can+instantiate+using+keyword+arguments+and+positional+arguments|code-block|syntax|javascript|156860|使用点运算符访问|156861|dataObj.key1+#+Gives+val1
datObj.key2+#+Gives+val2|156862|使用元组索引进行访问|156863|dataObj[0]+#+Gives+val1
dataObj[1]+#+Gives+val2|156864|但请记住，这是一个元组；不是。因此，下面的代码将给出错误|156865|dataObj['key1']+#+Gives+TypeError:+tuple+indices+must+be+integers+or+slices,+not+str|156866|参考：namedtuple|156867|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/2/library/collections.html#collections.namedtuple^0|2|A|0|0|A|4|0|0|0|0|0|0|C|2|0|0|3|A|0|0^^$0|@$1|2|3|4|5|6|7|1B|8|@$9|1C|A|1D|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1E|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|1F|8|@$9|1G|A|1H|B|J]]|D|@]|E|$]]|$1|K|3|L|5|M|7|1I|8|@]|D|@]|E|$N|O]]|$1|P|3|Q|5|6|7|1J|8|@]|D|@]|E|$]]|$1|R|3|S|5|M|7|1K|8|@]|D|@]|E|$N|O]]|$1|T|3|U|5|6|7|1L|8|@]|D|@]|E|$]]|$1|V|3|W|5|M|7|1M|8|@]|D|@]|E|$N|O]]|$1|X|3|Y|5|6|7|1N|8|@$9|1O|A|1P|B|J]]|D|@]|E|$]]|$1|Z|3|10|5|M|7|1Q|8|@]|D|@]|E|$N|O]]|$1|11|3|12|5|6|7|1R|8|@]|D|@$9|1S|A|1T|1|1U]]|E|$]]|$1|13|3|-4|5|6|7|1V|8|@]|D|@]|E|$]]]|14|$15|$5|16|17|18|E|$19|1A]]]]

Using <code>namedtuple</code> allows dot access.
It is like a lightweight object which also has the properties of a tuple.
It allows to define properties and access them using the dot operator.
<pre><code>from collections import namedtuple
Data = namedtuple('Data', ['key1', 'key2'])

dataObj = Data(val1, key2=val2) # can instantiate using keyword arguments and positional arguments
</code></pre>
Access using dot operator
<pre><code>dataObj.key1 # Gives val1
datObj.key2 # Gives val2
</code></pre>
Access using tuple indices
<pre><code>dataObj[0] # Gives val1
dataObj[1] # Gives val2
</code></pre>
But remember this is a tuple; not a dict. So the below code will give error
<pre><code>dataObj['key1'] # Gives TypeError: tuple indices must be integers or slices, not str
</code></pre>
Refer: <a href="https://docs.python.org/2/library/collections.html#collections.namedtuple" rel="nofollow noreferrer">namedtuple</a>

blocks|key|2684936|text|我只需要使用虚线路径字符串访问字典，所以我想出了：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2684937|def+get_value_from_path(dictionary,+parts):
++++"""+extracts+a+value+from+a+dictionary+using+a+dotted+path+string+"""

++++if+type(parts)+is+str:
++++++++parts+=+parts.split('.')

++++if+len(parts)+>+1:
++++++++return+get_value_from_path(dictionary[parts[0]],+parts[1:])

++++return+dictionary[parts[0]]

a+=+{'a':{'b':'c'}}
print(get_value_from_path(a,+'a.b'))+#+c|code-block|syntax|javascript|2684938|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I just needed to access a dictionary using a dotted path string, so I came up with:
<pre class="lang-py prettyprint-override"><code>def get_value_from_path(dictionary, parts):
 &quot;&quot;&quot; extracts a value from a dictionary using a dotted path string &quot;&quot;&quot;

 if type(parts) is str:
 parts = parts.split('.')

 if len(parts) &gt; 1:
 return get_value_from_path(dictionary[parts[0]], parts[1:])

 return dictionary[parts[0]]

a = {'a':{'b':'c'}}
print(get_value_from_path(a, 'a.b')) # c
</code></pre>

blocks|key|2684978|text|这是一个老问题，但我最近发现sklearn有一个可通过键访问的实现版本dict，即Bunch+https://scikit-learn.org/stable/modules/generated/sklearn.utils.Bunch.html#sklearn.utils.Bunch|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2684979|entityMap|0|LINK|mutability|MUTABLE|url|https://scikit-learn.org/stable/modules/generated/sklearn.utils.Bunch.html#sklearn.utils.Bunch^0|E|7|Z|4|15|5|1B|2M|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]|$9|Q|A|R|B|C]|$9|S|A|T|B|C]]|D|@$9|U|A|V|1|W]]|E|$]]|$1|F|3|-4|5|6|7|X|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]]]

It is an old question but I recently found that <code>sklearn</code> has an implemented version <code>dict</code> accessible by key, namely <code>Bunch</code>
<a href="https://scikit-learn.org/stable/modules/generated/sklearn.utils.Bunch.html#sklearn.utils.Bunch" rel="nofollow noreferrer">https://scikit-learn.org/stable/modules/generated/sklearn.utils.Bunch.html#sklearn.utils.Bunch</a>

blocks|key|1275643|text|这是我的@derek73+answer版本。我使用dict.__getitem__作为__getattr__，所以它仍然抛出KeyError，而且我使用"“前缀重命名dict公共方法(用"”包围会导致特殊的方法名称冲突，如__get__，它将被视为描述符方法)。无论如何，由于关键的dict基础方法，你不能获得作为属性的键的完全清晰的名称空间，所以解决方案并不完美，但你可以拥有键-属性，如get，pop，items等。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|BOLD|entityRanges|data|1275644|class+DotDictMeta(type):++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++def+__new__(++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++cls,++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++name,+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++bases,++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++attrs,+++++++++++++++++++++++++++++++++++++++++
++++++++rename_method=lambda+n:+f'__{n}__',++++++++++++++++++++++++++++
++++++++**custom_methods,+++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++):++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++d+=+dict++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++attrs.update(+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++cls.get_hidden_or_renamed_methods(rename_method),+++++++++++
++++++++++++__getattr__=d.__getitem__,++++++++++++++++++++++++++++++++++++++++++++
++++++++++++__setattr__=d.__setitem__,++++++++++++++++++++++++++++++++++++++++++++
++++++++++++__delattr__=d.__delitem__,++++++++++++++++++++++++++++++++++++++++++++
++++++++++++**custom_methods,+++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++)+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++return+super().__new__(cls,+name,+bases,+attrs)+++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++def+__init__(self,+name,+bases,+attrs,+**_):++++++++++++++++++++++++++++++++++
++++++++super().__init__(name,+bases,+attrs)++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++@property+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++def+attribute_error(self):++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++raise+AttributeError++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++@classmethod++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++def+get_hidden_or_renamed_methods(cls,+rename_method=None):++++++++++++++++++
++++++++public_methods+=+tuple(+++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++i+for+i+in+dict.__dict__.items()+if+not+i[0].startswith('__')+++++++++
++++++++)+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++error+=+cls.attribute_error+++++++++++++++++++++++++++++++++++++++++++++++
++++++++hidden_methods+=+((k,+error)+for+k,+v+in+public_methods)++++++++++++++++++
++++++++yield+from+hidden_methods+++++++++++++++++++++++++++++++++++++++++++++++++
++++++++if+rename_method:+++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++renamed_methods+=+((rename_method(k),+v)+for+k,+v+in+public_methods)+
++++++++++++yield+from+renamed_methods+++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
class+DotDict(dict,+metaclass=DotDictMeta):+++++++++++++++++++++++++++++++++++++++
++++pass++|code-block|syntax|javascript|1275645|你可以从DotDict命名空间中删除dict方法，继续使用dict类方法，当你想在其他dict实例上操作，并且想要使用相同的方法而不需要额外检查它的DotDict时，它也很有用，例如。|1275646|dct+=+dict(a=1)
dot_dct+=+DotDict(b=2)
foo+=+{c:+i+for+i,+c+in+enumerate('xyz')}
for+d+in+(dct,+dot_dct):
++++#+you+would+have+to+use+dct.update+and+dot_dct.__update+methods
++++dict.update(d,+foo)
++++
assert+dict.get(dot,+'foo',+0)+is+0|1275647|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/23689767/9253363^0|P|G|17|B|1Q|8|33|7|3X|4|5F|3|5J|3|5N|5|25|H|4|F|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|X|8|@$9|Y|A|Z|B|C]|$9|10|A|11|B|C]|$9|12|A|13|B|C]|$9|14|A|15|B|C]|$9|16|A|17|B|C]|$9|18|A|19|B|C]|$9|1A|A|1B|B|C]|$9|1C|A|1D|B|C]|$9|1E|A|1F|B|D]]|E|@$9|1G|A|1H|1|1I]]|F|$]]|$1|G|3|H|5|I|7|1J|8|@]|E|@]|F|$J|K]]|$1|L|3|M|5|6|7|1K|8|@]|E|@]|F|$]]|$1|N|3|O|5|I|7|1L|8|@]|E|@]|F|$J|K]]|$1|P|3|-4|5|6|7|1M|8|@]|E|@]|F|$]]]|Q|$R|$5|S|T|U|F|$V|W]]]]

Here's my version of <a href="https://stackoverflow.com/a/23689767/9253363">@derek73 answer</a>. I use <code>dict.__getitem__</code> as <code>__getattr__</code> so it still throws <code>KeyError</code>, and im renaming dict public methods with &quot;&quot; prefix (surrounded with &quot;&quot; leads to special methods name conflict, like <code>__get__</code> which would be treated as a descriptor method). Anyway you can't get completely clear namespace for keys as attributes due to crucial <code>dict</code> base methods, so the solution isn't perfect but you can have keys - attributes like <code>get</code>, <code>pop</code>, <code>items</code> etc.
<pre><code>class DotDictMeta(type): 
 def __new__( 
 cls, 
 name, 
 bases, 
 attrs, 
 rename_method=lambda n: f'__{n}__', 
 **custom_methods, 
 ): 
 d = dict 
 attrs.update( 
 cls.get_hidden_or_renamed_methods(rename_method), 
 __getattr__=d.__getitem__, 
 __setattr__=d.__setitem__, 
 __delattr__=d.__delitem__, 
 **custom_methods, 
 ) 
 return super().__new__(cls, name, bases, attrs) 
 
 def __init__(self, name, bases, attrs, **_): 
 super().__init__(name, bases, attrs) 
 
 @property 
 def attribute_error(self): 
 raise AttributeError 
 
 @classmethod 
 def get_hidden_or_renamed_methods(cls, rename_method=None): 
 public_methods = tuple( 
 i for i in dict.__dict__.items() if not i[0].startswith('__') 
 ) 
 error = cls.attribute_error 
 hidden_methods = ((k, error) for k, v in public_methods) 
 yield from hidden_methods 
 if rename_method: 
 renamed_methods = ((rename_method(k), v) for k, v in public_methods) 
 yield from renamed_methods 
 
 
class DotDict(dict, metaclass=DotDictMeta): 
 pass 

 
 
</code></pre>
You can remove dict methods from DotDict namespace and keep using dict class methods, its useful also when you want to operate on other dict instances and want to use the same methods without extra check whether its DotDict or not, eg.
<pre><code>dct = dict(a=1)
dot_dct = DotDict(b=2)
foo = {c: i for i, c in enumerate('xyz')}
for d in (dct, dot_dct):
 # you would have to use dct.update and dot_dct.__update methods
 dict.update(d, foo)
 
assert dict.get(dot, 'foo', 0) is 0
</code></pre>

blocks|key|2685065|text|这是我很久以前做的一个项目中发现的。它可能会进行一些优化，但现在开始了。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2685066|class+DotNotation(dict):
++++
++++__setattr__=+dict.__setitem__
++++__delattr__=+dict.__delitem__

++++def+__init__(self,+data):
++++++++if+isinstance(data,+str):
++++++++++++data+=+json.loads(data)
++++
++++++++for+name,+value+in+data.items():
++++++++++++setattr(self,+name,+self._wrap(value))

++++def+__getattr__(self,+attr):
++++++++def+_traverse(obj,+attr):
++++++++++++if+self._is_indexable(obj):
++++++++++++++++try:
++++++++++++++++++++return+obj[int(attr)]
++++++++++++++++except:
++++++++++++++++++++return+None
++++++++++++elif+isinstance(obj,+dict):
++++++++++++++++return+obj.get(attr,+None)
++++++++++++else:
++++++++++++++++return+attr
++++++++if+'.'+in+attr:
++++++++++++return+reduce(_traverse,+attr.split('.'),+self)
++++++++return+self.get(attr,+None)

++++def+_wrap(self,+value):
++++++++if+self._is_indexable(value):
++++++++++++#+(!)+recursive+(!)
++++++++++++return+type(value)([self._wrap(v)+for+v+in+value])
++++++++elif+isinstance(value,+dict):
++++++++++++return+DotNotation(value)
++++++++else:
++++++++++++return+value
++++
++++@staticmethod
++++def+_is_indexable(obj):
++++++++return+isinstance(obj,+(tuple,+list,+set,+frozenset))


if+__name__+==+"__main__":
++++test_dict+=+{
++++++++"dimensions":+{
++++++++++++"length":+"112",
++++++++++++"width":+"103",
++++++++++++"height":+"42"
++++++++},
++++++++"meta_data":+[
++++++++++++{
++++++++++++++++"id":+11089769,
++++++++++++++++"key":+"imported_gallery_files",
++++++++++++++++"value":+[
++++++++++++++++++++"https://example.com/wp-content/uploads/2019/09/unnamed-3.jpg",
++++++++++++++++++++"https://example.com/wp-content/uploads/2019/09/unnamed-2.jpg",
++++++++++++++++++++"https://example.com/wp-content/uploads/2019/09/unnamed-4.jpg"
++++++++++++++++]
++++++++++++}
++++++++]
++++}
++++dotted_dict+=+DotNotation(test_dict)
++++print(dotted_dict.dimensions.length)+#+=>+'112'
++++print(getattr(dotted_dict,+'dimensions.length'))+#+=>+'112'
++++print(dotted_dict.meta_data[0].key)+#+=>+'imported_gallery_files'
++++print(getattr(dotted_dict,+'meta_data.0.key'))+#+=>+'imported_gallery_files'
++++print(dotted_dict.meta_data[0].value)+#+=>+['link1','link2','link2']
++++print(getattr(dotted_dict,+'meta_data.0.value'))+#+=>+['link1','link2','link3']
++++print(dotted_dict.meta_data[0].value[2])+#+=>+'link3'
++++print(getattr(dotted_dict,+'meta_data.0.value.2'))+#+=>+'link3'|code-block|syntax|javascript|2685067|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I just dug this up from a project I was working on a long time ago. It could probably be optimized a bit, but here it goes.
<pre class="lang-py prettyprint-override"><code>class DotNotation(dict):
 
 __setattr__= dict.__setitem__
 __delattr__= dict.__delitem__

 def __init__(self, data):
 if isinstance(data, str):
 data = json.loads(data)
 
 for name, value in data.items():
 setattr(self, name, self._wrap(value))

 def __getattr__(self, attr):
 def _traverse(obj, attr):
 if self._is_indexable(obj):
 try:
 return obj[int(attr)]
 except:
 return None
 elif isinstance(obj, dict):
 return obj.get(attr, None)
 else:
 return attr
 if '.' in attr:
 return reduce(_traverse, attr.split('.'), self)
 return self.get(attr, None)

 def _wrap(self, value):
 if self._is_indexable(value):
 # (!) recursive (!)
 return type(value)([self._wrap(v) for v in value])
 elif isinstance(value, dict):
 return DotNotation(value)
 else:
 return value
 
 @staticmethod
 def _is_indexable(obj):
 return isinstance(obj, (tuple, list, set, frozenset))


if __name__ == &quot;__main__&quot;:
 test_dict = {
 &quot;dimensions&quot;: {
 &quot;length&quot;: &quot;112&quot;,
 &quot;width&quot;: &quot;103&quot;,
 &quot;height&quot;: &quot;42&quot;
 },
 &quot;meta_data&quot;: [
 {
 &quot;id&quot;: 11089769,
 &quot;key&quot;: &quot;imported_gallery_files&quot;,
 &quot;value&quot;: [
 &quot;https://example.com/wp-content/uploads/2019/09/unnamed-3.jpg&quot;,
 &quot;https://example.com/wp-content/uploads/2019/09/unnamed-2.jpg&quot;,
 &quot;https://example.com/wp-content/uploads/2019/09/unnamed-4.jpg&quot;
 ]
 }
 ]
 }
 dotted_dict = DotNotation(test_dict)
 print(dotted_dict.dimensions.length) # =&gt; '112'
 print(getattr(dotted_dict, 'dimensions.length')) # =&gt; '112'
 print(dotted_dict.meta_data[0].key) # =&gt; 'imported_gallery_files'
 print(getattr(dotted_dict, 'meta_data.0.key')) # =&gt; 'imported_gallery_files'
 print(dotted_dict.meta_data[0].value) # =&gt; ['link1','link2','link2']
 print(getattr(dotted_dict, 'meta_data.0.value')) # =&gt; ['link1','link2','link3']
 print(dotted_dict.meta_data[0].value[2]) # =&gt; 'link3'
 print(getattr(dotted_dict, 'meta_data.0.value.2')) # =&gt; 'link3'
</code></pre>

blocks|key|1275721|text|我的两点意见:出于我自己的目的，我开发了minydra，这是一个简单的命令行解析器，其中包含一个自定义类MinyDict+(灵感来自addict)：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1275722|In+[1]:+from+minydra+import+MinyDict

In+[2]:+args+=+MinyDict({"foo":+"bar",+"yes.no.maybe":+"idontknow"}).pretty_print();+args
╭──────────────────────────────╮
│+foo++++++++++:+bar+++++++++++│
│+yes.no.maybe+:+idontknow+++++│
╰──────────────────────────────╯
Out[2]:+{'foo':+'bar',+'yes.no.maybe':+'idontknow'}

In+[3]:+args.resolve().pretty_print();+args
╭──────────────────────────╮
│+foo+:+bar++++++++++++++++│
│+yes++++++++++++++++++++++│
│+│no++++++++++++++++++++++│
│+│+│maybe+:+idontknow+++++│
╰──────────────────────────╯
Out[3]:+{'foo':+'bar',+'yes':+{'no':+{'maybe':+'idontknow'}}}

In+[4]:+args.yes.no.maybe
Out[4]:+"idontknow"

In+[5]:+"foo"+in+args
Out[5]:+True

In+[6]:+"rick"+in+args
Out[6]:+False

In+[7]:+args.morty+is+None
Out[7]:+True

In+[8]:+args.items()
Out[8]:+dict_items([('foo',+'bar'),+('yes',+{'no':+{'maybe':+'idontknow'}})])|code-block|syntax|javascript|1275723|它比addict更进一步，向/从json+yaml和pickle添加转储/加载方法，并且在MinyDict.update()中还具有strict模式，以防止创建新的键(这对于防止命令行中的键入错误很有用)|1275724|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/vict0rsch/minydra|1|https://github.com/vict0rsch/minydra#minydict^0|K|7|1G|8|1U|6|K|7|0|1G|8|1|0|0|2|6|G|4|L|4|Q|6|19|H|1U|6|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@$9|13|A|14|1|15]|$9|16|A|17|1|18]]|E|$]]|$1|F|3|G|5|H|7|19|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1A|8|@$9|1B|A|1C|B|C]|$9|1D|A|1E|B|C]|$9|1F|A|1G|B|C]|$9|1H|A|1I|B|C]|$9|1J|A|1K|B|C]|$9|1L|A|1M|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|1N|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]|U|$5|P|Q|R|E|$S|V]]]]

My 2 cents: for my own purposes I developed <a href="https://github.com/vict0rsch/minydra" rel="nofollow noreferrer"><code>minydra</code></a>, a simple command-line parser which includes a custom class <a href="https://github.com/vict0rsch/minydra#minydict" rel="nofollow noreferrer"><code>MinyDict</code></a> (inspired by <code>addict</code>):
<pre><code>
In [1]: from minydra import MinyDict

In [2]: args = MinyDict({&quot;foo&quot;: &quot;bar&quot;, &quot;yes.no.maybe&quot;: &quot;idontknow&quot;}).pretty_print(); args
╭──────────────────────────────╮
│ foo : bar │
│ yes.no.maybe : idontknow │
╰──────────────────────────────╯
Out[2]: {'foo': 'bar', 'yes.no.maybe': 'idontknow'}

In [3]: args.resolve().pretty_print(); args
╭──────────────────────────╮
│ foo : bar │
│ yes │
│ │no │
│ │ │maybe : idontknow │
╰──────────────────────────╯
Out[3]: {'foo': 'bar', 'yes': {'no': {'maybe': 'idontknow'}}}

In [4]: args.yes.no.maybe
Out[4]: &quot;idontknow&quot;

In [5]: &quot;foo&quot; in args
Out[5]: True

In [6]: &quot;rick&quot; in args
Out[6]: False

In [7]: args.morty is None
Out[7]: True

In [8]: args.items()
Out[8]: dict_items([('foo', 'bar'), ('yes', {'no': {'maybe': 'idontknow'}})])
</code></pre>
It goes further than <code>addict</code> by adding dumping/loading methods to/from <code>json</code> <code>yaml</code> and <code>pickle</code> and also has a <code>strict</code> mode in <code>MinyDict.update()</code> to prevent the creation of new keys (this is useful to prevent typos in the command-line)

blocks|key|1275730|text|您可以使用SimpleNamespace实现这一点|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1275731|from+types+import+SimpleNamespace
#+Assign+values
args+=+SimpleNamespace()
args.username+=+'admin'

#+Retrive+values
print(args.username)++#+output:+admin|code-block|syntax|javascript|1275732|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You can achieve this using SimpleNamespace
<pre><code>from types import SimpleNamespace
# Assign values
args = SimpleNamespace()
args.username = 'admin'

# Retrive values
print(args.username) # output: admin
</code></pre>

blocks|key|156188|text|对于无限级别的字典、列表、字典列表和列表字典的嵌套。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|156189|它还支持酸洗。|156190|这是this+answer的一个扩展。|offset|length|156191|class+DotDict(dict):
++++#+https://stackoverflow.com/a/70665030/913098
++++"""
++++Example:
++++m+=+DotDict({'first_name':+'Eduardo'},+last_name='Pool',+age=24,+sports=['Soccer'])

++++Iterable+are+assumed+to+have+a+constructor+taking+list+as+input.
++++"""

++++def+__init__(self,+*args,+**kwargs):
++++++++super(DotDict,+self).__init__(*args,+**kwargs)
++++++++for+arg+in+args:
++++++++++++if+isinstance(arg,+dict):
++++++++++++++++for+k,+v+in+arg.items():
++++++++++++++++++++self[k]+=+v
++++++++++++++++++++if+isinstance(v,+dict):
++++++++++++++++++++++++self[k]+=+DotDict(v)
++++++++++++++++++++elif+isinstance(v,+str)+or+isinstance(v,+bytes):
++++++++++++++++++++++++self[k]+=+v
++++++++++++++++++++elif+isinstance(v,+Iterable):
++++++++++++++++++++++++klass+=+type(v)
++++++++++++++++++++++++map_value:+List[Any]+=+[]
++++++++++++++++++++++++for+e+in+v:
++++++++++++++++++++++++++++map_e+=+DotDict(e)+if+isinstance(e,+dict)+else+e
++++++++++++++++++++++++++++map_value.append(map_e)
++++++++++++++++++++++++self[k]+=+klass(map_value)

++++++++if+kwargs:
++++++++++++for+k,+v+in+kwargs.items():
++++++++++++++++self[k]+=+v
++++++++++++++++if+isinstance(v,+dict):
++++++++++++++++++++self[k]+=+DotDict(v)

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

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

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

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

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

if+__name__+==+"__main__":
++++def+test_map():
++++++++d+=+{
++++++++++++"a":+1,
++++++++++++"b":+{
++++++++++++++++"c":+"d",
++++++++++++++++"e":+2,
++++++++++++++++"f":+None
++++++++++++},
++++++++++++"g":+[],
++++++++++++"h":+[1,+"i"],
++++++++++++"j":+[1,+"k",+{}],
++++++++++++"l":
++++++++++++++++[
++++++++++++++++++++1,
++++++++++++++++++++"m",
++++++++++++++++++++{
++++++++++++++++++++++++"n":+[3],
++++++++++++++++++++++++"o":+"p",
++++++++++++++++++++++++"q":+{
++++++++++++++++++++++++++++"r":+"s",
++++++++++++++++++++++++++++"t":+["u",+5,+{"v":+"w"}]
++++++++++++++++++++++++}
++++++++++++++++++++}
++++++++++++++++],
++++++++}
++++++++map_d+=+DotDict(d)
++++++++w+=+map_d.l[2].q.t[2].v
++++++++assert+w+==+"w"


++++test_map()|code-block|syntax|javascript|156192|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/32107024/913098^0|0|0|2|B|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|W|8|@]|9|@$F|X|G|Y|1|Z]]|A|$]]|$1|H|3|I|5|J|7|10|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|N|$O|$5|P|Q|R|A|$S|T]]]]

For infinite levels of nesting of dicts, lists, lists of dicts, and dicts of lists.
It also supports pickling.
This is an extension of <a href="https://stackoverflow.com/a/32107024/913098">this answer</a>.
<pre><code>class DotDict(dict):
 # https://stackoverflow.com/a/70665030/913098
 &quot;&quot;&quot;
 Example:
 m = DotDict({'first_name': 'Eduardo'}, last_name='Pool', age=24, sports=['Soccer'])

 Iterable are assumed to have a constructor taking list as input.
 &quot;&quot;&quot;

 def __init__(self, *args, **kwargs):
 super(DotDict, self).__init__(*args, **kwargs)
 for arg in args:
 if isinstance(arg, dict):
 for k, v in arg.items():
 self[k] = v
 if isinstance(v, dict):
 self[k] = DotDict(v)
 elif isinstance(v, str) or isinstance(v, bytes):
 self[k] = v
 elif isinstance(v, Iterable):
 klass = type(v)
 map_value: List[Any] = []
 for e in v:
 map_e = DotDict(e) if isinstance(e, dict) else e
 map_value.append(map_e)
 self[k] = klass(map_value)

 if kwargs:
 for k, v in kwargs.items():
 self[k] = v
 if isinstance(v, dict):
 self[k] = DotDict(v)

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

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

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

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

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

if __name__ == &quot;__main__&quot;:
 def test_map():
 d = {
 &quot;a&quot;: 1,
 &quot;b&quot;: {
 &quot;c&quot;: &quot;d&quot;,
 &quot;e&quot;: 2,
 &quot;f&quot;: None
 },
 &quot;g&quot;: [],
 &quot;h&quot;: [1, &quot;i&quot;],
 &quot;j&quot;: [1, &quot;k&quot;, {}],
 &quot;l&quot;:
 [
 1,
 &quot;m&quot;,
 {
 &quot;n&quot;: [3],
 &quot;o&quot;: &quot;p&quot;,
 &quot;q&quot;: {
 &quot;r&quot;: &quot;s&quot;,
 &quot;t&quot;: [&quot;u&quot;, 5, {&quot;v&quot;: &quot;w&quot;}]
 }
 }
 ],
 }
 map_d = DotDict(d)
 w = map_d.l[2].q.t[2].v
 assert w == &quot;w&quot;


 test_map()

</code></pre>

blocks|key|1275808|text|可以使用dotsi，以获得完整的列表、字典和递归支持，以及一些扩展方法|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1275809|pip+install+dotsi|code-block|syntax|javascript|1275810|和|1275811|>>>+import+dotsi
>>>+
>>>+d+=+dotsi.Dict({"foo":+{"bar":+"baz"}})+++++#+Basic
>>>+d.foo.bar
'baz'
>>>+d.users+=+[{"id":+0,+"name":+"Alice"}]+++#+List
>>>+d.users[0].name
'Alice'
>>>+d.users.append({"id":+1,+"name":+"Becca"});+#+Append
>>>+d.users[1].name
'Becca'
>>>+d.users+%2B=+[{"id":+2,+"name":+"Cathy"}];++++#+`%2B=`
>>>+d.users[2].name
'Cathy'
>>>+d.update({"tasks":+[{"id":+"a",+"text":+"Task+A"}]});
>>>+d.tasks[0].text
'Task+A'
>>>+d.tasks[0].tags+=+["red",+"white",+"blue"];
>>>+d.tasks[0].tags[2];
'blue'
>>>+d.tasks[0].pop("tags")++++++++++++++++++++++#+`.pop()`
['red',+'white',+'blue']
>>>+
>>>+import+pprint
>>>+pprint.pprint(d)
{'foo':+{'bar':+'baz'},
+'tasks':+[{'id':+'a',+'text':+'Task+A'}],
+'users':+[{'id':+0,+'name':+'Alice'},
+++++++++++{'id':+1,+'name':+'Becca'},
+++++++++++{'id':+2,+'name':+'Cathy'}]}
>>>+
>>>+type(d.users)+++++++#+dotsi.Dict+(AKA+dotsi.DotsiDict)
<class+'dotsi.DotsiList'>
>>>+type(d.users[0])++++#+dotsi.List+(AKA+dotsi.DotsiList)
<class+'dotsi.DotsiDict'>+
>>>+|1275812|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/polydojo/dotsi^0|4|5|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|10|8|@]|9|@]|C|$G|H]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

One could use <a href="https://github.com/polydojo/dotsi" rel="nofollow noreferrer">dotsi</a>, for full list, dict and recursive support, with some extension methods
<pre><code>pip install dotsi
</code></pre>
and
<pre><code>&gt;&gt;&gt; import dotsi
&gt;&gt;&gt; 
&gt;&gt;&gt; d = dotsi.Dict({&quot;foo&quot;: {&quot;bar&quot;: &quot;baz&quot;}}) # Basic
&gt;&gt;&gt; d.foo.bar
'baz'
&gt;&gt;&gt; d.users = [{&quot;id&quot;: 0, &quot;name&quot;: &quot;Alice&quot;}] # List
&gt;&gt;&gt; d.users[0].name
'Alice'
&gt;&gt;&gt; d.users.append({&quot;id&quot;: 1, &quot;name&quot;: &quot;Becca&quot;}); # Append
&gt;&gt;&gt; d.users[1].name
'Becca'
&gt;&gt;&gt; d.users += [{&quot;id&quot;: 2, &quot;name&quot;: &quot;Cathy&quot;}]; # `+=`
&gt;&gt;&gt; d.users[2].name
'Cathy'
&gt;&gt;&gt; d.update({&quot;tasks&quot;: [{&quot;id&quot;: &quot;a&quot;, &quot;text&quot;: &quot;Task A&quot;}]});
&gt;&gt;&gt; d.tasks[0].text
'Task A'
&gt;&gt;&gt; d.tasks[0].tags = [&quot;red&quot;, &quot;white&quot;, &quot;blue&quot;];
&gt;&gt;&gt; d.tasks[0].tags[2];
'blue'
&gt;&gt;&gt; d.tasks[0].pop(&quot;tags&quot;) # `.pop()`
['red', 'white', 'blue']
&gt;&gt;&gt; 
&gt;&gt;&gt; import pprint
&gt;&gt;&gt; pprint.pprint(d)
{'foo': {'bar': 'baz'},
 'tasks': [{'id': 'a', 'text': 'Task A'}],
 'users': [{'id': 0, 'name': 'Alice'},
 {'id': 1, 'name': 'Becca'},
 {'id': 2, 'name': 'Cathy'}]}
&gt;&gt;&gt; 
&gt;&gt;&gt; type(d.users) # dotsi.Dict (AKA dotsi.DotsiDict)
&lt;class 'dotsi.DotsiList'&gt;
&gt;&gt;&gt; type(d.users[0]) # dotsi.List (AKA dotsi.DotsiList)
&lt;class 'dotsi.DotsiDict'&gt; 
&gt;&gt;&gt; 
</code></pre>

blocks|key|902337|text|最简单的解决方案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|902338|定义一个只包含pass语句的类。为这个类创建对象，并使用点符号。|902339|class+my_dict:
++++pass

person+=+my_dict()
person.id+=+1+#+create+using+dot+notation
person.phone+=+9999
del+person.phone+#+Remove+a+property+using+dot+notation

name_data+=+my_dict()
name_data.first_name+=+'Arnold'
name_data.last_name+=+'Schwarzenegger'

person.name+=+name_data
person.name.first_name+#+dot+notation+access+for+nested+properties+-+gives+Arnold|code-block|syntax|javascript|902340|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Simplest solution.
Define a class with only pass statement in it. Create object for this class and use dot notation.
<pre><code>class my_dict:
 pass

person = my_dict()
person.id = 1 # create using dot notation
person.phone = 9999
del person.phone # Remove a property using dot notation

name_data = my_dict()
name_data.first_name = 'Arnold'
name_data.last_name = 'Schwarzenegger'

person.name = name_data
person.name.first_name # dot notation access for nested properties - gives Arnold
</code></pre>

How do I make Python dictionary members accessible via a dot "."?

For example, instead of writing <code>mydict['val']</code>, I'd like to write <code>mydict.val</code>.

Also I'd like to access nested dicts this way. For example

<pre><code>mydict.mydict2.val 
</code></pre>

would refer to 

<pre><code>mydict = { 'mydict2': { 'val': ... } }
</code></pre>

How to use a dot "." to access members of dictionary?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

如何使Python字典成员可通过点".“访问？例如，我想编写mydict.val，而不是编写mydict['val']。另外，我想以这种方式访问嵌套的字典。例如mydict.mydict2.val 将会引用mydict = { 'mydict2': { 'val': ... } }

问“如何使用点”。访问字典的成员？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问“如何使用点”。访问字典的成员？EN