$devvkit resources --cheatsheet python-cheatsheet

Python Cheatsheet

[programming]

Every essential Python pattern: data structures, strings, control flow, comprehensions, functions, file I/O, and error handling, with syntax and real use cases.114 commands · 7 sections

Python is the language of scripts, automation, and data work. This cheatsheet covers the patterns you write daily: data types and structures, strings and f-strings, control flow, comprehensions, functions and lambdas, file I/O with context managers, and modules with error handling.

Every entry shows real syntax followed by the use case: when and why you reach for it.

Data Types & Structures28

$x: int = 42

Use case: Type annotation: declare an integer variable.Example: age: int = 30

$x: str = "hello"

Use case: Type-annotated string.Example: name: str = "devvkit"

$x: float = 3.14

Use case: Type-annotated float.Example: pi: float = 3.14159

$x: bool = True

Use case: Type-annotated boolean.Example: is_active: bool = True

$lst: list[int] = [1, 2, 3]

Use case: A list: ordered, mutable collection.Example: tags: list[str] = ["api", "auth"]

$tup: tuple[int, str] = (1, "a")

Use case: A tuple: immutable, fixed-size collection.Example: point: tuple[float, float] = (12.5, 42.1)

$d: dict[str, int] = {"a": 1}

Use case: A dictionary: key-value mapping.Example: counts: dict[str, int] = {"error": 3, "warn": 8}

$s: set[int] = {1, 2, 3}

Use case: A set: unique, unordered values.Example: seen: set[str] = {"git", "docker"}

$lst.append(x)

Use case: Add an item to the end of a list.Example: tags.append("dev")

$lst.extend([x, y])

Use case: Add multiple items to a list.Example: tags.extend(["web", "api"])

$lst.insert(0, x)

Use case: Insert an item at a specific index.Example: queue.insert(0, "high-prio")

$lst.pop()

Use case: Remove and return the last item: LIFO stack behavior.Example: last = tasks.pop()

$lst.pop(0)

Use case: Remove and return the first item: FIFO queue behavior.Example: first = queue.pop(0)

$lst.remove(x)

Use case: Remove the first occurrence of a value.Example: tags.remove("api")

$x in lst

Use case: Membership check: is this in the list?Example: if "dev" in tags:

$lst.index(x)

Use case: Find the index of a value.Example: pos = ids.index(42)

$lst.sort()

Use case: Sort a list in place.Example: scores.sort()

$sorted(lst, reverse=True)

Use case: Return a new sorted list, descending.Example: top = sorted(scores, reverse=True)[:3]

$lst[::-1]

Use case: Reverse a list with slicing: the Python idiom.Example: reversed_tasks = tasks[::-1]

$d.get(key, default)

Use case: Read a dict key with a fallback: no KeyError.Example: plan = user.get("plan", "free")

$d.setdefault(key, [])

Use case: Get a key, creating it with a default if missing: group-by pattern.Example: groups.setdefault(city, []).append(name)

$d.keys() / d.values() / d.items()

Use case: Iterate over keys, values, or pairs.Example: for k, v in config.items():

$collections.Counter(lst)

Use case: Count occurrences: frequency analysis.Example: c = Counter(words); c.most_common(5)

$collections.defaultdict(list)

Use case: Dict that auto-creates missing values: group-by without setdefault.Example: by_city = defaultdict(list); by_city["NY"].append(u)

$collections.deque(maxlen=10)

Use case: Fast append/pop at BOTH ends with bounded size: rolling windows.Example: recent = deque(maxlen=10); recent.append(x)

$enumerate(lst)

Use case: Loop with an index: the Pythonic counter.Example: for i, item in enumerate(items):

$zip(a, b)

Use case: Pair up two iterables.Example: for name, age in zip(names, ages):

$isinstance(x, int)

Use case: Type check at runtime.Example: if isinstance(value, (int, float)):

Strings & f-strings17

$s.upper() / s.lower()

Use case: Case conversion.Example: s.upper()

$s.strip()

Use case: Remove surrounding whitespace: clean user input.Example: email = email.strip()

$s.split(",")

Use case: Split into a list by delimiter.Example: parts = "a,b,c".split(",")

$",".join(lst)

Use case: Join a list into a string.Example: csv = ",".join(tags)

$s.replace(old, new)

