blocks|key|166971|text|使用reduce()遍历字典：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|166972|from+functools+import+reduce++#+forward+compatibility+for+Python+3
import+operator

def+getFromDict(dataDict,+mapList):
++++return+reduce(operator.getitem,+mapList,+dataDict)|code-block|syntax|javascript|166973|并重用getFromDict来查找存储setInDict()的值的位置|166974|def+setInDict(dataDict,+mapList,+value):
++++getFromDict(dataDict,+mapList[:-1])[mapList[-1]]+=+value|166975|mapList中除了最后一个元素之外的所有元素都需要找到要向其添加值的“父”字典，然后使用最后一个元素将值设置为正确的键。|166976|演示：|166977|>>>+getFromDict(dataDict,+["a",+"r"])
1
>>>+getFromDict(dataDict,+["b",+"v",+"y"])
2
>>>+setInDict(dataDict,+["b",+"v",+"w"],+4)
>>>+import+pprint
>>>+pprint.pprint(dataDict)
{'a':+{'r':+1,+'s':+2,+'t':+3},
+'b':+{'u':+1,+'v':+{'w':+4,+'x':+1,+'y':+2,+'z':+3},+'w':+3}}|166978|请注意，Python+PEP8样式指南prescribes+snake_case+names+for+functions。上面的方法同样适用于列表或字典和列表的混合，因此名称实际上应该是get_by_path()和set_by_path()|166979|from+functools+import+reduce++#+forward+compatibility+for+Python+3
import+operator

def+get_by_path(root,+items):
++++"""Access+a+nested+object+in+root+by+item+sequence."""
++++return+reduce(operator.getitem,+items,+root)

def+set_by_path(root,+items,+value):
++++"""Set+a+value+in+a+nested+object+in+root+by+item+sequence."""
++++get_by_path(root,+items[:-1])[items[-1]]+=+value|166980|为了完整起见，我们使用一个删除键的函数：|166981|def+del_by_path(root,+items):
++++"""Delete+a+key-value+in+a+nested+object+in+root+by+item+sequence."""
++++del+get_by_path(root,+items[:-1])[items[-1]]|166982|entityMap|0|LINK|mutability|MUTABLE|url|https://www.python.org/dev/peps/pep-0008/#function-and-variable-names^0|2|8|0|0|3|B|J|B|0|0|0|7|0|0|0|2L|D|2Z|D|J|15|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1A|8|@$9|1B|A|1C|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|1D|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1E|8|@$9|1F|A|1G|B|C]|$9|1H|A|1I|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|1J|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1K|8|@$9|1L|A|1M|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|6|7|1N|8|@]|D|@]|E|$]]|$1|S|3|T|5|H|7|1O|8|@]|D|@]|E|$I|J]]|$1|U|3|V|5|6|7|1P|8|@$9|1Q|A|1R|B|C]|$9|1S|A|1T|B|C]]|D|@$9|1U|A|1V|1|1W]]|E|$]]|$1|W|3|X|5|H|7|1X|8|@]|D|@]|E|$I|J]]|$1|Y|3|Z|5|6|7|1Y|8|@]|D|@]|E|$]]|$1|10|3|11|5|H|7|1Z|8|@]|D|@]|E|$I|J]]|$1|12|3|-4|5|6|7|20|8|@]|D|@]|E|$]]]|13|$14|$5|15|16|17|E|$18|19]]]]

Use <code>reduce()</code> to traverse the dictionary:
<pre><code>from functools import reduce # forward compatibility for Python 3
import operator

def getFromDict(dataDict, mapList):
 return reduce(operator.getitem, mapList, dataDict)
</code></pre>
and reuse <code>getFromDict</code> to find the location to store the value for <code>setInDict()</code>:
<pre><code>def setInDict(dataDict, mapList, value):
 getFromDict(dataDict, mapList[:-1])[mapList[-1]] = value
