We already know that a variable isn't a 'memory cell' that stores a value. Python creates an object, and a name starts referring to it. But that raises a new question: where is the name itself stored?

In the previous article, we learned about the `while` loop. It is great when we do not know in advance how many times an action needs to be repeated. But very often we already know that we want to iterate over some set of data.

In the previous article, we learned how to make programs make decisions. But what should we do when an action needs to be performed many times?

When the last reference disappears, Python knows the object is no longer needed and frees its memory. At first glance, that seems like all we need. But let’s look at a small example.

Until now, our programs always executed in the same way. But often a program needs to make decisions.

If an object continues to exist after its name is deleted, who decides when it can finally be removed from memory?

So far, every program we've written has behaved exactly the same way. But real programs need to interact with their users.

To answer that question, let's revisit one of the very first ideas we learned in this series.

In the previous article, we learned how to store data in variables. But what kinds of data can Python actually store?

We're used to thinking of a copy as a completely independent duplicate. The confusion comes from the fact that Python supports more than one kind of copying.

Now it's time to understand how Python stores data.

Many people expect `+=` to simply change a variable. But if you inspect the object with `id()`, you'll sometimes discover that it's actually a different object. Why does `+=` create a new object in some cases but not others?

To understand what's going on, it's enough to recall what we discussed in previous articles. First, variables don't store objects - they only reference them. Second, a list is a mutable object.

When people say, 'I write Python', they're usually referring to two different things at once. The first is the 'Python language' itself. The second is 'the program that can execute that code'.

If you ask a beginner what the difference is between is and ==, you'll often hear something like `==` compares values, while `is` compares references.

Python divides all objects into two large groups. The first group is called mutable objects. The second is immutable objects.

It almost looks as if Python somehow 'links' variables together. But that's not what's happening.

In the previous article, we learned that variables in Python don't store data themselves. Instead, a name simply refers to an object. With numbers, this feels quite intuitive. But as soon as we start working with lists, Python's behavior often surprises people.

At first glance it sounds obvious. We imagine a variable as a box in memory where you put a value. But Python works a little differently - and understanding that difference explains a lot.