Is there a way to do conditionals inside Python (3) for loops?

Not directly. A for loop iterates over a pre-generated sequence, rather than generating the sequence itself. The naive translation would probably look something like

flag = True
i = 1
while i < 20:
    if not flag:
        break
    ...
    if some_condition:
        flag = False
    i *= 2

However, your code probably could execute the break statement wherever you set flag to False, so you could probably get rid of the flag altogether.

i = 1
while i < 20:
    ...
    if some_condition:
        break
    i *= 2

Finally, you can define your own generator to iterate over

def powers_of_two():
    i = 1
    while True:
        yield i
        i *= 2


for i in powers_of_two():
    ...
    if some_condition:
        break
    

You can use range() if you have the step as some constant increment (like i++,i+=10,etc). The syntax is -

range(start,stop,step)

range(start, stop, step) is used as a replacement for for (int i = start; i < stop; i += step). It doesn't work with multiplication, but you can still use it (with break) if you have something like i < stop && condition.

The equivalent loop for the one you mentioned in question can be =>

for(int i=0;i<20;i*=2)  // C/C++ loop

# Python - 1
i = 0
while i < 20 :    # Equivalent python loop
    # Code here
    i*=2

If you are willing to use flag as well as a condition, you will have to do it as =>

// C/C++
bool flag = true; 
for(int i=0;i<20&&flag;i*=2)  // C/C++ loop

# Python - 1
i,flag = 1,True
while not flag and i < 20 :    # Equivalent python loop
    # Code here
    i*=2 

Hope this helps !

The for loops in Python are not like loops in C. They are like the for-each loops applied to iterables that came out in Java 7:

for (String name: TreeSet<String>(nameList) ) {
   //Your code here
}

If you want control over your iterator variable, then a while or for loop with a break in it is probably the cleanest way to achieve that kind of control.

This might be a good time to look into finding time to do a tutorial on Python comprehensions. Even though they are not directly applicable to your question, that is the feature that I appreciate most having come from Java about five years ago.

In a sense, but it's not quite as simple as it is with JS and Java.

Here is your example written in Python using a while loop with two conditions. Also note that in Python while loops, you cannot assign or increment the index in the loop's declaration.

boolean_flag = True

i = 1
while (i < 20 and boolean_flag):
    i *= 2
    # Code in here

The answers above are good and efficient for what you ask, but I'll give my idea of how I would do it.

max = 20
for i in range(0, max/2):
    c = i * 2
    if flag:
        #Do work.
        break

or to make it shorter:

max = 20
for i in range(0, max, 2):
    if flag:
        #Do work.
        break

Firstly, in python you cannot increment using the increment operator as in C++, or Java, e.x, x++ or --x. A for loop in Python works over an iterator (For example, List, String, etc.)