</code></pre>
All but the last element in <code>mapList</code> is needed to find the 'parent' dictionary to add the value to, then use the last element to set the value to the right key.
Demo:
<pre><code>&gt;&gt;&gt; getFromDict(dataDict, [&quot;a&quot;, &quot;r&quot;])
1
&gt;&gt;&gt; getFromDict(dataDict, [&quot;b&quot;, &quot;v&quot;, &quot;y&quot;])
2
&gt;&gt;&gt; setInDict(dataDict, [&quot;b&quot;, &quot;v&quot;, &quot;w&quot;], 4)
&gt;&gt;&gt; import pprint
&gt;&gt;&gt; pprint.pprint(dataDict)
{'a': {'r': 1, 's': 2, 't': 3},
 'b': {'u': 1, 'v': {'w': 4, 'x': 1, 'y': 2, 'z': 3}, 'w': 3}}
</code></pre>
Note that the Python PEP8 style guide <a href="https://www.python.org/dev/peps/pep-0008/#function-and-variable-names" rel="noreferrer">prescribes snake_case names for functions</a>. The above works equally well for lists or a mix of dictionaries and lists, so the names should really be <code>get_by_path()</code> and <code>set_by_path()</code>:
<pre><code>from functools import reduce # forward compatibility for Python 3
import operator

def get_by_path(root, items):
 &quot;&quot;&quot;Access a nested object in root by item sequence.&quot;&quot;&quot;
 return reduce(operator.getitem, items, root)

def set_by_path(root, items, value):
 &quot;&quot;&quot;Set a value in a nested object in root by item sequence.&quot;&quot;&quot;
 get_by_path(root, items[:-1])[items[-1]] = value
</code></pre>
And for completion's sake, a function to delete a key:
<pre><code>def del_by_path(root, items):
 &quot;&quot;&quot;Delete a key-value in a nested object in root by item sequence.&quot;&quot;&quot;
 del get_by_path(root, items[:-1])[items[-1]]
</code></pre>

blocks|key|385028|text|使用reduce很聪明，但是如果父键没有预先存在于嵌套字典中，那么OP的set方法可能会出现问题。由于这是我在谷歌搜索中看到的第一篇关于这个主题的帖子，我想把它做得稍微好一点。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|385029|(+Setting+a+value+in+a+nested+python+dictionary+given+a+list+of+indices+and+value+)中的set方法对于丢失的父密钥似乎更健壮。要复制它，请执行以下操作：|offset|length|385030|def+nested_set(dic,+keys,+value):
++++for+key+in+keys[:-1]:
++++++++dic+=+dic.setdefault(key,+{})
++++dic[keys[-1]]+=+value|code-block|syntax|javascript|385031|此外，使用一个遍历密钥树并获取所有绝对密钥路径的方法也很方便，我已经为这些路径创建了以下内容：|385032|def+keysInDict(dataDict,+parent=[]):
++++if+not+isinstance(dataDict,+dict):
++++++++return+[tuple(parent)]
++++else:
++++++++return+reduce(list.__add__,+
++++++++++++[keysInDict(v,parent%2B[k])+for+k,v+in+dataDict.items()],+[])|385033|它的一个用途是使用以下代码将嵌套树转换为pandas+DataFrame+(假设嵌套字典中的所有leafs都具有相同的深度)。|385034|def+dict_to_df(dataDict):
++++ret+=+[]
++++for+k+in+keysInDict(dataDict):
++++++++v+=+np.array(+getFromDict(dataDict,+k),+)
++++++++v+=+pd.DataFrame(v)
++++++++v.columns+=+pd.MultiIndex.from_product(list(k)+%2B+[v.columns])
++++++++ret.append(v)
++++return+reduce(pd.DataFrame.join,+ret)|385035|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/13687924/setting-a-value-in-a-nested-python-dictionary-given-a-list-of-indices-and-value^0|0|2|27|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|11|8|@]|9|@$D|12|E|13|1|14]]|A|$]]|$1|F|3|G|5|H|7|15|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|16|8|@]|9|@]|A|$]]|$1|M|3|N|5|H|7|17|8|@]|9|@]|A|$I|J]]|$1|O|3|P|5|6|7|18|8|@]|9|@]|A|$]]|$1|Q|3|R|5|H|7|19|8|@]|9|@]|A|$I|J]]|$1|S|3|-4|5|6|7|1A|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|Z]]]]

