In Python, "Magic Methods" (also known as Dunder methods, short for "double underscore") are special methods that allow you to define how objects of your class behave with built-in functions and operators. While init handles object initialization, str and repr are crucial for defining an object's string representation.

str: Returns a "user-friendly" string representation of an object, primarily for human readability (e.g., when print() is called).
repr: Returns an "official" string representation of an object, primarily for developers, often aiming to be unambiguous and allow recreation of the object.

class Book:
    def init(self, title, author, year):
        self.title = title
        self.author = author
        self.year = year

    def str(self):
        return f'"{self.title}" by {self.author} ({self.year})'

    def repr(self):
        return f"Book('{self.title}', '{self.author}', {self.year})"

Creating an instance

my_book = Book("The Hitchhiker's Guide to the Galaxy", "Douglas Adams", 1979)

str is used by print()

print(my_book)

repr is used by the interpreter or explicitly with repr()

print(repr(my_book))

In collections, repr is used by default

bookshelf = [my_book, Book("Pride and Prejudice", "Jane Austen", 1813)]
print(bookshelf)

Output:

"The Hitchhiker's Guide to the Galaxy" by Douglas Adams (1979)
Book('The Hitchhiker\'s Guide to the Galaxy', 'Douglas Adams', 1979)
[Book('The Hitchhiker\'s Guide to the Galaxy', 'Douglas Adams', 1979), Book('Pride and Prejudice', 'Jane Austen', 1813)]

#Python #MagicMethods #DunderMethods #OOP #Classes #PythonTips #CodeExamples #StringRepresentation #ObjectOrientation #Programming

---
By: @DataScienceQ ✨

Python OOP Tip: Inheritance Basics! 🚀

Inheritance allows a new class (child) to acquire properties and methods from an existing class (parent), promoting code reuse and establishing an "is-a" relationship.

class Vehicle:
    def init(self, brand):
        self.brand = brand

    def description(self):
        return f"This is a {self.brand} vehicle."

class Car(Vehicle): # Car inherits from Vehicle
    def init(self, brand, model):
        super().init(brand) # Call parent's constructor
        self.model = model

    def drive(self):
        return f"The {self.brand} {self.model} is driving."

my_car = Car("Toyota", "Camry")
print(my_car.description())
print(my_car.drive())

Key Takeaway: Use super().init() in a child class to properly initialize parent attributes when overriding the constructor.

#Python #OOP #Inheritance #PythonTips #Programming
---
By: @DataScienceQ ✨

🚀 NumPy Tip: Boolean Indexing (Masking) 🚀

Ever need to filter your arrays based on a condition? NumPy's Boolean Indexing, also known as masking, is your go-to! It allows you to select elements that satisfy a specific condition.

import numpy as np

Create a sample NumPy array

data = np.array([12, 5, 20, 8, 35, 15, 30])

Create a boolean mask: True where value is > 10, False otherwise

mask = data > 10
print("Boolean Mask:", mask)

Apply the mask to the array to filter elements

filtered_data = data[mask]
print("Filtered Data (values > 10):", filtered_data)

You can also combine the condition and indexing directly

even_numbers = data[data % 2 == 0]
print("Even Numbers:", even_numbers)

Explanation:
A boolean array (the mask) is created by applying a condition to your original array. When this mask is used for indexing, NumPy returns a new array containing only the elements where the mask was True. Simple, powerful, and efficient!

#NumPy #PythonTips #DataScience #ArrayMasking #Python #Programming

---
By: @DataScienceQ ✨

💡 Python Asyncio Tip: Basic async/await for concurrent operations.

import asyncio

async def say_hello():
    await asyncio.sleep(0.1) # Simulate a non-blocking I/O call
    print("Hello from async!")

async def main():
    await say_hello()

asyncio.run(main())

#Python #Asyncio #Concurrency #Programming

---
By: @DataScienceQ ✨

💡 Python Dictionary Cheatsheet: Key Operations

This lesson provides a quick, comprehensive guide to Python dictionaries. Dictionaries are unordered, mutable collections of key-value pairs, essential for mapping data. This cheatsheet covers creation, access, modification, and useful methods.

# 1. Dictionary Creation
my_dict = {"name": "Alice", "age": 30, "city": "New York"}
empty_dict = {}
another_dict = dict(brand="Ford", model="Mustang") # Using keyword arguments
from_tuples = dict([("a", 1), ("b", 2)]) # From a list of key-value tuples
dict_comprehension = {i: i*i for i in range(3)} # {0: 0, 1: 1, 2: 4}

# 2. Accessing Values
name = my_dict["name"] # Alice
age = my_dict.get("age") # 30 (safer, returns None if key not found)
job = my_dict.get("job", "Unemployed") # Unemployed (default value if key not found)

# 3. Adding and Updating Elements
my_dict["email"] = "[email protected]" # Adds new key-value pair
my_dict["age"] = 31 # Updates existing value
my_dict.update({"city": "London", "occupation": "Engineer"}) # Updates/adds multiple pairs

# 4. Removing Elements
removed_age = my_dict.pop("age") # Removes 'age' and returns its value (31)
del my_dict["city"] # Deletes the 'city' key-value pair
# my_dict.popitem() # Removes and returns a (key, value) pair (Python 3.7+ guaranteed last inserted)
my_dict.clear() # Empties the dictionary

# Re-create for further examples
person = {"name": "Bob", "age": 25, "city": "Paris", "occupation": "Artist"}

