The Secret Life of Python: The Matryoshka Trap

#python#coding#programming#softwaredevelopment

Timothy was humming a tune as he organized the library’s archives. He felt invincible. He had mastered the "Slice," the magical [:] syntax that allowed him to clone lists and avoid the curse of Aliasing.

"Margaret," he called out, "I’m reorganizing the library sections. I made a master map of the shelves, and I’m creating a backup before I move anything around. Look at this beautiful shallow copy."

He displayed his code, confident in his new skills.

# Timothy's Nested Plan
shelf_A = ["Fiction", "Mystery"]
shelf_B = ["Biography", "History"]

# The Master Layout: A list of lists
library_layout = [shelf_A, shelf_B]

# The Backup: Using the "Slice" trick he learned yesterday
# (Surely this clones everything... right?)
backup_layout = library_layout[:] 

# Now, let's move "Mystery" to a new location in the backup
# We access the first shelf (index 0) and remove "Mystery"
backup_layout[0].remove("Mystery")

print(f"Backup Shelf A: {backup_layout[0]}")
print(f"Master Shelf A: {library_layout[0]}")

"I modified the backup," Timothy explained. "But since I used the slice [:], the Master Layout should still have 'Mystery' on the shelf."

Margaret didn't look up from her tea. "Timothy, do you know what a Matryoshka doll is?"

Timothy hit Run, ignoring the question.

# Console Output:
Backup Shelf A: ['Fiction']
Master Shelf A: ['Fiction']

The music stopped. Timothy stared. "It’s gone. 'Mystery' is gone from the Master Layout too. But... but I used the slice! I made a new box!"

The Illusion of Safety

"You did make a new box," Margaret said, finally walking over. She placed a large wooden box on the table.

"This is your backup_layout list," she said.

Then, she reached inside and pulled out a slip of paper. "But what is inside the box?"

Timothy looked. "The inner lists? shelf_A and shelf_B?"

"No," Margaret corrected. "Inside the box are references. Think of them as string holding onto the inner lists."

She drew a diagram on the whiteboard to show exactly what had happened.

Original List        Backup List
   [Box 1]             [Box 2]
      |                   |
      +-------+   +-------+
              |   |
              v   v
           [Inner List]
          (Shared Data!)

"When you sliced the outer list," Margaret explained, "you copied the outer container. You made a new box. But inside that new box, you placed the exact same strings pointing to the exact same inner lists."

"This is the Matryoshka Trap," she whispered. "A Shallow Copy ([:] or .copy()) only constructs a new outer shell. If your list contains other mutable objects—like other lists or dictionaries—those inner objects are shared."

"So when I reached into the backup," Timothy realized, horrified, "I was reaching through a new window... but into the same room."

"Precisely."

The Deep Copy

"So how do I copy everything?" Timothy asked. "I want a new outer box, and new inner boxes. I want a complete clone."

"For that," Margaret said, "the standard syntax is not enough. You need a specialist. You must import the copy module."

She typed the solution:

import copy

shelf_A = ["Fiction", "Mystery"]
shelf_B = ["Biography", "History"]
library_layout = [shelf_A, shelf_B]

# The Deep Copy: Recursively copies everything
backup_layout = copy.deepcopy(library_layout)

backup_layout[0].remove("Mystery")

print(f"Backup Shelf A: {backup_layout[0]}")
print(f"Master Shelf A: {library_layout[0]}")

Output:

Backup Shelf A: ['Fiction']
Master Shelf A: ['Fiction', 'Mystery']

" copy.deepcopy() is thorough," Margaret explained. "It walks down the entire tree of objects. If it finds a list inside a list inside a dictionary, it clones all of them. It leaves no string attached to the original."

"Why isn't that the default?" Timothy asked.

"Because it is expensive," Margaret replied. "It takes time and memory to clone an entire world. For a small list, the difference is negligible. But if you are copying a massive nested structure thousands of times, the performance hit becomes real."

"Python assumes you usually want speed," she concluded. "But when you need safety for nested data, you must ask for it explicitly."

Margaret’s Cheat Sheet

Margaret opened her notebook to the "Memory" section, adding a red warning label.

• The Trap: Shallow Copies ([:], .copy(), list()) only copy the first layer.
• The Consequence: If your list contains other mutable items (lists, dicts, objects), the copy shares them with the original.
• The Solution: Use copy.deepcopy() for nested data.
• import copy

• new_list = copy.deepcopy(old_list)

• The "Explicit" Shallow Copy: copy.copy(x) does the same as x[:] but works on any object, not just lists.

• When to use Deep Copy?

• Flat List ([1, 2, 3]): Shallow Copy is fine.

• Nested List ([[1, 2], [3, 4]]): Use Deep Copy.

Timothy looked at his fully restored Master Layout. "Layers," he muttered. "Everything has layers."

"Indeed," Margaret smiled, sipping her tea. "Just like Python."

---

In the next episode, Margaret and Timothy will face "The Loophole"—where modifying a list while looping over it creates a chaotic, skipping timeline.

---

Aaron Rose is a software engineer and technology writer at tech-reader.blog and the author of Think Like a Genius.