Using reduce is clever, but the OP's set method may have issues if the parent keys do not pre-exist in the nested dictionary. Since this is the first SO post I saw for this subject in my google search, I would like to make it slightly better.

The set method in ( <a href="https://stackoverflow.com/questions/13687924/setting-a-value-in-a-nested-python-dictionary-given-a-list-of-indices-and-value">Setting a value in a nested python dictionary given a list of indices and value</a> ) seems more robust to missing parental keys. To copy it over:

<pre><code>def nested_set(dic, keys, value):
 for key in keys[:-1]:
 dic = dic.setdefault(key, {})
 dic[keys[-1]] = value
</code></pre>

Also, it can be convenient to have a method that traverses the key tree and get all the absolute key paths, for which I have created:

<pre><code>def keysInDict(dataDict, parent=[]):
 if not isinstance(dataDict, dict):
 return [tuple(parent)]
 else:
 return reduce(list.__add__, 
 [keysInDict(v,parent+[k]) for k,v in dataDict.items()], [])
</code></pre>

One use of it is to convert the nested tree to a pandas DataFrame, using the following code (assuming that all leafs in the nested dictionary have the same depth).

<pre><code>def dict_to_df(dataDict):
 ret = []
 for k in keysInDict(dataDict):
 v = np.array( getFromDict(dataDict, k), )
 v = pd.DataFrame(v)
 v.columns = pd.MultiIndex.from_product(list(k) + [v.columns])
 ret.append(v)
 return reduce(pd.DataFrame.join, ret)
</code></pre>

blocks|key|167075|text|与其每次查找一个值都会影响性能，不如将字典展平一次，然后简单地查找关键字，如b:v:y|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|167076|def+flatten(mydict):
++new_dict+=+{}
++for+key,value+in+mydict.items():
++++if+type(value)+==+dict:
++++++_dict+=+{':'.join([key,+_key]):_value+for+_key,+_value+in+flatten(value).items()}
++++++new_dict.update(_dict)
++++else:
++++++new_dict[key]=value
++return+new_dict

dataDict+=+{
"a":{
++++"r":+1,
++++"s":+2,
++++"t":+3
++++},
"b":{
++++"u":+1,
++++"v":+{
++++++++"x":+1,
++++++++"y":+2,
++++++++"z":+3
++++},
++++"w":+3
++++}
}++++

flat_dict+=+flatten(dataDict)
print+flat_dict
{'b:w':+3,+'b:u':+1,+'b:v:y':+2,+'b:v:x':+1,+'b:v:z':+3,+'a:r':+1,+'a:s':+2,+'a:t':+3}|code-block|syntax|javascript|167077|这样，您就可以简单地使用flat_dict['b:v:y']查找项目，这将为您提供1。|167078|而不是在每次查找时遍历字典，您可以通过扁平化字典并保存输出来加速这一过程，以便从冷启动的查找将意味着加载扁平化的字典，并简单地执行键/值查找而不遍历。|167079|entityMap^0|12|5|0|0|C|I|15|1|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@$9|V|A|W|B|C]|$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|Z|8|@]|D|@]|E|$]]|$1|O|3|-4|5|6|7|10|8|@]|D|@]|E|$]]]|P|$]]

Instead of taking a performance hit each time you want to look up a value, how about you flatten the dictionary once then simply look up the key like <code>b:v:y</code>

<pre><code>def flatten(mydict):
 new_dict = {}
 for key,value in mydict.items():
 if type(value) == dict:
 _dict = {':'.join([key, _key]):_value for _key, _value in flatten(value).items()}
 new_dict.update(_dict)
 else:
 new_dict[key]=value
 return new_dict

