General · Book or PDF

Think Python 2e

Study material generated by AI from this openly licensed book (CC BY-NC 3.0). Not affiliated with or endorsed by the publisher.

Think Python, 2nd Edition, by Allen B. Downey, Green Tea Press, licensed under CC BY-NC 3.0. Read the original free

Cheat sheet

Term	Meaning
Program	Sequence of instructions telling a computer how to compute something
Variable / assignment	Name for a value; created with `x = 5`
Expression vs. statement	Expression produces a value; statement performs an action
Function	Named block of statements, run by calling it; defined with `def`
Parameter / argument	Parameter is the name inside the function; argument is the value passed in
Local variable	Created inside a function; destroyed when the function returns
Fruitful vs. void	Fruitful returns a value; void returns `None`
Recursion	Function that calls itself; needs a base case
Mutable / immutable	Can / cannot be changed after creation
Aliasing	Two names point to the same object
Dictionary	Maps hashable keys to values (key-value pairs)
Tuple	Immutable sequence of comma-separated values
Memoization	Store computed results in a dict to reuse later
Class / instance	Programmer-defined type / an object made from it
Attribute	Named value attached to an object (`p.x`)
Pure function vs. modifier	Pure returns a result, changes nothing; modifier changes its arguments
Invariant	Condition that should always be true
Inheritance / override	Child class reuses a parent; redefines a method with the same name
Traceback	Error report: exception, line, chain of calls

Operator order: PEMDAS; same level runs left to right, except ** (right to left).
Floor division and remainder: 105 // 60 → 1, 105 % 60 → 45.
Factorial: $0! = 1$ , $n! = n \cdot (n-1)!$
Newton's square root of $a$ : $y = \frac{x + a/x}{2}$ , repeat until $|y - x| < \epsilon$ (e.g. $\epsilon = 10^{-7}$ ).
Regular polygon exterior angle: $\frac{360}{n}$ ; circle: $C = 2\pi r$ .
Indexing: first s[0], last s[-1] or s[len(s)-1]; slice s[n:m] includes $n$ , excludes $m$ .
int(3.9) → 3 (truncates toward zero, no rounding).
One-element tuple: (x,). Format: %d int, %g float, %s string.
Histogram: total = sum(hist.values()), unique = len(hist).
Comprehension: [expr for x in seq if cond]; generator uses ( ) and yields lazily.
Conditional expression: a if cond else b.

Exception	Cause
`NameError`	Undefined variable
`TypeError`	Wrong type of value
`KeyError`	Missing dict key
`IndexError`	Index out of range
`AttributeError`	Missing attribute
`FileNotFoundError`	File doesn't exist (catch with `try/except`)

Incremental development: write a working skeleton → add a little code → test → repeat → remove scaffolding prints.
Encapsulate and generalize: wrap working code in a function → replace fixed values with parameters → refactor shared parts into helpers → add a docstring.
Recursive function: check base case first → call itself on a smaller input → combine result (trust the leap of faith).
While loop: initialize variable → test condition → run body that updates the variable → loop until false (or break).
Counter pattern: count = 0 → traverse → count += 1 on each match.
Search pattern: loop; return False (or index) as soon as found/failed → return True (or -1) after the loop.
Dict of counters: d[c] = d.get(c, 0) + 1 for each item.
Read a file: open(name) → loop over lines → line.strip() removes \n.
Write a file: open(name, 'w') → f.write(str(x)) → f.close().
Debug: read the traceback → check arguments, return value, and how the caller uses it → split complex expressions into temporary variables.

Misconception	Correction
Defining a function runs it	Body runs only when called
Local variables survive the function	They vanish on return; assigning inside a function makes a local unless declared `global`
A missing `return` is harmless	Any path without `return` gives `None`
`a = b` is like algebra equality	It copies a value at one moment; `7 = a` is illegal
`x == 0.1 + 0.2` is safe with floats	Compare with $
You can edit a string/tuple character	Immutable: build a new one
String comparison ignores case	It is case-sensitive: all uppercase letters come before lowercase
`t = t.sort()` sorts `t`	`sort` works in place and returns `None`; now `t` is `None`
`b = a` copies a list	It aliases; use `a[:]` or `copy` (deep copy for nested objects)
`in` checks dict values	It checks keys only
`(a)` is a tuple	Needs a comma: `(a,)`
Mode `'w'` appends	It erases old contents
`==` compares object data	Default checks identity; define `__eq__` (and `__lt__` for `<`)
Child `__init__` runs parent's	Call the parent's `__init__` explicitly
The error is on the flagged line	Syntax errors are often earlier
Passing tests means no bugs	Tests show bugs exist, not that none exist; test edge cases like `''`
`zip` checks lengths	It stops at the shortest sequence

"SRS errors" – Syntax, Runtime, Semantic: won't start, crashes, wrong answer.
"Base before Branch": in recursion, check the base case before the recursive call.
"In at the start, out before the end": slice s[n:m] includes $n$ , stops before $m$ .
"Lists Lend, Tuples Lock": lists can change; tuples (and strings) are locked, so only they can be dict keys.
"IUT" for while loops – Initialize, Update, Terminate: skip one and the loop breaks or never ends.