entityMap|blocks|key|9hi4n|text|试试这个：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|eo78j|inv_map+=+dict(zip(my_map.values(),+my_map.keys()))|code-block|syntax|javascript|4pph|(请注意|4aker|字典视图上的Python文档|29rr3|明确保证|6gk9i|和|5pb5|使它们的元素具有相同的顺序，这使得上面的方法可以工作。)|7r56o|或者：|fg281|inv_map+=+dict((my_map[k],+k)+for+k+in+my_map)|cgrdf|或者使用python3.0的dict解释|ft5qi|inv_map+=+{my_map[k]+:+k+for+k+in+my_map}^0|0|0|0|0|0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|Z|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|10|9|@]|A|@]|B|$F|G]]|$2|H|4|I|6|7|8|11|9|@]|A|@]|B|$]]|$2|J|4|K|6|7|8|12|9|@]|A|@]|B|$]]|$2|L|4|M|6|7|8|13|9|@]|A|@]|B|$]]|$2|N|4|O|6|7|8|14|9|@]|A|@]|B|$]]|$2|P|4|Q|6|7|8|15|9|@]|A|@]|B|$]]|$2|R|4|S|6|7|8|16|9|@]|A|@]|B|$]]|$2|T|4|U|6|E|8|17|9|@]|A|@]|B|$F|G]]|$2|V|4|W|6|7|8|18|9|@]|A|@]|B|$]]|$2|X|4|Y|6|E|8|19|9|@]|A|@]|B|$F|G]]]]

Try this:

<pre><code>inv_map = dict(zip(my_map.values(), my_map.keys()))
</code></pre>

(Note that <a href="https://docs.python.org/library/stdtypes.html#dictionary-view-objects" rel="noreferrer">the Python docs on dictionary views</a> explicitly guarantee that <code>.keys()</code> and <code>.values()</code> have their elements in the same order, which allows the approach above to work.)

Alternatively:

<pre><code>inv_map = dict((my_map[k], k) for k in my_map)
</code></pre>

or using python 3.0's dict comprehensions

<pre><code>inv_map = {my_map[k] : k for k in my_map}
</code></pre>

entityMap|blocks|key|8v127|text|Python+3%2B：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|aq9gf|inv_map+=+{v:+k+for+k,+v+in+my_map.items()}|code-block|syntax|javascript|77hb4|Python+2：|bh8bs|inv_map+=+{v:+k+for+k,+v+in+my_map.iteritems()}^0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|L|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|M|9|@]|A|@]|B|$F|G]]|$2|H|4|I|6|7|8|N|9|@]|A|@]|B|$]]|$2|J|4|K|6|E|8|O|9|@]|A|@]|B|$F|G]]]]

Python 3+:
<pre><code>inv_map = {v: k for k, v in my_map.items()}
</code></pre>
Python 2:
<pre><code>inv_map = {v: k for k, v in my_map.iteritems()}
</code></pre>

entityMap|blocks|key|d49mr|text|假设dict中的值是唯一的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|11f3m|dict((v,+k)+for+k,+v+in+my_map.iteritems())|code-block|syntax|javascript^0|0^^$0|$]|1|@$2|3|4|5|6|7|8|H|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|I|9|@]|A|@]|B|$F|G]]]]

Assuming that the values in the dict are unique:

<pre><code>dict((v, k) for k, v in my_map.iteritems())
</code></pre>

entityMap|blocks|key|eopiu|text|中的值|type|unstyled|depth|inlineStyleRanges|entityRanges|data|39vgo|并不是唯一的：|4dro6|inv_map+=+{}
for+k,+v+in+my_map.iteritems():
++++inv_map[v]+=+inv_map.get(v,+[])+%2B+[k]|code-block|syntax|javascript^0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|J|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|K|9|@]|A|@]|B|$]]|$2|E|4|F|6|G|8|L|9|@]|A|@]|B|$H|I]]]]

If the values in <code>my_map</code> aren't unique:
<pre><code>inv_map = {}
for k, v in my_map.iteritems():
 inv_map[v] = inv_map.get(v, []) + [k]
</code></pre>

entityMap|blocks|key|1973v|text|要在保留映射类型的同时执行此操作(假设它是一个|type|unstyled|depth|inlineStyleRanges|entityRanges|data|8l53h|或者|egn17|子类)：|31abs|def+inverse_mapping(f):
++++return+f.__class__(map(reversed,+f.items()))|code-block|syntax|javascript^0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|L|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|M|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|N|9|@]|A|@]|B|$]]|$2|G|4|H|6|I|8|O|9|@]|A|@]|B|$J|K]]]]

To do this while preserving the type of your mapping (assuming that it is a <code>dict</code> or a <code>dict</code> subclass):

<pre><code>def inverse_mapping(f):
 return f.__class__(map(reversed, f.items()))
</code></pre>

entityMap|blocks|key|6n08c|text|如果值不是唯一的，而且你有点铁杆：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|9c7d2|inv_map+=+dict(
++++(v,+[k+for+(k,+xx)+in+filter(lambda+(key,+value):+value+==+v,+my_map.items())])+
++++for+v+in+set(my_map.values())
)|code-block|syntax|javascript|4dian|特别是对于大型字典，请注意这种解决方案的效率远远低于答案|mpj0|Python反转/反转映射|7arso|因为它循环|7jf0r|很多次。^0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|P|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|Q|9|@]|A|@]|B|$F|G]]|$2|H|4|I|6|7|8|R|9|@]|A|@]|B|$]]|$2|J|4|K|6|7|8|S|9|@]|A|@]|B|$]]|$2|L|4|M|6|7|8|T|9|@]|A|@]|B|$]]|$2|N|4|O|6|7|8|U|9|@]|A|@]|B|$]]]]

