Tutorial

This tutorial is all about approaching coding standards with little or no knowledge of in-depth programming or the code standards themselves. It's the equivalent of skipping the manual and jumping right in.

The command line prompt for these examples is:

tutor Desktop$

Getting Started

Running Pylint with the --help arguments will give you an idea of the arguments available. Do that now, i.e.:

pylint --help

A couple of the options that we'll focus on here are:

Commands:
  --help-msg=<msg-id>
  --generate-toml-config
Messages control:
  --disable=<msg-ids>
Reports:
  --reports=<y or n>
  --output-format=<format>

If you need more detail, you can also ask for an even longer help message:

pylint --long-help

Pay attention to the last bit of this longer help output. This gives you a hint of what Pylint is going to pick on:

Output:
   Using the default text output, the message format is :
  MESSAGE_TYPE: LINE_NUM:[OBJECT:] MESSAGE
  There are 5 kind of message types :
  * (C) convention, for programming standard violation
  * (R) refactor, for bad code smell
  * (W) warning, for python specific problems
  * (E) error, for probable bugs in the code
  * (F) fatal, if an error occurred which prevented pylint from doing
  further processing.

When Pylint is first run on a fresh piece of code, a common complaint is that it is too noisy. The default configuration enforce a lot of warnings. We'll use some of the options we noted above to make it suit your preferences a bit better.

Your First Pylint'ing

We'll use a basic Python script with black already applied on it, as fodder for our tutorial. The starting code we will use is called simplecaesar.py and is here in its entirety:

#!/usr/bin/env python3
import string
shift = 3
choice = input("would you like to encode or decode?")
word = input("Please enter text")
letters = string.ascii_letters + string.punctuation + string.digits
encoded = ""
if choice == "encode":
    for letter in word:
        if letter == " ":
            encoded = encoded + " "
        else:
            x = letters.index(letter) + shift
            encoded = encoded + letters[x]
if choice == "decode":
    for letter in word:
        if letter == " ":
            encoded = encoded + " "
        else:
            x = letters.index(letter) - shift
            encoded = encoded + letters[x]
print(encoded)

Let's get started. If we run this:

tutor Desktop$ pylint simplecaesar.py
************* Module simplecaesar
simplecaesar.py:1:0: C0114: Missing module docstring (missing-module-docstring)
simplecaesar.py:5:0: C0103: Constant name "shift" doesn't conform to UPPER_CASE naming style (invalid-name)
simplecaesar.py:8:0: C0103: Constant name "letters" doesn't conform to UPPER_CASE naming style (invalid-name)
simplecaesar.py:9:0: C0103: Constant name "encoded" doesn't conform to UPPER_CASE naming style (invalid-name)
simplecaesar.py:13:12: C0103: Constant name "encoded" doesn't conform to UPPER_CASE naming style (invalid-name)
simplecaesar.py:15:12: C0103: Constant name "x" doesn't conform to UPPER_CASE naming style (invalid-name)
simplecaesar.py:16:12: C0103: Constant name "encoded" doesn't conform to UPPER_CASE naming style (invalid-name)
simplecaesar.py:20:12: C0103: Constant name "encoded" doesn't conform to UPPER_CASE naming style (invalid-name)
simplecaesar.py:22:12: C0103: Constant name "x" doesn't conform to UPPER_CASE naming style (invalid-name)
simplecaesar.py:23:12: C0103: Constant name "encoded" doesn't conform to UPPER_CASE naming style (invalid-name)
-----------------------------------
Your code has been rated at 4.74/10

We can see the second line is:

"simplecaesar.py:1:0: C0114: Missing module docstring (missing-module-docstring)"

This basically means that line 1 at column 0 violates the convention C0114. Another piece of information is the message symbol between parens, missing-module-docstring.

If we want to read up a bit more about that, we can go back to the command line and try this:

tutor Desktop$ pylint --help-msg=missing-module-docstring
:missing-module-docstring (C0114): *Missing module docstring*
  Used when a module has no docstring.Empty modules do not require a docstring.
  This message belongs to the basic checker.

That one was a bit of a no-brainer, but we can also run into error messages where we are unfamiliar with the underlying code theory.

The Next Step

Now that we got some configuration stuff out of the way, let's see what we can do with the remaining warnings. If we add a docstring to describe what the code is meant to do that will help. There are invalid-name messages that we will get to later. Here is the updated code:

#!/usr/bin/env python3
"""This script prompts a user to enter a message to encode or decode
using a classic Caesar shift substitution (3 letter shift)"""
import string
shift = 3
choice = input("would you like to encode or decode?")
word = input("Please enter text")
letters = string.ascii_letters + string.punctuation + string.digits
encoded = ""
if choice == "encode":
    for letter in word:
        if letter == " ":
            encoded = encoded + " "
        else:
            x = letters.index(letter) + shift
            encoded = encoded + letters[x]
if choice == "decode":
    for letter in word:
        if letter == " ":
            encoded = encoded + " "
        else:
            x = letters.index(letter) - shift
            encoded = encoded + letters[x]
print(encoded)

Here is what happens when we run it:

tutor Desktop$ pylint simplecaesar.py
************* Module simplecaesar
simplecaesar.py:8:0: C0103: Constant name "shift" doesn't conform to UPPER_CASE naming style (invalid-name)
simplecaesar.py:11:0: C0103: Constant name "letters" doesn't conform to UPPER_CASE naming style (invalid-name)
simplecaesar.py:12:0: C0103: Constant name "encoded" doesn't conform to UPPER_CASE naming style (invalid-name)
simplecaesar.py:16:12: C0103: Constant name "encoded" doesn't conform to UPPER_CASE naming style (invalid-name)
simplecaesar.py:18:12: C0103: Constant name "x" doesn't conform to UPPER_CASE naming style (invalid-name)
simplecaesar.py:19:12: C0103: Constant name "encoded" doesn't conform to UPPER_CASE naming style (invalid-name)
simplecaesar.py:23:12: C0103: Constant name "encoded" doesn't conform to UPPER_CASE naming style (invalid-name)
simplecaesar.py:25:12: C0103: Constant name "x" doesn't conform to UPPER_CASE naming style (invalid-name)
simplecaesar.py:26:12: C0103: Constant name "encoded" doesn't conform to UPPER_CASE naming style (invalid-name)
------------------------------------------------------------------
Your code has been rated at 5.26/10 (previous run: 4.74/10, +0.53)

Nice! Pylint told us how much our code rating has improved since our last run, and we're down to just the invalid-name messages.

There are fairly well defined conventions around naming things like instance variables, functions, classes, etc. The conventions focus on the use of UPPERCASE and lowercase as well as the characters that separate multiple words in the name. This lends itself well to checking via a regular expression, thus the should match (([A-Z_][A-Z1-9_]*)|(__.*__))$.

In this case Pylint is telling us that those variables appear to be constants and should be all UPPERCASE. This is an in-house convention that has lived with Pylint since its inception. You too can create your own in-house naming conventions but for the purpose of this tutorial, we want to stick to the PEP 8 standard. In this case, the variables we declared should follow the convention of all lowercase. The appropriate rule would be something like: "should match [a-z_][a-z0-9_]{2,30}$". Notice the lowercase letters in the regular expression (a-z versus A-Z).

If we run that rule using a --const-rgx='[a-z\_][a-z0-9\_]{2,30}$' option, it will now be quite quiet:

tutor Desktop$ pylint simplecaesar.py --const-rgx='[a-z\_][a-z0-9\_]{2,30}$'
************* Module simplecaesar
simplecaesar.py:18:12: C0103: Constant name "x" doesn't conform to '[a-z\\_][a-z0-9\\_]{2,30}$' pattern (invalid-name)
simplecaesar.py:25:12: C0103: Constant name "x" doesn't conform to '[a-z\\_][a-z0-9\\_]{2,30}$' pattern (invalid-name)
------------------------------------------------------------------
Your code has been rated at 8.95/10 (previous run: 5.26/10, +3.68)

You can read up on regular expressions or use a website to help you.

TIP:

Installation

Pylint can be installed:

Command line installation

Pylint is installable using a package manager. Your package manager will find a version that works with your interpreter. We recommend pip:

pip install pylint

Or if you want to also check spelling with enchant (you might need to install the enchant C library):

pip install pylint[spelling]

The newest pylint supports all Python interpreters that are not past end of life.

We recommend to use the latest interpreter because we rely on the ast builtin module that gets better with each new Python interpreter. For example a Python 3.6 interpreter can't analyse 3.8 syntax (amongst others, because of the new walrus operator) while a 3.8 interpreter can also deal with Python 3.6. See using pylint with multiple interpreters for more details.

NOTE:

conda install pylint

sudo apt-get install pylint

Editor and IDE integration

Pylint can be integrated in various editors and IDE's. Below you can find tutorials for some of the most common ones.

Using Pylint through Flymake in Emacs

WARNING:

Integrate Pylint with TextMate

Install Pylint in the usual way:

pip install pylint

Install the Python bundle for TextMate:

You should now see it in Bundles > Python.

In Preferences, select the Variables tab. If a TM_PYCHECKER variable is not already listed, add it, with the value pylint.

The default keyboard shortcut to run the syntax checker is Control-Shift-V - open a .py file in Textmate, and try it.

You should see the output in a new window:

Then all is well, and most likely Pylint will have expressed some opinions about your Python code (or will exit with 0 if your code already conforms to its expectations).

If you receive a message:

That means that Pylint wasn't found, which is likely an issue with command paths - TextMate needs be looking for Pylint on the right paths.

Check where Pylint has been installed, using which:

$ which pylint
/usr/local/bin/pylint

The output will tell you where Pylint can be found; in this case, in /usr/local/bin.

... and try running Pylint again.

Pre-commit integration

pylint can be used as a pre-commit hook. We however discourage it as pylint -- due to its speed -- is more suited to a continuous integration job or a git pre-push hook, especially if your repository is large.

Since pylint needs to import modules and dependencies to work correctly, the hook only works with a local installation of pylint (in your environment). It means it can't be used with pre-commit.ci, and you will need to add the following to your .pre-commit-config.yaml

.. sourcecode:: yaml

Another limitation is that pylint should analyse all your code at once in order to best infer the actual values that result from calls. If only some of the files are given, pylint might miss a particular value's type and produce inferior inference for the subset. Since pre-commit slices the files given to it in order to parallelize the processing, the result can be degraded. It can also be unexpectedly different when the file set changes because the new slicing can change the inference. Thus the require_serial option should be set to true if correctness and determinism are more important than parallelization to you.

If you installed pylint locally it can be added to .pre-commit-config.yaml as follows:

- repo: local
  hooks:
    - id: pylint
      name: pylint
      entry: pylint
      language: system
      types: [python]
      require_serial: true
      args:
        [
          "-rn", # Only display messages
          "-sn", # Don't display the score
        ]

You can use args to pass command line arguments as described in the Tutorial. A hook with more arguments could look something like this:

- repo: local
  hooks:
    - id: pylint
      name: pylint
      entry: pylint
      language: system
      types: [python]
      args:
        [
          "-rn", # Only display messages
          "-sn", # Don't display the score
          "--rcfile=pylintrc", # Link to your config file
          "--load-plugins=pylint.extensions.docparams", # Load an extension
        ]

Installation with multiple interpreters

It's possible to analyse code written for older or multiple interpreters by using the py-version option and setting it to the oldest supported interpreter of your code. For example you can check that there are no f-strings in Python 3.5 code using Python 3.8 with an up-to-date pylint even if Python 3.5 is past end of life (EOL) and the version of pylint you use is not compatible with it.

