Susmitha Chakrala’s Post

🐍 3 Python Built-ins That Look Simple… But Are More Powerful Than They Seem One thing I appreciate about Python is how some of the most useful tools look deceptively simple. At first glance, they seem basic. But once you understand the one feature that really matters, they become incredibly practical in real projects. Here are 3 built-ins that quietly make Python code cleaner and more expressive. 🔢 1. sorted() — More Than Just Sorting Numbers Most people think sorted() is mainly for sorting numbers or strings. But the real power comes from key=. In real applications, you're rarely sorting plain numbers. Instead, you're sorting things like: 👤 Users 📋 Tasks 📁 Files 📦 Dictionaries The key parameter tells Python which part of each item should determine the order. Examples in real projects: ✔️ Sort users by age ✔️ Sort tasks by priority ✔️ Sort files by modification date Instead of restructuring your data or writing extra logic, sorted() lets you clearly express how your data should be ordered. 🔗 2. zip() — Pair Related Data Cleanly A very common pattern looks like this: names[i] ages[i] It works… but it also means manually managing indexes. zip() removes that extra work. It lets you iterate through related values together, without worrying about positions. Example scenarios: 👤 Names + ages 🛒 Products + prices 📅 Dates + sales numbers Another benefit: if the lists have different lengths, zip() automatically stops at the shortest one. The result? ✔️ Less indexing ✔️ Cleaner loops ✔️ Easier-to-read code 🔁 3. enumerate() — When You Need Index + Value You’ve probably seen this pattern before: for i in range(len(items)): It works, but it’s not the cleanest approach. enumerate() already gives you both the index and the value in one step. This makes loops much more natural. Common use cases include: 📋 Printing numbered lists 📊 Tracking item positions 🧭 Working with ordered data A small change—but it often makes loops simpler and clearer. 💡 The Bigger Lesson Many Python built-ins are like this. They look simple at first, so people only use them at a surface level. But once you understand the feature that really matters, your code becomes: ✔️ clearer ✔️ shorter ✔️ easier to reason about And that’s a pretty good trade. 💬 Which Python built-in improved your code the most once you truly understood it? #Python #Programming #SoftwareEngineering #PythonTips #CleanCode #DeveloperProductivity #CodingTips

💡 Python Exception Handling: Writing More Reliable Code While writing programs in Python, errors can sometimes occur during execution. These are known as runtime errors, such as: • Dividing by zero • Entering an invalid data type • Trying to open a file that does not exist If not handled properly, these errors may stop the program unexpectedly. Exception handling helps manage such situations gracefully. 1️⃣ Basic try/except Code that may cause an error is placed inside the try block. If an error occurs, the except block runs instead of stopping the program. Example: try: number = int(input("Enter a number: ")) print(1000 / number) except: print("An error occurred") ➡️ The program tries to convert the input and divide 1000 by it. If the input is invalid or 0, the except block runs instead of crashing. 2️⃣ Handling specific exceptions We can handle different errors separately. Example: try: number = int(input("Enter a number: ")) result = 1000 / number except ValueError: print("Invalid input") except ZeroDivisionError: print("Cannot divide by zero") This example handles different types of errors separately. ➡️ If the user enters an invalid value, a ValueError occurs. ➡️ If the user enters 0, a ZeroDivisionError occurs. 3️⃣ Using else The else block runs only if no exception occurs. Example: try: number = int(input("Enter number: ")) result = 1000 / number except ZeroDivisionError: print("Cannot divide by zero") else: print("Result is:", result) ➡️ This separates normal logic from error handling. 4️⃣ Using finally The finally block runs whether an exception occurs or not. Example: file = None try: file = open("data.txt", "r") print("File opened successfully") except FileNotFoundError: print("The file does not exist") finally: if file: file.close() print("File closed") ➡️ file is first set to None, meaning the variable exists but is not linked to a file yet. ➡️ The program tries to open data.txt. If the file is opened successfully, a message is printed. ➡️ If the file does not exist, a FileNotFoundError occurs and the except block runs. ➡️ The finally block always runs and ensures the file is closed if it was opened. 🔹 The finally block is commonly used for cleanup tasks such as closing files, database connections, or releasing system resources. 5️⃣ Capturing the error message Example: try: x = 10 / 0 except Exception as e: print("Error:", e) ➡️ The error message is stored in e, which helps in debugging. 🔹 Summary try and except make Python programs more robust by preventing crashes and handling unexpected situations properly. #Python #Programming #AI #DataAnalytics #ExceptionHandling #Coding