If the values aren't unique, and you're a little hardcore:

<pre><code>inv_map = dict(
 (v, [k for (k, xx) in filter(lambda (key, value): value == v, my_map.items())]) 
 for v in set(my_map.values())
)
</code></pre>

Especially for a large dict, note that this solution is far less efficient than the answer <a href="https://stackoverflow.com/questions/483666/python-reverse-inverse-a-mapping/485368#485368">Python reverse / invert a mapping</a> because it loops over <code>items()</code> multiple times.

entityMap|blocks|key|il3o|text|这是在答案的基础上展开的|type|unstyled|depth|inlineStyleRanges|entityRanges|data|igd7|作者:+Robert|9hm4f|，适用于当dict中的值不是唯一的时候。|cnh81|class+ReversibleDict(dict):

++++def+reversed(self):
++++++++"""
++++++++Return+a+reversed+dict,+with+common+values+in+the+original+dict
++++++++grouped+into+a+list+in+the+returned+dict.

++++++++Example:
++++++++>>>+d+=+ReversibleDict({'a':+3,+'c':+2,+'b':+2,+'e':+3,+'d':+1,+'f':+2})
++++++++>>>+d.reversed()
++++++++{1:+['d'],+2:+['c',+'b',+'f'],+3:+['a',+'e']}
++++++++"""

++++++++revdict+=+{}
++++++++for+k,+v+in+self.iteritems():
++++++++++++revdict.setdefault(v,+[]).append(k)
++++++++return+revdict|code-block|syntax|javascript|a1345|该实现受到限制，因为您不能使用|c35oq|两次，然后拿回原件。它本身并不是对称的。它使用Python+2.6进行了测试。|8s96c|这里|47ogu|是我如何用来打印结果字典的用例。|18f2p|如果您更愿意使用|bkr0v|而不是|4itet|，并且可能存在这样做有意义的无序应用程序，而不是|9v6p2|，使用|ah6ji|..。^0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|13|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|14|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|15|9|@]|A|@]|B|$]]|$2|G|4|H|6|I|8|16|9|@]|A|@]|B|$J|K]]|$2|L|4|M|6|7|8|17|9|@]|A|@]|B|$]]|$2|N|4|O|6|7|8|18|9|@]|A|@]|B|$]]|$2|P|4|Q|6|7|8|19|9|@]|A|@]|B|$]]|$2|R|4|S|6|7|8|1A|9|@]|A|@]|B|$]]|$2|T|4|U|6|7|8|1B|9|@]|A|@]|B|$]]|$2|V|4|W|6|7|8|1C|9|@]|A|@]|B|$]]|$2|X|4|Y|6|7|8|1D|9|@]|A|@]|B|$]]|$2|Z|4|10|6|7|8|1E|9|@]|A|@]|B|$]]|$2|11|4|12|6|7|8|1F|9|@]|A|@]|B|$]]]]

This expands upon the answer <a href="https://stackoverflow.com/a/485368/">by Robert</a>, applying to when the values in the dict aren't unique.

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

 def reversed(self):
 """
 Return a reversed dict, with common values in the original dict
 grouped into a list in the returned dict.

 Example:
 &gt;&gt;&gt; d = ReversibleDict({'a': 3, 'c': 2, 'b': 2, 'e': 3, 'd': 1, 'f': 2})
 &gt;&gt;&gt; d.reversed()
 {1: ['d'], 2: ['c', 'b', 'f'], 3: ['a', 'e']}
 """

 revdict = {}
 for k, v in self.iteritems():
 revdict.setdefault(v, []).append(k)
 return revdict
</code></pre>

The implementation is limited in that you cannot use <code>reversed</code> twice and get the original back. It is not symmetric as such. It is tested with Python 2.6. <a href="https://pastebin.com/vMf7tNA5" rel="noreferrer">Here</a> is a use case of how I am using to print the resultant dict.

If you'd rather use a <code>set</code> than a <code>list</code>, and there could exist unordered applications for which this makes sense, instead of <code>setdefault(v, []).append(k)</code>, use <code>setdefault(v, set()).add(k)</code>.

entityMap|blocks|key|feorj|text|除了上面建议的其他函数之外，如果您喜欢lambdas：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|38vbe|invert+=+lambda+mydict:+{v:k+for+k,+v+in+mydict.items()}|code-block|syntax|javascript|2a36m|或者，你也可以这样做：|21b94|invert+=+lambda+mydict:+dict(+zip(mydict.values(),+mydict.keys())+)^0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|L|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|M|9|@]|A|@]|B|$F|G]]|$2|H|4|I|6|7|8|N|9|@]|A|@]|B|$]]|$2|J|4|K|6|E|8|O|9|@]|A|@]|B|$F|G]]]]

In addition to the other functions suggested above, if you like lambdas:

<pre class="lang-py prettyprint-override"><code>invert = lambda mydict: {v:k for k, v in mydict.items()}
</code></pre>

Or, you could do it this way too:

<pre class="lang-py prettyprint-override"><code>invert = lambda mydict: dict( zip(mydict.values(), mydict.keys()) )
</code></pre>

entityMap|blocks|key|4qieq|text|另一种更实用的方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|c49en|my_map+=+{+'a':+1,+'b':2+}
dict(map(reversed,+my_map.items()))|code-block|syntax|javascript^0|0^^$0|$]|1|@$2|3|4|5|6|7|8|H|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|I|9|@]|A|@]|B|$F|G]]]]

Another, more functional, way:

<pre><code>my_map = { 'a': 1, 'b':2 }
dict(map(reversed, my_map.items()))
</code></pre>

entityMap|blocks|key|fsfbj|text|非双射映射的快速函数解决方案(值不唯一)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1vkke|from+itertools+import+imap,+groupby

