Case insensitive dictionary search?

Question

I can use map to implement the case insensitive list search with Python.

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

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

How can I do the same thing with dictionary?

I tried the following code, but ap has the list of [‘a’,’b’,’c’], not the case insensitive dictionary.

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

Asked By: prosseek

||

Source

Answer 1

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

will do what you’re looking for.

map(function,iterable) works over the iterable; and iterable of the dictionary is the list of keys.

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

zip brings together the keys and values back into pairs, but as a series of tuples. dict converts the tuples back into a dict.

You could also do something like

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}

Or, even more fun…

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

Answered By: Rizwan Kassim

Answer 2

Using dict comprehensions (Python2.7+)

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

If your python is too old for dict comprehensions

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

then look up the value with the lowercase version of the key

value = a_lower[key.lower()]

Answered By: John La Rooy

Answer 3

Note that making a dictionary case-insensitive, by whatever mean, may well lose information: for example, how would you “case-insensitivize” {'a': 23, 'A': 45}?! If all you care is where a key is in the dict or not (i.e., don’t care about what value corresponds to it), then make a set instead — i.e.

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

(in every version of Python, or {k.lower() for k in thedict} if you’re happy with your code working only in Python 2.7 or later for the sake of some purely decorative syntax sugar;-), and check with if k.lower() in theset: ....

Or, you could make a wrapper class, e.g., maybe a read-only one…:

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())

This will keep (without actually altering the original dictionary, so all precise information can still be retrieve for it, if and when needed) an arbitrary one of possibly-multiple values for keys that “collapse” into a single key due to the case-insensitiveness, and offer all read-only methods of dictionaries (with string keys, only) plus an actual_key_case method returning the actual case mix used for any given string key (or None if no case-alteration of that given string key matches any key in the dictionary).

Answered By: Alex Martelli

Answer 4

If you are not needing the lookup very often you can use this function without wasting space for other copy of dictionary. It is slow though as all keys must be checked against every time.

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'

Answered By: Tony Veijalainen

Answer 5

Just wanted to add __setitem__, pop to Alex Martelli’s Answer:

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())

Answered By: rabin utam

Answer 6

Start using a real case insensitive dictionary via:

from requests.structures import CaseInsensitiveDict

Or if you want to see the code:

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

Answered By: sorin

Case insensitive dictionary search?

Question:

Answers: