Python 3.13 No-GIL Benchmarks with FastAPI

Python functions with fixed signatures break the moment you need to forward arguments across abstraction boundaries. *args and **kwargs solve that — and this python tutorial goes well past the syntax. — How CPython actually handles variadic calls at the C level (PyTupleObject, PyDictObject, and why there's a real allocation cost) — Why a defaulted parameter before *args is effectively unreachable via positional calling — and the idiomatic fix — The difference between *args isolating the mapping vs sharing mutable values inside it — ParamSpec (PEP 612) for preserving decorator signatures through the type system — TypedDict + Unpack (PEP 692, Python 3.12) for per-key precision on **kwargs — inspect.Parameter.kind for reading variadic signatures at runtime — the foundation of FastAPI and pytest's dispatch logic — Lambda variadic syntax, functools.wraps, kwargs.setdefault patterns, and common SyntaxErrors caught at parse time Includes interactive quizzes, spot-the-bug challenges, a design decision review, and a 15-question final exam with a downloadable certificate of completion. Full guide: https://lnkd.in/gHkdvCn5 #Python #PythonProgramming #SoftwareDevelopment

🚀 Python GIL vs No-GIL — Real FastAPI Benchmarks (Python 3.13) Free-threaded Python is no longer just an experiment — it’s starting to show real impact. I came across a benchmark comparing Python 3.12 (with GIL) vs Python 3.13t (No-GIL) using FastAPI, and the results are pretty interesting 👇 💡 Key Takeaways: 🔹 Massive CPU Boost (~8x) CPU-bound endpoints jumped from ~4 RPS to ~32 RPS — with ZERO code changes. This is what true parallelism across cores looks like. 🔹 Threading inside requests ≠ better performance Even without GIL, spawning threads inside a single request didn’t help. Why? Under load, request-level parallelism already saturates the CPU. Extra threads just add overhead. 🔹 I/O performance unchanged No surprise here — GIL was never the bottleneck for I/O-bound workloads. Async + I/O still behaves the same. 📊 What this means in practice: ✅ Use No-GIL Python when: - You have CPU-heavy APIs (ML inference, image processing, data pipelines) - High concurrency + CPU contention exists - You previously relied on multiprocessing to bypass GIL ❌ Don’t expect gains if: - Your app is mostly I/O (DB calls, HTTP requests) - You’re already using async effectively ⚠️ Things to keep in mind: - Free-threading is still evolving - Thread safety is now YOUR responsibility - Some C extensions may not be ready yet 🔥 The most exciting part? Same code. Same FastAPI app. Just a different Python runtime → 8x improvement. This could seriously change how we design backend systems in Python. Curious — would you switch to No-GIL Python for your APIs? #Python #FastAPI #BackendEngineering #Performance #Concurrency #AI #SoftwareEngineering

Build a RAG pipeline from scratch in Python without LangChain Learn to build a RAG pipeline in Python from scratch using ChromaDB and OpenAI embeddings — no LangChain required. Read the full post 👇 https://lnkd.in/gBHKATvy #GenerativeAI #AI #WebDevelopment #PHP #Python #Developer #LLM

Build a RAG pipeline from scratch in Python without LangChain Learn to build a RAG pipeline in Python from scratch — chunk documents, embed with OpenAI, store in ChromaDB, and query with Claude. Read the full post 👇 https://lnkd.in/gBHKATvy #GenerativeAI #AI #WebDevelopment #PHP #Python #Developer #LLM

yield is one of those Python keywords that looks simple until someone asks you to explain it. Most developers can tell you a function with yield in it produces values and works in for loops. Fewer can explain why that same function doesn't actually run when you call it. Turns out, that's the whole point. Generators (functions with yield) are functions that pause mid-execution and resume exactly where they left off: local variables, loop counters, everything intact. In my Python Context Managers series, I'm covering generators as a dedicated article because they are not a standalone concept. They are the engine behind @contextmanager, a cleaner way to build context managers in Python. You can't fully understand one without understanding the other. This article is a deep dive into generator functions: https://lnkd.in/dSNegaWK A function that remembers where it left off changes everything. #Python #SoftwareEngineering #Backend #Programming #WebDevelopment #BuildBreakLearn

Python: 05 🐍 Python Iterables: Diving Deeper 🚀 We'll work on different complex types (range, list etc.) and strings iteration. We've already known the for loops, now let's dive into deeper and know what is range function returns. 🔍 We will use a built in 'type' function to get the type of an object. 🛠️ For example: type(5) .. it will return <class 'int'>; that means number 5 is an integer value 🔢 type(range(5)) .. it will return <class 'range'>; that means we get the value from a range function that means its an object of type range! 🧊 Primitive vs. Complex Types 💡 In python we have primitive types like numbers, strings, Booleans. We also have so many complex types, 'range' is one of those complex types. So interesting concept of range is, it is iterable which means we can iterate over it or use it in a for loop. That is why we can write code like this: for x in range(3): Here x can hold number in the range in each iteration. 🔄 Result: 1 2 3 Strings are also iterable! 🧵 For example: for x in "python": print(x) It will return: ✨ p ✨ y ✨ t ✨ h ✨ o ✨ n Which means x will hold one character from the string in each iteration. 🔡 List Iteration 📋: for x in [1, 2, 3, 4,..,n]: print(x) It will return: 1 2 3 4 ... ... ... nth X will hold one object from the list in each iteration. 🎯 #PythonProgramming #PythonDeveloper #Coding #python #iterator #DataScience #pythondeveloper #programmer

F-strings in Python — Not Just Cleaner. Fundamentally Better. Python has had three ways to format strings over its history. If you’ve only learned the language recently, you might not have encountered the older two — but you will, because they still appear in legacy codebases, documentation, and tutorials written before Python 3.6. The first was % formatting, borrowed from C: name = "Andres" print("Hello, %s. You have %d messages." % (name, 5)) It works. But the syntax is cryptic, the order of arguments is error-prone, and it becomes harder to read as soon as you add more than one variable. The second was .format(), introduced in Python 3.0: print("Hello, {}. You have {} messages.".format(name, 5)) An improvement — more explicit, more flexible. But the variables and the placeholders are still separated. To understand what goes where, your eyes have to travel back and forth across the line. Then Python 3.6 introduced f-strings: print(f"Hello, {name}. You have {5} messages.") The variable lives inside the string, exactly where it appears in the output. No positional arguments. No external references. The code reads the way the sentence reads. Beyond readability, f-strings also evaluate expressions directly inline — which means you can do this: hours = 7.5 print(f"Weekly total: {hours * 5} hours") No intermediate variable needed. And in terms of performance, f-strings are consistently faster than .format() because they are parsed closer to compile-time rather than evaluated fully at runtime. Knowing all three methods matters. Understanding why f-strings became the standard tells you something about how Python evolves — always toward clarity. #Python #PythonMOOC2026 #BackendDevelopment #SoftwareEngineering #LearningInPublic #UniversityOfHelsinki

Sometimes small Python behaviors end up causing big confusion in production. I faced one such case with shallow copies when handling nested lists and dicts. It looked simple at first but ended up modifying original data silently. Wrote a plain and honest Medium piece about what actually happened and how I fixed it. It is not theory or textbook — just one of those bugs you only understand after you hit it yourself. Friend link below ⬇️ https://lnkd.in/ehYY9zRY #Python #BackendDevelopment #SoftwareEngineering #CodingJourney #TechCommunity #MediumDev #PythonTips #LearningByDebugging

Day 27 Python Full Stack Development Journey Today’s focus was on understanding Polymorphism in Python and its key concepts. 🔹 Introduction to Polymorphism Polymorphism means “many forms”. In Python, it allows the same function, method, or operator to behave differently depending on the object or data type. Example: Python print(len("Hello")) # String length print(len([1,2,3])) # List length 🔹 Important Terminologies in Polymorphism Method Overriding Same method name in parent and child class, but different implementation. Duck Typing Python doesn’t check object type, it checks behavior. (“If it looks like a duck and acts like a duck, it is a duck.”) Dynamic Typing Variable type is decided at runtime, not fixed. 🔹 Operator Overloading Operator overloading allows operators to have different meanings for different objects. Example: Python print(5 + 3) # Addition print("Hello " + "World") # String concatenation We can also overload operators in user-defined classes. 🔹 Magic Methods (Dunder Methods) Magic methods are special methods in Python that start and end with double underscores (__). They are used to define behavior for operators and built-in functions. 👉 Common Magic Methods: __init__ → Constructor __str__ → String representation __add__ → Addition operator __len__ → Length __repr__ → Official representation 👉 Example: Python class Demo: def __init__(self, x): self.x = x def __str__(self): return f"Value is {self.x}" obj = Demo(10) print(obj) Thanks for our CEO G.R NARENDRA REDDY sir and Global Quest Technologies