Python Math Rules: Expressions, Operators & Priority

Day 3 of my Python & DSA learning journey 🚀 A simple string completely confused me today 🤯 "A man, a plan, a canal: Panama" — is this a palindrome? At first glance I thought — no way, there are too many symbols! But Python solved it in just a few lines. Here's what I learned today 👇 ❓ Valid Palindrome (Ignore Symbols) A palindrome is a word that reads the same forward and backward. Examples: madam racecar But what if the string contains spaces, commas, or symbols? Example: "A man, a plan, a canal: Panama" It is still a palindrome — we just need to ignore the non-alphanumeric characters. 📌 Python provides a very useful function for this: isalnum() → it checks whether a character is a letter or a number. 💻 Example in Python s = "A man, a plan, a canal: Panama" result = "" for ch in s: if ch.isalnum(): result += ch.lower() if result == result[::-1]: print("Palindrome") else: print("Not Palindrome") Output: Palindrome ✅ Here we: • Removed symbols using isalnum() • Converted characters to lowercase using .lower() • Compared the string with its reverse Just a few lines of code — problem solved! 🔥 🔥 Question for developers: Is "race a car" a valid palindrome according to this logic? Drop your answer in the comments and explain why 👇 👀 Day 4 Teaser Tomorrow I’ll share a very interesting string trick used in coding interviews: How to check if two strings are rotations of each other in just one line of Python. Stay tuned 🚀 #Python #DSA #Coding #Programming #LearningInPublic #100DaysOfCode #PythonProgramming

Mastering Python Algorithms: Turning Logic into Power In the world of programming, syntax gets you started… but algorithms make you unstoppable. Over the past few weeks, I’ve been diving deep into Python algorithms — not just solving problems, but understanding the why behind every solution. And here’s what I’ve realized 👇 💡 Algorithms are not just code — they are thinking patterns. From simple sorting techniques to complex problem-solving strategies, each algorithm teaches you how to: Break problems into smaller pieces 🧩 Optimize performance ⚡ Think logically under pressure 🧠 ✨ What I explored: ✔️ Sorting algorithms (Quick Sort, Merge Sort) ✔️ Searching techniques (Binary Search) ✔️ Recursion & Backtracking ✔️ Time & Space Complexity (Big-O) 🔥 The biggest lesson? It’s not about memorizing solutions — it’s about building the ability to think like a problem solver. Every bug, every failed attempt, every “why is this not working?” moment is actually shaping your mindset into something powerful. 📈 Consistency > Perfection Even 1 problem a day can transform your thinking over time. If you're learning Python, don’t just code — train your brain. #Python #Algorithms #CodingJourney #ProblemSolving #100DaysOfCode #SoftwareEngineering #Learning #Tech

I’ve just published my first blog post on Medium, diving into a Python concept I recently explored: 👉 Mutable vs Immutable Objects Before this, I used to think variables simply “store values.” But in Python, they actually reference objects in memory. Having learned C previously really helped me grasp this concept more quickly, especially when it comes to understanding how memory and references work. In this post, I break down: • The difference between == and is • Mutable vs immutable objects (with clear examples) • Why l1 = l1 + [4] and l1 += [4] behave differently • How Python passes arguments to functions Writing about what I learn pushes me to go deeper and truly understand the concepts. If you’re learning Python or preparing for technical interviews, this is definitely a topic worth mastering. 📖 Read here: https://lnkd.in/guVnYN3Q #Python #SoftwareEngineering #Programming #LearningJourney #Tech

🧠 Python Concept: sorted() with key Sort smarter, not harder 😎 ❌ Traditional Way students = [ {"name": "Alice", "marks": 85}, {"name": "Bob", "marks": 92}, {"name": "Charlie", "marks": 78} ] # Sorting manually (messy & long) students.sort(key=lambda x: x["marks"]) print(students) ✅ Pythonic Way students = [ {"name": "Alice", "marks": 85}, {"name": "Bob", "marks": 92}, {"name": "Charlie", "marks": 78} ] sorted_students = sorted(students, key=lambda x: x["marks"]) print(sorted_students) 🧒 Simple Explanation Think of key like a rule for sorting 📏 ➡️ “Sort based on THIS value” ➡️ Python handles the rest 💡 Why This Matters ✔ Clean & readable ✔ No custom loops needed ✔ Works with complex data ✔ Very common in real-world apps ⚡ Bonus Tip (Reverse Order) sorted_students = sorted(students, key=lambda x: x["marks"], reverse=True) 🐍 Don’t just sort — sort smart 🐍 Let Python do the heavy lifting #Python #PythonTips #CleanCode #LearnPython #Sort #SortingWithKeys #Programming #DeveloperLife #100DaysOfCode

