Python Equality vs Identity Operator: == vs is

😊❤️ Todays topic: Topic: *args and **kwargs in Python: ============== Sometimes you don’t know how many arguments a function will receive. Python gives a flexible way to handle this. *args (Non-keyword arguments): Used to pass multiple values as a tuple. def add(*args): print(args) add(1, 2, 3) Output: (1, 2, 3) Explanation: *args collects all positional arguments Inside the function, it behaves like a tuple Example with logic: def add(*args): total = 0 for i in args: total += i return total print(add(1, 2, 3, 4)) Output: 10 **kwargs (Keyword arguments): Used to pass multiple key-value pairs as a dictionary. def info(**kwargs): print(kwargs) info(name="Gemini", role="Developer") Output: {'name': 'Gemini', 'role': 'Developer'} Explanation: **kwargs collects named arguments Inside the function, it behaves like a dictionary Example with logic: def info(**kwargs): for key, value in kwargs.items(): print(key, ":", value) info(name="Gemini", role="Developer") Key Difference: *args → tuple of values **kwargs → dictionary of key-value pairs Order Rule (Important): def func(a, *args, **kwargs): pass Order must be: Normal parameters *args **kwargs 😎Interview Insight: You can use any name instead of args/kwargs, but * and ** are mandatory Very useful in writing flexible and reusable functions Quick Question: What will happen if you pass both *args and **kwargs together in a function call? #Python #Programming #Coding #InterviewPreparation #Developers

😊❤️ Todays topic: Topic: zip() function in Python ============ The zip() function is used to combine multiple iterables (like lists or tuples) into a single iterable. It pairs elements based on their position. Basic Example: names = ["A", "B", "C"] marks = [90, 80, 70] result = list(zip(names, marks)) print(result) Output: [('A', 90), ('B', 80), ('C', 70)] Explanation: Each element from both lists is paired together. Different Length Example: a = [1, 2, 3] b = [10, 20] print(list(zip(a, b))) Output: [(1, 10), (2, 20)] Explanation: zip() stops when the shortest iterable ends. Unzipping: pairs = [('A', 1), ('B', 2)] a, b = zip(*pairs) print(a) print(b) Output: ('A', 'B') (1, 2) Using zip in loop: names = ["A", "B"] marks = [90, 80] for name, mark in zip(names, marks): print(name, mark) Key Points: Combines multiple iterables Returns an iterator Stops at shortest iterable 😍Interview Insight: zip() is useful for parallel iteration and data pairing, especially when working with multiple lists. Quick Question: What will be the output? a = [1, 2] b = [3, 4] print(list(zip(a, b))) #Python #Programming #Coding #InterviewPreparation #Developers

😊❤️ Todays topic: Topic: Lambda Functions in Python ================ A lambda function is a small anonymous function defined in a single line. It is used when you need a simple function for a short period of time. Basic Syntax: lambda arguments: expression Example (Normal Function): def add(a, b): return a + b print(add(2, 3)) Same using lambda: add = lambda a, b: a + b print(add(2, 3)) Output: 5 Using lambda with built-in functions: map() numbers = [1, 2, 3, 4] result = list(map(lambda x: x * 2, numbers)) print(result) Output: [2, 4, 6, 8] filter() numbers = [1, 2, 3, 4, 5] result = list(filter(lambda x: x % 2 == 0, numbers)) print(result) Output: [2, 4] Key Points: No function name Single expression only (no multiple statements) Automatically returns result When to use: Small, simple operations Temporary functions (especially with map, filter, sorted) 😍Interview Insight: Lambda functions improve code readability when used correctly, but overusing them can make code harder to understand. Quick Question: What will be the output? result = list(map(lambda x: x + 1, [1, 2, 3])) print(result) #Python #Programming #Coding #InterviewPreparation #Developers

😊❤️ Todays topic: Topic: Polymorphism in Python: ============= Polymorphism means “one interface, multiple implementations”. In simple terms, the same method name can behave differently depending on the object. Example 1: Same method, different classes class Dog: def sound(self): print("Bark") class Cat: def sound(self): print("Meow") for animal in [Dog(), Cat()]: animal.sound() Output: Bark Meow Explanation: Both classes have the same method name, but different behavior. Example 2: Built-in polymorphism print(len("Hello")) # string print(len([1, 2, 3])) # list Output: 5 3 Explanation: len() works differently for different data types. Example 3: Method overriding class Parent: def show(self): print("Parent") class Child(Parent): def show(self): print("Child") obj = Child() obj.show() Output: Child Key Points: Same method name, different behavior Achieved using method overriding or different classes Improves flexibility and code reuse Interview Insight: Polymorphism allows writing generic and reusable code that works with different object types. Quick Question: Is method overloading supported in Python like Java? #Python #Programming #Coding #InterviewPreparation #Developers

I’ve just published my first blog post on Medium, diving into a Python concept I recently explored: 👉 Mutable vs Immutable Objects Before this, I used to think variables simply “store values.” But in Python, they actually reference objects in memory. Having learned C previously really helped me grasp this concept more quickly, especially when it comes to understanding how memory and references work. In this post, I break down: • The difference between == and is • Mutable vs immutable objects (with clear examples) • Why l1 = l1 + [4] and l1 += [4] behave differently • How Python passes arguments to functions Writing about what I learn pushes me to go deeper and truly understand the concepts. If you’re learning Python or preparing for technical interviews, this is definitely a topic worth mastering. 📖 Read here: https://lnkd.in/guVnYN3Q #Python #SoftwareEngineering #Programming #LearningJourney #Tech

