Python - 1

This rule identifies conditional statements in your code that will never execute, known as dead code, because their conditions are always false. Removing such statements cleans up the codebase, enhancing readability and potentially improving performance by eliminating unnecessary checks during execution. It’s crucial for maintaining an efficient and easily navigable codebase.

if False:
print(3)
if True:
print(2)

This rule emphasizes the importance of using the ‘from’ keyword in ‘raise’ statements to chain exceptions explicitly. It enhances error traceability by providing a clear path from the original to the new exception, greatly aiding in debugging complex issues. Addressing this issue leads to better error handling practices and more maintainable code by making the causal relationship between exceptions clear.

try:
sketchy_function()
except ValueError:
raise RuntimeError()

Advises on moving statements that do not change within the loop’s scope to outside of the loop. This optimization can lead to significant performance improvements, especially in large or heavily iterated loops, by reducing the computational overhead within the loop. It not only speeds up execution but also improves code readability by simplifying the loop’s body.

for i in range(100):
x = 10
print(x + i)

Targets functions and classes within the codebase that are never called or instantiated, marking them for removal. Cleaning up these unused elements can dramatically reduce code clutter, making the codebase easier to navigate and maintain. Moreover, it can highlight areas of the code that may require refactoring or optimization, contributing to overall better resource management.

This rule focuses on optimizing comparisons with singletons (like None in Python) by using identity checks (‘is’ or ‘is not’) instead of equality checks (’==’, ’!=’). Since singletons have a unique instance, identity checks are both logically appropriate and faster, leading to improved performance and code clarity.

x == None and k != None

Encourages refactoring to break out code that is duplicated across multiple branches of an if-else statement. This practice not only makes the code more DRY (Don’t Repeat Yourself) but also enhances readability and maintainability by reducing redundancy. It simplifies understanding the code’s logic and can make further changes or bug fixes easier to implement.

import random
if random.random() < 2:
print(100)
print(3)
else:
print(100)
print(21)

Aims to streamline the control flow within if statements, reducing complexity and improving readability. This may involve eliminating unnecessary nested conditions or simplifying logical expressions. Simplifying control flow makes the code easier to follow, understand, and test, which is beneficial for both current and future developers working on the codebase.

import random
x = 11
y = 12
z = random.random()
if z > 1 - z:
do_stuff(x)
do_stuff(y - x ** 2)
print(doing_other_stuff(x) - do_stuff(y ** y))
else:
do_stuff(y)
do_stuff(x - y ** 2)
print(doing_other_stuff(y) - do_stuff(x ** x))

Suggests rearranging if-else branches to improve clarity or efficiency, particularly when it allows for a more straightforward condition or aligns with expected coding practices. This change can make the code more intuitive and align execution paths with likely scenarios first, potentially improving both readability and performance by optimizing for common cases.

def f(x)  int:
if x > 10:
x += 1
x *= 12
print(x > 30)
return 100 - sum(x, 2, 3)
else:
return 13

Promotes using the early return pattern to exit functions as soon as a condition is met, avoiding additional indentation from nested if-else blocks. This pattern simplifies function logic, making it easier to understand and reducing the cognitive load required to follow the flow of the function. It can also decrease the function’s execution time by avoiding unnecessary checks after conditions are met.

def f(x)  int:
if x > 10:
x += 1
x *= 12
print(x > 30)
y = 100 - sum(x, 2, 3)
else:
y = 13
return y

Advises using the continue statement at the beginning of loops to immediately skip to the next iteration under certain conditions, reducing nesting and improving readability. This practice can make loops clearer by highlighting the conditions for continuing early and can improve performance by minimizing the execution of loop bodies under those conditions.

for x in range(100):
if x > 10:
    y = 13
else:
    x += 1
    x *= 12
    print(x > 30)
    y = 100 - sum(x, 2, 3)
print(x)

Identifies situations where the enumerate function is used unnecessarily, typically when the index it provides is not used. Removing such redundant uses can simplify the code, making it more readable and potentially enhancing performance by eliminating the overhead associated with enumeration when it’s not needed.

(x for _, x in enumerate(y))

Highlights instances where arguments provided to the zip function are never used, suggesting their removal for cleaner code. Addressing this issue not only improves code readability by eliminating superfluous elements but also can uncover potential logic errors or inefficiencies in how data structures are being used.

x = (a for _, a in zip(range(3), range(1, 3)))

Recommends replacing combinations of the map function and lambda expressions with list comprehensions for more readable and concise code. List comprehensions are often more straightforward for developers to understand and can offer performance benefits over map and lambda by being more Pythonic and potentially faster in execution.

x = map(lambda y: y > 0, (1, 2, 3))

Similar to map and lambda, this rule suggests using list comprehensions instead of the filter function combined with lambda expressions. This change makes the code cleaner and more accessible by leveraging the more intuitive syntax of list comprehensions, which can also lead to slight performance improvements.

x = filter(lambda y: y > 0, (1, 2, 3))

This rule is about removing unnecessary else statements in your code. An else statement is considered unnecessary when it follows a return statement in the if block. In such cases, the else block can be safely removed without changing the logic of the code. Unnecessary else statements can make your code harder to read and understand. They can also lead to more complex code structures, which can increase the likelihood of introducing bugs. By removing unnecessary else statements, you can make your code simpler and more readable.

def f(x: int)  int:
if x == 2:
    return 10
else:
    return 11 - x

This rule suggests using the filter function to streamline complex filtering logic within loops or list comprehensions. By encapsulating filtering logic in a filter function, code becomes cleaner and more expressive, allowing for better readability. This pattern can also improve performance by using built-in Python optimizations for filtering collections.

for x in range(10):
if x:
print(3)

Encourages combining multiple comparison operations into a single, chained expression. This not only makes the code more readable by reducing complexity and enhancing clarity but can also improve execution speed by minimizing the number of comparison operations. Chained comparisons are more pythonic and can make conditional logic easier to understand at a glance.

x = (y for y in (y for y in (3, 4, 5)))

Targets unnecessary casts (like converting a list comprehension directly to a list) of comprehensions, suggesting their removal. Since comprehensions inherently create their target collection, extra casting is redundant and can negatively impact performance. Removing these casts simplifies the code and can slightly improve runtime efficiency by reducing unnecessary function calls.

