Prove with the help of an example that the variable is rebuilt in case of immutable data types.

Exercise · Q7

Q. Prove with the help of an example that the variable is rebuilt in case of immutable data types.

Yanam BieapTextbookSubjective· 3mImportance★★★★★est

97% · 29/30 Questions

🔒 Locked · start free trial →

You're viewing a preview — the full solution, concept, methods & PYQ mapping are locked.

Start your 14-day free trial to unlock the full solution →

Concept understanding — Immutable Variable Reassignment

Immutable Variable Reassignment — What It Means and Why It Matters

Let’s start with a simple picture. Imagine you have a box labelled x, and inside it you put the number 5. Later, you decide you want x to hold 10 instead. You open the box, take out the 5, and put in 10. That’s reassignment — the variable x now points to a different value.

Now imagine a different kind of box. This one is sealed. Once you put 5 inside, you cannot change what’s inside. The box itself is immutable. If you want x to refer to 10, you cannot modify the sealed box. Instead, you throw away the old box and create a brand new sealed box containing 10, and label that one x. The old box (with 5) still exists somewhere — you just stopped using it.

That’s the core intuition: immutable variable reassignment means the variable’s name can be pointed to a new object, but the object itself never changes.

The Precise Statement

Important

Immutable variable reassignment is the act of binding a variable name to a new immutable object, after the variable was previously bound to a different immutable object. The original object remains unchanged; only the reference changes.

In programming languages (like Python, Java, or C++ with const), some types are immutable — their state cannot be modified after creation. Common examples: integers, floats, strings, tuples (in Python), and String objects (in Java).

When you write:

x = 5
x = 10

Here’s what happens step by step:

An integer object 5 is created in memory. It is immutable — you cannot change it to 6 or 10.
The name x is bound (pointed) to that object.
A new integer object 10 is created.
The name x is rebound to point to 10.
The original 5 object is still in memory (until garbage collected), but x no longer refers to it.

No mutation occurred. The 5 object never became 10. The variable x simply changed which object it names.

Why This Confuses Beginners

The confusion comes from the word “reassignment.” It sounds like you’re changing the variable’s value. But in immutable types, you’re actually changing which value the variable points to. The old value stays exactly as it was.

Watch out

A common mistake is to think x = x + 1 modifies the integer x. It does not. It creates a new integer (x + 1) and rebinds x to it. The original integer is untouched.

Contrast with Mutable Reassignment …

Start your 14-day free trial to unlock the full solution →

An immutable object (int, float, str, tuple) can never be changed in place. When we "modify" such a variable, Python builds a new object and rebinds the name to it. The built-in id() function exposes this — it returns a unique identity for the object a name currently refers to.

x = 10
print(id(x))   # identity of the object 10
x = x + 5
print(id(x))   # a DIFFERENT identity -> a new object 15 was built
``` …

Start your 14-day free trial to unlock the full solution →

Compare id() before and after "changing" an int or a string: the identity changes, proving Python built a brand-new object — immutable variables are rebuilt, never edited in place.

The idea. Data types like int, float, str and tuple are immutable — once an object is created, its value can never change. So a statement like x = x + 5 cannot modify the object 10; Python evaluates x + 5, creates a new object 15, and rebinds the name x to it. The tool that proves this is the built-in id() function, which returns a unique identity (roughly, the memory address) of the object a name is currently bound to. If the variable were updated in place, id() would stay the same; if it is rebuilt, id() changes.

Proof by example:

x = 10
print("x =", x, "id =", id(x))
x = x + 5          # x is REBUILT: a brand new int object is created
print("x =", x, "id =", id(x))

s = "Hello"
print("s =", s, "id =", id(s))
s = s + " World"   # strings are immutable too - s is rebuilt
print("s =", s, "id =", id(s))

Sample run (the actual id values will differ on every machine and every run — what matters is that they CHANGE):

x = 10 id = 140722972386376
x = 15 id = 140722972386536
s = Hello id = 2079190860208
s = Hello World id = 2079190873328

What this shows, line by line: …

Start your 14-day free trial to unlock the full solution →

←Previous questionQ6 — When to use tuple or dictionary in Python. Give some examples of progr…→Next questionQ8 — TypeError occurs while statement 2 is running. Give reason. How can it…

Q.Prove with the help of an example that the variable is rebuilt in case of immutable data types.

🎓Unlock everything free for 14 days

Unlock everything free for 14 days