Python List vs Array for Unsigned Integers

🧠 Python Concept That Explains Attribute Lookup Order: Descriptor Lookup Chain When you access: obj.attr Python follows a precise order 👀 🔍 The Real Lookup Order Python checks in this exact sequence: 1️⃣ Data descriptor (__set__ / __delete__) 2️⃣ Instance __dict__ 3️⃣ Non-data descriptor (__get__) 4️⃣ Class __dict__ 5️⃣ __getattr__ 🧪 Example Insight class D: def __get__(self, obj, owner): return "descriptor" class C: x = D() c = C() c.x = "instance" print(c.x) ✅ Output instance Because instance dict beats non-data descriptor. 🧒 Explain Like I’m 5 Imagine looking for a toy 🧸 1️⃣ Guard holding it 2️⃣ Your bag 3️⃣ Shelf 4️⃣ Store 5️⃣ Ask someone That order = lookup chain. 💡 Why This Matters ✔ Descriptor behavior ✔ Properties ✔ ORMs ✔ Framework internals ✔ Debugging weird attribute bugs ⚡ Key Rule 🐍 Data descriptors override instance attributes. 🐍 Non-data descriptors don’t. 🐍 Attribute access in Python isn’t random. 🐍 It follows a precise chain 🐍 Understanding the descriptor lookup order explains many “magic” behaviors. #Python #PythonTips #PythonTricks #AdvancedPython #CleanCode #LearnPython #Programming #DeveloperLife #DailyCoding #100DaysOfCode

🐍 Did you know? In Python, descriptors let you take full control over class attributes. They allow you to customize behavior when instance variables are accessed, modified, or deleted. What are Descriptors? A descriptor is a class that implements one or more of the following special methods: 1. Non-data descriptor  Does not override instance dictionary values.  Method: __get__(self, instance, owner) 2. Data descriptor  Overrides instance dictionary values.  Methods: __set__(self, instance, value)  __delete__(self, instance) Example: class PositiveInteger: def __set_name__(self, owner, name): print(f"Setting name {name} for {owner}") self.name = name def __get__(self, instance, owner): print("Getting value...") return instance.__dict__.get(self.name, 0) def __set__(self, instance, value): if not isinstance(value, int): raise TypeError(f"{self.name} must be an integer.") if value <= 0: raise ValueError(f"{self.name} must be a positive integer.") print(f"Setting {self.name} to {value}...") instance.__dict__[self.name] = value def __delete__(self, instance): print(f"Deleting {self.name}...") del instance.__dict__[self.name] class Product: quantity = PositiveInteger() #Python #PythonProgramming #PythonDevelopers #SoftwareEngineering #Programming

🐍 Python Tip: Stop copying lists the wrong way! Every Python developer hits this bug at some point: a = [1, 2, 3, 4] b = a b.append(5) print(a) # [1, 2, 3, 4, 5] 😱 When you write b = a, you're NOT copying the list. You're just creating another variable pointing to the SAME memory (call by reference). ✅ The 3 ways to properly copy a list: • b = a[:]    → Slice copy • b = a.copy()  → Built-in method • b = list(a)   → Constructor copy ⚡ Which one is fastest? a[:] wins — it's a direct C-level memory slice with zero Python overhead. Speed ranking: a[:] > a.copy() > list(a) ⚠️ BUT — all 3 are SHALLOW copies. If your list contains nested lists or objects, changes will still bleed through: a = [[1, 2], [3, 4]] b = a.copy() b[0].append(99) print(a) # [[1, 2, 99], [3, 4]] 😬 For nested structures, use deepcopy: import copy b = copy.deepcopy(a) Quick rule: 📦 Flat list → a[:] or a.copy() 📦 Nested list → copy.deepcopy(a) Small detail. Big bugs if you get it wrong. ♻️ Repost if this helped someone on your team! #Python #Programming #SoftwareDevelopment #CodingTips #PythonTips

Python Study Day 4 - String Manipulation Strings are sequences of characters. Python provides many useful methods to manipulate strings. - Common String Operations: Concatenation: Joining two or more strings together using the + operator. first_name = "John" last_name = "Doe" full_name = first_name + " " + last_name print(full_name) # Output: "John Doe" Repetition: Repeating a string multiple times using the * operator. greeting = "Hello! " * 3 print(greeting) # Output: "Hello! Hello! Hello! " - String Methods: upper(): Converts a string to uppercase. lower(): Converts a string to lowercase. strip(): Removes leading and trailing spaces from a string. replace(old, new): Replaces a substring with another string. message = " Hello, World! " print(message.strip()) # Output: "Hello, World!" print(message.upper()) # Output: "HELLO, WORLD!" print(message.replace("World", "Python")) # Output: "Hello, Python!" - Accessing String Characters: You can access individual characters in a string using indexing. Python uses zero-based indexing, so the first character has an index of 0. text = "Python" print(text[0]) # Output: P print(text[2]) # Output: t You can also use negative indexing to start counting from the end of the string. print(text[-1]) # Output: n print(text[-3]) # Output: h - Slicing Strings: You can extract a portion (substring) of a string using slicing. text = "Python Programming" print(text[0:6]) # Output: Python (extracts from index 0 to 5) print(text[:6]) # Output: Python (same as above) print(text[7:]) # Output: Programming (from index 7 to the end)