🐍 Day 2 of Learning Python Continuing my Python learning journey and today’s focus was on understanding how Python actually executes code behind the scenes, along with practicing some fundamental concepts. 🔎 What I explored today: ⚙️ How Python Executes Code I learned that Python does not directly run the code we write. Instead, the Python interpreter first converts the source code into Bytecode, which is then executed by the Python Virtual Machine (PVM). Understanding this process helped me see how Python translates human-readable instructions into something a computer can execute. 🧠 Variables in Python After that, I practiced working with variables, which are used to store data in memory. Python makes this simple since we don’t need to explicitly declare the data type — the interpreter handles it dynamically. 💻 Taking User Input To practice further, I wrote a small program where the user enters their name and age, and the program prints a formatted message. Example concept used: input() for user input. int() to convert age into an integer. f-strings for clean and readable output formatting. This small exercise helped me understand data types, variable assignment, and interaction with users through the terminal. Every day I’m trying to strengthen the fundamentals because strong basics make advanced topics like automation, AI, and machine learning easier to approach later. Looking forward to exploring more Python concepts tomorrow. 🚀 #Python #PythonProgramming #LearningPython #CodingJourney #100DaysOfCode #SoftwareDevelopment #ProgrammingBasics #TechLearning #Developers #FutureEngineer #LearnInPublic #PythonBeginner #SDE

Python isn't the same language it was a decade ago. With Python 3.15 coming later this year, here is a retrospective of Python's major changes. Link to my article: https://lnkd.in/eENfyxAm Here is a glimpse of what you might have missed in the various releases: * The death of the GIL: How "Free-Threaded Python" is finally bringing true parallelism. * Structural Pattern Matching: The switch from C is now part of Python syntax. * The Walrus Operator: A controversial syntactic sugar that shook Python's Leadership * T-strings: a safer alternative to f-string for SQL, HTML, and more. And more coming with 3.15: * The Tachyon JIT: A better, faster profiler * Lazy imports: no more conditional imports, you only import when you need it, Whether you've been using Python since the 2.x days or you've joined more recently, this article will show you how Python 3 has evolved over the years. Which feature do you like the most? Which feature surprised you? Are you looking for the 3.15 update? Comment down below! Follow me for more AI and Software Engineering news!

Diving Deep into Python Magic Methods . Recently, I started exploring the internals of Python’s magic methods — those special methods that begin and end with double underscores (__). These aren’t typically called directly; instead, Python invokes them behind the scenes to enable powerful behaviors. These methods can be broadly categorized into: * Callable Objects → __call__() * Iterator Pattern → __init__(), __iter__(), __next__() * Finite Iterators * Context Managers ¥ Understanding the for Loop Internals A for loop in Python is actually built on the Iterator Protocol. Under the hood, it relies on three key magic methods: __init__() → initializes the object __iter__() → returns the iterator object (usually self) __next__() → returns the next value in the sequence ⚙️ How the for Loop Works Internally 1)iter(obj) is called automatically This invokes __iter__() and returns an iterator 2) next(obj) is called repeatedly This invokes __next__() and fetches values 3)Loop continues until StopIteration is raised Without it, the loop runs infinitely 🧠 Example: Custom Iterator class Repeat: def __init__(self, msg): self.msg = msg def __iter__(self): return self def __next__(self): return self.msg This will print the same message infinitely because StopIteration is never raised. Key Insight A for loop is essentially syntactic sugar over a while loop using the iterator protocol. Understanding this gives you deeper control over debugging and helps you identify the root cause of issues in iteration-heavy code. ✨ Once you understand what's happening behind the scenes, Python feels a lot less “magical” and a lot more predictable. For better understanding and clarity I suggest referring the image attached. Till then Happy Sunday, Happy learning and Happy growing. #Python #Programming #SoftwareDevelopment #Coding #PythonInternals #OOP #Developers #Learning #Tech #CSStudents #Debugging

