Appendix A: Python Quick Reference

This appendix is a concentrated reference for the Python syntax and patterns covered in this textbook. It is not a tutorial — every item here is explained in detail in the chapter indicated. Use this when you know what you want to do but can't quite remember how to write it.

A.1 Data Types at a Glance

Truthiness Rules (Ch. 4): These values are falsy: False, 0, 0.0, "", [], (), {}, set(), None. Everything else is truthy.

A.2 Operators

Arithmetic Operators

Operator precedence (highest to lowest): ** then * / // % then + -. Use parentheses when in doubt.

Augmented Assignment

Comparison Operators

Chained comparisons: 1 < x < 10 is valid Python (equivalent to 1 < x and x < 10).

Boolean Operators

Precedence: not > and > or.

Identity and Membership

A.3 String Methods (Ch. 7)

Case Methods

Search Methods

Modification Methods (Return New Strings)

Testing Methods

String Indexing and Slicing

s = "Python"
s[0]        # 'P'       — first character
s[-1]       # 'n'       — last character
s[1:4]      # 'yth'     — index 1 up to (not including) 4
s[:3]       # 'Pyt'     — first three characters
s[3:]       # 'hon'     — from index 3 to end
s[::2]      # 'Pto'     — every other character
s[::-1]     # 'nohtyP'  — reversed

A.4 List Methods (Ch. 8)

Adding Elements

Removing Elements

Searching and Counting

Ordering

Copying

shallow = lst.copy()          # or lst[:]
import copy
deep = copy.deepcopy(lst)     # for nested structures

List Comprehensions

[expression for item in iterable]
[expression for item in iterable if condition]
[f(x) for x in range(10) if x % 2 == 0]

A.5 Dictionary Methods (Ch. 9)

Accessing

Adding / Updating

Removing

Iterating

for key in d:                  # iterate over keys
for key in d.keys():           # same as above (explicit)
for value in d.values():       # iterate over values
for key, value in d.items():   # iterate over key-value pairs

Dictionary Comprehensions

{key_expr: val_expr for item in iterable}
{k: v for k, v in d.items() if v > 0}

Useful Standard Library

from collections import defaultdict, Counter, OrderedDict

counts = Counter(["a", "b", "a", "c", "a", "b"])
# Counter({'a': 3, 'b': 2, 'c': 1})

dd = defaultdict(list)
dd["key"].append("val")       # no KeyError — auto-creates empty list

A.6 Set Methods (Ch. 9)

Creating Sets

s = {1, 2, 3}                # set literal
s = set()                     # empty set (NOT {} — that's a dict)
s = set([1, 2, 2, 3])        # from iterable — duplicates removed

Modifying

Set Operations

A.7 Control Flow Syntax

Conditionals (Ch. 4)

if condition:
    # body
elif other_condition:
    # body
else:
    # body

match/case (Ch. 4, Python 3.10+)

match value:
    case "option1":
        # body
    case "option2" | "option3":
        # matches either
    case _:
        # wildcard / default

for Loop (Ch. 5)

for item in iterable:
    # body

for i in range(n):             # 0, 1, ..., n-1
for i in range(start, stop):   # start, start+1, ..., stop-1
for i in range(start, stop, step):

for i, item in enumerate(lst):             # index + value
for a, b in zip(list1, list2):             # parallel iteration

while Loop (Ch. 5)

while condition:
    # body

# Input validation pattern
while True:
    value = input("Enter a number: ")
    if value.isdigit():
        break
    print("Invalid — try again.")

Loop Control

A.8 Function Syntax (Ch. 6)

Defining Functions

def function_name(param1, param2):
    """Docstring describing the function."""
    # body
    return result

# Default parameters
def greet(name, greeting="Hello"):
    return f"{greeting}, {name}!"

# *args — variable positional arguments
def average(*numbers):
    return sum(numbers) / len(numbers)

# Keyword-only arguments
def connect(host, *, port=80, timeout=30):
    pass

# Type hints (informational only — not enforced)
def add(a: int, b: int) -> int:
    return a + b

Returning Multiple Values

