Can One Object Be Used for Multiple Keys in Python?

[Rajeev Bagra]

Understanding Shared Objects with the Student Example

---

🔹 Initial Context

While learning Object-Oriented Programming (OOP) in Python, we often write code like this:

class Student:
    def __init__(self, exercises):
        self.exercises = exercises

And then store objects in a dictionary:

students = {}

students["Alice"] = Student(12)
students["Bob"] = Student(7)

Each key stores a reference to a Student object.

A common question learners ask is:

“If Student(12) already exists, can I reuse it for other students who also have 12 exercises?”

This tutorial explains what happens when you reuse objects — and when you should avoid doing so.

---

🔹 Step 1: Creating One Object and Reusing It

Let’s create one object first:

s = Student(12)

students["Alice"] = s
students["Charlie"] = s

Now both names refer to the same object.

Internally:

"Alice"   → s
"Charlie" → s

There is only one Student object in memory.

---

🔹 Step 2: What Happens When You Modify It?

Now change Alice’s record:

students["Alice"].exercises = 20

print(students["Charlie"].exercises)

Output:

20

Why?

Because both names point to the same object.

You did not create two students — you created one student with two labels.

---

🔹 Step 3: Visual Memory Model

Think of memory like this:

Object in Memory

Object S → Student(exercises=12)

Dictionary

"Alice"   → Object S
"Charlie" → Object S

After update:

Object S → Student(exercises=20)

Both keys now show the updated value.

---

🔹 Step 4: Creating Separate Objects with Same Values

Usually, this is what you want:

students["Alice"] = Student(12)
students["Charlie"] = Student(12)

Now:

"Alice"   → Student(12)  (Object A)
"Charlie" → Student(12)  (Object B)

They look the same, but they are different objects.

---

🔹 Step 5: Identity vs Value (is vs ==)

Try this:

a = Student(12)
b = Student(12)

print(a is b)
print(a == b)

Output:

False
False

Explanation:

• is → checks if both variables point to the same object
• == → checks if values are equal (not implemented here, so False)

They are different objects in memory.

---

🔹 Step 6: Using id() to See Memory Addresses

You can see this clearly with id():

a = Student(12)
b = Student(12)

print(id(a))
print(id(b))

The numbers will be different — showing two separate objects.

But with shared objects:

s = Student(12)
x = s
y = s

print(id(x))
print(id(y))

They will be the same.

---

🔹 Step 7: When Is Sharing an Object Useful?

Sharing objects is useful when the object represents something common.

Examples:

✔ App configuration
✔ Global counters
✔ Shared settings
✔ Cache objects

Example:

config = Config()

users["Alice"] = config
users["Bob"] = config

Here, sharing is intentional.

---

🔹 Step 8: When Should You NOT Share Objects?

Do NOT share when the object represents:

❌ People
❌ Accounts
❌ Profiles
❌ Records
❌ Contacts

Each entity should have its own object.

Example (correct way):

students["Alice"] = Student(12)
students["Bob"] = Student(12)

---

🔹 Step 9: Real-World Analogy

Imagine two students score 12 marks.

Do they become the same person?

No.

They just share a value.

Python works the same way.

Same value ≠ Same object.

---

🔹 Step 10: Common Beginner Mistake

Mistake:

s = Student(0)

for name in names:
    students[name] = s   # ❌ Wrong

Result: All students share one record.

Correct:

for name in names:
    students[name] = Student(0)   # ✅ Correct

Each gets their own object.

---

✅ Final Takeaway

In Python:

Dictionaries store references to objects.

If multiple keys point to the same object, they share data.

Remember:

✔ Reusing object = shared state
✔ New object = independent state
✔ Most real-world entities need separate objects

Understanding this helps you avoid serious logical bugs in larger programs.

---

 

[Author]

Posts