Tag: Python

This is a Python case insensitive dictionary that is ordered and has integer indexes for the keys and values.

I just wrote it today.

It is ordered because I am using Python 3.9.6 and plain dict is already ordered by default.

It prevents case insensitive duplicate keys from entering the dictionary (e.g. if ‘Adele’ is already in the dictionary, there can’t be another key named ‘adele’), and access the keys case insensitively, and updates existing key with same lowercase if found, preserves the cases of the keys when they are first inserted, and finally, it uses lists to index the keys and values.

The code:

class UDict(dict):
    @staticmethod
    def _key(k):
        return k.lower() if type(k) == str else k
    
    @classmethod
    def fromkeys(cls, keys, val=None):
        dic = cls()
        for i in keys:
            dic(i) = val
        return dic
    
    def __init__(self, *args, **kwargs):
        super(UDict, self).__init__(*args, **kwargs)
        self.KEYS = dict()
        self.Keys = list()
        self.Values = list()
        if self.keys():
            for k in list(self.keys()):
                v = super(UDict, self).pop(k)
                self.__setitem__(k, v)
    
    def _delete(self, key):
        k = UDict._key(key)
        self.KEYS.pop(k)
        i = self.Keys.index(k)
        self.Keys.pop(i)
        self.Values.pop(i)
    
    def _get_key(self, key):
        k = UDict._key(key)
        if k in self.KEYS:
            key = self.KEYS(k)
        return key
    
    def _process(self, key, val, modify=True):
        k = UDict._key(key)
        if k not in self.KEYS:
            self.KEYS.update({k: key})
            self.Keys.append(k)
            self.Values.append(val)
        else:
            key = self.KEYS(k)
            if modify:
                i = self.Keys.index(k)
                self.Values(i) = val
        return key
    
    def __contains__(self, key):
        key = self._get_key(key)
        return super(UDict, self).__contains__(key)
    
    def __delitem__(self, key):
        key = self._get_key(key)
        if key in self:
            self._delete(key)
            super(UDict, self).__delitem__(key)
    
    def __getitem__(self, key):
        key = self._get_key(key)
        if key in self:
            return super(UDict, self).__getitem__(key)
    
    def __setitem__(self, key, val):
        key = self._process(key, val)
        super(UDict, self).__setitem__(key, val)
    
    def at(self, i: int):
        if i not in range(len(self)):
            return None
        k = self.Keys(i)
        key = self.KEYS(k)
        val = self.Values(i)
        return (key, val)
    
    def clear(self):
        super(UDict, self).clear()
        self.KEYS.clear()
        self.Keys.clear()
        self.Values.clear()
    
    def copy(self):
        return UDict(self.items())
    
    def get(self, key, *args, **kwargs):
        key = self._get_key(key)
        if key in self:
            return super(UDict, self).get(key, *args, **kwargs)
        return None
    
    def index(self, key):
        k = UDict._key(key)
        if k not in self.KEYS:
            return None
        return self.Keys.index(k)
    
    def key_at(self, i: int):
        if i not in range(len(self)):
            return None
        k = self.Keys(i)
        return self.KEYS(k)
    
    def multiget(self, keys=None):
        if not keys:
            return None
        return (self.get(i) for i in keys)
    
    def multipop(self, keys):
        if not keys:
            return None
        for i in keys:
            self.pop(i)
    
    def pop(self, key, *args, **kwargs):
        key = self._get_key(key)
        if key in self:
            self._delete(key)
            return super(UDict, self).pop(key, *args, **kwargs)
        return None
    
    def setdefault(self, key, val=None):
        key = self._process(key, val, False)
        return super(UDict, self).setdefault(key, val)
    
    def update(self, obj=None):
        if not obj:
            return None
        
        if type(obj) == dict:
            obj = obj.items()
        
        for key, val in obj:
            key = self._process(key, val)
            super(UDict, self).update({key: val})
    
    def value_at(self, i: int):
        if i not in range(len(self)):
            return None
        return self.Values(i)

I have properly overridden all key related methods to make it behave exactly as I wanted it to, everything works as intended and I do need to get integer indexes.

Actually I implemented a function to get keys from values, by using the index of value in the Values list, but since values can be non-unique and Python lists only return indexes of first occurrences I removed it.

It is fully functional but performance wise it is considerably slower than plain dicts.

How can it be faster?