In Python, what is the difference between mutable and immutable variables? And how does this affect data handling inside functions? 🔹 First: What does Mutable vs Immutable mean? In Python, everything is an object. The key difference is whether the object can be changed after it is created. ✅ Immutable Objects An immutable object cannot be modified after creation. If you try to change it, Python creates a new object instead. Examples: • int • float • str • tuple Example: y = 3.5 y = y * 2 print(y) ➡️ Output: 7.0 Here, Python does not modify 3.5. It creates a new float object 7.0 and reassigns y to it. ✅ Mutable Objects A mutable object can be modified after creation without creating a new object. Examples: • list • dict • set Example: list = [1, 2, 3] list.append(4) print(list) ➡️ Output: [1, 2, 3, 4] Here, Python modifies the same list object in memory. 🔎 How Does This Affect Functions? This difference becomes very important when passing objects to functions. 1️⃣ Case 1: Immutable Inside a Function def change_text(text): text = text + "!" word = "Hi" change_text(word) print(word) ➡️ Output: Hi 🔹Explanation • word = "Hi" creates a string object "Hi" in memory. • When we call change_text(word), the function receives a reference to the same object. • Inside the function, text = text + "!" does NOT modify "Hi" because strings are immutable. • Python creates a new string "Hi!" and makes text refer to it. • The original variable word still refers to "Hi". ➡️ That’s why print(word) outputs "Hi". 2️⃣ Case 2: Mutable Inside a Function def remove_last(numbers): numbers.pop() values = [10, 20, 30] remove_last(values) print(values) ➡️ Output: [10, 20] 🔹Explanation • values = [10, 20, 30] creates a list object in memory. • When we call remove_last(values), the function receives a reference to the same list. • Inside the function, numbers.pop() removes the last element from the same list object in memory. • Since lists are mutable, Python modifies the existing object instead of creating a new list. • Both values and numbers point to that same list, so the change appears outside the function as well. ➡️ That’s why print(values) outputs [10, 20]. 🔎 Core Concept • Immutable objects cannot be changed in place. • Mutable objects can be modified directly. • When passing mutable objects to functions, changes inside the function affect the original data. • When passing immutable objects, changes inside the function do not affect the original variable. 🔹Why This Matters in AI & Analytics When working with datasets and AI pipelines, modifying a mutable object can unintentionally change your original data. Understanding mutability helps you avoid bugs and write more predictable, reliable code. #Python #Programming #AI #DataScience #MachineLearning #AIandAnalytics

