Suchen Sie den Pythonondict-Wörterbuchschlüssel nach regulären Ausdrücken

Ich möchte den Diktatschlüssel mit einem regulären Ausdruck durchsuchen

Das Diktatwörterbuch ist schnell und sehr einfach zu bedienen. Wenn Sie nach einem Schlüssel mit einem regulären Ausdruck suchen möchten, tun Sie dies normalerweise, aber wenn Sie ihn häufig verwenden, ist dies ein Ärger.

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]

#Es sieht bestenfalls so aus, auch wenn es durch die Einschlussnotation gekürzt wird, aber es ist nicht lesbar und ich weiß nicht, was ich tun wollte, wenn ich die Quelle las, als ich es vergaß.
s = re.compile(".bc")
[a[k] for k in a if s.search(k)] #-> [1]

Dies ist problematisch, daher habe ich das Standarddiktat erweitert, damit es so verwendet werden kann.

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

Hier ist die Quelle.

import re
from functools import lru_cache

@lru_cache(16) # re.Da das Kompilieren ein ziemlich schwerer Prozess ist, wird dasselbe Muster für reguläre Ausdrücke zwischengespeichert, um die Leistung zu steigern.
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)

Ich habe einige andere Funktionen hinzugefügt, aber hier ist ein Bild, wie man sie verwendet.

Finden Sie heraus, ob das Muster für reguläre Ausdrücke einen passenden Schlüssel enthält

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

Sonstiges 1. Gibt den Wert zurück, wenn ein Schlüssel vorhanden ist, wenn die Bedingung erfüllt ist.

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

Sonstiges 2. Suchen Sie den Schlüssel im Bereich und geben Sie den Wert zurück Wenn das Argument von findall aufrufbar ist, funktioniert alles, sodass auch die folgenden Anwendungen möglich sind

    >>> 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']

Danach die Funktion zum sofortigen Ändern des Werts des Schlüssels, der der Bedingung entspricht

    >>> 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'}

Übrigens die Funktion, alle Tasten, die den Bedingungen entsprechen, gleichzeitig zu löschen

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