Chapter 1: Getting Started with Pylint Basics

Knowledge Points

Pylint Overview

Pylint is a Python static code analysis tool used for:

• Checking programming errors: Syntax errors, logic errors, runtime errors
• Enforcing coding standards: PEP8 specifications, naming conventions
• Checking code smells: Duplicate code, excessive complexity
• Providing refactoring suggestions: Code optimization and improvement recommendations

Core Features of Pylint

graph TD
    A[Pylint Core Features] --> B[Error Detection]
    A --> C[Code Style Checking]
    A --> D[Code Complexity Analysis]
    A --> E[Refactoring Suggestions]

    B --> B1[Syntax Errors]
    B --> B2[Logic Errors]
    B --> B3[Import Errors]

    C --> C1[PEP8 Standards]
    C --> C2[Naming Conventions]
    C --> C3[Formatting]

    D --> D1[Cyclomatic Complexity]
    D --> D2[Code Duplication]
    D --> D3[Function Length]

    E --> E1[Code Optimization]
    E --> E2[Performance Improvements]
    E --> E3[Readability Enhancement]

Importance of Code Quality

Sample Code

Installation and Basic Usage

# Install Pylint
# pip install pylint

# Example: A simple Python file
# sample.py
def calculate_area(radius):
    """Calculate the area of a circle"""
    import math  # Not recommended to import inside function
    pi = 3.14159  # Should use math.pi
    area = pi * radius * radius
    return area

def main():
    r = 5
    area = calculate_area(r)
    print(f"The area of the circle is: {area}")

if __name__ == "__main__":
    main()

# Run Pylint check
pylint sample.py

# Example output:
# ************* Module sample
# sample.py:3:4: C0415: Import outside toplevel (math) (import-outside-toplevel)
# sample.py:4:4: C0103: Constant name "pi" doesn't conform to UPPER_CASE naming style (invalid-name)
# sample.py:1:0: C0114: Missing module docstring (missing-module-docstring)
#
# -----------------------------------
# Your code has been rated at 4.00/10

Improved Code

"""
Module for calculating geometric shape areas

This module contains functionality for calculating circular areas.
"""
import math


def calculate_area(radius):
    """
    Calculate the area of a circle

    Args:
        radius (float): The radius of the circle

    Returns:
        float: The area of the circle

    Raises:
        ValueError: When radius is negative
    """
    if radius < 0:
        raise ValueError("Radius cannot be negative")

    area = math.pi * radius * radius
    return area


def main():
    """Main function"""
    radius = 5.0
    area = calculate_area(radius)
    print(f"The area of a circle with radius {radius} is: {area:.2f}")


if __name__ == "__main__":
    main()

# Pylint check on improved code
pylint improved_sample.py

# Example output:
# -----------------------------------
# Your code has been rated at 10.00/10 (previous run: 4.00/10, +6.00)

Basic Command-Line Options

# Common Pylint command examples

# 1. Basic check
# pylint myfile.py

# 2. Check entire package
# pylint mypackage/

# 3. Generate configuration file
# pylint --generate-rcfile > .pylintrc

# 4. Specify output format
# pylint --output-format=json myfile.py

# 5. Show only errors and warnings
# pylint --errors-only myfile.py

# 6. Disable specific checks
# pylint --disable=C0103,C0114 myfile.py

# 7. Show statistics
# pylint --reports=yes myfile.py

# 8. Set minimum score
# pylint --fail-under=8.0 myfile.py

Message Code Examples

# Code examples demonstrating various Pylint messages
# pylint_examples.py

# C0103: invalid-name
variable_name_too_long_and_not_descriptive = "bad naming"
x = 10  # Variable name too short

# C0114: missing-module-docstring
# Missing module docstring

def function_without_docstring():  # C0116: missing-function-docstring
    pass

class MyClass:  # C0115: missing-class-docstring
    def __init__(self):
        self.value = 10

    def method_with_unused_variable(self):  # W0612: unused-variable
        unused_var = "not used"
        return self.value

# R0903: too-few-public-methods
class EmptyClass:
    pass

# W0613: unused-argument
def function_with_unused_arg(used_arg, unused_arg):
    return used_arg * 2

# E1101: no-member
# someobject.nonexistent_method()  # Would error

# R0914: too-many-locals
def function_with_many_variables():
    var1 = 1
    var2 = 2
    var3 = 3
    var4 = 4
    var5 = 5
    var6 = 6
    var7 = 7
    var8 = 8
    var9 = 9
    var10 = 10
    var11 = 11
    var12 = 12
    var13 = 13
    var14 = 14
    var15 = 15
    var16 = 16  # Exceeds default limit of 15 local variables
    return sum([var1, var2, var3, var4, var5, var6, var7, var8,
                var9, var10, var11, var12, var13, var14, var15, var16])

