1. The table the code fills

The code keeps a list is_prime of length $n$, one entry for each number from 0 to $n - 1$. At the end, is_prime[m] is True exactly when $m$ is prime. The answer is the number of True entries, sum(is_prime).

A number $m > 1$ is composite when it is not prime, so it has a factor other than 1 and $m$. The code starts with every entry True, sets 0 and 1 to False, and then crosses out composite numbers: it sets their entries to False. This method is the Sieve of Eratosthenes.

2. What one prime $p$ crosses out

For one prime $p$, the inner loop range(p * p, n, p) crosses out

$p^2,\ p^2 + p,\ p^2 + 2p,\ \ldots \quad \text{(every multiple of } p \text{ from } p^2 \text{ up to } n - 1\text{)}$

Each of these is $p$ times a whole number of at least $p$, so each is composite.

3. Why starting at $p^2$ and stopping at $\sqrt{n}$ loses nothing

Start at $p^2$. Take a multiple of $p$ below $p^2$, say $m = p \cdot j$ with $2 \le j < p$. The number $j$ has a prime factor $q \le j < p$. So $m$ is a multiple of the smaller prime $q$, and the loop for $q$ already crossed it out.

Stop at $\sqrt{n}$. Every composite $m < n$ can be written as $m = a \cdot b$ with $2 \le a \le b$. Then $a \cdot a \le a \cdot b = m < n$, so $a < \sqrt{n}$. The smallest prime factor $p$ of $m$ is at most $a$, so $p < \sqrt{n}$. Also $m = p \cdot (m / p)$ with $m / p \ge p$, so $m \ge p^2$. So the loop for $p$ crosses out $m$. Every composite below $n$ is crossed out by a prime $p$ with $p \le \sqrt{n}$. Primes above $\sqrt{n}$ need no loop of their own.

The if is_prime[p] check. When the outer loop reaches $p$, every composite below $p^2$ is already crossed out, by the argument above. So is_prime[p] is True exactly when $p$ is prime. A composite $p$ is skipped, because its multiples are also multiples of its prime factors.

4. The bounds in the code

range(2, int(n ** 0.5) + 1) runs $p$ up to $\lfloor \sqrt{n} \rfloor$, including it. The + 1 is needed because range stops one before its end. For LeetCode's inputs, $n \le 5 \cdot 10^6$, int(n ** 0.5) equals the exact integer square root for every $n$, so the float square root never cuts off a needed $p$.

The early return if n <= 2: return 0 covers the inputs with no prime below $n$. It also keeps is_prime[1] a valid index: the list needs at least two entries for the line is_prime[0] = is_prime[1] = False.

The problem asks for primes less than $n$, so $n$ itself is never in the list. range(p * p, n, p) stops before $n$ for the same reason.

5. Example 1 by hand

n = 10, so is_prime has entries 0 to 9, and $p$ runs from 2 to $\lfloor \sqrt{10} \rfloor = 3$.

After the loop, the entries still True are 2, 3, 5 and 7. The number 6 is a multiple of both 2 and 3. The loop for 3 starts at 9, so 6 is crossed out only once, by the loop for 2. The code returns 4, the expected output.

The picture shows the ten entries of is_prime after the loop, one cell per number from 0 to 9, with the number under its cell. "T" is True and "F" is False. Entries 0 and 1 are False because the code sets them before the loop. The label "p=2" marks the entries 4, 6 and 8, which the loop for $p = 2$ crosses out. The label "p=3" marks entry 9, which the loop for $p = 3$ crosses out. The four entries still True are 2, 3, 5 and 7, and the final sum(is_prime) counts them.

6. Example 2 by hand

n = 0. The condition n <= 2 is true, so the code returns 0 at once, the expected output.

7. How much work the crossing out takes

The loop for a prime $p$ writes at most $n / p$ entries. So the total work is about $n$ times the sum of $1 / p$ over the primes $p \le \sqrt{n}$. That sum grows like $\ln \ln n$, a known result about primes (Mertens' second theorem). So the sieve takes $O(n \log \log n)$ time, and the list takes $O(n)$ space. For $n = 10^6$, the loops write $2122046$ entries, about 2.1 writes per number.

8. From the math to the code