It is possible to select and ignore certain violations reported by and the plugins we've installed. It's also possible as of 3.0 to combine usage of flake8 --select and flake8 --ignore. This chapter of the User Guide aims to educate about how Flake8 will report errors based on different inputs.

By default, has a list of error codes that it ignores. The list used by a version of may be different than the list used by a different version. To see the default list, flake8 --help will show the output with the current default list.

If we want to extend the default list of ignored error codes, we can use flake8 --extend-ignore to specify a comma-separated list of codes for a specific run on the command line, e.g.,

This tells to ignore any error codes starting with E1 and E23, in addition the default ignore list. To view the default error code ignore list, run flake8 --help and refer to the help text for flake8 --ignore.

If we want to completely override the default list of ignored error codes, we can use flake8 --ignore to specify a comma-separated list of codes for a specific run on the command-line, e.g.,

This tells to only ignore error codes starting with E1, E23, or W503 while it is running.

In some cases, we might not want to ignore an error code (or class of error codes) for the entirety of our project. Instead, we might want to ignore the specific error code on a specific line. Let's take for example a line like

example = lambda: 'example'

Sometimes we genuinely need something this simple. We could instead define a function like we normally would. Note, in some contexts this distracts from what is actually happening. In those cases, we can also do:

example = lambda: 'example'  # noqa: E731

This will only ignore the error from pycodestyle that checks for lambda assignments and generates an E731. If there are other errors on the line then those will be reported. # noqa is case-insensitive, without the colon the part after # noqa would be ignored.

If we instead had more than one error that we wished to ignore, we could list all of the errors with commas separating them:

# noqa: E731,E123

Finally, if we have a particularly bad line of code, we can ignore every error using simply # noqa with nothing after it.

Contents before and after the # noqa: ... portion are ignored so multiple comments may appear on one line. Here are several examples:

# mypy requires `# type: ignore` to appear first
x = 5  # type: ignore  # noqa: ABC123

# can use to add useful user information to a noqa comment
y = 6  # noqa: ABC456  # TODO: will fix this later

Imagine a situation where we are adding to a codebase. Let's further imagine that with the exception of a few particularly bad files, we can add easily and move on with our lives. There are two ways to ignore the file:

1. By explicitly adding it to our list of excluded paths (see: flake8 --exclude)
2. By adding # flake8: noqa to the file

The former is the recommended way of ignoring entire files. By using our exclude list, we can include it in our configuration file and have one central place to find what files aren't included in checks. The latter has the benefit that when we run with flake8 --disable-noqa all of the errors in that file will show up without having to modify our configuration. Both exist so we can choose which is better for us.

has a default list of violation classes that we use. This list is:

• C90

  All C90 class violations are reported when the user specifies flake8 --max-complexity

• E

  All E class violations are "errors" reported by pycodestyle

• F

  All F class violations are reported by pyflakes

• W

  All W class violations are "warnings" reported by pycodestyle

This list can be overridden by specifying flake8 --select. Just as specifying flake8 --ignore will change the behaviour of , so will flake8 --select.

Let's look through some examples using this sample code:

# example.py
def foo():
    print(
                "Hello"
        "World"
        )

By default, if we run flake8 on this file we'll get:

example.py:4:9: E131 continuation line unaligned for hanging indent

Now let's select all E class violations:

example.py:3:17: E126 continuation line over-indented for hanging indent
example.py:4:9: E131 continuation line unaligned for hanging indent
example.py:5:9: E121 continuation line under-indented for hanging indent

Suddenly we now have far more errors that are reported to us. Using --select alone will override the default --ignore list. In these cases, the user is telling us that they want all E violations and so we ignore our list of violations that we ignore by default.

We can also be highly specific. For example, we can do

example.py:5:9: E121 continuation line under-indented for hanging indent

We can also specify lists of items to select both on the command-line and in our configuration files.

example.py:4:9: E131 continuation line unaligned for hanging indent
example.py:5:9: E121 continuation line under-indented for hanging indent

Prior to 3.0, all handling of flake8 --select and flake8 --ignore was delegated to pycodestyle. Its handling of the options significantly differs from how 3.0 has been designed.

pycodestyle has always preferred --ignore over --select and will ignore --select if the user provides both. 3.0 will now do its best to intuitively combine both options provided by the user. Let's look at some examples using:

# example.py
import os


def foo():
    var = 1
    print(
                "Hello"
        "World"
        )

If we run with its default settings we get:

example.py:1:1: F401 'os' imported but unused
example.py:5:5: F841 local variable 'var' is assigned to but never used
example.py:8:9: E131 continuation line unaligned for hanging indent

Now let's select all E and F violations including those in the default ignore list.

example.py:1:1: F401 'os' imported but unused
example.py:5:5: F841 local variable 'var' is assigned to but never used
example.py:7:17: E126 continuation line over-indented for hanging indent
example.py:8:9: E131 continuation line unaligned for hanging indent
example.py:9:9: E121 continuation line under-indented for hanging indent

Now let's selectively ignore some of these while selecting the rest:

example.py:5:5: F841 local variable 'var' is assigned to but never used
example.py:7:17: E126 continuation line over-indented for hanging indent
example.py:8:9: E131 continuation line unaligned for hanging indent

Via this example, we can see that the most specific user-specified rule will win. So in the above, we had very vague select rules and two very specific ignore rules. Let's look at a different example:

example.py:1:1: F401 'os' imported but unused
example.py:8:9: E131 continuation line unaligned for hanging indent

In this case, we see that since our selected violation codes were more specific those were reported.