python while false reddit - Brave Search

sorry to ask such a silly question but what does 'while True:' actually mean?

reddit.com › r › learnpython › comments › 17v3stw › sorry_to_ask_such_a_silly_question_but_what_does

while will always evaluate whatever comes behind it. For instance i =0 while i < 10: print(i) i = i+ 1 Here i <10 is evaluated to either be true or false. This will happen each iteration. i = 0 , True i= 1, True i= 2, True Etc, untill: i=10, False => break loop The code will continue untill it evaluates to false. while True kind of hacks it: True will always evaluate to True. While looks at it and thinks: hey this is true! So it always continues. While true isn't commonly used, but when it is it's commonly used with a break statement. (Or interrupted by ctrl + c). While False will never do anything in the loop as you stated. It checks to see if False is True. But it's never true, so it doesnt execute the code in the while loop. (Sorry fod bas formatting, mobile) Answer from Zer0designs on reddit.com

reddit.com › r/learnpython › sorry to ask such a silly question but what does 'while true:' actually mean?

r/learnpython on Reddit: sorry to ask such a silly question but what does 'while True:' actually mean?

November 14, 2023 -

what does the True refer to?

eg if i write:

while True: 
    print("hi")

i know that "hi" will be repeated infinitely, but what is it thats True thats making "hi" get printed?

also, whatever it is thats True, im assuming its always true, so is that why if i typed 'while False', none of the code below would ever run?

sorry if this is a stupid question

edit: also, besides adding an if statement, is there anything else that would break this infinite while loop?

and how would i break the loop, lets say after "hi" has been printed 10 times, using an if statement or whatever else there is that can break it. thanks!

while will always evaluate whatever comes behind it. For instance i =0 while i < 10: print(i) i = i+ 1 Here i <10 is evaluated to either be true or false. This will happen each iteration. i = 0 , True i= 1, True i= 2, True Etc, untill: i=10, False => break loop The code will continue untill it evaluates to false. while True kind of hacks it: True will always evaluate to True. While looks at it and thinks: hey this is true! So it always continues. While true isn't commonly used, but when it is it's commonly used with a break statement. (Or interrupted by ctrl + c). While False will never do anything in the loop as you stated. It checks to see if False is True. But it's never true, so it doesnt execute the code in the while loop. (Sorry fod bas formatting, mobile)

Never stop never stopping.

reddit.com › r/learnpython › how do while not loops work

r/learnpython on Reddit: How do while not loops work

September 11, 2024 -

I was reading through this code and I'm just not getting how while loops work when not operator is also used.

https://pastebin.com/5mfBhQSb

I thought the not operator just inversed whatever the value was but I just can't see this code working if that's the case.

For example , the while not sequenceCorrect should turn the original value of False to True, so the loop should run while it's True. But why not just state while True then? And why declare sequenceCorrect = True again? Doesn't it just means while True, make it True? And so on.

