blocks|key|3850466|text|怎么样|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3850467|n+=+sum([len(v)%2B1+for+k,+v+in+dict_test.items()])|code-block|syntax|javascript|3850468|你所做的是对所有的键k和值进行迭代，v是你的副词。您将获得这些字典的长度，并添加一个以包含用于索引子字典的键。|3850469|然后，对列表进行加和，以得到完整的键数。|3850470|编辑：|3850471|为了澄清，此片段仅适用于所要求的字典词典。不是字典的字典.|3850472|因此，不要将其用于嵌套示例:)|3850473|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|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|V|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

How about 

<pre><code>n = sum([len(v)+1 for k, v in dict_test.items()])
</code></pre>

What you are doing is iterating over all keys k and values v. The values v are your subdictionaries. You get the length of those dictionaries and add one to include the key used to index the subdictionary.

Afterwards you sum over the list to get the complete number of keys.

EDIT:

To clarify, this snippet works only for dictionaries of dictionaries as asked. Not dictionaries of dictionaries of dictionaries... 
So do not use it for nested example :)

blocks|key|3764092|text|类似于：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3764093|print+len(dict_test)+%2B+sum(len(v)+for+v+in+dict_test.values())|offset|length|style|CODE|3764094|entityMap^0|0|0|1Q|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@$D|L|E|M|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

Something like:

<code>print len(dict_test) + sum(len(v) for v in dict_test.values())</code>

blocks|key|3850485|text|尝尝这个,|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3850486|l+=+len(dict_test)
for+k+in+dict_test:
++++l+%2B=+len(dict_test[k])|code-block|syntax|javascript|3850487|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|$]]

Try this,

<pre><code>l = len(dict_test)
for k in dict_test:
 l += len(dict_test[k])
</code></pre>

blocks|key|3764126|text|你可以试着用熊猫DataFrame来做这个：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3764127|>>>+import+pandas+as+pd
>>>+data+=+{'1':+{'2':+'a',+'3':+'b'},+'4':+{'5':+'c',+'6':+'d'},+'7':+{'5':+'x'}}
>>>+df+=+pd.DataFrame(data)
>>>+print+(df.count().sum()+%2B+len(df.columns))++#+8|code-block|syntax|javascript|3764128|pd.DataFrame(data)行将将您的字典转换为N矩阵，其中N是“父”键的数目，M是唯一子键的数目：|offset|length|style|CODE|3764129|+++++1++++4++++7
2++++a++NaN++NaN
3++++b++NaN++NaN
5++NaN++++c++++x
6++NaN++++d++NaN|3764130|对于每一行，列都有一个值或NaN。您只需计算非NaN值，这将给出子键的数量，并添加len(df.columns)，后者代表列数(即父键)。|3764131|entityMap^0|0|0|0|I|0|0|N|3|15|F|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@$I|V|J|W|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|Y|8|@$I|Z|J|10|K|L]|$I|11|J|12|K|L]]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|13|8|@]|9|@]|A|$]]]|R|$]]

You could try using pandas DataFrame for that:

<pre><code>&gt;&gt;&gt; import pandas as pd
&gt;&gt;&gt; data = {'1': {'2': 'a', '3': 'b'}, '4': {'5': 'c', '6': 'd'}, '7': {'5': 'x'}}
&gt;&gt;&gt; df = pd.DataFrame(data)
&gt;&gt;&gt; print (df.count().sum() + len(df.columns)) # 8
</code></pre>

The <code>pd.DataFrame(data)</code> line will convert your dictionary to a N x M matrix, where N is number of "parent" keys and M is the number of unique children keys:

<pre><code> 1 4 7
2 a NaN NaN
3 b NaN NaN
5 NaN c x
6 NaN d NaN
</code></pre>

For each [row, column] you have a value or NaN. You just need to count the non <code>NaN</code> values, which will give you the number of children keys and add <code>len(df.columns)</code>, which stands for the number of columns (i.e. parent keys).

