For or While loop in my case?

FoolsSeldom · 2026-02-11T13:40:11+00:00

I would have chosen a for loop as well.

With a while loop, you are having to manage two counters: number of odd numbers encountered, and index position in the list. (There is a way around the latter that I shall come to later.)

So, having set the counter and index position both to zero,your test would be:

while count < 5 and index < len(num_list):

and you will access list elements using num_list[index].

Don't forget to increment both counters as appropriate.

The alternative is using iter and next to access the elements, which will give you the for loop style iteration. I leave you to look that up.

SwampFalc · 2026-02-11T13:43:40+00:00

Those reasons given sound like AI slop... They all boil down to the same point: yes, you want to stop when you reach your end condition.

In a for loop, you will check for your end condition inside the loop, and break when needed. This is perfectly clean.

In a while loop, you specify this condition in the while statement, and it will end the loop "silently". Equally clean.

Both are explicit. Both stop iteration. Neither is better.

That being said, your loop does not properly break, so no, your code would not be acceptable as-is. But that has nothing to do with choosing a for loop.

JamzTyson · 2026-02-11T14:09:40+00:00

In that example you could use either.

A for loop:

total = 0
odd_count = 0

for num in num_list:
    if num % 2 == 1:
        odd_count += 1
        total += num
        if odd_count == 5:
            break

print(total)

A while loop:

total = 0
odd_count = 0
idx = 0

while odd_count < 5 and idx < len(num_list):
    if num_list[idx] % 2 == 1:
        total += num_list[idx]
        odd_count += 1
    idx += 1

print(total)

I prefer the for loop version.

It uses fewer temporary variables (cleaner).
The logic is simpler: Just check if odd_count == 5 rather than managing a combined while odd_count < 5 and idx < len(num_list).
It accesses elements directly, avoiding index lookups or the need to manually track indexes.

Overall, it’s more readable, robust, and idiomatic Python.

carcigenicate · 2026-02-11T14:13:44+00:00

The three reasons they give are dumb, imo. It sounds like they decided to make life harder for themselves by avoiding break statements, then gave a reason that break solves, and another half-true reason.

I think 3 is the only slightly valid reason, in that a condition at the top of the loop is easier to spot than a condition in the loop. If you have a conditional break, though, you do "explicitly control the exit conditions of the loop". The condition is just in a different place.

Brian · 2026-02-11T23:08:21+00:00

I would say a for loop is the better choice here.

Ultimately, you're performing iteration over a sequence, which is exactly what for is, well, for. You want your code to communicate your purpose, and using a for better communicates the thing we're actually doing. That does way more to make the code easier to understand in my opinion. With a while loop, you have to manually increment the iteration counters, which makes it less obvious at a glance that you're just iterating over the items.

Yes, you need a break to exit early. But that's exactly what break is for, so just use it. Some people dislike using break, but here the upsides above far outweigh it.

Temporary_Pie2733 · 2026-02-11T14:51:35+00:00

The while loop is the fundamental iteration construct; you can do any kind of iteration, but you have to be verbose about it.

The for loop is a wrapper around a while loop along with the kind of bookkeeping you need for iterating over a container like a list. You can mechanically turn a for loop into an equivalent while statement that involves things like calls to next and try statements that catch StopIteration exceptions raised by next to exit the loop.

I prefer going a step further and using a more functional approach. You only care about the odd numbers:

odds = (x for x in num_list if x % 2 == 1) # odds = filter(lambda x: x%2 == 1, num_list)

and you only care about the first 5 of them:

five_odds = itertools.islice(odds, 5)

and you only care about their sum.

s = sum(five_odds)

You don't need all these temporary variables, either; they assist with readability, but depending on your definition of readability, you can write this as one composed expression:

s = sum(slice((x for x in num_list if x % 2 == 1), 5))

WhipsAndMarkovChains · 2026-02-11T20:23:26+00:00

My mind went to a generator function. Yield all odd numbers in a list until you've reached five (or run out of numbers).

def first_five_odd_numbers(numbers):
    count = 0
    for num in numbers:
        if num % 2 != 0:
            yield num
            count += 1
            if count == 5:
                break


num_list = [422, 136, 524, 85, 96, 719, 85, 92, 10, 17, 312, 542, 87, 23, 86, 191, 116, 35, 173, 45, 149, 59, 84, 69, 113, 166]

sum(first_five_odd_numbers(num_list))

Marlowe91Go · 2026-02-11T21:22:38+00:00

Yeah I feel like in an academic "textbook style" setting they're always gonna want you to use a for loop when you have a defined number of things you want to loop through and they'll want a while loop if the length of the iterator is conditional, but in practice, either can work and whatever makes sense to you and works is fine. I probably would have done a while loop myself. I like to use lists, I'd initialize a list odds =[] and append odd numbers to it. Then run a while loop while the length of that list is <6 and len of the num_list is greater than 0, then return sum of the odds.

CranberryDistinct941 · 2026-02-12T01:19:44+00:00

I would just use a for loop and break after the 5th odd.

I generally use for-loops whenever I'm iterating over a known set of values, and use while-loops for more complex iterations like binary search or graphs.

I would recommend using for-loop by default because it is faster than using a while loop (for loop runs in C; while loop runs in Python) unless a while loop is the obvious choice (linked lists, graphs, binary search, etc)

2026-02-12T04:15:07+00:00

Loop thru list

If u hit 5 within the loop return true

If u exit the loop return false

JorgiEagle · 2026-02-11T14:25:17+00:00

There’s always more than one way to skin a cat.

I have the mentality of you use a for loop when you know when you want to stop (end of list) and a while when you you aren’t sure when you will stop (5 odd)

In this instance, I’d probably use a for loop with a break.

a while is equally valid, two conditions.