set({x for x in range(10)})

Focuses on eliminating redundant casts in sequences of function calls, where the outcome of one operation is immediately cast to another type without need. Addressing this issue can clean up the code by removing unnecessary operations, thereby enhancing readability and possibly improving performance by reducing the computational overhead.

set(itertools.chain(range(10), range(11)))

This rule identifies if statements that end with a return statement and then have an unnecessary else block that also returns. It suggests removing the else block and placing the return statement outside, simplifying the control flow. This change makes the function easier to read and understand by reducing unnecessary nesting and highlighting the conditions under which different return values are provided.

def f(x: int)  int:
if x == 100:
    return False
return True

Aims to refactor if statements that assign the same variable to different values in each branch by suggesting a more streamlined approach, such as using a conditional expression. This can significantly enhance code readability by reducing the number of lines and making the conditional assignment clearer and more direct.

if x == 100:
y = False
else:
y = True

Suggests replacing calls to functions that simply return a static or simple dynamic value with literals or simpler expressions. This optimization can reduce the overhead associated with function calls, making the code more efficient and easier to read by directly presenting values or simple expressions instead of hiding them behind function calls.

u = list()
v = tuple()
w = dict()
a = dict(zip(range(4), range(1, 5)))
b = list((1, 2, 3, 99))
c = set([1, 2, 3])
d = iter((1, 2, 3, 5))
aa = (1 for u in (1, 2, 3, 5))

Recommends using collection literals (e.g., set or list literals) instead of adding or updating collections through method calls. This can make the code more concise and readable by clearly showing the intention to create or modify collections, and can improve performance by utilizing Python’s optimized syntax for collection manipulation.

x = {1, 2, 3}
x.add(7)
x.add(191)

Targets the simplification of unpacking operations for collections, advocating for more straightforward or efficient ways to unpack items. This can improve both the readability of the code by making unpacking operations clearer and the performance by reducing the complexity of these operations.

x = [*()]

Identifies and suggests removing duplicate elements in set initializations. Since sets automatically enforce uniqueness, explicitly listing duplicate elements is unnecessary and can mislead readers about the code’s intent, besides causing minor performance concerns during set creation.

{1, 99, "s", 1, sum(range(11)), sum(range(11))}

Encourages breaking out arguments that are passed with the star (*) operator into explicit variables, if practical. This can improve readability by making the function’s expected arguments clearer and can enhance maintainability by making it easier to identify and modify the use of these arguments in the function call.

x = foo(a, b, *(c, d), e, *{f}, *[k, v, h])

Advises on replacing .loc and .at with .iloc and .iat in pandas DataFrames for improved performance. .iloc and .iat are designed for position-based indexing and are generally faster than .loc and .at, which are label-based. This switch can lead to significant performance gains, especially in large datasets, by optimizing data access patterns.

y = x.loc[1, 2]

This rule recommends replacing the use of .iterrows in pandas DataFrames with direct indexing where possible for enhanced performance. Direct indexing accesses elements more efficiently than .iterrows, which iterates over DataFrame rows in a slower, row-wise manner. This change can lead to significant speed improvements in data processing scripts by leveraging faster data access patterns.

for x, _ in df.iterrows():
print(x)

Suggests substituting .iterrows with .itertuples for iterating over DataFrame rows in pandas. .itertuples is generally faster than .iterrows because it returns namedtuples of the row data, reducing overhead and improving performance in row-wise operations. This modification can greatly speed up loop iterations over DataFrame rows, making code more efficient.

for _, x in df.iterrows():
print(x["value"])

Encourages replacing for loops that build sets or lists with set or list comprehensions. Comprehensions provide a more concise, readable, and pythonic way to create collections compared to loops, and they often offer performance benefits by being optimized for collection creation. This leads to cleaner code that’s easier to understand and faster to execute.

x = []
for i in range(10):
x.append(i)

Advises on replacing set comprehensions followed by addition operations with set union operations. Set unions are more efficient and semantically clear for combining sets than adding elements in a loop, leading to code that’s both faster and easier to read by expressing the intent more directly.

x = {foo(z) ** 2 for z in range(3)}
for zua in range(3):
x.add(zua - 1)

Recommends using list concatenation instead of appending to a list within a loop. Concatenation can be more efficient, especially when dealing with small lists or when the total size is known beforehand, as it can reduce the overhead of repeated append operations. This approach also makes the code more succinct and readable by clearly showing the intention to combine list elements.

x = [foo(z) ** 2 for z in range(3)]
for zua in range(3):
x.append(zua - 1)

Promotes the use of dictionary comprehensions instead of for loops for creating dictionaries. Dictionary comprehensions offer a concise, readable alternative to loops, enhancing code clarity and potentially improving execution speed by optimizing the dictionary creation process.

x = {}
for i in range(10):
x[i] = 10

Encourages the use of the implicit form of dictionary keys(), values(), and items() methods in looping constructs. This practice can make the code more pythonic and readable by reducing verbosity without compromising functionality or performance.

(x for x, _ in d.items())

Suggests replacing sequential dictionary assignments with dictionary literals. Using literals can make the code more concise and easier to understand by displaying the dictionary’s contents directly, and can improve performance by reducing the number of assignment operations.

x = {}
x[10] = 100

Recommends using literal syntax for merging dictionaries instead of the update method. This approach is more direct and readable, showing the intent to combine dictionaries clearly, and can offer slight performance benefits by leveraging Python’s optimized syntax for literal merges.

x = {}
x.update({10: 100})

Targets replacing dictionary comprehensions that are immediately assigned to a dictionary with direct dictionary literals. This can enhance readability by presenting the dictionary’s content in a straightforward manner and may improve performance by avoiding the overhead of the comprehension and assignment steps.

x = {z: 21 for z in range(3)}
x[10] = 100

Advises on using dictionary literals for updating dictionaries instead of comprehensions followed by updates. This method is clearer and more efficient, directly showing the updated content and potentially reducing runtime by avoiding the two-step process of comprehension creation and update.

x = {z: 21 for z in range(3)}
x.update({10: 100})

