Python References, Memory & Copy Explained

PYTHON JOURNEY - Day 47 / 50..!! TOPIC – List Comprehensions Today I explored one of Python’s most "elegant" features — List Comprehensions. It’s a shorthand way to create new lists based on existing ones, turning 4 lines of code into just 1! 1. The Traditional Way vs. Comprehension Normally, to create a list of squares, you’d need a for loop and .append(). With comprehension, it’s a single line! Python # Traditional Way nums = [1, 2, 3] squares = [] for x in nums: squares.append(x * x) # List Comprehension (The Pythonic Way) squares = [x * x for x in nums] print(squares) # Output: [1, 4, 9] 2. Adding a Condition (The if part) You can filter items while creating the list. Python prices = [10, 55, 80, 25, 100] # Only keep prices over 50 expensive = [p for p in prices if p > 50] print(expensive) # Output: [55, 80, 100] 3. String Manipulation It works perfectly for transforming text data too. Python names = ["srikanth", "python", "dev"] capitalized = [n.capitalize() for n in names] print(capitalized) # Output: ['Srikanth', 'Python', 'Dev'] Why Use List Comprehensions? Readability: Once you learn the syntax, it's much easier to read at a glance. Performance: They are generally faster than standard for-loops for creating lists. Professional: It is a hallmark of "Pythonic" code—showing you really know the language! Mini Task Write a program that: Creates a list of numbers from 1 to 10. Uses List Comprehension to create a new list containing only the even numbers. Prints the resulting list. #Python #PythonLearning #50DaysOfPython #DailyCoding #LearnPython #CodingJourney #PythonForBeginners #LinkedInLearning #DeveloperCommunity

PEP-800: typing.disjoint_base PEP: https://lnkd.in/eHzws5n6 Discussion: https://lnkd.in/ewrrUSKY Implementation in typing_extensions: https://lnkd.in/e-pZED3M In python, you can inherit from several classes (and generally with the __mro_entries__ method, yes). Which is sometimes quite convenient if used without fanaticism. But the problem is that not all sets of classes are suitable for multiple inheritance. For example: >>> class What(str, int): ... Traceback (most recent call last): TypeError: multiple bases have instance lay-out conflict Why this happens, you can read here (https://lnkd.in/eNd2Mxhc). But, it is important for us to know that CPython has the concept of "solid base", which is considered for all created classes here. (https://lnkd.in/e3vZ_s_9). In short, CPython should be able to build a proper memory layout for all descendant classes. For example, all int descendants should be stored in memory like this: Otherwise, the basic int logic will stop working. But strs are arranged differently. Details (https://lnkd.in/eMUeHaGT ) from the ashes about "solid bases". Previously, this code was used in some typecheckers. After all, they thought that a type subclass of int and str could exist. And now they will know that this is impossible at the definition level and throw out the right mistake. Excellent PEP, the type system has become a little better. Discussion: Did you know about solid and disjoint bases in python? Have you shot yourself in the foot like that?

🧠 Python Concept You MUST Know: Python’s LEGB Rule (Variable Lookup Order) ✔️ Most Python developers use variables every day. ✔️ Very few understand how Python decides which variable to use. ✔️ That’s where the LEGB rule comes in. Let’s explain this simply 👇 🧒 Simple Explanation Imagine you’re looking for your toy car 🚗. You search in this order: 1️⃣ Your room 2️⃣ Your sibling’s room 3️⃣ Living room 4️⃣ Your building’s storage area Python does the same thing when looking for a variable. 🔍 LEGB = Local → Enclosed → Global → Built-in Python looks for variables in this exact order: 🔹 L — Local Inside the current function def fun(): x = 10 # local 🔹 E — Enclosed Inside an outer function (nested functions) def outer(): x = 20 def inner(): print(x) # enclosed 🔹 G — Global Defined at the top of the script x = 30 🔹 B — Built-in Python’s internal names (like len, range, print) 🧠 Example That Shows All 4 in Action x = 30 # global def outer(): x = 20 # enclosed def inner(): x = 10 # local print(x) inner() outer() Output: 10 Python stops at the first match — the local variable in inner(). ⚠️ When Python Can’t Find a Variable If Python checks: Local ❌ Enclosed ❌ Global ❌ Built-in ❌ Then you get: NameError: name 'x' is not defined 🎯 Interview Gold Line “Python resolves variables using the LEGB rule — Local, Enclosed, Global, Built-in — in that exact order.” Interviewers LOVE this answer. 🧠 One-Line Rule Python looks in the nearest scope first. ✨ Final Thought Knowing LEGB makes you better at: ✔ Debugging ✔ Writing functions ✔ Understanding closures ✔ Avoiding accidental shadowing It turns confusion into clarity. 📌 Save this post — LEGB is Python’s secret map for finding variables. #Python #LearnPython #PythonTips #Programming #DeveloperLife #SoftwareEngineering #Coding #TechLearning #CodeNewbie #Freshers

