A flake8 plugin to help you write better list/set/dict comprehensions.
Project description
A flake8 plugin that helps you write better list/set/dict comprehensions.
Linting a Django project? Check out my book Boost Your Django DX which covers Flake8 and many other code quality tools.
Requirements
Python 3.8 to 3.12 supported.
Installation
First, install with pip:
python m pip install flake8comprehensions
Second, if you define Flake8’s select setting, add the C4 prefix to it. Otherwise, the plugin should be active by default.
Rules
C400402: Unnecessary generator  rewrite as a <list/set/dict> comprehension.
Rules:
C400 Unnecessary generator  rewrite as a list comprehension.
C401 Unnecessary generator  rewrite as a set comprehension.
C402 Unnecessary generator  rewrite as a dict comprehension.
It’s unnecessary to use list, set, or dict around a generator expression, since there are equivalent comprehensions for these types. For example:
Rewrite list(f(x) for x in foo) as [f(x) for x in foo]
Rewrite set(f(x) for x in foo) as {f(x) for x in foo}
Rewrite dict((x, f(x)) for x in foo) as {x: f(x) for x in foo}
C403404: Unnecessary list comprehension  rewrite as a <set/dict> comprehension.
Rules:
C403 Unnecessary list comprehension  rewrite as a set comprehension.
C404 Unnecessary list comprehension  rewrite as a dict comprehension.
It’s unnecessary to use a list comprehension inside a call to set or dict, since there are equivalent comprehensions for these types. For example:
Rewrite set([f(x) for x in foo]) as {f(x) for x in foo}
Rewrite dict([(x, f(x)) for x in foo]) as {x: f(x) for x in foo}
C405406: Unnecessary <list/tuple> literal  rewrite as a <set/dict> literal.
C405 Unnecessary <list/tuple> literal  rewrite as a set literal.
C406 Unnecessary <list/tuple> literal  rewrite as a dict literal.
It’s unnecessary to use a list or tuple literal within a call to set or dict. For example:
Rewrite set([1, 2]) as {1, 2}
Rewrite set((1, 2)) as {1, 2}
Rewrite set([]) as set()
Rewrite dict([(1, 2)]) as {1: 2}
Rewrite dict(((1, 2),)) as {1: 2}
Rewrite dict([]) as {}
C407: Unnecessary <dict/list> comprehension  <builtin> can take a generator
This rule was dropped in version 3.4.0, because it promoted an increase in laziness which could lead to bugs.
C408: Unnecessary <dict/list/tuple> call  rewrite as a literal.
It’s slower to call e.g. dict() than using the empty literal, because the name dict must be looked up in the global scope in case it has been rebound. Same for the other two basic types here. For example:
Rewrite dict() as {}
Rewrite dict(a=1, b=2) as {"a": 1, "b": 2}
Rewrite list() as []
Rewrite tuple() as ()
C409410: Unnecessary <list/tuple> passed to <list/tuple>()  <advice>.
Rules:
C409 Unnecessary <list/tuple> passed to tuple()  <advice>.
C410 Unnecessary list passed to list()  <advice>.
Where <advice> is either:
remove the outer call to <list/tuple>()
rewrite as a <list/tuple> literal
It’s unnecessary to use a list or tuple literal within a call to list or tuple, since there is literal syntax for these types. For example:
Rewrite tuple([1, 2]) as (1, 2)
Rewrite tuple((1, 2)) as (1, 2)
Rewrite tuple([]) as ()
Rewrite list([1, 2]) as [1, 2]
Rewrite list((1, 2)) as [1, 2]
Rewrite list([]) as []
C411: Unnecessary list call  remove the outer call to list().
It’s unnecessary to use a list around a list comprehension, since it is equivalent without it. For example:
Rewrite list([f(x) for x in foo]) as [f(x) for x in foo]
C412: Unnecessary <dict/list/set> comprehension  ‘in’ can take a generator.
This rule was dropped in version 3.4.0, because it promoted an increase in laziness which could lead to bugs.
C413: Unnecessary <list/reversed> call around sorted().
It’s unnecessary to use list() around sorted() as it already returns a list. It is also unnecessary to use reversed() around sorted() as the latter has a reverse argument. For example:
Rewrite list(sorted([2, 3, 1])) as sorted([2, 3, 1])
Rewrite reversed(sorted([2, 3, 1])) as sorted([2, 3, 1], reverse=True)
Rewrite reversed(sorted([2, 3, 1], reverse=True)) as sorted([2, 3, 1])
C414: Unnecessary <list/reversed/set/sorted/tuple> call within <list/set/sorted/tuple>().
It’s unnecessary to doublecast or doubleprocess iterables by wrapping the listed functions within list/set/sorted/tuple. For example:
Rewrite list(list(iterable)) as list(iterable)
Rewrite list(tuple(iterable)) as list(iterable)
Rewrite tuple(list(iterable)) as tuple(iterable)
Rewrite tuple(tuple(iterable)) as tuple(iterable)
Rewrite set(set(iterable)) as set(iterable)
Rewrite set(list(iterable)) as set(iterable)
Rewrite set(tuple(iterable)) as set(iterable)
Rewrite set(sorted(iterable)) as set(iterable)
Rewrite set(reversed(iterable)) as set(iterable)
Rewrite sorted(list(iterable)) as sorted(iterable)
Rewrite sorted(tuple(iterable)) as sorted(iterable)
Rewrite sorted(sorted(iterable)) as sorted(iterable)
Rewrite sorted(reversed(iterable)) as sorted(iterable)
C415: Unnecessary subscript reversal of iterable within <reversed/set/sorted>().
It’s unnecessary to reverse the order of an iterable when passing it into one of the listed functions will change the order again. For example:
Rewrite set(iterable[::1]) as set(iterable)
Rewrite sorted(iterable)[::1] as sorted(iterable, reverse=True)
Rewrite reversed(iterable[::1]) as iterable
C416: Unnecessary <dict/list/set> comprehension  rewrite using <dict/list/set>().
It’s unnecessary to use a dict/list/set comprehension to build a data structure if the elements are unchanged. Wrap the iterable with dict(), list(), or set() instead. For example:
Rewrite {a: b for a, b in iterable} as dict(iterable)
Rewrite [x for x in iterable] as list(iterable)
Rewrite {x for x in iterable} as set(iterable)
C417: Unnecessary map usage  rewrite using a generator expression/<list/set/dict> comprehension.
map(func, iterable) has great performance when func is a builtin function, and it makes sense if your function already has a name. But if your func is a lambda, it’s faster to use a generator expression or a comprehension, as it avoids the function call overhead. For example:
Rewrite map(lambda x: x + 1, iterable) to (x + 1 for x in iterable)
Rewrite map(lambda item: get_id(item), items) to (get_id(item) for item in items)
Rewrite list(map(lambda num: num * 2, nums)) to [num * 2 for num in nums]
Rewrite set(map(lambda num: num % 2 == 0, nums)) to {num % 2 == 0 for num in nums}
Rewrite dict(map(lambda v: (v, v ** 2), values)) to {v : v ** 2 for v in values}
C418: Unnecessary <dict/dict comprehension> passed to dict()  remove the outer call to dict()
It’s unnecessary to use a dict around a dict literal or dict comprehension, since either syntax already constructs a dict. For example:
Rewrite dict({}) as {}
Rewrite dict({"a": 1}) as {"a": 1}
C419 Unnecessary list comprehension in <any/all>() prevents shortcircuiting  rewrite as a generator.
Using a list comprehension inside a call to any()/all() prevents shortcircuiting when a True / False value is found. The whole list will be constructed before calling any()/all(), potentially wasting work.partway. Rewrite to use a generator expression, which can stop part way. For example:
Rewrite all([condition(x) for x in iterable]) as all(condition(x) for x in iterable)
Rewrite any([condition(x) for x in iterable]) as any(condition(x) for x in iterable)
C420: Unnecessary dict comprehension  rewrite using dict.fromkeys().
It’s unnecessary to use a dict comprehension to build a dict with all values set to the same constant. Use dict.fromkeys() instead, which is faster. For example:
Rewrite {x: 1 for x in iterable} as dict.fromkeys(iterable, 1)
Rewrite {x: None for x in iterable} as dict.fromkeys(iterable)
Project details
Release history Release notifications  RSS feed
Download files
Download the file for your platform. If you're not sure which to choose, learn more about installing packages.
Source Distribution
Built Distribution
Hashes for flake8_comprehensions3.15.0.tar.gz
Algorithm  Hash digest  

SHA256  923c22603e0310376a6b55b03efebdc09753c69f2d977755cba8bb73458a5d4d 

MD5  a750a19cff2773ea80d66e20932e1667 

BLAKE2b256  60fa68481f25fc8ecdbe8a763062ba4f5b17fa4ef7fc0646c081267cef4f67e5 
Hashes for flake8_comprehensions3.15.0py3noneany.whl
Algorithm  Hash digest  

SHA256  b7e027bbb52be2ceb779ee12484cdeef52b0ad3c1fcb8846292bdb86d3034681 

MD5  55fb1af0ed0627a4d6f2852869c49864 

BLAKE2b256  3aaa93667d6f398749d1a9dd37d646e092f9f1baade7cbac948331b50a1d513c 