Focuses on simplifying the unpacking of dictionaries, especially in function calls or assignments. Simplifying unpacking operations can make the code more readable and maintainable by clearly showing which keys and values are being used, and can optimize the code by reducing unnecessary complexity in data handling.

x = {**{}}

Identifies and suggests removing duplicate keys in dictionary literals. Duplicate keys in dictionaries are usually an error or oversight, as they can lead to unpredictable behavior by overwriting values. Removing them improves code clarity and correctness, ensuring that each key-value pair is unique and intentional.

{1: 2, 99: 101, "s": 4, 1: 22, sum(range(11)): 9999, sum(range(11)): 9999}

This rule recommends replacing implicit matrix multiplication operations with explicit ones to enhance both clarity and performance. Explicit matrix multiplication, typically done with the @ operator in Python, makes the operation clear to the reader and can be optimized by libraries for better performance, especially with large datasets or complex mathematical computations.

import numpy as np

i, j, k = 10, 11, 12

a = np.random.random((i, j))
b = np.random.random((j, k))

u = np.array([[np.dot(a_, b_) for a_ in a] for b_ in b.T]).T
v = np.array([[np.dot(b_, a_) for b_ in b.T] for a_ in a])

Suggests replacing looping over sequences with subscripts (e.g., for i in range(len(sequence)): item = sequence[i]) with more direct iteration methods (e.g., for item in sequence). This change improves readability by reducing boilerplate code and can enhance performance by eliminating the need for indexing operations.

import numpy
[a[i] for i in range(len(a))]
[a[i, :] for i in range(len(a))]
[a[i, :] for i in range(a.shape[0])]
[a[:, i] for i in range(a.shape[1])]

Advises on replacing implicit dot product operations with explicit function calls to dot products. Explicit calls can make the code more understandable by clearly indicating the operation being performed and can allow for optimizations specific to dot product calculations, thus potentially improving performance.

Targets unnecessary transpose operations in arrays, suggesting their removal or simplification. Transposes can be computationally expensive and may not be needed, especially if followed by operations that negate their effects. Simplifying or removing them can improve both performance and code clarity.

Recommends optimizing matrix multiplication operations that involve unnecessary transposes. By rearranging or eliminating these transposes, the efficiency of matrix multiplications can be improved, resulting in faster computations and clearer code that more directly expresses the intended mathematical operations.

Encourages the use of defaultdict from the collections module for handling default values in dictionaries more cleanly. defaultdict automatically initializes missing keys with a default value, simplifying code and improving readability by avoiding explicit checks or assignments for missing keys.

def f(x: int)  int:
    return x+1
d = {}
for x in range(10):
y = f(x)
if x in d:
    d[x].append(y)
else:
    d[x] = [y]

Identifies and suggests removing redundant lambda functions that wrap direct function calls without modification. Using the functions directly can simplify the code, making it more readable and potentially improving performance by reducing the overhead associated with lambda expressions.

lambda *args: w(*args)

Highlights unnecessary comprehensions that could be replaced with simpler constructs or direct operations. Removing these can make the code more concise and readable, as well as improve performance by avoiding the overhead of the comprehension syntax for straightforward operations.

a = {x: y for x, y in zip(range(4), range(1, 5))}
b = [w for w in (1, 2, 3, 99)]
c = {v for v in [1, 2, 3]}
d = (u for u in (1, 2, 3, 5))
aa = (1 for u in (1, 2, 3, 5))
ww = {x: y for x, y in zip((1, 2, 3), range(3)) if x > y > 1}
ww = {x: y for y, x in zip((1, 2, 3), range(3))}

Focuses on simplifying complex boolean expressions to enhance readability and maintainability. Complex expressions can often be rewritten more concisely without changing their logical outcome, making the code easier to understand and less prone to errors.

x and False and y

Suggests simplifying expressions that constrain ranges redundantly, such as using min and max functions in a range where the limits are already clear. Simplifying these expressions can improve readability and performance by removing unnecessary function calls and making the intended range constraints more direct.

(x for x in range(10) if x > 4)

Recommends using symbolic mathematics libraries to simplify complex boolean expressions. This approach can reveal simplifications that are not immediately obvious, making the code cleaner and often more efficient by reducing the complexity of conditional logic.

x and not x

Advises inlining list or set comprehensions directly into mathematical expressions where possible. This can enhance readability by reducing the amount of code and improving performance by eliminating the need for intermediate collection construction during complex mathematical operations.

z = {a for a in range(10)}
x = sum(z)

Targets simplification of iterators used in mathematical expressions, recommending more straightforward iteration patterns. Simplifying these iterators can make the code easier to understand and reduce computational overhead in mathematical computations.

x = sum(range(10))
y = sum(range(3, 17))
h = sum((1, 2, 3))
q = sum([1, 2, 3, 99, 99, -8])
r = sum({1, 2, 3, 99, 99, -8})

Suggests replacing negated numeric comparisons with their direct counterparts for clarity and efficiency. For example, instead of using !(a > b), use a <= b. This makes the intended comparison more explicit and can improve both the readability of the code and its execution speed by using simpler operations.

not x > 3

This rule encourages the optimization of ‘contain’ types to enhance both performance and readability of the code. It focuses on improving the efficiency of checking whether an object is part of a collection. By using the most suitable and efficient methods for these checks, we can reduce computational overhead and improve the overall speed of the program.

1 in (1, 2, 3)
x in {1, 2, ()}
x in [1, 2, []]
w in [1, 2, {}]
w in {foo, bar, "asdf", coo}
w in (foo, bar, "asdf", coo)
w in {x for x in range(10)}
w in [x for x in range(10)]
w in (x for x in range(10))
w in {x for x in [1, 3, "", 909, ()]}
w in [x for x in [1, 3, "", 909, ()]]
w in (x for x in [1, 3, "", 909, ()])
x in sorted([1, 2, 3])

Identifies and recommends removing redundant method calls chained together where earlier calls do not affect the outcome of the chain. This simplification not only enhances code readability by eliminating unnecessary operations but also improves performance by reducing the computational overhead associated with executing these redundant method calls.

sorted(tuple(v))
sorted(list(v))
list(iter(v))
list(tuple(v))

