1. The number the code stores

Call $P[i]$ the prefix sum at $i$: the total of the first $i$ elements of nums. So $P[0] = 0$, because it adds no elements. $P[1]$ is nums[0], and $P[2]$ is nums[0] + nums[1]. An array of $n$ elements has $n + 1$ prefix sums, from $P[0]$ to $P[n]$.

The code stores $P[i]$ in self.prefix[i]. Every question is then answered with one formula:

$\text{sum}(\text{left} \ldots \text{right}) = P[\text{right} + 1] - P[\text{left}]$

2. Computing every prefix sum in one pass

Each prefix sum is the one before it plus one more element:

$P[i + 1] = P[i] + \text{nums}[i]$

So the code needs one pass from left to right. It starts with $P[0] = 0$ and adds one element per step. There are no cases to tell apart. The same line runs for every index.

3. Why one subtraction gives the range total

Split the first $\text{right} + 1$ elements into two parts. The first part is the first $\text{left}$ elements. The second part is nums[left] up to nums[right]. Written as totals:

$P[\text{right} + 1] = P[\text{left}] + \text{sum}(\text{left} \ldots \text{right})$

Move $P[\text{left}]$ to the other side, and you get the formula from part 1. The proof only splits one sum into two parts. It never needs the values to be positive, and it never needs $P$ to grow. So the formula also holds when nums has negative values, as in the example below.

4. The + 1 and the zero at the start

The two indices of the formula are not symmetric. $P[\text{right} + 1]$ includes nums[right], because it counts $\text{right} + 1$ elements. $P[\text{left}]$ excludes nums[left], because it counts only the $\text{left}$ elements before it. If you write self.prefix[right] - self.prefix[left], the result leaves out nums[right].

The extra entry $P[0] = 0$ handles ranges that start at index 0. For $\text{left} = 0$ the formula reads $P[\text{right} + 1] - P[0]$. That is the total of the first $\text{right} + 1$ elements minus nothing. Without $P[0]$, a range starting at index 0 would need its own if.

5. Example 1 by hand

nums = [-2, 0, 3, -5, 2, -1]. The constructor builds the prefix sums one step at a time:

The picture shows the seven prefix sums $P[0]$ to $P[6]$ for Example 1, with the index of each one under its cell. The two marked entries answer the question sumRange(2, 5), where $\text{left} = 2$ and $\text{right} + 1 = 6$. $P[6] = -3$ is the total of all six elements. $P[2] = -2$ is the total of the first two elements, nums[0] and nums[1]. Their difference is the total of nums[2] to nums[5].

The three questions of Example 1 each take one subtraction:

The answers $1$, $-1$ and $-3$ are the expected output. A direct check of the second one: $3 + (-5) + 2 + (-1) = -1$.

6. From the formulas to the code

__init__ runs the pass of part 2 once, in $O(n)$ time. After that, sumRange reads two stored values and subtracts them, in $O(1)$ time per question.