Use case: Replace all occurrences.Example: clean = code.replace(" ", " ")

$s.startswith("https")

Use case: Prefix check.Example: if url.startswith("https"):

$s.endswith(".json")

Use case: Suffix check.Example: if f.endswith(".json"):

$s.find("x")

Use case: Index of a substring, or -1 if missing.Example: pos = s.find("error")

$"x" in s

Use case: Substring membership.Example: if "prod" in env:

$s[:10]

Use case: Slice: first 10 characters.Example: short = s[:10]

$f"{name} is {age} years old"

Use case: f-string interpolation: the modern way to build strings.Example: f"user {id} plan={plan}"

$f"{x:.2f}"

Use case: Format a float to 2 decimal places.Example: f"total: ${total:.2f}"

$f"{x:>10}"

Use case: Right-align in 10 characters: aligned table output.Example: f"{name:>20} {score}"

$f"{x:,}"

Use case: Thousands separator: readable large numbers.Example: f"revenue: {rev:,}"

$"%s" % value

Use case: Old-style formatting: seen in legacy code, avoid in new code.Example: "Hello %s" % name

$s.title()

Use case: Title case: "hello world" becomes "Hello World".Example: name.title()

$s.isdigit()

Use case: Check if the string is all digits: validate input.Example: if s.isdigit(): n = int(s)

Control Flow & Loops9

$if x > 0: ... elif x == 0: ... else: ...

Use case: Conditional branching.Example: if code == 200: ok() elif code == 404: missing() else: fail()

$for x in iterable:

Use case: Iterate over any iterable.Example: for user in users: print(user["name"])

$for i in range(10):

Use case: Loop a fixed number of times.Example: for i in range(3): retry()

$while condition:

Use case: Loop until a condition is false.Example: while not queue.empty(): process(queue.get())

$break

Use case: Exit the loop immediately.Example: for p in pages: if p.is_complete(): break

$continue

Use case: Skip to the next iteration.Example: for f in files: if f.endswith(".tmp"): continue

for x in items:
    if cond: break
else:

Use case: Loop else: runs only when the loop completed without break.Example: for p in pages: if p.ok(): break else: raise Error("no ok page")

match value:
    case 1: ...
    case _: ...

Use case: Structural pattern matching (Python 3.10+): switch with unpacking.Example: match cmd: case "build": build() case _: help()

$a if cond else b

Use case: Ternary expression: inline conditional.Example: status = "ok" if code == 200 else "bad"

Comprehensions8

$[x * 2 for x in range(10)]

Use case: List comprehension: build a list in one line.Example: squares = [x**2 for x in range(10)]

$[x for x in items if x > 0]

Use case: List comprehension with filter.Example: valid = [v for v in values if v > 0]

${x: x**2 for x in range(5)}

Use case: Dict comprehension.Example: sq = {n: n*n for n in range(5)}

${x.upper() for x in words}

Use case: Set comprehension: deduplicate while transforming.Example: unique = {w.lower() for w in words}

$(x for x in items if x > 0)

Use case: Generator expression: lazy, memory-friendly for large data.Example: total = sum(x for x in big_list if x > 0)

$[[y for y in range(x)] for x in range(3)]

Use case: Nested comprehension: grids and matrices.Example: matrix = [[0] * 3 for _ in range(3)]

$[f(x) for x in items if g(x)]

Use case: Transform AND filter in one pass.Example: names = [u["name"].upper() for u in users if u["active"]]

$sum(x for x in nums)

Use case: Sum a stream: generator keeps memory flat.Example: total = sum(row["total"] for row in rows)

Functions & Lambdas19

def greet(name: str) -> str:
    return f"Hi {name}"

Use case: Define a typed function.Example: def slugify(text: str) -> str: return text.lower().replace(" ", "-")

$def f(a, b=10):

Use case: Default parameter value: optional arguments.Example: def fetch(url, timeout=30):

$def f(*args):

Use case: Variable positional arguments.Example: def log(*messages): print(" ".join(messages))

$def f(**kwargs):

Use case: Variable keyword arguments: config bags.Example: def configure(**opts): db = opts.get("db")

$lambda x: x * 2

Use case: Anonymous function: inline logic for sort/map/filter.Example: sorted(users, key=lambda u: u["age"])

$sorted(items, key=len)

Use case: Sort by a custom key function.Example: sorted(words, key=lambda w: len(w))

