"Understanding Python's Global Interpreter Lock (GIL)"

✨ The Python Story – Episode 7: Why People Call Python “Slow” ✨ Python is loved for its simplicity — but often teased for one thing: “Python is slow.” You’ve probably heard it, maybe even said it. But have you ever wondered why people say that? Let’s go back to the beginning. ⏳ When Guido van Rossum designed Python in 1989, he had a clear vision — a language that made coding easy to write, easy to read, and fun to use. He wasn’t chasing speed — he was chasing simplicity. “The time of a developer is more important than the time of a machine.” – Guido van Rossum Back then, computers were getting faster every year. Guido believed the future would belong to languages that valued human efficiency over machine efficiency. So Python made a few conscious trade-offs — the very reasons people call it “slow” today. 💡 1️⃣ Python is interpreted, not compiled Python doesn’t go straight to machine code like C or C++. It first compiles to bytecode (.pyc) and then executes line by line in a virtual machine. That flexibility and portability cost time — like having a translator between you and the computer. 💡 2️⃣ Python is dynamically typed No need to declare types — Python figures it out as it runs. It’s great for productivity but adds runtime overhead. Dynamic typing = freedom for you, extra work for the machine. 💡 3️⃣ The Global Interpreter Lock (GIL) To keep memory safe, only one thread can run Python bytecode at a time — even on multi-core CPUs. (We’ll explore this fully in Episode 8!) 💡 4️⃣ Readability over raw optimization Lists, dictionaries, and exceptions make Python beautiful and expressive — but all that elegance adds processing under the hood. 🚀 And here’s the truth: Python’s “slowness” rarely matters. For most real-world work — web apps, AI, scripting, automation — the bottleneck isn’t Python’s speed; it’s the network, database, or human time. And when performance does matter, Python calls faster languages like C, C++, or Rust using libraries such as NumPy or TensorFlow. That’s Python’s magic: It may not be the fastest to run, but it’s the fastest to build with. ⚡ 📌 Next Sunday – Episode 8: The Global Interpreter Lock (GIL) We’ll uncover what the GIL really is, why Guido introduced it, and how it affects Python on multi-core systems. ⚡ Fun Fact: Python compiles your code into portable bytecode — saved in the __pycache__ folder every time you run a program! #python #ThePythonStory #StoryOfPython #programming #developers #PythonInternals

✨ The Python Story – Episode 9: Memory & Garbage Collection in Python ✨ The Episode 8 revealed the mystery of the GIL, today we go deeper — into the place where every program lives: memory. Behind Python’s friendly syntax lies a system quietly cleaning up after your code… even when you forget to. This is how Python manages memory — how it knows when something is no longer needed, how it frees space, and how it keeps your programs running smoothly. 💡 Python’s Secret Cleaner: Reference Counting From its earliest days, Python used a simple idea: every object keeps a count of how many variables reference it. If that count drops to zero, Python frees the memory immediately. This makes memory management intuitive — you don’t manually free anything like in C. Python simply handles it. But reference counting has a flaw. 🔁 The Problem of Cycles If two objects reference each other, their counts never reach zero. They become “immortal junk” — unreachable, but never freed. Python needed a solution. 🧠 Enter: The Garbage Collector To handle cycles, Python added a generational garbage collector — a system that occasionally scans for groups of objects that reference each other but are no longer useful. It organizes objects into: • Young objects • Middle-aged objects • Old objects Most objects “die young,” so Python checks those generations more often. Older objects are scanned less frequently. This keeps GC efficient without heavy overhead. 🧩 Why Python Memory Feels “Safe” Python protects developers from: • Dangling pointers • Double frees • Memory corruption • Manual allocator mistakes Programs rarely crash due to memory bugs. This safety is part of why Python is both beginner-friendly and powerful for experts. 🔄 But There’s a Cost This convenience comes with trade-offs: • Reference counting adds overhead • Garbage collection introduces occasional pauses • Cycles require extra scanning • Python objects use more memory than raw machine types And yet — Python frees developers to focus on ideas, not memory addresses. Exactly what Guido wanted. 🧹 The Future of Memory in Python With the push toward a no-GIL future in Python 3.13 and 3.14, memory management is evolving again. Reference counting is being redesigned for thread safety, GC is being optimized, and Python’s internals are being modernized for multi-core systems. But through it all, Python keeps its promise: “Let me handle the complexity. You focus on the idea.” 📌 Next Sunday – Episode 10: Dynamic Typing vs Type Hints Why Python chose dynamic typing, how type hints entered decades later, and how both coexist today. ⚡ Fun Fact: Python’s garbage collector doesn’t clean everything — immutable objects like small integers and strings are often cached for reuse! #python #ThePythonStory #StoryOfPython #programming #developers #PythonInternals

