🚀 Python Mastery Roadmap

1️⃣ Basics – Syntax, loops, functions, exceptions

2️⃣ DS & Algorithms – Arrays, stacks, recursion, sorting

3️⃣ Modules & Advanced – Lambdas, decorators, regex

4️⃣ OOP – Classes, inheritance, dunder methods

5️⃣ Packages & Comprehensions – pip, conda, list comps

6️⃣ Frameworks & Concurrency – Flask, FastAPI, threading

7️⃣ Pro Skills – Typing, Testing, Docs, Docker, CI/CD

🎯 Stay consistent, build projects, master Python.

9 Hard Truths About Learning Python

10 Python Built-in Functions You Should Know

What's the output of the code snippet?

What's the output of the code snippet?

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 👈

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