$map(f, items)

Use case: Apply a function to every item (lazy).Example: list(map(str.upper, names))

$filter(f, items)

Use case: Keep items where the function is true.Example: list(filter(lambda x: x > 0, nums))

$functools.reduce(f, items)

Use case: Fold a sequence into one value.Example: total = reduce(lambda a, b: a + b, nums)

$return a, b

Use case: Return multiple values as a tuple.Example: def minmax(xs): return min(xs), max(xs)

$functools.lru_cache(maxsize=128)

Use case: Memoize a function: cache expensive computations.Example: @lru_cache def fib(n): return n if n < 2 else fib(n-1) + fib(n-2)

def outer():
    def inner(): ...

Use case: Nested function: closures for counters and decorators.Example: def make_counter(): n = 0 def inc(): nonlocal n; n += 1; return n return inc

@decorator
def f():

Use case: Wrap a function with a decorator: logging, timing, auth.Example: @timer def heavy_work(): ...

def decorator(fn):
    def wrapper(*a, **kw): ...

Use case: Write a decorator: the wrapper pattern.Example: def log_calls(fn): def w(*a, **k): print("call", fn.__name__) return fn(*a, **k) return w

def gen():
    yield x

Use case: Generator function: lazy sequences.Example: def read_lines(path): with open(path) as f: for line in f: yield line

$next(gen)

Use case: Pull the next value from a generator/iterator.Example: first = next(read_lines("app.log"), None)

from dataclasses import dataclass
@dataclass
class User:

Use case: Dataclass: boilerplate-free data containers.Example: @dataclass class Point: x: float y: float

$from typing import Optional, Union, Literal

Use case: Rich type hints: Optional[str], Union[int, str], Literal["a", "b"].Example: def f(x: Optional[str] = None):

$from typing import TypeVar, Generic

Use case: Generics: type-safe containers.Example: T = TypeVar("T") def first(xs: list[T]) -> T: return xs[0]

File I/O & Context Managers16

with open("f.txt") as f:
    data = f.read()

Use case: Read a whole file: the context manager closes it automatically.Example: with open("config.json") as f: data = json.load(f)

with open("f.txt", "w") as f:
    f.write("hello")

Use case: Write a file (overwrites).Example: with open("report.txt", "w") as f: f.write(report)

$with open("f.txt", "a") as f:

Use case: Append to a file: log lines.Example: with open("app.log", "a") as f: f.write(line)

$for line in f:

Use case: Iterate a file line by line: memory-safe for huge files.Example: with open("app.log") as f: for line in f: if "ERROR" in line: ...

$pathlib.Path("dir")

Use case: Modern path handling: cross-platform, chainable.Example: p = Path("src") / "main.py"

$p.exists() / p.is_file()

Use case: Check a path exists and its type.Example: if Path(".env").exists():

$p.mkdir(parents=True, exist_ok=True)

Use case: Create directories recursively: no error if present.Example: Path("build/assets").mkdir(parents=True, exist_ok=True)

$p.read_text() / p.write_text("x")

Use case: Read/write a text file via pathlib.Example: content = Path("README.md").read_text()

$Path("dir").glob("*.txt")

Use case: Glob files in a directory.Example: for f in Path("logs").glob("*.log"):

$Path("f").unlink()

Use case: Delete a file.Example: Path("old.tmp").unlink(missing_ok=True)

$Path("f").rename("new")

Use case: Rename or move a file.Example: Path("report.txt").rename("report-2026.txt")

$json.dump(obj, f)

Use case: Serialize Python data to JSON.Example: with open("out.json", "w") as f: json.dump(data, f, indent=2)

$json.load(f)

Use case: Parse JSON from a file.Example: with open("config.json") as f: cfg = json.load(f)

$from contextlib import contextmanager

Use case: Build your own context manager for setup/teardown.Example: @contextmanager def timer(): t = time.time() yield print(f"took {time.time()-t:.2f}s")

import csv
csv.DictReader(f)

Use case: Read CSV into dicts: headers become keys.Example: with open("users.csv") as f: for row in csv.DictReader(f): ...

import shutil
shutil.copy(src, dst)

Use case: Copy files/directories with stdlib.Example: shutil.copy(".env.example", ".env")

Modules & Error Handling17

import os
os.environ.get("KEY")

