Python Learning

🚀 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.

🧠 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.

🚀 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

🔥 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

What's the output of the code snippet?

🧠 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

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.

Introduction to Computer Science and Programming Using Python (MIT OCW)

This course teaches computational thinking and Python programming from the ground up. It is rigorous, university level, and excellent for developers who want strong fundamentals rather than just syntax. Completely FREE and highly respected course.

📚 12 lectures with assignments
⏰ Duration: 9–12 weeks
🏃‍♂️ Self Paced
Created by 👨‍🏫: MIT Professors
🔗 Course Link

#Python #ComputerScience #MIT
➖➖➖➖➖➖➖➖➖➖➖➖➖➖
👉 Join @bigdataspecialist for more 👈

What's the output of the code snippet?

What's the output of the code snippet?

10 Python Built-in Functions You Should Know

9 Hard Truths About Learning Python