Peter (PEZ) Strömberg’s Post

**Dangerous Python** **Artifact #1 – a function that changes its own code** Most programmers assume one simple rule: if a function is called f, it always does the same thing. Python allows you to break that assumption. Not through eval. Not through dynamic imports. Directly inside the function object itself. In Python, every function has an attribute called __code__. This is the bytecode, the actual execution engine of the function. And it can be replaced while the program is running. Below the post you can see a minimal example. _________________________________________________________________ **What just happened?** At first the function f behaves normally. f(x) = x + 1 But when the condition x == 7 appears, a surgical operation happens: f.__code__ = ... From that moment on, the function behaves completely differently. The same object. The same name. A different engine. **Why is this dangerous?** This mechanism breaks several fundamental assumptions of programming. 1. Code stops being stable over time A function may do one thing at the beginning of the program and something entirely different five seconds later. 2. Debugging becomes harder Stack traces and code inspection may show one thing while the runtime is executing something else. 3. Tests may become unstable If tests run in a different order, the program may behave differently. **Why does Python allow this?** Because Python is not only a programming language. It is a runtime manipulation system. Functions, classes, and modules are just objects. And objects can be modified. This power is useful in: frameworks plugin systems instrumentation code analysis tools But in normal application code, this is closer to a museum artifact than a design pattern. PYTHON ALLOWS SOMETHING MOST LANGUAGES FORBID: A FUNCTION CAN REMAIN THE SAME FUNCTION… AND STILL CHANGE ITS CODE WHILE THE PROGRAM IS RUNNING.

