Python Strings- A complete guide

💯 YES! You’ve understood the core idea perfectly —
and you’re already thinking like an advanced Pythonist now. 👏

Let’s go step-by-step, so you not only confirm your understanding,
but also see what’s happening behind the scenes in memory.

🧠 1️⃣ The Key Principle

In Python, immutable objects (like str, int, tuple) cannot be changed after creation.
So every “change” to them creates a new object in memory.

Mutable objects (like list, dict, set) can be changed in place — no new object creation.

🔍 2️⃣ Quick Recap of Mutable vs Immutable Types

🧩 3️⃣ Example 1 – Strings: The Classic Case

s = "Hello"
print(id(s))  # e.g., 140562398002672

s = s + " World"
print(id(s))  # Different ID → New object!

Even though you “modified” s,
the original "Hello" string stayed untouched,
and Python allocated new memory for "Hello World".

🧠 Internally:

1. Python creates new string of length = len(s) + len(” World”).
2. Copies characters from old s + new " World".
3. Returns a new str object.

⚡ 4️⃣ Example 2 – Lists: Mutable and Efficient

nums = [1, 2, 3]
print(id(nums))

nums.append(4)
print(nums)        # [1, 2, 3, 4]
print(id(nums))    # same ID → modified in place

✅ No new list was created.
Python simply extended the existing list’s underlying memory buffer.

🧱 5️⃣ Example 3 – Why immutability can cause inefficiency

❌ Inefficient string concatenation

result = ""
for word in ["I", "love", "Python"]:
    result += word + " "

Each += creates a new string → copies everything again → O(n²) behavior.

✅ Efficient way (using mutable structure internally)

words = ["I", "love", "Python"]
result = " ".join(words)  # O(n)

.join() first computes total length, allocates once, and fills in efficiently.

🧪 6️⃣ Example 4 – Numbers are immutable too!

x = 10
print(id(x))

x += 5
print(id(x))

Different IDs!
Each time you “increment”, Python creates a new int object in memory.

🧮 7️⃣ Example 5 – Tuples vs Lists

t = (1, 2, 3)
print(id(t))
t = t + (4,)
print(id(t))  # new tuple

But with a list:

l = [1, 2, 3]
print(id(l))
l.append(4)
print(id(l))  # same list object, mutated

⚙️ 8️⃣ Example 6 – Dicts and Sets are Mutable

d = {"a": 1}
print(id(d))

d["b"] = 2
print(id(d))  # same id → changed in place

Set example:

s = {1, 2, 3}
s.add(4)
print(s)  # {1, 2, 3, 4}

🧩 9️⃣ Example 7 – Immutable + Mutable Combo Pitfall

Tuples can contain mutable objects:

t = (1, [2, 3])
print(id(t[1]))

t[1].append(4)
print(t)           # (1, [2, 3, 4])
print(id(t[1]))    # same inner list!

Even though the tuple is immutable,
its contents (if mutable) can change → surprising behavior for newcomers.

⚡ 10️⃣ Example 8 – Optimizing String Processing with Mutable Structures

Say you want to reverse words in a long text.

❌ Bad (Immutable operations repeatedly)

def reverse_words_bad(text):
    words = text.split()
    reversed_text = ""
    for word in words:
        reversed_text = word + " " + reversed_text
    return reversed_text.strip()

Every + → new string allocation → very slow for large text.

✅ Good (Mutable intermediate list)

def reverse_words_good(text):
    words = text.split()
    words.reverse()
    return " ".join(words)

🧠 11️⃣ Behind-the-scenes Memory Visualization

s = "hi"
s2 = s + "!"

Memory diagram:

┌─────────────┐        ┌──────────────┐
│  "hi"       │  --->  │  "hi!"       │
└─────────────┘        └──────────────┘
       ↑                     ↑
       s                     s2

Each operation creates a new object and makes s2 reference it.

⚙️ 12️⃣ So when should you choose mutable vs immutable?

💬 13️⃣ Real-world Example — Logging or ETL String Building

If you’re building SQL dynamically or logging strings repeatedly:

❌ Inefficient:

log = ""
for msg in messages:
    log += msg + "\n"

✅ Efficient:

parts = []
for msg in messages:
    parts.append(msg)
log = "\n".join(parts)

⚡ 14️⃣ Example with Numbers (accumulating sum)

Even with simple integers:

x = 0
for i in range(10**6):
    x += i  # new int each time

Python internally creates a new int every time.
It’s fine because ints are small and optimized, but conceptually the same rule applies.

🧩 15️⃣ Example – Using Mutable Accumulators

Instead of building new strings or tuples:

# Bad
result = ()
for i in range(1000):
    result += (i,)  # new tuple each time

# Good
temp = []
for i in range(1000):
    temp.append(i)
result = tuple(temp)

✅ Much faster and memory-friendly.

🧭 16️⃣ Summary – The Core Rule

Immutable: any “update” → new object
Mutable: update happens in place

So:

• Use mutable structures (list, dict, set) for intermediate computations.
• Convert to immutable at the end if needed (tuple, frozenset, str).

Would you like me to show you a memory diagram + Python id() demo notebook (visualizing new object creation live in code) —
so you can see how immutable vs mutable objects behave in memory step by step?