Python zip() Function Simplifies Parallel Iteration

🐍✨ Move All Zeros to the End — Python Solution ✨🐍 Let’s solve this cleanly and efficiently in Python! 🚀 🧠 Problem Recap Given a list of integers: 👉 Move all 0s to the end 👉 Keep the order of non-zero numbers the same 👉 Do it in-place (no extra list) ⚡ Efficient Solution (Two-Pointer Technique) def push_zeros_to_end(arr): count = 0 # Position for next non-zero element for i in range(len(arr)): if arr[i] != 0: # Swap current element with element at 'count' arr[i], arr[count] = arr[count], arr[i] count += 1 # 🚀 Driver Code arr = [1, 2, 0, 4, 3, 0, 5, 0] push_zeros_to_end(arr) print(arr) 🔎 How It Works 🎯 Step-by-step idea: count keeps track of where the next non-zero number should go. When we find a non-zero: Swap it with the position at count Move count forward Zeros automatically shift toward the end. 🧪 Example Input: [1, 2, 0, 4, 3, 0, 5, 0] Output: [1, 2, 4, 3, 5, 0, 0, 0] ⏱ Time & Space Complexity ComplexityValue⏳ TimeO(n)💾 SpaceO(1) (in-place) ✔ Only one pass through the list ✔ No extra memory used ✔ Maintains order

If you’ve been using Python for a while, you’ve already used descriptors, even if you’ve never written one yourself. @property, instance methods, cached attributes, ORM fields… all of them rely on the same mechanism. I wrote a deep dive on how Python descriptors work under the hood, how attribute access is resolved, and when descriptors are (and aren’t) a good idea. 👉 https://lnkd.in/dudSFGpE

Why range(1,000,000) is cheap, but list(range(1,000,000)) is costly in Python? TL;DR: Iteration Protocol in Python needs to know only next item and not full list. The "Next Page" Rule Iteration in Python isn't about having a collection of items; it’s about knowing how to get the next item. Two special methods make this possible: 1. __iter__() → tells Python “I can be looped over” 2. __next__() → returns the next value, one at a time When there’s nothing left, StopIteration tells Python to stop the loop. Why this matters? When we use a list, we pay for all the memory upfront. When we use the Iteration Protocol, we only pay for one item at a time. This is called Lazy Evaluation. Takeaway - If the object represents a collection or a stream of data, implement __iter__ and __next__. It makes the code more memory-efficient and much more "Pythonic." I’m deep-diving into the Python protocols this week and will share my learnings. Do follow along and tell your experiences in comments. #Python #PythonInternals #SoftwareEngineering #BackendDevelopment

New Meta Open Source Content 🔎 Four type-narrowing patterns that make Python type checking more intuitive. 🐍✨ From tuple length narrowing to hasattr guards, see how Pyrefly helps reduce the need for explicit casts in your code. Learn more here: https://lnkd.in/eAny9r5R

Python simulates object orientated development. Recently I did a code review and the idea was to have a Table class and each instance has rows added from the different source tables on request. Sort of what the code below simulates. You call add_data() for a table and it reads an array of data from source, adding it to the provided table. In the first call, if no table exists yet, it creates a Table object for you. The parameter with a default is the culprit. What is the output of this code? Which leads to the root cause: How often is Table() being called?

New post on the Pyrefly blog from project maintainer Danny Yang: 4 type-narrowing patterns that make Python type checking more intuitive. 🐍✨ From tuple length narrowing to hasattr guards, see how Pyrefly helps reduce the need for explicit casts in your code. https://lnkd.in/ezr9etq5

I hate Python. I hate YAML. Any language or config that breaks because of a space, a tab, or copy-paste is bad design. I’m happy to have more characters, more brackets, and bigger files if it means my code doesn’t break because of one extra space. Code should not depend on whitespace. If a space can break your code, that’s not clean or smart , it’s fragile.

Exploring Python Context Managers under the hood Context managers are one of Python's most powerful features for resource management. I’ve been diving into how the context protocol works, and it’s fascinating to see how the with statement actually operates. To implement a context manager from scratch, you need two dunder methods: __enter__: Sets up the environment. If you’re opening a file or a database connection, this method prepares the object and returns it. __exit__: Handles the cleanup. It ensures that regardless of whether the code succeeds or crashes, the resources (like file handles or network sockets) are properly closed. As a fun experiment, I wrote this helper class to redirect print statements to a log file instead of the console: import sys class MockPrint: def __enter__(self): # Store the original write method to restore it later self.old_write = sys.stdout.write self.file = open('log.txt', 'a', encoding='utf-8') # Redirect stdout.write to our file logic sys.stdout.write = self.file.write return self def __exit__(self, exc_type, exc_value, traceback): # Restore the original functionality and close the file sys.stdout.write = self.old_write self.file.close() # Usage with MockPrint(): print("This goes to log.txt instead of the console!") While Python’s standard library has tools like contextlib.redirect_stdout for this exact purpose, building it manually really helped me understand how the protocol manages state and teardown. It’s a simple concept, but it's exactly what makes Python code so clean and safe. #Python #SoftwareEngineering #Backend

Day 7: Python Full-Stack Journey 🐍 | Unpacking the Power of Packing & Unpacking Today I explored one of Python's elegant features that makes code cleaner and more intuitive—variable packing and unpacking! What I learned: Unpacking allows you to assign multiple values in one line, making code more readable. For example, instead of accessing list indices separately, you can extract values directly: python coordinates = (10, 20) x, y = coordinates The asterisk operator takes this further by collecting remaining values. This is especially useful when you only care about certain elements: python first, *middle, last = [1, 2, 3, 4, 5] # first = 1, middle = [2, 3, 4], last = 5 For function arguments, packing with *args and **kwargs provides incredible flexibility, allowing functions to accept variable numbers of arguments without defining each parameter explicitly. Real-world application: I built a simple function that processes API responses by unpacking nested data structures, making the code significantly more concise than traditional index-based access. The beauty of unpacking is how it transforms verbose code into something elegant and Pythonic. It's these small features that make Python feel intuitive. What Python feature has surprised you with its elegance? #Python #100DaysOfCode #FullStackDevelopment #LearnInPublic #WebDevelopment #Coding

In Part 1, we saw packets flow through the kernel into socket buffers. Now let's see what Python does with them. Published Part 2, covering how asyncio and ASGI actually work under the hood. How the event loop uses epoll to monitor thousands of sockets, what happens when you await, how Uvicorn bridges bytes to FastAPI, and why async scales so well. The best part? Seeing how it all connects. The kernel work sets up everything for asyncio to handle massive concurrency with minimal overhead. https://lnkd.in/gcTm9fyB #Python #FastAPI #asyncio #HTTP #ASGI