The only way it makes sense to me is of the while not loop always means False (just like the while always means as long as it's True) even if the value is supposed be False and should be inverted to True.

So, is that the case? Can anyone explain why it works like that?

In general, recall the while loop syntax. while : Conceptually, coding aside, consider filling a glass of water. Is there space for more water in the glass? Okay, then pour some. Without going in detail of how this funky glass object is defined, hopefully the following makes sense as a python analog of that process. while glass.has_space(): #we're still filling the glass glass.add_water() #glass is now full of water Without writing out how this glass object works, let's say it has another method for returning a boolean (True/False) for whether or not it is currently full, instead of the previous example of whether or not it had space for more water. We can fill the glass in the same way, but we have to negate that statement using the not operator while not glass.is_full(): #we're still filling the glass glass.add_water() #glass is now full of water Going back to the initial syntax, which is still the same, the only thing we've done is changing the condition statement of the loop. Instead of checking that glass.has_space() evaluates to True, we are now checking that the expression not glass.is_full() evaluates to True. That is the same statement as evaluating that glass.is_full() evaluates to False, because the only thing the not operator does to a boolean is negating it, i.e. True becomes False and vice versa. Now looking at your code linked, the condition for looping is that not sequenceCorrect evaluates to True, which is equivalent to the statement that sequenceCorrect is False. I won't paste the code here, but we see on line 3 that sequenceCorrect starts its life being False, so upon entering the while loop we do indeed step into that block of code because at that time not sequenceCorrect is in fact True. Then the first thing we do on line 5 is reassign it to True. If the remaining lines don't change it back to False, this will stop the while loop from repeating, since in this current state not sequenceCorrect evaluates to False. So you can say that line 5 is defaulting the loop to not going to be repeated. The only way for the loop to be repeated is for lines 6-8 with the nested for loop and if statement to find some character in dna that is not in "actgn", upon which sequenceCorrect will be assigned to False and thus the statement in the while loop not sequenceCorrect would evaluate to True and thus the loop would repeat itself once more. Personally, I think this is just a pretty unclear way to achieve the goal of checking the validity of that input string. I would have defined it another way, but I can't see anything wrong with it really. If the not operation in the while loop statement is bothering you, you could equally have rewritten the code with a variable for instance named sequenceIncorrect and just flipped all assignments i.e. True's become False's and vice versa.

The difference here is that by using not sequenceCorrect you are avoiding the use of the break keyword. It's cleaner and makes the loop terminate itself, rather than relying on a specific keyword and force terminate it. You could use while True, but that way is not descriptive enough and can potentially create and endless loop if you don't take care of the edge cases. Think about it: while not sequenceCorrect is telling you, without a single comment line, that the loop should run while sequenceCorrect is False, vs while True which the only thing that's telling you is that this loop will run endlessly for unknown reasons.

Videos

🐍 Python Tutorial #19: while loops - YouTube

While loops in Python - YouTube

Python While Boolean

Python’s For / While Loops Are More Clever Than You Think - YouTube

September 12, 2022

Python While Loops & For Loops | Python tutorial for Beginners

Python While Loops: Simple Explanation + Examples - YouTube

September 16, 2025

reddit.com › r/learnpython › help understand while true/while false

r/learnpython on Reddit: Help understand while True/while False

December 19, 2015 -

for example, why does this code work:

user = input("Enter marital status: ")
user = user.upper()
valid = False
while not valid:
    if user == "M" or user == "S":
        valid = True
    else:
        print ("invalid input")
        user = input("Enter marital status: ")
        user = user.upper()

but this doesn't:

user = input("Enter marital status: ")
user = user.upper()
valid = True
while not valid:
    if user == "M" or user == "S":
        valid = False
    else:
        print ("invalid input")
        user = input("Enter marital status: ")
        user = user.upper()

isn't the boolean condition changing in both cases?

can someone just give me some guidelines for using while True/False,e.g. when is it best to use this type of a while loop? that I can follow on my test tomorrow (yes, tomorrow).

Thanks in advance!

When you say the code doesn't work, I assume you mean the code inside the while loop doesn't execute in the 2nd example. While loops in python have format while BOOLEAN: CODE where BOOLEAN is an expression which evaluates to either True or False. If the BOOLEAN evaluates to True, then CODE is executed. If not, CODE is skipped over. In your second example, BOOLEAN is the expression not valid valid has value True so, not valid is not True which evalutes to False. Therefore the CODE doesn't execute.

Evaluate valid = True; not valid in your head.

reddit.com › r/learnpython › trouble understanding while not

r/learnpython on Reddit: Trouble understanding While Not

February 16, 2017 -

I'm doing "automate the boring stuff" and was on an early lesson about while loops. I can't wrap my head around "while not." The code is below

name = ''
while not name:
     print('Enter your name:')
     name = input()
print('How many guests will you have?')

While my limited knowledge, I would write it instead as

name = ''
while name == '':
    print('Enter your name:')
    name = input()
print('How many guests will you have?')

My question is how can they mean the same thing? Both start with name = False/empty. The way I interpret the top code is, while name is not False/empty. The way I interpret the bottom is, while name is equal to False/empty. In my mind, the top would keep looping with any True value. Thanks for your help!

EDIT: formatting

EDIT 2: Finally figured it out. I'm posting this edit for prosperity sake, for any other programming ogres like me. As long as the condition line is True, the loop will run. If the condition is False, the loop will not run. Even though name is False, the condition line is True and the loop will go until something is inputted. Once something is typed in, name becomes True, which would make the condition not name False, ending the loop.

Thanks everyone for helping me understand that! It's so simple now that I see it. I'm super new to Python and made a rookie mistake.

An empty string coerces to False in a boolean context, while any other string coerces to True. The first version is the idiomatic way of writing that.

I almost committed suicide trying to get this straight in my head. I finally got it and maybe this will help someone else as well: In Python if variable is empty, i.e. = None or = "" - it is considered False (or Falsey to be more precise). While actually means While True and works as long as chosen condition is True. While not basically means While False and works as long as set condition is False. In this case we set name = False and say: as long as the name is False, i.e empty - do the loop. As soon as we add anything to the name through input - the name becomes True and the loop is ended. Jeeezoooos.

reddit.com › r/learnpython › as a beginner how do i understand while loops?

r/learnpython on Reddit: As a beginner how do I understand while loops?

April 10, 2025 -

While loops is kinda frustrating I'm 20 days into python and I'm stuck on loops since last 4 days

While confused: practice++

It’s just a loop which continues running until the condition becomes false.

reddit.com › r/python › while true antipattern

r/Python on Reddit: While True Antipattern

July 31, 2022 -

I'm working on designing an application, and the high level intention is to run the app forever; Sort of like a Daemon service. The only way I can think of doing this is

While True:
Decorator that does the While True: forever.

This really feels like an anti-pattern to me. What are some other ways to keep an app running forever?

Why is it an antipattern? Really simple to read and understand.

"while True" is totally acceptable. There's even a "while False" in the standard library.

reddit.com › r/learnpython › is using while true loops good?

r/learnpython on Reddit: Is using while True loops good?

December 3, 2022 -

I remember seeing a video where the programmer said that using while True loops aren't good.

Can someone give an example of where this might be the case?

What would be better to use? especially, if I am trying to check for user input.

E.g. They have entered a username that is not in the list of usernames.

Having a proper end condition for the while loop makes it more readable, and easier to understand.

It really depends on what you're trying to do with the loop. If there's a sensical condition, use the loop condition to end the loop. Don't force using a condition though just for the sake of using one. You may end up managing flags or something similar which is often not as readable as a conditional break in the loop. Also, afaik, Python doesn't have a do...while loops because a while True with a break at the end is close enough that implementing a separate construct wasn't worth it. Edit: Actually, this is what I was thinking of. Łukasz Langa is involved in the language , created Black, and GvR appears to be in agreeance with what he said in that post. As is typically the case, do whichever reads better for the particular scenario.

stackoverflow.com › questions › 22377668 › python-while-false-loop

Python - While false loop - Stack Overflow

If you want 'while false' functionality, you need not. Try while not fn: instead.

The condition is the loop is actually a "pre-" condition (as opposed to post-condition "do-while" loop in, say, C). It tests the condition for each iteration including the first one.

On first iteration the condition is false, thus the loop is ended immediately.

Find elsewhere

Google Bing Mojeek

reddit.com › r/programminghorror › convince me to not use "do { ... } while (false);"

r/programminghorror on Reddit: Convince me to not use "do { ... } while (false);"

October 26, 2023 -

I love this pattern:

do {
    something();
    if (condition) {
        break;
    }
    somethingelse();
    ....  // yadda yadda
} while (false);

I think it is beautiful. It is brilliant. Once you get it (it should not take long), you just have to agree that it makes code a lot easier to read.

Yet people online seem to disagree with this pattern. They claim "it is just a structured goto". But I disagree. It is fundamentally different from a goto. In a goto, you never know where you'll end up after following the label name. This is not the case here. You know exactly where you will land, and hence there is absolutely no spaghettification.

The code is much cleaner this way - everybody hates nested ifs.

Try to change my view, but I think you can't.

unless you've got additional metrics to show it is noticeably inefficient to do so, I'd probably argue that this example would be more suitable as a separate function where you just return out of it when you do not need to continue. The argument against what you are doing is that it requires you to read the entire block from the start to the end to realise it isn't actually ever going to loop more than once, which can be misleading/increase the cognitive complexity of this code block. If you need complicated control flow and are not micro-optimising, then it is often a sign you should break up your problem into smaller chunks. Code should be readable, boring, and explicit. Doing stuff in a "smart" way without physical evidence that it is required to prevent a noticeable defect in the final product, or maintainability, is almost never a good idea and just makes the codebase into a pain to work with over time. I'd rather something be verbose and boring than smart and confusing for the sake of a few lines of code.

The lengths people will take to avoid using goto when that’s what they actually mean, just because some Dutch dude said that only naughty programmers use goto. The problem I have with this is that when I see do, I assume I’m looking at a loop. I have to read all the way to the end to find out that it’s not a loop at all. And then, if I don’t already know the trick, I have to pause for a second to figure out what’s going on. As others have said, function with early return is clearer. Use a local function if you want to keep the logic together in one place.

reddit.com › r/learnpython › can someone explain what this `while true` function is actually checking?

r/learnpython on Reddit: Can someone explain what this `while True` function is actually checking?

December 13, 2023 -

https://pastebin.com/NWkKQc1P

It's from Automate the Boring Stuff. I tried running it through the python tutor and it didn't clarify. Is the basic point that there actually isn't anything it's checking to be True, so it's an infinite loop until you trigger the `break`?

PS I figure this is something simple from much earlier that I didn't internalize. I plan to go through all the basic curriculum again to make sure there aren't any gaps in super basic knowledge.

A while loop runs while a condition is true. True is always true, so it will run until something causes it to break (e.g. a break statement, program crash, etc.) For comparison, the first loop in the code you posted could be rewritten without an infinite loop as: age = input("Enter your age: ") while not age.isdecimal(): age = input("Please enter a number for your age: ")

Correct; this is just a way to start an infinite loop that you intend to break with some condition/break statement later on. Mostly used for starting/running an application that you don't want to close down without user intent (clicking an exit/quit button in a UI or entering "quit", "exit", etc from the command line. It *isn't* a great construct to use when you want something that has solidly defined criteria to repeat until those criteria are met. As mopslik pointed out, you would be better served in those examples to actually use the defined criteria in those as your loop conditions since you're not at risk of just sticking the user in an infinite loop if you forget to write your break statement somewhere. You, also, don't have to write so many lines to accomplish the same goal. ``` password = "" while not password.isalnum(): password = input('Select a new password (alphanumeric only') print("Password is good") ``` You do not have to print a line and then call input(), either. Just put the message you want displayed into the parens for the function call: input("Enter your age: ")

reddit.com › r › learnpython › comments › kueepr › what_does_while_true_mean

What does "while True" mean? : r/learnpython

January 10, 2021 - Subreddit for posting questions and asking for general advice about all topics related to learning python.

reddit.com › r/learnpython › none object and while loop confusion.

r/learnpython on Reddit: None object and While loop confusion.

June 23, 2022 -

Player_1 = None

While (not Player_1):
    Player_1 = input('your name')

I'm not new to python, I understand classes and functions etc..but this is really baffling me and I need some help understanding 'None' and the While loop.

I understand that 'not' negates a Boolean value, I get that piece, but None is not a Boolean value, I've searched this and None is its own Object and None is also not equal to False or True.

The while loop runs if the condition evaluates to true, and doesn't run if evaluated to False.

What is making the loop run the first time and not the second time. Obviously, the first time the logic equates to True and the second time to False...But I don't get the logic.

I think it's the "not" which is confusing me, what is the not doing?

Can someone please enlighten me?

I get that piece, but None is not a Boolean value, I've searched this and None is its own Object and None is also not equal to False or True. None isn't equal to False but None is "falsey", as are empty collections, the numbers 0 and 0.0, and the empty string. "Falsey" values are treated as boolean False in contexts where truth values are expected, so not None evaluates to True.

https://docs.python.org/3/library/stdtypes.html#truth-value-testing Here are most of the built-in objects considered false: constants defined to be false: None and False. zero of any numeric type: 0, 0.0, 0j, Decimal(0), Fraction(0, 1) empty sequences and collections: '', (), [], {}, set(), range(0) Anything else is treated as True. In your case the non-empty string from input() is considered True.

reddit.com › r/learnpython › while true loops vs try except

r/learnpython on Reddit: While True loops vs Try Except

May 11, 2024 - while True: try: value = float(input("Enter a float: ")) except ValueError: print("No good.") else: break ... Like mopsilk and qazbarf have pointed out, you're thinking about this a bit wrong. Raising exceptions is the standard way Python code can signal an error.

reddit.com › r/learnprogramming › help with python program where an inputted number is "true" or "false" (true if even, false if odd)

r/learnprogramming on Reddit: help with python program where an inputted number is "true" or "false" (true if even, false if odd)

February 11, 2025 -

Hi, I was coding a program (description in title). I just learnt about using functions, and was wondering why line 4 and line 6 can't be used in such a way. I know that I can just 'return' true or false, but was curious on why this method is unacceptable.

Any help or suggestions are appreciated!!

x = int(input ("What is your number? "))
def is_even (x):
    if x % 2 == 0:
        is_even(x) == "true"
    else:
        is_even(x) == "false"

print (f"It is {is_even(x)} that your number is even")

If you think of a function like a machine that does a very specific process, what is your code doing? From the print statement, you're passing your raw materials on the conveyor belt to the machine. It then does the modulo and then you call the function again. What happens there? Well, you take x and put it at the start of the conveyor belt. The machine does the modulo comparison, then x gets passed back to the start of the conveyor belt. This just repeats over and over. is_even(x) == "true" doesn't ever resolve to anything because there is no return statement. Even if it did, it's still just a comparison with a hanging value that never gets used anywhere. In most languages, this would just result in the value being discarded, not returned. The return statement is like the sorter at the end of the conveyor belt that goes, "Okay, this item goes back on the main belt."

Fascinating. Do you perhaps have previous experience with Fortran or maybe Algol? Or maybe Lisp? Some of those languages returned from functions in the way you're doing it. But in Python, instead of "is_even(x) == True", you'd just say "return 'true'".

reddit.com › r/learnpython › could anyone explain to me what 'while true' is and how it works?

r/learnpython on Reddit: Could anyone explain to me what 'while True' is and how it works?

October 12, 2019 -

aware numerous gaze cable attraction relieved fuzzy resolute obtainable humor

This post was mass deleted and anonymized with Redact

while is a type of loop that will execute code within a loop as long as some condition resolves to True for example while ThisIsACondition: DoSomething as long as ThisIsACondition is True, DoSomething will be executed. ThisIsACondition can be anything, like i < 10, as long as the variablbe i is less than 10, DoSomething will be executed. if ThisIsACondition is just the variable True, while Truemeans that the loop will continue indefinitely As for the why: In other programming languages, there is something called a do while loop that will execute the elements in a loop before testing the truth condition. your prof using while True is getting the same functionality, that is you'll DoSomething and then check some kind of stopping criteria. Effectively while ThisIsACondition: DoSomething if SomeStoppingCriteriaIsMet break doSomethingElse where the break keyword exists a while loop and will doSomethingElse

The while loop runs while the condition is true. Obviously, while True runs forever as True is true. :-) You need to use break inside such a loop to exit it.