• Day 30/30 Today I learned about Python File Handling Methods, which are used to work with files such as reading, writing, updating, and managing file content. File handling is very important because it allows us to store data permanently instead of keeping it only in memory while the program runs. 🔸 Common Python File Methods • open(): The close() method is used to close a file after use. It is important because it ensures that resources are released properly. file = open("sample.txt", "r") print(file) file.close() • read(): The read() method is used to read the entire content of a file at once. It is useful when we want to access all the text stored inside a file. with open("sample.txt", "r") as file: print(file.read()) • readline(): The readline() method reads one line at a time from the file. It is useful when working with large files. with open("sample.txt", "r") as file: print(file.readline()) • readlines(): The readlines() method reads all lines of a file and stores them in a list. Each line becomes a separate list element. This is helpful when we want to process file data line by line using loops. with open("sample.txt", "r") as file: print(file.readlines()) • write(): The write() method is used to write data into a file. If the file is opened in write mode, it will overwrite the existing content. This method is useful for saving text or program output into a file. with open("sample.txt", "w") as file: file.write("Hello Python") • writelines(): The writelines() method is used to write multiple lines into a file at once. It takes a list of strings and writes them to the file. This is useful when saving structured text data. lines = ["Python\n", "File Handling\n", "Methods\n"] with open("sample.txt", "w") as file: file.writelines(lines) • close(): The close() method is used to close a file after use. It is important because it ensures that resources are released properly. file = open("sample.txt", "r") file.close() print("File closed") • flush(): The readline() method reads one line at a time from the file. It is useful when working with large files. file = open("sample.txt", "w") file.write("Data saved") file.flush() file.close() • seek(): The flush() method forces the file buffer to write data immediately into the file without closing it. This is useful when we want to ensure that the data is saved instantly. with open("sample.txt", "r") as file: file.seek(0) print(file.read()) • tell(): The seek() method is used to move the file pointer to a specific position. This allows us to read or write from a particular point in the file. It is useful for random file access. print(file.tell()) When opening a file, Python uses different modes depending on the operation: "r" → Read mode "w" → Write mode "a" → Append mode "x" → Create mode "b" → Binary mode "t" → Text mode (default) #Python #File_Handling #BengaluruStudents #BangaloreIT #BTMLayout #fortunecloud Fortune Cloud Technologies Private Limited

🧙♂️ Magic Methods in Python (Dunder Methods) Python is known for its powerful and flexible object-oriented features. One of the most interesting concepts in Python is Magic Methods, also called Dunder Methods (Double Underscore Methods). Magic methods allow developers to define how objects behave with built-in operations such as addition, printing, comparison, and more. These methods always start and end with double underscores (__). Example: __init__ __str__ __add__ __len__ They are automatically called by Python when certain operations are performed. --- 🔹 Why Magic Methods are Important? Magic methods help to: ✔ Customize the behavior of objects ✔ Make classes behave like built-in types ✔ Improve code readability ✔ Implement operator overloading They allow developers to write clean, powerful, and Pythonic code. --- 🔹 Commonly Used Magic Methods 1️⃣ __init__ – Constructor This method is automatically called when an object is created. class Student: def __init__(self, name): self.name = name s = Student("Vamshi") --- 2️⃣ __str__ – String Representation Defines what should be displayed when we print the object. class Student: def __init__(self, name): self.name = name def __str__(self): return f"Student name is {self.name}" s = Student("Vamshi") print(s) --- 3️⃣ __len__ – Length of Object Allows objects to work with the len() function. class Team: def __init__(self, members): self.members = members def __len__(self): return len(self.members) t = Team(["A", "B", "C"]) print(len(t)) 4️⃣ __add__ – Operator Overloading Defines how the + operator works for objects. class Number: def __init__(self, value): self.value = value def __add__(self, other): return self.value + other.value n1 = Number(10) n2 = Number(20) print(n1 + n2) 🔹 Key Takeaway Magic methods make Python classes more powerful and flexible by allowing objects to interact naturally with Python's built-in operations. Understanding magic methods helps developers write cleaner and more advanced object-oriented programs. #Python #PythonProgramming #MagicMethods #DunderMethods #OOP #Coding #LearnPython #SoftwareDevelopment