def min_max(numbers):
    return min(numbers), max(numbers)

lo, hi = min_max([3, 1, 4, 1, 5])

Lambda Functions (Ch. 19)

square = lambda x: x ** 2
sorted(words, key=lambda w: len(w))

A.9 Class Syntax (Ch. 14-16)

Basic Class

class Dog:
    species = "Canis familiaris"    # class attribute

    def __init__(self, name, age):
        self.name = name            # instance attribute
        self.age = age

    def __str__(self):
        return f"{self.name} ({self.age} years)"

    def __repr__(self):
        return f"Dog(name={self.name!r}, age={self.age})"

    def __eq__(self, other):
        return self.name == other.name and self.age == other.age

    def bark(self):
        return f"{self.name} says Woof!"

Inheritance (Ch. 15)

class GuideDog(Dog):
    def __init__(self, name, age, handler):
        super().__init__(name, age)
        self.handler = handler

    def bark(self):                  # method overriding
        return f"{self.name} stays quiet (working dog)"

Abstract Base Classes (Ch. 15)

from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return 3.14159 * self.radius ** 2

Dataclasses (Ch. 16)

from dataclasses import dataclass

@dataclass
class Point:
    x: float
    y: float
    label: str = ""

Properties (Ch. 14)

class Temperature:
    def __init__(self, celsius):
        self._celsius = celsius

    @property
    def fahrenheit(self):
        return self._celsius * 9 / 5 + 32

    @fahrenheit.setter
    def fahrenheit(self, value):
        self._celsius = (value - 32) * 5 / 9

A.10 File I/O Patterns (Ch. 10)

Reading Files

# Read entire file
with open("data.txt", "r") as f:
    content = f.read()

# Read line by line (memory-efficient)
with open("data.txt", "r") as f:
    for line in f:
        line = line.strip()
        # process line

# Read all lines into a list
with open("data.txt", "r") as f:
    lines = f.readlines()

Writing Files

# Write (overwrites existing content)
with open("output.txt", "w") as f:
    f.write("Hello\n")
    f.write("World\n")

# Append (adds to end)
with open("output.txt", "a") as f:
    f.write("New line\n")

# Write multiple lines
with open("output.txt", "w") as f:
    f.writelines(["line 1\n", "line 2\n", "line 3\n"])

CSV (Ch. 10, 21)

import csv

# Read CSV
with open("data.csv", "r", newline="") as f:
    reader = csv.DictReader(f)
    for row in reader:
        print(row["name"], row["score"])

# Write CSV
with open("output.csv", "w", newline="") as f:
    writer = csv.DictWriter(f, fieldnames=["name", "score"])
    writer.writeheader()
    writer.writerow({"name": "Alice", "score": 92})

JSON (Ch. 10, 21)

import json

# Read JSON
with open("data.json", "r") as f:
    data = json.load(f)

# Write JSON
with open("output.json", "w") as f:
    json.dump(data, f, indent=2)

# Convert strings
json_string = json.dumps(data)
data = json.loads(json_string)

pathlib (Ch. 10)

from pathlib import Path

p = Path("data") / "reports" / "summary.txt"
p.exists()          # True / False
p.is_file()         # True / False
p.is_dir()          # True / False
p.name              # "summary.txt"
p.stem              # "summary"
p.suffix            # ".txt"
p.parent            # Path("data/reports")
p.read_text()       # read entire file as string
p.write_text("hi")  # write string to file
p.mkdir(parents=True, exist_ok=True)   # create directory
list(p.parent.glob("*.csv"))           # list matching files

A.11 Common Built-in Functions

A.12 f-String Formatting (Ch. 3, 7)

Basic Insertion

name = "Alice"
age = 30
print(f"Name: {name}, Age: {age}")

Format Specifications

Expressions Inside f-Strings

f"{2 + 3}"                    # "5"
f"{name.upper()}"             # "ALICE"
f"{'even' if x % 2 == 0 else 'odd'}"
f"{price:.2f}"                # "19.99"

A.13 Error Handling (Ch. 11)

try:
    result = risky_operation()
