adamchainz/flake8-comprehensions: ❄️ A flake8 plugin to help you write better list/set/dict comprehensions.

===================== flake8-comprehensions =====================

.. image:: https://img.shields.io/github/actions/workflow/status/adamchainz/flake8-comprehensions/main.yml.svg?branch=main&style=for-the-badge :target: https://github.com/adamchainz/flake8-comprehensions/actions?workflow=CI

.. image:: https://img.shields.io/pypi/v/flake8-comprehensions.svg?style=for-the-badge :target: https://pypi.org/project/flake8-comprehensions/

.. image:: https://img.shields.io/badge/code%20style-black-000000.svg?style=for-the-badge :target: https://github.com/psf/black

.. image:: https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white&style=for-the-badge :target: https://github.com/pre-commit/pre-commit :alt: pre-commit

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.11 to 3.15 supported.

Installation ============

First, install with `pip:

Second, if you define Flake8’s select setting, add the C4 prefix to it. Otherwise, the plugin should be active by default.

C400-402: Unnecessary generator - rewrite as a comprehension. ---------------------------------------------------------------------------------

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

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

• C405 Unnecessary literal - rewrite as a set literal.
• C406 Unnecessary literal - rewrite as a dict literal.

• 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 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 ()

• C409 Unnecessary passed to tuple() - .
• C410 Unnecessary list passed to list() - .

• remove the outer call to \()
• rewrite as a literal

• 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 []

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

It's unnecessary to double-cast or double-process 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)

• Rewrite set(iterable[::-1]) as set(iterable)
• Rewrite sorted(iterable)[::-1] as sorted(iterable, reverse=True)
• Rewrite reversed(iterable[::-1]) as iterable

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)

map(func, iterable) has great performance when func is a built-in 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 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}

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}

Using a list comprehension inside a call to any()/all() prevents short-circuiting when a True / False value is found. The whole list will be constructed before calling any()/all(), potentially wasting work.part-way. 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)

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)`