reddit.com › r/learnpython › what's the difference between using the break keyword and using the false keyword to exit a while loop?

r/learnpython on Reddit: What's the difference between using the break keyword and using the False keyword to exit a while loop?

May 19, 2018 -

Using break: https://repl.it/repls/SinfulMonstrousProperties

Using False: https://repl.it/repls/MildMulticoloredCases

I am learning about this flag. If you use the False keyword, you can exit the while loop whenever the elif statement = False.

What's the difference between this and just using the break keyword.

EDIT:

break ends your loop right now, whereas setting some flag equal to False means you're going to execute any remaining code in your current iteration of the loop.

Thank you guys so much for your help. r/learnpython is MUCH better than r/javahelp!

One of the big differences is that break ends your loop right now, whereas setting some flag equal to False means you're going to execute any remaining code in your current iteration of the loop.

They both can work just fine. The only thing I would add is that you can have i = 0 while i < 4: i += 1 else: print('done') # will print vs i = 0 while True: if i < 4: break i += 1 else: print('done') # will not print The else isn't called if your break out of the loop

discuss.python.org › python help

If we assign false to a variable and then use a while not loop, why is the variable still false and not true? - Python Help - Discussions on Python.org

November 16, 2022 - if we assign false to a variable and then use a while not loop, why is the variable still false and not true?