🚀 **Mastering Error Handling in Python: A Key Skill for Data Analysts** Podcast: https://lnkd.in/g_n2z_KS Errors are a natural part of programming. What separates beginner programmers from confident developers is the ability to **handle errors effectively**. In Python, understanding error handling can make your code more stable, readable, and reliable, especially when working in **data analysis workflows**. When writing Python programs, developers often encounter several common errors. These include **SyntaxError**, which occurs when code violates Python’s syntax rules, and **NameError**, raised when a variable or function is used before it is defined. Another frequent issue is **TypeError**, which appears when operations are performed on incompatible data types, such as adding a string and an integer. Other errors also appear frequently in data-driven scripts. **IndexError** occurs when trying to access a list element outside its valid range. **KeyError** happens when attempting to retrieve a dictionary value using a key that does not exist. Similarly, **AttributeError** arises when a program attempts to access an attribute that an object does not possess. Understanding these error types helps developers quickly identify the root cause of problems. Debugging is the process used to locate and fix such errors. One simple but effective method is the use of **print statements** to monitor variable values and program flow. Modern development environments such as **VS Code or PyCharm** also provide debugging tools that allow programmers to set breakpoints and inspect variables step by step. Carefully reading Python’s error messages is also important because they often provide precise clues about where and why a problem occurred. Some developers even use the well-known **rubber duck debugging method**, explaining their code aloud to clarify logic and identify mistakes. A powerful feature in Python for managing errors is the **try and except block**. This structure allows a program to attempt execution of code while safely handling any exceptions that occur. For example, when dividing numbers, a `ZeroDivisionError` may appear if the denominator is zero. Using a try and except block allows the program to catch this error and respond with a helpful message instead of crashing. Python also supports **multiple exception handlers**, allowing different errors to be handled separately. Additionally, the **else clause** runs code only when no exception occurs, while the **finally clause** executes regardless of whether an error happens. This is particularly useful when cleaning up resources such as closing files or database connections. #Python #DataAnalysis #Programming #PythonLearning #CodingTips #Debugging #SoftwareDevelopment

Build Microsoft Foundry Agents with Python SDK: Part 1: AGENTIC AI Set up agents from scratch, add tools, install guardrails, etc. Introduction As the title suggests, we will be learning how to create agents using Foundry’s python SDK. Before we begin, some of you may ask — what’s wrong with using the Foundry UI to create agents? The simple answer is — Nothing really. In fact I urge you to try creating an agent using a few clicks on the Foundry UI to understand where to see: * the instructions (and use AI to even write them instead of starting from scratch). For instance, here I am explicitly forcing a guided approach for my researcher-agent, where the agent must identify and get the topics approved before it starts generating them. Use AI to write the instructions for an agent * the version (and compare different agent versions to see which offers the best output). On the left, latest v7 version: the agent uses the web search tool and follows our instructions to confirm the topics with the end users first before it starts generating the research report ; whereas in the older v1 version on the right, it lacked access to any tool and it would start producing an output from the get go without a human-in-the-loop to verify the topics first. Compare different versions of an agent with the same input * the run trace to assess the input/output/tooluse, etc. This is highly beneficial for debugging agent responses if they lack quality, decent latency, or showcase signs of hallucinations. Run traces for each agent interaction Once you’ve had a good look and feel of the playground, you are ready to move onto the next step. While you can keep using the platform’s UI for manual agent creation, the Foundry SDK allows for automation, scalability and integration into your own application. In more practical terms, there are a few things that can only be done via the SDK: * implementing custom functions as tools (for example: get_user_info()to let the agent fetch a user’s record before further processing). * enriching traces with metadata (for example: adding custom attributes like customer_tier: “gold” programatically to filter traces in portal to find specifically why “gold” tier users are experiencing high latency) * logging client-side traces (for ex: user_id, app_version, retries, queuing, time spent waiting before you even call responses.create()) and merging them with server side traces (response time, error rate, intermediate steps by agent, tool call, etc). Since the UI portal allows out-of-box access to server-side traces only i.e. what’s happening on the cloud platform, without the SDK, your app’s logic and foundry portal’s traces are two separate puzzles that don’t fit together. (for ex: when something goes wrong, Foundry’s server trace won’t tell you which user workflow, which app version, or which feature flag produced the call). Later on in Part 2,… #genai #shared #ai