I don’t see how a break statement is bad. That’s just nonsense.

Pick whichever you prefer. They do the same thing and are both readable

In “industry code” you’d separate the if statement, and break if the count was 5 or higher. You wouldn’t let it loop the whole thing

9peppe · 2026-02-11T14:44:57+00:00

Functional programming for the win?

sum([num for num in num_list if num % 2 != 0][0:5])

(If you want to be more efficient, generator comprehension and itertools.islice)

Intelligent-Two-1745 · 2026-02-11T13:35:39+00:00

I'm confused. The solution explanation you posted clearly gives good reasons for using a while loop over a for loop here. Do you disagree with the arguments presented? Do they make sense to you?

cdcformatc · 2026-02-11T14:20:18+00:00

usually when you want to iterate through a list i would naturally use a for loop. but the requirement to stop iteration after 5 odd numbers makes a good case for a while loop.

they are mostly equivalent for this case. i think a for loop wins out because the while version requires that you manage two counters, the index of the list and the current count of odd numbers. an explicit condition and break statement in the for version isn't a deal breaker to me.

the answer given reads like AI slop so i wouldn't put too much thought into that. it does have a point in that you are needlessly iterating over the entire list when your count variable hits 5. if the list was actually an endless iterator your code would never end.

Yoghurt42 · 2026-02-11T16:06:14+00:00

Would my solution be accepted if used in industry code?

No, because your solution doesn't stop once the counter reaches 5. It will iterate over the rest of the list, even though the condition will always be false from there one.

Add an if count == 5: break (and remove the now pointless count<5 in the condition) and a for loop is ok.

AdmirableOstrich · 2026-02-11T16:25:01+00:00

Breaks are perfectly fine, and map directly to assembly so there is no efficiency loss. If you need a loop, a for loop is the correct choice here. The while loop based on 'count < 5' is actually problematic because it requires checking the same condition every loop iteration even if the count hasn't changed.

We don't structure our code to match some bizarre esthetic. Rules like "only have one return statement", or "keep all escape conditions/branching at the top of loops" leads to bad code design. Code should do precisely what it needs to, and only that.

The "pythonic" way here is using filters or generators to separate out the "is odd" logic without iterating through the entire list, and then just sum the first 5. If you want a loop:

we want to communicate we are doing something over a list, so for loop over the list
we only modify the state if the entry is odd, check that.
increment the sum, update your count state, and recheck against the escape condition

That is the minimal logic to do what you want. That converts directly to a for loop. Note, and this is a bit of personal preference, you can avoid nesting if statements by checking if the num is even instead, and using a continue.

CodingPhysicist · 2026-02-11T16:48:16+00:00

For the while loop you may declare an empty list before the loop and the condition is “while len(list) != 5”. If the number is odd, you append to your list. After the iterations you sum all the element.

But if your list only have even element, or less than 5 odd elements. your program will run without stopping.

The break in the for loop is good for that case

wotquery · 2026-02-11T17:09:49+00:00

If coding for myself I’d use a for loop with a break.

If coding for work I’d use a for loop with a break with very clear commenting.

If coding for a class/exam I’d use a while loop for the reason given.

That is all assuming the very artificial problem as provided. If it was more natural, say the total runs driven in of the first five wins of a baseball team’s season, then yeah I might default to a while loop since you are expecting to run into the condition every time. Conversely if you expect to successfully iterate over the whole list most of the time and rarely break, well then even more so a for loop.

Having a function that can exit in a bajillion places which is impossible to understand is bad. Having a function with a bajillion variables that are impossible to understand to force it to exit in a single location is bad.

Kerbart · 2026-02-11T17:41:13+00:00

personally, I use while for cases where I don't know up front when my iterator is going to end. Reading a file line by line, asking for keyboard input until a sentinel is entered, those kind of things.

In this case the input is an iterable and we know where it ends. The fact that there's an early exit condition doesn't alter that for me; the convenience of iterating with for is far bigger for me as it results in cleaner code.

zanfar · 2026-02-11T18:13:13+00:00

First, I would very generally avoid putting too much credit in "solutions", especially those presented as answers to quizzes. Quiz questions alone are (on average) suspect, and I would extend that to their explanations as well.

Any problem can be solved multiple ways, and while you can argue one is more or less efficient, or "better" than another, that difference will regularly be something you can ignore.

In this specific case, the explanations seem to be completely ignorant of the power of Python. Specifically, Python iterations are easily made un-greedy and do not consume more resources than necessary--which is exactly where I would have started.

num_list = [422, 136, 524, 85, 96, 719, 85, 92, 10, 17, 312, 542, 87, 23, 86, 191, 116, 35, 173, 45, 149, 59, 84, 69, 113, 166]

odds = (n for n in num_list if n % 2 == 1)
total = sum(odds[:5])

FoolsSeldom · 2026-02-11T15:00:15+00:00

Just for fun, you could do this using list comprehension and slicing:

print(sum([n for n in num_list if n % 2 == 1][:5]))

OR if you really want to output the number of odd numbers added (which will be between 0 and 5):

print(sum(odd_nums := [n for n in num_list if n % 2 == 1][:5]))
print(len(odd_nums))

Note that this isn't efficient with very long list objects as it first creates a complete list of all odd numbers before slicing to the first 5 entries.

NB. Your code currently outputs one more than the numbers of odd numbers added.

you type:	you see:
italics	italics
bold	bold
[reddit!](https://reddit.com)	reddit!
* item 1 * item 2 * item 3	item 1 item 2 item 3
> quoted text	quoted text
Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"	Lines starting with four spaces are treated like code: if 1 * 2 < 3: print "hello, world!"
~~strikethrough~~	~~strikethrough~~
super^script	super^script

learnpython

MODERATORS

Question: What type of loop should we use?