Day 461: 8/1/2026 Why Python Strings Are Immutable? Python strings cannot be modified after creation. At first glance, this feels restrictive — but immutability is a deliberate design choice with important performance and correctness benefits. Let’s break down why Python does this. ⚙️ 1. Immutability Enables Safe Hashing Strings are commonly used as: --> dictionary keys --> set elements --> For this to work reliably, their hash value must never change. If strings were mutable: --> changing a string would change its hash --> dictionary lookups would break --> internal hash tables would become inconsistent By making strings immutable: --> the hash can be computed once --> cached inside the object --> reused safely for O(1) lookups This is a foundational guarantee for Python’s data structures. 🔐 2. Immutability Makes Strings Thread-Safe Immutable objects: --> cannot be modified --> can be shared freely across threads --> require no locks or synchronization This simplifies Python’s memory model and avoids subtle concurrency bugs. Even in multi-threaded environments, the same string object can be reused safely without defensive copying. 🚀 3. Enables Memory Reuse and Optimizations Because strings never change, Python can: --> reuse string objects internally --> safely share references --> avoid defensive copies Example: --> multiple variables can point to the same string --> no risk that one modification affects another This reduces: --> memory usage --> allocation overhead --> unnecessary copying 🧠 4. Predictable Performance Characteristics Immutability allows Python to store: --> string length --> hash value --> directly inside the object. As a result: --> len(s) is O(1) --> hashing is fast after the first computation --> slicing and iteration don’t need recomputation --> This predictability improves performance across many operations. Stay tuned for more AI insights! 😊 #Python #Programming #Performance #MemoryManagement

Day 464: 11/1/2026 Why Python Exceptions Are Expensive? --> Python exceptions are great for error handling. --> They are not cheap and using them in performance-critical paths can seriously hurt runtime. --> This isn’t an opinion. --> It’s a consequence of how Python executes code. Let’s break it down. ⚙️ 1. Exceptions Are Not Simple Control Flow In Python, an exception is not just a conditional jump. Raising an exception triggers: --> stack unwinding --> frame inspection --> object creation --> metadata propagation This is orders of magnitude more expensive than an if check. Exceptions are designed for rare events, not normal execution paths. 🧱 2. Exception Objects Are Real Python Objects When an exception is raised, Python creates: --> an exception object --> a traceback object --> references to stack frames Each of these: --> allocates memory --> updates reference counts --> stores metadata Even if the exception is immediately caught, this work already happened. 🔁 3. Stack Unwinding Is Costly To raise an exception, Python must: --> walk up the call stack --> identify the correct except block --> clean up intermediate frames --> restore execution state This process touches multiple stack frames and Python objects. In deep call stacks, this cost increases further. 🧠 4. Tracebacks Are Expensive by Design Tracebacks store: --> file names --> line numbers --> function names --> execution context This is extremely useful for debugging but it means exception handling prioritizes diagnostics over speed. Stay tuned for more AI insights! 😊 #Python #PerformanceOptimization #SoftwareEngineering

𝗣𝘆𝘁𝗵𝗼𝗻 𝗶𝘀 𝗹𝗮𝘇𝘆. 𝗔𝗻𝗱 𝘁𝗵𝗮𝘁'𝘀 𝗮 𝗳𝗲𝗮𝘁𝘂𝗿𝗲, 𝗻𝗼𝘁 𝗮 𝗯𝘂𝗴. When Python evaluates `False and something_else`, it doesn't bother checking `something_else`. Why would it? The result is already determined. This is called short-circuit evaluation, and you can use it intentionally: → username = input("Name: ") or "Guest" If the user enters nothing, the empty string is falsy. Python short-circuits and uses "Guest" instead. No if/else. No extra variables. Just clean, readable code. 𝗕𝘂𝘁 𝗵𝗲𝗿𝗲'𝘀 𝘄𝗵𝗲𝗿𝗲 𝗶𝘁 𝗴𝗲𝘁𝘀 𝗽𝗼𝘄𝗲𝗿𝗳𝘂𝗹: → x != 0 and (10 / x) > 5 If x is zero, Python sees `False` and skips the division entirely. No ZeroDivisionError. This pattern lets you write guard clauses that are both elegant and safe. Understanding short-circuit evaluation isn't just about writing clever code. It's about understanding how Python thinks—and making that work for you. I'm writing "Zero to AI Engineer: Python Foundations" in public. Follow along on Substack for behind-the-scenes updates and excerpts (link in comments). #Python #Programming #AIEngineering #TechCareers #LearnToCode