def+fst(s):
++++return+s[0]

def+snd(s):
++++return+s[1]

def+inverseDict(d):
++++"""
++++input+d:+a+->+b
++++output+:+b+->+set(a)
++++"""
++++return+{
++++++++v+:+set(imap(fst,+kv_iter))
++++++++for+(v,+kv_iter)+in+groupby(
++++++++++++sorted(d.iteritems(),
+++++++++++++++++++key=snd),
++++++++++++key=snd
++++++++)
++++}|code-block|syntax|javascript|ced9r|从理论上讲，这应该比逐个添加到集合(或追加到列表)要快，就像在|256es|命令式解决方案|2l8hk|..。|15tn8|不幸的是，值必须是可排序的，排序是groupby所要求的。^0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|P|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|Q|9|@]|A|@]|B|$F|G]]|$2|H|4|I|6|7|8|R|9|@]|A|@]|B|$]]|$2|J|4|K|6|7|8|S|9|@]|A|@]|B|$]]|$2|L|4|M|6|7|8|T|9|@]|A|@]|B|$]]|$2|N|4|O|6|7|8|U|9|@]|A|@]|B|$]]]]

Fast functional solution for non-bijective maps (values not unique):

<pre><code>from itertools import imap, groupby

def fst(s):
 return s[0]

def snd(s):
 return s[1]

def inverseDict(d):
 """
 input d: a -&gt; b
 output : b -&gt; set(a)
 """
 return {
 v : set(imap(fst, kv_iter))
 for (v, kv_iter) in groupby(
 sorted(d.iteritems(),
 key=snd),
 key=snd
 )
 }
</code></pre>

In theory this should be faster than adding to the set (or appending to the list) one by one like in the <a href="https://stackoverflow.com/a/485368/711694">imperative solution</a>.

Unfortunately the values have to be sortable, the sorting is required by groupby.

entityMap|blocks|key|b21g9|text|在python+2.7/3.x上试试这个|type|unstyled|depth|inlineStyleRanges|entityRanges|data|9o5mo|inv_map={};
for+i+in+my_map:
++++inv_map[my_map[i]]=i++++
print+inv_map|code-block|syntax|javascript^0|0^^$0|$]|1|@$2|3|4|5|6|7|8|H|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|I|9|@]|A|@]|B|$F|G]]]]

Try this for python 2.7/3.x

<pre><code>inv_map={};
for i in my_map:
 inv_map[my_map[i]]=i 
print inv_map
</code></pre>

entityMap|blocks|key|ca59p|text|函数对于list类型的值是对称的；执行反向操作时，元组将转换为list|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4l7hr|_|b62e4|字典(反转|c7bo8|lp8e|字典(字典))|at2lu|def+reverse_dict(dictionary):
++++reverse_dict+=+{}
++++for+key,+value+in+dictionary.iteritems():
++++++++if+not+isinstance(value,+(list,+tuple)):
++++++++++++value+=+[value]
++++++++for+val+in+value:
++++++++++++reverse_dict[val]+=+reverse_dict.get(val,+[])
++++++++++++reverse_dict[val].append(key)
++++for+key,+value+in+reverse_dict.iteritems():
++++++++if+len(value)+==+1:
++++++++++++reverse_dict[key]+=+value[0]
++++return+reverse_dict|code-block|syntax|javascript^0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|O|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|P|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|Q|9|@]|A|@]|B|$]]|$2|G|4|D|6|7|8|R|9|@]|A|@]|B|$]]|$2|H|4|I|6|7|8|S|9|@]|A|@]|B|$]]|$2|J|4|K|6|L|8|T|9|@]|A|@]|B|$M|N]]]]

Function is symmetric for values of type list; Tuples are coverted to lists when performing reverse_dict(reverse_dict(dictionary))

<pre><code>def reverse_dict(dictionary):
 reverse_dict = {}
 for key, value in dictionary.iteritems():
 if not isinstance(value, (list, tuple)):
 value = [value]
 for val in value:
 reverse_dict[val] = reverse_dict.get(val, [])
 reverse_dict[val].append(key)
 for key, value in reverse_dict.iteritems():
 if len(value) == 1:
 reverse_dict[key] = value[0]
 return reverse_dict
</code></pre>

entityMap|blocks|key|1375f|text|我认为最好的方法是定义一个类。下面是一个“对称字典”的实现：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|eg4vf|class+SymDict:
++++def+__init__(self):
++++++++self.aToB+=+{}
++++++++self.bToA+=+{}

++++def+assocAB(self,+a,+b):
++++++++#+Stores+and+returns+a+tuple+(a,b)+of+overwritten+bindings
++++++++currB+=+None
++++++++if+a+in+self.aToB:+currB+=+self.bToA[a]
++++++++currA+=+None
++++++++if+b+in+self.bToA:+currA+=+self.aToB[b]

++++++++self.aToB[a]+=+b
++++++++self.bToA[b]+=+a
++++++++return+(currA,+currB)

++++def+lookupA(self,+a):
++++++++if+a+in+self.aToB:
++++++++++++return+self.aToB[a]
++++++++return+None

++++def+lookupB(self,+b):
++++++++if+b+in+self.bToA:
++++++++++++return+self.bToA[b]
++++++++return+None|code-block|syntax|javascript|8hbrl|如果需要，删除和迭代方法很容易实现。|1nkah|这种实现比倒排整个字典(这似乎是这个页面上最流行的解决方案)的效率要高得多。更不用说，您可以根据需要在SymDict中添加或删除值，并且您的反向字典将始终有效--如果您只对整个字典进行一次反向操作，情况就不是这样了。^0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|L|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|M|9|@]|A|@]|B|$F|G]]|$2|H|4|I|6|7|8|N|9|@]|A|@]|B|$]]|$2|J|4|K|6|7|8|O|9|@]|A|@]|B|$]]]]

