Python Code Style and PEP 8

Conventions only help if the names themselves carry meaning. remaining_places = capacity - enrolled explains itself; r = c - e follows the style rules and still tells the reader nothing. Avoid single-letter names except for short loops and well-known maths (i, x, y), and avoid l, O and I, which look like 1 and 0 in many fonts. Functions are usually named for what they do (calculate_fee) and booleans for the question they answer (is_full, has_paid).

PEP 8's main layout rules:

• 4 spaces per indentation level, never tabs mixed with spaces.
• Line length: 79 characters in PEP 8; many projects choose 88 (Black's default) or 99–120. Pick one and apply it everywhere.
• Blank lines: two around top-level functions and classes, one between methods.
• Spaces around assignment and comparison operators (x = y + 1), after commas, but not inside brackets (spam(ham[1], {eggs: 2})) or before a call's opening bracket (print(x), not print (x)).
• No spaces around = for keyword arguments and defaults: def book(lane, time=None): and book(3, time="18:00").

# Avoid
total=price*qty+fee
result = calculate( lanes [0] , fee = 5 )
# Prefer
total = price * qty + fee
result = calculate(lanes[0], fee=5)

Avoid aligning code with extra spaces to make columns line up; adding one longer name forces you to realign every line, and diffs become noisy.

Put imports at the top of the file, one module per line, in three groups separated by blank lines:

import csv                      # 1. standard library
from pathlib import Path

import requests                 # 2. third-party packages

from swimclub.fees import calculate_fee   # 3. your own project

Within each group, sort alphabetically. Prefer explicit imports: from module import * hides where names come from, can silently overwrite your own names, and confuses linters. Absolute imports (from swimclub.fees import ...) are clearer than relative ones in most code.

A typical module is laid out as: docstring, imports, constants, classes and functions, then an if __name__ == "__main__": block. Following that order means readers always know where to look.

PEP 8 itself says consistency within a project matters more than consistency with PEP 8, and consistency within a function matters most. It also lists reasons to break a rule, for example to match surrounding code or to stay compatible with older versions.

The practical answer is to let tools decide:

• Black (or ruff format) reformats code automatically to one style, removing almost all debate about layout.
• Ruff (or Flake8 and Pylint) reports naming problems, unused imports, unused variables, likely bugs and much more; ruff check --fix fixes many automatically, including import sorting.
• pre-commit runs these tools on every commit, so badly formatted code never reaches the repository.

Record the choices in pyproject.toml, for example [tool.ruff] line-length = 88, so every editor and CI run uses the same settings.

Task: refactor an enrolment script for meaningful names, consistent whitespace and clear imports without changing behaviour.

# Original:
# import sys,math
# def f(c,e): return math.ceil((c-e)/2)
# print(f(24,17))

import math


def lanes_needed(waiting_swimmers, per_lane):
    """Return the number of extra lanes for the waiting list."""
    return math.ceil(waiting_swimmers / per_lane)


capacity = 24
enrolled = 17
print(lanes_needed(capacity - enrolled, per_lane=2))   # 4, same as before

The unused sys import is removed, names explain the calculation, and the output is unchanged. For the worked check, Python functions are commonly named in snake_case.

Read PEP 8 itself; it's shorter than you might expect. The Black and Ruff documentation explain configuration. Continue with type checking and revisit naming and assignment. Practise with the Python exercises and Python quiz.