We do not guarantee that py-version will work for all EOL Python interpreters indefinitely, (for anything before Python 3.5, it probably won't). If a newer version does not work for you, the best available pylint might be an old version that works with your old interpreter but without the bug fixes and features of later versions.

Show your usage

You can place this badge in your README to let others know your project uses pylint.

[![linting: pylint](https://img.shields.io/badge/linting-pylint-yellowgreen)](https://github.com/pylint-dev/pylint)

.. image:: https://img.shields.io/badge/linting-pylint-yellowgreen
    :target: https://github.com/pylint-dev/pylint

Upgrading pylint

You should probably set the version of pylint in your development environment in order to choose when you actually upgrade pylint's warnings. pylint is following semver versioning. But we can't guarantee that the output between version will stays the same. What this means is that:

You can expect less messages if you set the minor and upgrade to a new patch version. But still, if you enable useless-suppression it still means you can get a new useless-suppression when a false positive that you disabled is now fixed. Also, if a library you're using was upgraded and is understood better or worse than the previous one, you could get new messages too.

You can expect a lot more change in output, the main one being new checks.

You could have to change the command you're launching or the plugin and editor integration you're using.

Usage

Running Pylint

On module packages or directories

Pylint is meant to be called from the command line. The usage is

pylint [options] modules_or_packages

By default the pylint command only accepts a list of python modules and packages. On versions below 2.15, specifying a directory that is not an explicit package (with __init__.py) results in an error:

pylint mydir
************* Module mydir
mydir/__init__.py:1:0: F0010: error while code parsing: Unable to load file mydir/__init__.py:
[Errno 2] No such file or directory: 'mydir/__init__.py' (parse-error)

Thus, on versions before 2.15 using the --recursive=y option allows for linting a namespace package:

pylint --recursive=y mydir mymodule mypackage

This option makes pylint attempt to discover all modules (files ending with .py extension) and all explicit packages (all directories containing a __init__.py file).

Pylint will not import this package or module, but it does use Python internals to locate them and as such is subject to the same rules and configuration. You should pay attention to your PYTHONPATH, since it is a common error to analyze an installed version of a module instead of the development version.

On files

It is also possible to analyze Python files, with a few restrictions. As a convenience, you can give it a file name if it's possible to guess a module name from the file's path using the python path. Some examples:

pylint mymodule.py should always work since the current working directory is automatically added on top of the python path

pylint directory/mymodule.py will work if: directory is a python package (i.e. has an __init__.py file), an implicit namespace package or if directory is in the python path.

With implicit namespace packages

If the analyzed sources use implicit namespace packages (PEP 420), the source root(s) should be specified using the --source-roots option. Otherwise, the package names are detected incorrectly, since implicit namespace packages don't contain an __init__.py.

Globbing support

It is also possible to specify both directories and files using globbing patterns:

pylint [options] packages/*/src

Command line options

First of all, we have two basic (but useful) options.

Pylint is architected around several checkers. You can disable a specific checker or some of its messages or message categories by specifying --disable=<symbol>. If you want to enable only some checkers or some message symbols, first use --disable=all then --enable=<symbol> with <symbol> being a comma-separated list of checker names and message symbols. See the list of available features for a description of provided checkers with their functionalities. The --disable and --enable options can be used with comma-separated lists mixing checkers, message ids and categories like -d C,W,no-error,design

It is possible to disable all messages with --disable=all. This is useful to enable only a few checkers or a few messages by first disabling everything, and then re-enabling only what you need.

Each checker has some specific options, which can take either a yes/no value, an integer, a python regular expression, or a comma-separated list of values (which are generally used to override a regular expression in special cases). For a full list of options, use --help

Specifying all the options suitable for your setup and coding standards can be tedious, so it is possible to use a configuration file to specify the default values. You can specify a configuration file on the command line using the --rcfile option. Otherwise, Pylint searches for a configuration file in the following order and uses the first one it finds:

The --generate-toml-config option will generate a commented configuration file on standard output according to the current configuration and exit. This includes:

Of course you can also start with the default values and hand-tune the configuration.

Other useful global options include:

Parallel execution

It is possible to speed up the execution of Pylint. If the running computer has more CPUs than one, then the work for checking all files could be spread across all cores via Pylints's sub-processes.

This functionality is exposed via the -j command-line parameter. If the provided number is 0, then the total number of CPUs will be autodetected and used.

Example:

pylint -j 4 mymodule1.py mymodule2.py mymodule3.py mymodule4.py

This will spawn 4 parallel Pylint sub-process, where each provided module will be checked in parallel. Discovered problems by checkers are not displayed immediately. They are shown just after checking a module is complete.

You can also do your own parallelization by launching pylint multiple times on subsets of your files (like pre-commit with the default require_serial=false does). Be aware, though: pylint should analyse all your code at once in order to best infer the actual values that result from calls. If only some of the files are given, pylint might miss a particular value's type and produce inferior inference for the subset. It can also be unexpectedly different when the file set changes because the new slicing can change the inference. So, don't do this if correctness and determinism are important to you.

Exit codes

Pylint returns bit-encoded exit codes.

For example, an exit code of 20 means there was at least one warning message (4) and at least one convention message (16) and nothing else.

Pylint output

Output options

Output by default is written to stdout. The simplest way to output to a file is with the --output=<filename> option.

The default format for the output is raw text. You can change this by passing pylint the --output-format=<value> option. Possible values are: text, json, parseable, colorized and msvs (for Visual Studio).

Multiple output formats can be used at the same time by passing a comma-separated list of formats to --output-format. This output can be redirected to a file by giving a filename after a colon.

For example, to save a json report to somefile.json and print a colorized report to stdout at the same time:

--output-format=json:somefile.json,colorized

Custom message formats

You can customize the exact way information are displayed using the --msg-template=<format string> option. The format string uses the Python new format syntax and the following fields are available :

For example, the former (pre 1.0) default format can be obtained with:

pylint --msg-template='{msg_id}:{line:3d},{column}: {obj}: {msg}'

A few other examples:

{path}:{line}:{column}: {msg_id}: {msg} ({symbol})

{path}({line}): [{msg_id}{obj}] {msg}

{path}:{line}: [{msg_id}({symbol}), {obj}] {msg}

The --msg-template option can only be combined with text-based reporters (--output-format either unspecified or one of: parseable, colorized or msvs). If both --output-format and --msg-template are specified, the --msg-template option will take precedence over the default line format defined by the reporter class.

If end_line or end_column are None, they will be represented as an empty string by the default TextReporter.

Source code analysis section

For each python module, Pylint will first display a few '*' characters followed by the name of the module. Then, a number of messages with the following format:

MESSAGE_TYPE: LINE_NUM:[OBJECT:] MESSAGE

You can get another output format, useful since it's recognized by most editors or other development tools using the --output-format=parseable option.

The message type can be:

Sometimes the line of code which caused the error is displayed with a caret pointing to the error. This may be generalized in future versions of Pylint.

Example (extracted from a run of Pylint on itself...):

************* Module pylint.checkers.format
W: 50: Too long line (86/80)
W:108: Operator not followed by a space
     print >>sys.stderr, 'Unable to match %r', line
            ^
W:141: Too long line (81/80)
W: 74:searchall: Unreachable code
W:171:FormatChecker.process_tokens: Redefining built-in (type)
W:150:FormatChecker.process_tokens: Too many local variables (20/15)
W:150:FormatChecker.process_tokens: Too many branches (13/12)

Reports section

Following the analysis message, Pylint can display a set of reports, each one focusing on a particular aspect of the project, such as number of messages by categories, modules dependencies. These features can be enabled through the --reports=y option, or its shorthand version -ry.

For instance, the metrics report displays summaries gathered from the current run.

Score section

Finally, Pylint displays a global evaluation score for the code, rated out of a maximum score of 10.0. This output can be suppressed through the --score=n option, or its shorthand version -sn.

The evaluation formula can be overridden with the --evaluation=<python_expression> option.

Messages

Messages overview

Pylint can emit the following messages:

Fatal

All messages in the fatal category:

astroid-error / F0002

Message emitted:

%s: %s

Description:

Used when an unexpected error occurred while building the Astroid representation. This is usually accompanied by a traceback. Please report such errors !

Additional details:

This is a message linked to an internal problem in pylint. There's nothing to change in your code, but maybe in pylint's configuration or installation.

Created by the main checker.

config-parse-error / F0011

Message emitted:

error while parsing the configuration: %s

Description:

Used when an exception occurred while parsing a pylint configuration file.

Additional details:

This is a message linked to a problem in your configuration not your code.

Created by the main checker.

fatal / F0001

Message emitted:

%s

Description:

Used when an error occurred preventing the analysis of a module (unable to find it for instance).

Additional details:

This is a message linked to an internal problem in pylint. There's nothing to change in your code.

Created by the main checker.

method-check-failed / F0202

Message emitted:

Unable to check methods signature (%s / %s)

Description:

Used when Pylint has been unable to check methods signature compatibility for an unexpected reason. Please report this kind if you don't make sense of it.

Additional details:

This is a message linked to an internal problem in pylint. There's nothing to change in your code.

Created by the classes checker.

parse-error / F0010

Message emitted:

error while code parsing: %s

Description:

Used when an exception occurred while building the Astroid representation which could be handled by astroid.

Additional details:

This is a message linked to an internal problem in pylint. There's nothing to change in your code.

Created by the main checker.

All renamed messages in the fatal category:

old-import-error / F0401

'old-import-error' has been renamed. The new message can be found at:

import-error / E0401

Message emitted:

Unable to import %s

Description:

Used when pylint has been unable to import a module.

Problematic code:

from patlib import Path  # [import-error]

Correct code:

from pathlib import Path

Additional details:

This can happen if you're importing a package that is not installed in your environment, or if you made a typo.

The solution is to install the package via pip/setup.py/wheel or fix the typo.

Created by the imports checker.

Error

All messages in the error category:

abstract-class-instantiated / E0110

Message emitted:

Abstract class %r with abstract methods instantiated

Description:

Used when an abstract class with `abc.ABCMeta` as metaclass has abstract methods and is instantiated.

Problematic code:

import abc
class Animal(abc.ABC):
    @abc.abstractmethod
    def make_sound(self):
        pass
sheep = Animal()  # [abstract-class-instantiated]

Correct code:

import abc
class Animal(abc.ABC):
    @abc.abstractmethod
    def make_sound(self):
        pass
class Sheep(Animal):
    def make_sound(self):
        print("bhaaaaa")
sheep = Sheep()

Created by the basic checker.

access-member-before-definition / E0203

Message emitted:

Access to member %r before its definition line %s

Description:

Used when an instance member is accessed before it's actually assigned.

Problematic code:

class Unicorn:
    def __init__(self, fluffiness_level):
        if self.fluffiness_level > 9000:  # [access-member-before-definition]
            print("It's OVER-FLUFFYYYY ! *crush glasses*")
        self.fluffiness_level = fluffiness_level

Correct code:

class Unicorn:
    def __init__(self, fluffiness_level):
        self.fluffiness_level = fluffiness_level
        if self.fluffiness_level > 9000:
            print("It's OVER-FLUFFYYYY ! *crush glasses*")

Created by the classes checker.

assigning-non-slot / E0237

Message emitted:

Assigning to attribute %r not defined in class slots

Description:

Used when assigning to an attribute not defined in the class slots.

Problematic code:

class Student:
    __slots__ = ("name",)
    def __init__(self, name, surname):
        self.name = name
        self.surname = surname  # [assigning-non-slot]
        self.setup()
    def setup(self):
        pass

Correct code:

class Student:
    __slots__ = ("name", "surname")
    def __init__(self, name, surname):
        self.name = name
        self.surname = surname
        self.setup()
    def setup(self):
        pass

Created by the classes checker.

assignment-from-no-return / E1111

Message emitted:

Assigning result of a function call, where the function has no return

Description:

Used when an assignment is done on a function call but the inferred function doesn't return anything.

Problematic code:

def add(x, y):
    print(x + y)
value = add(10, 10)  # [assignment-from-no-return]

Correct code:

def add(x, y):
    return x + y
value = add(10, 10)

Created by the typecheck checker.

assignment-from-none / E1128

Message emitted:

Assigning result of a function call, where the function returns None

Description:

Used when an assignment is done on a function call but the inferred function returns nothing but None.

Problematic code:

def function():
    return None
f = function()  # [assignment-from-none]

Correct code:

def function():
    return None
f = function() if function() else 1

Created by the typecheck checker.

await-outside-async / E1142

Message emitted:

'await' should be used within an async function

Description:

Emitted when await is used outside an async function.

Problematic code:

import asyncio
def main():
    await asyncio.sleep(1)  # [await-outside-async]

Correct code:

import asyncio
async def main():
    await asyncio.sleep(1)

Related links:

Created by the typecheck checker.

bad-configuration-section / E0014

Message emitted:

Out-of-place setting encountered in top level configuration-section '%s' : '%s'

Description:

Used when we detect a setting in the top level of a toml configuration that shouldn't be there.

Additional details:

This error was raised when we encountered an unexpected value type in a toml configuration between pylint 2.12 and pylint 2.14 (before the argparse refactor).

Created by the main checker.

bad-except-order / E0701

Message emitted:

Bad except clauses order (%s)

Description:

Used when except clauses are not in the correct order (from the more specific to the more generic). If you don't fix the order, some exceptions may not be caught by the most specific handler.

Problematic code:

try:
    print(int(input()))
except Exception:
    raise
except TypeError:  # [bad-except-order]
    # This block cannot be reached since TypeError exception
    # is caught by previous exception handler.
    raise

Correct code:

try:
    print(int(input()))
except TypeError:
    raise
except Exception:
    raise

Created by the exceptions checker.

bad-exception-cause / E0705

Message emitted:

Exception cause set to something which is not an exception, nor None

Description:

Used when using the syntax "raise ... from ...", where the exception cause is not an exception, nor None.

Problematic code:

def divide(x, y):
    result = 0
    try:
        result = x / y
    except ZeroDivisionError:
        # +1: [bad-exception-cause]
        raise ValueError(f"Division by zero when dividing {x} by {y} !") from result
    return result

Correct code:

def divide(x, y):
    result = 0
    try:
        result = x / y
    except ZeroDivisionError as exc:
        raise ValueError(f"Division by zero when dividing {x} by {y} !") from exc
    return result

Related links:

Created by the exceptions checker.

bad-format-character / E1300

Message emitted:

Unsupported format character %r (%#02x) at index %d

Description:

Used when an unsupported format character is used in a format string.

Problematic code:

print("%s %z" % ("hello", "world"))  # [bad-format-character]

Correct code:

print("%s %s" % ("hello", "world"))

Additional details:

This check is currently only active for "old-style" string formatting as seen in the examples. See Issue #6085 for more information.

Related links:

Created by the string checker.

bad-plugin-value / E0013

Message emitted:

Plugin '%s' is impossible to load, is it installed ? ('%s')

Description:

Used when a bad value is used in 'load-plugins'.

Additional details:

One of your pylint plugins cannot be loaded. There's nothing to change in your code, but your pylint configuration or installation has an issue.

For example, there might be a typo. The following config:

[MAIN]
load-plugins = pylint.extensions.bad_biultin

Should be:

[MAIN]
load-plugins = pylint.extensions.bad_builtin

Or the plugin you added is not importable in your environment.

Created by the main checker.

bad-reversed-sequence / E0111

Message emitted:

The first reversed() argument is not a sequence

Description:

Used when the first argument to reversed() builtin isn't a sequence (does not implement __reversed__, nor __getitem__ and __len__

Problematic code:

reversed({1, 2, 3, 4})  # [bad-reversed-sequence]

Correct code:

reversed([1, 2, 3, 4])

Created by the basic checker.

bad-str-strip-call / E1310

Message emitted:

Suspicious argument in %s.%s call

Description:

The argument to a str.{l,r,}strip call contains a duplicate character,

Problematic code:

hello_world.py:

"Hello World".strip("Hello")  # [bad-str-strip-call]
# >>> ' World'

remove_abc_from_both_side.py:

"abcbc def bacabc".strip("abcbc ")  # [bad-str-strip-call]
# >>> 'def'

Correct code:

hello_world.py:

"Hello World".strip("Helo")
# >>> ' World'

remove_abc_from_both_side.py:

"abcbc def bacabc".strip("abc ")
# >>> 'def'

Additional details:

A common misconception is that str.strip('Hello') removes the substring 'Hello' from the beginning and end of the string. This is not the case. From the documentation:

> The chars argument is not a prefix or suffix; rather, all combinations of its values are stripped

Duplicated characters in the str.strip call, besides not having any effect on the actual result, may indicate this misunderstanding.

Related links:

Created by the string checker.

bad-string-format-type / E1307

Message emitted:

Argument %r does not match format type %r

Description:

Used when a type required by format string is not suitable for actual argument type

Problematic code:

print("%d" % "1")  # [bad-string-format-type]

Correct code:

print("%d" % 1)

Additional details:

This check is currently only active for "old-style" string formatting as seen in the examples. See Issue #6085 for more information.

Related links:

Created by the string checker.

bad-super-call / E1003

Message emitted:

Bad first argument %r given to super()

Description:

Used when another argument than the current class is given as first argument of the super builtin.

Problematic code:

class Animal:
    pass
class Tree:
    pass
class Cat(Animal):
    def __init__(self):
        super(Tree, self).__init__()  # [bad-super-call]
        super(Animal, self).__init__()

Correct code:

class Animal:
    pass
class Tree:
    pass
class Cat(Animal):
    def __init__(self):
        super(Animal, self).__init__()

Additional details:

In Python 2.7, super() has to be called with its own class and self as arguments (super(Cat, self)), which can lead to a mix up of parent and child class in the code.

In Python 3 the recommended way is to call super() without arguments (see also super-with-arguments).

One exception is calling super() on a non-direct parent class. This can be used to get a method other than the default method returned by the mro().

Related links:

Created by the newstyle checker.

bidirectional-unicode / E2502

Message emitted:

Contains control characters that can permit obfuscated code executed differently than displayed

Description:

bidirectional unicode are typically not displayed characters required to display right-to-left (RTL) script (i.e. Chinese, Japanese, Arabic, Hebrew, ...) correctly. So can you trust this code? Are you sure it displayed correctly in all editors? If you did not write it or your language is not RTL, remove the special characters, as they could be used to trick you into executing code, that does something else than what it looks like. More Information: https://en.wikipedia.org/wiki/Bidirectional_text https://trojansource.codes/

Problematic code:

# +1: [bidirectional-unicode]
example = "x‏" * 100  #    "‏x" is assigned

Correct code:

example = "x[U+2194]" * 100

Created by the unicode_checker checker.

broken-collections-callable / E6005

Message emitted:

'collections.abc.Callable' inside Optional and Union is broken in 3.9.0 / 3.9.1 (use 'typing.Callable' instead)

Description:

``collections.abc.Callable`` inside Optional and Union is broken in Python 3.9.0 and 3.9.1. Use ``typing.Callable`` for these cases instead. https://bugs.python.org/issue42965

Problematic code:

from collections.abc import Callable
from typing import Optional
def func() -> Optional[Callable[[int], None]]:  # [broken-collections-callable]
    ...

Correct code:

from typing import Callable, Optional
def func() -> Optional[Callable[[int], None]]: ...

Configuration file:

[main]
py-version=3.9
load-plugins=pylint.extensions.typing

Related links:

NOTE:

Created by the typing checker.

broken-noreturn / E6004

Message emitted:

'NoReturn' inside compound types is broken in 3.7.0 / 3.7.1

Description:

``typing.NoReturn`` inside compound types is broken in Python 3.7.0 and 3.7.1. If not dependent on runtime introspection, use string annotation instead. E.g. ``Callable[..., 'NoReturn']``. https://bugs.python.org/issue34921

Problematic code:

from typing import NoReturn, Union
def exploding_apple(apple) -> Union[None, NoReturn]:  # [broken-noreturn]
    print(f"{apple} is about to explode")

Correct code:

from typing import NoReturn
def exploding_apple(apple) -> NoReturn:
    print(f"{apple} is about to explode")
    raise Exception("{apple} exploded !")

Configuration file:

[main]
py-version=3.7
load-plugins=pylint.extensions.typing

NOTE:

Created by the typing checker.

catching-non-exception / E0712

Message emitted:

Catching an exception which doesn't inherit from Exception: %s

Description:

Used when a class which doesn't inherit from Exception is used as an exception in an except clause.

Problematic code:

class FooError:
    pass
try:
    1 / 0
except FooError:  # [catching-non-exception]
    pass

Correct code:

class FooError(Exception):
    pass
try:
    1 / 0
except FooError:
    pass

Created by the exceptions checker.

class-variable-slots-conflict / E0242

Message emitted:

Value %r in slots conflicts with class variable

Description:

Used when a value in __slots__ conflicts with a class variable, property or method.

Problematic code:

class Person:
    # +1: [class-variable-slots-conflict, class-variable-slots-conflict, class-variable-slots-conflict]
    __slots__ = ("age", "name", "say_hi")
    name = None
    def __init__(self, age, name):
        self.age = age
        self.name = name
    @property
    def age(self):
        return self.age
    def say_hi(self):
        print(f"Hi, I'm {self.name}.")

Correct code:

class Person:
    __slots__ = ("_age", "name")
    def __init__(self, age, name):
        self._age = age
        self.name = name
    @property
    def age(self):
        return self._age
    def say_hi(self):
        print(f"Hi, I'm {self.name}.")

Created by the classes checker.

continue-in-finally / E0116

Message emitted:

'continue' not supported inside 'finally' clause

Description:

Emitted when the `continue` keyword is found inside a finally clause, which is a SyntaxError.

Problematic code:

while True:
    try:
        pass
    finally:
        continue  # [continue-in-finally]

Correct code:

while True:
    try:
        pass
    except ValueError:
        pass
    else:
        continue

Configuration file:

[MAIN]
py-version=3.7

Additional details:

Note this message can't be emitted when using Python version 3.8 or greater.

Created by the basic checker.

declare-non-slot / E0245

Message emitted:

No such name %r in __slots__

Description:

Raised when a type annotation on a class is absent from the list of names in __slots__, and __slots__ does not contain a __dict__ entry.

Problematic code:

class Student:
    __slots__ = ("name",)
    name: str
    surname: str  # [declare-non-slot]

Correct code:

class Student:
    __slots__ = ("name", "surname")
    name: str
    surname: str

Created by the classes checker.

dict-iter-missing-items / E1141

Message emitted:

Unpacking a dictionary in iteration without calling .items()

Description:

Emitted when trying to iterate through a dict without calling .items()

Problematic code:

data = {"Paris": 2_165_423, "New York City": 8_804_190, "Tokyo": 13_988_129}
for city, population in data:  # [dict-iter-missing-items]
    print(f"{city} has population {population}.")

Correct code:

data = {"Paris": 2_165_423, "New York City": 8_804_190, "Tokyo": 13_988_129}
for city, population in data.items():
    print(f"{city} has population {population}.")

Created by the typecheck checker.

duplicate-argument-name / E0108

Message emitted:

Duplicate argument name %r in function definition

Description:

Duplicate argument names in function definitions are syntax errors.

Problematic code:

def get_fruits(apple, banana, apple):  # [duplicate-argument-name]
    pass

Correct code:

def get_fruits(apple, banana, orange):
    pass

Created by the basic checker.

duplicate-bases / E0241

Message emitted:

Duplicate bases for class %r

Description:

Duplicate use of base classes in derived classes raise TypeErrors.

Problematic code:

class Animal:
    pass
class Cat(Animal, Animal):  # [duplicate-bases]
    pass

Correct code:

class Animal:
    pass
class Bird(Animal):
    pass
class Cat(Animal):
    pass

Created by the classes checker.

format-needs-mapping / E1303

Message emitted:

Expected mapping for format string, not %s

Description:

Used when a format string that uses named conversion specifiers is used with an argument that is not a mapping.

Problematic code:

print("%(x)d %(y)d" % [1, 2])  # [format-needs-mapping]

Correct code:

print("%(x)d %(y)d" % {"x": 1, "y": 2})

Created by the string checker.

function-redefined / E0102

Message emitted:

%s already defined line %s

Description:

Used when a function / class / method is redefined.

Problematic code:

def get_email():
    pass
def get_email():  # [function-redefined]
    pass

Correct code:

def get_email():
    pass

Created by the basic checker.

inconsistent-mro / E0240

Message emitted:

Inconsistent method resolution order for class %r

Description:

Used when a class has an inconsistent method resolution order.

Problematic code:

class A:
    pass
class B(A):
    pass
class C(A, B):  # [inconsistent-mro]
    pass

Correct code:

class A:
    pass
class B(A):
    pass
class C(B):  # or 'B, A' or 'A' but not 'A, B'
    pass

Created by the classes checker.

inherit-non-class / E0239

Message emitted:

Inheriting %r, which is not a class.

Description:

Used when a class inherits from something which is not a class.

Problematic code:

class Fruit(bool):  # [inherit-non-class]
    pass

Correct code:

class Fruit:
    def __bool__(self):
        pass

Created by the classes checker.

init-is-generator / E0100

Message emitted:

__init__ method is a generator

Description:

Used when the special class method __init__ is turned into a generator by a yield in its body.

Problematic code:

class Fruit:
    def __init__(self, worms):  # [init-is-generator]
        yield from worms
apple = Fruit(["Fahad", "Anisha", "Tabatha"])

Correct code:

class Fruit:
    def __init__(self, worms):
        self.__worms = worms
    def worms(self):
        yield from self.__worms
apple = Fruit(["Fahad", "Anisha", "Tabatha"])
for worm in apple.worms():
    pass

Created by the basic checker.

invalid-all-format / E0605

Message emitted:

Invalid format for __all__, must be tuple or list

Description:

Used when __all__ has an invalid format.

Problematic code:

__all__ = "CONST"  # [invalid-all-format]
CONST = 42

Correct code:

__all__ = ("CONST",)
CONST = 42

Created by the variables checker.

invalid-all-object / E0604

Message emitted:

Invalid object %r in __all__, must contain only strings

Description:

Used when an invalid (non-string) object occurs in __all__.

Problematic code:

__all__ = (
    None,  # [invalid-all-object]
    Fruit,
    Worm,
)
class Fruit:
    pass
class Worm:
    pass

Correct code:

__all__ = ["Fruit", "Worm"]
class Fruit:
    pass
class Worm:
    pass

Additional details:

Related links:

Created by the variables checker.

invalid-bool-returned / E0304

Message emitted:

__bool__ does not return bool

Description:

Used when a __bool__ method returns something which is not a bool

Problematic code:

class CustomBool:
    """__bool__ returns an int"""
    def __bool__(self):  # [invalid-bool-returned]
        return 1

Correct code:

class CustomBool:
    """__bool__ returns `bool`"""
    def __bool__(self):
        return True

Created by the classes checker.

invalid-bytes-returned / E0308

Message emitted:

__bytes__ does not return bytes

Description:

Used when a __bytes__ method returns something which is not bytes

Problematic code:

class CustomBytes:
    """__bytes__ returns <type 'str'>"""
    def __bytes__(self):  # [invalid-bytes-returned]
        return "123"

Correct code:

class CustomBytes:
    """__bytes__ returns <type 'bytes'>"""
    def __bytes__(self):
        return b"some bytes"

Created by the classes checker.

invalid-character-backspace / E2510

Message emitted:

Invalid unescaped character backspace, use "\b" instead.

Description:

Moves the cursor back, so the character after it will overwrite the character before.

Problematic code:

STRING = "Invalid character backspace ?"  # [invalid-character-backspace]

Correct code:

STRING = "Valid character backspace \b"

Created by the unicode_checker checker.

invalid-character-carriage-return / E2511

Message emitted:

Invalid unescaped character carriage-return, use "\r" instead.

Description:

Moves the cursor to the start of line, subsequent characters overwrite the start of the line.

Correct code:

STRING = "Valid carriage return: \r"

Additional details:

This message exists because one of our checkers is very generic, but it's never going to raise during normal use as it's a syntax-error that would prevent the python ast (and thus pylint) from constructing a code representation of the file.

You could encounter it by feeding a properly constructed node directly to the checker.

Created by the unicode_checker checker.

invalid-character-esc / E2513

Message emitted:

Invalid unescaped character esc, use "\x1B" instead.

Description:

Commonly initiates escape codes which allow arbitrary control of the terminal.

Problematic code:

STRING = "Invalid escape character ?"  # [invalid-character-esc]

Correct code:

STRING = "Valid escape character \x1B"

Created by the unicode_checker checker.

invalid-character-nul / E2514

Message emitted:

Invalid unescaped character nul, use "\0" instead.

Description:

Mostly end of input for python.

Additional details:

There's no need to use end-of-string characters. String objects maintain their own length.

Related links:

Created by the unicode_checker checker.

invalid-character-sub / E2512

Message emitted:

Invalid unescaped character sub, use "\x1A" instead.

Description:

Ctrl+Z "End of text" on Windows. Some programs (such as type) ignore the rest of the file after it.

Problematic code:

STRING = "Invalid character sub ?"  # [invalid-character-sub]

Correct code:

STRING = "Valid character sub x1A"

Created by the unicode_checker checker.

invalid-character-zero-width-space / E2515

Message emitted:

Invalid unescaped character zero-width-space, use "\u200B" instead.

Description:

Invisible space character could hide real code execution.

Problematic code:

STRING = "Invalid character zero-width-space ​"  # [invalid-character-zero-width-space]

Correct code:

STRING = "Valid character zero-width-space u200B"

Created by the unicode_checker checker.

invalid-class-object / E0243

Message emitted:

Invalid assignment to '__class__'. Should be a class definition but got a '%s'

Description:

Used when an invalid object is assigned to a __class__ property. Only a class is permitted.

Problematic code:

class Apple:
    pass
Apple.__class__ = 1  # [invalid-class-object]

Correct code:

class Apple:
    pass
class RedDelicious:
    pass
Apple.__class__ = RedDelicious

Created by the classes checker.

invalid-enum-extension / E0244

Message emitted:

Extending inherited Enum class "%s"

Description:

Used when a class tries to extend an inherited Enum class. Doing so will raise a TypeError at runtime.

Problematic code:

from enum import Enum
class Color(Enum):
    ORANGE = 1
    CHERRY = 2
class Fruit(Color):  # [invalid-enum-extension]
    APPLE = 3

Correct code:

from enum import Enum
class Color(Enum):
    ORANGE = 1
    CHERRY = 2
class Fruit(Enum):
    ORANGE = 1
    CHERRY = 2
    APPLE = 3

Created by the classes checker.

invalid-envvar-value / E1507

Message emitted:

%s does not support %s type argument

Description:

Env manipulation functions support only string type arguments. See https://docs.python.org/3/library/os.html#os.getenv.

Problematic code:

import os
os.getenv(1)  # [invalid-envvar-value]

Correct code:

import os
os.getenv("1")

Created by the stdlib checker.

invalid-field-call / E3701

Message emitted:

Invalid usage of field(), %s

Description:

The dataclasses.field() specifier should only be used as the value of an assignment within a dataclass, or within the make_dataclass() function.

Problematic code:

from dataclasses import dataclass, field
@dataclass
class C:
    a: float
    b: float
    c: float
    field(init=False)  # [invalid-field-call]
    def __post_init__(self):
        self.c = self.a + self.b
print(field(init=False))  # [invalid-field-call]

Correct code:

from dataclasses import dataclass, field, make_dataclass
C = make_dataclass(
    "C",
    [("x", int), "y", ("z", int, field(default=5))],
    namespace={"add_one": lambda self: self.x + 1},
)
@dataclass
class C:
    a: float
    b: float
    c: float = field(init=False)
    def __post_init__(self):
        self.c = self.a + self.b

Created by the dataclass checker.

invalid-format-returned / E0311

Message emitted:

__format__ does not return str

Description:

Used when a __format__ method returns something which is not a string

Problematic code:

class CustomFormat:
    """__format__ returns <type 'int'>"""
    def __format__(self, format_spec):  # [invalid-format-returned]
        return 1

Correct code:

class CustomFormat:
    """__format__ returns <type 'str'>"""
    def __format__(self, format_spec):
        return "hello!"

Created by the classes checker.

invalid-getnewargs-ex-returned / E0313

Message emitted:

__getnewargs_ex__ does not return a tuple containing (tuple, dict)

Description:

Used when a __getnewargs_ex__ method returns something which is not of the form tuple(tuple, dict)

Problematic code:

class CustomGetNewArgsEx:
    """__getnewargs_ex__ returns tuple with incorrect arg length"""
    def __getnewargs_ex__(self):  # [invalid-getnewargs-ex-returned]
        return (tuple(1), dict(x="y"), 1)

Correct code:

class CustomGetNewArgsEx:
    """__getnewargs_ex__ returns <type 'tuple'>"""
    def __getnewargs_ex__(self):
        return ((1,), {"2": 2})

Created by the classes checker.

invalid-getnewargs-returned / E0312

Message emitted:

__getnewargs__ does not return a tuple

Description:

Used when a __getnewargs__ method returns something which is not a tuple

Problematic code:

class CustomGetNewArgs:
    """__getnewargs__ returns an integer"""
    def __getnewargs__(self):  # [invalid-getnewargs-returned]
        return 1

Correct code:

class CustomGetNewArgs:
    """__getnewargs__ returns <type 'tuple'>"""
    def __getnewargs__(self):
        return (1, 2)

Created by the classes checker.

invalid-hash-returned / E0309

Message emitted:

__hash__ does not return int

Description:

Used when a __hash__ method returns something which is not an integer

Problematic code:

class CustomHash:
    """__hash__ returns dict"""
    def __hash__(self):  # [invalid-hash-returned]
        return {}

Correct code:

class CustomHash:
    """__hash__ returns `int`"""
    def __hash__(self):
        return 19

Created by the classes checker.

invalid-index-returned / E0305

Message emitted:

__index__ does not return int

Description:

Used when an __index__ method returns something which is not an integer

Problematic code:

class CustomIndex:
    """__index__ returns a dict"""
    def __index__(self):  # [invalid-index-returned]
        return {"19": "19"}

Correct code:

class CustomIndex:
    """__index__ returns <type 'int'>"""
    def __index__(self):
        return 19

Created by the classes checker.

invalid-length-hint-returned / E0310

Message emitted:

__length_hint__ does not return non-negative integer

Description:

Used when a __length_hint__ method returns something which is not a non-negative integer

Problematic code:

class CustomLengthHint:
    """__length_hint__ returns non-int"""
    def __length_hint__(self):  # [invalid-length-hint-returned]
        return 3.0

Correct code:

class CustomLengthHint:
    """__length_hint__ returns <type 'int'>"""
    def __length_hint__(self):
        return 10

Created by the classes checker.

invalid-length-returned / E0303

Message emitted:

__len__ does not return non-negative integer

Description:

Used when a __len__ method returns something which is not a non-negative integer

Problematic code:

class FruitBasket:
    def __init__(self, fruits):
        self.fruits = ["Apple", "Banana", "Orange"]
    def __len__(self):  # [invalid-length-returned]
        return -len(self.fruits)

Correct code:

class FruitBasket:
    def __init__(self, fruits):
        self.fruits = ["Apple", "Banana", "Orange"]
    def __len__(self):
        return len(self.fruits)

Created by the classes checker.

invalid-metaclass / E1139

Message emitted:

Invalid metaclass %r used

Description:

Emitted whenever we can detect that a class is using, as a metaclass, something which might be invalid for using as a metaclass.

Problematic code:

class Apple(metaclass=int):  # [invalid-metaclass]
    pass

Correct code:

class Plant:
    pass
class Apple(Plant):
    pass

Created by the typecheck checker.

invalid-repr-returned / E0306

Message emitted:

__repr__ does not return str

Description:

Used when a __repr__ method returns something which is not a string

Problematic code:

class CustomRepr:
    """__repr__ returns <type 'int'>"""
    def __repr__(self):  # [invalid-repr-returned]
        return 1

Correct code:

class CustomRepr:
    """__repr__ returns <type 'str'>"""
    def __repr__(self):
        return "apples"

Created by the classes checker.

invalid-sequence-index / E1126

Message emitted:

Sequence index is not an int, slice, or instance with __index__

Description:

Used when a sequence type is indexed with an invalid type. Valid types are ints, slices, and objects with an __index__ method.

Problematic code:

fruits = ["apple", "banana", "orange"]
print(fruits["apple"])  # [invalid-sequence-index]

Correct code:

fruits = ["apple", "banana", "orange"]
print(fruits[0])

Additional details:

Be careful with [True] or [False] as sequence index, since True and False will respectively be evaluated as 1 and 0 and will bring the second element of the list and the first without erroring.

Created by the typecheck checker.

invalid-slice-index / E1127

Message emitted:

Slice index is not an int, None, or instance with __index__

Description:

Used when a slice index is not an integer, None, or an object with an __index__ method.

Problematic code:

LETTERS = ["a", "b", "c", "d"]
FIRST_THREE = LETTERS[:"3"]  # [invalid-slice-index]

Correct code:

LETTERS = ["a", "b", "c", "d"]
FIRST_THREE = LETTERS[:3]

Created by the typecheck checker.

invalid-slice-step / E1144

Message emitted:

Slice step cannot be 0

Description:

Used when a slice step is 0 and the object doesn't implement a custom __getitem__ method.

Problematic code:

LETTERS = ["a", "b", "c", "d"]
LETTERS[::0]  # [invalid-slice-step]

Correct code:

LETTERS = ["a", "b", "c", "d"]
LETTERS[::2]

Created by the typecheck checker.

invalid-slots / E0238

Message emitted:

Invalid __slots__ object

Description:

Used when an invalid __slots__ is found in class. Only a string, an iterable or a sequence is permitted.

Problematic code:

class Person:  # [invalid-slots]
    __slots__ = 42

Correct code:

class Person:
    __slots__ = ("name", "age")

Created by the classes checker.

invalid-slots-object / E0236

Message emitted:

Invalid object %r in __slots__, must contain only non empty strings

Description:

Used when an invalid (non-string) object occurs in __slots__.

Problematic code:

class Person:
    __slots__ = ("name", 3)  # [invalid-slots-object]

Correct code:

class Person:
    __slots__ = ("name", "surname")

Related links:

Created by the classes checker.

invalid-star-assignment-target / E0113

Message emitted:

Starred assignment target must be in a list or tuple

Description:

Emitted when a star expression is used as a starred assignment target.

Problematic code:

*fruit = ["apple", "banana", "orange"]  # [invalid-star-assignment-target]

Correct code:

fruit = ["apple", "banana", "orange"]

Created by the basic checker.

invalid-str-returned / E0307

Message emitted:

__str__ does not return str

Description:

Used when a __str__ method returns something which is not a string

Problematic code:

class CustomStr:
    """__str__ returns int"""
    def __str__(self):  # [invalid-str-returned]
        return 1

Correct code:

class CustomStr:
    """__str__ returns <type 'str'>"""
    def __str__(self):
        return "oranges"

Created by the classes checker.

invalid-unary-operand-type / E1130

Message emitted:

%s

Description:

Emitted when a unary operand is used on an object which does not support this type of operation.

Problematic code:

cherries = 10
eaten_cherries = int
cherries = -eaten_cherries  # [invalid-unary-operand-type]

Correct code:

cherries = 10
eaten_cherries = 2
cherries -= eaten_cherries

Created by the typecheck checker.

invalid-unicode-codec / E2501

Message emitted:

UTF-16 and UTF-32 aren't backward compatible. Use UTF-8 instead

Description:

For compatibility use UTF-8 instead of UTF-16/UTF-32. See also https://bugs.python.org/issue1503789 for a history of this issue. And https://softwareengineering.stackexchange.com/questions/102205/ for some possible problems when using UTF-16 for instance.

Additional details:

This message is a placeholder for a potential future issue with unicode codecs.

Created by the unicode_checker checker.

logging-format-truncated / E1201

Message emitted:

Logging format string ends in middle of conversion specifier

Description:

Used when a logging statement format string terminates before the end of a conversion specifier.

Problematic code:

import logging
import sys
logging.warning("Python version: %", sys.version)  # [logging-format-truncated]

Correct code:

import logging
import sys
logging.warning("Python version: %s", sys.version)

Created by the logging checker.

logging-too-few-args / E1206

Message emitted:

Not enough arguments for logging format string

Description:

Used when a logging format string is given too few arguments.

Problematic code:

import logging
try:
    function()
except Exception as e:
    logging.error("%s error occurred: %s", e)  # [logging-too-few-args]
    raise

Correct code:

import logging
try:
    function()
except Exception as e:
    logging.error("%s error occurred: %s", type(e), e)
    raise

Created by the logging checker.

logging-too-many-args / E1205

Message emitted:

Too many arguments for logging format string

Description:

Used when a logging format string is given too many arguments.

Problematic code:

import logging
try:
    function()
except Exception as e:
    logging.error("Error occurred: %s", type(e), e)  # [logging-too-many-args]
    raise

Correct code:

import logging
try:
    function()
except Exception as e:
    logging.error("%s error occurred: %s", type(e), e)
    raise

Created by the logging checker.

logging-unsupported-format / E1200

Message emitted:

Unsupported logging format character %r (%#02x) at index %d

Description:

Used when an unsupported format character is used in a logging statement format string.

Problematic code:

import logging
logging.info("%s %y !", "Hello", "World")  # [logging-unsupported-format]

Correct code:

import logging
logging.info("%s %s !", "Hello", "World")

Created by the logging checker.

method-hidden / E0202

Message emitted:

An attribute defined in %s line %s hides this method

Description:

Used when a class defines a method which is hidden by an instance attribute from an ancestor class or set by some client code.

Problematic code:

class Fruit:
    def __init__(self, vitamins):
        self.vitamins = vitamins
    def vitamins(self):  # [method-hidden]
        pass

Correct code:

class Fruit:
    def __init__(self, vitamins):
        self.vitamins = vitamins
    def antioxidants(self):
        pass

Created by the classes checker.

misplaced-bare-raise / E0704

Message emitted:

The raise statement is not inside an except clause

Description:

Used when a bare raise is not used inside an except clause. This generates an error, since there are no active exceptions to be reraised. An exception to this rule is represented by a bare raise inside a finally clause, which might work, as long as an exception is raised inside the try block, but it is nevertheless a code smell that must not be relied upon.

Problematic code:

def validate_positive(x):
    if x <= 0:
        raise  # [misplaced-bare-raise]

Correct code:

def validate_positive(x):
    if x <= 0:
        raise ValueError(f"{x} is not positive")

Created by the exceptions checker.

misplaced-format-function / E0119

Message emitted:

format function is not called on str

Description:

Emitted when format function is not called on str object. e.g doing print("value: {}").format(123) instead of print("value: {}".format(123)). This might not be what the user intended to do.

Problematic code:

print("Value: {}").format("Car")  # [misplaced-format-function]

Correct code:

print("Value: {}".format("Car"))

Created by the basic checker.

missing-format-string-key / E1304

Message emitted:

Missing key %r in format string dictionary

Description:

Used when a format string that uses named conversion specifiers is used with a dictionary that doesn't contain all the keys required by the format string.

Problematic code:

# +1: [missing-format-string-key]
fruit_prices = """
Apple: %(apple_price)d ¤
Orange: %(orange_price)d ¤
""" % {
    "apple_price": 42
}

Correct code:

fruit_prices = """
Apple: %(apple_price)d ¤
Orange: %(orange_price)d ¤
""" % {
    "apple_price": 42,
    "orange_price": 87,
}

Created by the string checker.

missing-kwoa / E1125

Message emitted:

Missing mandatory keyword argument %r in %s call

Description:

Used when a function call does not pass a mandatory keyword-only argument.

Problematic code:

def target(pos, *, keyword):
    return pos + keyword
def not_forwarding_kwargs(*args, **kwargs):
    target(*args)  # [missing-kwoa]

Correct code:

def target(pos, *, keyword):
    return pos + keyword
def not_forwarding_kwargs(*args, **kwargs):
    target(*args, **kwargs)

Created by the typecheck checker.

mixed-format-string / E1302

Message emitted:

Mixing named and unnamed conversion specifiers in format string

Description:

Used when a format string contains both named (e.g. '%(foo)d') and unnamed (e.g. '%d') conversion specifiers. This is also used when a named conversion specifier contains * for the minimum field width and/or precision.

Problematic code:

print("x=%(x)d, y=%d" % (0, 1))  # [mixed-format-string]

Correct code:

only_named.py:

print("x=%(x)d, y=%(y)d" % {"x": 0, "y": 1})

only_ordered.py:

print("x=%d, y=%d" % (0, 1))

Created by the string checker.

modified-iterating-dict / E4702

Message emitted:

Iterated dict '%s' is being modified inside for loop body, iterate through a copy of it instead.

Description:

Emitted when items are added or removed to a dict being iterated through. Doing so raises a RuntimeError.

Problematic code:

fruits = {"apple": 1, "orange": 2, "mango": 3}
i = 0
for fruit in fruits:
    fruits["apple"] = i  # [modified-iterating-dict]
    i += 1

Correct code:

fruits = {"apple": 1, "orange": 2, "mango": 3}
i = 0
for fruit in fruits.copy():
    fruits["apple"] = i
    i += 1

Created by the modified_iteration checker.

modified-iterating-set / E4703

Message emitted:

Iterated set '%s' is being modified inside for loop body, iterate through a copy of it instead.

Description:

Emitted when items are added or removed to a set being iterated through. Doing so raises a RuntimeError.

Problematic code:

fruits = {"apple", "orange", "mango"}
for fruit in fruits:
    fruits.add(fruit + "yum")  # [modified-iterating-set]

Correct code:

fruits = {"apple", "orange", "mango"}
for fruit in fruits.copy():
    fruits.add(fruit + "yum")

Created by the modified_iteration checker.

no-member / E1101

Message emitted:

%s %r has no %r member%s

Description:

Used when a variable is accessed for a nonexistent member.

Problematic code:

from pathlib import Path
directories = Path(".").mothers  # [no-member]
class Cat:
    def meow(self):
        print("Meow")
Cat().roar()  # [no-member]

Correct code:

from pathlib import Path
directories = Path(".").parents
class Cat:
    def meow(self):
        print("Meow")
Cat().meow()

Additional details:

If you are getting the dreaded no-member error, there is a possibility that either:

Linting C extension modules is not supported out of the box, especially since pylint has no way to get an AST object out of the extension module.

But pylint actually has a mechanism which you might use in case you want to analyze C extensions. Pylint has a flag, called extension-pkg-allow-list (formerly extension-pkg-whitelist), through which you can tell it to import that module and to build an AST from that imported module:

$ pylint --extension-pkg-allow-list=your_c_extension

Be aware though that using this flag means that extensions are loaded into the active Python interpreter and may run arbitrary code, which you may not want. This is the reason why we disable by default loading C extensions. In case you do not want the hassle of passing C extensions module with this flag all the time, you can enable unsafe-load-any-extension in your configuration file, which will build AST objects from all the C extensions that pylint encounters:

$ pylint --unsafe-load-any-extension=y

Alternatively, since pylint emits a separate error for attributes that cannot be found in C extensions, c-extension-no-member, you can disable this error for your project.

If something is generated dynamically, pylint won't be able to understand the code from your library (c-extension or not). You can then specify generated attributes with the generated-members option. For example if cv2.LINE_AA and sphinx.generated_member create false positives for no-member, you can do:

$ pylint --generated-member=cv2.LINE_AA,sphinx.generated_member

Created by the typecheck checker.

no-method-argument / E0211

Message emitted:

Method %r has no argument

Description:

Used when a method which should have the bound instance as first argument has no argument defined.

Problematic code:

class Person:
    def print_greeting():  # [no-method-argument]
        print("hello")

Correct code:

class Person:
    def print_greeting(self):
        print("hello")

Created by the classes checker.

no-name-in-module / E0611

Message emitted:

No name %r in module %r

Description:

Used when a name cannot be found in a module.

Problematic code:

from os import pizza  # [no-name-in-module]

Correct code:

from os import path

Created by the variables checker.

no-self-argument / E0213

Message emitted:

Method %r should have "self" as first argument

Description:

Used when a method has an attribute different the "self" as first argument. This is considered as an error since this is a so common convention that you shouldn't break it!

Problematic code:

class Fruit:
    def __init__(this, name):  # [no-self-argument]
        this.name = name

Correct code:

class Fruit:
    def __init__(self, name):
        self.name = name

Created by the classes checker.

no-value-for-parameter / E1120

Message emitted:

No value for argument %s in %s call

Description:

Used when a function call passes too few arguments.

Problematic code:

def add(x, y):
    return x + y
add(1)  # [no-value-for-parameter]

Correct code:

def add(x, y):
    return x + y
add(1, 2)

Created by the typecheck checker.

non-iterator-returned / E0301

Message emitted:

__iter__ returns non-iterator

Description:

Used when an __iter__ method returns something which is not an iterable (i.e. has no `__next__` method)

Problematic code:

import random
class GenericAstrology:
    def __init__(self, signs, predictions):
        self.signs = signs
        self.predictions = predictions
    def __iter__(self):  # [non-iterator-returned]
        self.index = 0
        self.number_of_prediction = len(self.predictions)
        return self
SIGNS = ["Aries", "Taurus", "Gemini", "Cancer", "Leo", "Virgo", "Libra"]
PREDICTIONS = ["good things", "bad thing", "existential dread"]
for sign, prediction in GenericAstrology(SIGNS, PREDICTIONS):
    print(f"{sign} : {prediction} today")

Correct code:

import random
class GenericAstrology:
    def __init__(self, signs, predictions):
        self.signs = signs
        self.predictions = predictions
    def __iter__(self):
        self.index = 0
        self.number_of_prediction = len(self.predictions)
        return self
    def __next__(self):
        if self.index == len(self.signs):
            raise StopIteration
        self.index += 1
        prediction_index = random.randint(0, self.number_of_prediction - 1)
        return self.signs[self.index - 1], self.predictions[prediction_index]
SIGNS = ["Aries", "Taurus", "Gemini", "Cancer", "Leo", "Virgo", "Libra"]
PREDICTIONS = ["good things", "bad thing", "existential dread"]
for sign, prediction in GenericAstrology(SIGNS, PREDICTIONS):
    print(f"{sign} : {prediction} today")

Created by the classes checker.

nonexistent-operator / E0107

Message emitted:

Use of the non-existent %s operator

Description:

Used when you attempt to use the C-style pre-increment or pre-decrement operator -- and ++, which doesn't exist in Python.

Problematic code:

i = 0
while i <= 10:
    print(i)
    ++i  # [nonexistent-operator]

Correct code:

i = 0
while i <= 10:
    print(i)
    i += 1

Created by the basic checker.

nonlocal-and-global / E0115

Message emitted:

Name %r is nonlocal and global

Description:

Emitted when a name is both nonlocal and global.

Problematic code:

NUMBER = 42
def update_number(number):  # [nonlocal-and-global]
    global NUMBER
    nonlocal NUMBER
    NUMBER = number
    print(f"New global number is: {NUMBER}")
update_number(24)

Correct code:

NUMBER = 42
def update_number(number):
    global NUMBER
    NUMBER = number
    print(f"New global number is: {NUMBER}")
update_number(24)

Created by the basic checker.

nonlocal-without-binding / E0117

Message emitted:

nonlocal name %s found without binding

Description:

Emitted when a nonlocal variable does not have an attached name somewhere in the parent scopes

Problematic code:

class Fruit:
    def get_color(self):
        nonlocal colors  # [nonlocal-without-binding]

Correct code:

class Fruit:
    colors = ["red", "green"]
    def get_color(self):
        nonlocal colors

Created by the basic checker.

not-a-mapping / E1134

Message emitted:

Non-mapping value %s is used in a mapping context

Description:

Used when a non-mapping value is used in place where mapping is expected

Problematic code:

def print_colors(**colors):
    print(colors)
print_colors(**list("red", "black"))  # [not-a-mapping]

Correct code:

def print_colors(**colors):
    print(colors)
print_colors(**dict(red=1, black=2))

Created by the typecheck checker.

not-an-iterable / E1133

Message emitted:

Non-iterable value %s is used in an iterating context

Description:

Used when a non-iterable value is used in place where iterable is expected

Problematic code:

for i in 10:  # [not-an-iterable]
    pass

Correct code:

for i in "10":
    pass

Created by the typecheck checker.

not-async-context-manager / E1701

Message emitted:

Async context manager '%s' doesn't implement __aenter__ and __aexit__.

Description:

Used when an async context manager is used with an object that does not implement the async context management protocol.

Problematic code:

class ContextManager:
    def __enter__(self):
        pass
    def __exit__(self, *exc):
        pass
async def foo():
    async with ContextManager():  # [not-async-context-manager]
        pass

Correct code:

class AsyncContextManager:
    def __aenter__(self):
        pass
    def __aexit__(self, *exc):
        pass
async def foo():
    async with AsyncContextManager():
        pass

Additional details:

Async context manager doesn't implement __aenter__ and __aexit__. It can't be emitted when using Python < 3.5.

Created by the async checker.

not-callable / E1102

Message emitted:

%s is not callable

Description:

Used when an object being called has been inferred to a non callable object.

Problematic code:

NUMBER = 42
print(NUMBER())  # [not-callable]

Correct code:

NUMBER = 42
print(NUMBER)

Created by the typecheck checker.

not-context-manager / E1129

Message emitted:

Context manager '%s' doesn't implement __enter__ and __exit__.

Description:

Used when an instance in a with statement doesn't implement the context manager protocol(__enter__/__exit__).

Problematic code:

class MyContextManager:
    def __enter__(self):
        pass
with MyContextManager() as c:  # [not-context-manager]
    pass

Correct code:

class MyContextManager:
    def __enter__(self):
        pass
    def __exit__(self, *exc):
        pass
with MyContextManager() as c:
    pass

Created by the typecheck checker.

not-in-loop / E0103

Message emitted:

%r not properly in loop

Description:

Used when break or continue keywords are used outside a loop.

Problematic code:

def print_even_numbers():
    for i in range(100):
        if i % 2 == 0:
            print(i)
    else:
        continue  # [not-in-loop]

Correct code:

def print_even_numbers():
    for i in range(100):
        if i % 2:
            continue
        print(i)

Created by the basic checker.

notimplemented-raised / E0711

Message emitted:

NotImplemented raised - should raise NotImplementedError

Description:

Used when NotImplemented is raised instead of NotImplementedError

Problematic code:

class Worm:
    def bore(self):
        raise NotImplemented  # [notimplemented-raised]

Correct code:

class Worm:
    def bore(self):
        raise NotImplementedError

Created by the exceptions checker.

positional-only-arguments-expected / E3102

Message emitted:

`%s()` got some positional-only arguments passed as keyword arguments: %s

Description:

Emitted when positional-only arguments have been passed as keyword arguments. Remove the keywords for the affected arguments in the function call.

Problematic code:

def cube(n, /):
    """Takes in a number n, returns the cube of n"""
    return n**3
cube(n=2)  # [positional-only-arguments-expected]

Correct code:

def cube(n, /):
    """Takes in a number n, returns the cube of n"""
    return n**3
cube(2)

Related links:

Created by the method_args checker.

possibly-used-before-assignment / E0606

Message emitted:

Possibly using variable %r before assignment

Description:

Emitted when a local variable is accessed before its assignment took place in both branches of an if/else switch.

Problematic code:

def check_lunchbox(items: list[str]):
    if not items:
        empty = True
    print(empty)  # [possibly-used-before-assignment]

Correct code:

def check_lunchbox(items: list[str]):
    empty = False
    if not items:
        empty = True
    print(empty)

Additional details:

You can use assert_never to mark exhaustive choices:

from typing import assert_never
def handle_date_suffix(suffix):
    if suffix == "d":
        ...
    elif suffix == "m":
        ...
    elif suffix == "y":
        ...
    else:
        assert_never(suffix)
if suffix in "dmy":
    handle_date_suffix(suffix)

Or, instead of assert_never(), you can call a function with a return annotation of Never or NoReturn. Unlike in the general case, where by design pylint ignores type annotations and does its own static analysis, here, pylint treats these special annotations like a disable comment.

Pylint currently allows repeating the same test like this, even though this lets some error cases through, as pylint does not assess the intervening code:

if guarded():
    var = 1
# what if code here affects the result of guarded()?
if guarded():
    print(var)

But this exception is limited to the repeating the exact same test. This warns:

if guarded():
    var = 1
if guarded() or other_condition:
    print(var)  # [possibly-used-before-assignment]

If you find this surprising, consider that pylint, as a static analysis tool, does not know if guarded() is deterministic or talks to a database. For constants (e.g. guarded versus guarded()), this is less of an issue, so in this case, possibly-used-before-assignment acts more like a future-proofing style preference than an error, per se.

Created by the variables checker.

potential-index-error / E0643

Message emitted:

Invalid index for iterable length

Description:

Emitted when an index used on an iterable goes beyond the length of that iterable.

Problematic code:

print([1, 2, 3][3])  # [potential-index-error]

Correct code:

print([1, 2, 3][2])

Created by the variables checker.

raising-bad-type / E0702

Message emitted:

Raising %s while only classes or instances are allowed

Description:

Used when something which is neither a class nor an instance is raised (i.e. a `TypeError` will be raised).

Problematic code:

class FasterThanTheSpeedOfLightError(ZeroDivisionError):
    def __init__(self):
        super().__init__("You can't go faster than the speed of light !")
def calculate_speed(distance: float, time: float) -> float:
    try:
        return distance / time
    except ZeroDivisionError as e:
        raise None  # [raising-bad-type]

Correct code:

class FasterThanTheSpeedOfLightError(ZeroDivisionError):
    def __init__(self):
        super().__init__("You can't go faster than the speed of light !")
def calculate_speed(distance: float, time: float) -> float:
    try:
        return distance / time
    except ZeroDivisionError as e:
        raise FasterThanTheSpeedOfLightError() from e

Created by the exceptions checker.

raising-non-exception / E0710

Message emitted:

Raising a class which doesn't inherit from BaseException

Description:

Used when a class which doesn't inherit from BaseException is raised.

Problematic code:

raise str  # [raising-non-exception]

Correct code:

raise Exception("Goodbye world !")

Created by the exceptions checker.

redundant-keyword-arg / E1124

Message emitted:

Argument %r passed by position and keyword in %s call

Description:

Used when a function call would result in assigning multiple values to a function parameter, one value from a positional argument and one from a keyword argument.

Problematic code:

def square(x):
    return x * x
square(5, x=4)  # [redundant-keyword-arg]

Correct code:

only_arg.py:

def square(x):
    return x * x
square(5)

only_kwarg.py:

def square(x):
    return x * x
square(x=4)

Created by the typecheck checker.

relative-beyond-top-level / E0402

Message emitted:

Attempted relative import beyond top-level package

Description:

Used when a relative import tries to access too many levels in the current package.

Problematic code:

from ................antigravity import NGField  # [relative-beyond-top-level]

Correct code:

absolute_import.py:

from physic.antigravity import NGField

fix_the_relative_import.py:

# Right number of dots in the import: you needed 15 dots, not 16, duh.
# from ...............antigravity import NGField

Additional details:

Absolute imports were strongly preferred, historically. Relative imports allow you to reorganize packages without changing any code, but these days refactoring tools and IDEs allow you to do that at almost no cost anyway if the imports are explicit/absolute. Therefore, absolute imports are often still preferred over relative ones.

Related links:

Created by the imports checker.

repeated-keyword / E1132

Message emitted:

Got multiple values for keyword argument %r in function call

Description:

Emitted when a function call got multiple values for a keyword.

Problematic code:

def func(a, b, c):
    return a, b, c
func(1, 2, c=3, **{"c": 4})  # [repeated-keyword]
func(1, 2, **{"c": 3}, **{"c": 4})  # [repeated-keyword]

Correct code:

def func(a, b, c):
    return a, b, c
func(1, 2, c=3)

Created by the typecheck checker.

return-arg-in-generator / E0106

Message emitted:

Return with argument inside generator

Description:

Used when a "return" statement with an argument is found in a generator function or method (e.g. with some "yield" statements).

Correct code:

def yield_numbers():
    for number in range(10):
        yield number
        return "I am now allowed!"  # This was not allowed in Python 3.3 and earlier.

Additional details:

This is a message that isn't going to be raised for python > 3.3. It was raised for code like:

def interrogate_until_you_find_jack(pirates):
    for pirate in pirates:
        if pirate == "Captain Jack Sparrow":
            return "Arrr! We've found our captain!"
        yield pirate

Which is now valid and equivalent to the previously expected:

def interrogate_until_you_find_jack(pirates):
    for pirate in pirates:
        if pirate == "Captain Jack Sparrow":
            raise StopIteration("Arrr! We've found our captain!")
        yield pirate

Related links:

Created by the basic checker.

return-in-init / E0101

Message emitted:

Explicit return in __init__

Description:

Used when the special class method __init__ has an explicit return value.

Problematic code:

class Sum:
    def __init__(self, a, b):  # [return-in-init]
        return a + b

Correct code:

class Sum:
    def __init__(self, a, b) -> None:
        self.result = a + b

Related links:

Created by the basic checker.

return-outside-function / E0104

Message emitted:

Return outside function

Description:

Used when a "return" statement is found outside a function or method.

Problematic code:

return 42  # [return-outside-function]

Correct code:

def get_the_answer():
    return 42

Created by the basic checker.

singledispatch-method / E1519

Message emitted:

singledispatch decorator should not be used with methods, use singledispatchmethod instead.

Description:

singledispatch should decorate functions and not class/instance methods. Use singledispatchmethod for those cases.

Problematic code:

from functools import singledispatch
class Board:
    @singledispatch  # [singledispatch-method]
    def convert_position(self, position):
        pass
    @convert_position.register  # [singledispatch-method]
    def _(self, position: str) -> tuple:
        position_a, position_b = position.split(",")
        return (int(position_a), int(position_b))
    @convert_position.register  # [singledispatch-method]
    def _(self, position: tuple) -> str:
        return f"{position[0]},{position[1]}"

Correct code:

from functools import singledispatch
@singledispatch
def convert_position(position):
    print(position)
@convert_position.register
def _(position: str) -> tuple:
    position_a, position_b = position.split(",")
    return (int(position_a), int(position_b))
@convert_position.register
def _(position: tuple) -> str:
    return f"{position[0]},{position[1]}"

Created by the stdlib checker.

singledispatchmethod-function / E1520

Message emitted:

singledispatchmethod decorator should not be used with functions, use singledispatch instead.

Description:

singledispatchmethod should decorate class/instance methods and not functions. Use singledispatch for those cases.

Problematic code:

from functools import singledispatchmethod
@singledispatchmethod  # [singledispatchmethod-function]
def convert_position(position):
    print(position)
@convert_position.register  # [singledispatchmethod-function]
def _(position: str) -> tuple:
    position_a, position_b = position.split(",")
    return (int(position_a), int(position_b))
@convert_position.register  # [singledispatchmethod-function]
def _(position: tuple) -> str:
    return f"{position[0]},{position[1]}"

Correct code:

from functools import singledispatchmethod
class Board:
    @singledispatchmethod
    def convert_position(cls, position):
        pass
    @singledispatchmethod
    @classmethod
    def _(cls, position: str) -> tuple:
        position_a, position_b = position.split(",")
        return (int(position_a), int(position_b))
    @singledispatchmethod
    @classmethod
    def _(cls, position: tuple) -> str:
        return f"{position[0]},{position[1]}"

Created by the stdlib checker.

star-needs-assignment-target / E0114

Message emitted:

Can use starred expression only in assignment target

Description:

Emitted when a star expression is not used in an assignment target.

Problematic code:

stars = *["Sirius", "Arcturus", "Vega"]  # [star-needs-assignment-target]

Correct code:

sirius, *arcturus_and_vega = ["Sirius", "Arcturus", "Vega"]

Created by the basic checker.

syntax-error / E0001

Message emitted:

%s

Description:

Used when a syntax error is raised for a module.

Problematic code:

fruit_stock = {
    'apple': 42,
    'orange': 21  # [syntax-error]
    'banana': 12
}

Correct code:

fruit_stock = {"apple": 42, "orange": 21, "banana": 12}

Additional details:

The python's ast builtin module cannot parse your code if there's a syntax error, so if there's a syntax error other messages won't be available at all.

Related links:

Created by the main checker.

too-few-format-args / E1306

Message emitted:

Not enough arguments for format string

Description:

Used when a format string that uses unnamed conversion specifiers is given too few arguments

Problematic code:

print("Today is {0}, so tomorrow will be {1}".format("Monday"))  # [too-few-format-args]

Correct code:

print("Today is {0}, so tomorrow will be {1}".format("Monday", "Tuesday"))

Related links:

Created by the string checker.

too-many-format-args / E1305

Message emitted:

Too many arguments for format string

Description:

Used when a format string that uses unnamed conversion specifiers is given too many arguments.

Problematic code:

# +1: [too-many-format-args]
print("Today is {0}, so tomorrow will be {1}".format("Monday", "Tuesday", "Wednesday"))

Correct code:

print("Today is {0}, so tomorrow will be {1}".format("Monday", "Tuesday"))

Related links:

Created by the string checker.

too-many-function-args / E1121

Message emitted:

Too many positional arguments for %s call

Description:

Used when a function call passes too many positional arguments.

Problematic code:

class Fruit:
    def __init__(self, color):
        self.color = color
apple = Fruit("red", "apple", [1, 2, 3])  # [too-many-function-args]

Correct code:

class Fruit:
    def __init__(self, color, name):
        self.color = color
        self.name = name
apple = Fruit("red", "apple")

Created by the typecheck checker.

too-many-star-expressions / E0112

Message emitted:

More than one starred expression in assignment

Description:

Emitted when there are more than one starred expressions (`*x`) in an assignment. This is a SyntaxError.

Problematic code:

*stars, *constellations = ["Sirius", "Arcturus", "Vega"]  # [too-many-star-expressions]

Correct code:

*sirius_and_arcturus, vega = ["Sirius", "Arcturus", "Vega"]

Created by the basic checker.

truncated-format-string / E1301

Message emitted:

Format string ends in middle of conversion specifier

Description:

Used when a format string terminates before the end of a conversion specifier.

Problematic code:

PARG_2 = 1
print("strange format %2" % PARG_2)  # [truncated-format-string]

Correct code:

PARG_2 = 1
print(f"strange format {PARG_2}")

Created by the string checker.

undefined-all-variable / E0603

Message emitted:

Undefined variable name %r in __all__

Description:

Used when an undefined variable name is referenced in __all__.

Problematic code:

__all__ = ["get_fruit_colour"]  # [undefined-all-variable]
def get_fruit_color():
    pass

Correct code:

__all__ = ["get_fruit_color"]
def get_fruit_color():
    pass

Related links:

Created by the variables checker.

undefined-variable / E0602

Message emitted:

Undefined variable %r

Description:

Used when an undefined variable is accessed.

Problematic code:

print(number + 2)  # [undefined-variable]

Correct code:

number = 3
print(number + 2)

Created by the variables checker.

unexpected-keyword-arg / E1123

Message emitted:

Unexpected keyword argument %r in %s call

Description:

Used when a function call passes a keyword argument that doesn't correspond to one of the function's parameter names.

Problematic code:

def print_coordinates(x=0, y=0):
    print(f"{x=}, {y=}")
print_coordinates(x=1, y=2, z=3)  # [unexpected-keyword-arg]

Correct code:

def print_coordinates(x=0, y=0):
    print(f"{x=}, {y=}")
print_coordinates(x=1, y=2)

Created by the typecheck checker.

unexpected-special-method-signature / E0302

Message emitted:

The special method %r expects %s param(s), %d %s given

Description:

Emitted when a special method was defined with an invalid number of parameters. If it has too few or too many, it might not work at all.

Problematic code:

class ContextManager:
    def __enter__(self, context):  # [unexpected-special-method-signature]
        pass
    def __exit__(self, type):  # [unexpected-special-method-signature]
        pass

Correct code:

class ContextManager:
    def __enter__(self):
        pass
    def __exit__(self, type, value, traceback):
        pass

Created by the classes checker.

unhashable-member / E1143

Message emitted:

'%s' is unhashable and can't be used as a %s in a %s

Description:

Emitted when a dict key or set member is not hashable (i.e. doesn't define __hash__ method).

Problematic code:

# Print the number of apples:
print({"apple": 42}[["apple"]])  # [unhashable-member]

Correct code:

# Print the number of apples:
print({"apple": 42}["apple"])

Created by the typecheck checker.

unpacking-non-sequence / E0633

Message emitted:

Attempting to unpack a non-sequence%s

Description:

Used when something which is not a sequence is used in an unpack assignment

Problematic code:

a, b, c = 1  # [unpacking-non-sequence]

Correct code:

a, b, c = 1, 2, 3

Created by the variables checker.

unrecognized-inline-option / E0011

Message emitted:

Unrecognized file option %r

Description:

Used when an unknown inline option is encountered.

Problematic code:

# +1: [unrecognized-inline-option]
# pylint:applesoranges=1

Correct code:

# pylint: enable=too-many-public-methods

Created by the main checker.

unrecognized-option / E0015

Message emitted:

Unrecognized option found: %s

Description:

Used when we detect an option that we do not recognize.

Additional details:

One of your options is not recognized. There's nothing to change in your code, but your pylint configuration or the way you launch pylint needs to be modified.

For example, this message would be raised when invoking pylint with pylint --unknown-option=yes test.py. Or you might be launching pylint with the following toml configuration:

[tool.pylint]
jars = "10"

When the following should be used:

[tool.pylint]
jobs = "10"

This warning was released in pylint 2.14: bad options were silently failing before.

Created by the main checker.

unsubscriptable-object / E1136

Message emitted:

Value '%s' is unsubscriptable

Description:

Emitted when a subscripted value doesn't support subscription (i.e. doesn't define __getitem__ method or __class_getitem__ for a class).

Problematic code:

class Fruit:
    pass
Fruit()[1]  # [unsubscriptable-object]

Correct code:

class Fruit:
    def __init__(self):
        self.colors = ["red", "orange", "yellow"]
    def __getitem__(self, idx):
        return self.colors[idx]
Fruit()[1]

Created by the typecheck checker.

unsupported-assignment-operation / E1137

Message emitted:

%r does not support item assignment

Description:

Emitted when an object does not support item assignment (i.e. doesn't define __setitem__ method).

Problematic code:

def pick_fruits(fruits):
    for fruit in fruits:
        print(fruit)
pick_fruits(["apple"])[0] = "orange"  # [unsupported-assignment-operation]

Correct code:

def pick_fruits(fruits):
    for fruit in fruits:
        print(fruit)
    return []
pick_fruits(["apple"])[0] = "orange"

Created by the typecheck checker.

unsupported-binary-operation / E1131

Message emitted:

%s

Description:

Emitted when a binary arithmetic operation between two operands is not supported.

Problematic code:

drink = "water" | None  # [unsupported-binary-operation]
result = [] | None  # [unsupported-binary-operation]

Correct code:

masked = 0b111111 & 0b001100
result = 0xAEFF | 0x0B99

Configuration file:

[main]
py-version=3.9

Created by the typecheck checker.

unsupported-delete-operation / E1138

Message emitted:

%r does not support item deletion

Description:

Emitted when an object does not support item deletion (i.e. doesn't define __delitem__ method).

Problematic code:

FRUITS = ("apple", "orange", "berry")
del FRUITS[0]  # [unsupported-delete-operation]

Correct code:

FRUITS = ["apple", "orange", "berry"]
del FRUITS[0]

Created by the typecheck checker.

unsupported-membership-test / E1135

Message emitted:

Value '%s' doesn't support membership test

Description:

Emitted when an instance in membership test expression doesn't implement membership protocol (__contains__/__iter__/__getitem__).

Problematic code:

class Fruit:
    pass
apple = "apple" in Fruit()  # [unsupported-membership-test]

Correct code:

class Fruit:
    FRUITS = ["apple", "orange"]
    def __contains__(self, name):
        return name in self.FRUITS
apple = "apple" in Fruit()

Created by the typecheck checker.

used-before-assignment / E0601

Message emitted:

Using variable %r before assignment

Description:

Emitted when a local variable is accessed before its assignment took place. Assignments in try blocks are assumed not to have occurred when evaluating associated except/finally blocks. Assignments in except blocks are assumed not to have occurred when evaluating statements outside the block, except when the associated try block contains a return statement.

Problematic code:

print(hello)  # [used-before-assignment]
hello = "Hello World !"

Correct code:

hello = "Hello World !"
print(hello)

Created by the variables checker.

used-prior-global-declaration / E0118

Message emitted:

Name %r is used prior to global declaration

Description:

Emitted when a name is used prior a global declaration, which results in an error since Python 3.6.

Problematic code:

TOMATO = "black cherry"
def update_tomato():
    print(TOMATO)  # [used-prior-global-declaration]
    global TOMATO
    TOMATO = "cherry tomato"

Correct code:

TOMATO = "black cherry"
def update_tomato():
    global TOMATO
    TOMATO = "moneymaker"

Created by the basic checker.

yield-inside-async-function / E1700

Message emitted:

Yield inside async function

Description:

Used when an `yield` or `yield from` statement is found inside an async function.

Problematic code:

async def foo():
    yield from [1, 2, 3]  # [yield-inside-async-function]

Correct code:

async def foo():
    def _inner_foo():
        yield from [1, 2, 3]
async def foo():
    yield 42

Additional details:

The message can't be emitted when using Python < 3.5.

Related links:

Created by the async checker.

yield-outside-function / E0105

Message emitted:

Yield outside function

Description:

Used when a "yield" statement is found outside a function or method.

Problematic code:

for i in range(10):
    yield i  # [yield-outside-function]

Correct code:

def one_to_ten():
    for i in range(10):
        yield i

Created by the basic checker.

All renamed messages in the error category:

bad-context-manager / E0235

'bad-context-manager' has been renamed. The new message can be found at:

bad-exception-context / E0703

'bad-exception-context' has been renamed. The new message can be found at:

bad-option-value / E0012

'bad-option-value' has been renamed. The new message can be found at:

useless-option-value / R0022

Message emitted:

Useless option value for '%s', %s

Description:

Used when a value for an option that is now deleted from pylint is encountered.

Problematic code:

"""'bad-continuation' was removed from pylint in https://github.com/pylint-dev/pylint/pull/3571"""
# pylint: disable=bad-continuation  # [useless-option-value]

Correct code:

"""'bad-continuation' was removed from pylint in https://github.com/pylint-dev/pylint/pull/3571"""

Additional details:

You can disable this check if you don't want to cleanup your configuration of old messages.

Created by the main checker.

unknown-option-value / W0012

Message emitted:

Unknown option value for '%s', expected a valid pylint message and got '%s'

Description:

Used when an unknown value is encountered for an option.

Problematic code:

# pylint: disable=missnig-docstring  # [unknown-option-value]

Correct code:

# pylint: disable=missing-docstring

Created by the main checker.

maybe-no-member / E1103

'maybe-no-member' has been renamed. The new message can be found at:

old-non-iterator-returned-2 / E0234

'old-non-iterator-returned-2' has been renamed. The new message can be found at:

old-unbalanced-tuple-unpacking / E0632

'old-unbalanced-tuple-unpacking' has been renamed. The new message can be found at:

unbalanced-tuple-unpacking / W0632

Message emitted:

Possible unbalanced tuple unpacking with sequence %s: left side has %d label%s, right side has %d value%s

Description:

Used when there is an unbalanced tuple unpacking in assignment

Problematic code:

fruits = ("orange", "apple", "strawberry", "peer")
orange, apple, strawberry = fruits  # [unbalanced-tuple-unpacking]

Correct code:

fruits = ("orange", "apple", "strawberry", "peer")
orange, apple, *remaining_fruits = fruits

Related links:

Created by the variables checker.

unhashable-dict-key / E1140

'unhashable-dict-key' has been renamed. The new message can be found at:

Warning

All messages in the warning category:

abstract-method / W0223

Message emitted:

Method %r is abstract in class %r but is not overridden in child class %r

Description:

Used when an abstract method (i.e. raise NotImplementedError) is not overridden in concrete class.

Problematic code:

abstract_method.py:

import abc
class WildAnimal:
    @abc.abstractmethod
    def make_sound(self):
        pass
class Panther(WildAnimal):  # [abstract-method]
    pass

function_raising_not_implemented_error.py:

class Pet:
    def make_sound(self):
        raise NotImplementedError
class Cat(Pet):  # [abstract-method]
    pass

Correct code:

abstract_method.py:

import abc
class WildAnimal:
    @abc.abstractmethod
    def make_sound(self):
        pass
class Panther(WildAnimal):
    def make_sound(self):
        print("MEEEOW")

function_raising_not_implemented_error.py:

class Pet:
    def make_sound(self):
        raise NotImplementedError
class Cat(Pet):
    def make_sound(self):
        print("Meeeow")

Created by the classes checker.

anomalous-backslash-in-string / W1401

Message emitted:

Anomalous backslash in string: '%s'. String constant might be missing an r prefix.

Description:

Used when a backslash is in a literal string but not as an escape.

Problematic code:

string = "\z"  # [syntax-error]

Correct code:

double_escape.py:

string = "\\z"

existing_escape_sequence.py:

string = "\t"

r_prefix.py:

string = r"\z"

Additional details:

\z is same as \\z because there's no escape sequence for z. But it is not clear for the reader of the code.

The only reason this is demonstrated to raise syntax-error is because pylint's CI now runs on Python 3.12, where this truly raises a SyntaxError. We hope to address this discrepancy in the documentation in the future.

Related links:

Created by the string checker.

anomalous-unicode-escape-in-string / W1402

Message emitted:

Anomalous Unicode escape in byte string: '%s'. String constant might be missing an r or u prefix.

Description:

Used when an escape like u is encountered in a byte string where it has no effect.

Problematic code:

print(b"\u%b" % b"0394")  # [syntax-error]

Correct code:

print(b"\\u%b" % b"0394")

Created by the string checker.

arguments-differ / W0221

Message emitted:

%s %s %r method

Description:

Used when a method has a different number of arguments than in the implemented interface or in an overridden method. Extra arguments with default values are ignored.

Problematic code:

class Drink:
    def mix(self, fluid_one, fluid_two):
        return fluid_one + fluid_two
class Cocktail(Drink):
    def mix(self, fluid_one, fluid_two, alcoholic_fluid):  # [arguments-differ]
        return fluid_one + fluid_two + alcoholic_fluid

Correct code:

add_option_in_base_class.py:

"""
Here we assume that drink and cocktail are the same thing and should actually
inherit from each over. We also assume that 'Drink' are 'Cocktail' without
alcohol (we added the alcohol option in the base class).
This permit to not have to modify the cocktails calls downstream but the case where
an alcohol is mixed in a soft drink will need to be handled.
"""
class Drink:
    def mix(self, fluid_one, fluid_two, alcoholic_fluid=None):
        # if alcoholic_fluid is not None:
        #     raise Exception(f"This soft drink has {alcoholic_fluid} in it !")
        return fluid_one + fluid_two
class Cocktail(Drink):
    def mix(self, fluid_one, fluid_two, alcoholic_fluid):
        return fluid_one + fluid_two + alcoholic_fluid

default_value.py:

"""
Here we assume that drink and cocktail are the same thing and should actually
inherit from each over. We also assume that any Cocktail can be treated like
a Drink (if you add beer to it).
This permit to not have to modify the calls downstream and causes the least
amount of disturbance at the cost of making cocktails beer-based implicitly.
"""
class Drink:
    def mix(self, fluid_one, fluid_two):
        return fluid_one + fluid_two
class Cocktail(Drink):
    def mix(self, fluid_one, fluid_two, alcoholic_fluid="Beer"):
        return fluid_one + fluid_two + alcoholic_fluid

no_inheritance.py:

"""
Here we assume that 'Drink' and 'Cocktail' are different things and should
not be treated together like if they were the same thing.
This will force some downstream changes and force the API user to make a
conscious decision about the alcoholic content of its drink when using the
API. For example, it's impossible to create a mojito with beer without
explicitly wanting to, or to add an alcohol to a soft-drink.
"""
class Drink:
    def mix(self, fluid_one, fluid_two):
        return fluid_one + fluid_two
class Cocktail:
    def mix(self, fluid_one, fluid_two, alcoholic_fluid):
        return fluid_one + fluid_two + alcoholic_fluid

Additional details:

argument-differ denotes an issue with the Liskov Substitution Principle. This means that the code in question violates an important design principle which does not have one single solution. We recommend to search online for the best solution in your case.

To give some examples of potential solutions:

Related links:

Created by the classes checker.

arguments-out-of-order / W1114

Message emitted:

Positional arguments appear to be out of order

Description:

Emitted when the caller's argument names fully match the parameter names in the function signature but do not have the same order.

Problematic code:

def function_3_args(first_argument, second_argument, third_argument):
    """Three arguments function"""
    return first_argument, second_argument, third_argument
def args_out_of_order():
    first_argument = 1
    second_argument = 2
    third_argument = 3
    function_3_args(  # [arguments-out-of-order]
        first_argument, third_argument, second_argument
    )

Correct code:

def function_3_args(first_argument, second_argument, third_argument):
    """Three arguments function"""
    return first_argument, second_argument, third_argument
def args_out_of_order():
    first_argument = 1
    second_argument = 2
    third_argument = 3
    function_3_args(first_argument, second_argument, third_argument)

Created by the typecheck checker.

arguments-renamed / W0237

Message emitted:

%s %s %r method

Description:

Used when a method parameter has a different name than in the implemented interface or in an overridden method.

Problematic code:

class Fruit:
    def brew(self, ingredient_name: str):
        print(f"Brewing a {type(self)} with {ingredient_name}")
class Apple(Fruit): ...
class Orange(Fruit):
    def brew(self, flavor: str):  # [arguments-renamed]
        print(f"Brewing an orange with {flavor}")
for fruit, ingredient_name in [[Orange(), "thyme"], [Apple(), "cinnamon"]]:
    fruit.brew(ingredient_name=ingredient_name)

Correct code:

class Fruit:
    def brew(self, ingredient_name: str):
        print(f"Brewing a {type(self)} with {ingredient_name}")
class Apple(Fruit): ...
class Orange(Fruit):
    def brew(self, ingredient_name: str):
        print(f"Brewing an orange with {ingredient_name}")
for fruit, ingredient_name in [[Orange(), "thyme"], [Apple(), "cinnamon"]]:
    fruit.brew(ingredient_name=ingredient_name)

Created by the classes checker.

assert-on-string-literal / W0129

Message emitted:

Assert statement has a string literal as its first argument. The assert will %s fail.

Description:

Used when an assert statement has a string literal as its first argument, which will cause the assert to always pass.

Problematic code:

def test_division():
    a = 9 / 3
    assert "No ZeroDivisionError were raised"  # [assert-on-string-literal]

Correct code:

def test_division():
    a = 9 / 3
    assert a == 3

Additional details:

Directly asserting a string literal will always pass. The solution is to test something that could fail, or not assert at all.

For unittest assertions there is the similar redundant-unittest-assert / W1503 message.

Related links:

Created by the basic checker.

assert-on-tuple / W0199

Message emitted:

Assert called on a populated tuple. Did you mean 'assert x,y'?

Description:

A call of assert on a tuple will always evaluate to true if the tuple is not empty, and will always evaluate to false if it is.

Problematic code:

assert (1, None)  # [assert-on-tuple]

Correct code:

x, y = (1, None)
assert x
assert y

Additional details:

Created by the basic checker.

attribute-defined-outside-init / W0201

Message emitted:

Attribute %r defined outside __init__

Description:

Used when an instance attribute is defined outside the __init__ method.

Problematic code:

class Student:
    def register(self):
        self.is_registered = True  # [attribute-defined-outside-init]

Correct code:

class Student:
    def __init__(self):
        self.is_registered = False
    def register(self):
        self.is_registered = True

Created by the classes checker.

bad-builtin / W0141

Message emitted:

Used builtin function %s

Description:

Used when a disallowed builtin function is used (see the bad-function option). Usual disallowed functions are the ones like map, or filter , where Python offers now some cleaner alternative like list comprehension.

Problematic code:

numbers = list(map(lambda x: 2 * x, [1, 2, 3]))  # [bad-builtin]
print(numbers)

Correct code:

numbers = [2 * x for x in [1, 2, 3]]
print(numbers)

Configuration file:

[MAIN]
load-plugins = pylint.extensions.bad_builtin

NOTE:

Created by the deprecated_builtins checker.

bad-chained-comparison / W3601

Message emitted:

Suspicious %s-part chained comparison using semantically incompatible operators (%s)

Description:

Used when there is a chained comparison where one expression is part of two comparisons that belong to different semantic groups ("<" does not mean the same thing as "is", chaining them in "0 < x is None" is probably a mistake).

Problematic code:

parrot.py:

shop = {
    # animal: (specie, descriptions)
    "parrot": ("Norvegian blue", ("restin'", "remarkable", "beautiful plumage")),
}
if "parrot" in shop is "restin'":  # [bad-chained-comparison]
    print("Hellooooo, Pooolllllyyy ! WAAAAKEEY, WAKKEEEY !")

xor.py:

def xor_check(*, left=None, right=None):
    if left is None != right is None:  # [bad-chained-comparison]
        raise ValueError(
            "Either both left= and right= need to be provided or none should."
        )

Correct code:

parrot.py:

shop = {
    # animal: (specie, descriptions)
    "parrot": ("Norvegian blue", ("restin'", "remarkable", "beautiful plumage")),
}
if "parrot" in shop and "restin'" in shop["parrot"][1]:
    print("Hellooooo, Pooolllllyyy ! WAAAAKEEY, WAKKEEEY !")

xor.py:

def xor_check(*, left=None, right=None):
    if (left is None) != (right is None):
        raise ValueError(
            "Either both left= and right= need to be provided or none should."
        )

Related links:

Created by the bad-chained-comparison checker.

bad-dunder-name / W3201

Message emitted:

Bad or misspelled dunder method name %s.

Description:

Used when a dunder method is misspelled or defined with a name not within the predefined list of dunder names.

Problematic code:

class Apples:
    def _init_(self):  # [bad-dunder-name]
        pass
    def __hello__(self):  # [bad-dunder-name]
        print("hello")

Correct code:

class Apples:
    def __init__(self):
        pass
    def hello(self):
        print("hello")

Configuration file:

[MAIN]
load-plugins=pylint.extensions.dunder

NOTE:

Created by the dunder checker.

bad-format-string / W1302

Message emitted:

Invalid format string

Description:

Used when a PEP 3101 format string is invalid.

Problematic code:

print("{a[0] + a[1]}".format(a=[0, 1]))  # [bad-format-string]

Correct code:

print("{a[0]} + {a[1]}".format(a=[0, 1]))

Related links:

Created by the string checker.

bad-format-string-key / W1300

Message emitted:

Format string dictionary key should be a string, not %s

Description:

Used when a format string that uses named conversion specifiers is used with a dictionary whose keys are not all strings.

Problematic code:

print("%(one)d" % {"one": 1, 2: 2})  # [bad-format-string-key]

Correct code:

print("%(one)d, %(two)d" % {"one": 1, "two": 2})

Additional details:

This check only works for old-style string formatting using the '%' operator.

This check only works if the dictionary with the values to be formatted is defined inline. Passing a variable will not trigger the check as the other keys in this dictionary may be used in other contexts, while an inline defined dictionary is clearly only intended to hold the values that should be formatted.

Created by the string checker.

bad-indentation / W0311

Message emitted:

Bad indentation. Found %s %s, expected %s

Description:

Used when an unexpected number of indentation's tabulations or spaces has been found.

Problematic code:

if input():
   print('yes')  # [bad-indentation]

Correct code:

if input():
    print("yes")

Additional details:

The option --indent-string can be used to set the indentation unit for this check.

Created by the format checker.

bad-open-mode / W1501

Message emitted:

"%s" is not a valid mode for open.

Description:

Python supports: r, w, a[, x] modes with b, +, and U (only with r) options. See https://docs.python.org/3/library/functions.html#open

Problematic code:

def open_and_get_content(file_path):
    with open(file_path, "rwx") as file:  # [bad-open-mode]
        return file.read()

Correct code:

def open_and_get_content(file_path):
    with open(file_path, "r") as file:
        return file.read()

Created by the stdlib checker.

bad-staticmethod-argument / W0211

Message emitted:

Static method with %r as first argument

Description:

Used when a static method has "self" or a value specified in valid-classmethod-first-arg option or valid-metaclass-classmethod-first-arg option as first argument.

Problematic code:

class Wolf:
    @staticmethod
    def eat(self):  # [bad-staticmethod-argument]
        pass

Correct code:

class Wolf:
    @staticmethod
    def eat(sheep):
        pass

Created by the classes checker.

bad-thread-instantiation / W1506

Message emitted:

threading.Thread needs the target function

Description:

The warning is emitted when a threading.Thread class is instantiated without the target function being passed as a kwarg or as a second argument. By default, the first parameter is the group param, not the target param.

Problematic code:

import threading
def thread_target(n):
    print(n**2)
thread = threading.Thread(lambda: None)  # [bad-thread-instantiation]
thread.start()

Correct code:

import threading
def thread_target(n):
    print(n**2)
thread = threading.Thread(target=thread_target, args=(10,))
thread.start()

Created by the stdlib checker.

bare-except / W0702

Message emitted:

No exception type(s) specified

Description:

A bare ``except:`` clause will catch ``SystemExit`` and ``KeyboardInterrupt`` exceptions, making it harder to interrupt a program with ``Control-C``, and can disguise other problems. If you want to catch all exceptions that signal program errors, use ``except Exception:`` (bare except is equivalent to ``except BaseException:``).

Problematic code:

try:
    import platform_specific_module
except:  # [bare-except]
    platform_specific_module = None

Correct code:

try:
    import platform_specific_module
except ImportError:
    platform_specific_module = None

Additional details:

A good rule of thumb is to limit use of bare ‘except’ clauses to two cases: - If the exception handler will be printing out or logging the traceback; at least the user will be aware that an error has occurred. - If the code needs to do some cleanup work, but then lets the exception propagate upwards with raise. try...finally can be a better way to handle this case.

Related links:

Created by the exceptions checker.

binary-op-exception / W0711

Message emitted:

Exception to catch is the result of a binary "%s" operation

Description:

Used when the exception to catch is of the form "except A or B:". If intending to catch multiple, rewrite as "except (A, B):"

Problematic code:

try:
    1 / 0
except ZeroDivisionError or ValueError:  # [binary-op-exception]
    pass

Correct code:

try:
    1 / 0
except (ZeroDivisionError, ValueError):
    pass

Created by the exceptions checker.

boolean-datetime / W1502

Message emitted:

Using datetime.time in a boolean context.

Description:

Using datetime.time in a boolean context can hide subtle bugs when the time they represent matches midnight UTC. This behaviour was fixed in Python 3.5. See https://bugs.python.org/issue13936 for reference.

Problematic code:

import datetime
if datetime.time():  # [boolean-datetime]
    print("It is time.")
if datetime.datetime.now().time():  # [boolean-datetime]
    print("Now or never.")

Correct code:

import datetime
time_now_utc = datetime.datetime.now(tz=datetime.UTC).time()
if time_now_utc > datetime.time(6, 0):
    print("Daytime!")
if time_now_utc < datetime.time(6, 0):
    print("Nighttime!")

Configuration file:

[main]
py-version=3.4

Related links:

Created by the stdlib checker.

broad-exception-caught / W0718

Message emitted:

Catching too general exception %s

Description:

If you use a naked ``except Exception:`` clause, you might end up catching exceptions other than the ones you expect to catch. This can hide bugs or make it harder to debug programs when unrelated errors are hidden.

Problematic code:

try:
    import platform_specific_module
except Exception:  # [broad-exception-caught]
    platform_specific_module = None

Correct code:

try:
    import platform_specific_module
except ImportError:
    platform_specific_module = None

Additional details:

For example, you're trying to import a library with required system dependencies and you catch everything instead of only import errors, you will miss the error message telling you, that your code could work if you had installed the system dependencies.

Related links:

Created by the exceptions checker.

broad-exception-raised / W0719

Message emitted:

Raising too general exception: %s

Description:

Raising exceptions that are too generic force you to catch exceptions generically too. It will force you to use a naked ``except Exception:`` clause. You might then end up catching exceptions other than the ones you expect to catch. This can hide bugs or make it harder to debug programs when unrelated errors are hidden.

Problematic code:

def small_apple(apple, length):
    if len(apple) < length:
        raise Exception("Apple is too small!")  # [broad-exception-raised]
    print(f"{apple} is proper size.")

Correct code:

def small_apple(apple, length):
    if len(apple) < length:
        raise ValueError("Apple is too small!")
    print(f"{apple} is proper size.")

Related links:

Created by the exceptions checker.

cell-var-from-loop / W0640

Message emitted:

Cell variable %s defined in loop

Description:

A variable used in a closure is defined in a loop. This will result in all closures using the same value for the closed-over variable.

Problematic code:

def teacher_greeting(names):
    greetings = []
    for name in names:
        def greet():
            # do something
            print(f"Hello, {name}!")  # [cell-var-from-loop]
        if name.isalpha():
            greetings.append(greet)
    for greet in greetings:
        # the "name" variable is evaluated when the function is called here,
        # which is the last value it had in the loop - "Not-A-Name"
        greet()
teacher_greeting(["Graham", "John", "Terry", "Eric", "Terry", "Michael"])
# "Hello, Michael!"
# "Hello, Michael!"
# "Hello, Michael!"
# "Hello, Michael!"
# "Hello, Michael!"

Correct code:

functools.partial.py:

import functools
def teacher_greeting(names):
    greetings = []
    for name in names:
        if name.isalpha():
            # "name" is evaluated when the partial is created here, so this
            # does not do lazy evaluation
            greetings.append(functools.partial(print, f"Hello, {name}!"))
    for greet in greetings:
        # `partial`s are called like functions, but you've already passed the
        # arguments to them
        greet()
teacher_greeting(["Graham", "John", "Terry", "Eric", "Terry", "Michael"])
# "Hello, Graham!"
# "Hello, John!"
# "Hello, Eric!"
# "Hello, Terry!"
# "Hello, Michael!"

new_function.py:

def teacher_greeting(names):
    def greet(name):
        # do something
        print(f"Hello, {name}!")
    for name in names:
        if name.isalpha():
            # we're passing the value of "name" to the function here
            greet(name)
teacher_greeting(["Graham", "John", "Terry", "Eric", "Terry", "Michael"])
# "Hello, Graham!"
# "Hello, John!"
# "Hello, Eric!"
# "Hello, Terry!"
# "Hello, Michael!"

Related links:

Created by the variables checker.

comparison-with-callable / W0143

Message emitted:

Comparing against a callable, did you omit the parenthesis?

Description:

This message is emitted when pylint detects that a comparison with a callable was made, which might suggest that some parenthesis were omitted, resulting in potential unwanted behaviour.

Problematic code:

def function_returning_a_fruit() -> str:
    return "orange"
def is_an_orange(fruit: str = "apple"):
    # apple == <function function_returning_a_fruit at 0x7f343ff0a1f0>
    return fruit == function_returning_a_fruit  # [comparison-with-callable]

Correct code:

def function_returning_a_fruit() -> str:
    return "orange"
def is_an_orange(fruit: str = "apple"):
    # apple == orange
    return fruit == function_returning_a_fruit()

Created by the basic checker.

confusing-with-statement / W0124

Message emitted:

Following "as" with another context manager looks like a tuple.

Description:

Emitted when a `with` statement component returns multiple values and uses name binding with `as` only for a part of those values, as in with ctx() as a, b. This can be misleading, since it's not clear if the context manager returns a tuple or if the node without a name binding is another context manager.

Problematic code:

with open("file.txt", "w") as fh1, fh2:  # [confusing-with-statement]
    pass

Correct code:

with open("file.txt", "w", encoding="utf8") as fh1:
    with open("file.txt", "w", encoding="utf8") as fh2:
        pass

Created by the basic checker.

consider-ternary-expression / W0160

Message emitted:

Consider rewriting as a ternary expression

Description:

Multiple assign statements spread across if/else blocks can be rewritten with a single assignment and ternary expression

Problematic code:

x, y = input(), input()
if x >= y:  # [consider-ternary-expression]
    maximum = x
else:
    maximum = y

Correct code:

x, y = input(), input()
maximum = x if x >= y else y

Configuration file:

[MAIN]
load-plugins=pylint.extensions.consider_ternary_expression

NOTE:

Created by the consider_ternary_expression checker.

contextmanager-generator-missing-cleanup / W0135

Message emitted:

The context used in function %r will not be exited.

Description:

Used when a contextmanager is used inside a generator function and the cleanup is not handled.

Problematic code:

import contextlib
@contextlib.contextmanager
def cm():
    contextvar = "acquired context"
    print("cm enter")
    yield contextvar
    print("cm exit")
def genfunc_with_cm():
    with cm() as context:  # [contextmanager-generator-missing-cleanup]
        yield context * 2

Correct code:

import contextlib
@contextlib.contextmanager
def good_cm_except():
    contextvar = "acquired context"
    print("good cm enter")
    try:
        yield contextvar
    except GeneratorExit:
        print("good cm exit")
def genfunc_with_cm():
    with good_cm_except() as context:
        yield context * 2
def genfunc_with_discard():
    with good_cm_except():
        yield "discarded"
@contextlib.contextmanager
def good_cm_yield_none():
    print("good cm enter")
    yield
    print("good cm exit")
def genfunc_with_none_yield():
    with good_cm_yield_none() as var:
        print(var)
        yield "constant yield"
@contextlib.contextmanager
def good_cm_finally():
    contextvar = "acquired context"
    print("good cm enter")
    try:
        yield contextvar
    finally:
        print("good cm exit")
def good_cm_finally_genfunc():
    with good_cm_finally() as context:
        yield context * 2
@contextlib.contextmanager
def good_cm_no_cleanup():
    contextvar = "acquired context"
    print("cm enter")
    yield contextvar
def good_cm_no_cleanup_genfunc():
    with good_cm_no_cleanup() as context:
        yield context * 2

Additional details:

Instantiating and using a contextmanager inside a generator function can result in unexpected behavior if there is an expectation that the context is only available for the generator function. In the case that the generator is not closed or destroyed then the context manager is held suspended as is.

This message warns on the generator function instead of the contextmanager function because the ways to use a contextmanager are many. A contextmanager can be used as a decorator (which immediately has __enter__/__exit__ applied) and the use of as ... or discard of the return value also implies whether the context needs cleanup or not. So for this message, warning the invoker of the contextmanager is important.

The check can create false positives if yield is used inside an if-else block without custom cleanup. Use pylint: disable for these.

from contextlib import contextmanager
@contextmanager
def good_cm_no_cleanup():
    contextvar = "acquired context"
    print("cm enter")
    if some_condition:
        yield contextvar
    else:
        yield contextvar
def good_cm_no_cleanup_genfunc():
    # pylint: disable-next=contextmanager-generator-missing-cleanup
    with good_cm_no_cleanup() as context:
        yield context * 2

Related links:

Created by the basic checker.

dangerous-default-value / W0102

Message emitted:

Dangerous default value %s as argument

Description:

Used when a mutable value as list or dictionary is detected in a default value for an argument.

Problematic code:

def whats_on_the_telly(penguin=[]):  # [dangerous-default-value]
    penguin.append("property of the zoo")
    return penguin

Correct code:

def whats_on_the_telly(penguin=None):
    if penguin is None:
        penguin = []
    penguin.append("property of the zoo")
    return penguin

Additional details:

With a mutable default value, with each call the default value is modified, i.e.:

whats_on_the_telly() # ["property of the zoo"]
whats_on_the_telly() # ["property of the zoo", "property of the zoo"]
whats_on_the_telly() # ["property of the zoo", "property of the zoo", "property of the zoo"]

Created by the basic checker.

deprecated-argument / W4903

Message emitted:

Using deprecated argument %s of method %s()

Description:

The argument is marked as deprecated and will be removed in the future.

Problematic code:

int(x=1)  # [deprecated-argument]

Correct code:

int(1)

Configuration file:

Additional details:

The actual replacement needs to be studied on a case by case basis by reading the deprecation warning or the release notes.

Created by the stdlib checker.

deprecated-attribute / W4906

Message emitted:

Using deprecated attribute %r

Description:

The attribute is marked as deprecated and will be removed in the future.

Problematic code:

from configparser import ParsingError
err = ParsingError("filename")
source = err.filename  # [deprecated-attribute]

Correct code:

from configparser import ParsingError
err = ParsingError("filename")
source = err.source

Additional details:

The actual replacement needs to be studied on a case by case basis by reading the deprecation warning or the release notes.

Created by the stdlib checker.

deprecated-class / W4904

Message emitted:

Using deprecated class %s of module %s

Description:

The class is marked as deprecated and will be removed in the future.

Problematic code:

from collections import Iterable  # [deprecated-class]

Correct code:

from collections.abc import Iterable

Additional details:

The actual replacement needs to be studied on a case by case basis by reading the deprecation warning or the release notes.

Created by the stdlib checker.

deprecated-decorator / W4905

Message emitted:

Using deprecated decorator %s()

Description:

The decorator is marked as deprecated and will be removed in the future.

Problematic code:

import abc
class Animal:
    @abc.abstractclassmethod  # [deprecated-decorator]
    def breath(cls):
        pass

Correct code:

import abc
class Animal:
    @abc.classmethod
    @abc.abstractmethod
    def breath(cls):
        pass

Configuration file:

[main]
py-version = 3.3

Additional details:

The actual replacement needs to be studied on a case by case basis by reading the deprecation warning or the release notes.

Created by the stdlib checker.

deprecated-method / W4902

Message emitted:

Using deprecated method %s()

Description:

The method is marked as deprecated and will be removed in the future.

Problematic code:

import logging
logging.warn("I'm coming, world !")  # [deprecated-method]

Correct code:

import logging
logging.warning("I'm coming, world !")

Additional details:

The actual replacement needs to be studied on a case by case basis by reading the deprecation warning or the release notes.

Created by the stdlib checker.

deprecated-module / W4901

Message emitted:

Deprecated module %r

Description:

A module marked as deprecated is imported.

Problematic code:

import distutils  # [deprecated-module]
import whatever_you_want  # [deprecated-module]

Correct code:

import setuptools
import whatever_replacement_you_want

Configuration file:

[main]
py-version=3.7
deprecated-modules=whatever_you_want

Additional details:

The actual replacement needs to be studied on a case by case basis by reading the deprecation warning or the release notes.

Created by the imports checker.

deprecated-typing-alias / W6001

Message emitted:

'%s' is deprecated, use '%s' instead

Description:

Emitted when a deprecated typing alias is used.

Problematic code:

import typing
item_to_number_of_item: typing.Dict[str, int]  # [deprecated-typing-alias]

Correct code:

item_to_number_of_item: dict[str, int]

Configuration file:

[main]
load-plugins = pylint.extensions.typing

NOTE:

Created by the typing checker.

differing-param-doc / W9017

Message emitted:

"%s" differing in parameter documentation

Description:

Please check parameter names in declarations.

Problematic code:

def add(x, y):  # [differing-param-doc]
    """Add two numbers.
    :param int x: x value.
    :param int z: z value.
    """
    return x + y

Correct code:

def add(x, y):
    """Add two numbers.
    :param int x: x value.
    :param int y: y value.
    """
    return x + y

Configuration file:

[MAIN]
load-plugins = pylint.extensions.docparams

NOTE:

Created by the parameter_documentation checker.

differing-type-doc / W9018

Message emitted:

"%s" differing in parameter type documentation

Description:

Please check parameter names in type declarations.

Problematic code:

def add(x: int, y: int):  # [differing-type-doc]
    """Add two numbers.
    :param int xy: x value.
    :param str y: y value.
    """
    return x + y

Correct code:

def add(x, y):
    """Add two numbers.
    :param int x: x value.
    :param int y: y value.
    """
    return x + y

Configuration file:

[MAIN]
load-plugins = pylint.extensions.docparams

NOTE:

Created by the parameter_documentation checker.

duplicate-except / W0705

Message emitted:

Catching previously caught exception type %s

Description:

Used when an except catches a type that was already caught by a previous handler.

Problematic code:

try:
    1 / 0
except ZeroDivisionError:
    pass
except ZeroDivisionError:  # [duplicate-except]
    pass

Correct code:

try:
    1 / 0
except ZeroDivisionError:
    pass

Created by the exceptions checker.

duplicate-key / W0109

Message emitted:

Duplicate key %r in dictionary

Description:

Used when a dictionary expression binds the same key multiple times.

Problematic code:

test_score = {"Mathematics": 85, "Biology": 90, "Mathematics": 75}  # [duplicate-key]

Correct code:

test_score = {"Mathematics": 85, "Biology": 90, "History": 75}

Related links:

Created by the basic checker.

duplicate-string-formatting-argument / W1308

Message emitted:

Duplicate string formatting argument %r, consider passing as named argument

Description:

Used when we detect that a string formatting is repeating an argument instead of using named string arguments

Problematic code:

# pylint: disable=missing-docstring, consider-using-f-string
SEE = "see 👀"
SEA = "sea 🌊"
# +1: [duplicate-string-formatting-argument,duplicate-string-formatting-argument]
CONST = """
A sailor went to {}, {}, {}
To {} what he could {}, {}, {}
But all that he could {}, {}, {}
Was the bottom of the deep blue {}, {}, {}!
""".format(
    SEA,
    SEA,
    SEA,
    SEE,
    SEE,
    SEE,
    SEE,
    SEE,
    SEE,
    SEE,
    SEA,
    SEA,
    SEA,
)

Correct code:

# pylint: disable=missing-docstring, consider-using-f-string
SEE = "see 👀"
SEA = "sea 🌊"
CONST = """
A sailor went to {sea}, {sea}, {sea}
To {see} what he could {see}, {see}, {see}
But all that he could {see}, {see}, {see}
Was the bottom of the deep blue {sea}, {sea}, {sea}!
""".format(
    sea=SEA, see=SEE
)

Created by the string checker.

duplicate-value / W0130

Message emitted:

Duplicate value %r in set

Description:

This message is emitted when a set contains the same value two or more times.

Problematic code:

incorrect_set = {"value1", 23, 5, "value1"}  # [duplicate-value]

Correct code:

correct_set = {"value1", 23, 5}

Created by the basic checker.

eq-without-hash / W1641

Message emitted:

Implementing __eq__ without also implementing __hash__

Description:

Used when a class implements __eq__ but not __hash__. Objects get None as their default __hash__ implementation if they also implement __eq__.

Problematic code:

class Fruit:  # [eq-without-hash]
    def __init__(self) -> None:
        self.name = "apple"
    def __eq__(self, other: object) -> bool:
        return isinstance(other, Fruit) and other.name == self.name

Correct code:

class Fruit:
    def __init__(self) -> None:
        self.name = "apple"
    def __eq__(self, other: object) -> bool:
        return isinstance(other, Fruit) and other.name == self.name
    def __hash__(self) -> int:
        return hash(self.name)

Configuration file:

[MAIN]
load-plugins=pylint.extensions.eq_without_hash,

NOTE:

Created by the eq-without-hash checker.

eval-used / W0123

Message emitted:

Use of eval

Description:

Used when you use the "eval" function, to discourage its usage. Consider using `ast.literal_eval` for safely evaluating strings containing Python expressions from untrusted sources.

Problematic code:

eval("[1, 2, 3]")  # [eval-used]

Correct code:

from ast import literal_eval
literal_eval("[1, 2, 3]")

Created by the basic checker.

exec-used / W0122

Message emitted:

Use of exec

Description:

Raised when the 'exec' statement is used. It's dangerous to use this function for a user input, and it's also slower than actual code in general. This doesn't mean you should never use it, but you should consider alternatives first and restrict the functions available.

Problematic code:

username = "Ada"
code_to_execute = f"""input('Enter code to be executed please, {username}: ')"""
program = exec(code_to_execute)  # [exec-used]
exec(program)  # [exec-used]

Correct code:

def get_user_code(name):
    return input(f"Enter code to be executed please, {name}: ")
username = "Ada"
allowed_globals = {"__builtins__": None}
allowed_locals = {"print": print}
# pylint: disable-next=exec-used
exec(get_user_code(username), allowed_globals, allowed_locals)

Additional details:

The available methods and variables used in exec() may introduce a security hole. You can restrict the use of these variables and methods by passing optional globals and locals parameters (dictionaries) to the exec() method.

However, use of exec is still insecure. For example, consider the following call that writes a file to the user's system:

exec("""\nwith open("file.txt", "w", encoding="utf-8") as file:\n file.write("# code as nefarious as imaginable")\n""")

Related links:

Created by the basic checker.

expression-not-assigned / W0106

Message emitted:

Expression "%s" is assigned to nothing

Description:

Used when an expression that is not a function call is assigned to nothing. Probably something else was intended.

Problematic code:

str(42) == "42"  # [expression-not-assigned]

Correct code:

are_equal: bool = str(42) == "42"

Created by the basic checker.

f-string-without-interpolation / W1309

Message emitted:

Using an f-string that does not have any interpolated variables

Description:

Used when we detect an f-string that does not use any interpolation variables, in which case it can be either a normal string or a bug in the code.

Problematic code:

x = 1
y = 2
print(f"x + y = x + y")  # [f-string-without-interpolation]

Correct code:

x = 1
y = 2
print(f"{x} + {y} = {x + y}")

Created by the string checker.

fixme / W0511

Message emitted:

%s

Description:

Used when a warning note as FIXME or XXX is detected.

Problematic code:

# TODO: We should fix this at some point  # [fixme]

Correct code:

bug_tracker.py:

# The issue was added to the bug tracker: no longer need the comment

fixed.py:

# The issue was fixed: no longer need the comment

no_fix.py:

# We no longer want to fix this: no longer need the comment

Additional details:

You can use regular expressions and the notes-rgx option to create some constraints for this message. See the following issue for some examples.

Created by the miscellaneous checker.

forgotten-debug-statement / W1515

Message emitted:

Leaving functions creating breakpoints in production code is not recommended

Description:

Calls to breakpoint(), sys.breakpointhook() and pdb.set_trace() should be removed from code that is not actively being debugged.

Problematic code:

import pdb
def find_the_treasure(clues):
    for clue in clues:
        pdb.set_trace()  # [forgotten-debug-statement]
        if "treasure" in clue:
            return True
    return False
treasure_hunt = [
    "Dead Man's Chest",
    "X marks the spot",
    "The treasure is buried near the palm tree",
]
find_the_treasure(treasure_hunt)

Correct code:

def find_the_treasure(clues):
    for clue in clues:
        if "treasure" in clue:
            return True
    return False
treasure_hunt = [
    "Dead Man's Chest",
    "X marks the spot",
    "The treasure is buried near the palm tree",
]
find_the_treasure(treasure_hunt)

Created by the stdlib checker.

format-combined-specification / W1305

Message emitted:

Format string contains both automatic field numbering and manual field specification

Description:

Used when a PEP 3101 format string contains both automatic field numbering (e.g. '{}') and manual field specification (e.g. '{0}').

Problematic code:

print("{} {1}".format("hello", "world"))  # [format-combined-specification]

Correct code:

index_formatting.py:

print("{0} {1}".format("hello", "world"))

order_formatting.py:

print("{} {}".format("hello", "world"))

Created by the string checker.

format-string-without-interpolation / W1310

Message emitted:

Using formatting for a string that does not have any interpolated variables

Description:

Used when we detect a string that does not have any interpolation variables, in which case it can be either a normal string without formatting or a bug in the code.

Problematic code:

print("number".format(1))  # [format-string-without-interpolation]

Correct code:

print("number: {}".format(1))

Created by the string checker.

global-at-module-level / W0604

Message emitted:

Using the global statement at the module level

Description:

Used when you use the "global" statement at the module level since it has no effect.

Problematic code:

price = 25
global price  # [global-at-module-level]

Correct code:

price = 25

Related links:

Created by the variables checker.

global-statement / W0603

Message emitted:

Using the global statement

Description:

Used when you use the "global" statement to update a global variable. Pylint discourages its usage. That doesn't mean you cannot use it!

Problematic code:

var = 1
def foo():
    global var  # [global-statement]
    var = 10
    print(var)
foo()
print(var)

Correct code:

var = 1
def foo():
    print(var)
    return 10
var = foo()
print(var)

Created by the variables checker.

global-variable-not-assigned / W0602

Message emitted:

Using global for %r but no assignment is done

Description:

When a variable defined in the global scope is modified in an inner scope, the 'global' keyword is required in the inner scope only if there is an assignment operation done in the inner scope.

Problematic code:

TOMATO = "black cherry"
def update_tomato():
    global TOMATO  # [global-variable-not-assigned]
    print(TOMATO)

Correct code:

TOMATO = "black cherry"
def update_tomato():
    global TOMATO
    TOMATO = "moneymaker"

Created by the variables checker.

global-variable-undefined / W0601

Message emitted:

Global variable %r undefined at the module level

Description:

Used when a variable is defined through the "global" statement but the variable is not defined in the module scope.

Problematic code:

def update_tomato():
    global TOMATO  # [global-variable-undefined]
    TOMATO = "moneymaker"

Correct code:

TOMATO = "black cherry"
def update_tomato():
    global TOMATO
    TOMATO = "moneymaker"

Created by the variables checker.

implicit-flag-alias / W0213

Message emitted:

Flag member %(overlap)s shares bit positions with %(sources)s

Description:

Used when multiple integer values declared within an enum.IntFlag class share a common bit position.

Problematic code:

from enum import IntFlag
class FilePermissions(IntFlag):
    READ = 1
    WRITE = 2
    EXECUTE = 3  # [implicit-flag-alias]

Correct code:

from enum import IntFlag
class FilePermissions(IntFlag):
    READ = 1
    WRITE = 2
    EXECUTE = 4

Created by the classes checker.

implicit-str-concat / W1404

Message emitted:

Implicit string concatenation found in %s

Description:

String literals are implicitly concatenated in a literal iterable definition : maybe a comma is missing ?

Problematic code:

list.py:

x = ["a" "b"]  # [implicit-str-concat]

open.py:

with open("hello.txt" "r") as f:  # [implicit-str-concat]
    print(f.read())

Correct code:

list.py:

x = ["a", "b"]

open.py:

with open("hello.txt", "r") as f:
    print(f.read())

Additional details:

By default, detection of implicit string concatenation of line jumps is disabled. Hence the following code will not trigger this rule:

SEQ = ('a', 'b'
            'c')

In order to detect this case, you must enable check-str-concat-over-line-jumps:

[STRING_CONSTANT]
check-str-concat-over-line-jumps = true

However, the drawback of this setting is that it will trigger false positive for string parameters passed on multiple lines in function calls:

warnings.warn(
    "rotate() is deprecated and will be removed in a future release. "
    "Use the rotation() context manager instead.",
    DeprecationWarning,
    stacklevel=3,
)

No message will be emitted, though, if you clarify the wanted concatenation with parentheses:

warnings.warn(
    (
        "rotate() is deprecated and will be removed in a future release. "
        "Use the rotation() context manager instead."
    ),
    DeprecationWarning,
    stacklevel=3,
)

Created by the string checker.

import-self / W0406

Message emitted:

Module import itself

Description:

Used when a module is importing itself.

Additional details:

Say you have a file called my_file.py. import-self would be raised on the following code:

from my_file import a_function  # [import-self]
def a_function():
    pass

The solution would be to remove the import:

def a_function():
    pass

Created by the imports checker.

inconsistent-quotes / W1405

Message emitted:

Quote delimiter %s is inconsistent with the rest of the file

Description:

Quote delimiters are not used consistently throughout a module (with allowances made for avoiding unnecessary escaping).

Problematic code:

import datetime
print('Current year: ', datetime.date.today().strftime("%Y")) # [inconsistent-quotes]

Correct code:

import datetime
print("Current year: ", datetime.date.today().strftime("%Y"))

Configuration file:

[main]
check-quote-consistency=yes

Created by the string checker.

invalid-envvar-default / W1508

Message emitted:

%s default type is %s. Expected str or None.

Description:

Env manipulation functions return None or str values. Supplying anything different as a default may cause bugs. See https://docs.python.org/3/library/os.html#os.getenv.

Problematic code:

import os
env = os.getenv("SECRET_KEY", 1)  # [invalid-envvar-default]

Correct code:

import os
env = os.getenv("SECRET_KEY", "1")

Created by the stdlib checker.

invalid-format-index / W1307

Message emitted:

Using invalid lookup key %r in format specifier %r

Description:

Used when a PEP 3101 format string uses a lookup specifier ({a[1]}), but the argument passed for formatting doesn't contain or doesn't have that key as an attribute.

Problematic code:

not_enough_fruits = ["apple"]
print('The second fruit is a {fruits[1]}'.format(fruits=not_enough_fruits))  # [invalid-format-index]

Correct code:

enough_fruits = ["apple", "banana"]
print("The second fruit is a {fruits[1]}".format(fruits=enough_fruits))

Created by the string checker.

invalid-overridden-method / W0236

Message emitted:

Method %r was expected to be %r, found it instead as %r

Description:

Used when we detect that a method was overridden in a way that does not match its base class which could result in potential bugs at runtime.

Problematic code:

class Fruit:
    async def bore(self, insect):
        insect.eat(self)
class Apple(Fruit):
    def bore(self, insect):  # [invalid-overridden-method]
        insect.eat(self)

Correct code:

class Fruit:
    async def bore(self, insect):
        insect.eat(self)
class Apple(Fruit):
    async def bore(self, insect):
        insect.eat(self)

Created by the classes checker.

isinstance-second-argument-not-valid-type / W1116

Message emitted:

Second argument of isinstance is not a type

Description:

Emitted when the second argument of an isinstance call is not a type.

Problematic code:

isinstance("apples and oranges", hex)  # [isinstance-second-argument-not-valid-type]

Correct code:

isinstance("apples and oranges", str)

Created by the typecheck checker.

keyword-arg-before-vararg / W1113

Message emitted:

Keyword argument before variable positional arguments list in the definition of %s function

Description:

When defining a keyword argument before variable positional arguments, one can end up in having multiple values passed for the aforementioned parameter in case the method is called with keyword arguments.

Problematic code:

def func(x=None, *args):  # [keyword-arg-before-vararg]
    return [x, *args]

Correct code:

def func(*args, x=None):
    return [*args, x]

Created by the typecheck checker.

kwarg-superseded-by-positional-arg / W1117

Message emitted:

%r will be included in %r since a positional-only parameter with this name already exists

Description:

Emitted when a function is called with a keyword argument that has the same name as a positional-only parameter and the function contains a keyword variadic parameter dict.

Problematic code:

def print_name(name="Sarah", /, **kwds):
    print(name)
print_name(name="Jacob")  # [kwarg-superseded-by-positional-arg]
# Will print "Sarah"

Correct code:

def print_name(name="Sarah", /, **kwds):
    print(name)
print_name("Jacob")
# Will print "Jacob"

Created by the typecheck checker.

logging-format-interpolation / W1202

Message emitted:

Use %s formatting in logging functions

Description:

Used when a logging statement has a call form of "logging.<logging method>(format_string.format(format_args...))". Use another type of string formatting instead. You can use % formatting but leave interpolation to the logging function by passing the parameters as arguments. If logging-fstring-interpolation is disabled then you can use fstring formatting. If logging-not-lazy is disabled then you can use % formatting as normal.

Problematic code:

import logging
import sys
# +1: [logging-format-interpolation]
logging.error("Python version: {}".format(sys.version))

Correct code:

import logging
import sys
logging.error("Python version: %s", sys.version)

Additional details:

Another reasonable option is to use f-string. If you want to do that, you need to enable logging-format-interpolation and disable logging-fstring-interpolation.

Related links:

Created by the logging checker.

logging-fstring-interpolation / W1203

Message emitted:

Use %s formatting in logging functions

Description:

Used when a logging statement has a call form of "logging.<logging method>(f"...")".Use another type of string formatting instead. You can use % formatting but leave interpolation to the logging function by passing the parameters as arguments. If logging-format-interpolation is disabled then you can use str.format. If logging-not-lazy is disabled then you can use % formatting as normal.

Problematic code:

import logging
import sys
logging.error(f"Python version: {sys.version}")  # [logging-fstring-interpolation]

Correct code:

import logging
import sys
logging.error("Python version: %s", sys.version)

Additional details:

This message permits to allow f-string in logging and still be warned of logging-format-interpolation.

Related links:

Created by the logging checker.

logging-not-lazy / W1201

Message emitted:

Use %s formatting in logging functions

Description:

Used when a logging statement has a call form of "logging.<logging method>(format_string % (format_args...))". Use another type of string formatting instead. You can use % formatting but leave interpolation to the logging function by passing the parameters as arguments. If logging-fstring-interpolation is disabled then you can use fstring formatting. If logging-format-interpolation is disabled then you can use str.format.

Problematic code:

import logging
try:
    function()
except Exception as e:
    logging.error("Error occurred: %s" % e)  # [logging-not-lazy]
    raise

Correct code:

import logging
try:
    function()
except Exception as e:
    logging.error("Error occurred: %s", e)
    raise

Additional details:

Another reasonable option is to use f-strings. If you want to do that, you need to enable logging-not-lazy and disable logging-fstring-interpolation.

Related links:

Created by the logging checker.

lost-exception / W0150

Message emitted:

%s statement in finally block may swallow exception

Description:

Used when a break or a return statement is found inside the finally clause of a try...finally block: the exceptions raised in the try clause will be silently swallowed instead of being re-raised.

Problematic code:

class FasterThanTheSpeedOfLightError(ZeroDivisionError):
    def __init__(self):
        super().__init__("You can't go faster than the speed of light !")
def calculate_speed(distance: float, time: float) -> float:
    try:
        return distance / time
    except ZeroDivisionError as e:
        raise FasterThanTheSpeedOfLightError() from e
    finally:
        return 299792458  # [lost-exception]

Correct code:

class FasterThanTheSpeedOfLightError(ZeroDivisionError):
    def __init__(self):
        super().__init__("You can't go faster than the speed of light !")
def calculate_speed(distance: float, time: float) -> float:
    try:
        return distance / time
    except ZeroDivisionError as e:
        raise FasterThanTheSpeedOfLightError() from e

Created by the basic checker.

method-cache-max-size-none / W1518

Message emitted:

'lru_cache(maxsize=None)' or 'cache' will keep all method args alive indefinitely, including 'self'

Description:

By decorating a method with lru_cache or cache the 'self' argument will be linked to the function and therefore never garbage collected. Unless your instance will never need to be garbage collected (singleton) it is recommended to refactor code to avoid this pattern or add a maxsize to the cache. The default value for maxsize is 128.

Problematic code:

import functools
class Fibonnaci:
    def __init__(self):
        self.result = []
    @functools.lru_cache(maxsize=None)  # [method-cache-max-size-none]
    def fibonacci(self, n):
        if n in {0, 1}:
            self.result.append(n)
        self.result.append(self.fibonacci(n - 1) + self.fibonacci(n - 2))

Correct code:

import functools
@functools.cache
def cached_fibonacci(n):
    if n in {0, 1}:
        return n
    return cached_fibonacci(n - 1) + cached_fibonacci(n - 2)
class Fibonnaci:
    def __init__(self):
        self.result = []
    def fibonacci(self, n):
        self.result.append(cached_fibonacci(n))

Created by the stdlib checker.

misplaced-future / W0410

Message emitted:

__future__ import is not the first non docstring statement

Description:

Python 2.5 and greater require __future__ import to be the first non docstring statement in the module.

Problematic code:

import sys
from __future__ import print_function  # [misplaced-future]

Correct code:

from __future__ import print_function
import sys

Additional details:

A bare raise statement will re-raise the last active exception in the current scope. If the raise statement is not in an except or finally block, a RuntimeError will be raised instead.

Created by the imports checker.

missing-any-param-doc / W9021

Message emitted:

Missing any documentation in "%s"

Description:

Please add parameter and/or type documentation.

Problematic code:

def puppies(head, tail):  # [missing-any-param-doc]
    """Print puppy's details."""
    print(head, tail)

Correct code:

def puppies(head: str, tail: str):
    """Print puppy's details.
    :param head: description of the head of the dog
    :param tail: description of the tail of the dog
    """
    print(head, tail)

Configuration file:

[main]
load-plugins = pylint.extensions.docparams
accept-no-param-doc = false

NOTE:

Created by the parameter_documentation checker.

missing-format-argument-key / W1303

Message emitted:

Missing keyword argument %r for format string

Description:

Used when a PEP 3101 format string that uses named fields doesn't receive one or more required keywords.

Problematic code:

print("My name is {first} {last}".format(first="John"))  # [missing-format-argument-key]

Correct code:

print("My name is {first} {last}".format(first="John", last="Wick"))

Related links:

Created by the string checker.

missing-format-attribute / W1306

Message emitted:

Missing format attribute %r in format specifier %r

Description:

Used when a PEP 3101 format string uses an attribute specifier ({0.length}), but the argument passed for formatting doesn't have that attribute.

Problematic code:

print("{0.real}".format("1"))  # [missing-format-attribute]

Correct code:

print("{0.real}".format(1))

Created by the string checker.

missing-param-doc / W9015

Message emitted:

"%s" missing in parameter documentation

Description:

Please add parameter declarations for all parameters.

Problematic code:

def integer_sum(a: int, b):  # [missing-param-doc]
    """Returns sum of two integers
    :param a: first integer
    """
    return a + b

Correct code:

def integer_sum(a: int, b: int):
    """Returns sum of two integers
    :param a: first integer
    :param b: second integer
    """
    return a + b

Configuration file:

[MAIN]
load-plugins = pylint.extensions.docparams

NOTE:

Created by the parameter_documentation checker.

missing-parentheses-for-call-in-test / W0126

Message emitted:

Using a conditional statement with potentially wrong function or method call due to missing parentheses

Description:

Emitted when a conditional statement (If or ternary if) seems to wrongly call a function due to missing parentheses

Problematic code:

import random
def is_it_a_good_day():
    return random.choice([True, False])
if is_it_a_good_day:  # [missing-parentheses-for-call-in-test]
    print("Today is a good day!")

Correct code:

import random
def is_it_a_good_day():
    return random.choice([True, False])
if is_it_a_good_day():
    print("Today is a good day!")

Created by the basic checker.

missing-raises-doc / W9006

Message emitted:

"%s" not documented as being raised

Description:

Please document exceptions for all raised exception types.

Problematic code:

def integer_sum(a: int, b: int):  # [missing-raises-doc]
    """Returns sum of two integers
    :param a: first integer
    :param b: second integer
    """
    if not (isinstance(a, int) and isinstance(b, int)):
        raise ValueError("Function supports only integer parameters.")
    return a + b

Correct code:

def integer_sum(a: int, b: int):
    """Returns sum of two integers
    :param a: first integer
    :param b: second integer
    :raises ValueError: One of the parameters is not an integer.
    """
    if not (isinstance(a, int) and isinstance(b, int)):
        raise ValueError("Function supports only integer parameters.")
    return a + b

Configuration file:

[MAIN]
load-plugins = pylint.extensions.docparams
[BASIC]
accept-no-raise-doc = no

NOTE:

Created by the parameter_documentation checker.

missing-return-doc / W9011

Message emitted:

Missing return documentation

Description:

Please add documentation about what this method returns.

Problematic code:

def integer_sum(a: int, b: int):  # [missing-return-doc]
    """Returns sum of two integers
    :param a: first integer
    :param b: second integer
    """
    return a + b

Correct code:

def integer_sum(a: int, b: int) -> int:
    """Returns sum of two integers
    :param a: first integer
    :param b: second integer
    :return: sum of parameters a and b
    """
    return a + b

Configuration file:

[main]
load-plugins=pylint.extensions.docparams
[Parameter_documentation]
accept-no-return-doc=no

Additional details:

This message is raised only when parameter accept-no-return-doc is set to no.

NOTE:

Created by the parameter_documentation checker.

missing-return-type-doc / W9012

Message emitted:

Missing return type documentation

Description:

Please document the type returned by this method.

Problematic code:

def integer_sum(a: int, b: int):  # [missing-return-type-doc]
    """Returns sum of two integers
    :param a: first integer
    :param b: second integer
    :return: sum of parameters a and b
    """
    return a + b

Correct code:

def integer_sum(a: int, b: int) -> int:
    """Returns sum of two integers
    :param a: first integer
    :param b: second integer
    :return: sum of parameters a and b
    """
    return a + b

Configuration file:

[main]
load-plugins=pylint.extensions.docparams
[Parameter_documentation]
accept-no-return-doc=no

Additional details:

This message is raised only when parameter accept-no-return-doc is set to no.

NOTE:

Created by the parameter_documentation checker.

missing-timeout / W3101

Message emitted:

Missing timeout argument for method '%s' can cause your program to hang indefinitely

Description:

Used when a method needs a 'timeout' parameter in order to avoid waiting for a long time. If no timeout is specified explicitly the default value is used. For example for 'requests' the program will never time out (i.e. hang indefinitely).

Problematic code:

import requests
requests.post("http://localhost")  # [missing-timeout]

Correct code:

import requests
requests.post("http://localhost", timeout=10)

Additional details:

You can add new methods that should have a defined `timeout argument as qualified names in the timeout-methods option, for example:

Created by the method_args checker.

missing-type-doc / W9016

Message emitted:

"%s" missing in parameter type documentation

Description:

Please add parameter type declarations for all parameters.

Problematic code:

def integer_sum(a: int, b):  # [missing-type-doc]
    """Returns sum of two integers
    :param a: first integer
    :param b: second integer
    """
    return a + b

Correct code:

def integer_sum(a: int, b: int):
    """Returns sum of two integers
    :param a: first integer
    :param b: second integer
    """
    return a + b

Configuration file:

[MAIN]
load-plugins = pylint.extensions.docparams

NOTE:

Created by the parameter_documentation checker.

missing-yield-doc / W9013

Message emitted:

Missing yield documentation

Description:

Please add documentation about what this generator yields.

Problematic code:

def even_number_under(n: int):  # [missing-yield-doc]
    """Prints even numbers smaller than n.
    Args:
        n: Upper limit of even numbers.
    """
    for i in range(n):
        if i % 2 == 1:
            continue
        yield i

Correct code:

from typing import Iterator
def even_number_under(n: int) -> Iterator[int]:
    """Prints even numbers smaller than n.
    Args:
        n: Upper limit of even numbers.
    Yields:
        even numbers
    """
    for i in range(n):
        if i % 2 == 1:
            continue
        yield i

Configuration file:

[main]
load-plugins=pylint.extensions.docparams
[Parameter_documentation]
accept-no-yields-doc=no

Additional details:

This message is raised only when parameter accept-no-yields-doc is set to no.

NOTE:

Created by the parameter_documentation checker.

missing-yield-type-doc / W9014

Message emitted:

Missing yield type documentation

Description:

Please document the type yielded by this method.

Problematic code:

def even_number_under(n: int):  # [missing-yield-type-doc]
    """Prints even numbers smaller than n.
    Args:
        n: Upper limit of even numbers.
    Yields:
        even numbers
    """
    for i in range(n):
        if i % 2 == 1:
            continue
        yield i

Correct code:

from typing import Iterator
def even_number_under(n: int) -> Iterator[int]:
    """Prints even numbers smaller than n.
    Args:
        n: Upper limit of even numbers.
    Yields:
        even numbers
    """
    for i in range(n):
        if i % 2 == 1:
            continue
        yield i

Configuration file:

[main]
load-plugins=pylint.extensions.docparams
[Parameter_documentation]
accept-no-yields-doc=no

Additional details:

This message is raised only when parameter accept-no-yields-doc is set to no.

NOTE:

Created by the parameter_documentation checker.

modified-iterating-list / W4701

Message emitted:

Iterated list '%s' is being modified inside for loop body, consider iterating through a copy of it instead.

Description:

Emitted when items are added or removed to a list being iterated through. Doing so can result in unexpected behaviour, that is why it is preferred to use a copy of the list.

Problematic code:

fruits = ["apple", "orange", "mango"]
for fruit in fruits:
    fruits.append("pineapple")  # [modified-iterating-list]

Correct code:

fruits = ["apple", "orange", "mango"]
for fruit in fruits.copy():
    fruits.append("pineapple")

Created by the modified_iteration checker.

multiple-constructor-doc / W9005

Message emitted:

"%s" has constructor parameters documented in class and __init__

Description:

Please remove parameter declarations in the class or constructor.

Problematic code:

class Point:  # [multiple-constructor-doc]
    """Represents a point in the xy-coordinate plane.
    :param x: coordinate
    :param y: coordinate
    """
    def __init__(self, x, y):
        """Represents a point in the xy-coordinate plane.
        :param x: coordinate
        :param y: coordinate
        """
        self.x = x
        self.y = y

Correct code:

class Point:
    def __init__(self, x, y):
        """Represents a point in the xy-coordinate plane.
        :param x: x coordinate
        :param y: y coordinate
        """
        self.x = x
        self.y = y

Configuration file:

[main]
load-plugins=pylint.extensions.docparams
[Parameter_documentation]
no-docstring-rgx=^(?!__init__$)_

Additional details:

Both docstrings are acceptable but not both at the same time.

NOTE:

Created by the parameter_documentation checker.

named-expr-without-context / W0131

Message emitted:

Named expression used without context

Description:

Emitted if named expression is used to do a regular assignment outside a context like if, for, while, or a comprehension.

Problematic code:

(a := 42)  # [named-expr-without-context]

Correct code:

if a := 42:
    print("Success")

Created by the basic checker.

nan-comparison / W0177

Message emitted:

Comparison %s should be %s

Description:

Used when an expression is compared to NaN values like numpy.NaN and float('nan').

Problematic code:

import numpy as np
def both_nan(x, y) -> bool:
    return x == np.NaN and y == float("nan")  # [nan-comparison, nan-comparison]

Correct code:

import numpy as np
def both_nan(x, y) -> bool:
    return np.isnan(x) and np.isnan(y)

Created by the basic checker.

nested-min-max / W3301

Message emitted:

Do not use nested call of '%s'; it's possible to do '%s' instead

Description:

Nested calls ``min(1, min(2, 3))`` can be rewritten as ``min(1, 2, 3)``.

Problematic code:

print(min(1, min(2, 3)))  # [nested-min-max]

Correct code:

print(min(1, 2, 3))

Created by the nested_min_max checker.

non-ascii-file-name / W2402

Message emitted:

%s name "%s" contains a non-ASCII character.

Description:

Under python 3.5, PEP 3131 allows non-ascii identifiers, but not non-ascii file names.Since Python 3.5, even though Python supports UTF-8 files, some editors or tools don't.

Problematic code:

bàd.py:

# [non-ascii-file-name]

not_bétter.py:

# [non-ascii-file-name]

Correct code:

__init__.py:

bad.py:

not_better.py:

Related links:

Created by the nonascii-checker checker.

non-parent-init-called / W0233

Message emitted:

__init__ method from a non direct base class %r is called

Description:

Used when an __init__ method is called on a class which is not in the direct ancestors for the analysed class.

Problematic code:

class Animal:
    def __init__(self):
        self.is_multicellular = True
class Vertebrate(Animal):
    def __init__(self):
        super().__init__()
        self.has_vertebrae = True
class Cat(Vertebrate):
    def __init__(self):
        Animal.__init__(self)  # [non-parent-init-called]
        self.is_adorable = True

Correct code:

class Animal:
    def __init__(self):
        self.is_multicellular = True
class Vertebrate(Animal):
    def __init__(self):
        super().__init__()
        self.has_vertebrae = True
class Cat(Vertebrate):
    def __init__(self):
        super().__init__()
        self.is_adorable = True

Created by the classes checker.

non-str-assignment-to-dunder-name / W1115

Message emitted:

Non-string value assigned to __name__

Description:

Emitted when a non-string value is assigned to __name__

Problematic code:

class Fruit:
    pass
Fruit.__name__ = 1  # [non-str-assignment-to-dunder-name]

Correct code:

class Fruit:
    pass
Fruit.__name__ = "FRUIT"

Created by the typecheck checker.

overlapping-except / W0714

Message emitted:

Overlapping exceptions (%s)

Description:

Used when exceptions in handler overlap or are identical

Problematic code:

def divide_x_by_y(x: float, y: float):
    try:
        print(x / y)
    except (ArithmeticError, FloatingPointError) as e:  # [overlapping-except]
        print(f"There was an issue: {e}")

Correct code:

less_generic_first.py:

def divide_x_by_y(x: float, y: float):
    try:
        print(x / y)
    except FloatingPointError as e:
        print(f"There was a FloatingPointError: {e}")
    except ArithmeticError as e:
        # FloatingPointError  were already caught at this point
        print(f"There was an OverflowError or a ZeroDivisionError: {e}")

only_generic.py:

def divide_x_by_y(x: float, y: float):
    try:
        print(x / y)
    except ArithmeticError as e:
        print(
            f"There was an OverflowError, a ZeroDivisionError or a FloatingPointError: {e}"
        )

Configuration file:

[MAIN]
load-plugins=pylint.extensions.overlapping_exceptions,

Related links:

NOTE:

Created by the overlap-except checker.

overridden-final-method / W0239

Message emitted:

Method %r overrides a method decorated with typing.final which is defined in class %r

Description:

Used when a method decorated with typing.final has been overridden.

Problematic code:

from typing import final
class Animal:
    @final
    def can_breathe(self):
        return True
class Cat(Animal):
    def can_breathe(self):  # [overridden-final-method]
        pass

Correct code:

from typing import final
class Animal:
    @final
    def can_breathe(self):
        return True
class Cat(Animal):
    def can_purr(self):
        return True

Configuration file:

[MAIN]
py-version=3.8

Additional details:

The message can't be emitted when using Python < 3.8.

Related links:

Created by the classes checker.

pointless-exception-statement / W0133

Message emitted:

Exception statement has no effect

Description:

Used when an exception is created without being assigned, raised or returned for subsequent use elsewhere.

Problematic code:

Exception("This exception is a statement.")  # [pointless-exception-statement]

Correct code:

raise Exception("This will raise.")

Created by the basic checker.

pointless-statement / W0104

Message emitted:

Statement seems to have no effect

Description:

Used when a statement doesn't have (or at least seems to) any effect.

Problematic code:

[1, 2, 3]  # [pointless-statement]

Correct code:

NUMBERS = [1, 2, 3]
print(NUMBERS)

Created by the basic checker.

pointless-string-statement / W0105

Message emitted:

String statement has no effect

Description:

Used when a string is used as a statement (which of course has no effect). This is a particular case of W0104 with its own message so you can easily disable it if you're using those strings as documentation, instead of comments.

Problematic code:

"""This is a docstring which describes the module"""
"""This is not a docstring"""  # [pointless-string-statement]

Correct code:

"""This is a docstring which describes the module"""
# This is comment which describes a particular part of the module.

Related links:

Created by the basic checker.

possibly-unused-variable / W0641

Message emitted:

Possibly unused variable %r

Description:

Used when a variable is defined but might not be used. The possibility comes from the fact that locals() might be used, which could consume or not the said variable

Problematic code:

def choose_fruits(fruits):
    print(fruits)
    color = "red"  # [possibly-unused-variable]
    return locals()

Correct code:

def choose_fruits(fruits):
    current_locals = locals()
    print(fruits)
    color = "red"
    print(color)
    return current_locals

Created by the variables checker.

preferred-module / W0407

Message emitted:

Prefer importing %r instead of %r

Description:

Used when a module imported has a preferred replacement module.

Problematic code:

import urllib  # [preferred-module]

Correct code:

import requests

Configuration file:

[IMPORTS]
preferred-modules=urllib:requests,

Created by the imports checker.

protected-access / W0212

Message emitted:

Access to a protected member %s of a client class

Description:

Used when a protected member (i.e. class member with a name beginning with an underscore) is accessed outside the class or a descendant of the class where it's defined.

Problematic code:

class Worm:
    def __swallow(self):
        pass
jim = Worm()
jim.__swallow()  # [protected-access]

Correct code:

class Worm:
    def __swallow(self):
        pass
    def eat(self):
        return self.__swallow()
jim = Worm()
jim.eat()

Created by the classes checker.

raise-missing-from / W0707

Message emitted:

Consider explicitly re-raising using %s'%s from %s'

Description:

Python's exception chaining shows the traceback of the current exception, but also of the original exception. When you raise a new exception after another exception was caught it's likely that the second exception is a friendly re-wrapping of the first exception. In such cases `raise from` provides a better link between the two tracebacks in the final error.

Problematic code:

try:
    1 / 0
except ZeroDivisionError as e:
    raise ValueError("Rectangle Area cannot be zero")  # [raise-missing-from]

Correct code:

try:
    1 / 0
except ZeroDivisionError as e:
    raise ValueError("Rectangle Area cannot be zero") from e

Related links:

Created by the exceptions checker.

raising-format-tuple / W0715

Message emitted:

Exception arguments suggest string formatting might be intended

Description:

Used when passing multiple arguments to an exception constructor, the first of them a string literal containing what appears to be placeholders intended for formatting

Problematic code:

raise RuntimeError("This looks wrong %s %s", ("a", "b"))  # [raising-format-tuple]

Correct code:

raise RuntimeError("This looks wrong %s %s" % ("a", "b"))

Created by the exceptions checker.

redeclared-assigned-name / W0128

Message emitted:

Redeclared variable %r in assignment

Description:

Emitted when we detect that a variable was redeclared in the same assignment.

Problematic code:

FIRST, FIRST = (1, 2)  # [redeclared-assigned-name]

Correct code:

FIRST, SECOND = (1, 2)

Created by the basic checker.

redefined-builtin / W0622

Message emitted:

Redefining built-in %r

Description:

Used when a variable or function override a built-in.

Problematic code:

def map():  # [redefined-builtin]
    pass

Correct code:

def map_iterable():
    pass

Created by the variables checker.

redefined-loop-name / W2901

Message emitted:

Redefining %r from loop (line %s)

Description:

Used when a loop variable is overwritten in the loop body.

Problematic code:

def normalize_names(names):
    for name in names:
        name = name.lower()  # [redefined-loop-name]

Correct code:

def normalize_names(names):
    for name in names:
        lowercased_name = name.lower()

Configuration file:

[MAIN]
load-plugins=pylint.extensions.redefined_loop_name,

NOTE:

Created by the redefined-loop-name checker.

redefined-outer-name / W0621

Message emitted:

Redefining name %r from outer scope (line %s)

Description:

Used when a variable's name hides a name defined in an outer scope or except handler.

Problematic code:

count = 10
def count_it(count):  # [redefined-outer-name]
    for i in range(count):
        print(i)

Correct code:

count = 10
def count_it(limit):
    for i in range(limit):
        print(i)

Additional details:

A common issue is that this message is triggered when using pytest fixtures:

import pytest
@pytest.fixture
def setup():
    ...
def test_something(setup):  # [redefined-outer-name]
    ...

One solution to this problem is to explicitly name the fixture:

@pytest.fixture(name="setup")
def setup_fixture():
    ...

Alternatively pylint plugins like pylint-pytest can be used.

Created by the variables checker.

redefined-slots-in-subclass / W0244

Message emitted:

Redefined slots %r in subclass

Description:

Used when a slot is re-defined in a subclass.

Problematic code:

class Base:
    __slots__ = ("a", "b")
class Subclass(Base):
    __slots__ = ("a", "d")  # [redefined-slots-in-subclass]

Correct code:

class Base:
    __slots__ = ("a", "b")
class Subclass(Base):
    __slots__ = ("d",)

Created by the classes checker.

redundant-returns-doc / W9008

Message emitted:

Redundant returns documentation

Description:

Please remove the return/rtype documentation from this method.

Problematic code:

def print_fruits(fruits):  # [redundant-returns-doc]
    """Print list of fruits
    Returns
    -------
        str
    """
    print(fruits)
    return None

Correct code:

def print_fruits(fruits):
    """Print list of fruits
    Returns
    -------
        str
    """
    print(fruits)
    return ",".join(fruits)

Configuration file:

[MAIN]
load-plugins = pylint.extensions.docparams

NOTE:

Created by the parameter_documentation checker.

redundant-u-string-prefix / W1406

Message emitted:

The u prefix for strings is no longer necessary in Python >=3.0

Description:

Used when we detect a string with a u prefix. These prefixes were necessary in Python 2 to indicate a string was Unicode, but since Python 3.0 strings are Unicode by default.

Problematic code:

def print_fruit():
    print(u"Apple")  # [redundant-u-string-prefix]

Correct code:

def print_fruit():
    print("Apple")

Created by the string checker.

redundant-unittest-assert / W1503

Message emitted:

Redundant use of %s with constant value %r

Description:

The first argument of assertTrue and assertFalse is a condition. If a constant is passed as parameter, that condition will be always true. In this case a warning should be emitted.

Problematic code:

import unittest
class DummyTestCase(unittest.TestCase):
    def test_dummy(self):
        self.assertTrue("foo")  # [redundant-unittest-assert]

Correct code:

import unittest
class DummyTestCase(unittest.TestCase):
    def test_dummy(self):
        actual = "test_result"
        self.assertEqual(actual, "expected")

Additional details:

Directly asserting a string literal will always pass. The solution is to test something that could fail, or not assert at all.

For assertions using assert there are similar messages: assert-on-string-literal / W0129 and assert-on-tuple / W0199.

Related links:

Created by the stdlib checker.

redundant-yields-doc / W9010

Message emitted:

Redundant yields documentation

Description:

Please remove the yields documentation from this method.

Problematic code:

def give_fruits(fruits):  # [redundant-yields-doc]
    """Something about fruits
    Yields
    -------
        list
            fruits
    """
    return fruits

Correct code:

def give_fruits(fruits):
    """Something about fruits
    Yields
    -------
        str
            fruit
    """
    for fruit in fruits:
        yield fruit

Configuration file:

[MAIN]
load-plugins = pylint.extensions.docparams

NOTE:

Created by the parameter_documentation checker.

reimported / W0404

Message emitted:

Reimport %r (imported line %s)

Description:

Used when a module is imported more than once.

Problematic code:

import re
import re  # [reimported]

Correct code:

import re

Created by the imports checker.

return-in-finally / W0134

Message emitted:

'return' shadowed by the 'finally' clause.

Description:

Emitted when a 'return' statement is found in a 'finally' block. This will overwrite the return value of a function and should be avoided.

Problematic code:

def second_favorite():
    fruits = ["kiwi", "pineapple"]
    try:
        return fruits[1]
    finally:
        # because of this `return` statement, this function will always return "kiwi"
        return fruits[0]  # [return-in-finally]

Correct code:

def second_favorite():
    fruits = ["kiwi", "pineapple"]
    try:
        return fruits[1]
    except KeyError:
        ...
    return fruits[0]

Related links:

Created by the basic checker.

self-assigning-variable / W0127

Message emitted:

Assigning the same variable %r to itself

Description:

Emitted when we detect that a variable is assigned to itself

Problematic code:

year = 2000
year = year  # [self-assigning-variable]

Correct code:

year = 2000

Related links:

Created by the basic checker.

self-cls-assignment / W0642

Message emitted:

Invalid assignment to %s in method

Description:

Invalid assignment to self or cls in instance or class method respectively.

Problematic code:

class Fruit:
    @classmethod
    def list_fruits(cls):
        cls = "apple"  # [self-cls-assignment]
    def print_color(self, *colors):
        self = "red"  # [self-cls-assignment]
        color = colors[1]
        print(color)

Correct code:

class Fruit:
    @classmethod
    def list_fruits(cls):
        fruit = "apple"
        print(fruit)
    def print_color(self, *colors):
        color = colors[1]
        print(color)

Created by the variables checker.

shadowed-import / W0416

Message emitted:

Shadowed %r (imported line %s)

Description:

Used when a module is aliased with a name that shadows another import.

Problematic code:

from pathlib import Path
import FastAPI.Path as Path  # [shadowed-import]

Correct code:

from pathlib import Path
import FastAPI.Path as FastApiPath

Created by the imports checker.

shallow-copy-environ / W1507

Message emitted:

Using copy.copy(os.environ). Use os.environ.copy() instead.

Description:

os.environ is not a dict object but proxy object, so shallow copy has still effects on original object. See https://bugs.python.org/issue15373 for reference.

Problematic code:

import copy
import os
copied_env = copy.copy(os.environ)  # [shallow-copy-environ]

Correct code:

import os
copied_env = os.environ.copy()

Created by the stdlib checker.

signature-differs / W0222

Message emitted:

Signature differs from %s %r method

Description:

Used when a method signature is different than in the implemented interface or in an overridden method.

Problematic code:

class Animal:
    def run(self, distance=0):
        print(f"Ran {distance} km!")
class Dog(Animal):
    def run(self, distance):  # [signature-differs]
        super(Animal, self).run(distance)
        print("Fetched that stick, wuff !")

Correct code:

class Animal:
    def run(self, distance=0):
        print(f"Ran {distance} km!")
class Dog(Animal):
    def run(self, distance=0):
        super(Animal, self).run(distance)
        print("Fetched that stick, wuff !")

Created by the classes checker.

subclassed-final-class / W0240

Message emitted:

Class %r is a subclass of a class decorated with typing.final: %r

Description:

Used when a class decorated with typing.final has been subclassed.

Problematic code:

from typing import final
@final
class PlatypusData:
    """General Platypus data."""
    average_length = 46
    average_body_temperature = 32
class FluorescentPlaytipus(PlatypusData):  # [subclassed-final-class]
    """Playtipus with fluorescent fur."""

Correct code:

from typing import final
@final
class PlatypusData:
    """General Platypus data."""
    average_length = 46
    average_body_temperature = 32
def print_average_length_platypus():
    output = f"The average length of a platypus is: {PlatypusData.average_length}cm"
    print(output)

Configuration file:

[MAIN]
py-version=3.8

Additional details:

This message is emitted when a class which is decorated with final is subclassed; the decorator indicates that the class is not intended to be extended.

Note this message can't be emitted when using Python < 3.8.

Related links:

Created by the classes checker.

subprocess-popen-preexec-fn / W1509

Message emitted:

Using preexec_fn keyword which may be unsafe in the presence of threads

Description:

The preexec_fn parameter is not safe to use in the presence of threads in your application. The child process could deadlock before exec is called. If you must use it, keep it trivial! Minimize the number of libraries you call into. See https://docs.python.org/3/library/subprocess.html#popen-constructor

Problematic code:

import subprocess
def foo():
    pass
subprocess.Popen(preexec_fn=foo)  # [subprocess-popen-preexec-fn]

Correct code:

import subprocess
subprocess.Popen()

Created by the stdlib checker.

subprocess-run-check / W1510

Message emitted:

'subprocess.run' used without explicitly defining the value for 'check'.

Description:

The ``check`` keyword is set to False by default. It means the process launched by ``subprocess.run`` can exit with a non-zero exit code and fail silently. It's better to set it explicitly to make clear what the error-handling behavior is.

Problematic code:

import subprocess
proc = subprocess.run(["ls"])  # [subprocess-run-check]

Correct code:

import subprocess
proc = subprocess.run(["ls"], check=False)

Related links:

Created by the stdlib checker.

super-init-not-called / W0231

Message emitted:

__init__ method from base class %r is not called

Description:

Used when an ancestor class method has an __init__ method which is not called by a derived class.

Problematic code:

class Fruit:
    def __init__(self, name="fruit"):
        self.name = name
        print("Creating a {self.name}")
class Apple(Fruit):
    def __init__(self):  # [super-init-not-called]
        print("Creating an apple")

Correct code:

class Fruit:
    def __init__(self, name="fruit"):
        self.name = name
        print("Creating a {self.name}")
class Apple(Fruit):
    def __init__(self):
        super().__init__("apple")

Created by the classes checker.

super-without-brackets / W0245

Message emitted:

Super call without brackets

Description:

Used when a call to super does not have brackets and thus is not an actual call and does not work as expected.

Problematic code:

class Soup:
    @staticmethod
    def temp():
        print("Soup is hot!")
class TomatoSoup(Soup):
    @staticmethod
    def temp():
        super.temp()  # [super-without-brackets]
        print("But tomato soup is even hotter!")

Correct code:

class Soup:
    @staticmethod
    def temp():
        print("Soup is hot!")
class TomatoSoup(Soup):
    @staticmethod
    def temp():
        super().temp()
        print("But tomato soup is even hotter!")

Created by the classes checker.

too-many-try-statements / W0717

Message emitted:

%s

Description:

Try clause contains too many statements.

Problematic code:

FRUITS = {"apple": 1, "orange": 10}
def pick_fruit(name):
    try:  # [too-many-try-statements]
        count = FRUITS[name]
        count += 1
        print(f"Got fruit count {count}")
    except KeyError:
        return

Correct code:

FRUITS = {"apple": 1, "orange": 10}
def pick_fruit(name):
    try:
        count = FRUITS[name]
    except KeyError:
        return
    count += 1
    print(f"Got fruit count {count}")

Configuration file:

[MAIN]
load-plugins=pylint.extensions.broad_try_clause,

NOTE:

Created by the broad_try_clause checker.

try-except-raise / W0706

Message emitted:

The except handler raises immediately

Description:

Used when an except handler uses raise as its first or only operator. This is useless because it raises back the exception immediately. Remove the raise operator or the entire try-except-raise block!

Problematic code:

try:
    1 / 0
except ZeroDivisionError as e:  # [try-except-raise]
    raise

Correct code:

remove_try_except.py:

# The try except might be removed entirely:
1 / 0

specialized_exception.py:

# Another more detailed exception can be raised:
try:
    1 / 0
except ZeroDivisionError as e:
    raise ValueError("The area of the rectangle cannot be zero") from e

Additional details:

There is a legitimate use case for re-raising immediately. E.g. with the following inheritance tree:

+-- ArithmeticError
     +-- FloatingPointError
     +-- OverflowError
     +-- ZeroDivisionError

The following code shows valid case for re-raising exception immediately:

def execute_calculation(a, b):
    try:
        return some_calculation(a, b)
    except ZeroDivisionError:
        raise
    except ArithmeticError:
        return float('nan')

The pylint is able to detect this case and does not produce error.

Created by the exceptions checker.

unbalanced-dict-unpacking / W0644

Message emitted:

Possible unbalanced dict unpacking with %s: left side has %d label%s, right side has %d value%s

Description:

Used when there is an unbalanced dict unpacking in assignment or for loop

Problematic code:

FRUITS = {"apple": 2, "orange": 3, "mellon": 10}
for fruit, price in FRUITS.values():  # [unbalanced-dict-unpacking]
    print(fruit)

Correct code:

FRUITS = {"apple": 2, "orange": 3, "mellon": 10}
for fruit, price in FRUITS.items():
    print(fruit)

Created by the variables checker.

undefined-loop-variable / W0631

Message emitted:

Using possibly undefined loop variable %r

Description:

Used when a loop variable (i.e. defined by a for loop or a list comprehension or a generator expression) is used outside the loop.

Problematic code:

def find_even_number(numbers):
    for x in numbers:
        if x % 2 == 0:
            break
    return x  # [undefined-loop-variable]

Correct code:

def find_even_number(numbers):
    for x in numbers:
        if x % 2:
            return x
    return None

Created by the variables checker.

unnecessary-ellipsis / W2301

Message emitted:

Unnecessary ellipsis constant

Description:

Used when the ellipsis constant is encountered and can be avoided. A line of code consisting of an ellipsis is unnecessary if there is a docstring on the preceding line or if there is a statement in the same scope.

Problematic code:

def my_function():
    """My docstring"""
    ...  # [unnecessary-ellipsis]

Correct code:

def my_function():
    """My docstring"""

Created by the unnecessary_ellipsis checker.

unnecessary-lambda / W0108

Message emitted:

Lambda may not be necessary

Description:

Used when the body of a lambda expression is a function call on the same argument list as the lambda itself; such lambda expressions are in all but a few cases replaceable with the function being called in the body of the lambda.

Problematic code:

pandas.py:

df.apply(lambda x: str(x))  # [unnecessary-lambda]

print.py:

function = lambda x: print(x)  # [unnecessary-lambda]
function("Hello world !")

Correct code:

pandas.py:

df.apply(str)

print.py:

print("Hello world !")

Created by the basic checker.

unnecessary-pass / W0107

Message emitted:

Unnecessary pass statement

Description:

Used when a "pass" statement can be removed without affecting the behaviour of the code.

Problematic code:

class DataEntryError(Exception):
    """This exception is raised when a user has provided incorrect data."""
    pass  # [unnecessary-pass]

Correct code:

class DataEntryError(Exception):
    """This exception is raised when a user has provided incorrect data."""

Created by the basic checker.

unnecessary-semicolon / W0301

Message emitted:

Unnecessary semicolon

Description:

Used when a statement is ended by a semi-colon (";"), which isn't necessary (that's python, not C ;).

Problematic code:

print("Hello World!");  # [unnecessary-semicolon]

Correct code:

print("Hello World!")

Created by the format checker.

unreachable / W0101

Message emitted:

Unreachable code

Description:

Used when there is some code behind a "return" or "raise" statement, which will never be accessed.

Problematic code:

def say_hello():
    return True
    print("Hello World!, Outside function.")  # [unreachable]

Correct code:

def say_hello():
    print("Hello World!, Inside function.")
    return True

Created by the basic checker.

unspecified-encoding / W1514

Message emitted:

Using open without explicitly specifying an encoding

Description:

It is better to specify an encoding when opening documents. Using the system default implicitly can create problems on other operating systems. See https://peps.python.org/pep-0597/

Problematic code:

def foo(file_path):
    with open(file_path) as file:  # [unspecified-encoding]
        contents = file.read()

Correct code:

def foo(file_path):
    with open(file_path, encoding="utf-8") as file:
        contents = file.read()

Created by the stdlib checker.