blocks|key|3850524|text|作为一种更普遍的方法，您可以使用递归函数和生成器表达式：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3850525|>>>+def+count_keys(dict_test):
...+++++return+sum(1%2Bcount_keys(v)+if+isinstance(v,dict)+else+1+for+_,v+in+dict_test.iteritems())
...+|code-block|syntax|javascript|3850526|示例：|3850527|>>>+dict_test+=+{'a':+{'c':+'2',+'b':+'1',+'e':+{'f':+{1:+{5:+'a'}}},+'d':+'3'}}
>>>+
>>>+count(dict_test)
8|3850528|注意:在python3.x中，使用dict.items()方法而不是iteritems()。|offset|length|style|CODE|3850529|一个具有可接受答案的基准，它表明这个函数比接受的答案更快：|3850530|from+timeit+import+timeit

s1+=+"""
def+sum_keys(d):
++++return+0+if+not+isinstance(d,+dict)+else+len(d)+%2B+sum(sum_keys(v)+for+v+in+d.itervalues())

sum_keys(dict_test)
"""

s2+=+"""
def+count_keys(dict_test):
++++return+sum(1%2Bcount_keys(v)+if+isinstance(v,dict)+else+1+for+_,v+in+dict_test.iteritems())

count_keys(dict_test)
+++"""

print+'1st:+',+timeit(stmt=s1,
++++++++++++++++++++++number=1000000,
++++++++++++++++++++++setup="dict_test+=+{'a':+{'c':+'2',+'b':+'1',+'e':+{'f':+{1:+{5:+'a'}}},+'d':+'3'}}")
print+'2nd+:+',+timeit(stmt=s2,
+++++++++++++++++++++++number=1000000,
+++++++++++++++++++++++setup="dict_test+=+{'a':+{'c':+'2',+'b':+'1',+'e':+{'f':+{1:+{5:+'a'}}},+'d':+'3'}}")|3850531|结果：|3850532|1st:++4.65556812286
2nd+:++4.09120802879|3850533|entityMap^0|0|0|0|0|H|C|Y|B|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|12|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|14|8|@$M|15|N|16|O|P]|$M|17|N|18|O|P]]|9|@]|A|$]]|$1|Q|3|R|5|6|7|19|8|@]|9|@]|A|$]]|$1|S|3|T|5|D|7|1A|8|@]|9|@]|A|$E|F]]|$1|U|3|V|5|6|7|1B|8|@]|9|@]|A|$]]|$1|W|3|X|5|D|7|1C|8|@]|9|@]|A|$E|F]]|$1|Y|3|-4|5|6|7|1D|8|@]|9|@]|A|$]]]|Z|$]]

As a more general way you can use a recursion function and generator expression:

<pre><code>&gt;&gt;&gt; def count_keys(dict_test):
... return sum(1+count_keys(v) if isinstance(v,dict) else 1 for _,v in dict_test.iteritems())
... 
</code></pre>

Example:

<pre><code>&gt;&gt;&gt; dict_test = {'a': {'c': '2', 'b': '1', 'e': {'f': {1: {5: 'a'}}}, 'd': '3'}}
&gt;&gt;&gt; 
&gt;&gt;&gt; count(dict_test)
8
</code></pre>

Note: In python 3.X use <code>dict.items()</code> method instead of <code>iteritems()</code>.

A benchmark with accepted answer which shows that this function is faster than accepted answer:

<pre><code>from timeit import timeit

s1 = """
def sum_keys(d):
 return 0 if not isinstance(d, dict) else len(d) + sum(sum_keys(v) for v in d.itervalues())

sum_keys(dict_test)
"""

s2 = """
def count_keys(dict_test):
 return sum(1+count_keys(v) if isinstance(v,dict) else 1 for _,v in dict_test.iteritems())

count_keys(dict_test)
 """

print '1st: ', timeit(stmt=s1,
 number=1000000,
 setup="dict_test = {'a': {'c': '2', 'b': '1', 'e': {'f': {1: {5: 'a'}}}, 'd': '3'}}")
print '2nd : ', timeit(stmt=s2,
 number=1000000,
 setup="dict_test = {'a': {'c': '2', 'b': '1', 'e': {'f': {1: {5: 'a'}}}, 'd': '3'}}")
