For loop iterate over powers of 2

You’ll need to create your own function:

def doubling_range(start, stop):
    while start < stop:
        yield start
        start <<= 1

This uses a left-shift operation; you could also use start *= 2 if you find that clearer.

Demo:

>>> def doubling_range(start, stop):
...     while start < stop:
...         yield start
...         start <<= 1
... 
>>> for i in doubling_range(2, 1025):
...     print i
... 
2
4
8
16
32
64
128
256
512
1024

You say you want to iterate over the powers of 2 for each loop,

Seeing your example, the formulation could be:

Make a loop that multiply the initial by 2 untill it reach 1024.

ii = 2
while ii <= 1024: 
    print(ii)
    ii = ii*2

You don’t need your own function for this one, just use a lambda

import sys
from math import log
for i in map(lambda v : pow(2,v), range(0,log(1024, 2))):
    print i

output looks like

1
2
4
8
16
32
64
128
256
512
1024

If you know what power of 2 you need to go to. If you don’t, you could just go up to the largest storable int, like this:

from math import log
import sys
for i in map(lambda v : pow(2,v), range(0,int(log(sys.maxint, 2)))):
    print i

Output looks like

1
2
4
8
16
32
64
128
256
512
1024
2048
4096
8192
16384
32768
65536
131072
262144
524288
1048576
2097152
4194304
8388608
16777216
33554432
67108864
134217728
268435456
536870912
1073741824
2147483648
4294967296
8589934592
17179869184
34359738368
68719476736
137438953472
274877906944
549755813888
1099511627776
2199023255552
4398046511104
8796093022208
17592186044416
35184372088832
70368744177664
140737488355328
281474976710656
562949953421312
1125899906842624
2251799813685248
4503599627370496
9007199254740992
18014398509481984
36028797018963968
72057594037927936
144115188075855872
288230376151711744
576460752303423488
1152921504606846976
2305843009213693952
4611686018427387904

You can use a generator expression so that it generates the numbers as needed and they don’t waste memory:

>>> for x in (2**p for p in range(1, 11)):
...    print(x)

2
4
8
16
32
64
128
256
512
1024

In Python 2, you can use xrange instead of range to keep it as a generator and avoid creating unnecessary lists.

If you want to enter the actual stop point instead of the power to stop at, this is probably the simplest way:

from itertools import count
for x in (2**p for p in count(1)):
    if x > 1024:
        break
    print(x)

You could put it all in one line:

from itertools import count, takewhile
for x in takewhile(lambda x: x <= 1024, (2**p for p in count(1))):
    print(x)

but that’s becoming silly (and not very readable).

def ram_size(min_size: int, step: int, max_size: int):
    """list generator from min to max powered by step"""
        size = min_size
        while size <= max_size:
            yield size
            size *= step