Use case: Read environment variables: config without code changes.Example: db_url = os.environ.get("DATABASE_URL")

import sys
sys.exit(1)

Use case: Exit a script with a non-zero code: signal failure to CI.Example: if not args: sys.exit("no args")

$import argparse

Use case: Parse CLI arguments: professional scripts.Example: parser = argparse.ArgumentParser(); parser.add_argument("--verbose", action="store_true")

import subprocess
subprocess.run(["ls", "-la"], check=True)

Use case: Run shell commands from Python: automation glue.Example: subprocess.run(["npm", "run", "build"], check=True)

import re
re.search(r"\d+", s)

Use case: Regex search: extract patterns.Example: m = re.search(r"v(\d+\.\d+)", version)

import requests
requests.get(url, timeout=10)

Use case: HTTP requests (third-party, pip install requests).Example: r = requests.get("https://api.github.com", timeout=10); r.json()

import time
time.sleep(1)

Use case: Pause execution: retry loops and rate limiting.Example: for attempt in range(3): try: connect(); break except: time.sleep(2)

try:
    risky()
except ValueError as e:

Use case: Catch a specific exception type.Example: try: n = int(text) except ValueError: n = 0

try:
    ...
except (TypeError, ValueError):

Use case: Catch multiple exception types together.Example: except (KeyError, IndexError):

try:
    ...
finally:

Use case: Always-run cleanup: close connections, release locks.Example: try: process() finally: conn.close()

try:
    ...
except Exception as e:
    log(e)
else:

Use case: else runs only on success: keep try blocks small.Example: try: r = api.get() except HttpError as e: log(e) else: save(r)

$raise ValueError("bad input")

Use case: Raise an exception with a message.Example: if not name: raise ValueError("name required")

$raise ... from e

Use case: Chain exceptions: keep the original traceback.Example: except OSError as e: raise ConfigError("bad file") from e

class MyError(Exception):
    pass

Use case: Define a custom exception type.Example: class RateLimited(Exception): pass

import logging
logging.basicConfig(level=logging.INFO)

Use case: Structured logging: better than print for real apps.Example: logging.basicConfig(level=logging.INFO); logging.info("started %s", service)

import json
json.dumps(obj, indent=2)

Use case: Pretty-print JSON: debug data structures.Example: print(json.dumps(payload, indent=2))

$from collections import OrderedDict

Use case: Dict with guaranteed insertion order (dicts are ordered since 3.7 anyway).Example: from collections import OrderedDict

Python Cheatsheet

Every essential Python pattern: data structures, strings, control flow, comprehensions, functions, file I/O, and error handling, with syntax and real use cases.

Every entry shows real syntax followed by the use case: when and why you reach for it.

Data Types & Structures

x: int = 42: Type annotation: declare an integer variable.

Example: age: int = 30

x: str = "hello": Type-annotated string.

Example: name: str = "devvkit"

x: float = 3.14: Type-annotated float.

Example: pi: float = 3.14159

x: bool = True: Type-annotated boolean.

Example: is_active: bool = True

lst: list[int] = [1, 2, 3]: A list: ordered, mutable collection.

Example: tags: list[str] = ["api", "auth"]

tup: tuple[int, str] = (1, "a"): A tuple: immutable, fixed-size collection.

Example: point: tuple[float, float] = (12.5, 42.1)

d: dict[str, int] = {"a": 1}: A dictionary: key-value mapping.

Example: counts: dict[str, int] = {"error": 3, "warn": 8}

s: set[int] = {1, 2, 3}: A set: unique, unordered values.

Example: seen: set[str] = {"git", "docker"}

lst.append(x): Add an item to the end of a list.

Example: tags.append("dev")

lst.extend([x, y]): Add multiple items to a list.

Example: tags.extend(["web", "api"])

lst.insert(0, x): Insert an item at a specific index.

Example: queue.insert(0, "high-prio")

lst.pop(): Remove and return the last item: LIFO stack behavior.

Example: last = tasks.pop()

lst.pop(0): Remove and return the first item: FIFO queue behavior.

Example: first = queue.pop(0)

lst.remove(x): Remove the first occurrence of a value.

Example: tags.remove("api")

x in lst: Membership check: is this in the list?

Example: if "dev" in tags:

lst.index(x): Find the index of a value.

Example: pos = ids.index(42)