</code></pre>

result:

<pre><code>1st: 4.65556812286
2nd : 4.09120802879
</code></pre>

blocks|key|3764199|text|保持简单|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|3764200|如果我们知道所有的值都是字典，并且不希望检查它们的任何值是否也是字典，那么它就是这样简单的：|3764201|len(dict_test)+%2B+sum(len(v)+for+v+in+dict_test.itervalues())|code-block|syntax|javascript|3764202|对其进行一些改进，以便在计算值之前实际检查它们是否为字典：|3764203|len(dict_test)+%2B+sum(len(v)+for+v+in+dict_test.itervalues()+if+isinstance(v,+dict))|3764204|最后，如果您想做任意深度的操作，如下所示：|3764205|def+sum_keys(d):
++++return+(0+if+not+isinstance(d,+dict)+
++++++++++++else+len(d)+%2B+sum(sum_keys(v)+for+v+in+d.itervalues())

print+sum_keys({'key2':+{'key_in3':+'value',+'key_in4':+'value'},+
++++++++++++++++'key1':+{'key_in2':+'value',+
+++++++++++++++++++++++++'key_in1':+dict(a=2)}})
#+=>+7|3764206|在最后一个例子中，我们定义了一个将被递归调用的函数。给定一个值d，我们返回以下任一项：|CODE|3764207|如果该值不是字典，则为0；或|unordered-list-item|3764208|字典中的键数，加上我们所有孩子的键总数。|3764209|使它更快|3764210|以上是一种简洁易懂的方法。我们可以更快地使用生成器：|3764211|def+_counter(d):
++++#+how+many+keys+do+we+have?
++++yield+len(d)

++++#+stream+the+key+counts+of+our+children
++++for+v+in+d.itervalues():
++++++++if+isinstance(v,+dict):
++++++++++++for+x+in+_counter(v):
++++++++++++++++yield+x

def+count_faster(d):
++++return+sum(_counter(d))|3764212|这给我们带来了更多的性能：|3764213|In+[1]:+%25timeit+sum_keys(dict_test)
100000+loops,+best+of+3:+4.12+µs+per+loop

In+[2]:+%25timeit+count_faster(dict_test)
100000+loops,+best+of+3:+3.29+µs+per+loop|3764214|entityMap^0|0|4|0|0|0|0|0|0|0|V|1|0|B|1|0|0|0|4|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1E|8|@$9|1F|A|1G|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|1H|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|1I|8|@]|D|@]|E|$K|L]]|$1|M|3|N|5|6|7|1J|8|@]|D|@]|E|$]]|$1|O|3|P|5|J|7|1K|8|@]|D|@]|E|$K|L]]|$1|Q|3|R|5|6|7|1L|8|@]|D|@]|E|$]]|$1|S|3|T|5|J|7|1M|8|@]|D|@]|E|$K|L]]|$1|U|3|V|5|6|7|1N|8|@$9|1O|A|1P|B|W]]|D|@]|E|$]]|$1|X|3|Y|5|Z|7|1Q|8|@$9|1R|A|1S|B|W]]|D|@]|E|$]]|$1|10|3|11|5|Z|7|1T|8|@]|D|@]|E|$]]|$1|12|3|13|5|6|7|1U|8|@$9|1V|A|1W|B|C]]|D|@]|E|$]]|$1|14|3|15|5|6|7|1X|8|@]|D|@]|E|$]]|$1|16|3|17|5|J|7|1Y|8|@]|D|@]|E|$K|L]]|$1|18|3|19|5|6|7|1Z|8|@]|D|@]|E|$]]|$1|1A|3|1B|5|J|7|20|8|@]|D|@]|E|$K|L]]|$1|1C|3|-4|5|6|7|21|8|@]|D|@]|E|$]]]|1D|$]]

Keeping it Simple

If we know all the values are dictionaries, and do not wish to check that any of their values are also dictionaries, then it is as simple as:

<pre><code>len(dict_test) + sum(len(v) for v in dict_test.itervalues())
</code></pre>

Refining it a little, to actually check that the values are dictionaries before counting them:

<pre><code>len(dict_test) + sum(len(v) for v in dict_test.itervalues() if isinstance(v, dict))
</code></pre>

And finally, if you wish to do an arbitrary depth, something like the following:

<pre><code>def sum_keys(d):
 return (0 if not isinstance(d, dict) 
 else len(d) + sum(sum_keys(v) for v in d.itervalues())

print sum_keys({'key2': {'key_in3': 'value', 'key_in4': 'value'}, 
 'key1': {'key_in2': 'value', 
 'key_in1': dict(a=2)}})
# =&gt; 7
</code></pre>

In this last case, we define a function that will be called recursively. Given a value <code>d</code>, we return either:

<ul>
<li><code>0</code> if that value is not a dictionary; or</li>
<li>the number of keys in the dictionary, plus the total of keys in all of our children.</li>
</ul>

Making it Faster

The above is a succinct and easily understood approach. We can get a little faster using a generator:

<pre><code>def _counter(d):
 # how many keys do we have?
 yield len(d)

 # stream the key counts of our children
 for v in d.itervalues():
 if isinstance(v, dict):
 for x in _counter(v):
 yield x

def count_faster(d):
 return sum(_counter(d))
</code></pre>

This gets us a bit more performance:

<pre><code>In [1]: %timeit sum_keys(dict_test)
100000 loops, best of 3: 4.12 µs per loop

In [2]: %timeit count_faster(dict_test)
100000 loops, best of 3: 3.29 µs per loop
</code></pre>

blocks|key|766932|text|使用Python3.x中新的生成器函数和yield+from语法。这将适用于任意嵌套字典。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|766933|>>>+from+collections+import+Mapping
>>>+def+count_keys(mydict):
...+++++for+key,+value+in+mydict.items():
...+++++++++if+isinstance(value,+Mapping):
...+++++++++++++yield+from+count_keys(value)
...+++++yield+len(mydict)
...+
>>>+dict_test+=+{'key2':+{'key_in3':+'value',+'key_in4':+'value'},+'key1':+{'key_in2':+'value',+'key_in1':+'value'}}
>>>+sum(count_keys(dict_test))
6|code-block|syntax|javascript|766934|在Python2.x中，需要a来完成以下操作：|766935|>>>+def+count_keys(mydict):
...+++++for+key,+value+in+mydict.items():
...+++++++++if+isinstance(value,+Mapping):
...+++++++++++++for+item+in+count_keys(value):
...+++++++++++++++++yield+1
...+++++++++yield+1
...+
>>>+sum(count_keys(dict_test))
6|766936|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/3/whatsnew/3.3.html#pep-380-syntax-for-delegating-to-a-subgenerator^0|K|A|K|A|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@$9|Z|A|10|1|11]]|E|$]]|$1|F|3|G|5|H|7|12|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|13|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|14|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|15|8|@]|D|@]|E|$]]]|P|$Q|$5|R|S|T|E|$U|V]]]]

Using a generator function and the <a href="https://docs.python.org/3/whatsnew/3.3.html#pep-380-syntax-for-delegating-to-a-subgenerator" rel="nofollow"><code>yield from</code></a> syntax new in Python 3.x. This will work for an arbitrary nested dictionary

<pre><code>&gt;&gt;&gt; from collections import Mapping
&gt;&gt;&gt; def count_keys(mydict):
... for key, value in mydict.items():
... if isinstance(value, Mapping):
... yield from count_keys(value)
... yield len(mydict)
... 
&gt;&gt;&gt; dict_test = {'key2': {'key_in3': 'value', 'key_in4': 'value'}, 'key1': {'key_in2': 'value', 'key_in1': 'value'}}
&gt;&gt;&gt; sum(count_keys(dict_test))
6
</code></pre>

In Python 2.x you need a to do this:

<pre><code>&gt;&gt;&gt; def count_keys(mydict):
... for key, value in mydict.items():
... if isinstance(value, Mapping):
... for item in count_keys(value):
... yield 1
... yield 1
... 
&gt;&gt;&gt; sum(count_keys(dict_test))
6
</code></pre>

blocks|key|3850566|text|递归函数：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3850567|def+count_keys(some_dict):
++++count+=+0
++++for+key+in+some_dict:
++++++++if+isinstance(some_dict[key],+dict):
++++++++++++count+%2B=+count_keys(some_dict[key])
++++++++count+%2B=+1
++++return+count|code-block|syntax|javascript|3850568|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|$]]

