Fallback with pip and venv same result, a few seconds slower

If you cannot install uv, the venv module and pip ship with Python itself. They have done since 3.3 and 3.4 respectively, so there is nothing to install before you start.

python3 -m venv .venv
source .venv/bin/activate
pip install --upgrade pip
pip install playwright

The difference that matters here is speed: uv resolves and installs in parallel and caches aggressively, pip is sequential and cold-caches often. Pick one and stay with it for the rest of the session.

F-strings self-documenting prints for debugging

F-strings are the modern way to build a string. A leading f tells Python to evaluate the expressions inside {} braces and insert the results.

name = "Ada"
age = 36
print(f"{name} is {age} years old.")
print(f"Next birthday: {age + 1}.")
print(f"{name=}, {age=}")

The last form – an = inside the braces – prints both the expression and its value: name='Ada', age=36. It exists for one purpose, throwaway debug prints that are still readable three weeks later.

Collection operations boringly similar across all four

Most operations look the same on lists, tuples, dicts and sets. in tests membership, len() gives the size, iteration yields elements – for a dict, its keys. The differences are in mutation and in shape.

urls = ["https://a.com", "https://b.com"]
urls.append("https://c.com")
"https://a.com" in urls        # True

seen = {"https://a.com"}
seen.add("https://b.com")

page = {"url": "https://a.com", "status": 200}
page["title"] = "A"   # dicts grow by assignment

Control flow indentation is the block delimiter

Python uses indentation where other languages use braces. Four spaces per level – what PEP 8 asks for and what black and ruff format produce. No end, no }, no semicolons.

status = 404

if status == 200:
    print("ok")
elif 300 <= status < 400:
    print("redirect")
else:
    print("problem")

elif is the Python spelling of else if. There is no separate keyword and no switch.

A for loop walks an iterable, never an index. continue skips to the next item, break leaves the loop entirely, and both do what you expect.

for url in urls:
    if "localhost" in url:
        continue
    print(url)

Comprehensions one line from an iterable

A comprehension builds a list, a dict or a set out of an existing iterable in one expression. It reads as “this element, for each item in that source, optionally filtered”.

urls = ["https://a.com/", "https://b.com", "mailto:x@y"]

https_only = [u for u in urls if u.startswith("https://")]
lengths = {u: len(u) for u in https_only}
domains = {u.split("/")[2] for u in https_only}

Prefer a comprehension to a for-loop with .append(). It is more compact, a little faster, and it says which of two things you are doing: building a collection, rather than performing side effects.

Exceptions errors are values you catch and inspect

Exceptions are Python’s error channel. When something goes wrong a function raises one; a caller further up the stack catches it with try/except and decides what to do.

try:
    value = int(user_input)
except ValueError as exc:
    print(f"Not a number: {exc}")
    value = 0

The as exc clause binds the exception object to a name so that you can inspect it. Drop it when you only care that something failed and not what failed: except ValueError:.

pathlib paths are objects, not strings

pathlib replaces string surgery on paths with path objects. The / operator joins segments, and .read_text(), .mkdir(parents=True) and .glob() do what their names say.

from pathlib import Path

here = Path(__file__).parent
report = here / "out" / "report.txt"
report.parent.mkdir(parents=True, exist_ok=True)
report.write_text("hello\n")

for md in here.glob("**/*.md"):
    print(md.relative_to(here))

Cross-platform correctness costs no extra code. Path normalises slashes and drive letters, so the same lines run on Linux, macOS and Windows with no os.path.join gymnastics.

re just enough regex

Reach for re when pattern matching is the right tool, and not before. If what you need is “starts with” or “contains”, then str.startswith, str.endswith and in are faster to write and faster to read.

import re

pattern = re.compile(r"^https?://")
pattern.match("https://example.com")   # Match object
pattern.match("mailto:x@y")            # None

Compile once, match many. re.compile hands back a compiled pattern, and calling .match() on it skips the compile step every time round the loop.

argparse the --help you never wrote, in three lines

argparse turns a list of argument descriptions into a whole CLI. Help text, type coercion, default values and error messages are all generated from the add_argument calls.

import argparse

p = argparse.ArgumentParser(description="Scan a page for link health.")
p.add_argument("url", help="URL to start from")
p.add_argument("--max", type=int, default=20, help="max links")
args = p.parse_args()

print(args.url, args.max)

python scanner.py --help already works. Three lines of setup, and the user has a standards-conforming CLI with Unix-style flags and a readable usage block.

Extract all links page.evaluate bridges Python and JS

page.evaluate runs JavaScript inside the page and returns the result as plain Python data. Anything JSON-serialisable crosses the boundary.

hrefs = await page.evaluate("""
  () => Array.from(document.querySelectorAll('a[href]'))
             .map(a => a.href)
""")

hrefs comes back as a Python list of strings, already absolute. The browser resolves a relative <a href> against the current page URL before it hands them over.

Running it pipe it into grep for the interesting cases

python scanner.py https://example.com --max 10

The output is grep-friendly: one line per page, flags first and the URL last, so grep -v '^ok' leaves only the pages with a problem.

ok                                       https://example.com/
no-description                           https://example.com/about
status=404 no-title                      https://example.com/oops