Why "simple Python scripts" in analytics stop being simple Almost every analytics project starts the same way. "A small Python script". "Just a quick notebook". "We will clean it up later". And at the beginning, it really is simple. Until it is not. Stage 1 - the harmless script At first, the script: loads data applies a few transformations saves a result Everything lives in one file, variables are global, configuration is hardcoded. It works, and nobody complains. Stage 2 - reuse starts creeping in Soon, the same logic is needed: in another notebook in another pipeline for another metric Copy-paste appears. Then slightly modified copy-paste. Now you have multiple versions of the "same" script, and nobody is sure which one is correct. Stage 3 - state and configuration leak everywhere Then come: database connections environment flags feature toggles credentials Suddenly, your "simple script" depends on: execution order hidden global state implicit assumptions At this point, debugging becomes harder than writing new code. Stage 4 - accidental software engineering Without noticing, analysts start reinventing: configuration managers shared resources lifecycle control basic design patterns Not because they want to, but because the system demands it. This is usually the moment when people say: "Why is analytics code so hard to maintain?" The real problem The problem is not that analytics code becomes complex. The problem is pretending that it will not. Analytics scripts often grow into: production jobs business-critical pipelines decision-making systems But they are still treated as disposable code. A more honest mindset Instead of asking: "How do we keep analytics code simple?" A better question is: "How do we let it grow without turning into chaos?" That is where: structure explicit state clear ownership and basic engineering discipline start to matter. Final thought Most analytics code does not fail because of bad logic. It fails because it outgrows the assumptions it was written with. At what point do Python scripts in your analytics work usually stop being "simple"? #python #data_analytics #analytics_engineering #data_engineering

Variables in python: 💡 What if I told you… In Python, a “variable” doesn’t actually store data? Yes! Let that sink in for a second. When I first started learning Python, I thought: num = 100 means the variable(num) stores 100. But that’s not entirely true. 🔎 Here’s what really happens: 🔹 Variables A variable is just a name that references an object in memory. It points to data — it doesn’t physically store it. When you reassign: - num = 100 - num = 200 You’re not “changing the box.” You’re making the name point to a new object. That small understanding changes how you think about Python. 🔒 What About Constants? Python doesn’t truly enforce constants. Instead, we follow a professional convention: PI = 3.14 MAX_USERS = 1000 Uppercase indicates = “Please don’t change this.” It’s discipline, not enforcement, and discipline makes better developers. Constants is also the value that variable holds. For every constant there will be a specific memory. 🧠 And Then There Are Data Types… Every value in Python has a type: Integers → Whole numbers (25,-34) Float → Decimal numbers (99.99) String → Anything written inside '.....', "......." ,'''.....'''' or """....""" will be called as a string value. - it can be a character, a word or a sentence or even other datatypes Example-("Hello", " 65",'0.86','"false"') Boolean → True / False Data types define how Python behaves with that value. Add two integers? ✅ Add a string and an integer? ❌ Error. Programming isn’t about memorizing code. It’s about understanding how things actually work behind the scenes. Excited for what’s next 🚀 #DataScience #Python #SQL #ProgrammingBasics #LearningInPublic #CareerGrowth

When I stop using Python and switch back to SQL. I like Python. It’s flexible, expressive, and great for exploration. But there’s a point where I deliberately put it down and move back to SQL. That moment usually comes when the work needs to be: reproducible, not just correct once, reviewable by others and easy to rerun as data updates. Python is where I explore: test assumptions, prototype logic, sanity-check edge cases etc. SQL is where I formalise: define metrics clearly, apply business rules consistently and create outputs others can trust. In my opinion, if an analysis is likely to be reused, audited, or built on by someone else, SQL almost always wins. It’s not about which tool is more powerful, It’s about what stage the work is in. Knowing when to switch has been far more valuable than knowing more syntax. How do you approach this? what’s your signal that it’s time to move from exploration to structure? #DataAnalytics #SQL #Python #AnalyticsEngineering

