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.
Requirements
Python 3.6 to 3.10 supported.
Installation
First, install with pip:
python m pip install flake8comprehensions
Second, check that flake8 lists the plugin in its version line:
$ 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
Third, add the C4 prefix to your select list. For example, if you have your configuration in setup.cfg:
[flake8] select = E,F,W,C4
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
C400402: Unnecessary generator  rewrite as a <list/set/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.
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.
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 {}
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>()  (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]
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 <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.7.0py3noneany.whl (6.7 kB)  File type Wheel  Python version py3  Upload date  Hashes View 
Filename, size flake8comprehensions3.7.0.tar.gz (10.8 kB)  File type Source  Python version None  Upload date  Hashes View 
Hashes for flake8_comprehensions3.7.0py3noneany.whl
Algorithm  Hash digest  

SHA256  a5d7aea6315bbbd6fbcb2b4e80bff6a54d1600155e26236e555d0c6fe1d62522 

MD5  22c6ba9797874c7d15b531638dc6faaf 

BLAKE2256  3c919d309c22b5b2a163c801cd40f2e6e25ef374a6b3fa214bf8263c9ca4cfe1 
Hashes for flake8comprehensions3.7.0.tar.gz
Algorithm  Hash digest  

SHA256  6b3218b2dde8ac5959c6476cde8f41a79e823c22feb656be2710cd2a3232cef9 

MD5  ea319913e9f1142a49cd0ef574d43313 

BLAKE2256  6db187d560cb5c1be41b92684196c283903abe0a9652984219909825fd87ad2c 