range()函数参数中表达式/函数的计算时机、性能对比及enumerate()同类情况咨询

Great question—this is a common point of confusion, but the logic is straightforward once you break it down.

1. How range() handles its arguments #

When you call range(), all arguments passed to it are evaluated exactly once, at the moment you call the function. After that, range() uses those pre-computed values to generate the sequence during iteration—there’s no re-calculation of your expression or function on each loop pass.

Applying this to your example #

Let’s compare your two code patterns:

• Pattern 1:

  l = len(some_array)
  for i in range(l):
      # do something
  

• Pattern 2:

  for i in range(len(some_array)):
      # do something
  

These are functionally identical in terms of performance. The len(some_array) call runs once in both cases—either when assigning l or when passing it directly to range(). Since len() is an O(1) operation (super fast, even for large arrays), there’s no meaningful speed difference between the two.

The only time you’d prefer the first pattern is if you need to reuse the len(some_array) value elsewhere in your code, or if you’re using a computationally expensive function (not len())—but that’s about code clarity/reusability, not range()’s behavior.

2. Does enumerate() follow the same logic? #

Yes! enumerate() works the same way:

• Its first argument (the iterable you want to index) is resolved once when you call enumerate(), then iterated over without re-generating it.
• The optional start parameter (which sets the starting index) is also evaluated once at call time.

Example to prove it #

Let’s use a function that prints a message every time it’s called to see how many times it runs:

def track_calls():
    print("Function called!")
    return 3

# Test range
print("--- Testing range ---")
for i in range(track_calls()):
    print(i)

# Test enumerate
print("\n--- Testing enumerate ---")
my_list = ["a", "b", "c"]
for idx, item in enumerate(my_list, start=track_calls()):
    print(idx, item)

If you run this, you’ll see "Function called!" printed exactly twice total—once for range() and once for enumerate()’s start parameter. No repeated calls during iteration!

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