Python Tuples: Unexpected Mutation

🧠 Python Concept That Explains Why += Can Mutate: In-place vs New Objects (__iadd__) Why does this behave differently? 👀 a = [1, 2] b = a a += [3] print(a) # [1, 2, 3] print(b) # [1, 2, 3] But: x = (1, 2) y = x x += (3,) print(x) # (1, 2, 3) print(y) # (1, 2) Same += … different result 🤯 🤔 The Reason: __iadd__ Python tries: 1️⃣ __iadd__ (in-place add) 2️⃣ else → __add__ (new object) 🧪 Lists implement __iadd__ list.__iadd__(self, other) So list is modified in place. 🧪 Tuples don’t So Python creates a new tuple. 🧒 Simple Explanation List = clay 🧱 You reshape same clay. Tuple = brick 🧱 You must make new brick. 💡 Why This Matters ✔ Mutability understanding ✔ Side-effects bugs ✔ Performance ✔ Data structures ✔ Interview classic ⚡ Key Insight id(a) == id(a += ...) True for mutable types False for immutable types 💻 In Python, += doesn’t always mean “new value”. 🐍 Sometimes it means “modify in place” 🐍 The difference comes from __iadd__. #Python #PythonTips #PythonTricks #AdvancedPython #CleanCode #LearnPython #Programming #DeveloperLife #DailyCoding #100DaysOfCode

Consider the following code in Python: def add_item(lst): lst.append(100) a = [1, 2, 3] add_item(a) print(a) What happens here? The correct explanation is: ✅ An in-place modification occurs on the list. Lists in Python are mutable objects, which means they can be modified after they are created. Let’s break it down step by step. 1️⃣ Creating the list When we write: a = [1, 2, 3] Python creates a list object in memory, and the variable a references it: a → [1, 2, 3] 2️⃣ Calling the function When the function is called: add_item(a) The parameter lst inside the function now references the same list object: a → [1, 2, 3] lst → ↑ (same list) ➡️ Both variables point to the same object in memory. 3️⃣ Inside the function Inside the function we execute: lst.append(100) The append() method modifies the list itself. This is called in-place modification, meaning the original list object is updated instead of creating a new one. The list now becomes: [1, 2, 3, 100] 4️⃣ Printing the result Since both a and lst reference the same list, the change is visible through a. Now when we execute: print(a) Output: [1, 2, 3, 100] 📌 Final thought Understanding how variables reference objects in memory is essential when working with mutable data types like lists in Python. #Python #PythonProgramming #Coding #LearnPython #SoftwareDevelopment

Python Default Arguments 🐍🐍 Default Arguments Powerful but Dangerous. Let’s see why. Basic Example def greet(name="Guest"): print(f"Hello {name}") greet() # Hello Guest greet("Rahul") # Hello Rahul #Looks simple. But here is the important detail: 👉 Default arguments are evaluated only once — when the function is defined, not when it is called. The Classic Python Trap def add_item(item, items=[]): items.append(item) return items print(add_item(1)) # [1] print(add_item(2)) # [1, 2] print(add_item(3)) # [1, 2, 3] Most people expect: [1] [2] [3] But Python keeps reusing the same list object. Why? Because the default list "[]" was created once at function definition time and reused in every call. The Correct Way def add_item(item, items=None): if items is None: items = [] items.append(item) return items Now every call gets a fresh list. Why Python Works This Way Python stores default arguments inside the function object: function.__defaults__ They are not recreated each time the function runs. This design improves performance but can introduce subtle bugs. #Takeaway ✔ Default arguments are evaluated once at definition time ✔ Mutable defaults ("list", "dict", "set") can cause shared state bugs ✔ Use "None" as a safe default when mutation is involved #Python #PythonTips #Programming #SoftwareEngineering #PythonDeveloper

🔹 Python Tip: sort() vs sorted() When working with lists in Python, we often need to sort data. There are two common ways to do this: list.sort() and sorted(). Let’s look at a simple example: lst1 = [20, 10, 50, 30, 40] Suppose we want to sort the elements in ascending order. 1️⃣ Using list.sort() lst1 = [20, 10, 50, 30, 40] lst1.sort() print(lst1) ➡️ Output: [10, 20, 30, 40, 50] Here, sort() modifies the original list directly. This is called in-place sorting, meaning the existing list itself gets reordered. 2️⃣ Using sorted() lst1 = [20, 10, 50, 30, 40] new_list = sorted(lst1) print(new_list) ➡️ Output: [10, 20, 30, 40, 50] The key difference is that sorted() does not change the original list. Instead, it returns a new sorted list, so we store it in another variable. So now we have: new_list = [10, 20, 30, 40, 50] lst1 = [20, 10, 50, 30, 40] 🔹 Summary • Use sort() when you want to modify the list itself and don’t need the original order. • Use sorted() when you want to keep the original data unchanged and create a new sorted sequence. • Another advantage of sorted() is that it works with other iterable types such as tuples, strings, and sets. #Python #Programming #Coding #DataScience #LearnPython

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!