Targets unnecessary calls to iter(), suggesting their removal. In many cases, Python’s for loops and other iterators implicitly call iter() on collections, making explicit calls redundant. Removing them simplifies the code and can slightly improve performance by avoiding superfluous function calls.

Recommends replacing the sorted() function with heapq functions for performance improvements in scenarios involving large collections. When only the smallest or largest elements are needed, heapq can provide these more efficiently than sorting the entire collection, leading to significant performance gains in handling large datasets.

Advises adding missing context managers for file and resource handling to ensure that resources are properly managed and released, even in the event of errors. Using context managers improves code reliability and readability by clearly defining the scope of resource usage.

import requests

session = requests.Session()
session.get("https://www.google.com")

Identifies functions that are duplicated within the codebase and suggests removing the duplicates. Duplicate functions can lead to maintenance issues, inconsistencies, and increased code size, making it harder to manage and understand the codebase.

Targets duplicate import statements for removal. Duplicate imports can clutter the code and lead to confusion about the namespace’s structure, without offering any benefit. Streamlining imports can enhance code clarity and organization.

from logging import info
from logging import warning
from logging import error, info, log
from logging import (
warning,
critical   ,
error, error, error as error)
from logging import critical

Recommends removing import statements that are not used within the code. Unused imports can lead to unnecessary dependencies and can potentially slow down program startup time. Cleaning up imports can improve code readability and performance.

import numpy as np, pandas as pd
print(pd)

Suggests transforming dictionary keys in the source to key-value pairs (items), providing a more comprehensive view of the data structure being iterated over or manipulated. This can enhance both the expressiveness and efficiency of operations that require access to both keys and values.

Advises on transforming item tuples back to keys when only the keys are needed from a dictionary that was initially accessed for its items. This can simplify data handling by focusing on the relevant part of the data structure for the given context.

Recommends transforming item tuples to values, focusing on the value part of key-value pairs in a dictionary. This is useful in contexts where the values are of primary interest, streamlining the code by removing unnecessary references to keys.

Applies a transformation from keys to items in the source, suggesting a shift in focus from operating solely on keys to working with both keys and values. This can be particularly beneficial in scenarios where both elements are needed for processing or decision-making.

Implies a transformation for items to keys, advocating for a simplification in cases where the operation initially involves both keys and values but ultimately requires only the keys. This simplification can make the code more focused and readable.

Suggests a shift from handling item tuples to focusing solely on their values. This transformation is recommended when the values hold the necessary data for the operation, allowing the code to be more concise and targeted.

Identifies scenarios where a value is assigned to a variable only to be immediately returned and suggests simplifying this by returning the value directly. This change can make the code cleaner and more straightforward by eliminating an unnecessary variable assignment.

Recommends swapping explicit if-else branches when it results in clearer or more efficient code. For example, changing the order of if-else branches can improve readability by placing the most common or simplest case first, or it can enhance performance by optimizing the order of condition evaluation.

def f(x)  int:
if x > 10:
    x += 1
    x *= 12
    print(x > 30)
    return 100 - sum(x, 2, 3)
else:
    return 13

This rule identifies scenarios where a value is assigned to a variable only to be immediately returned by the function. Simplifying this pattern by returning the value directly can make the function more straightforward and concise, eliminating unnecessary intermediate variables and clearly communicating the return value.

def foo():
x = 100
return x

Recommends reordering explicit if-else branches when such a change leads to clearer or more logically organized code. Swapping if-else branches can enhance readability, especially when it aligns the code’s structure with its intended logic or prioritizes more common conditions, making the code easier to follow and sometimes more efficient.

Advises replacing string concatenation operations with f-strings for improved readability and performance. F-strings, introduced in Python 3.6, provide a more concise and intuitive syntax for embedding expressions inside string literals, making the code cleaner and often faster than traditional concatenation methods.

a = "Hello" + name

Flags an instance being created from an abstract class that contains abstract methods. Abstract classes are designed to be subclassed, not instantiated directly, and doing so can lead to runtime errors if the abstract methods are not implemented. This rule helps ensure that the code’s design intentions are respected and that subclasses provide concrete implementations for abstract methods.

import abc


class Animal(abc.ABC):
@abc.abstractmethod
def make_sound(self):
    pass


sheep = Animal()  # [abstract-class-instantiated]

Identifies access to a class member before its definition has occurred. This can lead to errors or unintended behavior, as the member may not be initialized at the time of access. Ensuring members are defined before they are accessed improves code reliability and readability.

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

Detects assignments to attributes not defined in the class slots. Using slots is a way to declare explicitly which attributes the class will have, offering memory savings and faster attribute access. Assigning to non-slot attributes breaks the constraints set by slots and can lead to unexpected behavior or inefficiencies.

class Student:
__slots__ = ("name",)

def __init__(self, name, surname):
    self.name = name
    self.surname = surname  # [assigning-non-slot]
    self.setup()

def setup(self):
    pass

Catches attempts to assign the result of a function call to a variable when the function does not explicitly return a value. This usually results in the variable being assigned None, which can be a source of bugs if not intended. Highlighting these cases encourages more explicit control flow and return value handling.

def add(x, y):
print(x + y)


value = add(10, 10)  # [assignment-from-no-return]

Similar to the above, this rule flags assignments of the result of function calls where the function is known to return None. Such assignments are often unintended and can lead to logic errors if the None value is not handled properly.

def function():
return None


f = function()  # [assignment-from-none]

Identifies the use of ‘await’ for an asynchronous call outside of an async function. This is a syntax error as ‘await’ can only be used within async functions. This rule helps prevent runtime errors by ensuring that asynchronous calls are correctly placed within the asynchronous execution context.

import asyncio


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

Points out misconfigurations in configuration files or sections of code that are not set up correctly. Proper configuration is crucial for the successful execution and behavior of applications, and this rule aids in identifying and correcting configuration errors.

Warns about incorrectly ordered except clauses in try-except blocks. Specific exceptions should be listed before more general ones to prevent the general exceptions from catching exceptions intended for the specific handlers. This ensures that exceptions are handled appropriately and that error handling logic is clear and effective.

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

Flags instances where the cause of an exception (using the ‘from’ keyword) is set to something that is not an exception or None. The ‘from’ keyword is used for exception chaining, to help clarify the cause of secondary exceptions. Setting it incorrectly can lead to confusion and make error diagnosis more difficult.

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

