पायथन: एक शब्दकोश में अद्वितीय मूल्यों के साथ कुंजी खोजना?

Question

मुझे इनपुट के रूप में एक शब्दकोश प्राप्त होता है, और उस कुंजी की एक सूची वापस करना चाहता है जिसके लिए शब्दकोश के दायरे में शब्दकोश मान अद्वितीय हैं।

मैं एक उदाहरण के साथ स्पष्टीकरण दूंगा। कहो मेरी इनपुट के रूप में इस शब्दकोश एक का निर्माण किया है:

a = dict() 
a['cat'] =  1 
a['fish'] =  1 
a['dog'] =  2 # <-- unique 
a['bat'] =  3 
a['aardvark'] = 3 
a['snake'] = 4 # <-- unique 
a['wallaby'] = 5 
a['badger'] = 5 

परिणाम मैं उम्मीद ['dog', 'snake'] है।

यह हासिल करने के लिए स्पष्ट ब्रूट फोर्स तरीके हैं, हालांकि मुझे आश्चर्य हुआ कि क्या काम पूरा करने के लिए एक साफ पाइथोनियन तरीका है।

Answer 1

मुझे लगता है कि कारगर तरीका अगर dict बहुत बड़ी होगी है

countMap = {} 
for v in a.itervalues(): 
    countMap[v] = countMap.get(v,0) + 1 
uni = [ k for k, v in a.iteritems() if countMap[v] == 1] 

Answer 2

ध्यान दें कि यह वास्तव में एक bruteforce है:

l = a.values() 
b = [x for x in a if l.count(a[x]) == 1] 

Answer 3

आप कुछ इस तरह कर सकता है (बस प्रत्येक मान के लिए घटनाओं की संख्या गिनती):

def unique(a): 
    from collections import defaultdict 
    count = defaultdict(lambda: 0) 
    for k, v in a.iteritems(): 
     count[v] += 1 
    for v, c in count.iteritems(): 
     if c <= 1: 
      yield v 

Answer 4

>>> b = [] 
>>> import collections 
>>> bag = collections.defaultdict(lambda: 0) 
>>> for v in a.itervalues(): 
...  bag[v] += 1 
... 
>>> b = [k for (k, v) in a.iteritems() if bag[v] == 1] 
>>> b.sort() # optional 
>>> print b 
['dog', 'snake'] 
>>> 

Answer 5

नेस्टेड सूची समझ का प्रयोग करें!

print [v[0] for v in 
      dict([(v, [k for k in a.keys() if a[k] == v]) 
        for v in set(a.values())]).values() 
     if len(v) == 1] 

Answer 6

यहां एक और भिन्नता है।

>>> import collections 
>>> inverse= collections.defaultdict(list) 
>>> for k,v in a.items(): 
...  inverse[v].append(k) 
... 
>>> [ v[0] for v in inverse.values() if len(v) == 1 ] 
['dog', 'snake'] 

मैं इसके लिए आंशिक हूं क्योंकि उलटा शब्दकोश इतना आम डिजाइन पैटर्न है।

Answer 7

यहाँ एक समाधान है कि केवल dict एक बार traversing की आवश्यकता है:

def unique_values(d): 
    seen = {} # dict (value, key) 
    result = set() # keys with unique values 
    for k,v in d.iteritems(): 
     if v in seen: 
      result.discard(seen[v]) 
     else: 
      seen[v] = k 
      result.add(k) 
    return list(result) 

Answer 8

एक छोटे से अधिक वर्बोज़, लेकिन एक से अधिक केवल एक पास की जरूरत है:

revDict = {} 
for k, v in a.iteritems(): 
    if v in revDict: 
    revDict[v] = None 
    else: 
    revDict[v] = k 

[ x for x in revDict.itervalues() if x != None ] 

(मुझे आशा है कि यह काम करता है, चूंकि मैं इसे यहां परीक्षण नहीं कर सकता)

Answer 9

सबक्लासिंग के बारे में क्या?

class UniqueValuesDict(dict): 

    def __init__(self, *args): 
     dict.__init__(self, *args) 
     self._inverse = {} 

    def __setitem__(self, key, value): 
     if value in self.values(): 
      if value in self._inverse: 
       del self._inverse[value] 
     else: 
      self._inverse[value] = key 
     dict.__setitem__(self, key, value) 

    def unique_values(self): 
     return self._inverse.values() 

a = UniqueValuesDict() 

a['cat'] =  1 
a['fish'] =  1 
a[None] =  1 
a['duck'] =  1 
a['dog'] =  2 # <-- unique 
a['bat'] =  3 
a['aardvark'] = 3 
a['snake'] = 4 # <-- unique 
a['wallaby'] = 5 
a['badger'] = 5 

assert a.unique_values() == ['dog', 'snake']