dataDict = {
"a":{
 "r": 1,
 "s": 2,
 "t": 3
 },
"b":{
 "u": 1,
 "v": {
 "x": 1,
 "y": 2,
 "z": 3
 },
 "w": 3
 }
} 

flat_dict = flatten(dataDict)
print flat_dict
{'b:w': 3, 'b:u': 1, 'b:v:y': 2, 'b:v:x': 1, 'b:v:z': 3, 'a:r': 1, 'a:s': 2, 'a:t': 3}
</code></pre>

This way you can simply look up items using <code>flat_dict['b:v:y']</code> which will give you <code>1</code>.

And instead of traversing the dictionary on each lookup, you may be able to speed this up by flattening the dictionary and saving the output so that a lookup from cold start would mean loading up the flattened dictionary and simply performing a key/value lookup with no traversal.

blocks|key|385115|text|使用递归函数怎么样？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|385116|要获取值，请执行以下操作：|385117|def+getFromDict(dataDict,+maplist):
++++first,+rest+=+maplist[0],+maplist[1:]

++++if+rest:+
++++++++#+if+`rest`+is+not+empty,+run+the+function+recursively
++++++++return+getFromDict(dataDict[first],+rest)
++++else:
++++++++return+dataDict[first]|code-block|syntax|javascript|385118|并设置一个值：|385119|def+setInDict(dataDict,+maplist,+value):
++++first,+rest+=+maplist[0],+maplist[1:]

++++if+rest:
++++++++try:
++++++++++++if+not+isinstance(dataDict[first],+dict):
++++++++++++++++#+if+the+key+is+not+a+dict,+then+make+it+a+dict
++++++++++++++++dataDict[first]+=+{}
++++++++except+KeyError:
++++++++++++#+if+key+doesn't+exist,+create+one
++++++++++++dataDict[first]+=+{}

++++++++setInDict(dataDict[first],+rest,+value)
++++else:
++++++++dataDict[first]+=+value|385120|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|Q|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|R|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

How about using recursive functions?

To get a value:

<pre><code>def getFromDict(dataDict, maplist):
 first, rest = maplist[0], maplist[1:]

 if rest: 
 # if `rest` is not empty, run the function recursively
 return getFromDict(dataDict[first], rest)
 else:
 return dataDict[first]
</code></pre>

And to set a value:

<pre><code>def setInDict(dataDict, maplist, value):
 first, rest = maplist[0], maplist[1:]

 if rest:
 try:
 if not isinstance(dataDict[first], dict):
 # if the key is not a dict, then make it a dict
 dataDict[first] = {}
 except KeyError:
 # if key doesn't exist, create one
 dataDict[first] = {}

 setInDict(dataDict[first], rest, value)
 else:
 dataDict[first] = value
</code></pre>

blocks|key|385137|text|纯Python风格，无需任何导入：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|385138|def+nested_set(element,+value,+*keys):
++++if+type(element)+is+not+dict:
++++++++raise+AttributeError('nested_set()+expects+dict+as+first+argument.')
++++if+len(keys)+<+2:
++++++++raise+AttributeError('nested_set()+expects+at+least+three+arguments,+not+enough+given.')

++++_keys+=+keys[:-1]
++++_element+=+element
++++for+key+in+_keys:
++++++++_element+=+_element[key]
++++_element[keys[-1]]+=+value

example+=+{"foo":+{+"bar":+{+"baz":+"ok"+}+}+}
keys+=+['foo',+'bar']
nested_set(example,+"yay",+*keys)
print(example)|code-block|syntax|javascript|385139|输出|385140|{'foo':+{'bar':+'yay'}}|385141|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|$]]

Pure Python style, without any import:

<pre><code>def nested_set(element, value, *keys):
 if type(element) is not dict:
 raise AttributeError('nested_set() expects dict as first argument.')
 if len(keys) &lt; 2:
 raise AttributeError('nested_set() expects at least three arguments, not enough given.')

 _keys = keys[:-1]
 _element = element
 for key in _keys:
 _element = _element[key]
 _element[keys[-1]] = value