🧠 Python Concept You Must Understand: Iterator vs Iterable ✨ Many people use loops. ✨ Few understand what actually gets looped. ✨ This concept explains how for loops really work in Python. 🧒 Real World Explanation Imagine you have a box of chocolates 🍫🍫🍫. ✔️ The box contains chocolates ✔️ Your hand takes chocolates one by one In Python: 💻 The box is an Iterable 💻 The hand is an Iterator 🔹 What Is an Iterable? An iterable is something you can loop over. Examples: List Tuple String Dictionary numbers = [1, 2, 3] 👉 numbers is an iterable It contains items but doesn’t know how to move through them. 🔹 What Is an Iterator? An iterator is what actually gives values one at a time. it = iter(numbers) print(next(it)) print(next(it)) Output: 1 2 👉 The iterator remembers where it stopped 🧠 What a for Loop Really Does for x in numbers: print(x) Behind the scenes, Python does: it = iter(numbers) while True: try: x = next(it) print(x) except StopIteration: break 🤯 This is the secret behind loops. 🚀 Why This Concept Is VERY Important Understanding this helps you: ✔ Understand generators ✔ Understand yield ✔ Write memory-efficient code ✔ Debug iteration errors ✔ Answer interview questions Most advanced Python features depend on this. 🎯 Interview Gold Line “An iterable can create an iterator.” ✔️ Short sentence. ✔️ Deep understanding. 🧠 One-Line Rule 🖥️ Iterable = has items 🖥️ Iterator = gives items one by one ✨ Final Thought 💯 Python loops look simple because Python hides complexity. 💯 Once you understand iterators and iterables, Python feels logical instead of magical. 📌 Save this post — this concept unlocks many others. #Python #LearnPython #Programming #DeveloperLife #PythonTips #Freshers #TechCareers #SoftwareEngineering

Python Logic: How Code Makes Decisions When you start with Python, it feels like a calculator. But real engineering begins when your code starts making decisions. This is the world of Comparison and Logical Operators. 🛠️ The Logic Toolbox: ✅ Comparison Operators: Python uses tools like ==, !=, >, and < to evaluate data. Every comparison results in a Boolean (True or False)—the foundation of all backend logic. ✅ Type Strictness: Python is smart. It knows that 1 == "1" is False because a number and a string are completely different entities. This strictness prevents massive bugs in data pipelines. ✅ Logical Operators (and, or, not): These allow you to combine conditions. They are the "brains" behind user validation and AI decision-making. ✅ The Power of Booleans: Whether it's an if statement or a complex AI workflow, everything boils down to a simple True or False. The Takeaway: Mastering these operators allows you to control the flow of your program. It’s the difference between a script that just runs and a system that actually "thinks." I’m building my foundation in Python logic as I move toward Backend and AI Engineering. #Python #SoftwareEngineering #Backend #Logic #CleanCode #LearningInPublic #GoogleCertification #ProgrammingTips

Mastering Iterators in Python:- When you loop over a list, string, or file in Python using a for loop, you are already using iterators behind the scenes. Understanding them gives you more control over data processing, especially with large datasets and streams. 🔹 Real definition (Iterator in Python):- An iterator in Python is an object that returns the next item from a sequence each time you call next() on it, following the iterator protocol with __iter__() and __next__() methods. You usually get an iterator by passing an iterable (like a list, tuple, or string) to the built-in iter() function, and a for loop automatically uses this iterator internally >>Image explanation :- Use a simple, clean image that explains the concept visually: >Visual idea: Show a conveyor belt with boxes (elements: 10, 20, 30, 40) moving one-by-one to a worker labeled iterator, and behind the belt a warehouse labeled list. >Concept to highlight in text on the image:- >>Warehouse = iterable (stores all items) >>Conveyor belt worker = iterator (gives one item at a time using next()) >Caption on image: >> Iterator in Python: get one item at a time from an iterable, instead of loading everything at once. >Key advantages of iterators:- >>Memory efficient: Process one element at a time without storing the whole sequence in memory, ideal for large or infinite data streams. >>Lazy evaluation: Values are produced only when needed, which reduces unnecessary computation and speeds up pipelines. >>Clean and uniform looping: The same for loop syntax works across lists, tuples, strings, files, and custom objects via iterators. >>Powerful with generators and itertools: Iterators combine with generators to build flexible, composable data-processing pipelines. #Python #Iterators #PythonTips #PythonDeveloper #Programming #Coding #SoftwareDevelopment #LearnPython #DataProcessing #CleanCode

Day 459: 6/1/2026 Why Python Objects Are Heavy? Python is loved for its simplicity and flexibility. But that flexibility comes with a cost — Python objects are memory-heavy by design. ⚙️ What Happens When You Create a Python Object? Let’s take a simple example: a string. When you create a string in Python, you are not just storing characters. Python allocates a full object structure around that value. Every Python object carries additional metadata. 🧱 1. Object Header (Core Overhead) Every Python object has an object header that stores: --> Type Pointer Points to the object’s type (e.g., str, int, list) Required because Python is dynamically typed Enables runtime checks like: which methods are valid whether operations are allowed This is why “a” + 1 raises a TypeError Unlike C/C++, Python must always know the object’s type at runtime. --> Reference Count Tracks how many variables reference the object Used for Python’s memory management When the count drops to zero, the object is immediately deallocated This bookkeeping happens for every object, all the time. 🔐 2. Hash Cache (For Immutable Objects) Immutable objects like strings store their hash value inside the object. Why? Hashing strings is expensive Dictionaries need fast lookups So Python caches the hash: Hash computed once Reused for dictionary and set operations Enables average O(1) lookups This improves speed — but adds more memory per object. 📏 3. Length Metadata Strings also store their length internally. This allows: len(s) to run in O(1) slicing and iteration without recomputing length efficient bounds checking Again: faster execution, but extra memory. Stay tuned for more AI insights! 😊 #Python #MemoryManagement #PerformanceOptimization