SHREYA SARVAN MASANAM’s Post

1: Everything is an object? In the world of Python, (an integer, a string, a list , or even a function) are all treated as an objects. This is what makes Python so flexible but introduces specific behaviors regarding memory management and data integrity that must be will known for each developer. 2: ID and type: Every object has 3 components: identity, type, and value. - Identity: The object's address in memory, it can be retrieved by using id() function. - Type: Defines what the object can do and what values could be hold. *a = [1, 2, 3] print(id(a)) print(type(a)) 3: Mutable Objects: Contents can be changed after they're created without changing their identity. E.x. lists, dictionaries, sets, and byte arrays. *l1 = [1, 2, 3] l2 = l1 l1.append(4) print(l2) 4: Immutable Objects: Once it is created, it can't be changed. If you try to modify it, Python create new object with a new identity. This includes integers, floats, strings, tuples, frozensets, and bytes. *s1 = "Holberton" s2 = s1 s1 = s1 + "school" print(s2) 5: why it matters? and how Python treats objects? The distinction between them dictates how Python manages memory. Python uses integer interning (pre-allocating small integers between -5 and 256) and string interning for performance. However, it is matter because aliasing (two variables pointing to the same object) can lead to bugs. Understanding this allows you to choose the right data structure. 6: Passing Arguments to Functions: "Call by Assignment." is a mechanism used by Python. When you pass an argument to a function, Python passes the reference to the object. - Mutable: If you pass a list to a function and modify it inside, the change persists outside because the function operated on the original memory address. - Immutable: If you pass a string and modify it inside, the function creates a local copy, leaving the original external variable untouched. *def increment(n, l): n += 1 l.append(1) val = 10 my_list = [10] increment(val, my_list) print(val) print(my_list) *: Indicates an examples. I didn't involve the output, you can try it!

Python 3: Mutable, Immutable... Everything Is Object Python treats everything as an object. A variable is not a box that stores a value directly; it is a name bound to an object. That is why assignment, comparison, and updates can behave differently depending on the type of object involved. For example, a = 10; b = a means both names refer to the same integer object, while l1 = [1, 2]; l2 = l1 means both names refer to the same list object. Many Python surprises come from object identity and mutability. Two built-in functions are essential when studying objects: id() and type(). type() tells us the class of an object, while id() gives its identity in the current runtime. Example: a = 3; b = a; print(type(a)) prints <class 'int'>, and print(a is b) prints True because both names point to the same object. By contrast, l1 = [1, 2, 3]; l2 = [1, 2, 3] gives l1 == l2 as True but l1 is l2 as False. Equality checks value, but identity checks whether two names point to the exact same object. Mutable objects can be changed after they are created. Lists, dictionaries, and sets are common mutable types. If two variables reference the same mutable object, a change through one name is visible through the other. Example: l1 = [1, 2, 3]; l2 = l1; l1.append(4); print(l2) outputs [1, 2, 3, 4]. The list changed in place, and both names still point to that same list. Immutable objects cannot be changed after creation. Integers, strings, booleans, and tuples are common immutable types. If an immutable object seems to change, Python actually creates a new object and rebinds the variable. Example: a = 1; a = a + 1 does not modify the original 1; it creates 2 and binds a to it. The same happens with strings: s = "Hi"; s = s + "!" creates a new string. Tuples are also immutable: (1) is just the integer 1, while (1,) is a tuple. This matters because Python treats mutable and immutable objects differently during updates. l1.append(4) mutates a list in place, but l1 = l1 + [4] creates a new list and reassigns the name. With immutable objects, operations produce a new object rather than changing the existing one. That is why == is for value and is is for identity, especially checks like x is None. Arguments in Python are passed as object references. A function receives a reference to the same object, not a copy. That means behavior depends on whether the function mutates the object or simply rebinds a local name. Example: def add(x): x.append(4) changes the original list. But def inc(n): n += 1 does not change the caller’s integer because integers are immutable and the local variable is rebound. From the advanced tasks, I also learned that CPython may reuse some constant objects such as small integers and empty tuples as an optimization. That helps explain identity results, but it also reinforces the rule: never rely on is for value comparison when == is what you mean.