I think the best way to do this is to define a class. Here is an implementation of a "symmetric dictionary":

<pre><code>class SymDict:
 def __init__(self):
 self.aToB = {}
 self.bToA = {}

 def assocAB(self, a, b):
 # Stores and returns a tuple (a,b) of overwritten bindings
 currB = None
 if a in self.aToB: currB = self.bToA[a]
 currA = None
 if b in self.bToA: currA = self.aToB[b]

 self.aToB[a] = b
 self.bToA[b] = a
 return (currA, currB)

 def lookupA(self, a):
 if a in self.aToB:
 return self.aToB[a]
 return None

 def lookupB(self, b):
 if b in self.bToA:
 return self.bToA[b]
 return None
</code></pre>

Deletion and iteration methods are easy enough to implement if they're needed.

This implementation is way more efficient than inverting an entire dictionary (which seems to be the most popular solution on this page). Not to mention, you can add or remove values from your SymDict as much as you want, and your inverse-dictionary will always stay valid -- this isn't true if you simply reverse the entire dictionary once.

entityMap|blocks|key|sd25|text|因为与值不同，字典需要字典中的一个唯一键，所以我们必须将反转的值附加到排序列表中，以包括在新的特定键中。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|bn89d|def+r_maping(dictionary):
++++List_z=[]
++++Map=+{}
++++for+z,+x+in+dictionary.iteritems():+#iterate+through+the+keys+and+values
++++++++Map.setdefault(x,List_z).append(z)+#Setdefault+is+the+same+as+dict[key]=default."The+method+returns+the+key+value+available+in+the+dictionary+and+if+given+key+is+not+available+then+it+will+return+provided+default+value.+Afterward,+we+will+append+into+the+default+list+our+new+values+for+the+specific+key.
++++return+Map|code-block|syntax|javascript^0|0^^$0|$]|1|@$2|3|4|5|6|7|8|H|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|I|9|@]|A|@]|B|$F|G]]]]

Since dictionaries require one unique key within the dictionary unlike values, we have to append the reversed values into a list of sort to be included within the new specific keys. 

<pre><code>def r_maping(dictionary):
 List_z=[]
 Map= {}
 for z, x in dictionary.iteritems(): #iterate through the keys and values
 Map.setdefault(x,List_z).append(z) #Setdefault is the same as dict[key]=default."The method returns the key value available in the dictionary and if given key is not available then it will return provided default value. Afterward, we will append into the default list our new values for the specific key.
 return Map
</code></pre>

entityMap|blocks|key|1babg|text|不是完全不同的东西，只是从Cookbook中重写了一点食谱。它通过保留来进一步优化|type|unstyled|depth|inlineStyleRanges|entityRanges|data|9klm1|方法，而不是每次都通过实例获取它：|7se0j|def+inverse(mapping):
++++'''
++++A+function+to+inverse+mapping,+collecting+keys+with+simillar+values
++++in+list.+Careful+to+retain+original+type+and+to+be+fast.
++++>>+d+=+dict(a=1,+b=2,+c=1,+d=3,+e=2,+f=1,+g=5,+h=2)
++++>>+inverse(d)
++++{1:+['f',+'c',+'a'],+2:+['h',+'b',+'e'],+3:+['d'],+5:+['g']}
++++'''
++++res+=+{}
++++setdef+=+res.setdefault
++++for+key,+value+in+mapping.items():
++++++++setdef(value,+[]).append(key)
++++return+res+if+mapping.__class__==dict+else+mapping.__class__(res)|code-block|syntax|javascript|6cd4t|设计为在CPython+3.x下运行，用于2.x替换|6ltt1|使用|37krd|在我的机器上运行得比这里的其他示例快一点^0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|P|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|Q|9|@]|A|@]|B|$]]|$2|E|4|F|6|G|8|R|9|@]|A|@]|B|$H|I]]|$2|J|4|K|6|7|8|S|9|@]|A|@]|B|$]]|$2|L|4|M|6|7|8|T|9|@]|A|@]|B|$]]|$2|N|4|O|6|7|8|U|9|@]|A|@]|B|$]]]]

Not something completely different, just a bit rewritten recipe from Cookbook. It's futhermore optimized by retaining <code>setdefault</code> method, instead of each time getting it through the instance:

<pre><code>def inverse(mapping):
 '''
 A function to inverse mapping, collecting keys with simillar values
 in list. Careful to retain original type and to be fast.
 &gt;&gt; d = dict(a=1, b=2, c=1, d=3, e=2, f=1, g=5, h=2)
 &gt;&gt; inverse(d)
 {1: ['f', 'c', 'a'], 2: ['h', 'b', 'e'], 3: ['d'], 5: ['g']}
 '''
 res = {}
 setdef = res.setdefault
 for key, value in mapping.items():
 setdef(value, []).append(key)
 return res if mapping.__class__==dict else mapping.__class__(res)
</code></pre>

Designed to be run under CPython 3.x, for 2.x replace <code>mapping.items()</code> with <code>mapping.iteritems()</code>

On my machine runs a bit faster, than other examples here

entityMap|blocks|key|bg48u|text|我在循环'for‘和方法'.get()’的帮助下编写了这段代码，并将字典的名称'map‘改为'map1’，因为'map‘是一个函数。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|l65k|def+dict_invert(map1):
++++inv_map+=+{}+#+new+dictionary
++++for+key+in+map1.keys():
++++++++inv_map[map1.get(key)]+=+key
++++return+inv_map|code-block|syntax|javascript^0|0^^$0|$]|1|@$2|3|4|5|6|7|8|H|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|I|9|@]|A|@]|B|$F|G]]]]

