DEV Community: Abdullah alshebel

Understanding Python's Object Model: Mutable vs Immutable Objects

Abdullah alshebel — Fri, 03 Oct 2025 10:00:33 +0000

Introduction

In this post, I'll walk through key Python concepts I explored while learning more deeply about how objects, identity, and mutability work. We'll examine:

Python's id() and type() functions
What makes objects mutable or immutable
How this impacts program behavior
Why it matters when passing arguments to functions

Throughout, I'll provide simple code examples to make each concept concrete and relatable for new and intermediate Python learners.

Understanding `id()` and `type()`

Every object in Python has a unique identity that you can inspect using the id() function. You can also inspect the object's class with the type() function.

Basic Example

x = [1, 2, 3]
print(id(x))        # Outputs object's unique identifier (memory address)
print(type(x))      # <class 'list'>

Output:

140234567890123
<class 'list'>

Identity vs Equality

Even two variables holding identical contents may have different ids if they're different objects in memory. This helps distinguish identity (is) from equality (==):

a = [1, 2, 3]
b = [1, 2, 3]
print(a == b)   # True, they have equal contents
print(a is b)   # False, they're different objects

Key Takeaway: == checks if values are equal, while is checks if they're the same object in memory.

Mutable Objects

A mutable object can have its internal state changed after it is created. Common examples include:

Lists
Dictionaries
Sets
Most classes with modifiable attributes

Example: Modifying a List

numbers = [1, 2, 3]
numbers.append(4)
print(numbers)  # [1, 2, 3, 4]

Identity Persists After Modification

Changing the contents doesn't change the identity:

before = id(numbers)
numbers.append(5)
after = id(numbers)
print(before == after)  # True
print(numbers)          # [1, 2, 3, 4, 5]

Output:

True
[1, 2, 3, 4, 5]

Immutable Objects

Immutable objects cannot be changed in place after they're created. These include:

Integers
Floats
Strings
Tuples
Frozensets

Any 'modification' creates a new object.

Example: Integers

x = 5
print(id(x))
x += 1              # This rebinds x to a new object
print(id(x))        # The id is different now

Output:

140734567823456
140734567823488  # Different id!

Example: Strings

s = "hello"
print(id(s))
s += " world"
print(id(s))        # New object, new id
print(s)            # hello world

Why Does It Matter? Python's Treatment of Mutable vs Immutable Objects

Understanding mutability influences everything from performance to subtle bugs. Python stores small integers and short strings in a cache, so they may appear to share ids in some cases, but in general, identity and mutability are fundamental to how variables work.

Key Differences

Aspect	Mutable Objects	Immutable Objects
Can be changed in-place?	✅ Yes	❌ No
Identity after modification	Same	Different
Safe to share references?	⚠️ Risky	✅ Safe
Examples	list, dict, set	int, str, tuple

Implications

Mutable objects:

Can be changed via various methods
If two variables reference the same object, changes by one variable affect the other

Immutable objects:

Safe to share
Reassigning a variable to a new value doesn't alter the original object

Example Comparison

# Mutable example
def modify_list(lst):
    lst.append(99)

l = [1, 2, 3]
modify_list(l)
print(l)  # [1, 2, 3, 99], because lists are mutable

# Immutable example
def modify_int(n):
    n += 1

x = 5
modify_int(x)
print(x)  # 5, unchanged

Output:

[1, 2, 3, 99]
5

How Arguments Are Passed to Functions

Python's argument passing is often summarized as "assignment by object reference" or "pass by object reference."

What This Means

For mutable types, functions can change the content of the argument outside the function
For immutable types, any operation that looks like a modification (e.g., x += 1) instead creates a new object and rebinds the local variable

More Examples

Mutable Example (List)

def add_element(mylist):
    mylist.append('new')

lst = [0]
add_element(lst)
print(lst)  # [0, 'new']

Output: [0, 'new'] ✅ The original list was modified!

Immutable Example (Integer)

def add_one(num):
    num += 1
    print(f"Inside function: {num}")

n = 10
add_one(n)
print(f"Outside function: {n}")

Output:

Inside function: 11
Outside function: 10

❌ The original integer was NOT modified!

Why This Matters

This behavior is crucial to avoid unexpected side effects or bugs, especially when working with functions that handle lists or dictionaries.

Best Practices:

🔍 Be aware of which types are mutable
📝 Document if your function modifies arguments
🛡️ Use .copy() if you need to avoid modifying the original

Advanced Tasks: Exploring Object Internals

While digging deeper, I explored several advanced concepts:

Topics Covered

✅ Inspecting memory addresses of objects
✅ Testing Python's integer caching (small integers cached for efficiency)
✅ Careful copying: list.copy() vs slicing vs simple assignment

Copying Lists: Three Approaches

a = [1, 2, 3]

# Approach 1: Simple assignment (both refer to same object)
b = a
b.append(4)
print(f"a: {a}")   # [1, 2, 3, 4] - a was affected!

# Approach 2: Using .copy() (creates separate object)
c = a.copy()
c.append(5)
print(f"a: {a}")   # [1, 2, 3, 4] - unchanged
print(f"c: {c}")   # [1, 2, 3, 4, 5]

