Perflint: Pylint Extension for Performance Anti-patterns

0.8.1 · active · verified Thu Apr 16

Perflint is an extension for Pylint that identifies performance anti-patterns in Python code, helping developers optimize their applications by flagging common inefficiencies. It is currently in early beta, version 0.8.1, and may produce false positives. The project is actively maintained with a focus on enhancing code performance through static analysis.

Common errors

```
pylint: error: no such option: --load-plugins=perflint
```
cause Perflint is not installed in the environment where Pylint is being run, or Pylint's version is too old to support plugin loading.

fix Ensure `perflint` is installed in the same virtual environment as Pylint (`pip install perflint`). Also, ensure Pylint is up-to-date.
```
W8101: unnecessary-list-cast
```
cause Using `list()` to cast an already iterable object (like a tuple or generator) into a list unnecessarily creates a new list object, which can be inefficient.

fix Remove the `list()` constructor if the iterable type already suffices, e.g., `for item in my_tuple:` instead of `for item in list(my_tuple):`.
```
W8102: incorrect-dictionary-iterator
```
cause Iterating over `dict.items()` and discarding either the key or the value (e.g., `for _, value in my_dict.items():`) is less efficient than using `dict.keys()` or `dict.values()` directly.

fix Use `for value in my_dict.values():` if only values are needed, or `for key in my_dict.keys():` if only keys are needed.

Warnings

gotcha Perflint is currently an 'early beta' and may generate false positives, requiring careful review of its findings.
Fix: Always manually verify reported performance anti-patterns before refactoring code based on Perflint warnings.
breaking Using `try...except` blocks inside loops can have significant computational overhead, especially in Python versions prior to 3.11 (R8203).
Fix: Refactor code to place the entire loop within a single `try` block, or move exception handling outside the loop if possible, to avoid per-iteration overhead.
gotcha Dotted imports (e.g., `os.path.exists`) inside loops can be inefficient because Python performs multiple lookups in each iteration (W8205).
Fix: Import the specific function or attribute directly before the loop (e.g., `from os.path import exists`) to reduce lookup overhead.
gotcha Accessing global variables within a tight loop can be slower than using local variables (W8202).
Fix: Cache the global variable's value in a local variable outside the loop, then use the local variable inside the loop.

Install

pip install perflint Install Perflint

Imports

Perflint as Pylint Plugin
wrong:
```
from perflint import some_check
```
correct:
```
pylint your_module/ --load-plugins=perflint
```
Perflint is not imported as a Python module in application code. It's loaded as a plugin for Pylint via the command line or configuration.

Quickstart

Save the code above as `my_module.py`. Then run Perflint as a Pylint plugin. It will highlight performance anti-patterns like global lookups in loops, unnecessary list casting, and inefficient dictionary iteration.

import os

def process_data(items):
    # W8202: Global name usage in a loop
    # os.environ is a global lookup; cache it outside the loop for performance.
    for item in items:
        value = os.environ.get(item, 'default') # This will trigger W8202
        print(value)

def unnecessary_list_cast_example(data):
    # W8101: Unnecessary use of list() on an already iterable type
    for x in list(data): # data is already iterable, no need for list()
        print(x)

def incorrect_dict_iterator_example(dictionary):
    # W8102: Incorrect iterator method for dict
    for _, value in dictionary.items(): # If only values are needed, use .values()
        print(value)

if __name__ == '__main__':
    my_items = ['HOME', 'PATH']
    process_data(my_items)
    my_tuple = (1, 2, 3)
    unnecessary_list_cast_example(my_tuple)
    my_dict = {'a': 1, 'b': 2}
    incorrect_dict_iterator_example(my_dict)

view raw JSON →