🔍 Python's Hidden Gem: Short-Circuit Evaluation with Operand Return Ever wondered why Python's "or" and "and" operators are more powerful than they seem? Unlike Java or C++, they don't just return True/False – they return the actual values! Short-circuit evaluation means that logical operators like and and or stop evaluating as soon as the result of the expression is known. In Python, these operators don’t just return True or False; they actually return the operand that determined the result — that’s what is meant by operand return. Python's logical operators ("or" and "and") return one of the actual operands, not necessarily True or False. The "or" Operator - - Returns the first truthy value it encounters - If all values are false, returns the last value The "and" Operator in Python - - Returns the first false value it encounters - If all values are truthy, returns the last value ``` # OR examples print(None or [1, 2, 3])   # [1, 2, 3] - returns first truthy print("hello" or "world")   # "hello" - returns first truthy print(False or 0 or [] or {}) # {} - all falsy, returns last print(42 or False)       # 42 - returns first truthy # AND examples   print([1, 2] and "text")    # "text" - all truthy, returns last print("text" and None)     # None - returns first falsy print(5 and 10 and 20)     # 20 - all truthy, returns last print(0 and [1, 2, 3])     # 0 - returns first falsy # Check if user exists AND has valid credentials OR is admin user = get_user(username) access_granted = (user and user.password == password) or is_admin # Returns: user object if password matches, False if not, or True if admin ``` False Values in Python (the complete list) : False None 0 (integer zero) 0.0 (float zero) 0j (complex zero) "" (empty string) [ ] (empty list) ( ) (empty tuple) { } (empty dict) set( ) (empty set) range(0) (empty range) Truth Values in Python (everything else!) : True Any non-zero number: 1, -1, 3.14, 2+3j Any non-empty string: "hello", "0", " " (even a space!) Any non-empty collection: [1, 2], (1,), {"a": 1} Any object or instance (by default) Functions, classes, modules ⚡ Why This Matters: - Reduces code complexity - Eliminates nested if-else pyramids - Makes default value handling elegant - Improves code readability dramatically #Python #CleanCode #CodingTips #SoftwareDevelopment

𝐓𝐡𝐞 𝐆𝐡𝐨𝐬𝐭 𝐢𝐧 𝐭𝐡𝐞 𝐌𝐚𝐜𝐡𝐢𝐧𝐞 Python is a memory safe language, right? After all, it's listed as memory‑safe language in the 2014 CISA recommendations. We trust Python's automatic GC (Garbage Collector) to tidy up, but sometimes, the GC is blinded. It’s not about poor coding (even though that can certainly be a factor); it’s about Python’s fundamental, hidden engine: 𝐑𝐞𝐟𝐞𝐫𝐞𝐧𝐜𝐞 𝐂𝐨𝐮𝐧𝐭𝐢𝐧𝐠. This is the core mechanism that keeps track of every variable. If a reference count never hits zero, Python thinks the object is still needed. The code looks fine, but deep down, a forgotten pointer is hoarding gigabytes of memory. A reference cycle occurs when two or more objects refer to each other, forming a closed loop. For example, object A refers to B, and object B refers back to A. Even if no external code is referencing A or B anymore, their internal counter never drops to zero because they are holding each other hostage. Python's Garbage Collector (GC) runs periodically to break these cycles, but: - It is 𝐧𝐨𝐭 𝐠𝐮𝐚𝐫𝐚𝐧𝐭𝐞𝐞𝐝 to run immediately. - It creates a significant 𝐩𝐞𝐫𝐟𝐨𝐫𝐦𝐚𝐧𝐜𝐞 𝐬𝐩𝐢𝐤𝐞 when it does run. - It can be 𝐝𝐢𝐬𝐚𝐛𝐥𝐞𝐝 or 𝐝𝐞𝐥𝐚𝐲𝐞𝐝 by other code execution. If you are dealing with complex data structures, caches, or deeply nested class hierarchies, you are building the perfect hiding spot for a tenacious reference cycle. You need to be proactive, don't wait for the GC to save the day! 1. Use 𝘸𝘦𝘢𝘬𝘳𝘦𝘧: When designing data structures where objects need to point to each other (like parent-child relationships), use the built-in 𝘸𝘦𝘢𝘬𝘳𝘦𝘧 module. A weak reference does not increase an object's reference count, allowing the other object in the cycle to be collected properly. 2. Inspect with 𝘨𝘤: Use the 𝘨𝘤 module to investigate. 𝘨𝘤.𝘨𝘦𝘵_𝘰𝘣𝘫𝘦𝘤𝘵𝘴() can show you all managed objects, and 𝘨𝘤.𝘤𝘰𝘭𝘭𝘦𝘤𝘵() lets you manually trigger the cleanup process to see if it fixes your memory spike (revealing an existing cycle). 3. Profile with 𝘵𝘳𝘢𝘤𝘦𝘮𝘢𝘭𝘭𝘰𝘤: This module tracks memory allocation down to the specific line of code that allocated it. Run your service with 𝘵𝘳𝘢𝘤𝘦𝘮𝘢𝘭𝘭𝘰𝘤 enabled to pinpoint the exact function and data structure responsible for the leak. Not using these suggestions doesn't mean you're a bad developer, or that your code is lacking. Python's memory model is not the same as writing code, or even engineering scalable services . You have to be a real coding geek (like the ones in Kratos Core) to even be interested in this - but it could really make a difference!

