Python Strings: Immutable for Performance and Safety

Most Python code works. Very little Python code scales. The difference? 👉 Object-Oriented Programming (OOPS). As part of rebuilding my Python foundations for Data, ML, and AI, I’m now focusing on OOPS — the layer that turns scripts into maintainable systems. Below are short, practical notes on OOPS — explained the way I wish I learned it 👇 (No theory overload, only what actually matters) 🧠 Python OOPS — Short Notes (Practical First) 🔹 1. Class & Object A class is a blueprint. An object is a real instance. class User: def __init__(self, name): self.name = name u = User("Anurag") Used to model real-world entities (User, File, Model, Pipeline) 🔹 2. __init__ (Constructor) Runs automatically when an object is created. Used to initialize data. def __init__(self, x, y): self.x = x self.y = y 🔹 3. Encapsulation Keep data + logic together. Control access using methods. class Account: def get_balance(self): return self.__balance Improves safety & maintainability 🔹 4. Inheritance Reuse existing code instead of rewriting. class Admin(User): pass Used heavily in frameworks & libraries 🔹 5. Polymorphism Same method name, different behavior. obj.process() Makes systems flexible and extensible 🔹 6. Abstraction Expose what a class does, hide how it does it. from abc import ABC, abstractmethod Critical for large codebases & APIs OOPS isn’t about syntax. It’s about thinking in systems, not scripts. #Python #OOPS #DataEngineering #LearningInPublic #SoftwareEngineering #AIJourney

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

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 Data Structures and Their Tradeoffs In Python, data structures are not interchangeable. Each one reflects a deliberate tradeoff between performance, memory usage, and correctness. Here’s a breakdown of common Python data structures and their core tradeoffs: 📌 Lists (list) - Strengths: Dynamic, iterable, excellent for ordered collections and sequential access. - Tradeoffs: O(n) membership checks (in operator) and mid-list insertions/deletions. - When to use: Maintaining order, iterating over items, or when you need a simple, mutable sequence. 📌 Sets (set) - Strengths: O(1) average-time membership tests, enforce uniqueness, optimized for set operations (union, intersection). - Tradeoffs: Unordered, higher memory overhead, not indexable. - When to use: Removing duplicates, testing membership, or mathematical set operations. 📌 Dictionaries (dict) - Strengths: Key-value mapping with O(1) average lookup time, highly versatile. - Tradeoffs: Memory usage (overhead per key-value pair), keys must be hashable. - When to use: Associating data, frequency counting, caching (e.g., memoization), or fast lookups by key. 📌 Tuples (tuple) - Strengths: Immutable, memory-efficient, hashable (if all elements are hashable), thread-safe. - Tradeoffs: Cannot be modified after creation; less flexible than lists. - When to use: Fixed collections, dictionary keys, returning multiple values from functions, or when you need data integrity. Strong Python code is less about knowing what to use and more about knowing why to use it. #Python #Programming #DataStructures #CodeQuality

Day 2nd ->I started by understanding what Python is and why it’s so popular. Python’s simple syntax, readability, and massive ecosystem of libraries . * Next, I learned how "Python executes code" The process is straightforward but fascinating: 👉 You write the code → Python compiles it into bytecode → the interpreter executes it → and finally, you see the output. This behind-the-scenes flow helped me understand why Python is called an interpreted language. *I also explored "comments" and "print formatting", which are essential for writing clean code. Comments make programs readable for humans, while the "print() function" becomes more powerful with parameters like sep and end, allowing better control over output formatting. *Then came "data types" the building blocks of any program. I worked with: Integers and Floats for numbers Strings and Characters for text Booleans for true/false logic Understanding data types clarified how Python stores and processes different kinds of information. * learned about "variables" and the concept of "reinitialization" which allows changing a variable’s value anytime—simple, flexible, and very Pythonic. *Finally, I studied "identifier rules" which define how variables should be named. Following these rules ensures clarity, avoids errors, and makes code professional and readable.

Frustrated with a Python script that feels sluggish? Instead of guessing where the slowdown is, you can measure it. Tom Reid shares a guide on using cProfile and snakeviz to find and fix the exact parts of your code that are causing delays.