I wrote this with the help of cycle 'for' and method '.get()' and I changed the name 'map' of the dictionary to 'map1' because 'map' is a function.

<pre><code>def dict_invert(map1):
 inv_map = {} # new dictionary
 for key in map1.keys():
 inv_map[map1.get(key)] = key
 return inv_map
</code></pre>

entityMap|blocks|key|ast6v|text|我们还可以使用以下命令反转具有重复键的字典|type|unstyled|depth|inlineStyleRanges|entityRanges|data|21pdi|from+collections+import+Counter,+defaultdict

def+invert_dict(d):
++++d_inv+=+defaultdict(list)
++++for+k,+v+in+d.items():
++++++++d_inv[v].append(k)
++++return+d_inv

text+=+'aaa+bbb+ccc+ddd+aaa+bbb+ccc+aaa'+
c+=+Counter(text.split())+#+Counter({'aaa':+3,+'bbb':+2,+'ccc':+2,+'ddd':+1})
dict(invert_dict(c))+#+{1:+['ddd'],+2:+['bbb',+'ccc'],+3:+['aaa']}|code-block|syntax|javascript|loa9|请参见|5t0tj|这里|bvd93|这种技术比使用|294gp|..。^0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|P|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|Q|9|@]|A|@]|B|$F|G]]|$2|H|4|I|6|7|8|R|9|@]|A|@]|B|$]]|$2|J|4|K|6|7|8|S|9|@]|A|@]|B|$]]|$2|L|4|M|6|7|8|T|9|@]|A|@]|B|$]]|$2|N|4|O|6|7|8|U|9|@]|A|@]|B|$]]]]

We can also reverse a dictionary with duplicate keys using <code>defaultdict</code>:

<pre><code>from collections import Counter, defaultdict

def invert_dict(d):
 d_inv = defaultdict(list)
 for k, v in d.items():
 d_inv[v].append(k)
 return d_inv

text = 'aaa bbb ccc ddd aaa bbb ccc aaa' 
c = Counter(text.split()) # Counter({'aaa': 3, 'bbb': 2, 'ccc': 2, 'ddd': 1})
dict(invert_dict(c)) # {1: ['ddd'], 2: ['bbb', 'ccc'], 3: ['aaa']} 
</code></pre>

See <a href="https://docs.python.org/3/library/collections.html#collections.defaultdict" rel="noreferrer">here</a>:

<blockquote>
 This technique is simpler and faster than an equivalent technique using <code>dict.setdefault()</code>.
</blockquote>

entityMap|blocks|key|6758l|text|如果值不是唯一的，并且可能是散列(一维)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1tb4s|for+k,+v+in+myDict.items():
++++if+len(v)+>+1:
++++++++for+item+in+v:
++++++++++++invDict[item]+=+invDict.get(item,+[])
++++++++++++invDict[item].append(k)
++++else:
++++++++invDict[v]+=+invDict.get(v,+[])
++++++++invDict[v].append(k)|code-block|syntax|javascript|4cm29|对于递归，如果你需要挖掘更深的维度，只需要一个维度：|54f8g|def+digList(lst):
++++temp+=+[]
++++for+item+in+lst:
++++++++if+type(item)+is+list:
++++++++++++temp.append(digList(item))
++++++++else:
++++++++++++temp.append(item)
++++return+set(temp)

for+k,+v+in+myDict.items():
++++if+type(v)+is+list:
++++++++items+=+digList(v)
++++++++for+item+in+items:
++++++++++++invDict[item]+=+invDict.get(item,+[])
++++++++++++invDict[item].append(k)
++++else:
++++++++invDict[v]+=+invDict.get(v,+[])
++++++++invDict[v].append(k)^0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|L|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|M|9|@]|A|@]|B|$F|G]]|$2|H|4|I|6|7|8|N|9|@]|A|@]|B|$]]|$2|J|4|K|6|E|8|O|9|@]|A|@]|B|$F|G]]]]

If values aren't unique AND may be a hash (one dimension):

<pre><code>for k, v in myDict.items():
 if len(v) &gt; 1:
 for item in v:
 invDict[item] = invDict.get(item, [])
 invDict[item].append(k)
 else:
 invDict[v] = invDict.get(v, [])
 invDict[v].append(k)
</code></pre>

And with a recursion if you need to dig deeper then just one dimension:

<pre><code>def digList(lst):
 temp = []
 for item in lst:
 if type(item) is list:
 temp.append(digList(item))
 else:
 temp.append(item)
 return set(temp)

for k, v in myDict.items():
 if type(v) is list:
 items = digList(v)
 for item in items:
 invDict[item] = invDict.get(item, [])
 invDict[item].append(k)
 else:
 invDict[v] = invDict.get(v, [])
 invDict[v].append(k)
</code></pre>

entityMap|blocks|key|18u0m|text|这将处理非唯一的值，并保留唯一实例的大部分外观。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|14loh|inv_map+=+{v:[k+for+k+in+my_map+if+my_map[k]+==+v]+for+v+in+my_map.itervalues()}|code-block|syntax|javascript|54hj4|对于Python+3.x，请替换|3u8j9|使用|79is|..。^0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|N|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|O|9|@]|A|@]|B|$F|G]]|$2|H|4|I|6|7|8|P|9|@]|A|@]|B|$]]|$2|J|4|K|6|7|8|Q|9|@]|A|@]|B|$]]|$2|L|4|M|6|7|8|R|9|@]|A|@]|B|$]]]]

This handles non-unique values and retains much of the look of the unique case. 

<pre><code>inv_map = {v:[k for k in my_map if my_map[k] == v] for v in my_map.itervalues()}
</code></pre>

For Python 3.x, replace <code>itervalues</code> with <code>values</code>.