🚀 Day 26 — Understanding the Iterable Class in Python 🔹 What is an Iterable? An iterable is any object that can be looped over using a for loop. It can return an iterator using the built-in iter() function. Common examples: list, tuple, string, set, dictionary You can go through their elements one by one easily using a loop. 🔹 What is an Iterator? An iterator is an object that fetches elements one at a time from an iterable. It is created when you call iter() on an iterable. You use the next() function to get each item from the iterator. When all items are finished, Python raises a StopIteration exception to signal the end. 🔹 Relationship Between Iterable and Iterator All iterators are iterables, but not all iterables are iterators. 👉 Iterable → Can produce an iterator 👉 Iterator → Knows how to fetch the next item Think of it like this: Iterable is like a book you can read. Iterator is like a bookmark that remembers where you left off. 🔹 Making a Class Iterable To make your own class work in a for loop, you need to: 1️⃣ Define a method __iter__() that returns an iterator object. 2️⃣ The iterator must have a __next__() method that returns the next value. 3️⃣ When there are no more values, __next__() must raise StopIteration. That’s how Python knows how to iterate through your custom class objects. 🧠 Common Terms Iterable → Object that can return an iterator (supports iter()) Iterator → Object that returns elements one by one (supports next()) StopIteration → Signals the end of iteration iter() → Returns the iterator object next() → Returns the next element in the sequence 💡 Key Takeaways ✅ Iteration means accessing elements one by one. ✅ for loops work because they internally use iter() and next(). ✅ You can create your own iterable classes using __iter__() and __next__(). ✅ Once all elements are exhausted, iteration stops automatically. 📂 GitHub - https://lnkd.in/dGTqN_G9 🙏 Thank you, Saurabh Shukla Sir, for another beautifully explained concept! You make understanding Python’s hidden magic so simple and fun! 🐍💙 #100DaysLearningChallenge #Python #Iterable #Day26

Python Tuple Packing and Unpacking 🐍 In Python, tuples are more than just immutable lists. They are powerful tools that make your code cleaner, more readable, and incredibly Pythonic. And the concepts of tuple packing and unpacking are at the heart of writing elegant Python code. 🔹 Tuple Packing: Packing means grouping multiple values into a single tuple variable. Python makes this seamless: my_tuple = 1, 2, 3, 4, 5 👉Values are packed into a tuple 👉This allows you to store multiple values in a single variable, return multiple values from a function, or pass collections around without extra boilerplate. 🔹 Tuple Unpacking: 👉Unpacking is the reverse: extracting tuple elements into individual variables in a single, readable line. a, b, c = (10, 20, 30) print(a, b, c) 👉Output: 10 20 30 💡 Why Tuple Packing & Unpacking Matters? 1. Makes code more readable than indexing elements manually. 2. Enables returning multiple values from functions effortlessly. 3. Works beautifully with loops, function arguments, and nested data structures. ✨ Pro Tip: Tuple unpacking is especially powerful when swapping variables without a temporary placeholder: x, y = y, x No extra line, no temp variable—just clean, Pythonic magic. -------------------------- 🤓 Check Out More About Tuple Packing and Unpacking in my Python Lists Repo down below! -------------------------- ☺️ Here are Python (Beginner to Intermediate) GitHub Repos for you: 📁Python Variables: https://lnkd.in/e9rjz-_D 📁Python Operators: https://lnkd.in/e6hzgHSn 📁Python Conditionals: https://lnkd.in/egQNGZBF 📁Python Loops: https://lnkd.in/eezUg_-y 📁Python Functions: https://lnkd.in/eKdU6nex 📁Python Lists: https://lnkd.in/eZ8KiQNs ------------------------- ⚡ Follow my learning journey: 📎 GitHub: https://lnkd.in/ehu8wX85 🔗GitLab: https://lnkd.in/eiiQP2gw 💬 Feedback: I’d love your thoughts and tips! 🤝 Collab: If you’re also exploring Python, DM me! Let’s grow together! -------------------------- 📞Book A Call With Me: https://lnkd.in/e23BtnR9 -------------------------- #pythontuples #tuplepackingandunpacking #pythonforbeginners #pythonlanguage #pythonfordatascience