Lists in Python A versatile data structure used to store multiple items in a single variable. 🎯 1. What is a List? Lists are ordered, mutable collections of items that allow duplicate elements. They are defined using square brackets []. 🎯 2. Creating a List A list by placing comma-separated values inside square brackets. python # Example my_list = [1, "Hello", 3.14, True] 🎯 3. Accessing List Elements & Indexing zero-based indexing to access elements. python # Example fruits = ["apple", "banana", "cherry"] print(fruits[0]) # First element print(fruits[-1]) # Last element 🎯 4. List Slicing Access a range of elements Syntax [start:stop:step]. python # Example numbers = [10, 20, 30, 40, 50, 60] print(numbers[1:4]) # From index 1 up to (but not including) 4 print(numbers[::-1]) # Reverse the list Output: [20, 30, 40] [60, 50, 40, 30, 20, 10] 🎯 5. Modifying Lists Lists are mutable, meaning you can change their items. python # Example fruits = ["apple", "banana", "cherry"] fruits[1] = "blueberry" # Change index 1 print(fruits) Output: [apple, blueberry, cherry] 🎯 6. List Methods append() : Adds an item to the end. python fruits.append("orange") insert() : Adds an item at a specific position. python fruits.insert(1, "mango") remove() : Removes the first occurrence of a specific value. python fruits.remove("banana") pop() : Removes and returns an item at a specific index (or the last item if no index is specified). python last_item = fruits.pop() sort() : Sorts the list in place. 🎯 List Comprehensions A list comprehension offers a concise way to create lists in Python based on existing lists or iterables. Basic Syntax: new_list = [expression for item in iterable if condition] 🎯 1. Creating a List of Squares Instead of using a for loop to append squares, you can do it in one line. python # Traditional loop squares = [] for x in range(1, 6): squares.append(x*2) 🎯 List comprehension squares = [x*2 for x in range(1, 6)] print(squares) Output: [1, 4, 9, 16, 25] 🎯 2. Filtering with if Condition You can add a condition to filter elements from the original list. python numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] # Get only even numbers evens = [x for x in numbers if x % 2 == 0] print(evens) Output: [2, 4, 6, 8, 10] 🎯 3. Transforming Strings You can apply string methods like .upper() during creation. python fruits = ["apple", "banana", "cherry"] # Convert all to uppercase upper_fruits = [fruit.upper() for fruit in fruits] print(upper_fruits) Output: ['APPLE', 'BANANA', 'CHERRY'] 🎯 4. Flattening a Nested List This is a highly efficient way to turn a list of lists into a single flat list. python nested_list = [[1, 2], [3, 4], [5, 6]] # Flatten the list flatlist = [item for sublist in nestedlist for item in sublist] print(flat_list) Output: [1, 2, 3, 4, 5, 6] #PythonProgramming #PythonList #DataScience #CodingTips #PythonTutorial #SoftwareDevelopment #Programming

Day 23: Comprehensions — The "Pythonic" Way to Code ⚡ A Comprehension is a shorthand way to create a new collection (List, Dictionary, or Set) based on an existing one. It combines a for loop and an if statement into a single line. 1. List Comprehensions: The Standard Instead of creating an empty list and using .append(), you define the list's content in place. ❌ The Rookie Way: squares = [] for x in range(10):   squares.append(x * x) ✅ The Pythonic Way: squares = [x * x for x in range(10)] 💡 The Engineering Lens: Comprehensions are actually slightly faster than for loops because they run at "C speed" inside the Python interpreter. However, if your comprehension is longer than one line, it’s better to use a regular loop for readability. 2. Adding Logic: The "if" Filter You can filter data while you build the list. Example: Create a list of even numbers only. evens = [n for n in range(20) if n % 2 == 0] 3. Dictionary Comprehensions You can build a key-value map just as easily. Example: Mapping names to their lengths. names = ["Alice", "Bob", "Charlie"] name_lengths = {name: len(name) for name in names} # Result: {'Alice': 5, 'Bob': 3, 'Charlie': 7} 4. Set Comprehensions Exactly like list comprehensions, but using {} to ensure all items are unique. Example: Getting unique file extensions from a list of files. files = ["test.py", "main.py", "data.csv", "script.py"] extensions = {f.split(".")[-1] for f in files} # Result: {'py', 'csv'} 💡 The "Clean Code" Rule of Thumb: Just because you can do it in one line doesn't mean you should. Do use it for: Simple transformations and filtering. Don't use it for: Complex logic with multiple if/else statements or "Nested Comprehensions" (a loop inside a loop). If another engineer has to read it three times to understand it, use a standard for loop instead. #Python #SoftwareEngineering #CleanCode #Pythonic #ProgrammingTips #LearnToCode #TechCommunity #DataScience #CodingEfficiency

