Python中range(i+1)与[0]*(i+1)及对应循环语句的差异是什么？

Alright, let's break down the differences between range(i+1) and [0]*(i+1) in Python, along with how their corresponding for loops behave. I'll start with core object differences, then dive into loop-specific behavior.

1. Core Object Differences #

First, these are fundamentally distinct types of objects—this is the root of all their behavioral gaps:

• range(i+1): This is a lazy sequence object (specifically a range type). It doesn’t generate or store all numbers from 0 to i upfront. Instead, it only tracks the start, stop, and step values (default step is 1). No matter how large i gets (even a million), the range object uses barely any memory—just enough to hold those three parameters.
• [0]*(i+1): This creates a concrete list filled with i+1 copies of the integer 0. Every element is stored in memory. For small i, this is trivial, but if i is large (like 100,000), you’re creating a list with 100k elements that will consume noticeable memory (even though 0 is a cached small integer, the list still needs to store references to each entry).

2. Behavior in for Loops #

Now let’s look at how for _ in range(i+1): vs for _ in [0]*(i+1): differ in practice:

Memory & Performance #

• The range loop is far more memory-efficient, especially for large i. Since it doesn’t pre-generate all elements, it starts iterating immediately without waiting to build a full list. For very large i, this also means faster startup time—no need to allocate memory for a huge list first.
• The list loop requires creating the entire list before the loop starts. This adds overhead in both memory and setup time, which becomes noticeable as i grows.

Iterated Values #

Even though _ is a convention for "unused variables", the actual value of _ differs between the two loops:

• In for _ in range(i+1):, _ will take on each integer from 0 to i in sequence. For example, if i=2, _ will be 0, then 1, then 2.
• In for _ in [0]*(i+1):, _ will be 0 every single iteration. The list is filled with 0s, so every loop step pulls that same value.

This might seem irrelevant if you’re ignoring _, but it can cause bugs if you accidentally use the variable later. For example:

i = 2
sum_total = 0
for _ in range(i+1):
    sum_total += _
print(sum_total)  # Output: 3 (0+1+2)

vs

i = 2
sum_total = 0
for _ in [0]*(i+1):
    sum_total += _
print(sum_total)  # Output: 0 (0+0+0)

Mutability #

• range objects are immutable—you can’t modify their values once created. This makes them safe; there’s no risk of accidentally altering the sequence mid-loop.
• Lists are mutable. While [0]*(i+1) uses immutable integers, if you were using a mutable type (like [[]]*(i+1)), modifying one element would affect all others (since they’re references to the same object). Even with integers, if you hold a reference to the list, you could modify it during the loop, leading to unexpected behavior (though in this specific case, it wouldn’t change iteration values since we’re iterating over the original elements).

3. When to Use Which? #

• Use range(i+1) when you just need to run a loop i+1 times and don’t care about the iteration value. It’s the standard, efficient choice for counting loops in Python.
• Use [0]*(i+1) only when you actually need a list of i+1 zeros—for example, initializing a list to store data later, or passing it to a function that expects a list. Don’t use it just to get a loop count; that’s wasting memory and performance.

内容的提问来源于stack exchange，提问作者Junth