Python OOPS Fundamentals: Classes, Objects, Encapsulation & More

🔥 15 Days Python Series – Day 1 🎯 From Today: Focus on Consistency. Build Strong Python Foundation. 🚀 Why Python? Why Now? Tech world is not just “digital” anymore — it’s becoming AI-driven. Today, everything runs on Python: 🤖 AI 📊 Data Science 📈 Data Analytics 🧠 Machine Learning 🌐 Web Development ⚙ Automation The reason? ✅ Simple & Readable ✅ Beginner Friendly ✅ Powerful Libraries ✅ Huge Community ✅ Used by companies like Google, Netflix, Instagram Python is like English of programming – easy to read, easy to write, easy to scale. 📅 Day 1 – How Python Works? Most people use Python. But do you know what happens internally? 🔁 Python Execution Flow: Source Code → Compiler → PVM → Machine Code 🧩 Step-by-Step Explanation: 1️⃣ Source Code The code you write in .py file. 2️⃣ Compiler Time Python converts source code into Bytecode (.pyc file). This process happens before execution. 👉 Source Code + Compiler = Compile Time 3️⃣ PVM (Python Virtual Machine) PVM converts bytecode into machine code and executes it. 👉 PVM + Machine Code = Run Time ❌ What is Compile Time Error? A compile time error happens before execution, when Python checks your code structure. 💻 Example: if 5 > 2 print("Hello") ❌ Missing colon : 👉 Python will stop immediately and show SyntaxError 🧠 Real-Life Example: Imagine you are filling a job application form. If you forget to fill a mandatory field, the system won’t let you submit. That is Compile Time Error – mistake before processing. ⚠ What is Runtime Error? A runtime error happens after program starts executing. The code structure is correct, but problem occurs during execution. 💻 Example: a = 10 b = 0 print(a / b) ❌ ZeroDivisionError Program starts, but crashes while running. 🧠 Real-Life Example: You start driving a bike 🏍️ Everything is correct initially. But suddenly fuel becomes empty in the middle of the road. That is Runtime Error – issue during execution. more information Prem chandar #Python #PythonDeveloper #30DaysOfPython #AI #MachineLearning #DataScience #CodingJourney #TechCareer #LearnToCode #SoftwareDeveloper #LinkedInLearning

99% of Python developers don't know about __slots__. 𝗕𝘂𝘁 𝘁𝗵𝗶𝘀 𝘀𝗶𝗻𝗴𝗹𝗲 𝗹𝗶𝗻𝗲 𝗰𝗮𝗻 𝗰𝘂𝘁 𝘆𝗼𝘂𝗿 𝗺𝗲𝗺𝗼𝗿𝘆 𝘂𝘀𝗮𝗴𝗲 𝗯𝘆 𝟰𝟬-𝟲𝟬%. Here's why this matters in ML/AI applications: 𝗪𝗶𝘁𝗵𝗼𝘂𝘁 __𝘀𝗹𝗼𝘁𝘀__: class DataPoint: def __init__(self, x, y, features): self.x = x self.y = y self.features = features 𝗘𝗮𝗰𝗵 𝗶𝗻𝘀𝘁𝗮𝗻𝗰𝗲 𝘀𝘁𝗼𝗿𝗲𝘀 𝗮𝘁𝘁𝗿𝗶𝗯𝘂𝘁𝗲𝘀 𝗶𝗻 𝗮 𝗱𝗶𝗰𝘁𝗶𝗼𝗻𝗮𝗿𝘆 → ~𝟮𝟴𝟬 𝗯𝘆𝘁𝗲𝘀 𝗽𝗲𝗿 𝗼𝗯𝗷𝗲𝗰𝘁 𝗪𝗶𝘁𝗵 __𝘀𝗹𝗼𝘁𝘀__: class DataPoint: __slots__ = ['x', 'y', 'features'] def __init__(self, x, y, features): self.x = x self.y = y self.features = features 𝗔𝘁𝘁𝗿𝗶𝗯𝘂𝘁𝗲𝘀 𝘀𝘁𝗼𝗿𝗲𝗱 𝗶𝗻 𝗳𝗶𝘅𝗲𝗱 𝘀𝘁𝗿𝘂𝗰𝘁𝘂𝗿𝗲 → ~𝟭𝟮𝟬 𝗯𝘆𝘁𝗲𝘀 𝗽𝗲𝗿 𝗼𝗯𝗷𝗲𝗰𝘁 Real impact on ML workflows: • Training with 1M+ data points? Save ~160MB instantly • Faster attribute access (15-20% speed boost) • Cleaner memory profiling during model training 𝗧𝗵𝗲 𝗰𝗮𝘁𝗰𝗵? → No dynamic attribute addition → Inheritance becomes trickier → Can't use with multiple inheritance easily When building ML pipelines with massive datasets, this optimization can be the difference between smooth training and memory crashes. Have you used __slots__ in your Python projects? What memory optimization tricks do you swear by? 🔧 #Python #MachineLearning #PerformanceOptimization

Variables in python: 💡 What if I told you… In Python, a “variable” doesn’t actually store data? Yes! Let that sink in for a second. When I first started learning Python, I thought: num = 100 means the variable(num) stores 100. But that’s not entirely true. 🔎 Here’s what really happens: 🔹 Variables A variable is just a name that references an object in memory. It points to data — it doesn’t physically store it. When you reassign: - num = 100 - num = 200 You’re not “changing the box.” You’re making the name point to a new object. That small understanding changes how you think about Python. 🔒 What About Constants? Python doesn’t truly enforce constants. Instead, we follow a professional convention: PI = 3.14 MAX_USERS = 1000 Uppercase indicates = “Please don’t change this.” It’s discipline, not enforcement, and discipline makes better developers. Constants is also the value that variable holds. For every constant there will be a specific memory. 🧠 And Then There Are Data Types… Every value in Python has a type: Integers → Whole numbers (25,-34) Float → Decimal numbers (99.99) String → Anything written inside '.....', "......." ,'''.....'''' or """....""" will be called as a string value. - it can be a character, a word or a sentence or even other datatypes Example-("Hello", " 65",'0.86','"false"') Boolean → True / False Data types define how Python behaves with that value. Add two integers? ✅ Add a string and an integer? ❌ Error. Programming isn’t about memorizing code. It’s about understanding how things actually work behind the scenes. Excited for what’s next 🚀 #DataScience #Python #SQL #ProgrammingBasics #LearningInPublic #CareerGrowth

🐍 Python Data Structures Explained: Lists vs Tuples vs Sets vs Dictionaries Understanding Python’s core data structures is fundamental for writing clean, optimized, and scalable code. Choosing the right structure directly impacts: ✔ Performance ✔ Readability ✔ Maintainability ✔ Scalability Let’s break them down 👇 1️⃣ List: Ordered & Mutable Collection A list is an ordered, changeable (mutable) collection that allows duplicate values. my_list = [1, 2, 3, 3, "Python"] Use when: ✔ Order matters ✔ You need to modify elements ✔ Duplicates are allowed 2️⃣ Tuple: Ordered but Immutable A tuple is an ordered, unchangeable (immutable) collection. my_tuple = (1, 2, 3, "Python") Use when: ✔ Data should not change ✔ You need fixed configurations ✔ Memory efficiency matters 3️⃣ Set: Unordered & Unique Elements A set is an unordered collection of unique elements. my_set = {1, 2, 3, 3} Use when: ✔ Removing duplicates ✔ Performing mathematical operations (union, intersection, difference) ✔ Fast membership testing 4️⃣ Dictionary: Key-Value Mapping A dictionary stores data in key-value pairs. my_dict = { "name": "Usman", "role": "Software Engineer" } Use when: ✔ Working with structured data ✔ Handling JSON / API responses ✔ Need fast key-based lookups 🧠 Performance Insight • List -> Flexible but slightly heavier • Tuple -> Faster iteration & memory efficient • Set -> Optimized for uniqueness & membership checks • Dictionary -> Extremely fast key-based lookups using hash tables 🚀 Final Takeaway Choosing the correct data structure isn’t just about syntax, it affects: ✔ Application performance ✔ Memory optimization ✔ Code clarity ✔ System scalability Quick Guide: 👉 Ordered & modifiable -> List 👉 Fixed & read-only -> Tuple 👉 Uniqueness -> Set 👉 Structured mapping -> Dictionary Mastering these fundamentals separates average developers from strong Python engineers. 💡 Boost up your skills with: 🌐 python.org 🌐 w3schools.com 🌐 Tutorialspoint #Python #Programming #SoftwareEngineering #BackendDevelopment #DataStructures

🐍 Python Tip: Stop copying lists the wrong way! Every Python developer hits this bug at some point: a = [1, 2, 3, 4] b = a b.append(5) print(a) # [1, 2, 3, 4, 5] 😱 When you write b = a, you're NOT copying the list. You're just creating another variable pointing to the SAME memory (call by reference). ✅ The 3 ways to properly copy a list: • b = a[:]    → Slice copy • b = a.copy()  → Built-in method • b = list(a)   → Constructor copy ⚡ Which one is fastest? a[:] wins — it's a direct C-level memory slice with zero Python overhead. Speed ranking: a[:] > a.copy() > list(a) ⚠️ BUT — all 3 are SHALLOW copies. If your list contains nested lists or objects, changes will still bleed through: a = [[1, 2], [3, 4]] b = a.copy() b[0].append(99) print(a) # [[1, 2, 99], [3, 4]] 😬 For nested structures, use deepcopy: import copy b = copy.deepcopy(a) Quick rule: 📦 Flat list → a[:] or a.copy() 📦 Nested list → copy.deepcopy(a) Small detail. Big bugs if you get it wrong. ♻️ Repost if this helped someone on your team! #Python #Programming #SoftwareDevelopment #CodingTips #PythonTips

Day 2nd ->I started by understanding what Python is and why it’s so popular. Python’s simple syntax, readability, and massive ecosystem of libraries . * Next, I learned how "Python executes code" The process is straightforward but fascinating: 👉 You write the code → Python compiles it into bytecode → the interpreter executes it → and finally, you see the output. This behind-the-scenes flow helped me understand why Python is called an interpreted language. *I also explored "comments" and "print formatting", which are essential for writing clean code. Comments make programs readable for humans, while the "print() function" becomes more powerful with parameters like sep and end, allowing better control over output formatting. *Then came "data types" the building blocks of any program. I worked with: Integers and Floats for numbers Strings and Characters for text Booleans for true/false logic Understanding data types clarified how Python stores and processes different kinds of information. * learned about "variables" and the concept of "reinitialization" which allows changing a variable’s value anytime—simple, flexible, and very Pythonic. *Finally, I studied "identifier rules" which define how variables should be named. Following these rules ensures clarity, avoids errors, and makes code professional and readable.

After ~6 years of building with Python, I still get surprised by how much depth there is in the “basic” stuff. I recently read an article on Python memory management (from stack frames to closures) and it genuinely taught me a lot. A few things that really clicked for me: • Garbage collection vs references (finally cleared up): I’ve used Python’s GC forever, but this article explains the relationship between reference counting, object references, and cycle detection in a way that removed a bunch of mental fog. It made it easier to reason about why objects stick around, when they get freed, and why “it should be collected” isn’t always true the way we casually assume. • Stack frames, scopes, and what actually stays alive: The framing around stack frames helped connect execution flow to memory behavior—especially how local variables, function calls, and references interact under the hood. • Closures, cell objects, and the “ohhh that’s why” moment: I knew closures existed, but I wasn’t aware of cell objects and the mechanism Python uses to keep variables alive for inner functions. That was new to me—and honestly one of those concepts that makes you write better, safer code once you understand it. What I liked most: this is one of the few articles I’ve read recently that covers a very foundational concept—but still manages to teach a lot without getting hand-wavy. If you write Python professionally (or even casually), it’s worth reading—especially if you’ve ever had questions like: • “Why didn’t this object get freed yet?” • “What exactly does GC do here?” • “How do closures really store state?” https://lnkd.in/dZSi27vn #Python #SoftwareEngineering #BackendEngineering #Programming #ComputerScience #MemoryManagement

🎯𝗗𝗮𝘆 𝟮/𝟯𝟬 – 𝟯𝟬-𝗗𝗮𝘆𝗟𝗲𝗮𝗿𝗻𝗶𝗻𝗴𝗖𝗵𝗮𝗹𝗹𝗲𝗻𝗴𝗲🔥 Day 2 complete.📝 Today was less about syntax… and more about thinking logically. I focused on Control Flow and Functions in Python — basically how programs make decisions and how we avoid repeating code. Here’s what I learned (and revised) today 𝟭. 𝗖𝗼𝗻𝘁𝗿𝗼𝗹 𝗙𝗹𝗼𝘄 – Teaching Code to Think Programming isn’t just writing instructions. It’s teaching the system how to decide. -Conditional Statements (if, elif, else) This is where logic begins. if condition: # execute this elif another_condition: # execute this else: # fallback Python checks conditions from top to bottom. Only the first true condition runs. It reminded me that order matters — 𝗶𝗻 𝗰𝗼𝗱𝗲 𝗮𝗻𝗱 𝗶𝗻 𝗹𝗶𝗳𝗲. Loops help us repeat tasks efficiently. 𝗳𝗼𝗿 𝗹𝗼𝗼𝗽 → when we know how many times to run. for i in range(5): print(i) 𝘄𝗵𝗶𝗹𝗲 𝗹𝗼𝗼𝗽 → when execution depends on a condition. while condition: # keep running 𝗯𝗿𝗲𝗮𝗸 → stops the loop immediately 𝗰𝗼𝗻𝘁𝗶𝗻𝘂𝗲 → skips current iteration 𝗽𝗮𝘀𝘀 → placeholder 𝟮. 𝗙𝘂𝗻𝗰𝘁𝗶𝗼𝗻𝘀 – Write Once, Use Many Times This was my favorite part today. Instead of repeating code again and again, we define functions. def greet(name): return f"Hello {name}" *𝗮𝗿𝗴𝘀 → accepts multiple positional arguments (stored as tuple) **𝗸𝘄𝗮𝗿𝗴𝘀 → accepts multiple keyword arguments (stored as dictionary) 𝗟𝗘𝗚𝗕 𝗥𝘂𝗹𝗲 (𝗩𝗮𝗿𝗶𝗮𝗯𝗹𝗲 𝗦𝗰𝗼𝗽𝗲) Python searches variables in this order: 𝗟𝗼𝗰𝗮𝗹 → 𝗘𝗻𝗰𝗹𝗼𝘀𝗶𝗻𝗴 → 𝗚𝗹𝗼𝗯𝗮𝗹 → 𝗕𝘂𝗶𝗹𝘁-𝗶𝗻 Scope clarity = fewer debugging headaches. 𝗥𝗲𝗰𝘂𝗿𝘀𝗶𝗼𝗻 A function calling itself. Powerful, but must have a base condition, otherwise it runs forever. 𝗚𝗲𝗻𝗲𝗿𝗮𝘁𝗼𝗿𝘀 (𝘆𝗶𝗲𝗹𝗱) Unlike return, which ends a function, yield pauses it and resumes later. Generators don’t store all values in memory — they generate values one by one. 𝗹𝗮𝗺𝗯𝗱𝗮 → small anonymous functions 𝗺𝗮𝗽() → transform data 𝗳𝗶𝗹𝘁𝗲𝗿() → filter data 𝗿𝗲𝗱𝘂𝗰𝗲() → reduce list to single value It showed me there are multiple ways to solve the same problem — and choosing the right one matters. 𝗛𝗶𝗴𝗵𝗲𝗿-𝗢𝗿𝗱𝗲𝗿 𝗙𝘂𝗻𝗰𝘁𝗶𝗼𝗻𝘀, 𝗖𝗹𝗼𝘀𝘂𝗿𝗲𝘀 & 𝗣𝗮𝗿𝘁𝗶𝗮𝗹 Today I learned that in Python: Functions can accept other functions. Functions can return functions. Inner functions can remember outer variables (Closures). We can pre-fill arguments using partial(). This made Python feel powerful and elegant. 📝 𝗥𝗲𝗳𝗹𝗲𝗰𝘁𝗶𝗼𝗻 – 𝗗𝗮𝘆 𝟮 Today wasn’t about writing long programs. It was about: - Understanding flow - Structuring logic -Writing smarter code - Thinking like a programmer I’m realizing something: The more I learn fundamentals deeply, the more confident I feel moving forward. Consistency > Motivation. 28 days to go. #𝟯𝟬𝗗𝗮𝘆𝘀𝗟𝗲𝗮𝗿𝗻𝗶𝗻𝗴𝗖𝗵𝗮𝗹𝗹𝗲𝗻𝗴𝗲 #𝗣𝘆𝘁𝗵𝗼𝗻 #𝗟𝗲𝗮𝗿𝗻𝗶𝗻𝗴𝗜𝗻𝗣𝘂𝗯𝗹𝗶𝗰 #𝗖𝗼𝗻𝘀𝗶𝘀𝘁𝗲𝗻𝗰𝘆 #𝗦𝗮𝗵𝗮𝗻𝗮.𝗕𝘂𝗶𝗹𝗱s #𝗗𝗮𝘆𝟮