Flags the use of an unsupported format character in a string format operation. This typically indicates a typo or misunderstanding of the format specification, and can lead to runtime errors or incorrect string formatting. Correcting these characters ensures the intended output is produced reliably.

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

Indicates an invalid value has been provided for a pylint plugin configuration. Plugins extend pylint’s functionality, and providing valid configuration values is crucial for their correct operation. This rule helps maintain the integrity and usefulness of extended linting capabilities.

Warns when the first argument passed to reversed() is not a sequence. Since reversed() is designed to iterate over sequences in reverse order, passing a non-sequence type indicates a logical error in the code, potentially leading to runtime errors.

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

Identifies suspicious arguments passed to string strip methods (strip, lstrip, rstrip). These methods are often used incorrectly with multiple characters, leading to unexpected behavior. Ensuring the correct use of these methods helps maintain the intended functionality of string manipulation.

Flags format strings where an argument does not match the expected format type, indicating a mismatch between the data type of the argument and the format specifier. This can prevent runtime errors and ensure that string formatting operations produce the intended result.

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

Detects incorrect first arguments given to super(), which can lead to incorrect method resolution and potentially runtime errors. Using super() correctly is crucial for accessing parent class methods reliably in inheritance hierarchies.

class Animal:
pass


class Tree:
pass


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

Highlights the presence of bidirectional Unicode text that may contain control characters capable of obfuscating code. This can make the code appear different from its actual execution, posing a security risk by hiding malicious code within seemingly benign text.

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

Points out issues with callables intended for use in collection classes that do not work as expected. Ensuring callables are correctly implemented is essential for the proper functioning of custom collection behaviors.

from collections.abc import Callable
from typing import Optional


def func()  Optional[Callable[[int], None]]:  # [broken-collections-callable]
...

Flags functions declared to not return a value (e.g., by typing annotations) that contain return statements. This inconsistency can lead to confusion about the function’s behavior and should be corrected for clarity and correctness.

from typing import NoReturn, Union


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

Warns about catching objects that do not inherit from Exception. Only objects derived from Exception should be caught by except clauses. This rule ensures that error handling in try-except blocks is correctly targeted and meaningful.

class FooError:
pass


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

Detects conflicts between slots declarations and class variables. slots are used to declare instance variables and prevent the creation of dict and weakref for each instance, and conflicts can lead to unexpected behavior or inefficiencies.

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}.")

Identifies the use of ‘continue’ within a ‘finally’ clause, which is not supported and can lead to a syntax error. This rule helps prevent control flow errors in complex try-except-finally structures.

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

Flags the unpacking of a dictionary in iteration without explicitly calling .items(). This can lead to errors or unintended behavior when expecting key-value pairs but only keys are provided. Ensuring .items() is called makes the intention clear and the code more reliable.

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}.")

Detects duplicate argument names in a function definition, which can lead to confusion and errors in how arguments are passed and used within the function. Unique argument names ensure clarity in function signatures.

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

Warns about a class being defined with duplicate bases, which is redundant and can lead to confusion about the class’s inheritance hierarchy. Removing duplicate bases clarifies the class structure.

class Animal:
pass


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

Indicates a format string that expects a mapping (e.g., a dictionary) but is provided with a different type. This mismatch can lead to runtime errors during string formatting operations. Ensuring the correct type is provided to format strings maintains their intended functionality.

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

Flags instances where a function is redefined within the same scope, potentially overwriting the previous definition. This can lead to unexpected behavior and logic errors. Ensuring each function has a unique name within its scope prevents these issues.

def get_email():
pass


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

Indicates an error in importing a module or package, which could be due to a missing dependency, incorrect path, or other issues. Resolving import errors is crucial for ensuring that all code dependencies are correctly managed and accessible.

from patlib import Path  # [import-error]

Detects classes with an inconsistent method resolution order (MRO), which can lead to errors in method inheritance and overriding. Ensuring a consistent MRO is essential for the predictable behavior of class hierarchies.

class A:
pass


class B(A):
pass


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

Flags instances where an attempt is made to inherit from a non-class object. This rule is important because Python’s class inheritance mechanism requires that all bases of a class are themselves classes. Attempting to inherit from non-class objects will lead to a TypeError at runtime.

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

Identifies if the init method of a class is defined as a generator, which is incorrect because init should initialize the instance and cannot yield values. This rule helps prevent a common mistake that can lead to unexpected behavior or runtime errors.

class Fruit:
def __init__(self, worms):  # [init-is-generator]
    yield from worms


apple = Fruit(["Fahad", "Anisha", "Tabatha"])

Warns when the all variable, which should explicitly export module symbols, is not formatted as a tuple or list. Correctly defining all is crucial for module encapsulation and namespace control, ensuring that only intended names are exported.

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

CONST = 42

Indicates that an object within the all list or tuple is not a string. Since all should contain the names of objects to be exported by a module, having non-string objects can lead to errors when the module is imported or used.

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


class Fruit:
pass


class Worm:
pass

Flags cases where a custom bool method does not return a boolean value. The bool method is used to determine the truth value of an object, and returning non-bool values can lead to incorrect behavior in boolean contexts.

class CustomBool:
"""__bool__ returns an int"""

def __bool__(self):  # [invalid-bool-returned]
    return 1

Identifies when a bytes method does not return a bytes object. This method should return the bytes representation of the object, and returning anything other than bytes can cause type errors or unexpected behavior.

class CustomBytes:
"""__bytes__ returns <type 'str'>"""

def __bytes__(self):  # [invalid-bytes-returned]
    return "123"

Warns about the use of an invalid, unescaped backspace character in a string. It suggests using ”” for a backspace character to avoid syntax errors or unintended behavior in strings.

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

Highlights the use of an invalid, unescaped carriage return character, recommending the use of ” ” instead. Proper escaping is necessary to ensure the character is interpreted correctly by Python.

Flags the improper use of an unescaped ESC character in a string, suggesting the use of ”” for clarity and correctness. Escaping special characters prevents errors in string processing.

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

Indicates an invalid unescaped NUL character in a string, recommending the use of ”�” instead. The NUL character must be properly escaped to be included in strings without causing errors.