# 5. Iterating Through Dictionaries
# print("--- Keys ---")
for key in person: # Iterates over keys by default
    # print(key)
    pass
# print("--- Values ---")
for value in person.values():
    # print(value)
    pass
# print("--- Items (Key-Value Pairs) ---")
for key, value in person.items():
    # print(f"{key}: {value}")
    pass

# 6. Dictionary Information
num_items = len(person) # 4
keys_list = list(person.keys()) # ['name', 'age', 'city', 'occupation']
values_list = list(person.values()) # ['Bob', 25, 'Paris', 'Artist']
items_list = list(person.items()) # [('name', 'Bob'), ('age', 25), ...]

# 7. Checking for Key Existence
has_name = "name" in person # True
has_country = "country" in person # False

# 8. Copying Dictionaries
person_copy = person.copy() # Shallow copy
person_deep_copy = dict(person) # Another way for shallow copy

# 9. fromkeys() - Create dictionary from keys with default value
default_value_dict = dict.fromkeys(["a", "b", "c"], 0) # {'a': 0, 'b': 0, 'c': 0}

Code explanation: This script demonstrates essential Python dictionary operations. It covers various ways to create dictionaries, access values using direct key lookup and the safer get() method, and how to add or update key-value pairs. It also shows different methods for removing elements (pop(), del, clear()), and iterating through dictionary keys, values, or items. Finally, it illustrates how to get dictionary size, retrieve lists of keys/values/items, check for key existence, and create copies or new dictionaries using fromkeys().

#Python #Dictionaries #DataStructures #Programming #Cheatsheet

━━━━━━━━━━━━━━━
By: @DataScienceQ ✨

🧠 Quiz: Which of the following is the most Pythonic and efficient way to iterate through a list my_list and access both each item and its corresponding index?

A) i = 0; while i < len(my_list): item = my_list[i]; i += 1
B) for index, item in enumerate(my_list):
C) for index in range(len(my_list)): item = my_list[index]
D) for item in my_list: index = my_list.index(item)

✅ Correct answer: B

Explanation: The enumerate() function is specifically designed to provide both the index and the item while iterating over a sequence, making the code cleaner, more readable, and generally more efficient than manual indexing or while loops. Option D is inefficient as list.index(item) scans the list for each item, especially if duplicates exist.

#PythonTips #Pythonic #Programming

━━━━━━━━━━━━━━━
By: @DataScienceQ ✨

💡 Understanding Python Decorators

Decorators are a powerful feature in Python that allow you to add functionality to an existing function without modifying its source code. A decorator is essentially a function that takes another function as an argument, wraps it in an inner function (the "wrapper"), and returns the wrapper. This is useful for tasks like logging, timing, or access control.

import time

def timer_decorator(func):
    """A decorator that prints the execution time of a function."""
    def wrapper(*args, **kwargs):
        start_time = time.perf_counter()
        result = func(*args, **kwargs)
        end_time = time.perf_counter()
        run_time = end_time - start_time
        print(f"Finished {func.__name__!r} in {run_time:.4f} secs")
        return result
    return wrapper

@timer_decorator
def process_heavy_data(n):
    """A sample function that simulates a time-consuming task."""
    sum = 0
    for i in range(n):
        sum += i
    return sum

process_heavy_data(10000000)

Code explanation: The timer_decorator function takes process_heavy_data as its argument. The @timer_decorator syntax is shorthand for process_heavy_data = timer_decorator(process_heavy_data). When the decorated function is called, the wrapper inside the decorator executes, recording the start time, running the original function, recording the end time, and printing the duration.

#Python #Decorators #Programming #CodeTips #PythonTutorial

━━━━━━━━━━━━━━━
By: @DataScienceQ ✨

• (Time: 60s) What does the pass statement do?
a) It terminates the program.
b) It skips the current iteration of a loop.
c) It is a null operation; nothing happens when it executes.
d) It raises a NotImplementedError.

#Python #Certification #Exam #Programming #CodingTest #Intermediate

━━━━━━━━━━━━━━━
By: @DataScienceQ ✨

The Walrus Operator := (Assignment Expressions)

Introduced in Python 3.8, the "walrus operator" := allows you to assign a value to a variable as part of a larger expression. It's a powerful tool for writing more concise and readable code, especially in while loops and comprehensions.

It solves the common problem where you need to compute a value, check it, and then use it again.

---

#### The Old Way: Repetitive Code

Consider a loop that repeatedly prompts a user for input and stops when the user enters "quit".

# We have to get the input once before the loop,
# and then again inside the loop.
command = input("Enter command: ")

while command != "quit":
    print(f"Executing: {command}")
    command = input("Enter command: ")

print("Exiting program.")

Notice how input("Enter command: ") is written twice.

---

#### The Pythonic Way: Using the Walrus Operator :=

The walrus operator lets you capture the value and test it in a single, elegant line.

while (command := input("Enter command: ")) != "quit":
    print(f"Executing: {command}")

print("Exiting program.")

Here, (command := input(...)) does two things:
• Calls input() and assigns its value to the command variable.
• The entire expression evaluates to that same value, which is then compared to "quit".

This eliminates redundant code, making your logic cleaner and more direct.

#Python #PythonTips #PythonTricks #WalrusOperator #Python3 #CleanCode #Programming #Developer #CodingTips

━━━━━━━━━━━━━━━
By: @DataScienceQ ✨