lst.sort(): Sort a list in place.

Example: scores.sort()

sorted(lst, reverse=True): Return a new sorted list, descending.

Example: top = sorted(scores, reverse=True)[:3]

lst[::-1]: Reverse a list with slicing: the Python idiom.

Example: reversed_tasks = tasks[::-1]

d.get(key, default): Read a dict key with a fallback: no KeyError.

Example: plan = user.get("plan", "free")

d.setdefault(key, []): Get a key, creating it with a default if missing: group-by pattern.

Example: groups.setdefault(city, []).append(name)

d.keys() / d.values() / d.items(): Iterate over keys, values, or pairs.

Example: for k, v in config.items():

collections.Counter(lst): Count occurrences: frequency analysis.

Example: c = Counter(words); c.most_common(5)

collections.defaultdict(list): Dict that auto-creates missing values: group-by without setdefault.

Example: by_city = defaultdict(list); by_city["NY"].append(u)

collections.deque(maxlen=10): Fast append/pop at BOTH ends with bounded size: rolling windows.

Example: recent = deque(maxlen=10); recent.append(x)

enumerate(lst): Loop with an index: the Pythonic counter.

Example: for i, item in enumerate(items):

zip(a, b): Pair up two iterables.

Example: for name, age in zip(names, ages):

isinstance(x, int): Type check at runtime.

Example: if isinstance(value, (int, float)):

Strings & f-strings

s.upper() / s.lower(): Case conversion.

Example: s.upper()

s.strip(): Remove surrounding whitespace: clean user input.

Example: email = email.strip()

s.split(","): Split into a list by delimiter.

Example: parts = "a,b,c".split(",")

",".join(lst): Join a list into a string.

Example: csv = ",".join(tags)

s.replace(old, new): Replace all occurrences.

Example: clean = code.replace(" ", " ")

s.startswith("https"): Prefix check.

Example: if url.startswith("https"):

s.endswith(".json"): Suffix check.

Example: if f.endswith(".json"):

s.find("x"): Index of a substring, or -1 if missing.

Example: pos = s.find("error")

"x" in s: Substring membership.

Example: if "prod" in env:

s[:10]: Slice: first 10 characters.

Example: short = s[:10]

f"{name} is {age} years old": f-string interpolation: the modern way to build strings.

Example: f"user {id} plan={plan}"

f"{x:.2f}": Format a float to 2 decimal places.

Example: f"total: ${total:.2f}"

f"{x:>10}": Right-align in 10 characters: aligned table output.

Example: f"{name:>20} {score}"

f"{x:,}": Thousands separator: readable large numbers.

Example: f"revenue: {rev:,}"

"%s" % value: Old-style formatting: seen in legacy code, avoid in new code.

Example: "Hello %s" % name

s.title(): Title case: "hello world" becomes "Hello World".

Example: name.title()

s.isdigit(): Check if the string is all digits: validate input.

Example: if s.isdigit(): n = int(s)

Control Flow & Loops

if x > 0: ... elif x == 0: ... else: ...: Conditional branching.

Example: if code == 200: ok() elif code == 404: missing() else: fail()

for x in iterable:: Iterate over any iterable.

Example: for user in users: print(user["name"])

for i in range(10):: Loop a fixed number of times.

Example: for i in range(3): retry()

while condition:: Loop until a condition is false.

Example: while not queue.empty(): process(queue.get())

break: Exit the loop immediately.

Example: for p in pages: if p.is_complete(): break

continue: Skip to the next iteration.

Example: for f in files: if f.endswith(".tmp"): continue

for x in items:
    if cond: break
else:

: Loop else: runs only when the loop completed without break.

Example: for p in pages: if p.ok(): break else: raise Error("no ok page")

match value:
    case 1: ...
    case _: ...

: Structural pattern matching (Python 3.10+): switch with unpacking.

Example: match cmd: case "build": build() case _: help()

a if cond else b: Ternary expression: inline conditional.

Example: status = "ok" if code == 200 else "bad"

Comprehensions

[x * 2 for x in range(10)]: List comprehension: build a list in one line.

Example: squares = [x**2 for x in range(10)]

[x for x in items if x > 0]: List comprehension with filter.

Example: valid = [v for v in values if v > 0]

{x: x**2 for x in range(5)}: Dict comprehension.

Example: sq = {n: n*n for n in range(5)}