Warns about the use of an unescaped SUB (substitute) character, advising to use ”” for correct representation. Proper escaping ensures that control characters are treated correctly in strings.

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

Identifies the improper use of an unescaped zero-width space character, recommending ”​” for correct inclusion in strings. Escaping this character is necessary to avoid syntax errors and ensure it is interpreted correctly.

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

Flags incorrect assignments to the ‘class’ attribute, which should only be assigned class definitions. This rule helps maintain the integrity of the object model by ensuring ‘class’ accurately reflects the object’s class structure.

class Apple:
pass


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

Warns against extending an already inherited Enum class. Python’s enum classes are designed to be final; extending them can lead to unexpected behavior or errors. This rule ensures that enums are used as intended, providing clear, immutable sets of named values.

from enum import Enum


class Color(Enum):
ORANGE = 1
CHERRY = 2


class Fruit(Color):  # [invalid-enum-extension]
APPLE = 3

Indicates that an environment variable does not support a given type argument, highlighting the importance of ensuring environment variables are correctly parsed and validated to match the expected types used in the application.

import os

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

Flags incorrect usage of the field() function, typically seen in data classes. This rule helps ensure that field definitions are correct and conform to the expectations of Python’s data model, preventing runtime errors.

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]

Identifies when a custom format method does not return a string. Since format is used in string formatting operations, returning any other type can cause type errors or unexpected behavior in formatted strings.

class CustomFormat:
"""__format__ returns <type 'int'>"""

def __format__(self, format_spec):  # [invalid-format-returned]
    return 1

Warns if getnewargs_ex does not return a tuple containing a tuple and a dict. This method is crucial for customizing pickling behavior, and its return values must conform to this structure to ensure objects are pickled and unpickled correctly.

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)

Flags cases where getnewargs does not return a tuple. Similar to getnewargs_ex, this method supports pickling and must return a tuple to function correctly, ensuring objects can be serialized and deserialized properly.

class CustomGetNewArgs:
"""__getnewargs__ returns an integer"""

def __getnewargs__(self):  # [invalid-getnewargs-returned]
    return 1

Indicates that a custom hash method does not return an integer. Since hashes are used to uniquely identify objects, especially in collections like sets and dictionaries, returning non-int values can lead to incorrect behavior or errors.

class CustomHash:
"""__hash__ returns dict"""

def __hash__(self):  # [invalid-hash-returned]
    return {}

Warns when index does not return an integer. The index method should return an integer to be used when the object is operated on by built-in functions and operators expecting a numerical index, ensuring correct integration with Python’s data model.

class CustomIndex:
"""__index__ returns a dict"""

def __index__(self):  # [invalid-index-returned]
    return {"19": "19"}

Identifies when length_hint does not return a non-negative integer. This method is used to provide an estimate of the number of elements in an iterable, and returning incorrect types or values can mislead functions that rely on this hint for optimization.

class CustomLengthHint:
"""__length_hint__ returns non-int"""

def __length_hint__(self):  # [invalid-length-hint-returned]
    return 3.0

Flags incorrect return types from len, which must always return a non-negative integer. This ensures that the length of a collection is accurately reported, supporting Python’s built-in len() function and the sizing of collections.

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

def __len__(self):  # [invalid-length-returned]
    return -len(self.fruits)

Highlights the use of an invalid metaclass. Metaclasses are used in Python to control the creation of classes, and using an incorrect metaclass can lead to unexpected behavior or errors in class creation and inheritance.

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

Warns if repr does not return a string. The repr method should provide a clear, unambiguous string representation of an object for debugging and logging, and returning a non-string violates this contract.

class CustomRepr:
"""__repr__ returns <type 'int'>"""

def __repr__(self):  # [invalid-repr-returned]
    return 1

Indicates that an index used on a sequence is not of a valid type. Valid types include integers, slices, or instances with an index method. Ensuring indexes are of the correct type is crucial for the predictable behavior of sequence operations.

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

Flags slice indexes that are not integers, None, or instances with an index method. Correct slice indexes are essential for the expected slicing behavior of sequences, supporting flexible and error-free slicing operations.

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

FIRST_THREE = LETTERS[:"3"]  # [invalid-slice-index]

Identifies slice steps that are set to 0, which is invalid since a step of 0 would result in an undefined slice. This rule ensures that slices are defined with a valid step, avoiding runtime errors and maintaining the integrity of slice operations.

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

LETTERS[::0]  # [invalid-slice-step]

Flags an incorrectly defined slots object. The slots declaration is used to explicitly declare data members and prevent the creation of dict and weakref for each instance, optimizing memory usage. Invalid slots definitions can lead to runtime errors or unintended behavior.

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

Indicates that an object within slots is not a valid non-empty string. slots should contain names of instance attributes, defined as non-empty strings, to properly allocate space for them. Invalid objects in slots can prevent the expected optimization and might cause attribute errors.

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

Warns when a starred expression is used outside of a list or tuple context. Starred expressions are used for unpacking iterables and must be part of a list or tuple assignment, ensuring correct and predictable unpacking behavior.

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

Identifies when a custom str method does not return a string. The str method should provide a readable string representation of an object, and returning a non-string type can lead to type errors and misunderstandings about the object’s representation.

class CustomStr:
"""__str__ returns int"""

def __str__(self):  # [invalid-str-returned]
    return 1

Flags an invalid operand type for a unary operation, such as negation or bitwise not. This rule ensures that unary operations are used with compatible types, preventing runtime type errors and promoting type-safe operations.

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

Advises against using UTF-16 or UTF-32 due to their lack of backward compatibility with ASCII, recommending UTF-8 instead. UTF-8 is universally accepted and provides better compatibility and efficiency, especially for web and internationalized applications.

Warns when a logging format string is truncated, ending in the middle of a conversion specifier. This can lead to incomplete log messages and is usually the result of an accidental omission or typo in the format string.

import logging
import sys

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

Indicates that there are not enough arguments provided to a logging format string, which can result in a runtime error when the logging statement is executed. Ensuring the correct number of arguments for format strings is essential for accurate and error-free logging.

import logging

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

Flags when more arguments are provided to a logging format string than placeholders available in the string. This can lead to unused arguments and might indicate a misunderstanding of the format string’s requirements or an error in argument preparation.