example = {"foo": { "bar": { "baz": "ok" } } }
keys = ['foo', 'bar']
nested_set(example, "yay", *keys)
print(example)
</code></pre>

Output

<pre><code>{'foo': {'bar': 'yay'}}
</code></pre>

blocks|key|385167|text|用递归解决了这个问题：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|385168|def+get(d,l):
++++if+len(l)==1:+return+d[l[0]]
++++return+get(d[l[0]],l[1:])|code-block|syntax|javascript|385169|使用您的示例：|385170|dataDict+=+{
++++"a":{
++++++++"r":+1,
++++++++"s":+2,
++++++++"t":+3
++++++++},
++++"b":{
++++++++"u":+1,
++++++++"v":+{
++++++++++++"x":+1,
++++++++++++"y":+2,
++++++++++++"z":+3
++++++++},
++++++++"w":+3
++++++++}
}
maplist1+=+["a",+"r"]
maplist2+=+["b",+"v",+"y"]
print(get(dataDict,+maplist1))+#+1
print(get(dataDict,+maplist2))+#+2|385171|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|$]]

Solved this with recursion:

<pre><code>def get(d,l):
 if len(l)==1: return d[l[0]]
 return get(d[l[0]],l[1:])
</code></pre>

Using your example:

<pre><code>dataDict = {
 "a":{
 "r": 1,
 "s": 2,
 "t": 3
 },
 "b":{
 "u": 1,
 "v": {
 "x": 1,
 "y": 2,
 "z": 3
 },
 "w": 3
 }
}
maplist1 = ["a", "r"]
maplist2 = ["b", "v", "y"]
print(get(dataDict, maplist1)) # 1
print(get(dataDict, maplist2)) # 2
</code></pre>

blocks|key|167241|text|如果您还希望能够使用包括嵌套列表和字典在内的任意json，并很好地处理无效的查找路径，下面是我的解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|167242|from+functools+import+reduce


def+get_furthest(s,+path):
++++'''
++++Gets+the+furthest+value+along+a+given+key+path+in+a+subscriptable+structure.

++++subscriptable,+list+->+any
++++:param+s:+the+subscriptable+structure+to+examine
++++:param+path:+the+lookup+path+to+follow
++++:return:+a+tuple+of+the+value+at+the+furthest+valid+key,+and+whether+the+full+path+is+valid
++++'''

++++def+step_key(acc,+key):
++++++++s+=+acc[0]
++++++++if+isinstance(s,+str):
++++++++++++return+(s,+False)
++++++++try:
++++++++++++return+(s[key],+acc[1])
++++++++except+LookupError:
++++++++++++return+(s,+False)

++++return+reduce(step_key,+path,+(s,+True))


def+get_val(s,+path):
++++val,+successful+=+get_furthest(s,+path)
++++if+successful:
++++++++return+val
++++else:
++++++++raise+LookupError('Invalid+lookup+path:+{}'.format(path))


def+set_val(s,+path,+value):
++++get_val(s,+path[:-1])[path[-1]]+=+value|code-block|syntax|javascript|167243|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 also want the ability to work with arbitrary json including nested lists and dicts, and nicely handle invalid lookup paths, here's my solution:

<pre><code>from functools import reduce


def get_furthest(s, path):
 '''
 Gets the furthest value along a given key path in a subscriptable structure.

 subscriptable, list -&gt; any
 :param s: the subscriptable structure to examine
 :param path: the lookup path to follow
 :return: a tuple of the value at the furthest valid key, and whether the full path is valid
 '''

 def step_key(acc, key):
 s = acc[0]
 if isinstance(s, str):
 return (s, False)
 try:
 return (s[key], acc[1])
 except LookupError:
 return (s, False)

 return reduce(step_key, path, (s, True))


def get_val(s, path):
 val, successful = get_furthest(s, path)
 if successful:
 return val
 else:
 raise LookupError('Invalid lookup path: {}'.format(path))


def set_val(s, path, value):
 get_val(s, path[:-1])[path[-1]] = value
</code></pre>

