क्या प्रत्येक पुनरावृत्ति के बाद पाइथन में "फॉर" लूप को मेरे इंडेक्स वैल्यू को डबल करने का कोई तरीका है?

Question

सी ++ में, मैं आसानी से की तरह नीचे है कि इस उद्देश्य के

for(int i = 1; i < 100; i *= 2){} 

वहाँ पायथन में एक for पाश एक ही बात करते हैं बनाने के लिए कोई तरीका है को प्राप्त होता है पाश के लिए एक लिख सकता है? या while लूप एकमात्र तरीका है जो मैं कर सकता हूं।

Answer 1

for लूप कोई वृद्धि नहीं करते हैं; वे इसके बजाय एक पुनरावृत्त पर फिर से शुरू होते हैं।

आप एक जनरेटर समारोह है कि एक iterable के रूप में अपना नंबर अनुक्रम का उत्पादन बना सकते हैं:

def powers_of_two(start, stop=None): 
    if stop is None: 
     start, stop = 1, start # start at 1, as 0 * 2 is still 0 
    i = start 
    while i < stop: 
     yield i 
     i *= 2 

for i in powers_of_two(129): 
    # ... 

डेमो:

>>> for i in powers_of_two(129): 
...  print(i) 
... 
1 
2 
4 
8 
16 
32 
64 
128 

Answer 2

एक जनरेटर, कि लिखा जा सकता है कुछ हद तक पाश के लिए सी ++ के समान है, लूप वैरिएबल में हेरफेर करने के लिए लैम्ब्डा फ़ंक्शन के रूप में अभिव्यक्ति लेता है।

def func_range(func, start, stop=None): 
    start, stop = (0, start) if stop is None else (start, stop) 
    while start < stop: 
     yield start 
     start = func(start) 


for i in func_range(lambda x: x*2, 1, 100): 
    print(i) 

Answer 3

पावर ऑपरेटर का उपयोग करें।

In [1]: [2**j for j in range(7)] 
Out[1]: [1, 2, 4, 8, 16, 32, 64] 

Answer 4

generator चाल

def doubler(n): 
    x = 1 
    while x < n: 
     yield x 
     x *= 2 


for i in doubler(100): 
    print(i) 

Answer 5

थोड़ा राउंडअबाउट करना होगा, लेकिन काम कर देता है: पाश के लिए

>>> for i in itertools.takewhile(lambda t: t < 100, (2**x for x in itertools.count())): 
... print(i) 
... 
1 
2 
4 
8 
16 
32 
64 

Answer 6

एक C++ वास्तव में भेष में बस थोड़ी देर के पाश है।

for (int i = 1; i < 100; i *= 2) 
{ 
    // do stuff 
} 

तो चालाक बनने की कोशिश नहीं करते

int i = 1; 
while (i < 100) 
{ 
    // do stuff 
    i *= 2 
} 

के बराबर है। बस थोड़ी देर लूप का प्रयोग करें।