entityMap|blocks|key|4b05u|text|在python+2中，我会这样做。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|81r0k|inv_map+=+{my_map[x]+:+x+for+x+in+my_map}|code-block|syntax|javascript^0|0^^$0|$]|1|@$2|3|4|5|6|7|8|H|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|I|9|@]|A|@]|B|$F|G]]]]

I would do it that way in python 2.

<pre><code>inv_map = {my_map[x] : x for x in my_map}
</code></pre>

entityMap|blocks|key|2t2ki|text|def+invertDictionary(d):
++++myDict+=+{}
++for+i+in+d:
+++++value+=+d.get(i)
+++++myDict.setdefault(value,[]).append(i)+++
+return+myDict
+print+invertDictionary({'a':1,+'b':2,+'c':3+,+'d'+:+1})|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|g64e|这将提供如下输出：{1：|unstyled|266af|'a'，'d‘|bm6c3|，2：|b30a4|“b”|44qfk|，3：|371ga|'c‘|90ice|}^0|0|0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|T|9|@]|A|@]|B|$C|D]]|$2|E|4|F|6|G|8|U|9|@]|A|@]|B|$]]|$2|H|4|I|6|G|8|V|9|@]|A|@]|B|$]]|$2|J|4|K|6|G|8|W|9|@]|A|@]|B|$]]|$2|L|4|M|6|G|8|X|9|@]|A|@]|B|$]]|$2|N|4|O|6|G|8|Y|9|@]|A|@]|B|$]]|$2|P|4|Q|6|G|8|Z|9|@]|A|@]|B|$]]|$2|R|4|S|6|G|8|10|9|@]|A|@]|B|$]]]]

<pre><code>def invertDictionary(d):
 myDict = {}
 for i in d:
 value = d.get(i)
 myDict.setdefault(value,[]).append(i) 
 return myDict
 print invertDictionary({'a':1, 'b':2, 'c':3 , 'd' : 1})
</code></pre>

This will provide output as : {1: ['a', 'd'], 2: ['b'], 3: ['c']}

entityMap|blocks|key|b66cf|text|def+reverse_dictionary(input_dict):
++++++out+=+{}
++++++for+v+in+input_dict.values():++
++++++++++for+value+in+v:
++++++++++++++if+value+not+in+out:
++++++++++++++++++out[value.lower()]+=+[]

++++++for+i+in+input_dict:
++++++++++for+j+in+out:
++++++++++++++if+j+in+map+(lambda+x+:+x.lower(),input_dict[i]):
++++++++++++++++++out[j].append(i.lower())
++++++++++++++++++out[j].sort()
++++++return+out|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|4jetb|此代码如下所示：|unstyled|6psog|r+=+reverse_dictionary({'Accurate':+['exact',+'precise'],+'exact':+['precise'],+'astute':+['Smart',+'clever'],+'smart':+['clever',+'bright',+'talented']})

print(r)

{'precise':+['accurate',+'exact'],+'clever':+['astute',+'smart'],+'talented':+['smart'],+'bright':+['smart'],+'exact':+['accurate'],+'smart':+['astute']}^0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|J|9|@]|A|@]|B|$C|D]]|$2|E|4|F|6|G|8|K|9|@]|A|@]|B|$]]|$2|H|4|I|6|7|8|L|9|@]|A|@]|B|$C|D]]]]

<pre><code> def reverse_dictionary(input_dict):
 out = {}
 for v in input_dict.values(): 
 for value in v:
 if value not in out:
 out[value.lower()] = []

 for i in input_dict:
 for j in out:
 if j in map (lambda x : x.lower(),input_dict[i]):
 out[j].append(i.lower())
 out[j].sort()
 return out
</code></pre>

this code do like this:

<pre><code>r = reverse_dictionary({'Accurate': ['exact', 'precise'], 'exact': ['precise'], 'astute': ['Smart', 'clever'], 'smart': ['clever', 'bright', 'talented']})

print(r)

{'precise': ['accurate', 'exact'], 'clever': ['astute', 'smart'], 'talented': ['smart'], 'bright': ['smart'], 'exact': ['accurate'], 'smart': ['astute']}
</code></pre>

entityMap|blocks|key|2bj2c|text|列表和字典理解的组合。可以处理重复的键|type|unstyled|depth|inlineStyleRanges|entityRanges|data|as588|{v:[i+for+i+in+d.keys()+if+d[i]+==+v+]+for+k,v+in+d.items()}|code-block|syntax|javascript^0|0^^$0|$]|1|@$2|3|4|5|6|7|8|H|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|I|9|@]|A|@]|B|$F|G]]]]

Combination of list and dictionary comprehension. Can handle duplicate keys

<pre><code>{v:[i for i in d.keys() if d[i] == v ] for k,v in d.items()}
</code></pre>

entityMap|blocks|key|3e3mg|text|例如，您有以下字典：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|ut3d|dict+=+{'a':+'fire',+'b':+'ice',+'c':+'fire',+'d':+'water'}|code-block|syntax|javascript|3vo9n|你想让它以这样一种倒置的形式出现：|2099g|inverted_dict+=+{'fire':+['a',+'c'],+'ice':+['b'],+'water':+['d']}|5at0q|第一个解决方案|ehfqf|..。用于反转|b9lgo|键值|44lv0|字典中的对使用|14ija|-loop方法：|3v3je|#+Use+this+code+to+invert+dictionaries+that+have+non-unique+values

inverted_dict+=+dict()
for+key,+value+in+dict.items():
++++inverted_dict.setdefault(value,+list()).append(key)|26tnh|第二种解决方案|806ag|..。使用|bk4a9|词典理解|2vrhq|倒置方法：|dp9o8|#+Use+this+code+to+invert+dictionaries+that+have+unique+values