Python3: Mutable, Immutable… Everything is an Object! Introduction : In Python, everything is an object. This fundamental idea shapes how variables behave, how memory is managed, and how data flows through your programs. Understanding the difference between mutable and immutable objects is essential for writing predictable and efficient code. In this post, I’ll walk through object identity, types, mutability, and how Python handles function arguments—with concrete examples. Id and Type : Every Object in Python has: an identity (its memory address) - a type (what kind of object it is) - a value You can inspect these using id() and type(): x=10 print(id(x)) # unique identifier (memory address) print(type(x)) # <class 'int'> Example Output : 140734347123456 <class 'int'> Two variables can point to the same object: a = 5 b = a print(id(a)) print(id(b)) Both a and b will have the same id, meaning they reference the same object. MUTABLE OBJECTS : Mutable objects can be changed after they are created without changing their identity. Common mutable types: List , dict , set Example: my_list = [1, 2, 3] print(id(my_list)) my_list.append(4) print(my_list) print(id(my_list)) # same id! Output: [1, 2, 3, 4] The content changed, but the memory address stayed the same. Another example with dictionaries: d = {"a": 1} d["b"] = 2 print(d) # {'a': 1, 'b': 2} IMMUTABLE OBJECTS: Immutable objects cannot be modified after creation. Any "change" actually creates a new object. Common immutable types: int , float , str , tuple Example: x = 10 print(id(x)) x = x + 1 print(id(x)) # different id! Output: 140734347123456 140734347123999  A new object is created instead of modifying the old one. String example: s = "hello" print(id(s)) s += " world" print(id(s)) Again, a new object is created. Why does it matter? Understanding mutability helps avoid unexpected bugs. Example problem: list1 = [1, 2, 3] list2 = list1 list2.append(4) print(list1) # [1, 2, 3, 4] Both variables changed because they reference the same object. To avoid this: list2 = list1.copy() Now they are independent. HOW ARGUMENTS ARE PASSED TO FUNCTIONS Python uses pass-by-object-reference (or “call by sharing”). With immutable objects: def add_one(x):   x += 1   print("Inside:", x) a = 5 add_one(a) print("Outside:", a) Output: Inside: 6 Outside: 5 The original value is unchanged. With mutable objects: def add_item(lst):   lst.append(4)   print("Inside:", lst) my_list = [1, 2, 3] add_item(my_list) print("Outside:", my_list) Output: Inside: [1, 2, 3, 4] Outside: [1, 2, 3, 4] The original object is modified. IMPORT IMPLICATION If you don’t want a function to modify your data: def safe_modify(lst):   lst = lst.copy()   lst.append(4)   return lst Understanding mutable vs immutable objects is crucial in Python because it directly affects: memory behavior , variable assignment , function side effects

Day 10 – Mastering Sliding Window (Python 30 Days Revision Series) Sliding Window ek powerful technique hai jisse hum O(n²) ke brute force ko O(n) me convert kar sakte hain. Aaj ke 3 high-quality problems freshers + MNC interview dono ke liye perfect hain. 🧩 Problem 1: Maximum Sum Subarray of Size K Given: An array and a number k, return the maximum sum of any contiguous subarray of size k. ✅ Approach (Sliding Window) Pehle k elements ka sum nikalo Window aage slide karo: Remove left element Add new right element Har iteration me max update karo ✅ Python Code def max_sum_k(arr, k): curr = sum(arr[:k]) max_sum = curr for i in range(k, len(arr)): curr += arr[i] - arr[i - k] max_sum = max(max_sum, curr) return max_sum print(max_sum_k([2, 1, 5, 1, 3, 2], 3)) ➡ Output: 9 🧩 Problem 2: Longest Substring Without Repeating Characters Given: A string Return: Length of longest substring with all unique characters. ✅ Approach (Sliding Window + HashSet) Ek window maintain karo jisme sab characters unique ho Duplicate mile → left pointer move karo until removed Right pointer har step me aage badhta hai ✅ Python Code def longest_unique(s): seen = set() left = 0 longest = 0 for right in range(len(s)): while s[right] in seen: seen.remove(s[left]) left += 1 seen.add(s[right]) longest = max(longest, right - left + 1) return longest print(longest_unique("abcabcbb")) ➡ Output: 3 🧩 Problem 3: Minimum Window Substring (Hard Level) Given: Strings s and t Goal: Find the smallest window in s that contains all characters of t. ✅ Approach Two hashmaps: need & window Expand until all required chars are included Contract window to make it minimum This is one of the most asked MNC questions (Amazon/Google) ✅ Python Code from collections import Counter def min_window(s, t): need = Counter(t) have = {} left = 0 need_count = len(t) res = (float('inf'), 0, 0) for right, char in enumerate(s): have[char] = have.get(char, 0) + 1 if need.get(char, 0) >= have[char]: need_count -= 1 while need_count == 0: if right - left + 1 < res[0]: res = (right - left + 1, left, right) have[s[left]] -= 1 if need.get(s[left], 0) > have[s[left]]: need_count += 1 left += 1 length, l, r = res return s[l:r+1] if length != float('inf') else "" print(min_window("ADOBECODEBANC", "ABC")) ➡ Output: "BANC"