Context managers — Python’s most unappreciated feature. If you’ve written Python, you’ve probably used this: with open("file.txt", "r") as f: data = f.read() But do you actually know what "with" is doing? In simple terms, "with" makes sure something is properly cleaned up after you’re done using it. Without "with" , you would write: f = open("file.txt", "r") data = f.read() f.close() Now imagine you forget f.close()… Or your program crashes before it runs. That’s where with shines. When you use "with", Python automatically: • Sets things up • Runs your code • Cleans everything up — even if errors happen It’s not just for files. You can use with for: - Database connections - Locks in multithreading - Opening network connections - Even capturing print output And here’s something many beginners don’t realize: You can create your own custom context managers. Yes — you can teach Python how to automatically handle setup and cleanup for your own logic. That means: Start something → Use it → Safely finish it All enforced by the language itself. For beginners, this is powerful. It makes your code safer. It reduces hidden bugs. And it builds strong engineering habits early. The with statement isn’t complicated. It’s just disciplined coding — made simple. If you're learning Python and treating with like magic syntax, dig deeper. It’s one of the cleanest tools Python gives you. #Python #Programming #SoftwareEngineering #CleanCode

🚀 Revisiting Python Fundamentals Day 6: Flow Control Statements in Python In Python, code normally executes line by line from top to bottom. But real-world programs need more than that. They need to: Make decisions Repeat actions Control execution flow That’s where Flow Control Statements come in. Flow control statements decide which block of code runs and how many times it runs. They are mainly divided into three categories: 🔹 1️⃣ Decision Statements These are used when a program needs to choose between alternatives. Python provides: if elif else Example: age = 18 if age >= 18: print("Eligible to vote") else: print("Not eligible") Here: Python checks the condition age >= 18 If it is True, the first block runs If False, the else block runs Decision statements allow programs to behave differently based on conditions. 🔹 2️⃣ Looping Statements Loops are used when a block of code needs to run multiple times. Python provides: for while For Loop Used when the number of iterations is known. for i in range(3): print(i) This prints values from 0 to 2. While Loop Used when execution depends on a condition. count = 0 while count < 3: print(count) count += 1 The loop runs until the condition becomes False. Loops reduce repetition and make programs efficient. 🔹 3️⃣ Control Statements These are used inside loops to change their normal behavior. break → immediately exits the loop continue → skips the current iteration pass → placeholder that does nothing Example using break: for i in range(5): if i == 3: break print(i) The loop stops when i becomes 3. #Python #FlowControl #PythonBasics #LearnPython #Programming