{x.upper() for x in words}: Set comprehension: deduplicate while transforming.

Example: unique = {w.lower() for w in words}

(x for x in items if x > 0): Generator expression: lazy, memory-friendly for large data.

Example: total = sum(x for x in big_list if x > 0)

[[y for y in range(x)] for x in range(3)]: Nested comprehension: grids and matrices.

Example: matrix = [[0] * 3 for _ in range(3)]

[f(x) for x in items if g(x)]: Transform AND filter in one pass.

Example: names = [u["name"].upper() for u in users if u["active"]]

sum(x for x in nums): Sum a stream: generator keeps memory flat.

Example: total = sum(row["total"] for row in rows)

Functions & Lambdas

def greet(name: str) -> str:
    return f"Hi {name}"

: Define a typed function.

Example: def slugify(text: str) -> str: return text.lower().replace(" ", "-")

def f(a, b=10):: Default parameter value: optional arguments.

Example: def fetch(url, timeout=30):

def f(*args):: Variable positional arguments.

Example: def log(*messages): print(" ".join(messages))

def f(**kwargs):: Variable keyword arguments: config bags.

Example: def configure(**opts): db = opts.get("db")

lambda x: x * 2: Anonymous function: inline logic for sort/map/filter.

Example: sorted(users, key=lambda u: u["age"])

sorted(items, key=len): Sort by a custom key function.

Example: sorted(words, key=lambda w: len(w))

map(f, items): Apply a function to every item (lazy).

Example: list(map(str.upper, names))

filter(f, items): Keep items where the function is true.

Example: list(filter(lambda x: x > 0, nums))

functools.reduce(f, items): Fold a sequence into one value.

Example: total = reduce(lambda a, b: a + b, nums)

return a, b: Return multiple values as a tuple.

Example: def minmax(xs): return min(xs), max(xs)

functools.lru_cache(maxsize=128): Memoize a function: cache expensive computations.

Example: @lru_cache def fib(n): return n if n < 2 else fib(n-1) + fib(n-2)

def outer():
    def inner(): ...

: Nested function: closures for counters and decorators.

Example: def make_counter(): n = 0 def inc(): nonlocal n; n += 1; return n return inc

@decorator
def f():

: Wrap a function with a decorator: logging, timing, auth.

Example: @timer def heavy_work(): ...

def decorator(fn):
    def wrapper(*a, **kw): ...

: Write a decorator: the wrapper pattern.

Example: def log_calls(fn): def w(*a, **k): print("call", fn.__name__) return fn(*a, **k) return w

def gen():
    yield x

: Generator function: lazy sequences.

Example: def read_lines(path): with open(path) as f: for line in f: yield line

next(gen): Pull the next value from a generator/iterator.

Example: first = next(read_lines("app.log"), None)

from dataclasses import dataclass
@dataclass
class User:

: Dataclass: boilerplate-free data containers.

Example: @dataclass class Point: x: float y: float

from typing import Optional, Union, Literal: Rich type hints: Optional[str], Union[int, str], Literal["a", "b"].

Example: def f(x: Optional[str] = None):

from typing import TypeVar, Generic: Generics: type-safe containers.

Example: T = TypeVar("T") def first(xs: list[T]) -> T: return xs[0]

File I/O & Context Managers

with open("f.txt") as f:
    data = f.read()

: Read a whole file: the context manager closes it automatically.

Example: with open("config.json") as f: data = json.load(f)

with open("f.txt", "w") as f:
    f.write("hello")

: Write a file (overwrites).

Example: with open("report.txt", "w") as f: f.write(report)

with open("f.txt", "a") as f:: Append to a file: log lines.

Example: with open("app.log", "a") as f: f.write(line)

for line in f:: Iterate a file line by line: memory-safe for huge files.

Example: with open("app.log") as f: for line in f: if "ERROR" in line: ...

pathlib.Path("dir"): Modern path handling: cross-platform, chainable.

Example: p = Path("src") / "main.py"

p.exists() / p.is_file(): Check a path exists and its type.

Example: if Path(".env").exists():

p.mkdir(parents=True, exist_ok=True): Create directories recursively: no error if present.

Example: Path("build/assets").mkdir(parents=True, exist_ok=True)

p.read_text() / p.write_text("x"): Read/write a text file via pathlib.