🐍 10 Python Built-in Functions Most Developers Ignore (But Shouldn't) I've been writing Python for years — and I'll be honest, I was still discovering functions hiding in plain sight. Here are 10 powerful built-ins that can seriously level up your code: 🔴 1. breakpoint() Forget print-debugging forever. Drop this anywhere in your code and get an instant interactive debugger. Game changer. 🔧 2. compile() Turn a string of code into an executable object. Perfect for dynamic code execution workflows. ⚡ 3. exec() Run Python code dynamically — on the fly. Powerful when used carefully. 🧠 4. eval() Evaluate expressions from strings. Need to compute "10 + 20" at runtime? Done. 📦 5. vars() Peek inside any object and see all its attributes as a dictionary. Incredibly useful for debugging classes. 🌍 6. globals() Inspect all global variables in your current scope. Great for introspection and debugging. 🔍 7. locals() Same idea, but scoped to the current function. Print it inside any function to see exactly what's in memory. 📋 8. dir() Explore every method and attribute available on any object. No more guessing what a list or dict can do. 📚 9. help() Built-in documentation — right in your terminal. Stop Googling basic syntax; just call help(). ✅ 10. callable() Check if an object can be called like a function. Super useful when building flexible, dynamic systems. --- 💡 The best Python developers aren't those who memorize the most syntax. They're the ones who deeply understand the tools already in their hands. Save this post. The next time you're debugging or building something dynamic, one of these will save you hours. ♻️ Repost if this helped someone on your network!

Ever screamed at your screen because Python changed a variable you never touched?   Or a function suddenly "remembered" values from previous calls?   Or a SyntaxError pointed to a line that looked perfect? These aren't random bugs — they're Python's design decisions in action. And they trip up beginners and experienced devs alike. I wrote the guide I wish existed when I started:   "Getting Started with Python: Overview & Real-World Applications"   Not another "Python is readable" list — but a practitioner's breakdown of the **8 core surprises** that explain most "why does this behave that way?" moments in your first year. The 8 problems covered: - Terminal says Python doesn't exist (PATH hell) - Error on a line that looks fine (parser vs runtime) - Changing one variable changes another (name binding) - Function modifies input it should only read - Mutable defaults trap — function remembers across calls - "1992" isn't a number (input() strings) - Code runs but nobody understands it (naming/docstrings) - Windows paths break silently (escape sequences/raw strings) Plus: how these same concepts power real-world Python in data science (Pandas views/copies), web (Django/FastAPI), and automation. If you've ever wasted hours debugging a "perfectly logical" Python script — this post gives you the mental model to stop it. Read it here: https://lnkd.in/gcsHx66Q What's the #1 Python surprise that cost you the most time early on? Drop it below — let's commiserate and learn from each other. #Python #LearnPython #PythonBeginners #ProgrammingTips #DataScience #Coding (Full Python Fundamentals series linked inside — 13 articles building from install to production concepts)

I used to hate lazy imports in Python. Coming from C++, there's something deeply uncomfortable about importing inside a method. You want your dependencies declared upfront, visible, accounted for — not buried somewhere in the call stack. But that discomfort was baggage, not wisdom. If you've been avoiding them out of habit, it's worth a second look. https://lnkd.in/g-4dkyH8

Python Portal: Use itertools instead of loops While loops are great, they have limitations, especially in modern programming styles and for certain types of problems. Understanding these limitations helps you choose the right tool for the task. Each loop iteration in Python incurs interpreter overhead, such as type checking and memory management. This can add up significantly on large datasets. To get around this limitation, Python has a convenient built-in library, itertools. For example, suppose you need to generate all unique pairs from a given list. Order is unimportant, and no element should be paired with itself. To avoid code bloat and reduce the risk of bugs, you can use the itertools library. The itertools.combinations() function directly generates all unique combinations of elements from an iterable, without repetition or order. Here's how you can rewrite the code using combinations from itertools: from itertools import combinations def get_unique_pairs_itertools(items):     return list(combinations(items, 2)) my_list = ['A', 'B', 'C', 'D'] print(get_unique_pairs_itertools(my_list)) Output: [('A', 'B'), ('A', 'C'), ('A', 'D'), ('B', 'C'), ('B', 'D'), ('C', 'D')] Original: https://lnkd.in/dRUUNewb

Why List Comprehensions in Python Are Faster Than Traditional Loops 🚀🚀🚀🚀🚀🚀🚀 When working with Python, you may have noticed that many developers prefer list comprehensions over traditional "for" loops when creating lists. While both approaches produce the same result, list comprehensions are generally more optimized and faster. Let's look at a simple example. Using a #traditional loop squares = [] for i in range(10): squares.append(i * i) Using a #list_comprehension squares = [i * i for i in range(10)] Both snippets generate the same list of squared numbers, but the list comprehension is usually 20–40% faster. 🔍 Why is it faster? 1️⃣ Fewer Bytecode Instructions Traditional loops repeatedly perform method lookups for "append()". List comprehensions use a specialized Python bytecode instruction called "LIST_APPEND", which reduces interpreter overhead. 2️⃣ Reduced Function Calls In a loop, Python repeatedly calls the "append()" method. List comprehensions avoid this repeated call mechanism internally. 3️⃣ Cleaner and More Pythonic Code Besides performance, list comprehensions often make code more concise and readable. ⚠️ Important Note: While list comprehensions are powerful, they should be used when the logic is simple. If the expression becomes too complex, readability can suffer. 💡 Key Takeaway List comprehensions are faster because Python optimizes them using specialized bytecode and avoids repeated method lookups like "list.append()". --- ✨ Small Python optimizations like this can significantly improve both performance and code clarity. #Python #Programming #SoftwareEngineering #CodingTips #PythonDeveloper #TechLearning

Understanding How Python Code Runs: From Source Code to Execution When we write Python programs, it may appear that the code runs directly after we execute it. However, behind the scenes, Python follows a well-defined process before producing the final output. Here is a step-by-step overview of how Python code is executed: 1️⃣ Writing the Source Code The process begins when a developer writes Python code in a file with the ".py" extension (for example, "main.py"). This file contains the human-readable instructions written using Python syntax. 2️⃣ Python Interpreter Reads the Code When the program is executed (e.g., "python main.py"), the Python interpreter reads the source code. Unlike compiled languages such as C or C++, Python does not directly convert code into machine code. 3️⃣ Compilation to Bytecode The interpreter first compiles the source code into an intermediate format called bytecode. Bytecode is a low-level, platform-independent representation of the program instructions. 4️⃣ Storage in "__pycache__" The generated bytecode is often stored in the "__pycache__" directory as ".pyc" files. This allows Python to reuse the compiled bytecode in future executions, improving performance. 5️⃣ Execution by the Python Virtual Machine (PVM) Finally, the Python Virtual Machine (PVM) reads the bytecode and executes it instruction by instruction. The PVM acts as a runtime engine that translates bytecode into operations understandable by the underlying system. 📌 In Summary: Python Execution Flow → "Source Code (.py) → Bytecode (.pyc) → Python Virtual Machine → Output" #Python #Programming #SoftwareDevelopment #Coding #PythonInternals #Developers #LearningPython

Python developers have accepted forks and monkey patches for too long. 𝗺𝗼𝗱𝘀𝗵𝗶𝗺 is a cleaner way to customize packages without touching their code. It gives Python developers a way to override and customize existing packages without editing the original source code, which immediately makes it stand out from the usual mix of forks, vendoring, and brittle monkey patches. That matters because most teams do not want to maintain a permanent fork of a dependency just to patch one behavior, test one variation, or add one missing feature that the upstream package does not support yet. What I like about modshim is that it approaches this problem with a cleaner mental model, where the original package stays intact and your changes live in a separate layer that can be mounted through Python’s import system. In practice, that means you can adapt third party packages in a way that feels far more deliberate, maintainable, and reversible than the hacks many of us have quietly accepted as normal in production code. It is the kind of tool that feels small at first glance, but the more Python you have written, the more obvious its value becomes. --- ♻️ Found this useful? Share it with another builder. ➕ For daily practical AI and Python posts, follow Banias Baabe.

Python String Formatting: From Old to New String formatting in Python has evolved significantly, from the older `%` style to the more modern `str.format()` method and the introduction of f-strings in Python 3.6. This evolution is essential for improving readability and flexibility in code, allowing you to embed variables and expressions directly within strings seamlessly. The old-style formatting uses the `%` operator, where placeholders like `%s` indicate where variables should be inserted. While functional, this method can become cumbersome with multiple variables and is less readable when formatting complex strings. This is where `str.format()` comes in. It uses curly braces `{}` as placeholders and allows for more flexibility, including the ability to format numbers, align text, and control decimal places. F-strings further streamline the process. They provide a way to embed expressions directly in string literals, making the code more intuitive and concise. By prefixing the string with `f`, you can insert variables directly without additional syntax. Understanding string formatting is crucial for any Python developer. The choice between these options often depends on readability, complexity, and the version of Python you're using, but f-strings are generally recommended due to their simplicity and efficiency. Quick challenge: How would you modify the f-string to include a number variable for age in the greeting? #WhatImReadingToday #Python #PythonProgramming #StringFormatting #Fstrings #Programming

Python may get async yield from. Nice syntax. Potentially ugly consequences. At first glance, it feels like a natural extension of yield from for async generators. It is convenient. It is visually consistent. And yes, sometimes it would make code cleaner. But async generators are already one of those Python features that look simpler than they really are. Go a bit deeper, and you run into things like explicit closing, cleanup that does not happen when you expect, wrong assumptions about generator behavior, dependence on an event loop just to finish safely, and bugs that appear the moment multiple tasks touch the same flow. That is the real discussion. Not whether async yield from looks elegant. But whether it makes a sharp edge even sharper. This is one of the things I find most interesting in Python: a feature can look like syntax sugar on the surface, while quietly expanding the state model underneath. And in production systems, that difference matters. Complexity in Python rarely arrives as one dramatic failure. It shows up as a chain of locally reasonable decisions that slowly become hard to reason about as a whole. That is why async-heavy systems need more than code that “works”. They need clear lifecycle rules, ownership boundaries, and predictable behavior under failure. Curious where others land on this: Would async yield from make async Python better, or just easier to misuse?