Pass by Object Reference in Python

Is Python pass-by-value or pass-by-reference? 

➡️ Actually, Python uses Pass by Object Reference.

That means:
The function receives a reference to the same object.

📌 Example: Mutable Object

def modify(lst):
    lst.append(4)

nums = [1, 2, 3]
modify(nums)

print(nums)

Output:
[1, 2, 3, 4]

👉 The original list changed 
Because the function received a reference 
to the SAME object in memory.


📌 Example: Immutable Object

def modify(x):
    x = x + 1
    print("Inside:", x)

num = 10
modify(num)

print("Outside:", num)

Output:
Inside: 11
Outside: 10

👉 Integer did not change 
Because integers are immutable 
Reassignment creates a new object.


🎯 Core Idea

• Functions receive object references 
• Mutable objects can be modified 
• Immutable objects create new objects 
• Python is NOT pure pass-by-value 
• Python is NOT pure pass-by-reference 

✅ It is Pass by Object Reference.

🧠 Garbage Collection & Reference Counting in Python

Python automatically manages memory. 
Objects are deleted when they are no longer used.

📌 Reference Counting

Every object tracks how many variables point to it. 
When the count becomes 0, it is removed.

a = [1, 2, 3]
b = a

del a
del b

Reference count:
a → 1
a, b → 2
after del → 0
Object deleted

📌 Circular Reference Problem

Two objects pointing to each other 
will never reach reference count 0.

class Node:
    def __init__(self):
        self.ref = None

a = Node()
b = Node()

a.ref = b
b.ref = a

del a
del b

Both objects still reference each other
Reference count ≠ 0

📌 Garbage Collector (GC)

Python’s GC:
• Detects unreachable cycles 
• Breaks circular references 
• Frees memory safely 

🎯 Core Idea

Reference Counting → Main mechanism 
GC → Handles circular references

What's the output of the code snippet?

🔥 is vs == in Python

Many developers confuse these two operators. 
But they check completely different things.

📌 == (Equality Operator)

== checks whether values are equal.

a = [1, 2, 3]
b = [1, 2, 3]

print(a == b)

```text
Output:
True

👉 Values are the same  
👉 Even though they are different objects


📌 is (Identity Operator)

is checks whether two variables point to the same object in memory.

python
a = [1, 2, 3]
b = [1, 2, 3]

print(a is b)

text
Output:
False

👉 They are stored at different memory locations  
👉 So identity is different


📌 When is returns True

python
x = [1, 2, 3]
y = x

print(x is y)

text
Output:
True`


👉 Both reference the SAME object

🎯 Quick Difference

• == → Compares values 
• is → Compares memory identity 
• Use == for value comparison 
• Use is mainly for None checks

🚀 Shallow Copy vs Deep Copy in Python

When copying objects in Python, behavior changes for nested data structures.


📌 Shallow Copy

A shallow copy creates a new outer object 
but inner objects remain shared references 🔗 

import copy

original = [[1, 2], [3, 4]]
shallow = copy.copy(original)

shallow[0].append(99)

print(original)
print(shallow)

Output:
[[1, 2, 99], [3, 4]]
[[1, 2, 99], [3, 4]]

👉 Nested objects are shared.


📌 Deep Copy

A deep copy creates a completely independent copy 
including all nested objects 🧠 

import copy

original = [[1, 2], [3, 4]]
deep = copy.deepcopy(original)

deep[0].append(99)

print(original)
print(deep)

Output:
[[1, 2], [3, 4]]
[[1, 2, 99], [3, 4]]

👉 No shared references.


🎯 Quick Difference

• Shallow → Copies outer layer only 
• Deep → Copies entire structure 
• Use deep copy for nested data

🧠 LEGB Rule in Python (Scope Resolution)

When Python looks for a variable, 
it follows a fixed order called LEGB.

L → Local 
E → Enclosing 
G → Global 
B → Built-in 

Python searches in this order.


1️⃣ Local Scope (L) 📍 
Variables defined inside a function.

x = 10

def func():
    x = 5
    print(x)

func()

Output:
5
➤ Python finds x inside the function first.


2️⃣ Enclosing Scope (E) 🔄 
Variables in outer function (nested functions).

def outer():
    x = 20
    def inner():
        print(x)
    inner()

outer()

Output:
20
➤ Python finds x in the enclosing function.


3️⃣ Global Scope (G) 🌍 
Variables defined outside all functions.

x = 30

def func():
    print(x)

func()

Output:
30
➤ Python uses global x.


4️⃣ Built-in Scope (B) ⚙️ 
Predefined names like len, print, etc.

print(len([1, 2, 3]))

Output:
3

💡 Search Order

Local → Enclosing → Global → Built-in 

Python stops searching once it finds the name.

🚀 List vs Tuple in Python

Both store collections of data. 
But they differ in mutability and internal behavior.

1️⃣ List (Mutable) 📦

Can be modified after creation.

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

Output:
[1, 2, 3, 4]
➤ How: Stored as a dynamic array 
➤ Wins: Flexible, easy to modify 
➤ Risk: Slightly higher memory usage 

2️⃣ Tuple (Immutable) 🔒

Cannot be modified after creation.

nums = (1, 2, 3)
nums.append(4)

Output:
AttributeError: 'tuple' object has no attribute 'append'
➤ How: Fixed-size structure 
➤ Wins: Faster iteration, lower memory usage 
➤ Risk: No modification allowed 

💡 Key Difference

• List → Mutable & flexible 
• Tuple → Immutable & lightweight 

Use List when data changes. 
Use Tuple when data should stay constant.

NumPy Cheatsheet (Basic to Advanced)

🐍 Let’s Fix How You’re Learning Python

If you feel slow in Python, it usually is not because Python is hard. It is because of the learning approach.

Let me be direct.

⚠️ Avoid these habits

- Jumping between many tutorials
- Copying code without thinking
- Ignoring error messages
- Watching more than building

👉 Instead, build this discipline

- Follow one main learning path
- After every concept, write your own small code
- When an error appears, read it slowly
- Build small projects every week

📌 Python becomes easier the moment you start treating it like a tool, not a subject.

Keywords in Python

🧠 Learn to Trace Code by Hand

Before running code, pause and predict the output. This builds real understanding.

Consider this:

x = 0

for i in range(3):
    x += i

print(x) 

Walk through slowly.

1. Start: x = 0

2. i = 0 → x = 0

3. i = 1 → x = 1

4. i = 2 → x = 3

Final output:

3

This habit strengthens your debugging ability more than passive reading ever will.

Try this daily with small snippets.

Python Basics Cheat Sheet (Beginner Friendly)