✨ The Python Story – Episode 6: Why Python Became Loved Anyway ❤️ ✨ By 2020, the long journey from Guido van Rossum’s Christmas hobby to a worldwide movement had finally come full circle. Python 3 was stable. The 2 vs 3 debates had faded. And something beautiful had happened — developers didn’t just use Python anymore… they loved it. 💖 But why? After all, Python isn’t the fastest language. It isn’t the newest, the flashiest, or the most rigidly typed. So what made it special? 💡 Because Python was built for humans. From the start, Guido’s goal wasn’t machine efficiency — it was developer happiness. He believed code should read like English, not like algebra. Every indentation, every clear keyword, every “there should be one obvious way to do it” made Python feel friendly. Beginners could learn it in days. Experts could express ideas in minutes. And that simplicity turned into power. 🔹 Educators used it to teach the next generation. 🔹 Researchers used it to explore data and AI. 🔹 Startups used it to build quickly and dream big. 🔹 Big companies used it to automate the world. Python quietly became the universal translator between creativity and code. 🌍 Community over complexity While many languages revolved around companies or committees, Python revolved around people. Mailing lists became meetups. Meetups became conferences. The humble “import this” Zen became a shared philosophy. Python wasn’t just a tool — it was a culture of kindness, readability, and sharing. 🚀 And that’s why it won. Even with its slowness jokes, indentation memes, and version wars — Python kept growing because it stayed human-centric. It evolved without losing its heart. Today, from AI labs to classrooms, from NASA scripts to web startups, Python speaks one language — clarity. 💭 But even with all its success, Python isn’t perfect. It’s often called “slow.” Some say its dynamic typing can be risky. Others debate its threading model or memory behavior. Yet every one of these “drawbacks” has a reason — a story behind it. And next season, we’ll explore exactly why Python works the way it does. Stay tuned. ⚙️ 📌 Next Sunday – Season 2 Begins Episode 7: Why People Call Python “Slow” We’ll peek under the hood and uncover how Python really works — its interpreter, bytecode, and the trade-offs that make it both loved and misunderstood. ⚡ Fun Fact: Guido once said, “Code is read much more often than it is written.” That single belief shaped everything Python stands for. #python #ThePythonStory #StoryOfPython #programming #developers

Python Iteration Using iter() and next() 🤔What is Iteration in Python? 👉 Iteration in Python is the process of accessing elements of a collection one by one 🌀 When using iter() and next(): 👉iter() → creates an iterator object from an iterable (like a list, tuple, or string). 👉next() → retrieves the next element from the iterator, one at a time. ‼️When the iterator has no more elements, next() raises StopIteration, signaling the end. ------------------------- ☺️ Here are Python (Beginner to Intermediate) GitHub Repos for you: 📁Python Variables: https://lnkd.in/e9rjz-_D 📁Python Operators: https://lnkd.in/e6hzgHSn 📁Python Conditionals: https://lnkd.in/egQNGZBF 📁Python Loops: https://lnkd.in/eezUg_-y 📁Python Functions: https://lnkd.in/eKdU6nex 📁Python Lists & Tuples: https://lnkd.in/eZ8KiQNs 📁Python Dictionaries & Sets: https://lnkd.in/eDmgj7pc 📁Python OOP: https://lnkd.in/eJFupCiK 📁Python DSAs: https://lnkd.in/ebR3rjkt ------------------------- ⚡ Follow my learning journey: 📎 GitHub: https://lnkd.in/ehu8wX85 🔗 GitLab: https://lnkd.in/eiiQP2gw 💬 Feedback: I’d love your thoughts and tips! 🤝 Collab: If you’re also exploring Python, DM me! Let’s grow together! -------------------------- 📞Book A Call With Me: https://lnkd.in/e23BtnR9 -------------------------- #iteration #pythonprogramming #iterationinpython #pythonforbeginners

