perflint

The following rules are provided by perflint to identify performance anti-patterns in Python code.

W8101 : Unnecessary `list()` on already iterable type (`unnecessary-list-cast`)
W8102: Incorrect iterator method for dictionary (`incorrect-dictionary-iterator`)
W8201: Loop invariant statement (`loop-invariant-statement`)
W8202: Global name usage in a loop (`loop-global-usage`)
R8203 : Try..except blocks have a significant overhead. Avoid using them inside a loop (`loop-try-except-usage`)
W8204 : Looped slicing of bytes objects is inefficient. Use a memoryview() instead (`memoryview-over-bytes`)
W8205 : Importing the "%s" name directly is more efficient in this loop. (`dotted-import-in-loop`)
W8301 : Use tuple instead of list for a non-mutated sequence. (`use-tuple-over-list`)
W8401 : Use a list comprehension instead of a for-loop (`use-list-comprehension`)
W8402 : Use a list copy instead of a for-loop (`use-list-copy`)
W8403 : Use a dictionary comprehension instead of a for-loop (`use-dict-comprehension`)

The ForLoopChecker class identifies performance anti-patterns specifically related to how iterables are used in for loops. It detects unnecessary type casting and incorrect dictionary iteration methods.

Detected Messages

• W8101 (unnecessary-list-cast): Triggered when list() is called on an object that is already an iterable (like a tuple, list, or set). This is inefficient due to eager iteration.
• W8102 (incorrect-dictionary-iterator): Triggered when .items() is used on a dictionary but the key or value is being ignored using an underscore _. For example, using .items() when you only need values should be replaced with .values().

msgs = {
    "W8101": (
        "Unnecessary using of list() on an already iterable type.",
        "unnecessary-list-cast",
        "Eager iteration of an iterable is inefficient.",
    ),
    "W8102": (
        "Incorrect iterator method for dictionary, use %s.",
        "incorrect-dictionary-iterator",
        "Incorrect use of .items() when not unpacking key and value.",
    ),
}

The LoopInvariantChecker class identifies various performance anti-patterns within for and while loop bodies. It focuses on expressions that do not change during loop execution or operations that incur high overhead when repeated.

Detected Messages

• W8201 (loop-invariant-statement): An expression inside the loop does not depend on any variables that change during the loop. This should be moved outside the loop.
• W8202 (loop-global-usage): Accessing global names inside a loop is slower than accessing local names. Copy the global to a local variable before the loop.
• R8203 (loop-try-except-usage): try..except blocks have overhead. Avoid them inside loops unless used for control flow (Note: applies to Python < 3.11).
• W8204 (memoryview-over-bytes): Slicing bytes objects inside a loop is inefficient. Use memoryview() instead.
• W8205 (dotted-import-in-loop): Accessing dotted global names (e.g., module.attribute) inside a loop is inefficient. Import the name directly before the loop.

msgs = {
    "W8201": (
        "Consider moving this expression outside of the loop.",
        "loop-invariant-statement",
        "None of the variables referred to in this expression change within the loop.",
    ),
    "W8202": (
        "Lookups of global names within a loop is inefficient, copy to a local variable outside of the loop first.",
        "loop-global-usage",
        "Global name lookups in Python are slower than local names.",
    ),
    "R8203": (
        "Try..except blocks have an overhead. Avoid using them inside a loop unless you're using them for control-flow. Rule only applies to Python < 3.11.",
        "loop-try-except-usage",
        "Avoid using try..except within a loop.",
    ),
    "W8204": (
        "Looped slicing of bytes objects is inefficient. Use a memoryview() instead",
        "memoryview-over-bytes",
        "Avoid using byte slicing in loops.",
    ),
    "W8205": (
        'Importing the "%s" name directly is more efficient in this loop.',
        "dotted-import-in-loop",
        "Dotted global names in loops are inefficient.",
    ),
}

The ComprehensionChecker emits the following messages when it detects inefficient loop patterns:

• W8401 (use-list-comprehension): Suggests using a list comprehension instead of a for loop that performs an append or insert operation.
• W8402 (use-list-copy): Suggests using a list copy (e.g., list(iterable)) instead of a for loop that performs an append or insert operation.
• W8403 (use-dict-comprehension): Suggests using a dictionary comprehension instead of a for loop that populates a dictionary via subscript assignment.

msgs = {
    "W8401": (
        "Use a list comprehension instead of a for-loop",
        "use-list-comprehension",
        "",
    ),
    "W8402": (
        "Use a list copy instead of a for-loop",
        "use-list-copy",
        "",
    ),
    "W8403": (
        "Use a dictionary comprehension instead of a for-loop",
        "use-dict-comprehension",
        "",
    ),
}