import logging

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

Identifies an unsupported format character in a logging statement. This rule helps ensure that logging format strings are correctly formed, using only supported format specifiers to prevent runtime errors or malformed log messages.

import logging

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

Warns when an attribute defined elsewhere hides a method of the same name. This can lead to unexpected behavior, as the attribute will take precedence over the method, potentially causing errors or confusion about the object’s interface.

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

def vitamins(self):  # [method-hidden]
    pass

Indicates a raise statement used outside of an except clause, which can lead to a RuntimeError since there’s no active exception to re-raise. This rule ensures that raise statements are used correctly, within the context of exception handling.

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

Flags when the format function is used on an object that is not a string. Since format is intended for string formatting, calling it on non-strings is likely an error and can lead to unexpected behavior or type errors.

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

Identifies when a key referenced in a format string is missing from the format string’s dictionary argument. This can lead to a KeyError at runtime, making it important to ensure that all keys used in format strings are provided in the accompanying dictionary.

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

Flags a function call missing a mandatory keyword-only argument. This rule ensures that all required arguments are provided in function calls, particularly important for functions that define parameters with the keyword-only syntax, improving code reliability and preventing runtime errors.

def target(pos, *, keyword):
return pos + keyword


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

Warns against mixing named and unnamed placeholders within a single format string. This practice can lead to confusion and errors in string formatting, and maintaining consistency in format specifiers enhances readability and predictability of the output.

Indicates that a dictionary being iterated over in a for loop is also being modified within the loop. Modifying a collection while iterating over it can lead to runtime errors or unpredictable behavior. Iterating over a copy of the dictionary is recommended to avoid such issues.

fruits = {"apple": 1, "orange": 2, "mango": 3}

i = 0
for fruit in fruits:
fruits["apple"] = i  # [modified-iterating-dict]
i += 1

Similar to the above, warns when a set being iterated over is modified within the loop. As with dictionaries, this can cause unexpected behavior or errors, and iterating over a copy of the set is advised to maintain correct and predictable iteration behavior.

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

Flags the access of a non-existent member of an object or class, indicating a potential attribute error or a misunderstanding of the object’s interface. This rule helps prevent runtime errors by ensuring that only existing members are accessed.

from pathlib import Path

directories = Path(".").mothers  # [no-member]


class Cat:
def meow(self):
    print("Meow")


Cat().roar()  # [no-member]

Indicates a method definition is missing an argument. This can lead to errors when the method is called and is especially critical for methods expected to adhere to a specific signature, such as those defined in interfaces or base classes.

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

Warns when an attempt is made to import a name from a module, but the name does not exist in that module. This can lead to ImportError at runtime and is often the result of a typo or misunderstanding of the module’s API.

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

Flags a method that does not include self as its first argument, which is required for instance methods in classes to correctly refer to the object instance upon which they are called. Ensuring self is the first argument is fundamental for the method’s access to the instance and its attributes.

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

Indicates that a required parameter is missing a value in a function call. This rule ensures that all necessary arguments are provided to functions, preventing TypeError due to missing arguments and improving function call correctness.

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


add(1)  # [no-value-for-parameter]

Warns if the iter method of a class does not return an iterator object. For a class to be iterable, its iter method must return an object that implements the next method, ensuring compatibility with iteration protocols.

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

Flags the use of an operator that does not exist in Python. This rule helps identify typos or misconceptions about Python’s operators, preventing syntax errors or incorrect assumptions about code behavior.

i = 0

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

Indicates a variable is declared both nonlocal and global, which is contradictory as nonlocal refers to variables in enclosing scopes, excluding the global scope. This rule clarifies scope usage and prevents scope resolution conflicts.

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)

Warns when a nonlocal statement is used for a name that does not have an existing binding in any enclosing scopes, which can lead to errors since nonlocal is intended to refer to previously defined variables in outer non-global scopes.

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

Flags when a value that is not a mapping (e.g., not a dict or similar) is used in a context that expects a mapping, such as in unpacking operations. This rule ensures that values used in mapping contexts correctly support the mapping interface.

def print_colors(**colors):
print(colors)


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

Indicates a value used in a context that requires iteration, such as a for loop, does not support iteration. This rule is essential for preventing runtime errors by ensuring that only iterable objects are used in iterating contexts.

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

Warns that an object meant to be used as an async context manager (with an async with statement) does not implement the required aenter and aexit methods. Implementing these methods is crucial for the correct operation of async context managers, enabling asynchronous resource management.

class ContextManager:
def __enter__(self):
    pass

def __exit__(self, *exc):
    pass


async def foo():
async with ContextManager():  # [not-async-context-manager]
    pass

Flags an attempt to call an object that is not callable, indicating a type error. This rule is critical for identifying objects being used incorrectly as functions or methods, ensuring that only callable objects are invoked, which helps prevent runtime errors.

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

Indicates that an object expected to function as a context manager does not implement the enter and exit methods. For an object to manage resources with a ‘with’ statement, implementing these methods is essential for correct resource acquisition and release.

class MyContextManager:
def __enter__(self):
    pass


with MyContextManager() as c:  # [not-context-manager]
pass

Flags the use of break or continue statements outside of a loop, which is a syntactic error. This rule helps ensure that these control flow statements are used correctly within the context of loops to manage loop execution properly.

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

Warns when NotImplemented is raised instead of NotImplementedError. NotImplemented is a special value used for binary methods to indicate that an operation is not implemented for the given operands, whereas NotImplementedError should be raised when an abstract method or function is not implemented.

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

Flags the incorrect passing of positional-only arguments as keyword arguments in function calls. This rule ensures that arguments are passed according to the function signature, respecting positional-only restrictions to prevent TypeError.

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


cube(n=2)  # [positional-only-arguments-expected]

Indicates a potential error when accessing an index that may be out of bounds for the given iterable. This rule helps identify possible IndexError before runtime by analyzing patterns that could lead to accessing invalid indexes.

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

Flags an attempt to raise an object that is neither an exception class nor an instance of one. This rule ensures that only valid exceptions are raised, adhering to Python’s error handling model and preventing runtime errors.

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]

