Python Best Practices — PEP 8, Clean Code

# PEP 8 compliant
def calculate_total(price, tax_rate):
    return price * (1 + tax_rate)


# Not PEP 8 compliant — still runs identically, just harder for anyone else to read
def calculateTotal(price,tax_rate):
        return price*(1+tax_rate)

# snake_case — functions, variables, methods, modules
def calculate_total(price, tax_rate):
    user_name = "Asha"

# PascalCase — classes
class PaymentProcessor:
    ...

# SCREAMING_SNAKE_CASE — constants (values that never change)
MAX_RETRIES = 3
DEFAULT_TIMEOUT_SECONDS = 30

# _leading_underscore — internal/non-public (covered fully in the Encapsulation module)
class Account:
    def __init__(self):
        self._internal_cache = {}

# 4 spaces per indentation level (never tabs) — covered back in Control Flow
if condition:
    do_something()

# Max line length: 79 characters (many teams relax this to 99-120 in practice,
# but PEP 8's own recommendation is 79 — check your project's actual configured limit)

# Two blank lines between top-level function/class definitions
def first_function():
    ...


def second_function():
    ...


class MyClass:
    ...

# One blank line between methods inside a class
class Account:
    def deposit(self, amount):
        ...

    def withdraw(self, amount):
        ...

# Preferred
total = price * quantity
result = (a + b) * (c - d)

# Avoid
total=price*quantity
result = ( a+b ) * ( c-d )

# 1. Standard library imports
import json
import os
from datetime import datetime

# 2. Third-party imports
import requests
import pandas as pd

# 3. Local/project imports
from myapp.models import User
from myapp.utils import format_currency

def calculate_discount(price, percent):
    """Apply a percentage discount to a price.

    Args:
        price: The original price, in dollars.
        percent: The discount percentage, from 0 to 100.

    Returns:
        The discounted price, rounded to 2 decimal places.

    Raises:
        ValueError: If percent is outside the 0-100 range.
    """
    if not 0 <= percent <= 100:
        raise ValueError(f"Invalid discount percent: {percent}")
    return round(price * (1 - percent / 100), 2)

>>> import this
The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
...

# Smell: a function doing too many unrelated things
def process_order(order):
    validate(order)
    charge_card(order)
    send_email(order)
    update_inventory(order)
    log_analytics(order)
# Better: split into smaller, focused functions — each independently
# testable and each with a name describing exactly one responsibility

# Smell: "magic numbers" with no explanation
if attempts > 3:
    lock_account()
# Better: name the constant, and its meaning becomes self-documenting
MAX_LOGIN_ATTEMPTS = 3
if attempts > MAX_LOGIN_ATTEMPTS:
    lock_account()

pip install black ruff

black your_project/       # auto-formats code to a consistent style — no debate needed
ruff check your_project/  # lints for style issues, unused imports, common bugs, and more

A small team notices that a large fraction of their pull request review comments are about formatting — spacing, line length, whether a string should use single or double quotes — rather than actual logic, correctness, or design. Reviewers spend real time on comments that add no value to the software itself, and authors get frustrated re-litigating style preferences that are ultimately arbitrary.

# Added to CI, blocking merge on failure:
black --check .
ruff check .

# Added to pre-commit hooks, so formatting issues never even reach a PR:
pip install pre-commit
pre-commit install

The actual effect on the team's process

Style-related review comments dropped to nearly zero within two weeks — not because engineers suddenly became more careful, but because black and ruff now caught and auto-fixed nearly everything before a human reviewer ever saw the code. Code review time genuinely shifted toward the things that actually needed a human's judgement — architecture, edge cases, whether the logic was correct — which the team considered the single highest-leverage process change they made that quarter.