Day 2🚀 When working with Python, data rarely comes in the format we need. Numbers may arrive as strings, decimals may need to become integers, and sometimes values must simply be displayed as text. This is where data type conversion (type casting) becomes essential. Python provides built-in functions like int(), float(), and str() to convert data from one type to another. ✨Float conversion is more flexible. Python allows both whole numbers and decimal values, even when they are stored as strings, to be converted into floating-point numbers. However, non-numeric strings cannot be converted into numbers at all and result in runtime errors. ✨String conversion is the safest of all. Any value — whether a number, decimal, or word — can be converted into a string without errors. #Python #DataScience #TypeCasting #PythonBasics #LearningInPublic #InternshipJourney

🐍 Exception Handling in Python – Write Crash-Free Code! ⚠️💻 Errors happen — wrong input, missing files, division by zero… Instead of letting your program crash, Python gives you a smart way to handle errors gracefully using try–except blocks 🚀 🔹 1️⃣ What is an Exception? An exception is an error that occurs while the program is running, interrupting its normal flow. Examples: ❌ File not found ❌ Division by zero ❌ Invalid input type 🔹 2️⃣ Basic Try–Except Block Wrap risky code inside try and handle the error in except. try: x = 10 / 0 except: print("Something went wrong!") 📝 Output: Something went wrong! 🔹 3️⃣ Catch Specific Exceptions 🎯 Always try to catch specific errors instead of generic ones. try: num = int("abc") except ValueError: print("Invalid conversion!") 🔹 4️⃣ Using Else Block Runs when no exception occurs ✅ try: result = 10 / 2 except ZeroDivisionError: print("Cannot divide by zero") else: print("Result:", result) 🔹 5️⃣ Finally Block – Always Executes 🔚 Used for cleanup actions like closing files or releasing resources. try: file = open("data.txt") except FileNotFoundError: print("File missing!") finally: print("Operation completed.") 🔹 6️⃣ Why Exception Handling is Important? ✔️ Prevents program crashes ✔️ Improves user experience ✔️ Makes debugging easier ✔️ Essential for production systems ✔️ Used heavily in Data Science & automation pipelines ✨ Takeaway: Exception handling helps your program stay stable, secure, and professional even when things go wrong. If you want to write real-world Python applications — mastering try–except is a must! 🚀🐍 #Python #Programming #ExceptionHandling #TryExcept #CodingBasics #DataScience #Automation #LearningJourney #CareerGrowth #DataEngineering #Data Ulhas Narwade (Cloud Messenger☁️📨) Rushikesh Latad

"Performance tips in Python: vectorization & memory (Part 4)" At small scale, almost any Python code “works.” Once you’re dealing with millions of rows, the difference between a loop and a vectorized operation can mean minutes vs hours. Here’s how I think about performance in real data work: 1️⃣ Stop looping over rows when you don’t have to Row-by-row for loops feel intuitive, but they’re usually the slowest option. Vectorized operations in pandas or NumPy apply logic to entire columns at once, leveraging optimized C under the hood instead of pure Python. 2️⃣ Watch your data types like a hawk Memory issues often come from heavier types than necessary: float64 when float32 is enough, or long strings where categories would work. Downcasting numeric columns and converting repeated text to category can dramatically reduce memory usage and speed up operations. 3️⃣ Process large data in chunks (or scale out) If a dataset doesn’t fit comfortably in memory, reading and processing it in chunks is often better than loading everything at once. At larger scales, pushing transformations to distributed engines (like Spark) lets Python focus on orchestration and specialized logic. 4️⃣ Measure, don’t guess Simple timing and memory checks — timing a cell, inspecting DataFrame. info(), or sampling before and after changes — turn performance from guesswork into an experiment. Over time, this builds intuition about which patterns are “cheap” and which are “expensive.” These habits don’t just make code faster — they make it more reliable when datasets grow or when a proof-of-concept script needs to become a production pipeline. 👉 If you’re working with growing datasets, start by replacing one loop with a vectorized operation and one wide numeric column with a more efficient type. You’ll feel the difference quickly. #Python #Pandas #Performance #DataEngineering #BigData #AnalyticsEngineering