Rechercher une clé de dictionnaire pythondict par expression régulière

Je veux rechercher la clé dict avec une expression régulière

Le dictionnaire dict est rapide et très simple à utiliser. Si vous voulez rechercher une clé avec une expression régulière, vous le feriez normalement, mais si vous l'utilisez beaucoup, c'est un problème.

a = dict(abc=1, def=2) #-> {"abc": 1, "def": 2}
s = re.compile(".bc")
ret = []
for k in a:
    if s.search(k):
        ret.append(a[k])
print(ret) #-> [1]

#Cela ressemble au mieux à ceci même s'il est raccourci par la notation d'inclusion, mais ce n'est pas lisible et je ne sais pas ce que je voulais faire quand j'ai lu la source quand j'ai oublié.
s = re.compile(".bc")
[a[k] for k in a if s.search(k)] #-> [1]

Comme cela est gênant, j'ai étendu le dict standard afin qu'il puisse être utilisé comme ça.

a = rdict(abc=1, def=2) #-> {"abc": 1, "def": 2}
a.search(".bc") #-> [1]

Voici la source.

import re
from functools import lru_cache

@lru_cache(16) # re.La compilation étant un processus assez lourd, le même modèle d'expression régulière est mis en cache pour améliorer les performances.
def re_call(pattern, flags=0, call_re_func="search"):
    return re.compile(pattern, flags=flags).__getattribute__(call_re_func)

class rdict(dict):
    def _filter(self, _callable):
        return (k for k in self if _callable(k))

    def isin(self, key_or_function):
        if callable(key_or_function):
            return any(True for _ in self._filter(key_or_function))
        return dict.__contains__(self, key_or_function)

    def findall(self, key_or_function):
        if callable(key_or_function):
            return [dict.__getitem__(self, key) for key in self._filter(key_or_function)]
        return dict.__getitem__(self, key_or_function)

    def search(self, pattern, flags=0):
        return [dict.__getitem__(self,key) for key in self if re_call(pattern, flags, "search")(key)]

    def fullmatch(self, pattern, flags=0):
        return [dict.__getitem__(self,key) for key in self if re_call(pattern, flags, "fullmatch")(key)]

    def __setitem__(self, key_or_function, value):
        if callable(key_or_function):
            for key in self._filter(key_or_function):
                dict.__setitem__(self, key, value)
        else:
            return dict.__setitem__(self, key_or_function, value)

    def __delitem__(self, key_or_function):
        if callable(key_or_function):
            for key in list(self._filter(key_or_function)):
                dict.__delitem__(self, key)
        else:
            return dict.__delitem__(self, key_or_function)

J'ai ajouté d'autres fonctions, mais voici une image de leur utilisation.

Découvrez s'il existe une clé correspondante dans le modèle d'expression régulière

    >>> a.isin(re.compile(".b.*").search)
    True
    >>> a.isin(re.compile(".z.*").search)
    False

Autre 1. Renvoie la valeur lors de la possession d'une clé lorsque la condition est vraie.

    >>> a.findall(lambda x: len(x) == 3)
    [1, 2]

Autre 2. Recherchez la clé dans la plage et renvoyez la valeur Si l'argument de findall est appelable, tout fonctionne, donc les applications suivantes sont également possibles

    >>> from datetime import datetime
    >>> b = funcdict()
    >>> b[datetime(2020,1,1)] = "2020/01/01"
    >>> b[datetime(2020,2,1)] = "2020/02/01"
    >>> b[datetime(2020,3,1)] = "2020/03/01"

    >>> def between_0131_0202(x):
    ...    return datetime(2020,1,31) < x and x < datetime(2020,2,2)
    >>> b.findall(between_0131_0202)
    ['2020/02/01']

    >>> def less_0401(x):
    ...    return x < datetime(2020, 4, 1)
    >>> b.isin(less_0401)
    True

    >>> def grater_0401(x):
    ...    return x > datetime(2020, 4, 1)
    >>> b.isin(grater_0401)
    False

    >>> b.findall(less_0401)
    ['2020/01/01', '2020/02/01', '2020/03/01']

Après cela, la fonction pour changer la valeur de la clé qui correspond à la condition à la fois

    >>> b[less_0401] = "test"
    >>> b
    {datetime.datetime(2020, 1, 1, 0, 0): 'test',
     datetime.datetime(2020, 2, 1, 0, 0): 'test',
     datetime.datetime(2020, 3, 1, 0, 0): 'test'}

À propos, la fonction pour supprimer toutes les clés qui correspondent aux conditions à la fois

    >>> del b[between_0131_0202]
    >>> b
    {datetime.datetime(2020, 1, 1, 0, 0): 'test',
     datetime.datetime(2020, 3, 1, 0, 0): 'test'}