Pranay Mahendrakar’s Post

Navigating the Infinite Structures of Logical Loops in Python! 💻🌀 The journey of mastering Data Science isn't always a linear path; sometimes, it requires dynamic, repeating, and branching structures. Day 5 was a significant milestone: understanding and applying Python Loops (For and While). These fundamental concepts are the exact groundwork I need to process massive datasets and iterate efficiently: 🔄 FOR Loop: Iterating through structures. A clean, defined pathway that processes an entire set of data—like a cascading aqueduct of items. I visualized this structure iterating through geometric data blocks (10, 20, 30, 40). ⚖️ WHILE Loop: Condition-based mastery. Creating dynamic cycles that continue only as long as a condition holds true (WHILE count < 3). This isn't just repetition; it’s decision-making within the loop. I applied these structures to process large list data and simulate dynamic logical cycles. Moving from simple linear code to optimized, looping logic is how I’m preparing for scalable Machine Learning pipelines down the road. Consistency beats talent when talent doesn't iterate! I've organized these new logical structures and pushed the optimized code to my GitHub. Check out my logic mastery here: **** 🔗 How did you find mastering logical structures like loops? Did you find visualizing the condition-based cycles the hardest part? Let me know in the comments! 👇 #DataScience #Python #100DaysOfCode #MasaiSchool #IITMandi #TechJourney #CareerGrowth #LogicMastery #IterationPath #PythonLoops #MLOps #Consistency

🧠 Python Concept: sorted() vs sort() ✨ Both sort data, but they behave differently. ✨ sorted() → Returns a new sorted list numbers = [5, 2, 8, 1] result = sorted(numbers) print(numbers) # Original list print(result) # Sorted list Output [5, 2, 8, 1] [1, 2, 5, 8] The original list stays unchanged. ✨ list.sort() → Sorts in place numbers = [5, 2, 8, 1] numbers.sort() print(numbers) Output [1, 2, 5, 8] The original list is modified. 🧒 Simple Explanation 📚 Imagine arranging books 📚 sorted() → makes a new sorted pile 📚 sort() → rearranges the same pile 💡 Why This Matters ✔ Understand side effects ✔ Avoid unexpected bugs ✔ Cleaner data processing ✔ Common interview question 🐍 In Python, sorted() and sort() look similar but behave differently 🐍 One creates a new list, the other modifies the existing one. #Python #PythonTips #PythonTricks #AdvancedPython #CleanCode #LearnPython #Programming #DeveloperLife #DailyCoding #100DaysOfCode

Today’s Python breakthrough: Rethinking the Fibonacci sequence. I started with a Recursive (Top-Down) approach—it looks clean but recalculates the same values repeatedly. It's fine for small numbers, but a nightmare for scaling. I moved to Tabulation (Bottom-Up). By using a list to store results as I go: ✅ Time complexity dropped from O(2 n) to O(n). ✅ No more redundant calculations. ✅ The code actually scales. As an economist moving into Data Science, these efficiency wins are what I love most. It’s not just about getting the right answer; it’s about the most effective way to get there. Check out the clean code here: https://lnkd.in/dgw_sRVM #Python #DataScience #BuildInPublic #DynamicProgramming #WomenInTech

A small helper tool. This is very much an early early “release” if it can even be called that, but I know that if I go off to make it an actual fortified repo, I’ll get busy and forget about it. The biggest problem it aims to tackle: processing large video datasets into a manageable, streamlined format whilst remaining and being built primarily in python. #opensource #opensauce #dohashtagsdoanythingonlinkedin #computervision

Recently I’ve been diving deeper into NumPy, one of the most fundamental libraries for numerical computing in Python. Instead of just using it in code, I wanted to understand how it actually works and why it’s so powerful. Here are some key things I learned: • NumPy Arrays (ndarray) NumPy uses homogeneous arrays, meaning all elements share the same data type. This allows efficient memory usage and fast numerical computation. • Why NumPy is fast NumPy is largely implemented in C, which allows Python to perform vectorized operations much faster than traditional Python loops. • Array creation methods I practiced creating arrays using functions like: np.array(), np.arange(), np.ones(), np.zeros(), np.identity(), and np.random.random(). • Understanding array attributes Learning attributes like ndim, shape, size, itemsize, and dtype helped me better understand how data is stored internally. • Array operations and statistics NumPy makes it easy to perform vectorized operations and statistical computations like: mean, median, variance, standard deviation, and dot products. • Data manipulation I explored powerful tools like: Indexing and slicing Iterating arrays with np.nditer() Reshaping with reshape() Flattening arrays with ravel() Transposing arrays with .T • Combining and splitting arrays Using functions like np.hstack(), np.vstack(), np.hsplit(), and np.vsplit(). What I’m realizing is that NumPy is the foundation for most of the Python data ecosystem — including libraries like Pandas, SciPy, and many machine learning frameworks. Every concept I learn here is another step toward becoming better in data science and machine learning. Small progress every day compounds. #Python #NumPy #LearningInPublic #DataScienceJourney #MachineLearning 😊 🗒️