reddit.com › r/python › (not true) vs (false)

r/Python on Reddit: (not True) vs (False)

February 1, 2023 -

What is the difference? I still can’t get it? Both display false

Boolean logic has only 2 states, true and false. Therefore one can understand why False and not True are logically equivalent. When working in Python it's common not to write True or False. Instead of writing if x == True: we commonly write if X: and instead of writing if x == False: we commonly write if not x:.

not is a unary operator, that takes the argument after it and negates it's boolean value. So the difference is, one expression is just False, the other needs to be evaluated first, and results in False (because that is negated True). That being said, you'd never see not False in a codebase.

reddit.com › r/learnpython › need help understanding boolean statement in while loop

r/learnpython on Reddit: need help understanding Boolean statement in while loop

December 24, 2018 -

Hello I am doing Jose Portillas course on python in udemy and I ran into a bit of code that I am having a hard time wrapping my head around.

def summer_69(arr):
    sum69 = 0 
    cond = True
    for num in arr:
        while cond: 
            if num != 6: 
                sum69 += num
                break
            else: 
                cond = False
        while not cond: 
            if num != 9: 
                break
            else:
                cond = True
                break
summer_69([2, 1, 6, 9, 11])

as you can see the variable cond starts with True assigned to it. but in the first while loop if the condition is no longer met (that the variable num is not equal to 6) then the cond will have its value reassigned to False.