Python Prototypes vs. Production Systems: Lessons in Logic Rigor 🛠️ This week, I stopped trying to write code that "just works" and started writing code that refuses to crash. As an aspiring Data Scientist, I’m learning that stakeholders don’t just care about the output—they care about uptime. If a single "typo" from a user kills your entire analytics pipeline, your system isn't ready for the real world. Here are the 4 "Industry Veteran" shifts I made to my latest Python project: 1. EAFP over LBYL (Stop "Looking Before You Leap") In Python, we often use if statements to check every possible error (Look Before You Leap). But a "Senior" approach often favors EAFP (Easier to Ask for Forgiveness than Permission) using try/except blocks. Why? if statements become "spaghetti" when checking for types, ranges, and existence all at once. Rigor: A try block handles the "ABC" input in a float field immediately, keeping the logic clean and the performance high. 2. The .get() Method: Killing the KeyError Directly indexing a dictionary with prices[item] is a ticking time bomb. If the key is missing, the program dies. The Fix: I’ve switched to .get(item, 0.0). This allows for a "Default Value" fallback in a single line, preventing "Dictionary Sparsity" from breaking my calculations. 3. Preventing the "System Crush" Stakeholders hate downtime. I implemented a while True loop combined with try/except for all user inputs. The Goal: The program should never end unless the user explicitly chooses to "Quit." Every "bad" input now triggers a helpful re-prompt instead of a system failure. 4. Precision in Data Type Conversion Logic errors often hide in the "Conversion Chain." I focused on the transition from String (from input()) to Int (for indexing). The Off-by-One Risk: Users think in "1-based" counting, but Python is "0-based." I’ve made it a rule to always subtract 1 from the integer input immediately to ensure the correct data point is retrieved every time. The Lesson: Coding is about the architecture of the "Why" just as much as the syntax of the "What." [https://lnkd.in/gvtiAKUb] #Python #DataScience #CodingJourney #CleanCode #BuildInPublic #SoftwareEngineering #SeniorDataScientist #TechMentor