Example: content = Path("README.md").read_text()

Path("dir").glob("*.txt"): Glob files in a directory.

Example: for f in Path("logs").glob("*.log"):

Path("f").unlink(): Delete a file.

Example: Path("old.tmp").unlink(missing_ok=True)

Path("f").rename("new"): Rename or move a file.

Example: Path("report.txt").rename("report-2026.txt")

json.dump(obj, f): Serialize Python data to JSON.

Example: with open("out.json", "w") as f: json.dump(data, f, indent=2)

json.load(f): Parse JSON from a file.

Example: with open("config.json") as f: cfg = json.load(f)

from contextlib import contextmanager: Build your own context manager for setup/teardown.

Example: @contextmanager def timer(): t = time.time() yield print(f"took {time.time()-t:.2f}s")

import csv
csv.DictReader(f)

: Read CSV into dicts: headers become keys.

Example: with open("users.csv") as f: for row in csv.DictReader(f): ...

import shutil
shutil.copy(src, dst)

: Copy files/directories with stdlib.

Example: shutil.copy(".env.example", ".env")

Modules & Error Handling

import os
os.environ.get("KEY")

: Read environment variables: config without code changes.

Example: db_url = os.environ.get("DATABASE_URL")

import sys
sys.exit(1)

: Exit a script with a non-zero code: signal failure to CI.

Example: if not args: sys.exit("no args")

import argparse: Parse CLI arguments: professional scripts.

Example: parser = argparse.ArgumentParser(); parser.add_argument("--verbose", action="store_true")

import subprocess
subprocess.run(["ls", "-la"], check=True)

: Run shell commands from Python: automation glue.

Example: subprocess.run(["npm", "run", "build"], check=True)

import re
re.search(r"\d+", s)

: Regex search: extract patterns.

Example: m = re.search(r"v(\d+\.\d+)", version)

import requests
requests.get(url, timeout=10)

: HTTP requests (third-party, pip install requests).

Example: r = requests.get("https://api.github.com", timeout=10); r.json()

import time
time.sleep(1)

: Pause execution: retry loops and rate limiting.

Example: for attempt in range(3): try: connect(); break except: time.sleep(2)

try:
    risky()
except ValueError as e:

: Catch a specific exception type.

Example: try: n = int(text) except ValueError: n = 0

try:
    ...
except (TypeError, ValueError):

: Catch multiple exception types together.

Example: except (KeyError, IndexError):

try:
    ...
finally:

: Always-run cleanup: close connections, release locks.

Example: try: process() finally: conn.close()

try:
    ...
except Exception as e:
    log(e)
else:

: else runs only on success: keep try blocks small.

Example: try: r = api.get() except HttpError as e: log(e) else: save(r)

raise ValueError("bad input"): Raise an exception with a message.

Example: if not name: raise ValueError("name required")

raise ... from e: Chain exceptions: keep the original traceback.

Example: except OSError as e: raise ConfigError("bad file") from e

class MyError(Exception):
    pass

: Define a custom exception type.

Example: class RateLimited(Exception): pass

import logging
logging.basicConfig(level=logging.INFO)

: Structured logging: better than print for real apps.

Example: logging.basicConfig(level=logging.INFO); logging.info("started %s", service)

import json
json.dumps(obj, indent=2)

: Pretty-print JSON: debug data structures.

Example: print(json.dumps(payload, indent=2))

from collections import OrderedDict: Dict with guaranteed insertion order (dicts are ordered since 3.7 anyway).

Example: from collections import OrderedDict

Frequently asked questions

What is the difference between a list and a tuple?

Lists are mutable: you can add, remove, and change elements. Tuples are immutable and hashable, so they work as dictionary keys. Use tuples for fixed data and lists for collections that change.

How does a list comprehension work?

It builds a new list in one expression: [f(x) for x in iterable if condition]. For example [x*2 for x in range(10) if x % 2 == 0] yields even numbers doubled. They are faster and more readable than manual loops.

What is the difference between a generator and a list?

A generator yields items one at a time and never stores the whole sequence in memory: ideal for large or infinite data. A list holds everything eagerly. Use generators for streaming and lists for random access.

How do I handle exceptions properly?

Use try/except/else/finally: put risky code in try, handle specific exceptions in except, run success-only code in else, and always-run cleanup in finally. Catch specific exception types, never bare except.