so if cond is now false. how come it skips the first while loop considering that the while loops condition is met in the next iteration

and also why, in the second while loop, does it meet the conditions is the variable assigned to cond somehow still True?

For your first question: cond is initalized (and set to True) before the for-loop, so if it get changed inside the iteration (doesn't matter if inside the while-loop or anywhere else inside the iteration), it stays changed, until a next iteration changes it again or it gets changed after the for-loop is done. So, if a iteration changes cond to False, with the next iteration cond is still False and therefore it skips the first while-loop. Example step by step with arr = [2, 6, 7, 9]: sum69 = 0 cond = True (iteration 1) num = 2 # entering first while-loop, because cond=True # entering if-statement because 2 != 6 sum69 = 2 # entering next iteration because of break (iteration 2) num = 6 # entering first while-loop, because nothing changed with cond # ignoring if-statement because 6 == 6 # entering else cond = False # entering second while-loop # entering if-statement because 6 != 9 # entering next iteration because of break (iteration 3) num = 7 # ignoring first while-loop because cond changed in the last iteration # entering second while-loop # entering if-statement because 7 != 9 # next iteration because of break (iteration 4) num = 9 # ignoring first while-loop because cond changed in iteration 2 # ignoring if-statement because 9 == 9 # entering else cond = True # next iteration because of break (now it would work again like in iteration 1) # end of function I don't exactly understand the second question.

This was code used as an example in a course that's teaching python? This is just my personal opinion, but there's no reason that the code needs to be this obfuscated. And just at a glance, if this is the quality of code being written for examples, that would lead me to believe the course is probably not teaching you best practices. I cleaned up the code to get rid of all the while loops and breaks, and also added a return so the function actually does something. Currently it just throws away the result when the function returns. def summer_69(arr): sum = 0 cond = True for num in arr: if cond: if num == 6: cond = False else: sum += num else: if num == 9: cond = True return sum That should be a bit easier to follow along without getting too far away from what the original code (and I'm pretty sure this could be further improved). In short, this function iterates through a list of numbers and keeps a running total of all the numbers until it finds a 6. After it finds a 6, it stops adding any numbers to the total until it finds a 9. Then it resumes adding those subsequent numbers to the total. Think of 6 as an off switch and 9 an the on switch, with the function starting in the on position. I don't blame you for having difficulty understanding what the original code was doing. Both the inner while loops were unnecessary and by extension so were the breaks. Also the if statements were all screwy. The instructor was thinking about them backwards. When a number is 6 or 9, that has special meaning so it should be clear that those are what flip the boolean. Those shouldn't be on an else block when a number isn't 6 or 9. Doing it that way hides the intent.

reddit.com › r/learnpython › what is the difference between 'while not done' vs 'while done = false' ?

r/learnpython on Reddit: What is the difference between 'While not done' vs 'While done = False' ?

August 29, 2015 -

I'm having trouble wrapping my head around the concept of this as I am going through all of the tutorials on programarcadegames.com . This bit comes up at Section 5 and I have seen it previously on the tutorials but ignored it because I couldn't understand what the difference was or why to use one over the other. If anyone could please clear it up for me I would appreciate it very much! Thank you!

They achieve the same goal. while not done takes the value of done and logically negates it, so False becomes True and vice versa. while done == False checks if the value of done is equal to False. In the first case, done could be 0 or "" or any "falsey" thing and it would evaluate to True and keep the loop going. In the second case, done must equal False. The first option is generally preferred, although both are correct.

Just a little tip, While done == False. One = means assignment.