Warns when an attempt is made to raise a class that does not inherit from BaseException, which is required for all exception classes. This rule helps maintain the integrity of the exception handling system by ensuring that only valid exceptions are used.

raise str  # [raising-non-exception]

Indicates that an argument is passed both by position and keyword in the same function call, which can lead to confusion and errors. This rule helps ensure clarity and consistency in function calls by preventing redundant argument specification.

Flags an attempted relative import that goes beyond the top-level package, which is not allowed. This rule helps maintain proper package structure and import semantics, preventing ImportError caused by invalid relative import paths.

Warns when a keyword argument is specified multiple times in a function call, which is a TypeError. This rule ensures that each keyword argument is uniquely specified, preventing ambiguous or conflicting argument values.

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]

Indicates the use of a return statement with an argument in a generator function, which is not allowed. In Python 3, return in a generator can only be used without an argument to signal the generator’s termination. This rule helps prevent syntax errors and maintains the correct use of generators.

Flags the use of an explicit return statement with a value in the init method of a class. Since init is meant to initialize an instance and not return a value, using return with a value can lead to confusion and is considered incorrect in Python.

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

Indicates a return statement used outside of a function or method definition, which is a syntax error. This rule helps ensure that return statements are correctly placed within the functional or methodological scope.

return 42  # [return-outside-function]

Warns against using the singledispatch decorator with methods, as it’s designed for standalone functions. Python 3.8 introduced singledispatchmethod for methods to support single dispatch based on the type of the first argument in method calls.

from functools import singledispatch


class Board:
@singledispatch  # [singledispatch-method]
@classmethod
def convert_position(cls, position):
    pass

@convert_position.register  # [singledispatch-method]
@classmethod
def _(cls, position: str)  tuple:
    position_a, position_b = position.split(",")
    return (int(position_a), int(position_b))

@convert_position.register  # [singledispatch-method]
@classmethod
def _(cls, position: tuple)  str:
    return f"{position[0]},{position[1]}"

Indicates the misuse of singledispatchmethod decorator with standalone functions. singledispatchmethod is intended for use with methods, while singledispatch is designed for functions, ensuring that the correct decorator is used for single dispatch functionality.

from functools import singledispatchmethod


class Board:
@singledispatchmethod  # [singledispatchmethod-function]
@staticmethod
def convert_position(position):
    pass

@convert_position.register  # [singledispatchmethod-function]
@staticmethod
def _(position: str)  tuple:
    position_a, position_b = position.split(",")
    return (int(position_a), int(position_b))

@convert_position.register  # [singledispatchmethod-function]
@staticmethod
def _(position: tuple)  str:
    return f"{position[0]},{position[1]}"

Flags a starred expression used in a context other than as an assignment target, such as in a function call or outside a list/tuple on the right side of an assignment. Starred expressions are only valid when unpacking values in an assignment.

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

Indicates a syntax error detected in the code, which will prevent the program from running. This rule is fundamental for identifying areas of the code that are incorrectly written and need correction for proper execution.

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

Warns when there are not enough arguments provided to a format string, leading to a runtime error when the string formatting is attempted. Ensuring the correct number of arguments for format strings is crucial for accurate and error-free string formatting.

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

Indicates that more arguments are provided to a format string than there are placeholders for those arguments. This can lead to unused arguments and might suggest a misunderstanding of the format string’s requirements.

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

Flags a function call that has too many positional arguments provided, exceeding the function’s defined parameters. This rule helps ensure function calls are made with the correct number and type of arguments.

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


apple = Fruit("red", "apple", [1, 2, 3])  # [too-many-function-args]

Warns when more than one starred expression is used in an assignment, which is not allowed. Starred expressions can unpack iterable values, but only one such unpacking is permitted per assignment to maintain clarity and prevent ambiguity.

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

Indicates that a format string ends unexpectedly in the middle of a conversion specifier, which can lead to incomplete or incorrect string formatting. Ensuring complete and correct format strings is essential for accurate data representation.

PARG_2 = 1

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

Flags a name referenced in the all variable that has not been defined, which can lead to an ImportError when attempting to import names from the module. This rule ensures that all accurately reflects the module’s public API.

__all__ = ["get_fruit_colour"]  # [undefined-all-variable]


def get_fruit_color():
pass

Indicates the use of a variable that has not been defined, leading to a NameError at runtime. This rule is crucial for identifying typos or logical errors in variable usage, ensuring that all variables are properly declared and assigned.

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

Warns when a function call includes a keyword argument that is not accepted by the function’s signature. This rule helps ensure that function calls are compatible with function definitions, preventing TypeError due to unexpected arguments.

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


print_coordinates(x=1, y=2, z=3)  # [unexpected-keyword-arg]

Indicates that a special method (like len or getitem) is defined with an unexpected number of parameters, which can lead to incorrect behavior or errors when the method is called by Python runtime. Ensuring special methods have the correct signature is vital for adhering to Python’s data model and expected object behaviors.

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

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

Flags an attempt to use an unhashable object (like a list) as a member of a hash-based collection (like a set or dictionary key). This rule is important for ensuring data integrity in collections that rely on the hashability of their elements to function correctly.

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

Warns when there’s an attempt to unpack a non-sequence type, which is not iterable. This rule prevents runtime errors by ensuring that only iterable objects are unpacked, adhering to Python’s requirement for unpacking operations.

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

Indicates the use of an inline option (typically in a comment) that pylint does not recognize. This helps maintain the clarity and effectiveness of inline directives, ensuring they are correctly interpreted by pylint.

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

Flags an option in a pylint configuration file that is not recognized by pylint. This rule helps ensure that configuration files are correctly written and that all specified options are valid and effective.

Warns when an attempt is made to subscript (index or slice) an object that does not support subscripting. This rule is crucial for preventing TypeError by ensuring that subscript operations are only performed on objects that support them.

class Fruit:
pass


Fruit()[1]  # [unsubscriptable-object]

Indicates that an object does not support item assignment, typically flagged when attempting to modify an immutable object. This rule helps prevent runtime errors by ensuring that objects being modified support item assignment.

def pick_fruits(fruits):
for fruit in fruits:
    print(fruit)


pick_fruits(["apple"])[0] = "orange"  # [unsupported-assignment-operation]