不區分大小寫的字典搜索？

Question

我可以使用map來實現使用Python進行不區分大小寫的列表搜索。

a = ['xyz', 'wMa', 'Pma']; 

b = map(string.lower, a) 
if 'Xyz'.lower() in b: 
    print 'yes' 

我該怎麼用字典做同樣的事情？

我試過下面的代碼，但是ap有['a'，'b'，'c']的列表，而不是不區分大小寫的字典。

a = {'a':1, 'B':2, 'c':3} 
ap = map(string.lower, a) 

Answer 1

注意的小寫版本，可能會丟失信息：例如，你會如何「病例不敏感「{'a': 23, 'A': 45}？！如果您所關心的是，其中一個關鍵是在字典或沒有（即不關心什麼值對應於它），然後做一個set代替 - 即

theset = set(k.lower() for k in thedict) 

（Python中的每個版本或者{k.lower() for k in thedict}，如果你對你的代碼感到滿意，那麼你的代碼只能在Python 2.7或更高版本中工作，這是爲了一些純粹的裝飾語法糖;-)，並且檢查if k.lower() in theset: ...。

或者，你可以做一個包裝類，例如，可能是隻讀一個...：

import collections 

class CaseInsensitiveDict(collections.Mapping): 
    def __init__(self, d): 
     self._d = d 
     self._s = dict((k.lower(), k) for k in d) 
    def __contains__(self, k): 
     return k.lower() in self._s 
    def __len__(self): 
     return len(self._s) 
    def __iter__(self): 
     return iter(self._s) 
    def __getitem__(self, k): 
     return self._d[self._s[k.lower()]] 
    def actual_key_case(self, k): 
     return self._s.get(k.lower()) 

這將保持（實際上不改變原來的字典，所以所有的準確信息仍然可以在需要時檢索它）任意一個可能爲多個值的鍵值，這些鍵值由於不區分大小寫而「摺疊」爲單個鍵值，並提供字典的所有隻讀方法（僅限字符串鍵）加上一個actual_key_case方法返回用於任何給定字符串鍵的實際大小寫混合（或None，如果沒有該給定字符串鍵的大小寫改變匹配字典中的任何鍵）。

Answer 2

dict(zip(map(string.lower,a.keys()),a.values())) 

會做你要找的東西。

map（函數，可迭代）在迭代器上工作;並且字典的迭代是密鑰列表。

a = {'a': 1, 'c': 3, 'B': 2} 
for i in a: 
print a 
# returns a c B 

zip將鍵和值彙集到一起，但是作爲一系列元組。字典將元組轉換回字典。

你也可以做類似

def myfunc(t): 
return (string.lower(t[0]),t[1]) 

map(myfunc,a.items()) 
# returns [('a', 1), ('c', 3), ('b', 2) 
dict(map(myfunc,a.items())) 
# returns {'a': 1, 'c': 3, 'b': 2} 

或者，甚至更多的樂趣......

dict(map(lambda (key, value):(string.lower(key),value),a.items())) 

Answer 3

使用字典內涵（Python2.7 +）

a_lower = {k.lower():v for k,v in a.items()} 

如果你的python對於詞典理解來說太老了

a_lower = dict((k.lower(),v) for k,v in a.items()) 

再看看價值與製作字典不區分大小寫的，以任何均值的關鍵

value = a_lower[key.lower()] 

Answer 4

如果你不經常需要查找，你可以使用此函數而不浪費其他字典副本的空間。這是緩慢的，因爲所有的密鑰都必須每次檢查。

a = {'xyz':2, 'wMa':8, 'Pma':9} 

## if you do not use many times and/or the dict is very big 

def case_insensitive_key(a,k): 
    k = k.lower() 
    return [a[key] for key in a if key.lower() == k] 

print 'yes' if case_insensitive_key(a,'Xyz') else 'no' 

Answer 5

只想添加__setitem__，彈出亞歷馬爾泰利的答案：

from requests import CaseInsensitiveDict 

或者，如果你想看到的代碼：通過使用一個真正的不區分大小寫的字典

from collections import Mapping 

class CaseInsensitiveDict(Mapping): 
    def __init__(self, d): 
     self._d = d 
     self._s = dict((k.lower(), k) for k in d) 
    def __contains__(self, k): 
     return k.lower() in self._s 
    def __len__(self): 
     return len(self._s) 
    def __iter__(self): 
     return iter(self._s) 
    def __getitem__(self, k): 
     return self._d[self._s[k.lower()]] 
    def __setitem__(self, k, v): 
     self._d[k] = v 
     self._s[k.lower()] = k 
    def pop(self, k): 
     k0 = self._s.pop(k.lower()) 
     return self._d.pop(k0) 
    def actual_key_case(self, k): 
     return self._s.get(k.lower()) 

Answer 6

開始：

class CaseInsensitiveDict(dict): 

    """Basic case insensitive dict with strings only keys.""" 

    proxy = {} 

    def __init__(self, data): 
     self.proxy = dict((k.lower(), k) for k in data) 
     for k in data: 
      self[k] = data[k] 

    def __contains__(self, k): 
     return k.lower() in self.proxy 

    def __delitem__(self, k): 
     key = self.proxy[k.lower()] 
     super(CaseInsensitiveDict, self).__delitem__(key) 
     del self.proxy[k.lower()] 

    def __getitem__(self, k): 
     key = self.proxy[k.lower()] 
     return super(CaseInsensitiveDict, self).__getitem__(key) 

    def get(self, k, default=None): 
     return self[k] if k in self else default 

    def __setitem__(self, k, v): 
     super(CaseInsensitiveDict, self).__setitem__(k, v) 
     self.proxy[k.lower()] = k