inverted_dict+=+{value:+key+for+key,+value+in+dict.items()}|4qaa9|第三种解决方案|2nfen|4ub3c|反转|8irsp|方法(依赖于第二种解决方案)：|c956f|#+Use+this+code+to+invert+dictionaries+that+have+lists+of+values

dict+=+{value:+key+for+key+in+inverted_dict+for+value+in+my_map[key]}^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|1G|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|1H|9|@]|A|@]|B|$F|G]]|$2|H|4|I|6|7|8|1I|9|@]|A|@]|B|$]]|$2|J|4|K|6|E|8|1J|9|@]|A|@]|B|$F|G]]|$2|L|4|M|6|7|8|1K|9|@]|A|@]|B|$]]|$2|N|4|O|6|7|8|1L|9|@]|A|@]|B|$]]|$2|P|4|Q|6|7|8|1M|9|@]|A|@]|B|$]]|$2|R|4|S|6|7|8|1N|9|@]|A|@]|B|$]]|$2|T|4|U|6|7|8|1O|9|@]|A|@]|B|$]]|$2|V|4|W|6|E|8|1P|9|@]|A|@]|B|$F|G]]|$2|X|4|Y|6|7|8|1Q|9|@]|A|@]|B|$]]|$2|Z|4|10|6|7|8|1R|9|@]|A|@]|B|$]]|$2|11|4|12|6|7|8|1S|9|@]|A|@]|B|$]]|$2|13|4|14|6|7|8|1T|9|@]|A|@]|B|$]]|$2|15|4|16|6|E|8|1U|9|@]|A|@]|B|$F|G]]|$2|17|4|18|6|7|8|1V|9|@]|A|@]|B|$]]|$2|19|4|10|6|7|8|1W|9|@]|A|@]|B|$]]|$2|1A|4|1B|6|7|8|1X|9|@]|A|@]|B|$]]|$2|1C|4|1D|6|7|8|1Y|9|@]|A|@]|B|$]]|$2|1E|4|1F|6|E|8|1Z|9|@]|A|@]|B|$F|G]]]]

For instance, you have the following dictionary:

<pre><code>dict = {'a': 'fire', 'b': 'ice', 'c': 'fire', 'd': 'water'}
</code></pre>

And you wanna get it in such an inverted form:

<pre><code>inverted_dict = {'fire': ['a', 'c'], 'ice': ['b'], 'water': ['d']}
</code></pre>

First Solution. For inverting key-value pairs in your dictionary use a <code>for</code>-loop approach:

<pre><code># Use this code to invert dictionaries that have non-unique values

inverted_dict = dict()
for key, value in dict.items():
 inverted_dict.setdefault(value, list()).append(key)
</code></pre>

Second Solution. Use a dictionary comprehension approach for inversion:

<pre><code># Use this code to invert dictionaries that have unique values

inverted_dict = {value: key for key, value in dict.items()}
</code></pre>

Third Solution. Use reverting the inversion approach (relies on second solution):

<pre><code># Use this code to invert dictionaries that have lists of values

dict = {value: key for key in inverted_dict for value in my_map[key]}
</code></pre>

entityMap|blocks|key|7isj5|text|当前python+3.x版本的lambda解决方案：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|24b59|d1+=+dict(alice='apples',+bob='bananas')
d2+=+dict(map(lambda+key:+(d1[key],+key),+d1.keys()))
print(d2)|code-block|syntax|javascript|e4ba8|结果：|fo5sm|{'apples':+'alice',+'bananas':+'bob'}|ei59i|此解决方案不检查重复项。|diee8|以下是一些备注：|d8qik|lambda构造可以从外部作用域访问d1，所以我们只传入当前键。它返回一个元组。|32huu|dict()构造函数接受元组列表。它还接受映射的结果，因此我们可以跳过到列表的转换。|8m5s4|此解决方案没有显式|cddir|循环。它还避免使用|5n4sm|对于那些数学不好的人;-)^0|0|0|0|0|0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|Z|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|10|9|@]|A|@]|B|$F|G]]|$2|H|4|I|6|7|8|11|9|@]|A|@]|B|$]]|$2|J|4|K|6|E|8|12|9|@]|A|@]|B|$F|G]]|$2|L|4|M|6|7|8|13|9|@]|A|@]|B|$]]|$2|N|4|O|6|7|8|14|9|@]|A|@]|B|$]]|$2|P|4|Q|6|7|8|15|9|@]|A|@]|B|$]]|$2|R|4|S|6|7|8|16|9|@]|A|@]|B|$]]|$2|T|4|U|6|7|8|17|9|@]|A|@]|B|$]]|$2|V|4|W|6|7|8|18|9|@]|A|@]|B|$]]|$2|X|4|Y|6|7|8|19|9|@]|A|@]|B|$]]]]

A lambda solution for current python 3.x versions:

<pre><code>d1 = dict(alice='apples', bob='bananas')
d2 = dict(map(lambda key: (d1[key], key), d1.keys()))
print(d2)
</code></pre>

Result:

<pre><code>{'apples': 'alice', 'bananas': 'bob'}
</code></pre>

This solution does not check for duplicates.

Some remarks:

<ul>
<li>The lambda construct can access d1 from the outer scope, so we only
pass in the current key. It returns a tuple.</li>
<li>The dict() constructor accepts a list of tuples. It
also accepts the result of a map, so we can skip the conversion to a
list.</li>
<li>This solution has no explicit <code>for</code> loop. It also avoids using a <code>list comprehension</code> for those who are bad at math ;-)</li>
</ul>

entityMap|blocks|key|i9l6|text|我发现这个版本比接受的有10000个关键字的字典版本快10%25以上。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|8olia|d+=+{i:+str(i)+for+i+in+range(10000)}

