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.
Installation
Install from pip with:
python m pip install flake8comprehensions
Python 3.5 to 3.9 supported.
When installed it will automatically be run as part of flake8; you can check it is being picked up with:
$ flake8 version 3.7.8 (flake8comprehensions: 3.0.0, mccabe: 0.6.1, pycodestyle: 2.5.0, pyflakes: 2.1.1) CPython 3.8.0 on Linux
Linting a Django project? Check out my book Speed Up Your Django Tests which covers loads of best practices so you can write faster, more accurate tests.
Rules
Code  Rule 

C400  Unnecessary generator  rewrite as a list comprehension. 
C401  Unnecessary generator  rewrite as a set comprehension. 
C402  Unnecessary generator  rewrite as a dict comprehension. 
C403  Unnecessary list comprehension  rewrite as a set comprehension. 
C404  Unnecessary list comprehension  rewrite as a dict comprehension. 
C405  Unnecessary (list/tuple) literal  rewrite as a set literal. 
C406  Unnecessary (list/tuple) literal  rewrite as a dict literal. 
C407  Unnecessary (dict/list) comprehension  ‘<builtin>’ can take a generator. 
C408  Unnecessary (dict/list/tuple) call  rewrite as a literal. 
C409  Unnecessary (list/tuple) passed to tuple()  (remove the outer call to tuple()/rewrite as a tuple literal). 
C410  Unnecessary (list/tuple) passed to list()  (remove the outer call to list()/rewrite as a list literal). 
C411  Unnecessary list call  remove the outer call to list(). 
C412  Unnecessary (dict/list/set) comprehension  ‘in’ can take a generator. 
C413  Unnecessary list call around sorted(). 
C413  Unnecessary reversed call around sorted()  (use sorted(…, reverse=(True/False))/toggle reverse argument to sorted()). 
C414  Unnecessary (list/reversed/set/sorted/tuple) call within list/set/sorted/tuple(). 
C415  Unnecessary subscript reversal of iterable within reversed/set/sorted(). 
C416  Unnecessary (list/set) comprehension  rewrite using list/set(). 
Examples
C400402: Unnecessary generator
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
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,C409410: Unnecessary list/tuple literal
It’s unnecessary to use a list or tuple literal within a call to tuple, list, set, or dict since there is literal syntax for these types. For example:
 Rewrite tuple([1, 2]) or tuple((1, 2)) as (1, 2)
 Rewrite tuple([]) as ()
 Rewrite list([1, 2]) or list((1, 2)) as [1, 2]
 Rewrite list([]) as []
 Rewrite set([1, 2]) or set((1, 2)) as {1, 2}
 Rewrite set([]) as set()
 Rewrite dict([(1, 2)]) or dict(((1, 2),)) as {1: 2}
 Rewrite dict([]) as {}
C407: Unnecessary list comprehension  ‘<builtin>’ can take a generator
It’s unnecessary to pass a list comprehension to some builtins that can take generators instead. For example:
 Rewrite sum([x ** 2 for x in range(10)]) as sum(x ** 2 for x in range(10))
 Rewrite all([foo.bar for foo in foos]) as all(foo.bar for foo in foos)
 Rewrite filter(lambda x: x % 2 == 0, [x ** 3 for x in range(10)]) as filter(lambda x: x % 2 == 0, (x ** 3 for x in range(10)))
The list of builtins that are checked for are:
 all
 any
 enumerate
 filter
 frozenset
 map
 max
 min
 sorted
 sum
 tuple
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 {}
 Rewrite list() as []
 Rewrite tuple() as ()
C411: Unnecessary list call  remove the outer call to list().
It’s unnecessary to use a list around 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.
It’s unnecessary to pass a dict/list/set comprehension to ‘in’ that can take a generator instead. For example:
 Rewrite y in [f(x) for x in foo] as y in (f(x) for x in foo)
 Rewrite y in {x ** 2 for x in foo} as y in (x ** 2 for x in foo)
C413: Unnecessary list/reversed call around sorted().
It’s unnecessary to use list() around sorted() as it already returns a list. It is also suboptimal 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 change the type of the iterable or change the order of elements within certain other function calls that will themselves define the order of the iterable or the type that is output. 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 using a [::1] before passing it into set() which will randomize the order, sorted() which will return a new sorted list, or reversed() which will effectively return the original iterable. 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 (list/set) comprehension  rewrite using list/set().
It’s unnecessary to use a list comprehension if the elements are unchanged. The iterable should be wrapped in list() or set() instead. For example:
 Rewrite [x for x in iterable] as list(iterable)
 Rewrite {x for x in iterable} as set(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.
Filename, size  File type  Python version  Upload date  Hashes 

Filename, size flake8_comprehensions3.3.0py3noneany.whl (7.2 kB)  File type Wheel  Python version py3  Upload date  Hashes View 
Filename, size flake8comprehensions3.3.0.tar.gz (66.7 kB)  File type Source  Python version None  Upload date  Hashes View 
Hashes for flake8_comprehensions3.3.0py3noneany.whl
Algorithm  Hash digest  

SHA256  c1dd6d8a00e9722619a5c5e0e6c5747f5cf23c089032c86eaf614c14a2e40adb 

MD5  896be93c27bf90a7aeef674c15413f12 

BLAKE2256  2b77f2d042252342c9db95f00381d9a549e52ab3bcb221f274243afc23ca485a 
Hashes for flake8comprehensions3.3.0.tar.gz
Algorithm  Hash digest  

SHA256  355ef47288523cad7977cb9c1bc81b71c82b7091e425cd9fbcd7e5c19a613677 

MD5  104a99c83a9c347ada80d5c9c7f5be84 

BLAKE2256  565c46627ecc3210e97d1e764ae9b0e5d04f1c6e840bdce1c66abef4906bfbb5 