Day 26 of my Python journey — going deeper into classes with classmethods, staticmethods, and the factory pattern. Yesterday I learned the fundamentals of classes and objects. Today I learned the tools that make classes flexible, reusable, and production-ready. @classmethod — alternative constructors and class-level operations class Student:   total_students = 0   def __init__(self, name: str, roll: int, marks: list):     self.name = name     self.roll = roll     self.marks = marks     Student.total_students += 1   @classmethod   def from_csv_row(cls, row: str) -> "Student":     """Create a Student from a CSV string: 'Rahul,101,87,92,78'"""     parts   = row.split(",")     name, roll = parts[0], int(parts[1])     marks   = [int(m) for m in parts[2:]]     return cls(name, roll, marks)   @classmethod   def get_total(cls) -> int:     return cls.total_students # Two ways to create the same object s1 = Student("Rahul", 101, [87, 92, 78]) s2 = Student.from_csv_row("Priya,102,94,88,91") The from_csv_row method is called a factory method. It creates an object from a different input format — a string — without the caller needing to know how to parse it. This pattern is used throughout Python's standard library: datetime.fromisoformat(), int.from_bytes(), Path.from_uri(). @staticmethod — utility functions that belong to the class but need no instance @staticmethod def validate_marks(marks: list) -> bool:   """Returns True if all marks are in range 0-100."""   return all(0 <= m <= 100 for m in marks) A staticmethod has no self and no cls — it cannot access the instance or the class. It is a pure function that lives inside the class because it is logically related to it. Validation functions, format converters, and helper calculations are natural staticmethods. @classmethod vs @staticmethod — when to use which Use @classmethod when the method needs to create, modify, or inspect the class itself — or create instances of it. Use @staticmethod when the method is logically related to the class but needs neither instance data nor class data. __eq__ — defining what equality means for your objects def __eq__(self, other: "Student") -> bool:   return self.roll == other.roll Without this: s1 == s2 compares memory addresses — almost always False. With this: s1 == s2 compares roll numbers — the meaningful definition of "same student." Classes are becoming genuinely powerful. #Python#Day26#ConditionalLogic#SelfLearning#CodewithHarry#PythonBasics#w3schools.com#W3Schools

 Three months ago, our agent cited Python 3.13 as the latest stable release in a research report. It was wrong — 3.12 was current at the time.  The factcheck caught it. Corrected the report.  That part isn't remarkable. Any review process would catch that.  What happened next is the part that matters: the agent stored a lesson. Not the corrected fact — the lesson about the mistake itself. "Always verify version numbers against the official release page. Don't  rely on training data for anything with a release cycle."  Two weeks later, I asked it to research a completely different tool. The vector memory surfaced that lesson during pre-search. The agent went straight to the official changelog before writing a single  sentence about version compatibility.  Nobody told it to. It remembered why it had been wrong before.  This is the self-improvement loop I've been building toward in this series. Previous posts covered the infrastructure — four memory types, four storage systems, routing, retrieval. This post is about what it enables: an agent that gets better without being retrained.  The loop:  1. Agent produces output  2. Factcheck or human review finds an error  3. The correction gets saved — not just the right answer, but the lesson: what went wrong and how to avoid it  4. Next time, pre-search surfaces the lesson before the agent starts working  The key word is "lesson." We don't store "Python 3.12 is correct." We store "version numbers from training data are unreliable — always check the source." One is a fact that expires. The other is a behavior  that compounds.  The same loop runs on human feedback.  I told the agent: "Don't mock the database in integration tests." Instead of losing that correction after the session, the agent saved it with structure — what was corrected, why it was wrong, how to apply it in the future.  That's a feedback memory. Next time it writes integration tests — in any project, any session — it retrieves the lesson and applies it. Over time, these accumulate into working knowledge about how to do the  job correctly.  Does it work? In the first 20 research sessions, the agent averaged 3.2 factcheck corrections per report. After 80+ sessions with the lesson loop: 0.8.  Not zero. But the same category of mistake rarely happens twice. Version numbers, citation formats, API accuracy — each corrected once, stored as a lesson, applied going forward. No fine-tuning, no  retraining. The model is the same. The memory layer is what improved.  The deeper insight: the agent doesn't just store information. It stores lessons about how to handle information. Facts expire. Lessons compound.  What's the most repeated mistake your agent makes — the one you keep correcting but it never sticks?  #AIAgents #AgentArchitecture #SelfImprovingAI

Same language. Four completely different power levels. 🐍 This is every Python developer's journey. And if you're still in panel 1, let me tell you what nobody else will 👇 💭 PANEL 1: BASIC CODING x = 10 print("Hello") You're sweating. Python looks friendly but feels impossible. The snake is tiny but you're terrified. Why? Because you're thinking like a human trying to talk to a machine. Reality: Everyone starts here. Everyone struggles. The snake stays small until you feed it. 📊 🎯 PANEL 2: LEARNING PYTHON def greeting(): print(x) Now it clicks. Functions make sense. Imports make sense. The snake wraps around you like a friend. You're not fighting Python anymore. You're dancing with it. This is where most tutorials end. And where most developers get stuck thinking they "know Python." 💡 🔥 PANEL 3: USING LIBRARIES NumPy. Pandas. Requests. Pip. The snake got confident. You got powerful. You're not writing basic scripts anymore. You're manipulating datasets. Making API calls. Building real tools. This is where beginners become developers. Where code becomes solutions. ⚡ 🐉 PANEL 4: PYTHON + DJANGO + AI The snake is a BEAST now. Muscular. Unstoppable. Django for full-stack web apps. AI models. Neural networks. Production systems. You're not just using Python. You're wielding it. 🚀 💪 THE PATTERN EVERYONE MISSES Most people give up between Panel 1 and Panel 2. They see "def greeting():" and think it's too hard. They quit right before it gets easy. The snake doesn't become powerful overnight. It grows with every library you learn. Every project you build. Every bug you fix. 💭 🚨 THE UNCOMFORTABLE TRUTH Panel 1 developers and Panel 4 developers use the SAME language. The difference? One stopped at syntax. The other kept building. Python isn't hard. Stopping too early is hard. 🎯 📌 WHERE ARE YOU? Panel 1: Struggling with basics → Keep going, everyone was here Panel 2: Comfortable with syntax → Start building real projects Panel 3: Using libraries → Master 2-3 deeply, not 20 superficially Panel 4: Full stack + AI → You're not learning anymore, you're creating The snake grows with you. But only if you keep feeding it. 🔥 Which panel are you in right now? Be honest 👇 #Python #Programming #WebDevelopment #AI #MachineLearning #Django #CodingJourney #TechSkills #SoftwareDevelopment #LearnToCode