🚀 Mastering Recursion with Gray Code Generation I recently worked on an interesting problem—generating Gray Codes using recursion in Python. This problem is a great example of how powerful and elegant recursive thinking can be. 🔹 What is Gray Code? Gray Code is a binary sequence where two consecutive values differ in only one bit. It has applications in digital systems, error correction, and algorithms. 🔹 Approach Used: Instead of generating all binary numbers and converting them, I used a recursive pattern: Base case: For n = 1 → ["0", "1"] Recursively get Gray codes for n-1 Prefix "0" to the original list Prefix "1" to the reversed list Combine both 🔹 Python Implementation: class Solution: def graycode(self,n): if n ==1: return ["0","1"] prev_gray = self.graycode(n - 1) result = [] for code in prev_gray: result.append("0" + code) for code in reversed(prev_gray): result.append("1" + code) return result 💡 Key Learning: Sometimes the best solutions don’t require complex logic—just recognizing patterns and applying recursion smartly. 📈 This problem strengthened my understanding of: Recursion Pattern building Problem decomposition Would love to hear how others approached this problem or optimized it further! 😊 #Python #Recursion #Algorithms #CodingJourney #DataStructures #ProblemSolving

Slow python ? Meet pybind11 ! It started with a simple curiosity while exploring autograd in Deep Learning frameworks. To better understand how gradients work behind the scenes, we implemented #micrograd by Andrej Karpathy a tiny educational autograd engine written in Python. After building it, a natural question emerged: If Python is slow, how are performance-heavy libraries still so fast? Digging deeper, we discovered that many high-performance Python libraries rely on C++ under the hood, with Python acting as a clean interface. This led us to explore pybind11, a lightweight way to bridge Python and C++ ! We then, - Implemented micrograd in C++ - Exposed it to Python using pybind11 - Generated .so modules using setup.py - Recreated a simplified Python plus C++ architecture This small experiment helped us understand how Python can leverage C++ for performance while maintaining developer productivity.. Also, pybind11 is one of the several alternatives like SWIG, Boost.Python, and Cython that can also be used for language bindings. This exploration was done in collaboration with Kavin Kumar, where we jointly worked on both the medium article and the C++ micrograd implementation. To check our implementation, Github: https://lnkd.in/gz6GBuNV For a deep dive, Explore our article: https://lnkd.in/g2y8KRta PS: Not AI Generated :) #Python #CPP #CPlusPlus #Pybind11 #MachineLearning #DeepLearning #Autograd #Micrograd #PythonPerformance

"Python's performance sucks" - Yes, but... that's not the end of the story. Can python be fast? Yes: Performance engineering in Python is not a niche concern, so it's important to be aware of the "optimization ladder" available to us, and which we can activate to gain real performance optimizations. These are some great options that you can use to drive performance gains: 1) Upgrade CPython to gain non-trivial performance gains. 2) Compile your typed python with mypyc can deliver strong wins if your code is already typed. 3) Leverage NumPy/JAX to drive massive performance gains with vectorizable array math. 4) You can use Numba to accelerate particularly for numeric loops over arrays. 5) If none of these work, then you can go low level and rebuild core components with Cython/Rust/etc. The most practically useful insight is that realistic pipelines often bottleneck on Python object creation and parsing, not just raw compute, so the biggest gains can come from changing data representations or moving parsing and hot paths out of Python objects entirely. This is a great article on practical Python performance optimizations; it's often best to go back to the foundations to drive the most value. Blog: https://lnkd.in/dp9Wm7FS --- If you liked this post you can join 70,000+ practitioners for weekly tutorials, resources, OSS frameworks, and MLOps events across the machine learning ecosystem: https://lnkd.in/eRBQzVcA #ML #MachineLearning #ArtificialIntelligence #AI #MLOps #AIOps #DataOps #augmentedintelligence #deeplearning #privacy #kubernetes #datascience #python #bigdata