blocks|key|167295|text|如果您不想在缺少其中一个键的情况下引发错误，另一种方法是(这样您的主代码就可以运行而不会中断)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|167296|def+get_value(self,your_dict,*keys):
++++curr_dict_+=+your_dict
++++for+k+in+keys:
++++++++v+=+curr_dict.get(k,None)
++++++++if+v+is+None:
++++++++++++break
++++++++if+isinstance(v,dict):
++++++++++++curr_dict+=+v
++++return+v|code-block|syntax|javascript|167297|在这种情况下，如果任何输入键都不存在，则返回None，这可用作检查您的主代码以执行替代任务。|167298|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

An alternative way if you don't want to raise errors if one of the keys is absent (so that your main code can run without interruption):

<pre><code>def get_value(self,your_dict,*keys):
 curr_dict_ = your_dict
 for k in keys:
 v = curr_dict.get(k,None)
 if v is None:
 break
 if isinstance(v,dict):
 curr_dict = v
 return v
</code></pre>

In this case, if any of the input keys is not present, None is returned, which can be used as a check in your main code to perform an alternative task.

blocks|key|385372|text|在不处理所有索引的情况下检查并设置dict元素如何？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|385373|解决方案：|385374|def+nested_yield(nested,+keys_list):
++++"""
++++Get+current+nested+data+by+send(None)+method.+Allows+change+it+to+Value+by+calling+send(Value)+next+time
++++:param+nested:+list+or+dict+of+lists+or+dicts
++++:param+keys_list:+list+of+indexes/keys
++++"""
++++if+not+len(keys_list):++#+assign+to+1st+level+list
++++++++if+isinstance(nested,+list):
++++++++++++while+True:
++++++++++++++++nested[:]+=+yield+nested
++++++++else:
++++++++++++raise+IndexError('Only+lists+can+take+element+without+key')


++++last_key+=+keys_list.pop()
++++for+key+in+keys_list:
++++++++nested+=+nested[key]

++++while+True:
++++++++try:
++++++++++++nested[last_key]+=+yield+nested[last_key]
++++++++except+IndexError+as+e:
++++++++++++print('no+index+{}+in+{}'.format(last_key,+nested))
++++++++++++yield+None|code-block|syntax|javascript|385375|工作流程示例：|385376|ny+=+nested_yield(nested_dict,+nested_address)
data_element+=+ny.send(None)
if+data_element:
++++#+process+element
++++...
else:
++++#+extend/update+nested+data
++++ny.send(new_data_element)
++++...
ny.close()|385377|测试|385378|>>>+cfg=+{'Options':+[[1,[0]],[2,[4,[8,16]]],[3,[9]]]}
++++ny+=+nested_yield(cfg,+['Options',1,1,1])
++++ny.send(None)
[8,+16]
>>>+ny.send('Hello!')
'Hello!'
>>>+cfg
{'Options':+[[1,+[0]],+[2,+[4,+'Hello!']],+[3,+[9]]]}
>>>+ny.close()|385379|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|V|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

How about check and then set dict element without processing all indexes twice?

Solution:

<pre><code>def nested_yield(nested, keys_list):
 """
 Get current nested data by send(None) method. Allows change it to Value by calling send(Value) next time
 :param nested: list or dict of lists or dicts
 :param keys_list: list of indexes/keys
 """
 if not len(keys_list): # assign to 1st level list
 if isinstance(nested, list):
 while True:
 nested[:] = yield nested
 else:
 raise IndexError('Only lists can take element without key')


 last_key = keys_list.pop()
 for key in keys_list:
 nested = nested[key]

 while True:
 try:
 nested[last_key] = yield nested[last_key]
 except IndexError as e:
 print('no index {} in {}'.format(last_key, nested))
 yield None
</code></pre>

Example workflow:

<pre><code>ny = nested_yield(nested_dict, nested_address)
data_element = ny.send(None)
if data_element:
 # process element
 ...
else:
 # extend/update nested data
 ny.send(new_data_element)
 ...
ny.close()
</code></pre>