𝐏𝐲𝐭𝐡𝐨𝐧 𝐒𝐭𝐫𝐢𝐧𝐠 𝐏𝐫𝐚𝐜𝐭𝐢𝐜𝐞 – 𝐈𝐦𝐩𝐥𝐞𝐦𝐞𝐧𝐭𝐢𝐧𝐠 𝐋𝐨𝐠𝐢𝐜 𝐢𝐧 𝐂𝐨𝐝𝐞 Today(12/03/2026) I practiced some Python problems related to string manipulation, focusing on implementing the logic manually instead of relying only on built-in functions. 𝐒𝐨𝐦𝐞 𝐩𝐫𝐨𝐛𝐥𝐞𝐦𝐬 𝐈 𝐬𝐨𝐥𝐯𝐞𝐝: 🔹 Reverse a String def rev_str(s): rev = "" for char in s: rev = char + rev return rev 🔹 Palindrome Check def is_palindrome(s): return s == s[::-1] 🔹 Character Frequency Count def freq_count(s): freq = {} for x in s: if x in freq: freq[x] += 1 else: freq[x] = 1 return freq 🔹 Count Vowels def count_vowels(s): count = 0 for x in s: if x in "aeiouAEIOU": count += 1 return count 🔹 Check Anagram def is_anagram(s1, s2): return sorted(s1) == sorted(s2) 🔹 Count words in a sentence def count_words(s): words = s.split() return len(words) 🔹 Find the first unique character in a string def first_unique(s): for x in s: if s.count(x) == 1: return x 𝐂𝐨𝐧𝐜𝐞𝐩𝐭𝐬 𝐩𝐫𝐚𝐜𝐭𝐢𝐜𝐞𝐝 • String traversal • Dictionary frequency counting • Conditional logic • Basic algorithmic thinking Consistent small practice sessions help strengthen Python fundamentals and problem-solving skills. #Python #CodingPractice #DataEngineering #ProblemSolving

📌 Topic: Set Methods in Python Today I explored Set Methods in Python. A set is an unordered collection of unique elements. It does not allow duplicates and is very useful for mathematical operations like union and intersection. 🔹 Important Set Methods I Learned:  add() – Adds a single element to the set s = {1, 2, 3} s.add(4) print(s) ✅ update() – Adds multiple elements s.update([5, 6]) ✅ remove() – Removes an element (gives error if not found) ✅ discard() – Removes an element (no error if not found) ✅ pop() – Removes a random element ✅ clear() – Removes all elements 🔹 Set Operations: 🔸 Union (| or union()) 🔸 Intersection (& or intersection()) 🔸 Difference (- or difference()) 🔸 Symmetric Difference (^) Example: a = {1, 2, 3} b = {3, 4, 5} print(a.union(b)) print(a.intersection(b)) 📚 Every day I am improving step by step in Python. Consistency is the key to success! 💪 #Day16 #PythonLearning #SetMethods #CodingJourney #LearningEveryday

Multipart (Python library), ReDoS, CVE-2026-28356 (High) The `parse_options_header()` function in `multipart.py` versions up to `1.3.0` contains a regular expression with an ambiguous alternation . When parsing a maliciously crafted `Content-Type` header (specifically the options section), the regex engine attempts to validate the string against multiple paths . Due to the nested repetition and alternation in the pattern, providing a carefully crafted input with many backslashes and quotes causes exponential backtracking ....

Multipart (Python library), ReDoS, CVE-2026-28356 (High) The `parse_options_header()` function in `multipart.py` versions up to `1.3.0` contains a regular expression with an ambiguous alternation . When parsing a maliciously crafted `Content-Type` header (specifically the options section), the regex engine attempts to validate the string against multiple paths . Due to the nested repetition and alternation in the pattern, providing a carefully crafted input with many backslashes and quotes causes exponential backtracking ....

I recently conducted a benchmark comparing Python 3.13 and 3.14 on the same CPU-heavy task, initially out of curiosity. The results were surprising; the performance difference was significant and has changed my perspective on parallelism in Python. While optimizing a CPU-bound data pipeline, my usual approach was to use ProcessPoolExecutor. Although it effectively handles tasks, the OS-level process spawn cost can accumulate quickly. Python 3.14 introduced a new option: InterpreterPoolExecutor. This allows for multiple isolated Python interpreters within the same process, eliminating GIL conflicts. I benchmarked the performance of Python 3.13 versus 3.14 as follows: ───────────────────────────────────────── 📊 1. HEAVY CPU TASKS (8 tasks, 4 workers) 🔴 Threads: 2.519s (GIL serializes everything) 🟠 Processes: 1.222s (parallel, but costly to spawn) 🟢 Subinterpreters: 1.130s (parallel and lighter) ───────────────────────────────────────── ⚡ 2. STARTUP COST (50 tiny tasks, where it really shows) 🟠 Processes: 0.271s 🟢 Subinterpreters: 0.128s (about 2x faster to start) 📈 3. SCALING (1 → 8 workers) 🔴 Threads: flatlined at ~1.9s (no real scaling benefit) 🟢 Subinterpreters: 2.16s → 0.91s (close to linear scaling) ───────────────────────────────────────── The key takeaway is that we can achieve process-level parallelism with thread-like startup speed, without GIL contention or extra process memory overhead, all within the standard library. Are you still using ProcessPoolExecutor for CPU-bound work? I am genuinely interested in whether subinterpreters could be a practical improvement in your stack. #Python #Python314 #SoftwareEngineering #Performance #Concurrency #BackendDevelopment #DataEngineering