map(), filter(), sort() with Lambda Functions In Python! ⚙️ ✨I explored how map, filter, and sort work with lambda functions that results in 2-3 code lines, sped up coding, and code redeability 👉The best part about lambda functions is that they can easily shrink 4-5 lines of code into just 2-3, crazy right? 🤓Also, lambda functions are interesting in a way that they collaborate seamlessly with map, filter, and sort to provide you with same results that a big chunk of code would ‼️Important: My python functions repo has been updated for Lambda Functions with map, filter, and sort HAPPY CODING! 😉 ---------------------------- ☺️ Here are Python (Beginner to Intermediate) GitHub Repos for you: 📁Python Variables: https://lnkd.in/e9rjz-_D 📁Python Operators: https://lnkd.in/e6hzgHSn 📁Python Conditionals: https://lnkd.in/egQNGZBF 📁Python Loops: https://lnkd.in/eezUg_-y 📁Python Functions: https://lnkd.in/eKdU6nex 📁Python Lists & Tuples: https://lnkd.in/eZ8KiQNs 📁Python Dictionaries & Sets: https://lnkd.in/eDmgj7pc 📁Python OOP: https://lnkd.in/eJFupCiK ------------------------- ⚡ Follow my learning journey: 📎 GitHub: https://lnkd.in/ehu8wX85 🔗GitLab: https://lnkd.in/eiiQP2gw 💬 Feedback: I’d love your thoughts and tips! 🤝 Collab: If you’re also exploring Python, DM me! Let’s grow together! -------------------------- 📞Book A Call With Me: https://lnkd.in/e23BtnR9 -------------------------- #lambdafunctions #pythonprogramming #pythonforbeginners #lambdafunctionsinpython #pythonlanguage

Python: Awesome language, lots of use-cases. I have used python for 5-6 years, and I think it’s a good language to use and misuse. Yesterday I revising my datastructures and algorithms, and wanted to make a red-black-tree. I did it in C, thought to myself "I don‘t care about the intricacies I need to understand it at a high level first" So i used Python Python isn‘t a language that fits my definition of recreational programming. Python has all these fancy features, and it enables you to not take care when you program (but you _should_ care. Here you can afford to not care though, unlike in C), and furthermore with metaclasses using __new__ (a constructor for classes, not instances as far as i know) and dynamic classes (type taking 3 arguments, the name __class__, the parents of which it inherits, and the dictionary of methods and properties), you get this… mess…, you can overwrite and override everything, and forcibly one-line-ify literally the entire source code, you can make recursive lists for crying out loud My goal isnt to learn the craft, my goal is to learn the *art* of the craft, and for that i need recreational use languages. My definition of recreational language is "is the representation of the entity relatable at a lower level". For Python, Java, JavaScript, TypeScript the answer is a clear No. Another addition to my arbitrary ruleset is "How much nonsense does it add?" Not lack, add. Not having strings is nonsense, bounds checks, allowing buffer overflows etc, that’s nonsense, but that isn‘t _added_. Convenience fixes are added to fix these things, which is awesome, but C doesn‘t add its problems. It just doesn‘t add solutions. Another "paradigm" of my recreational language checklist is "How much abstraction are you willing to take?" C is high level in that regard, but the code has a clear correspondence to the generated assembly Summary: - Is the representation of the entity relatable at a lower level (if you were to take everything apart layer by layer, when would things stop existing) - How much "extra" does it add? (What features are there that are useful but don‘t match the 99% usecase Python: metaclasses, name mangling with match, hacking the import resolver, etc for example. I am not good enough in Java, I just artificially don‘t like the language. JSFuck, and TypeScript types are turing complete.) - How much abstractions are you willing to take? (In my case very little. The job of the compiler is to compile, not make me dinner and sing me to sleep. If I make a mistake, this is my fault. Compile the code. This is what I installed you for. You are here to compile code, not tell me that I am bad at programming. I know that) I went back to C and it felt good again. Maybe I just am too far gone in the C rabbit hole, or maybe I am just saying 3000 characters worth of cope and skill issue. If this post offends you because I dunked on your favourite language, make 100 C compilers out of spite Have a great day everyone