new_d+=+dict(zip(d.values(),+d.keys()))|code-block|syntax|javascript^0|0^^$0|$]|1|@$2|3|4|5|6|7|8|H|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|I|9|@]|A|@]|B|$F|G]]]]

I found that this version is more than 10% faster than the accepted version of a dictionary with 10000 keys.
<pre><code>d = {i: str(i) for i in range(10000)}

new_d = dict(zip(d.values(), d.keys()))
</code></pre>

entityMap|blocks|key|akqm9|text|这是另一种方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|5q554|my_map+=+{'a':+1,+'b':+2}

inv_map=+{}
for+key+in+my_map.keys()+:
++++val+=+my_map[key]
++++inv_map[val]+=+key|code-block|syntax|javascript^0|0^^$0|$]|1|@$2|3|4|5|6|7|8|H|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|I|9|@]|A|@]|B|$F|G]]]]

Here is another way to do it.
<pre><code>my_map = {'a': 1, 'b': 2}

inv_map= {}
for key in my_map.keys() :
 val = my_map[key]
 inv_map[val] = key
</code></pre>

entityMap|blocks|key|54c4p|text|字典值是集合的情况。例如：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1ogu7|some_dict+=+{"1":{"a","b","c"},
++++++++"2":{"d","e","f"},
++++++++"3":{"g","h","i"}}|code-block|syntax|javascript|d3njr|反之亦然：|dol2o|some_dict+=+{vi:+k++for+k,+v+in+some_dict.items()+for+vi+in+v}|3ff66|输出如下：|6fcs1|{'c':+'1',
+'b':+'1',
+'a':+'1',
+'f':+'2',
+'d':+'2',
+'e':+'2',
+'g':+'3',
+'h':+'3',
+'i':+'3'}^0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|P|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|Q|9|@]|A|@]|B|$F|G]]|$2|H|4|I|6|7|8|R|9|@]|A|@]|B|$]]|$2|J|4|K|6|E|8|S|9|@]|A|@]|B|$F|G]]|$2|L|4|M|6|7|8|T|9|@]|A|@]|B|$]]|$2|N|4|O|6|E|8|U|9|@]|A|@]|B|$F|G]]]]

A case where the dictionary values is a set. Like:
<pre><code>some_dict = {&quot;1&quot;:{&quot;a&quot;,&quot;b&quot;,&quot;c&quot;},
 &quot;2&quot;:{&quot;d&quot;,&quot;e&quot;,&quot;f&quot;},
 &quot;3&quot;:{&quot;g&quot;,&quot;h&quot;,&quot;i&quot;}}
</code></pre>
The inverse would like:
<pre><code>some_dict = {vi: k for k, v in some_dict.items() for vi in v}
</code></pre>
The output is like this:
<pre><code>{'c': '1',
 'b': '1',
 'a': '1',
 'f': '2',
 'd': '2',
 'e': '2',
 'g': '3',
 'h': '3',
 'i': '3'}
</code></pre>

entityMap|blocks|key|edf8o|text|我知道这个问题已经有了很多很好的答案，但我想分享这个非常简洁的解决方案，它也考虑了重复的值：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|fipkn|def+dict_reverser(d):
++++seen+=+set()
++++return+{v:+k+for+k,+v+in+d.items()+if+v+not+in+seen+or+seen.add(v)}|code-block|syntax|javascript|1vls5|这依赖于这样一个事实：|3cc7t|总是返回|30r48|在Python中。^0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|N|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|O|9|@]|A|@]|B|$F|G]]|$2|H|4|I|6|7|8|P|9|@]|A|@]|B|$]]|$2|J|4|K|6|7|8|Q|9|@]|A|@]|B|$]]|$2|L|4|M|6|7|8|R|9|@]|A|@]|B|$]]]]

I am aware that this question already has many good answers, but I wanted to share this very neat solution that also takes care of duplicate values:
<pre><code>def dict_reverser(d):
 seen = set()
 return {v: k for k, v in d.items() if v not in seen or seen.add(v)}
</code></pre>
This relies on the fact that <code>set.add</code> always returns <code>None</code> in Python.

entityMap|blocks|key|3k899|text|有很多答案，但没有找到任何干净的东西，以防我们讨论的是一个具有非唯一值的字典。一种解决方案是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|16s3j|from+collections+import+defaultdict

inv_map+=+defaultdict(list)+
for+k,+v+in+my_map.items():+
++++inv_map[v].append(k)|code-block|syntax|javascript^0|0^^$0|$]|1|@$2|3|4|5|6|7|8|H|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|I|9|@]|A|@]|B|$F|G]]]]

Lot of answers but didn't find anything clean in case we are talking about a dictionary with non-unique values.
A solution would be:
<pre><code>from collections import defaultdict

inv_map = defaultdict(list) 
for k, v in my_map.items(): 
 inv_map[v].append(k)
</code></pre>
<h3>Example:</h3>
If initial dict <code>my_map = {'c': 1, 'd': 5, 'a': 5, 'b': 10}</code>
then, running the code above will give:
<pre><code>{5: ['a', 'd'], 1: ['c'], 10: ['b']}
</code></pre>

Given a dictionary like so:

<pre><code>my_map = {'a': 1, 'b': 2}
</code></pre>

How can one invert this map to get:

<pre><code>inv_map = {1: 'a', 2: 'b'}
</code></pre>

Reverse / invert a dictionary mapping

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

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

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

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

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

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

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

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

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

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

 给定一个字典，如下所示： my_map = {'a': 1, 'b': 2} 如何反转这张地图才能得到： inv_map = {1: 'a', 2: 'b'}

问反转/反转字典映射
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问反转/反转字典映射EN