Python Learning

🚀 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