PYTHON FOR LOOPS: A for loop is used for iterating over a sequence (that is either a list, a tuple, a dictionary, a set, or a string`).

This is less like the for keyword in other programming languages, and works more like an iterator method as found in other object-orientated programming languages.

With the for loop we can execute a set of statements, once for each item in a list, tuple, set etc.

Example Print each fruit in a fruit list:

fruits = ["apple", "banana", "cherry"]
for x in fruits:
  print(x)

will print:

apple
banana
cherry

Example Do not print banana:

fruits = ["apple", "banana", "cherry"]
for x in fruits:
  if x == "banana":
    continue
  print(x)

PYTHON CONDITIONALS:

In python the keyword for false values is False, and that for true values is True

Like C++ or Java, you can use == to compare values. But unlike Java, where there is strict type-checking and the condition needs to be a Boolean Statement, in Python:

1. Almost any value is evaluated to True if it has some sort of content.
2. Any string is True, except empty strings.
3. Any number is True, except 0.
4. Any list, tuple, set, and dictionary are True`, except empty ones.

In fact, there are not many values that evaluates to False, except empty values, such as (), [], {}, "", the number 0, and the value None. And of course the value False evaluates to False.

The following will return False:

bool(False)
bool(None)
bool(0)
bool("")
bool(())
bool([])
bool({})

One more value, or object in this case, evaluates to False, and that is if you have an object that is made from a class with a __len__ function that returns 0orFalse`:

class myclass():
  def __len__(self):
    return 0

myobj = myclass()
print(bool(myobj))

You use while for flag and condition and increment inside loop

i = 1
while flag and i < 20:
    # code here
    i = i*2

Sure, but you may need to do some things yourself.

Python provides the range() class which produces an interable sequence of values with an optional step increment.

for i in range(1, 20, 2):
  # do the things
  # here, i starts at 1, and increments by 2 each loop stops at >= 20

If you want to do something more complicated like i *= 2, You have two options:

1. use a while loop and increment the values yourself
2. write a custom generator like range() that implements such a thing.

Example generator:

def range_step_mult(start, stop, step):
    while start < stop:
        yield start
        start *= step

for i in range_step_mult(1, 100, 2):
    print(i)

Note the use of the yield keyword here. This is VERY important for performance over large ranges, especially if the iterable object is on the larger side. Using the keyword here allows Python to simply deal with one object at a time as opposed to generating all that stuff in memory before it even starts working on it.

You can use conditionals within the for loop, and you can use the break and continue keywords to control the loop flow to some level. That being said, the loop is generated outside of this block, so you can't change the step or something mid loop.

While loops are a different story entirely and you can alter the step as much as you want as you're the one incrementing it in the first place.

Example while loop:

i = 1
while i < 100
  if i % 2 == 0:
    i *= 2
  else:
    i += 1

In common with several other answers, here is how I would actually translate that code:

boolean_flag = True
i = 1 # actually I wouldn't use i as a variable name, but whatever.
while i < 20 and boolean_flag:
    # code goes here
    i *= 2

I would also consider using a for loop, which might look something like this:

from itertools import takewhile, count

boolean_flag = True
for i in takewhile(lambda i: i < 20, map(lambda x: 2**x, count())):
    # code goes here
    if not boolean_flag:
        break

But having considered both, I prefer the while loop. And in practice I very rarely actually need a flag defined across a loop like that. Normally you can either break from the loop immediately you detect the condition that would cause you to set the flag, or else use logic like this:

boolean_flag = something()
something_that_has_to_happen_after_regardless_of_flag_value()
if not boolean_flag:
    break

The need for boolean "break" flags is mostly (not wholly) a result of trying to write all your loops with no break in them, but there's no particular benefit to doing that.

It might be possible to salvage the for loop, or at least learn a few things about Python, by playing around with other ways to write what comes after for. Like lambda i: i < 20 could be (20).__gt__, but that's breathtakingly ugly in its own way. Or map(lambda is always a warning sign, and in this case map(lambda x: 2**x, count()) could be replaced with (2**x for x in count()). Or you can use functools.reduce to change the exponentiation back to multiplication, but it's unlikely to be worth it. Or you can write a generator function, but that's a chunk more boilerplate.

Supposing I know that the base-2 logarithm of 20 can only be so big, but I don't want to make myself a hostage to stupid off-by-one errors, I could write something like:

for i in (2**x for x in range(10)):
    if not i < 20:
        break

Or to get rid of all of the "clever" stuff:

for x in range(10):
    i = 2 ** x
    if not (i < 20 and boolean_flag):
        break

But again, this isn't really solving the basic issue that for loops are intended for when you have an iterable containing the right values, and in Python you need to pull several things together to come up with the right iterable for this case (especially if you want to write 20 rather than the logarithm of 20). And that's even before you deal with the flag. So, in general you use a for loop when you have something to iterate over, or can easily produce something to iterate over, and use a while loop for more general looping based on mutating local variables.

Frankly for those specific numbers you might as well write for i in (1, 2, 4, 8, 16) and have done with it!