Sometimes small Python behaviors end up causing big confusion in production. I faced one such case with shallow copies when handling nested lists and dicts. It looked simple at first but ended up modifying original data silently. Wrote a plain and honest Medium piece about what actually happened and how I fixed it. It is not theory or textbook — just one of those bugs you only understand after you hit it yourself. Friend link below ⬇️ https://lnkd.in/ehYY9zRY #Python #BackendDevelopment #SoftwareEngineering #CodingJourney #TechCommunity #MediumDev #PythonTips #LearningByDebugging

Here's an interesting thing I came to know about Python today (which I should have known earlier, but anyway): Python can store all kinds of data types within a list or tuple is because it just stores the reference of the elements. Where as if you use something like array.array(), it will store the actual values, and hence, you will be able to store only one kind of data type in that. And as an inference, array.array() takes very less memory, since it has only the values, while a list on its whole (if you include memories of all the references it carries) takes more memory. For example, I just created a list of 10 million ints, and an array.array() of the same and ran a test, with Python 3.14 interpreter, and here's the result: Size of array.array for 10 million ints: 39.07MB Size of list for 10 million ints: 390.14MB Further more: Sequences like lists, tuples are called "container sequence" as they contain multiple objects. Sequences like array.array() are called "flat sequence" as they contain only values. The below image is taken from "Fluent Python" book, written by Luciano Ramalho, and it explains diagrammatically about Container sequence and Flat sequence. #python

Top 10 Python One Liners! 1️⃣ Reverse a string: reversed_string = "Hello World"[::-1] 2️⃣ Check if a number is even: is_even = lambda x: x % 2 == 0 3️⃣ Find the factorial of a number: factorial = lambda x: 1 if x == 0 else x * factorial(x - 1) 4️⃣ Read a file and print its contents: [print(line.strip()) for line in open('file.txt')] 5️⃣ Create a list of squares: squares = [x**2 for x in range(10)] 6️⃣ Flatten a list of lists: flat_list = [item for sublist in [[1, 2], [3, 4], [5, 6]] for item in sublist] 7️⃣ Find the length of a list: length = len([1, 2, 3, 4]) 8️⃣ Create a dictionary from two lists: keys = ['a', 'b', 'c']; values = [1, 2, 3]; dictionary = dict(zip(keys, values)) 9️⃣ Generate a list of random numbers: import random; random_numbers = [random.randint(0, 100) for _ in range(10)] 🔟 Check if a string is a palindrome: is_palindrome = lambda s: s == s[::-1] Mastering these one-liners can significantly improve your coding efficiency and make your code more concise.

DAY 9 – Python Revision | Recursion Masterclass (Core Logic Building) #Python #Recursion #LogicBuilding #FAANGPrep #DSA Recursion means a function calling itself until a base condition stops it. Ye technique har FAANG interview ka core hoti hai, specially: Tree problems Backtracking Divide & Conquer Dynamic Programming Aaj ke 4 powerful recursion problems 👇 (clean code + explanation) 🧩 Problem 1 — Factorial using Recursion (Base Concept) Input: 5 Output: 120 ✔ Recursion Logic Base case → n == 0 → return 1 Recursive case → n * factorial(n-1) def factorial(n): if n == 0: return 1 return n * factorial(n - 1) print(factorial(5)) Output: 120 🧩 Problem 2 — Fibonacci Using Recursion (Interview Favorite) Input: 6 Output: 8 ✔ Recursion Logic Fib(n) = Fib(n-1) + Fib(n-2) def fib(n): if n <= 1: return n return fib(n - 1) + fib(n - 2) print(fib(6)) Output: 8 🧩 Problem 3 — Sum of Digits Using Recursion (Logic Booster) Input: 1234 Output: 10 ✔ Recursion Logic Base → jab number 0 ho Recursive → last digit add + remaining digits ka sum def sum_of_digits(n): if n == 0: return 0 return (n % 10) + sum_of_digits(n // 10) print(sum_of_digits(1234)) Output: 10 🧩 Problem 4 — Reverse a String Using Recursion (Amazon) Input: "hello" Output: "olleh" ✔ Recursion Logic Base → length 0 or 1 Recursive → last char + reverse of remaining string def reverse_string(s): if len(s) <= 1: return s return reverse_string(s[1:]) + s[0] print(reverse_string("hello")) Output: olleh

🔹 *args and **kwargs in Python — Flexible Function Design Ever wondered how Python functions handle dynamic inputs? That’s where *args and **kwargs come in 👇 💡 *args (Non-keyword arguments) Allows you to pass a variable number of positional arguments. def add_numbers(*args): return sum(args) print(add_numbers(1, 2, 3)) # 6 print(add_numbers(5, 10, 15, 20)) # 50 💡 **kwargs (Keyword arguments) Allows you to pass a variable number of named arguments. def print_details(**kwargs): for key, value in kwargs.items(): print(f"{key} = {value}") print_details(name="Nittu", role="QA", skill="Playwright") ⚡ Combined usage: def demo(*args, **kwargs): print("Args:", args) print("Kwargs:", kwargs) demo(1, 2, 3, name="Tester", tool="Playwright") 🚀 Key takeaway: Use *args when you don’t know how many positional inputs you’ll get. Use **kwargs when you want flexibility with named inputs. #Python #Coding #Automation #QA #SoftwareTesting #Developers #TechLearning