# Approach 3: Using slicing (also creates separate object)
d = a[:]
d.append(6)
print(f"a: {a}")   # [1, 2, 3, 4] - still unchanged
print(f"d: {d}")   # [1, 2, 3, 4, 6]

Integer Caching Example

# Small integers are cached
x = 256
y = 256
print(x is y)  # True - same object!

# Large integers are not
a = 1000
b = 1000
print(a is b)  # False - different objects

Key Lessons

Assignment doesn't copy - it creates another reference
Use .copy() or slicing to create independent copies
Python caches small integers (-5 to 256) for efficiency
Understanding object identity helps debug confusing behavior

Conclusion

Understanding Python's object model, especially the difference between mutable and immutable objects, is foundational for writing reliable, bug-free code. It impacts:

🔧 Function arguments and side effects
🎯 Variable assignment behavior
📦 Copying data structures safely
⚡ Performance optimizations

Summary Table

Concept	Key Point
`id()`	Returns unique object identifier
`type()`	Returns object's class/type
Mutable	Can be modified in-place (list, dict, set)
Immutable	Cannot be modified (int, str, tuple)
Function Args	Passed by object reference
Copying	Use `.copy()` or `[:]` for independent copies

Practicing these patterns and observing object identities has fundamentally changed my perspective on how Python "really" works under the hood. I hope this guide helps you build a stronger mental model too! 🐍✨

🐚 What Happens When You Type ls *.c in the Terminal?

Abdullah alshebel — Wed, 14 May 2025 17:58:31 +0000

If you’re new to the command line, you might be scratching your head when someone types something like:

ls *.c

What does that even mean? What is ls? What’s that little star doing? And why does it matter?

Let’s walk through step-by-step what’s happening behind the scenes—like a detective solving a mystery. 🕵️‍♂️🔍

🎬 Scene 1: The Shell Enters the Chat

Before anything runs, your shell (like bash, zsh, etc.) is the real MVP. It’s the program that reads your command and makes sense of it.

When you type:

ls *.c

The shell, not the ls command, is the one who notices the asterisk (*) and goes, “Aha! That’s a wildcard!”

🧠 Step-by-Step Breakdown

🪄 Step 1: Wildcard Expansion (aka Globbing)

The * is a wildcard. It means “match anything.”

*.c means: "Match all files that end in .c"

So, if your directory has:

main.c
test.c
script.py
notes.txt

The shell will expand *.c into:

main.c test.c

✅ Key point: The shell replaces *.c with a list of matching filenames before it runs ls.

🧮 Step 2: Executing the `ls` Command

Now the shell runs:

ls main.c test.c

This tells the ls command to list info about those specific files.

So the terminal might output:

main.c  test.c

💡 If you want detailed info (like file sizes), you could do:

ls -l *.c

Which expands and runs:

ls -l main.c test.c

🚨 What If There Are No `.c` Files?

If there are no files ending in .c, the shell might just pass the literal *.c to ls, depending on your shell settings.

You’ll then see:

ls: cannot access '*.c': No such file or directory

💥 Boom. Shell said, “I couldn’t find anything, so I left it as-is.”

🛠️ Real World Examples

✅ Example 1: List all `.c` files

ls *.c

Output:

main.c  utils.c

✅ Example 2: Combine with other wildcards

ls *test*.c

Matches files like:

unit_test.c  test_cases.c

⚠️ Example 3: Use quotes (prevents wildcard expansion!)

ls "*.c"

This is not the same. With quotes, the * is not expanded. It looks for a file literally named *.c.

🧠 Bonus Tip: Globbing Is Everywhere

Wildcards (*, ?, etc.) work with lots of commands, not just ls:

cp *.txt backup/
rm *.log
cat data_??.csv

They’re part of shell globbing, and it’s powerful once you get used to it! 💪

🧾 TL;DR

When you type ls *.c:

The shell sees the * and expands it to match filenames.
It runs ls with those filenames as arguments.
You see the list of files that match *.c.

And that’s it! 🎉 You're officially smarter than 80% of first-year CS students. Okay, maybe 60%. 😉

What happens when you type gcc main.c

Abdullah alshebel — Thu, 01 May 2025 09:38:23 +0000

GCC (GNU Compiler Collection) is the workhorse that turns your C code into lightning-fast machine code.
In this article, we’ll explore why C uses a compiler, how compiling differs from interpreting, the landscape of other popular compilers, and then walk through each of GCC’s four stages—preprocessing, compiling to assembly, assembling to object code, and linking into an executable. 🚀

Why Do We Compile C at All? 🤔

Performance:
Compiled languages (like C) are translated into machine code ahead of time, so the CPU can execute them directly. This gives you blazing speed—crucial for system software, games, and real-time applications.
Portability:
The same C source can be compiled on Windows, Linux, macOS, or even embedded controllers. The compiler handles the platform differences.
Error Checking & Optimization:
The compiler can detect syntax and type errors before you even run your program. It also performs powerful optimizations (inlining, loop unrolling, dead-code elimination) to squeeze out extra performance.