Day 24: Iterators — The Engine Behind the Loop ⚙️ In Python, we often talk about "looping over data." But how does Python actually keep track of where it is in a list of 1 million items? It uses the Iterator Protocol. 1. Iterable vs. Iterator (The "Book" vs. The "Bookmark") Iterable: Any object you can loop over (List, String, Dictionary). Think of it as a Book. It contains all the data, but it doesn't "know" which page you are on. Iterator: A special object that represents a stream of data. Think of it as a Bookmark. It knows exactly where you are and what comes next. 2. The Tools: iter() and next() You can turn any Iterable into an Iterator using these two built-in functions: iter(my_list): Creates the "Bookmark" for that list. next(my_iterator): Moves the bookmark to the next "page" and returns the value. numbers = [10, 20] my_iter = iter(numbers) print(next(my_iter)) # Output: 10 print(next(my_iter)) # Output: 20 # print(next(my_iter)) # Error: StopIteration (The book is finished!) 3. Does it store data in memory? 🧠 This is the "Senior Engineer" secret. Lists/Tuples store all their data in memory at once. If you have 1 billion numbers, your RAM will crash. Iterators (and specifically Generators) are "Lazy." They don't store the whole list; they only calculate or fetch the next item when you ask for it. 💡 The Engineering Lens: This is why we use Iterators for massive datasets (like reading a 10GB log file). We process one line at a time, keeping our memory usage near zero! 4. The StopIteration Exception When an iterator runs out of items, it doesn't return None or 0. It raises a StopIteration error. 💡 The Engineering Lens: A for loop is actually just a "Fancy While Loop" that calls next() repeatedly and automatically handles the StopIteration error so your program doesn't crash. #Python #SoftwareEngineering #ComputerScience #MemoryManagement #Iterators #LearnToCode #CodingTips #TechCommunity #BackendDevelopment

Python in Data Science #009 I feel like I’ve lost count of how many times I saw “feature importance” in a slide deck, nodded along. Sometimes I realize it is telling a comforting story, not the true one. The model workes, but the explanation is quiet misleading. I always default to permutation importance for explanations and treat impurity-based importance as a rough heuristic. Tree models (RF/GB/XGB) often expose impurity-based importance (the built-in “gain”/“gini” style). It’s fast, but it’s biased toward continuous/high-cardinality features, and it can inflate variables that simply offer more split opportunities. Permutation importance asks a more practical question: “If I shuffle this feature, how much does my metric drop?” That trade-off matters: permutation is slower and can get messy with highly correlated features (importance gets shared or diluted), but it’s much closer to “what the model actually uses” on the data distribution you care about. Also important: compute it on a validation set, not the training set, or you’ll explain overfitting.#datascience #machinelearning #python

I stopped using Python loops for array operations. Here’s why. I’ll be honest—I used to be a "loop person." When I first started working with large datasets, writing a Python loop just felt natural. It was easy to read and easy to write. But as my data grew, my performance tanked. I finally got tired of waiting for my code to finish and decided to time it. One single switch from a standard loop to a NumPy vectorized operation changed everything. The result? My processing time dropped from 12 seconds to 0.3 seconds. That is a 40x speedup by changing just one line of code. Here is the breakdown of what happened: import time, numpy as np data = list(range(1_000_000)) The slow way (Python Loop) start = time.time() result = [x**2 for x in data] print(f"Loop: {time.time()-start:.2f}s") # ~0.40s The fast way (NumPy Vectorization) arr = np.array(data) start = time.time() result = arr**2 print(f"NumPy: {time.time()-start:.4f}s") # ~0.003s So why is NumPy so much faster?  It boils down to three things: 1. It runs on compiled C code (bypassing the slow Python interpreter). 2. It uses contiguous memory (the CPU can grab data way faster). 3. It skips the "interpreter tax" on every single element in your array. I tell my students this all the time now: If you are looping over numbers, you are probably leaving performance on the table. In ML tasks like feature scaling or distance calculations, this isn't just a "nice-to-have"—it's a requirement. New habit: Before you write 'for x in...', ask yourself if NumPy can do it in one line. Your future self (and your CPU) will thank you. What’s the biggest performance win you've found recently? I'd love to hear about it in the comments! #Python #NumPy #DataScience #MachineLearning #PerformanceOptimization

🚀 Built a Data Cleaning Tool with Python GUI 💻✨ Recently, I worked on developing a Data Cleaning Application using Python, Pandas, and Tkinter — turning raw, unstructured data into meaningful insights. From handling missing values to visualizing data before and after cleaning, this project helped me explore how real-world data preprocessing actually works. 🔹 Key Highlights: ✔ Upload and process CSV datasets ✔ Remove duplicates & handle missing values ✔ Visualize data (before & after cleaning) ✔ Download cleaned dataset with ease What made this project special? 👉 It’s not just about cleaning data — it’s about understanding how raw data transforms into actionable insights. 🔗 Project available on GitHub: https://lnkd.in/g7Kj_duN Excited to keep building, learning, and improving 🚀 #Python #DataScience #MachineLearning #Projects #Coding #StudentDeveloper #GitHub #LearningByDoing

From Pandas to NumPy: The Real Power Behind Data Analysis After working with Pandas, I realized something important… Most of the heavy lifting actually comes from NumPy. NumPy is not just another library — it’s the foundation of data analysis in Python. 💡 Here’s what makes NumPy a game-changer: ✔️ N-dimensional arrays (ndarray) Faster and more efficient than Python lists ✔️ Vectorization Write less code, get faster results (no loops needed ) ✔️ Broadcasting Perform operations on different-sized arrays effortlessly ✔️ Mathematical operations Linear algebra, statistics, and more — built-in ✔️ Speed & Performance Optimized in C → significantly faster than pure Python ✔️ Memory Efficiency Uses less memory compared to lists My biggest learning: “If you understand NumPy well, half of data analysis becomes easier.” Now applying NumPy in real-world projects and strengthening my data analysis skills What’s your favorite NumPy feature? 👇 #Python #NumPy #DataScience #MachineLearning #Coding #LearningJourney #100DaysOfCode