Python Loops & Iterations: Mastering Automation and Data Processing

🚀 Python Tip: Using default_factory in Dataclasses While working on a data quality framework in Python, I encountered an interesting scenario with timestamps. I wanted every new instance of my dataclass to have a fresh, current timestamp. At first, I tried this: from dataclasses import dataclass, field from datetime import datetime, timezone @dataclass class QualityCheckResult:   timestamp: datetime = datetime.now(timezone.utc) # ❌ The problem? Every instance got the same timestamp — Python evaluated it once when the class was defined. Not what I wanted! The solution: default_factory @dataclass class QualityCheckResult:   timestamp: datetime = field(default_factory=lambda: datetime.now(timezone.utc)) # ✅ Why this works: default_factory expects a callable (like a lambda or function) Python stores the callable, but doesn’t run it immediately Every time you create a new object, Python calls the lambda, producing a fresh timestamp 💡 Think of it as keeping a “recipe” instead of the finished product. Each object gets its own freshly baked “timestamp” instead of reusing the same one. This small tweak solves a subtle bug and ensures my data quality logs always reflect the exact creation time. Python’s dataclasses + default_factory = cleaner, bug-free defaults! ⚡

🌦️ 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

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.

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

Understanding == vs is in Python 🐍 In Python, == and is may look similar, but they serve very different purposes. == (Equality Operator) The == operator checks whether two values are equal. a = 10 b = 10 print(a == b) Output: True This returns True because both a and b have the same value. is (Identity Operator) The is operator checks whether two variables point to the same object in memory. Python a = 10 b = 10 print(a is b) Outpu: True This happens because Python internally reuses memory for small integers (a concept called integer interning). ⚠️ Important note: is should be used for identity checks (like comparing with None), not for value comparison. Copy code Python a = [1, 2, 3] b = [1, 2, 3] print(a == b) # True (values are equal) print(a is b) # False (different memory locations) 📌 Takeaway: Use == to compare values Use is to compare memory identity #Python #Programming beginner-friendly, shorter, or more engaging (carousel-style or with emojis), tell me — I’ll tweak it 😄 Because - 5 to 256 small integers are catchable. Example : a=257 b=257 print(a is b) Ouput: False

# Python Challenge: Reversing Inspiration 🔄 # Two manual ways to reverse "Small steps lead to big success" def reverse_letters_manual(sentence): """Reverse letters in each word using nested for loops""" reversed_sentence = "" for word in sentence.split(): reversed_word = "" # Manual reversal: start from the end of the word for i in range(len(word)-1, -1, -1): reversed_word += word[i] reversed_sentence += reversed_word + " " return reversed_sentence.strip() def reverse_words_manual(sentence): """Reverse word order using a while loop""" words = sentence.split() reversed_words = [] # Start from the last word index = len(words) - 1 while index >= 0: reversed_words.append(words[index]) index -= 1 # Move backward return " ".join(reversed_words) # Let's test it original_quote = "Small steps lead to big success" print("Original quote:", original_quote) print("\n1. Reversed letters in each word:") print(reverse_letters_manual(original_quote)) print("\n2. Reversed word order:") print(reverse_words_manual(original_quote)) print("\n3. Ultimate reversal (letters AND words):") step1 = reverse_letters_manual(original_quote) step2 = reverse_words_manual(step1) print(step2)

Python with Machine Learning — Chapter 10 📘 Topic: Python Class - Constructors 🔍 Hey there! 👋 Let’s talk about a special part of Python classes called *constructors*. They set up your objects when you first create them—like getting a new phone ready to use. Why does this matter? 🤔 Because starting objects with the right data helps your code work smoothly, especially in machine learning where every object needs correct values to make predictions. Now, let’s look at two types of constructors: 1. DEFAULT CONSTRUCTORS 🔄 - These have NO parameters (except self). - They set up basic values automatically. Example: [CODE] class Car: def __init__(self): self.color = "red" # default value print("Car created!") my_car = Car() print(f"My car is {my_car.color}") [/CODE] Here, every Car object starts as red—no extra info needed. 2. PARAMETERIZED CONSTRUCTORS 🎯 - These take parameters so you can give each object unique values. Example: [CODE] class Car: def __init__(self, color): self.color = color print(f"Car created: {self.color}") car1 = Car("blue") car2 = Car("green") [/CODE] Now each car can have its own color. Perfect for customizing objects! A QUICK NOTE: 📝 Unlike Java or C++, Python doesn’t allow “constructor overloading” (multiple versions of __init__). If you define more than one, only the LAST one works. So plan your parameters carefully! Remember, starting simple is okay. You’re doing great! 💪 Stay curious, Your coding mentor ✨

