How to use the Python for loop

Table of Contents

When you want to produce a loop in Python, you commonly have two choices: the when loop and the for loop. when is very simple: it just repeats right until a specified issue is no lengthier accurate. The for loop is more elaborate, and so more potent: for lets you iterate by means of objects in a collection of some type without having possessing to know specifics about the collection.

Python for loop parts

A Python for loop has two parts:

A container, sequence, or generator that is made up of or yields the factors to be looped more than. In typical, any object that supports Python’s iterator protocol can be utilized in a for loop.
A variable that retains every single ingredient from the container/sequence/generator.

In the pursuing case in point, we loop by means of a list of figures, and use the variable digit to keep every single quantity in flip:

for digit in [three,one,4,one,5,nine]:
    print (digit)

This will print:

three
one
4
one
5
nine

If you are iterating by means of an object that yields containers or sequences, you can use Python’s multi-assignment syntax to unpack them. For occasion:

for letter, quantity in [["a",one],["b",2]]:
    print (letter, quantity)

The output:

a one
b 2

Widespread Python for loops

Below are some widespread objects utilized in a Python for loop:

Lists

The case in point earlier mentioned reveals how a list can be iterated more than using a for loop. Note that if you have a list of lists, every single ingredient extracted by the for loop will itself be a list. for loops do not mechanically “flatten” nested constructions of any type.

Strings

Strings in Python are regarded as “sequences” — they can be iterated more than, and the final results of iterating more than a string are every single character in the string.

for letter in "Hello planet":
    print (letter)

This would generate:

H
e
l
l
o

w
o
r
l
d

Dictionaries

Iterating by means of a dictionary with a for loop yields every single crucial in the dictionary.

d1 = 
    "a": one,
    "b": 2


for crucial in d1:
    print (crucial)

This would generate:

a
b

If you want to iterate by means of the values of a dictionary, use the dictionary’s .values() technique. You can also iterate by means of keys and values together, with .things():

d1 = 
    "a": one,
    "b": 2


for crucial, value in d1.things():
    print (crucial, value)

This would generate:

a one
b 2

Generators

Generators generate a succession of things, just one for every single time they are termed. A widespread case in point of a generator utilized in a for loop is vary.

for n in vary(50):
    print (n)

This would print the figures by means of forty nine.

Note that just simply because you can use a generator in a for loop does not necessarily mean that the generator will inevitably stop of its possess accord. For occasion, this for loop will run for good:

def for good():
    when Accurate:
        generate one

for n in for good():
    print (n)

In these types of situations you may well want to get actions to ensure the loop can terminate. (See “Flow control” under.)

Employing indexes and enumerate with a Python for loop

Developers who arrive to Python from languages like C, C++, or Java will typically produce an index variable that is utilized to move by means of the object staying iterated. An case in point:

x=[three,one,4,one,5,nine]
n = 
when n
This isn’t wrong as these types of, but it misses the place of how Python works. A for loop in Python does not demand an index it can just traverse the object to be iterated more than without having needing to index into it.
Even so, often you will need to keep track of which ingredient you’re dealing with when looping. Python’s enumerate() utility aids with this. It requires an iterable and on every single iteration generates a tuple of the index and the object at that index:
x = [three,one,4,one,5,nine]
for index, n in enumerate(x):
    print (index, n)

 three
one one
2 4 
three one
4 5
5 nine

Circulation handle in a Python for loop
for loops do not generally run to completion, or in actual sequence. From time to time you want to go away a for loop early, or skip more than an product in the loop. To do that, Python supplies you with two keywords and phrases: crack and continue on.
for n in vary(20):
    if n % 2 == : # if n is a multiple of 2
        continue on   # then skip it
    # anything immediately after this place is not run
    # if `continue` is invoked
    print (n)
print ("Completed")

This yields one three 5 seven nine 11 thirteen 15 seventeen 19, then Completed. Note that when the loop ends, the plan continues usually at print ("Completed").
for n in vary(20):
    if n == 10:
        crack # go away the loop completely
    print (n)
print ("Completed")

This prints the figures  by means of nine, then Completed.
Note that if you have loops nested within other loops, crack will only impact the existing loop — it will not likely exit from all loop levels. Exiting from multiple for loops necessitates a unique system, like a sentinel variable:
performed = Fake
for n in vary(20):
    for m in vary(40):
        if n==10 and m==10:
            performed = Accurate
        if performed: crack
    if performed: crack

A Python for loop gotcha
When iterating more than the factors of an object in a for loop, do not do anything at all that would change the customers or length of the sequence. For occasion, if you’re iterating more than a list, do not include or take away factors from the list as you iterate.
If the cause you’re iterating more than factors is to take a look at every single ingredient to see if you will need to include or take away one thing, there is a better alternative. Create a new, empty container, populate it only with the factors you want to keep, then change the outdated container with the new just one.
Below is an case in point with a list. This results in a new list that is made up of only odd figures:
outdated_list = [one,2,three,4,5,six]
new_list = []
for n in outdated_list:
    if n % 2:
        new_list.append(n)
outdated_list = new_list