Ein flake8-Plugin, das Ihnen hilft, bessere Listen-/Set-/Dikt-Verständnisse zu schreiben.
Linting ein Django-Projekt? Schauen Sie sich mein Buch „Boost Your Django DX“ an, das Flake8 und viele andere Tools für die Codequalität behandelt.
Python 3.9 bis 3.13 wird unterstützt.
Zuerst mit pip installieren:
python -m pip install flake8-comprehensions Zweitens: Wenn Sie die select von Flake8 definieren, fügen Sie ihr das Präfix C4 hinzu. Andernfalls sollte das Plugin standardmäßig aktiv sein.
<list/set/dict> -Verständnis umschreiben.Regeln:
Es ist unnötig, list , set oder dict rund um einen Generatorausdruck zu verwenden, da es für diese Typen äquivalente Verständnisse gibt. Zum Beispiel:
list(f(x) for x in foo) umschreiben als [f(x) for x in foo]set(f(x) for x in foo) um als {f(x) for x in foo}dict((x, f(x)) for x in foo) um als {x: f(x) for x in foo}<set/dict> -Verständnis umschreiben.Regeln:
Es ist nicht erforderlich, in einem Aufruf von set oder dict ein Listenverständnis zu verwenden, da es für diese Typen gleichwertige Verständnisse gibt. Zum Beispiel:
set([f(x) for x in foo]) um als {f(x) for x in foo}dict([(x, f(x)) for x in foo]) um als {x: f(x) for x in foo}<list/tuple> -Literal – als <set/dict> -Literal umschreiben.<list/tuple> -Literal – als Mengenliteral umschreiben.<list/tuple> -Literal – als Diktliteral umschreiben. Es ist nicht erforderlich, in einem Aufruf von set oder dict ein Listen- oder Tupelliteral zu verwenden. Zum Beispiel:
set([1, 2]) als {1, 2} umschreibenset((1, 2)) als {1, 2} umschreibenset([]) als set() umschreibendict([(1, 2)]) als {1: 2}dict(((1, 2),)) um als {1: 2}dict([]) als {}<dict/list> -Verständnis – <builtin> kann einen Generator annehmenDiese Regel wurde in Version 3.4.0 gestrichen, da sie eine Zunahme der Faulheit förderte, die zu Fehlern führen konnte.
<dict/list/tuple> -Aufruf – als Literal umschreiben. Der Aufruf von zB dict() ist langsamer als die Verwendung des leeren Literals, da der Name dict im globalen Bereich nachgeschlagen werden muss, falls er erneut gebunden wurde. Das Gleiche gilt für die beiden anderen Grundtypen hier. Zum Beispiel:
dict() als {}dict(a=1, b=2) um als {"a": 1, "b": 2}list() als [] umschreibentuple() um als ()<list/tuple> wurde an <list/tuple> () – <advice> übergeben.Regeln:
<list/tuple> wurde an tuple() - <advice> übergeben.<advice> . Dabei ist <advice> entweder:
<list/tuple> ()<list/tuple> -Literal umschreiben Es ist nicht erforderlich, in einem Aufruf von list oder tuple ein Listen- oder Tupelliteral zu verwenden, da es für diese Typen eine Literalsyntax gibt. Zum Beispiel:
tuple([1, 2]) umschreiben als (1, 2)tuple((1, 2)) als (1, 2) umschreibentuple([]) um als ()list([1, 2]) als [1, 2] umschreibenlist((1, 2)) umschreiben als [1, 2]list([]) umschreiben als [] Es ist unnötig, eine list um ein Listenverständnis herum zu verwenden, da es ohne sie gleichwertig ist. Zum Beispiel:
list([f(x) for x in foo]) umschreiben als [f(x) for x in foo]<dict/list/set> -Verständnis – „in“ kann einen Generator erfordern.Diese Regel wurde in Version 3.4.0 gestrichen, da sie eine Zunahme der Faulheit förderte, die zu Fehlern führen konnte.
<list/reversed> -Aufruf um sorted(). Es ist unnötig, list() neben sorted() zu verwenden, da es bereits eine Liste zurückgibt. Es ist auch unnötig, reversed() neben sorted() zu verwenden, da letzteres ein reverse Argument hat. Zum Beispiel:
list(sorted([2, 3, 1])) als sorted([2, 3, 1]) umschreibenreversed(sorted([2, 3, 1])) als sorted([2, 3, 1], reverse=True) umschreibenreversed(sorted([2, 3, 1], reverse=True)) als sorted([2, 3, 1]) umschreiben<list/reversed/set/sorted/tuple> -Aufruf innerhalb von <list/set/sorted/tuple> (). Es ist nicht erforderlich, Iterables doppelt umzuwandeln oder doppelt zu verarbeiten, indem die aufgelisteten Funktionen in list / set / sorted / tuple eingeschlossen werden. Zum Beispiel:
list(list(iterable)) als list(iterable) umschreibenlist(tuple(iterable)) als list(iterable) umschreibentuple(list(iterable)) als tuple(iterable) umschreibentuple(tuple(iterable)) um als tuple(iterable)set(set(iterable)) als set(iterable) umschreibenset(list(iterable)) als set(iterable) umschreibenset(tuple(iterable)) als set(iterable) umschreibenset(sorted(iterable)) als set(iterable) umschreibenset(reversed(iterable)) als set(iterable) umschreibensorted(list(iterable)) als sorted(iterable)sorted(tuple(iterable)) als sorted(iterable)sorted(sorted(iterable)) als sorted(iterable) umsorted(reversed(iterable)) als sorted(iterable)<reversed/set/sorted> ().Es ist nicht erforderlich, die Reihenfolge eines Itables umzukehren, wenn die Übergabe an eine der aufgelisteten Funktionen die Reihenfolge erneut ändert. Zum Beispiel:
set(iterable[::-1]) als set(iterable) umschreibensorted(iterable)[::-1] als sorted(iterable, reverse=True)reversed(iterable[::-1]) als iterable<dict/list/set> -Verständnis – mit <dict/list/set> () neu schreiben. Es ist nicht erforderlich, ein Diktat-/Listen-/Set-Verständnis zu verwenden, um eine Datenstruktur aufzubauen, wenn die Elemente unverändert bleiben. Umschließen Sie die Iterable stattdessen mit dict() , list() oder set() . Zum Beispiel:
{a: b for a, b in iterable} als dict(iterable) um.[x for x in iterable] als list(iterable) um.{x for x in iterable} als set(iterable) um.map – Umschreiben mit einem Generatorausdruck/ <list/set/dict> -Verständnis. map(func, iterable) bietet eine hervorragende Leistung, wenn func eine integrierte Funktion ist, und es ist sinnvoll, wenn Ihre Funktion bereits einen Namen hat. Wenn Ihre Funktion jedoch ein lambda ist, ist es schneller, einen Generatorausdruck oder eine Comprehension zu verwenden, da dadurch der Funktionsaufruf-Overhead vermieden wird. Zum Beispiel:
map(lambda x: x + 1, iterable) in (x + 1 for x in iterable) um.map(lambda item: get_id(item), items) in (get_id(item) for item in items) um.list(map(lambda num: num * 2, nums)) umschreiben in [num * 2 for num in nums]set(map(lambda num: num % 2 == 0, nums)) in {num % 2 == 0 for num in nums} umschreibendict(map(lambda v: (v, v ** 2), values)) um in {v : v ** 2 for v in values}<dict/dict comprehension> wurde an dict() übergeben – entfernen Sie den äußeren Aufruf von dict() Es ist nicht erforderlich, ein dict um ein Diktatliteral oder eine Diktatverständlichkeit herum zu verwenden, da beide Syntaxen bereits ein Diktat erstellen. Zum Beispiel:
dict({}) um als {}dict({"a": 1}) um als {"a": 1}<any/all> () verhindert Kurzschlüsse – als Generator umschreiben. Die Verwendung eines Listenverständnisses innerhalb eines Aufrufs von any() / all() verhindert einen Kurzschluss, wenn ein True / False -Wert gefunden wird. Die gesamte Liste wird vor dem Aufruf von any() / all() erstellt, wodurch möglicherweise ein Teil der Arbeit verschwendet wird. Umschreiben, um einen Generatorausdruck zu verwenden, was teilweise zum Stillstand kommen kann. Zum Beispiel:
all([condition(x) for x in iterable]) um als all(condition(x) for x in iterable)any([condition(x) for x in iterable]) um als any(condition(x) for x in iterable) Es ist nicht erforderlich, ein Diktatverständnis zu verwenden, um ein Diktat zu erstellen, bei dem alle Werte auf dieselbe Konstante gesetzt sind. Verwenden Sie stattdessen dict.fromkeys() , was schneller ist. Zum Beispiel:
{x: 1 for x in iterable} um als dict.fromkeys(iterable, 1){x: None for x in iterable} als dict.fromkeys(iterable) um.