Inline Message Disabling

# Methods for disabling Pylint messages inline

# Disable specific message for a single line
variable_name = "test"  # pylint: disable=invalid-name

# Disable multiple messages
def short_function():  # pylint: disable=missing-function-docstring,invalid-name
    return True

# Disable for code block
# pylint: disable=missing-class-docstring,too-few-public-methods
class SimpleClass:
    def __init__(self):
        self.value = 42
# pylint: enable=missing-class-docstring,too-few-public-methods

# Disable specific message for entire file (place at beginning of file)
# pylint: disable=missing-module-docstring

# More specific disabling method
def complex_calculation():
    """Perform complex calculation"""
    # pylint: disable-next=invalid-name
    x = 10  # This line will ignore invalid-name check

    return x * 2

Understanding the Scoring System

# Pylint scoring system example
"""
Pylint score calculation:
- Base score: 10.0
- Error: -10 points
- Warning: -2 points
- Convention: -1 point
- Refactor: -5 points
- Fatal: -10 points

Final score = 10.0 - (errors*10 + warnings*2 + conventions*1 + refactors*5) / total_statements * 10
"""

# Example: Low-score code
def bad_function(a,b,c,d,e,f,g,h,i,j):  # Too many parameters
    x=a+b  # Missing spaces
    y=c+d
    z=e+f
    if x>10:  # Missing spaces
        if y>20:  # Too much nesting
            if z>30:
                return True
    return False

# Example: High-score code
def good_function(first_number, second_number):
    """
    Calculate the sum of two numbers

    Args:
        first_number (int): The first number
        second_number (int): The second number

    Returns:
        int: The sum of the two numbers
    """
    return first_number + second_number


def demonstrate_score_improvement():
    """Demonstrate how to improve Pylint score"""
    # Good practices:
    # 1. Add docstrings
    # 2. Use descriptive variable names
    # 3. Follow PEP8 formatting
    # 4. Avoid complex nesting
    # 5. Limit function parameter count

    result = good_function(10, 20)
    return result

Output Format Examples

# Examples of different output formats

# 1. Default text format
# pylint myfile.py
"""
************* Module myfile
myfile.py:1:0: C0114: Missing module docstring (missing-module-docstring)
myfile.py:3:0: C0116: Missing function or method docstring (missing-function-docstring)
-----------------------------------
Your code has been rated at 5.00/10
"""

# 2. JSON format
# pylint --output-format=json myfile.py
"""
[
    {
        "type": "convention",
        "module": "myfile",
        "obj": "",
        "line": 1,
        "column": 0,
        "path": "myfile.py",
        "symbol": "missing-module-docstring",
        "message": "Missing module docstring",
        "message-id": "C0114"
    }
]
"""

# 3. Colorized format
# pylint --output-format=colorized myfile.py

# 4. Report format
# pylint --reports=yes myfile.py
"""
Report
======
15 statements analysed.

Statistics by type
------------------
|type      |number |%      |previous |difference |
|----------|-------|-------|---------|-----------|
|module    |1      |6.67   |1        |=          |
|class     |1      |6.67   |1        |=          |
|method    |2      |13.33  |2        |=          |
|function  |1      |6.67   |1        |=          |
"""

Pylint Installation Verification

# Script to verify Pylint installation
# check_pylint.py
"""Check Pylint installation and basic functionality"""

import subprocess
import sys


def check_pylint_installation():
    """Check if Pylint is correctly installed"""
    try:
        result = subprocess.run(
            [sys.executable, '-m', 'pylint', '--version'],
            capture_output=True,
            text=True,
            check=True
        )
        print("✅ Pylint installed successfully!")
        print(f"Version info:\n{result.stdout}")
        return True
    except subprocess.CalledProcessError:
        print("❌ Pylint is not installed or has installation issues")
        print("Please run: pip install pylint")
        return False
    except FileNotFoundError:
        print("❌ Python environment has issues")
        return False


def run_sample_check():
    """Run sample code check"""
    sample_code = '''
def hello():
    print("Hello, World!")

hello()
'''

    # Create temporary file
    with open('temp_sample.py', 'w', encoding='utf-8') as f:
        f.write(sample_code)

    try:
        result = subprocess.run(
            [sys.executable, '-m', 'pylint', 'temp_sample.py'],
            capture_output=True,
            text=True
        )
        print("✅ Pylint basic functionality working!")
        print("Sample check results:")
        print(result.stdout)
    except Exception as e:
        print(f"❌ Pylint error: {e}")
    finally:
        # Clean up temporary file
        import os
        if os.path.exists('temp_sample.py'):
            os.remove('temp_sample.py')


if __name__ == "__main__":
    if check_pylint_installation():
        run_sample_check()

Pylint is an indispensable code quality tool in Python development. Mastering its basic usage is the first step toward writing high-quality Python code.