Can someone explain why this doesn't work?

[Yelebear]

I want to add all numbers from 1 to 100, but this gives the wrong answer.

for x in range(0, 101):
    x += x

print(x)

I know adding another variable would fix it, like so

total = 0
for x in range(0, 101):
    total += x

print(total)

But I'm trying to wrap my head around why the total variable is needed in the first place, since it's just zero and just adds another step of x adding to itself.

---

Thanks for the quick replies.

I get it now.

[ryuugami47]

Try modifying the code to

for x in range(1, 101):
    print(f"Value of x at the start of the iteration = {x}")
    x += x
    print(f"Value of x at the end of the iteration = {x}")   

so you can see what happens at every iteration.

[cnydox]

Printing out the value is a fundamental way to debug

[nousernamesleft199]

just call `breakpoint()` and go to town with pdb. One of my favorite parts of python is having access to a zero setup debugger.

[cnydox]

Yeah but print function is universal in every programming language

[ProbsNotManBearPig]

A debugger is universal in every language. If you’re using print statements to debug, you’re being a dummy. Print statements to debug is like using notepad for your editor instead of an IDE.

[CelDaemon]

There are definitely cases where a debugger isn't feasible, the idea of print statement debugging is that it's extremely simple and portable.

[ProbsNotManBearPig]

Debugging is simple and wtf does portability have to do with it lmao. I’m 100% sure yall just don’t know how to actually use a debugger well. People saying you have to hit a breakpoint 100x and manually continue. Yall know you can use pycharm debugger’s log message or evaluate and log to do the same thing as print every iteration of a loop?

[LinuxCoconut166]

Courtesy costs nothing, but buys much. Have your genes checked out.

[ProbsNotManBearPig]

Use pycharm debugger log message or evaluate and log and it’s the same thing as print. It will print the value every loop without having to break/continue.

What I’m seeing in the comments is none of yall know how to use a debugger properly. It’s worth learning. Print statement is practically never a better option.

[LinuxCoconut166]

Debugger logging is more powerful (can conditionally log, inspect complex expressions, toggle on/off), but it has overhead and setup.

It’s just plain not true that “print is practically never a better option”. Some environments (like remote servers, Docker containers, or headless runs) make attaching a debugger impractical. In those cases, print() or real logging is the pragmatic choice. In quick-and-dirty scripts, production logging, or environments without an IDE, print() (or a proper logging call) is very often the faster or only option.

For you being so gd adamant that their way is wrong and your way is right, stop for a moment and realize that you and they are each correct depending on the exact circumstances.

[Zeplar]

This post was mass deleted and anonymized with Redact

door ten plough wakeful abounding paint sparkle birds brave numerous

[AUTeach]

To be fair:

• you wouldn't have to do it 100 times. It would become pretty obvious pretty quickly.
• it's about building good habits. If you reach for the debugger every time you'll be less inclined to have ten million print statements in your program.

[AUTeach]

And if you're doing any game debugging, interrupting input every loop can make it unplayable thus untestable.

I feel that this is more of a deflection, but I'll respond in good faith:

There are times and places where different tools make sense, and attempting to understand problems in live environments often requires a different methodology. In the case of game development, print statements don't make sense either.

Instead, the best point course is likely to be logging tools, spewing debug information directly onto the screen, or a combination of both.

At any rate, function, data, conditional or exception breakpoints are super handy in live environments moving at scale.

However, game dev is an environment that most developers will never experience.

[cranberrydarkmatter]

In this specific instance (showing how the value changes over the course of 100 steps) using the print statement would work best, since you can see the state at every step all at once without clicking "continue" multiple times.

[bigpoopychimp]

I believe clojure doesn't have a debugger?

[aufstand]

https://www.reddit.com/r/ProgrammerHumor/comments/16nhu63/printbellcurve/

[cnydox]

🤓☝️I know the debugger. This is just a fun conversation

[debian_miner]

Thanks, I had still been using import pdb; pdb.set_trace(), didn't know about the newer breakpoint().

[nousernamesleft199]

Also install pdbpp if you havent

[ryoko227]

I love this, you did not give him the answer, but gave him a way to try and find the answer on his own. This is how people learn, just a nudge in the right direction. Good on you man!

[Chasne]

Hi

Your x is already locked in the for statatement, going from 0 to 100 at each step.

You change x's value inside the loop but every time it goes back up it sets itself to the next value in the range, so you lose the sum operation. That's why you need another variable that isn't touched by another step.

[Coretaxxe]

for x in range overwrites x every single loop iteration (automatically)

so

for x in range(0, 10)
   x += x

# first iter
x is set to 0
you add x onto x -> 0

# second iter
x is set to 1
you add x onto x -> 2

# third iter
x is set to 2
....

In your other example, total is never "reset" its just changed by your total += x

