You can use the second argument of iter(), to call a function repeatedly until its return value matches that argument. This would loop forever as 1 will never be equal to 0 (which is the return value of int()):
for _ in iter(int, 1):
pass
If you wanted an infinite loop using numbers that are incrementing you could use itertools.count:
from itertools import count
for i in count(0):
....
You can use the second argument of iter(), to call a function repeatedly until its return value matches that argument. This would loop forever as 1 will never be equal to 0 (which is the return value of int()):
for _ in iter(int, 1):
pass
If you wanted an infinite loop using numbers that are incrementing you could use itertools.count:
from itertools import count
for i in count(0):
....
The quintessential example of an infinite loop in Python is:
while True:
pass
To apply this to a for loop, use a generator (simplest form):
def infinity():
while True:
yield
This can be used as follows:
for _ in infinity():
pass
Videos
DISCLAIMER: This post is mainly just curious thoughts, it has nothing to do with real-life application or good practice. So please don't actually use any examples provided.
Python is (or at least was) rather famous for its possibilities for one-liners (programs occupying only a single line of code) some time ago. A lot of things can be achieved like this, but among the most puzzling things must be infinite loops; they aren't exactly easy to implement with the tools we have available.
An infinite loop usually requires the use of a while-loop, because for-loops have a beginning and an end. Using a while-loop in one-liners is problematic, though, because you may only use it once, on the top level. This is due to how Python restricts block structures to either be separated by whitespace (and proper indentation), or to only have a single depth level following it. In other words,
while True: print("This works!")is valid Python, but
while True: if 1 == 1: print("But this doesn't...)is not.
We do have another "kind" of loop, though; list comprehensions. They are unique in that they may be nested as we see fit, all while using only a single line.
[["Order pizza." for _ in range(6)] for _ in range(42)]
But this doesn't give us an infinite loop; even if we simply input a ridiculously large number to range, it's still technically finite no matter what kind of hardware we're using. Thus, a different approach is required. I mentioned how infinite loops usually require the use of while-loops in Python. We can, however, utilise a certain property of Python to create an infinite loop with for-loops.
nums = [1, 2, 3, 4]
for num in nums:
print(num)Okay, that prints out four numbers. Not exactly infinite. But if we tweak our approach a little...
nums = [1]
for num in nums:
print(num)
nums.append(num + 1)We actually get... as many numbers as the computer's memory allows. With this, we can essentially get something like this to work:
nums=[1];[(print(num) and nums.append(num+1)) for num in nums]
(Disclaimer; I never tested if that actually runs.)
It's not a pure one-liner, because it still technically requires two lines (fused together with a semicolon), but it's a proof-of-concept. I initially tried to make it work without having to define a variable, but failed to find a way.
I hope this was mildly interesting, I don't usually write stuff like this. Just found it curious myself, so why not share the thought? Maybe someone can even improve on this.
range is a class, and using in like e.g. range(1, a) creates an object of that class. This object is created only once, it is not recreated every iteration of the loop. That's the reason the first example will not result in an infinite loop.
The other two loops are not infinite because, unlike the range object, the loop variable i is recreated (or rather reinitialized) each iteration. The values you assign to i inside the loop will be overwritten as the loop iterates.
Consider a for loop:
for item in iterable:
print(item)
The idea is that as long as iterable is unchanged, we will loop through each and every item inside iterable once. For example,
for item in [3, 2, 1, 666]:
print(item)
will output 3 2 1 666. In particular, we find that range(1, 4) is a easy way to represent an iterable [1, 2, 3]. Thus,
for i in range(1, 4):
print(i)
will output 1 2 3.
Example 1
a=5
for i in range(1,a):
print(i)
a=a+1
In this case, range(1,a) is evaluated once, when the loop begins.
Example 2
for i in range(1,4):
print(i)
i=i-1
In this case, i is reevaluated every loop, before executing the print and i=i-1 statements within the body of the loop.
Example 3
for i in range(1,4):
print(i)
i=1
Just like Example 2, i is reevaluated every loop.
Iterating over a list which you are simultaneously updating is bad practice.
In your code, the range is already calculated before you run the loop, so the range will be range(1), and then the for loop runs just that once and stops. This can also be observed if listWords is not empty, but is listWords = ['a','b'], so below loop run 3 times since the iterator is range(3)
Then the code becomes.
listWords = ['a','b']
for i in range (len(listWords)+1):
listWords.append("New word")
print ("End loop")
print(listWords)
['a', 'b', 'New word', 'New word', 'New word']
While loop doesn't have such a limitation, The below example will keep running since len(listWords) is always updated at the end of next iteration
listWords = []
i = 0
while i < (len(listWords)+1):
listWords.append("New word")
i+=1
As already noted, updating a list while iterating it is generally a bad idea. However, it seems like in this case this is exactly what you want to do. Instead of calculating the len of the list before iterating the list (which is exactly why it is never updated) you could iterate the elements in the list directly.
>>> lst = [1,2,3]
>>> for x in lst:
... if x < 10:
... lst.append(x*2)
...
>>> lst
[1, 2, 3, 2, 4, 6, 4, 8, 12, 8, 16, 16]
If you need the index of the current element (or both the index and the element itself) you could use for i, x in enumerate(lst) to the same effect.
The itertools.repeat function will return an object endlessly, so you could loop over that:
import itertools
for x in itertools.repeat(1):
pass
To iterate over an iterable over and over again, you would use itertools.cycle:
from itertools import cycle
for t in cycle(range(0, 4)):
print(t)
This will print the following output:
0
1
2
3
0
1
2
3
0
1
...
words = ['cat', 'window', 'defenestrate']
for w in words:
if len(w) > 6:
words.insert(0, w)With for w in words:, the example would attempt to create an infinite list, inserting defenestrate over and over again. I don't understand why the for-loop does it; shouldn't it exit from the loop when it comes to the value defenestrate and the code below the if statement is executed since it evaluates to True.
If the statement was while without any break statement I would understand, but with a for-loop I don't understand. Why is there no end when it doesn't have to go through an infinite list but only a list with 3 values.
In contrast, If I just change the line for w in words: to for w in words[:]: the loop will no longer be infinite and the output will be ['defenestrate', 'cat', 'window', 'defenestrate'] Why is that so?
I am a beginner in programming and would be grateful if you could answer with no advanced terms. Thx.
The example itself can be seen in the Python documentation 3.7.2 under Tutorials, under More Control Flow Tools, under For Statements.