recursive function:

<pre><code>def count_keys(some_dict):
 count = 0
 for key in some_dict:
 if isinstance(some_dict[key], dict):
 count += count_keys(some_dict[key])
 count += 1
 return count
</code></pre>

blocks|key|766945|text|len(dict)将返回字典中的键数，因此，假设您知道它是如何嵌套的，并且所有的值都是字典：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|766946|counter+=+len(outer_dict)
for+v+in+outer_dict.values+:
++++counter+%2B=+len(v)|code-block|syntax|javascript|766947|您可以将其包含在列表理解中：|766948|counter+=+len(outer_dict)
counter+%2B=+sum([len(inner_dict)+for+inner_dict+in+outer_dict.values])|766949|这可能是最重要的。您可以将其扩展为：|766950|counter+=+len(outer_dict)
counter+%2B=+sum([len(inner_dict)+if+isinstance(inner_dict,+dict)+else+0+for+inner_dict+in+outer_dict.values])|766951|但我倾向于认为这是相当不可读的。|766952|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|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

len(dict) will return the number of keys in a dictionary, so, assuming you know how nested it is and that all the values are dictionaries:

<pre><code>counter = len(outer_dict)
for v in outer_dict.values :
 counter += len(v)
</code></pre>

You can wrap this in a list comprehension :

<pre><code>counter = len(outer_dict)
counter += sum([len(inner_dict) for inner_dict in outer_dict.values])
</code></pre>

which is probably the most pythonic. You can extend it as :

<pre><code>counter = len(outer_dict)
counter += sum([len(inner_dict) if isinstance(inner_dict, dict) else 0 for inner_dict in outer_dict.values])
</code></pre>

but I tend to think that this is fairly unreadable.

blocks|key|3850610|text|下面是递归函数，用于查找嵌套字典的键总数.|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3850611|s=0
def+recurse(v):
+++if+type(v)==type({}):
+++++for+k+in+v.keys():
++++++global+s
++++++s%2B=1
++++++recurse(v[k])|code-block|syntax|javascript|3850612|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|$]]

Here is the recursive function to find the nested dictionaries' total number of keys...

<pre><code>s=0
def recurse(v):
 if type(v)==type({}):
 for k in v.keys():
 global s
 s+=1
 recurse(v[k])
</code></pre>

I have a dictionary of dictionaries in Python 2.7.

I need to quickly count the number of all keys, including the keys within each of the dictionaries.

So in this example I would need the number of all keys to be 6:

<pre><code>dict_test = {'key2': {'key_in3': 'value', 'key_in4': 'value'}, 'key1': {'key_in2': 'value', 'key_in1': 'value'}}
</code></pre>

I know I can iterate through each key with for loops, but I am looking for a quicker way to do this, since I will have thousands/millions of keys and doing this is just ineffective:

<pre><code>count_the_keys = 0

for key in dict_test.keys():
 for key_inner in dict_test[key].keys():
 count_the_keys += 1

# something like this would be more effective
# of course .keys().keys() doesn't work
print len(dict_test.keys()) * len(dict_test.keys().keys())
</code></pre>

Get the number of all keys in a dictionary of dictionaries in Python

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

我有一本Python2.7的字典。我需要快速计算所有键的数量，包括每个字典中的键。因此，在这个例子中，我需要所有键的数目为6：dict_test = {'key2': {'key_in3': 'value', 'key_in4': 'value'}, 'key1': {'key_in2': 'value', 'key_...

问获取Python字典中所有键的数目。
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问获取Python字典中所有键的数目。EN