except ValueError as e:
    print(f"Bad value: {e}")
except (TypeError, KeyError):
    print("Type or key problem")
except Exception as e:
    print(f"Unexpected: {e}")
else:
    print("No error occurred")
finally:
    print("Always runs — cleanup here")

Raising Exceptions

raise ValueError("Score must be between 0 and 100")

# Custom exception
class InsufficientFundsError(Exception):
    pass

Common Exception Types

A.14 Common Patterns

Accumulator Pattern (Ch. 5)

# Numeric accumulator
total = 0
for num in numbers:
    total += num

# String accumulator
result = ""
for char in text:
    if char.isalpha():
        result += char

# List accumulator
evens = []
for n in range(20):
    if n % 2 == 0:
        evens.append(n)

Sentinel Loop (Ch. 5)

while True:
    value = input("Enter value (or 'quit'): ")
    if value == "quit":
        break
    process(value)

Swap Pattern (Ch. 3)

a, b = b, a     # Pythonic swap — no temp variable needed

Frequency Counting (Ch. 9)

counts = {}
for item in data:
    counts[item] = counts.get(item, 0) + 1

# Or using defaultdict
from collections import defaultdict
counts = defaultdict(int)
for item in data:
    counts[item] += 1

# Or using Counter
from collections import Counter
counts = Counter(data)

Max/Min Tracking (Ch. 5)

best = numbers[0]
for num in numbers[1:]:
    if num > best:
        best = num

Guard Clause / Early Return (Ch. 6)

def process(value):
    if value is None:
        return
    if value < 0:
        raise ValueError("Must be non-negative")
    # main logic here

Input Validation Loop (Ch. 5)

while True:
    try:
        age = int(input("Enter your age: "))
        if 0 <= age <= 150:
            break
        print("Age must be between 0 and 150.")
    except ValueError:
        print("Please enter a valid integer.")

Read-Process-Write Pipeline (Ch. 10)

with open("input.csv", "r", newline="") as infile:
    reader = csv.DictReader(infile)
    results = []
    for row in reader:
        processed = transform(row)
        results.append(processed)

with open("output.csv", "w", newline="") as outfile:
    writer = csv.DictWriter(outfile, fieldnames=results[0].keys())
    writer.writeheader()
    writer.writerows(results)

A.15 Imports and Modules (Ch. 12)

import math                       # import entire module
from math import sqrt, pi         # import specific names
from collections import Counter   # from standard library
import datetime as dt             # alias

# Conditional main block
if __name__ == "__main__":
    main()

Frequently Used Standard Library Modules

A.16 Testing (Ch. 13)

pytest Style

# test_calculator.py
from calculator import add, divide

def test_add_positive():
    assert add(2, 3) == 5

def test_add_negative():
    assert add(-1, -1) == -2

def test_divide_by_zero():
    import pytest
    with pytest.raises(ZeroDivisionError):
        divide(10, 0)

Run: python -m pytest test_calculator.py -v

Assertions

assert condition, "Error message if assertion fails"
assert len(items) > 0, "List must not be empty"

A.17 Regular Expressions Quick Reference (Ch. 22)

import re
re.search(r"\d+", "Age: 25")         # Match object
re.findall(r"\b\w+\b", text)         # List of all words
re.sub(r"\s+", " ", text)            # Replace whitespace
re.split(r"[,;]\s*", "a, b; c")     # Split on delimiters

A.18 Git Quick Reference (Ch. 25)

git init                          # Initialize a repository
git status                        # Check current status
git add filename                  # Stage a file
git add .                         # Stage all changes
git commit -m "message"           # Commit staged changes
git log --oneline                 # View commit history
git branch feature-name           # Create a branch
git checkout feature-name         # Switch to a branch
git checkout -b feature-name      # Create and switch
git merge feature-name            # Merge branch into current
git remote add origin URL         # Add remote
git push -u origin main           # Push to remote
git pull                          # Pull from remote
git clone URL                     # Clone a repository
git diff                          # Show unstaged changes

This reference covers Python 3.12+. For the complete language reference, see docs.python.org.