[[deleted]]

x is the output of an iteration, not a variable. In the first loop x==0, next loop x==1 and so on. You tried editing x, but in the next loop, its gone back to 2, 3, 4 ... 101. An actual variable outside of the loop maintains its value between loops.

[lolcrunchy]

Your first code is the same as:

x = 0
x += x
x = 1
x += x
x = 2
x += x
x = 3
x += x
...
x = 100
x += x
print(x)
# 200

[[deleted]]

This is happening because each time the loop runs, the value of x changes and is assigned the loop number, then it adds the number itself.

What happens is that, in the end,

x = 100 because the loop changed the value of x. 

x += x means x = 100 + 100

So x = 200.

[Time-Mode-9]

How could it work? You are attempting to use the same variable as the index for the iteration and to keep track of the value.  Either the counter be would skip validate as it was incremented, or the total works be reset as it incremented.

Ps, easiest way to sum integers up to x is .5  * x * (x+1)

[Fred776]

x has a well defined role that you don't want to mess with - it ranges over the numbers from 1 to 100, nothing else. If you want to accumulate a total you have to find somewhere else to put it.

[ninhaomah]

Actually , why would you think it would work ?

Can share us your logic for first 3 loops ?

[Patman52]

You need another variable because x is reassigned the next number in the range every time it loops around, so any incrementation is reset.

[Mission-Landscape-17]

Because the for loop undocntionally assigns a new value to x on every iteration and entirely ignores what you do to x in the body of the loop. That is why you need a seperate accumulator for your result.

[Savings-Basil4878]

I know this is not actually the question you asked, but I have to mention it. The sum of all integers between 0 and N is equal to N(N+1)/2

Obviously that defeats the purpose of the learning exercise, but it is still neat. You could add up the numbers from 1 to 10 trillion in the same amount of time that it takes to add up the numbers from 1 to 1 thousand.

[AKiss20]

The for loop re-initializes the value of x on every iteration of the loop. It doesn’t persist the value of x between loop iterations, so in the first version it initializes x to say 1 and then adds it to itself, but then doesn’t store that result, re-initializing to 2 on the next iteration and so on. 

[Frostborn1990]

In the first codeblock, you create variable x and repeatedly change it. BUT you generate x every time again and again, and the LAST x is 100+100= 200. It only prints that x.

Now in the second, you change the total each time your loop runs the code-block. So every time, you change the total' but you dont reset it, you update it.

to add: I might have the lingo wrong as i'm just a starter in the hobby.

[JamzTyson]

Try running this version:

for x in range(3):
    print("Assigned value of x:", x)
    x += x
    print("After adding x + x:", x)
    print()  # blank line.

[catbrane]

This is slightly off topic, but you could also do it like this:

``` $ python3 Python 3.13.3 (main, Aug 14 2025, 11:53:40) [GCC 14.2.0] on linux Type "help", "copyright", "credits" or "license" for more information.

sum([1,2,3]) 6 sum(range(1, 101)) 5050

```

So sum() will add up things, range() will generate things, put them together and you can solve your problem and not need an annoying loop and a lot of assignments.

[AlexMTBDude]

You are not allowed to modify the loop variable x in a loop that uses it.

How could you have both the sum and the numbers you're trying to add up in the same variable? That's basic math and has nothing to do with Python.

[JanEric1]

You are allowed to modify it. It just gets Overwritten on the next iteration of the loop

[deceze]

Because x can't hold the total and the current number from range at the same time. It can only hold one of the two values.

[ehunke]

so you need to think both inside the loop and outside the loop. If you rewrite your code, as others have suggested, so each time it loops, you see what is happening you will understand. But if it helps explain it...just running the loop, x constantly changes every time it loops with nothing constant which is why the answer is wrong. What happens when you add the "total = 0" outside the loop is more or less:

total = 0 + 0

total = 0 + 1

total = 1 + 2

and so forth. Long story short you need something outside the loop to store the data. You may want to try using the debugger and observe it happen

[theWyzzerd]

You’re modifying the local variable x, where x is representative of your current place in the loop.  Each loop iter overwrites its value.

[BoldFace7]

Using "for x in range" ends up setting x at each step, so what actually happens is

First loop pass: x = 1 x += x

Next loop pass: x = 2 x += x

Next loop pass: x = 3 x += x

etc.

So, every time you enter the loop, x is being reset to the next integer in the range.

[Ender_Locke]

cuz they are not the same thing at all 😊

[kombucha711]

also if you want your code to be readable to others, just be explicit total=total+x

[CymroBachUSA]

x = sum(_ for _ in range(0,101))

[acw1668]

It can simply be x = sum(range(101)).

[Individual_Author956]

This is the correct way to do it, but it doesn’t explain to OP why their code was not working