Incrementing the upper limit of range inside a loop doesn't make it run forever [duplicate]

Answer 1

You are adding to n, which initially is 10 (or whichever upper bound you are using). Thus your result is indeed 10 (the initial value) + 0 + 1 + ... + 9 (from the range).

Having said that, I'd still recomment not using the initial value of n and instead getting the sum of range(1, n+1), as that's much clearer.

>>> sum(range(1, n+1))
55

Or if you want to show off:

>>> n*(n+1)//2
55

---

About your second question:¹ No, the range(0, n) is evaluated only once, when the for loop is first entered, not in each iteration. You can think of the code as being roughly² equivalent to this:

r = range(0, n) # [0, 1, 2, 3, ..., n-2, n-1]
for i in r:
    n+=i

In particular, Python's for ... in ... loop is not the "typical" for (initialization; condition; action) loop known from Java, C, and others, but more akin to a "for-each" loop, iterating over each element of a given collections, generator, or other kind of iterable.

¹⁾ Which, I now realise, is actually your actual question...

²⁾ Yes, a range does not create a list but a special kind of iterable, that's why I said "roughly".

Answer 2

The range function is taking a value of n as its upper bound which prevents the for loop from funning forever. The for loop stops when i has the same value as n (which in the example you gave is 10.

So your code

for i in range(0,n):

is the equivalent of saying "first let i have a value of 0, then on the next iteration of the loop, let i have a value of 1, ..... and so on until i has a value of 10".

Answer 3

This is because int values are immutable and range captures that particular instance only once at the beginning.

When inside the loop, the variable n which was pointing to the value 10 initially is re-pointing everytime to a new int instance when you are adding some number to it. And since range is evaluated only once it keeps the reference to the original int instance 10.

The int instance which is referenced by the range function at the beginning, is not at all mutated in the for-loop and is still pointing the int instance value of 10.

That is why the loop is completed even though n is now pointing to a different number every time.

Try this example snippet, you can prove this:

def bigAdd(n):
    for i in range(0,n):
        #temp captures the int before the addition
        temp = n
        n+=i
        print(temp is n)
    return n

The output is:

bigAdd(10)
True
False
False
False
False
False
False
False
False
False
Out[8]: 55

The first line prints True as 10 + 0 is 10 so both are the same instance.

Answer 4

range(0,n) is evaluated once before the loop is entered.

This isn't like a typical for loop from other languages that has a condition that is constantly checked. range returns a range object that produces numbers, and the upper limit is set when the range object is created. Changing n has no effect on the range object that's already been constructed.

Answer 5

Well, you can solve this problem in a loop, but why not use the Gaußsche Summenformel (sorry for the German link, I couldn't find the english name of it), which is indeed

n (n+1)
-------
   2

Put this in a function and return the value:

def gaussian_sum(n):
    return (n * (n+1)) // 2

Answer 6

As I understand it when you have range(0,n) you define a generator with upper limit 10, because n was 10, and after that the generator doesn't change.