PCAP-31-03 — Reading Guide

The core reading: the three import styles (import m / from m import name / import m as alias), the module search path, and the classic `if __name__ == '__main__':` guard — a module's __name__ is '__main__' when run directly and the module's own name when imported. Executing an imported module runs its top-level code exactly once (later imports reuse the cached object).

A package is a folder of modules marked by __init__.py. Learn dotted imports (import pkg.sub), and how __all__ controls exactly which names `from pkg import *` brings in. Single-underscore names are skipped by import *.

Exam traps live here: floor rounds toward -infinity, ceil toward +infinity, trunc toward zero; sqrt ALWAYS returns a float (sqrt(9) → 3.0). Also pi, e, and factorial.

The single most-tested distinction: randint(a, b) INCLUDES b, but randrange(a, b) EXCLUDES it (range semantics). choice() returns one element, sample() a subset, shuffle() reorders in place, seed() makes runs reproducible.

sys.path is the ordered list of directories import searches. The platform module is on the blueprint too: platform.system() returns 'Linux'/'Windows'/'Darwin', platform.machine()/processor() the hardware, platform.python_version() the interpreter version.

The main reading. Nail the clause semantics: else runs only when NO exception fired; finally ALWAYS runs (and a return in finally overrides one in try). Catch multiple types with a tuple `except (A, B):`; bind with `as e`; re-raise with a bare `raise`. Custom exceptions subclass Exception. `assert cond, msg` raises AssertionError when cond is falsy — and is disabled entirely under the -O flag.

Memorise the tree at the bottom of this page. BaseException is the true root; Exception is what you normally subclass and catch. Know that LookupError is the base of IndexError and KeyError; ArithmeticError is the base of ZeroDivisionError; ValueError vs TypeError (wrong value vs wrong type); FileNotFoundError is an OSError. A base class in an except clause must come AFTER its subclasses or it makes them unreachable.

How raise works with and without an argument, and `raise X from Y` for chaining. Caught instances carry .args (a tuple of the constructor arguments) and str(e) for the message.

The reference for every method the exam uses: split/join/strip/replace/find vs index (find returns -1, index raises)/count/startswith/upper/lower and the is* predicates. Remember strings are IMMUTABLE — every method returns a new string; s[0]='x' raises TypeError.

The gentle introduction to negative indexing (s[-1] is the last char), slicing (start-inclusive, stop-exclusive), steps and reversal (s[::-1]), and why slicing never raises on out-of-range bounds while plain indexing does.

ord('A') → 65 and chr(65) → 'A' are inverses; string comparison is by code point, so 'Z' (90) < 'a' (97). Skim the format() mini-language for {} placeholders and alignment/precision.

The single most important reading for the exam. self, __init__, the difference between class variables (shared) and instance variables (per-object) and how assigning through self SHADOWS a class variable, inheritance, super().__init__(), and name mangling (__x inside class C becomes _C__x). Also scopes — the setup for closures/nonlocal in Block 5.

With class C(A, B), method lookup follows the Method Resolution Order — C, then bases left-to-right, then object — computed by C3 linearization. Read C.__mro__ to see it. This is a favourite 'which method runs?' question.

How to make your objects behave like built-ins: __str__ (for print/str) vs __repr__ (debug/echo), __eq__ for ==, __add__ for +, __len__ for len(), __call__ to make an instance callable, __init__/__new__/__del__ lifecycle. Skim — you need recognition, not memorisation.

type(), isinstance(obj, Class) (True for subclasses; pass a tuple to test several), issubclass(A, B) (class-to-class), hasattr/getattr(with a default)/setattr, dir(), vars() (an object's __dict__). Know isinstance vs `type(x) is Class` (exact type only).

List, dict, and set comprehensions and nested/flattening forms. The key distinction the exam tests: a trailing `if` is a FILTER ([x for x in xs if cond]), while an `if/else` BEFORE the for is a per-element TRANSFORM.

A lambda is a single-EXPRESSION anonymous function. map/filter return lazy, single-pass iterators in Python 3 (wrap in list()). sorted(..., key=...) returns a NEW list; list.sort() mutates in place and returns None.

The iterator protocol is __iter__ + __next__ (raising StopIteration when done). A function with `yield` is a generator; (expr for x in xs) is a generator expression. All are LAZY and SINGLE-PASS — once exhausted they yield nothing more. PEP 255 is the original generators proposal.

Open modes: 'r' read, 'w' TRUNCATES/creates, 'a' appends, 'x' fails if the file exists, '+' read/update, 'b' binary. read()/readline()/readlines() and iterating a file line-by-line. Always prefer `with open(...) as f:` — it closes the file even on an exception (PEP 343).

The LEGB lookup rule, and how a closure (an inner function) captures variables from its enclosing scope. Use `nonlocal` to REBIND an enclosing variable, `global` for module scope. Watch the late-binding trap: closures capture the variable, not its value at creation.