Test

<pre><code>&gt;&gt;&gt; cfg= {'Options': [[1,[0]],[2,[4,[8,16]]],[3,[9]]]}
 ny = nested_yield(cfg, ['Options',1,1,1])
 ny.send(None)
[8, 16]
&gt;&gt;&gt; ny.send('Hello!')
'Hello!'
&gt;&gt;&gt; cfg
{'Options': [[1, [0]], [2, [4, 'Hello!']], [3, [9]]]}
&gt;&gt;&gt; ny.close()
</code></pre>

blocks|key|385417|text|一种连接字符串的方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|385418|def+get_sub_object_from_path(dict_name,+map_list):
++++for+i+in+map_list:
++++++++_string+=+"['%25s']"+%25+i
++++++++dict_name+%2B=+_string
++++value+=+eval(dict_name)
++++return+value
#Sample:
_dict+=+{'new':+'person',+'time':+{'for':+'one'}}
map_list+=+['time',+'for']
print+get_sub_object_from_path("_dict",map_list)
#Output:
#one|code-block|syntax|javascript|385419|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 method for concatenating strings:

<pre><code>def get_sub_object_from_path(dict_name, map_list):
 for i in map_list:
 _string = "['%s']" % i
 dict_name += _string
 value = eval(dict_name)
 return value
#Sample:
_dict = {'new': 'person', 'time': {'for': 'one'}}
map_list = ['time', 'for']
print get_sub_object_from_path("_dict",map_list)
#Output:
#one
</code></pre>

blocks|key|167494|text|扩展@DomTomCat和其他人的方法，这些函数式(即，通过深度复制返回修改后的数据，而不影响输入)设置器和映射器适用于嵌套的dict和list。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|167495|setter：|167496|def+set_at_path(data0,+keys,+value):
++++data+=+deepcopy(data0)
++++if+len(keys)>1:
++++++++if+isinstance(data,dict):
++++++++++++return+{k:(set_by_path(v,keys[1:],value)+if+k==keys[0]+else+v)+for+k,v+in+data.items()}
++++++++if+isinstance(data,list):
++++++++++++return+[set_by_path(x[1],keys[1:],value)+if+x[0]==keys[0]+else+x[1]+for+x+in+enumerate(data)]
++++else:
++++++++data[keys[-1]]=value
++++++++return+data|code-block|syntax|javascript|167497|映射器：|167498|def+map_at_path(data0,+keys,+f):
++++data+=+deepcopy(data0)
++++if+len(keys)>1:
++++++++if+isinstance(data,dict):
++++++++++++return+{k:(map_at_path(v,keys[1:],f)+if+k==keys[0]+else+v)+for+k,v+in+data.items()}
++++++++if+isinstance(data,list):
++++++++++++return+[map_at_path(x[1],keys[1:],f)+if+x[0]==keys[0]+else+x[1]+for+x+in+enumerate(data)]
++++else:
++++++++data[keys[-1]]=f(data[keys[-1]])
++++++++return+data|167499|entityMap^0|1R|4|1W|4|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|X|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|Y|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|Z|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|10|8|@]|D|@]|E|$K|L]]|$1|Q|3|-4|5|6|7|11|8|@]|D|@]|E|$]]]|R|$]]

Extending @DomTomCat and others' approach, these functional (ie, return modified data via deepcopy without affecting the input) setter and mapper works for nested <code>dict</code> and <code>list</code>. 

setter:

<pre><code>def set_at_path(data0, keys, value):
 data = deepcopy(data0)
 if len(keys)&gt;1:
 if isinstance(data,dict):
 return {k:(set_by_path(v,keys[1:],value) if k==keys[0] else v) for k,v in data.items()}
 if isinstance(data,list):
 return [set_by_path(x[1],keys[1:],value) if x[0]==keys[0] else x[1] for x in enumerate(data)]
 else:
 data[keys[-1]]=value
 return data
</code></pre>

mapper:

<pre><code>def map_at_path(data0, keys, f):
 data = deepcopy(data0)
 if len(keys)&gt;1:
 if isinstance(data,dict):
 return {k:(map_at_path(v,keys[1:],f) if k==keys[0] else v) for k,v in data.items()}
 if isinstance(data,list):
 return [map_at_path(x[1],keys[1:],f) if x[0]==keys[0] else x[1] for x in enumerate(data)]
 else:
 data[keys[-1]]=f(data[keys[-1]])
 return data
</code></pre>

blocks|key|167519|text|您可以使用pydash：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|167520|import+pydash+as+_

_.get(dataDict,+["b",+"v",+"y"],+default='Default')|code-block|syntax|javascript|167521|https://pydash.readthedocs.io/en/latest/api.html|offset|length|167522|entityMap|0|LINK|mutability|MUTABLE|url^0|0|0|0|1C|0|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|S|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|T|8|@]|9|@$I|U|J|V|1|W]]|A|$]]|$1|K|3|-4|5|6|7|X|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|H]]]]

You can use pydash:

<pre><code>import pydash as _

_.get(dataDict, ["b", "v", "y"], default='Default')
</code></pre>

<a href="https://pydash.readthedocs.io/en/latest/api.html" rel="nofollow noreferrer">https://pydash.readthedocs.io/en/latest/api.html</a>

blocks|key|167539|text|我用这个|type|unstyled|depth|inlineStyleRanges|entityRanges|data|167540|def+get_dictionary_value(dictionary_temp,+variable_dictionary_keys):
+++++try:
++++++++++if(len(variable_dictionary_keys)+==+0):
+++++++++++++++return+str(dictionary_temp)

++++++++++variable_dictionary_key+=+variable_dictionary_keys[0]
++++++++++variable_dictionary_keys.remove(variable_dictionary_key)

++++++++++return+get_dictionary_value(dictionary_temp[variable_dictionary_key]+,+variable_dictionary_keys)

+++++except+Exception+as+variable_exception:
++++++++++logging.error(variable_exception)
+
++++++++++return+''|code-block|syntax|javascript|167541|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 use this
<pre><code>def get_dictionary_value(dictionary_temp, variable_dictionary_keys):
 try:
 if(len(variable_dictionary_keys) == 0):
 return str(dictionary_temp)

 variable_dictionary_key = variable_dictionary_keys[0]
 variable_dictionary_keys.remove(variable_dictionary_key)

 return get_dictionary_value(dictionary_temp[variable_dictionary_key] , variable_dictionary_keys)

 except Exception as variable_exception:
 logging.error(variable_exception)
 
 return ''

</code></pre>

I have a complex dictionary structure which I would like to access via a list of keys to address the correct item.

<pre class="lang-py prettyprint-override"><code>dataDict = {
 "a":{
 "r": 1,
 "s": 2,
 "t": 3
 },
 "b":{
 "u": 1,
 "v": {
 "x": 1,
 "y": 2,
 "z": 3
 },
 "w": 3
 }
} 

maplist = ["a", "r"]
</code></pre>

or 

<pre><code>maplist = ["b", "v", "y"]
</code></pre>

I have made the following code which works but I'm sure there is a better and more efficient way to do this if anyone has an idea.

<pre><code># Get a given data from a dictionary with position provided as a list
def getFromDict(dataDict, mapList): 
 for k in mapList: dataDict = dataDict[k]
 return dataDict

# Set a given data in a dictionary with position provided as a list
def setInDict(dataDict, mapList, value): 
 for k in mapList[:-1]: dataDict = dataDict[k]
 dataDict[mapList[-1]] = value
</code></pre>

Access nested dictionary items via a list of keys?

Python

我有一个复杂的字典结构，我想通过一个关键字列表来访问它，以找到正确的条目。dataDict = {    "a":{        "r": 1,        "s": 2,        "t": 3        },    "b":{        "u": 1,        "v": {          ...

问通过键列表访问嵌套的字典项？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问通过键列表访问嵌套的字典项？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问通过键列表访问嵌套的字典项？
EN