By contrast, an interpreter (e.g., Python’s python script.py) reads your code line by line at runtime, which is more flexible for scripting but generally much slower.

Compiler vs. Interpreter: The TL;DR 🔄

Aspect	Compiler (C, Rust)	Interpreter (Python, Ruby)
Translation	Ahead-of-time → machine code	On-the-fly → virtual machine or direct execution
Speed	Fast at runtime	Slower (per-line overhead)
Error Timing	Catches many errors pre-run	Errors only show when that line executes
Distribution	Distribute binaries	Distribute source (requires runtime)

Why GCC? And What Else Is Out There? 🌐

GCC (GNU Compiler Collection)
- Mature, battle-tested since the late 1980s
- Supports C, C++, Fortran, Ada, Go, and more - Highly portable (runs on hundreds of architectures)
- Rich optimization flags (-O2, -O3, -Ofast, -march=…)
Clang/LLVM
- Modular, reusable libraries (LLVM IR)
- Very fast compile times and user-friendly diagnostics
- Used as the basis for Apple’s toolchain
MSVC (Microsoft Visual C++)
- Dominant on Windows for building native apps
- Tight IDE integration and Windows SDK support
TinyCC (tcc)
- Super-lightweight, great for quick experimentation
- Not production-grade for heavy optimization ---

The Four Stages of Compilation 🔍

When you type:

gcc main.c

GCC actually performs four distinct steps under the hood:

1. Preprocessing

gcc -E main.c -o main.i

Includes
Expands #include <...> and #include "..." by pasting in header contents.
Macros
Expands #define macros.
Conditionals
Evaluates #if, #ifdef, etc.

🔎 Result: main.i — the pure C code the compiler sees, with no more preprocessor directives.

2. Compilation (C → Assembly)

gcc -S main.i -o main.s

Syntax analysis
Builds an abstract syntax tree (AST), ensures your code follows C grammar.
Semantic checks
Type-checks, ensures you’re not, say, assigning a float* to an int without a cast.
Optimization
Applies inlining, constant folding, loop transformations, etc.
Code generation
Emits human-readable assembly for your target CPU.

🔎 Result: main.s — the assembly instructions, like:

.LC0:
    .string "Hello, world!"
movl    $.LC0, %edi
call    puts

3. Assembling (Assembly → Object Code)

gcc -c main.s -o main.o

Translation
Turns assembly mnemonics into binary opcodes.
Metadata
Creates symbol tables (which functions and variables you define/export) and relocation entries.

🔎 Result: main.o — an object file containing machine code and metadata (but not yet a full program).

4. Linking (Object Code → Executable)

gcc main.o -o myapp

Symbol resolution
Matches your references (e.g., puts) to their definitions in libraries (e.g., libc).
Library inclusion
Pulls in the necessary parts of the standard library or any other .a/.so you specify.
Relocation
Adjusts addresses so that each piece of code and data sits at the correct memory location.
Final image
Emits a standalone executable (myapp).
🔎 Result: ./myapp runs your program!

Putting It All Together with -v 🤓
Want to watch GCC orchestrate all these tools? Try:

gcc -v main.c -o myapp

You’ll see lines like:

Using built-in specs.
COLLECT_GCC=gcc
…cc1 – the actual compiler for C…
/usr/bin/as – the assembler
/usr/bin/ld – the linker

DEV Community: Abdullah alshebel

Understanding Python's Object Model: Mutable vs Immutable Objects

Introduction

Understanding id() and type()

Basic Example

Identity vs Equality

Mutable Objects

Example: Modifying a List

Identity Persists After Modification

Immutable Objects

Example: Integers

Example: Strings

Why Does It Matter? Python's Treatment of Mutable vs Immutable Objects

Key Differences

Implications

Example Comparison

How Arguments Are Passed to Functions

What This Means

More Examples

Mutable Example (List)

Immutable Example (Integer)

Why This Matters

Advanced Tasks: Exploring Object Internals

Topics Covered

Copying Lists: Three Approaches

Integer Caching Example

Key Lessons

Conclusion

Summary Table

🐚 What Happens When You Type ls *.c in the Terminal?

🎬 Scene 1: The Shell Enters the Chat

🧠 Step-by-Step Breakdown

🪄 Step 1: Wildcard Expansion (aka Globbing)

🧮 Step 2: Executing the ls Command

🚨 What If There Are No .c Files?

🛠️ Real World Examples

✅ Example 1: List all .c files

✅ Example 2: Combine with other wildcards

⚠️ Example 3: Use quotes (prevents wildcard expansion!)

🧠 Bonus Tip: Globbing Is Everywhere

🧾 TL;DR

What happens when you type gcc main.c

Why Do We Compile C at All? 🤔

Compiler vs. Interpreter: The TL;DR 🔄

Why GCC? And What Else Is Out There? 🌐

The Four Stages of Compilation 🔍

Understanding `id()` and `type()`

🧮 Step 2: Executing the `ls` Command

🚨 What If There Are No `.c` Files?

✅ Example 1: List all `.c` files