Python Basics
2026-02-21 21:10 Diff
https://hexlet.io/courses/python-basics/lessons/while/theory_unit

The code we write in this course becomes more complex and extensive. Although our programs are still far from real-life programs, we are not making it easier for you.

In this lesson, we will come to one of the most difficult fundamental topics in programming — loops.

Reasons to use loops

Applications can help you manage employees, control your finances, and provide entertainment. Despite the differences, they all execute embedded algorithms that are similar to each other. Algorithms are sequences of actions that lead to expected results.

Suppose we have a book and want to find a particular phrase there. We remember the words but not what page it is on. We have to go through the pages until we find the right one. It is an example of an algorithm.

This algorithm includes logical checks and page lookups. We do not know how many pages we will need to look at. But the viewing process itself is repeated in the same way. To perform repetitive actions, you need loops. Each repetition is an iteration.

We will write a function with a simple loop that will display the string 'Hello!' for n times:

Now we will analyze an example function with a loop that displays numbers from one to n.

We pass the n to the function as an argument:

You cannot implement this function with the tools you have learned so far because we do not know the number of outputs beforehand. But this is not a problem for loops:

The while loop

A while loop consists of three elements:

  • The keyword while
  • The predicate — a condition we compute at each iteration
  • The code block — a loop body

Each execution of a body is an iteration. In the example above, print_numbers(3) is three iterations, each displaying the i variable. Here we say:

Execute the loop body as long as the condition i <= last_number is True

Let us look at how this code works when you call print_numbers(3):

The end of the loop

The process that generates the loop must stop. The programmer is responsible for this.

Usually, this boils down to introducing a variable called the loop counter. First, we initialize it by giving it an initial value. In our example, it is the line i = 1. The loop condition then checks if the counter has reached its limit.

In the example, the limit depends on the function argument. The program does not execute the body if the loop does not satisfy the condition. The interpreter continues with the instructions after the loop.

If the loop condition is True, we execute the body that contains the stop element. In this case, it is changing the counter. Usually, it is at the end of the body, and you cannot change the counter without a variable. In the example above, the line i = i + 1 is responsible for the change.

At this point, beginners make a lot of mistakes. For example, you may forget to increment the counter or check it incorrectly in the predicate. It will cause the loop to run indefinitely, and the program will never stop. In this case, you need to force it to stop:

In some cases, infinite loops are helpful. We will not look at these situations right now, but we can show you what this code looks like:

You cannot do without loops when an algorithm for performing a task requires repeating actions, and we do not know how many times we need to repeat those actions.

The syntactic sugar

In Python, constructions like index = index + 1 are widespread, so the creators of the language added an abbreviated version: index += 1.

The only difference is how we write them. The interpreter will turn an abbreviated construction into its expanded form.

Such abbreviations are syntactic sugar because they make code writing a little easier and more pleasant.

There are abbreviated forms for all arithmetic operations and string concatenation:

  • a = a + 1 → a += 1
  • a = a - 1 → a -= 1
  • a = a * 2 → a *= 2
  • a = a / 1 → a /= 1