Why Python Has = and == - and Why Mixing Them Up Matters One of the first things people notice when learning Python is that it has both = and ==. They look similar, but they serve very different purposes - and confusing them can lead to subtle bugs. = - assignment The single equals sign is used to assign a value to a variable. x = 10 This means: store the value 10 in the variable x. Assignment does not ask a question. It performs an action. == - comparison The double equals sign is used to compare two values. x == 10 This means: are these two values equal? The result is always a boolean: True or False Why this distinction matters In real-world Python code, the difference becomes critical inside: - if conditions - loops - filtering logic - data validation A simple typo can completely change program behavior - or cause an error. A mental model that helps A useful way to think about it: = - put this value here == - are these two things the same? Different intent, different outcome. Common beginner pitfall if x = 10:  # SyntaxError Python prevents this mistake explicitly, which is a good thing. (Some other languages are far less forgiving.) Final thought Python is explicit by design. Having separate operators for assignment and comparison makes code clearer, safer, and easier to reason about. Understanding this early helps avoid confusion later - especially when working with conditions, data pipelines, or production logic. Have you ever seen a bug caused by confusing assignment and comparison - in Python or another language? #python #py #double_equal #comparison

Python Functions: A function is a block of organized, reusable code and that us used perform a single used and multiple tasks. Syntax: def calculate(a,b): Recurstion:In Python, recursion refers to a function calling itself to solve a problem. It involves two critical components: Base case: This is the condition that terminates the recursion. Difference between print and Return: print just stored the human user output in a control. Return:-is keyword and return used to terminate the function and gives that a value the function. Return only one time call the function because terminate the value. Keyword and positional arguments: number of values and keyword accepted to jumbling order also accepted. Default arguments: already existed non default followed. *arguments: Is used to unpack the elements only should pass single * arguments. Variable length arguments of automatically stored in tuple and used * arguments. **keywards of automatically stored in dictionary and used * arguments. Global and Local variables: A variable inside and outside function is called global and local variables. Usage of global Keywords: When user want to access the global variable inside the function directly and carry farward the updated value given outside the function then we need to used global keyword. Generators: No tuples comprehension in above cases if we remove don't spaces and key parameter than out coming generators. A generators is also a function which can be used as an loops by producing group of values, variable used yield keywords. Yield/Return: Return keyword terminate the function where as yield can pass function and go on the every function iteration Pooja Chinthakayala Mam,Saketh Kallepu Sir,Uppugundla Sairam Sir.

Mind-blowing Python fact that changes how you think about variables: In Python, values have types, but variables don't. Here's what this means: x = 25        # x is int x = 13.75     # x is now float (changed!) x = "Hello"   # x is now str (changed again!) x = [1,2,3]   # x is now list (changed again!) The same variable x can hold different types. The variable is just a label—the type comes from the value. Why this matters: Python is dynamically typed Variables are references, not fixed containers Type is determined at runtime, not declaration This flexibility is powerful but requires understanding The key insight: Think of variables as empty boxes. The box doesn't have a type—whatever you put inside determines the type. If you're learning Python, this concept is fundamental. I wrote a complete beginner's guide covering: How dynamic typing works Why values have types but variables don't How to use type() function Python vs statically typed languages Practice exercises Read the full guide here: https://lnkd.in/gW5F2TkQ What's your experience with dynamic typing? Drop a comment below. #Python #Programming #Coding #SoftwareDevelopment #LearnPython #PythonBasics #DynamicTyping #TechEducation #ProgrammingTips #DeveloperCommunity