LeetCode #49 – Group Anagrams | Python Implementation I implemented a character frequency signature approach to group anagrams efficiently. Instead of sorting each string (which would cost O(k log k) per string), I generate a fixed-size frequency array of 26 elements representing counts for each letter. This array is converted to a tuple to serve as a hashable key in a dictionary, mapping each unique signature to its corresponding anagram group. This pattern is widely used in document clustering, duplicate detection systems, and search indexing pipelines. res = defaultdict(list) for s in strs:   count = [0] * 26           # Fixed-size frequency array   for c in s:     count[ord(c) - ord("a")] += 1   # Map 'a'-'z' to indices 0-25   res[tuple(count)].append(s)      # Use tuple as hashable key     return list(res.values())         # Return grouped anagrams Key Takeaway: Using character frequency arrays as keys avoids the sorting overhead entirely. The tuple conversion is crucial since lists aren't hashable in Python. This technique shines when dealing with large datasets where minimizing per-element processing time is critical. Time: O(n * k) where n is the number of strings and k is the max string length | Space: O(n * k) #LeetCode #DataStructures #Python #HashMap #Anagrams #CodingInterview #ProblemSolving #SoftwareEngineering

99% of Python developers don't know about __slots__. 𝗕𝘂𝘁 𝘁𝗵𝗶𝘀 𝘀𝗶𝗻𝗴𝗹𝗲 𝗹𝗶𝗻𝗲 𝗰𝗮𝗻 𝗰𝘂𝘁 𝘆𝗼𝘂𝗿 𝗺𝗲𝗺𝗼𝗿𝘆 𝘂𝘀𝗮𝗴𝗲 𝗯𝘆 𝟰𝟬-𝟲𝟬%. Here's why this matters in ML/AI applications: 𝗪𝗶𝘁𝗵𝗼𝘂𝘁 __𝘀𝗹𝗼𝘁𝘀__: class DataPoint: def __init__(self, x, y, features): self.x = x self.y = y self.features = features 𝗘𝗮𝗰𝗵 𝗶𝗻𝘀𝘁𝗮𝗻𝗰𝗲 𝘀𝘁𝗼𝗿𝗲𝘀 𝗮𝘁𝘁𝗿𝗶𝗯𝘂𝘁𝗲𝘀 𝗶𝗻 𝗮 𝗱𝗶𝗰𝘁𝗶𝗼𝗻𝗮𝗿𝘆 → ~𝟮𝟴𝟬 𝗯𝘆𝘁𝗲𝘀 𝗽𝗲𝗿 𝗼𝗯𝗷𝗲𝗰𝘁 𝗪𝗶𝘁𝗵 __𝘀𝗹𝗼𝘁𝘀__: class DataPoint: __slots__ = ['x', 'y', 'features'] def __init__(self, x, y, features): self.x = x self.y = y self.features = features 𝗔𝘁𝘁𝗿𝗶𝗯𝘂𝘁𝗲𝘀 𝘀𝘁𝗼𝗿𝗲𝗱 𝗶𝗻 𝗳𝗶𝘅𝗲𝗱 𝘀𝘁𝗿𝘂𝗰𝘁𝘂𝗿𝗲 → ~𝟭𝟮𝟬 𝗯𝘆𝘁𝗲𝘀 𝗽𝗲𝗿 𝗼𝗯𝗷𝗲𝗰𝘁 Real impact on ML workflows: • Training with 1M+ data points? Save ~160MB instantly • Faster attribute access (15-20% speed boost) • Cleaner memory profiling during model training 𝗧𝗵𝗲 𝗰𝗮𝘁𝗰𝗵? → No dynamic attribute addition → Inheritance becomes trickier → Can't use with multiple inheritance easily When building ML pipelines with massive datasets, this optimization can be the difference between smooth training and memory crashes. Have you used __slots__ in your Python projects? What memory optimization tricks do you swear by? 🔧 #Python #MachineLearning #PerformanceOptimization

🌦️ Built one more script using Python - **DuckDuckGo Top Search Result CLI Tool** (last project of edureka). I made a script using Python that fetches real-time top search result data of DuckDuckGo search engine for any query using "ddgs library of python" as one of the final project given by Edureka The program accepts a argument as query to search in duckduckgo search engine, and returns the required top search results, not only title and urls - it will provide you the top videos and all corresponding details like published_date, publisher, embed_urls, thumbnail_images of different resolutions and many more and at last you can save these data in a file. Tech Used: Python, JSON parsing, duckduckgo-search (ddgs), AsyncIO Features: ✅ accepting query by CLI ✅ current top required search results ✅ You can choose how many results you want to fetch ✅ Get all data - Title, URL, Publisher, Publishing date, images, Provider, Uploader, Video urls and many more ✅ Facility to save these data into a file (with the timestamp and the query) ✅ Clean terminal formatting ✅ Async execution for better structure This project strengthened my understanding of working with external services, handling responses, and building practical automation tools. All scripts available in my github profile - https://lnkd.in/gJGmqXme