blocks|key|1101478|text|从dict派生，并实现__getattr__和__setattr__。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1101479|或者，您可以使用非常类似的Bunch。|1101480|我不认为monkeypatch内置的dict类是可能的。|1101481|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|1101529|text|在Python中，属性访问和索引是两件不同的事情，您不应该希望它们执行相同的操作。如果你有一些东西应该有可访问的属性，那么创建一个类(可能是由namedtuple制作的)，并使用[]表示法从字典中获取一个条目。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1101530|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|1316517|text|语言本身不支持这一点，但有时这仍然是一个有用的需求。除了Bunch方法之外，您还可以编写一个小方法，该方法可以使用虚线字符串访问字典：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1316518|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|1316519|它会支持这样的东西：|1316520|>>+test_dict+=+{'thing':+{'spam':+12,+'foo':+{'cheeze':+'bar'}}}
>>+output+=+get_var(test_dict,+'thing.spam.foo.cheeze')
>>+print+output
'bar'
>>|1316521|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|1101641|text|我试过这个：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1101642|class+dotdict(dict):
++++def+__getattr__(self,+name):
++++++++return+self[name]|code-block|syntax|javascript|1101643|你也可以试试__getattribute__。|offset|length|style|CODE|1101644|让每个字典都是一种点字典就足够了，如果你想从一个多层字典中初始化它，也可以尝试实现__init__。|1101645|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|1316667|text|基于Kugel的回答，并考虑到Mike+Graham的警告，如果我们做一个包装器呢？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1316668|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|1316669|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|1316727|text|我一直把它放在一个util文件中。你也可以在你自己的类中使用它作为混入。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1316728|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|1316729|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|1316788|text|我最终尝试了AttrDict和Bunch库，发现它们对我的使用来说太慢了。在我和一个朋友研究过后，我们发现编写这些库的main方法会导致库通过嵌套对象积极地递归，并从头到尾复制字典对象。考虑到这一点，我们做了两个关键的改变。1)我们创建了延迟加载的属性2)我们创建了轻量级代理对象的副本，而不是创建字典对象的副本。这是最终的实现。使用此代码的性能提升是难以置信的。当使用AttrDict或Bunch时，这两个库分别消耗了我请求时间的1/2和1/3+(什么！？)。这段代码将时间减少到几乎为零(在0.5ms范围内的某个地方)。当然，这取决于您的需求，但如果您在代码中经常使用此功能，则一定要使用类似下面这样的简单代码。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1316789|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|1316790|请参阅https://stackoverflow.com/users/704327/michael-merickel的原始实现here。|1316791|另一件需要注意的事情是，这个实现非常简单，并没有实现您可能需要的所有方法。您需要根据需要在DictProxy或ListProxy对象上编写这些代码。|1316792|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|1101870|text|此解决方案是对epool提供的解决方案的改进，以满足OP以一致的方式访问嵌套字典的需求。epool的解决方案不允许访问嵌套的字典。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1101871|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|1101872|有了这个类，我们现在可以做一些类似的事情：A.B.C.D。|style|CODE|1101873|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|1316844|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|1316845|如果决定永久地将dict转换为object，应该可以这样做。您可以在访问之前创建一个一次性对象。|unstyled|offset|length|style|CODE|1316846|d+=+dict_to_object(d)|1316847|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|1101914|text|我想把我自己的解决方案抛到拳台上：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1101915|https://github.com/skorokithakis/jsane|offset|length|1101916|它允许您将JSON解析为可以访问with.attribute.lookups.like.this.r()的内容，这主要是因为我在开始研究之前没有看到这个答案。|style|CODE|1101917|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|1101946|text|如果你想要修改你的字典，你需要在上面的答案中添加一些状态方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1101947|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|1101948|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|1316968|text|不是对OP问题的直接回答，但受到一些人的启发，也许对他们有用。我已经使用内部__dict__创建了一个基于对象的解决方案(绝对不是优化代码)|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1316969|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|1316970|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|1317006|text|为了构建epool的答案，此版本允许您通过点运算符访问内部的任何字典：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1317007|foo+=+{
++++"bar"+:+{
++++++++"baz"+:+[+{"boo"+:+"hoo"}+,+{"baba"+:+"loo"}+]
++++}
}|code-block|syntax|javascript|1317008|例如，foo.bar.baz[1].baba返回"loo"。|offset|length|style|CODE|1317009|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]|1317010|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|1317082|text|获取点访问(但不是数组访问)的一种简单方法是在Python中使用纯对象。如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1317083|class+YourObject:
++++def+__init__(self,+*args,+**kwargs):
++++++++for+k,+v+in+kwargs.items():
++++++++++++setattr(self,+k,+v)|code-block|syntax|javascript|1317084|...and这样使用它：|1317085|>>>+obj+=+YourObject(key="value")
>>>+print(obj.key)
"value"|1317086|..。要将其转换为字典，请执行以下操作：|1317087|>>>+print(obj.__dict__)
{"key":+"value"}|1317088|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|1317142|text|一种微妙的解决方案|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1317143|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|1317144|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|1102200|text|这也适用于嵌套的字典，并确保稍后附加的字典具有相同的行为：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1102201|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|1102202|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|1317239|text|我最近偶然发现了'Box‘库，它做了同样的事情。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1317240|安装命令：pip+install+python-box|style|CODE|1317241|示例：|1317242|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|1317243|我发现它比其他现有的库更有效，比如dotmap，当你有大的嵌套字典时，它会产生python递归错误。|1317244|库链接和详细信息：https://pypi.org/project/python-box/|1317245|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|1317255|text|使用SimpleNamespace|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1317256|>>>+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|1317257|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|1317309|text|我只需要使用虚线路径字符串访问字典，所以我想出了：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1317310|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|1317311|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|1317365|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|1317366|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|1317389|text|这是我很久以前做的一个项目中发现的。它可能会进行一些优化，但现在开始了。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1317390|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|1317391|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|1317454|text|我的两点意见:出于我自己的目的，我开发了minydra，这是一个简单的命令行解析器，其中包含一个自定义类MinyDict+(灵感来自addict)：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1317455|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|1317456|它比addict更进一步，向/从json+yaml和pickle添加转储/加载方法，并且在MinyDict.update()中还具有strict模式，以防止创建新的键(这对于防止命令行中的键入错误很有用)|1317457|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|1102526|text|您可以使用SimpleNamespace实现这一点|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1102527|from+types+import+SimpleNamespace
#+Assign+values
args+=+SimpleNamespace()
args.username+=+'admin'

#+Retrive+values
print(args.username)++#+output:+admin|code-block|syntax|javascript|1102528|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|1102551|text|可以使用dotsi，以获得完整的列表、字典和递归支持，以及一些扩展方法|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1102552|pip+install+dotsi|code-block|syntax|javascript|1102553|和|1102554|>>>+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'>+
>>>+|1102555|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|1102609|text|最简单的解决方案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1102610|定义一个只包含pass语句的类。为这个类创建对象，并使用点符号。|1102611|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|1102612|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?

Python

JSON

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

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

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

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

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

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