# Signal processing - Filter and analyze data
from scipy import signal

# Design & apply Butterworth filter
sos = signal.butter(4, 100, 'lp', fs=1000, output='sos')
filtered = signal.sosfilt(sos, np.random.randn(1000))

# Spectral analysis (FFT)
freqs, psd = signal.welch(np.sin(2*np.pi*50*np.linspace(0,1,1000)) + np.random.randn(1000), fs=1000)
print(freqs[np.argmax(psd)])  # Output: ~50.0 (peak frequency)

# Convolution (image processing)
kernel = np.ones(5)/5
smoothed = signal.convolve([1,2,3,4,5,4,3,2,1], kernel, mode='valid')
print(smoothed)  # Output: [2. 3. 4. 4. 4. 3. 2.]

# Sparse matrices - Handle massive datasets
from scipy import sparse

# Create CSR matrix (memory efficient)
row = np.array([0, 0, 1, 2, 2])
col = np.array([0, 2, 1, 0, 2])
data = np.array([1, 2, 3, 4, 5])
sparse_mat = sparse.csr_matrix((data, (row, col)), shape=(3, 3))

# Matrix operations (100x faster than dense for sparse data)
dense_equivalent = sparse_mat.toarray()
print(sparse_mat.dot([1, 2, 3]))  # Output: [11  6 19]

# Real-world use: PageRank algorithm
adjacency = sparse.random(1000, 1000, density=0.01, format='csr')

# Spatial data structures - Nearest neighbor search
from scipy import spatial

# KD-Tree for fast queries (critical for ML interviews)
points = np.random.rand(100, 2)
tree = spatial.KDTree(points)

# Find 5 nearest neighbors
distances, indices = tree.query([0.5, 0.5], k=5)
print(indices)  # Output: [23 45 17 89 12] (closest point indices)

# Voronoi diagrams (geospatial analysis)
vor = spatial.Voronoi(points)
print(vor.vertices.shape)  # Output: (196, 2) (Voronoi vertices)

# File I/O - Work with scientific data formats
from scipy import io

# Save/load MATLAB files
mat_data = {'x': np.arange(10), 'y': np.random.rand(10)}
io.savemat('data.mat', mat_data)
loaded = io.loadmat('data.mat')
print(loaded['x'])  # Output: [[0 1 2 ... 9]]

# Read WAV audio files
from scipy.io import wavfile
sample_rate, audio = wavfile.read('audio.wav')
print(sample_rate)  # Output: 44100 (CD quality)

# Image processing - Beyond basic operations
from scipy import ndimage

# Load sample image (requires imageio)
# image = io.imread('sample.jpg', as_gray=True)

# Apply Gaussian blur
# blurred = ndimage.gaussian_filter(image, sigma=1)

# Edge detection (Sobel filter)
# edges = ndimage.sobel(image, axis=0)

# Morphological operations
# eroded = ndimage.binary_erosion(image > 0.5)

# Advanced optimization - Constrained problems
from scipy import optimize

# Minimize with constraints (interview gold)
def objective(x):
    return (x[0] - 1)**2 + (x[1] - 2.5)**2

constraints = ({
    'type': 'ineq', 
    'fun': lambda x: np.array([x[0] - 2*x[1] + 2, x[0]**2 + x[1]**2 - 1])
})
bounds = optimize.Bounds([0, -2], [2, 2])
result = optimize.minimize(objective, [0, 0], bounds=bounds, constraints=constraints)
print(result.x)  # Output: [1.4, 1.7] (constrained minimum)

# Statistical modeling - Regression analysis
from scipy import stats

# Linear regression with confidence intervals
x = np.linspace(0, 10, 100)
y = 2.5 * x + 1.3 + np.random.normal(size=100)
slope, intercept, r_value, p_value, std_err = stats.linregress(x, y)

print(f"Slope: {slope:.2f}±{std_err:.2f}")  # Output: Slope: 2.49±0.03
print(f"R²: {r_value**2:.4f}")              # Output: R²: 0.9872

# Fourier transforms - Frequency domain analysis
from scipy import fft

# Analyze composite signal
t = np.linspace(0, 1, 1000, endpoint=False)
signal = np.sin(2*np.pi*5*t) + 0.5*np.sin(2*np.pi*10*t)
spectrum = fft.fft(signal)

# Find dominant frequencies
freq = fft.fftfreq(len(t), t[1]-t[0])
print(freq[np.argmax(np.abs(spectrum))])  # Output: 5.0

# Cluster analysis - Unsupervised learning
from scipy import cluster

# Hierarchical clustering (dendrograms)
data = np.random.rand(100, 2)
Z = cluster.hierarchy.linkage(data, 'ward')
# cluster.hierarchy.dendrogram(Z)  # Visualize clusters

# Vector quantization (k-means)
codebook, _ = cluster.vq.kmeans(data, 3)
print(codebook.shape)  # Output: (3, 2) (3 cluster centers)

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)

"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)]

my_fruits = ["apple", "banana", "cherry", "date"]

Using enumerate() for a clean loop with index

print("--- Looping with default index ---")
for index, fruit in enumerate(my_fruits):
    print(f"Fruit at index {index}: {fruit}")

You can also specify a starting index for the counter

print("\n--- Looping with custom start index (e.g., from 1) ---")
for count, fruit in enumerate(my_fruits, start=1):
    print(f"Fruit number {count}: {fruit}")

--- Looping with default index ---
Fruit at index 0: apple
Fruit at index 1: banana
Fruit at index 2: cherry
Fruit at index 3: date

--- Looping with custom start index (e.g., from 1) ---
Fruit number 1: apple
Fruit number 2: banana
Fruit number 3: cherry
Fruit number 4: date

coordinates = (10, 20)
x = coordinates[0]
y = coordinates[1]
print(f"X: {x}, Y: {y}")

coordinates = (10, 20)
x, y = coordinates
print(f"X: {x}, Y: {y}")

a = 5
b = 10
a, b = b, a # Swaps values of a and b
print(f"a: {a}, b: {b}") # Output: a: 10, b: 5

names = ['Alice', 'Bob', 'Charlie']
ages = [30, 24, 35]
for i in range(len(names)):
    print(f"{names[i]} is {ages[i]} years old.")

names = ['Alice', 'Bob', 'Charlie']
ages = [30, 24, 35]
for name, age in zip(names, ages):
    print(f"{name} is {age} years old.")

class Car:
    def init(self, make, model, year):
        self.make = make    # Assign 'make' to the instance's 'make' attribute
        self.model = model  # Assign 'model' to the instance's 'model' attribute
        self.year = year    # Assign 'year' to the instance's 'year' attribute

    def get_description(self):
        return f"This is a {self.year} {self.make} {self.model}."

my_car = Car("Toyota", "Camry", 2020)
your_car = Car("Honda", "Civic", 2022)

print(my_car.get_description())
print(your_car.get_description())

This is a 2020 Toyota Camry.
This is a 2022 Honda Civic.

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())

import pandas as pd

data = {'Name': ['Alice', 'Bob', 'Charlie'],
        'Score': [85, 92, 78]}
df = pd.DataFrame(data)

Example: Create a new column 'Grade' based on 'Score'

def assign_grade(score):
    if score >= 90:
        return 'A'
    elif score >= 80:
        return 'B'
    else:
        return 'C'

df['Grade'] = df['Score'].apply(assign_grade)
print(df)

You can also use lambda functions for simpler operations

df['Score_Double'] = df['Score'].apply(lambda x: x * 2)
print(df)

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)

from django.db.models import F
from your_app.models import Product # Assuming a Product model with 'stock' and 'price' fields

Increment the stock of all products by 5 directly in the database

Product.objects.all().update(stock=F('stock') + 5)

Update the price to be 10% higher than the current price

Product.objects.all().update(price=F('price')  1.1)

Filter for products where the stock is less than 10 times its price

low_ratio_products = Product.objects.filter(stock__lt=F('price')  10)

from your_app.models import Post, Comment # Assuming your models are here

Bad: This would cause N+1 queries if you loop and access comments

posts = Post.objects.all()

for post in posts:

    for comment in post.comment_set.all(): # database hit for EACH post

        print(comment.text)

Good: Fetches all posts AND all comments in just 2 queries!

posts_with_comments = Post.objects.prefetch_related('comment_set')

for post in posts_with_comments:
    print(f"Post: {post.title}")
    for comment in post.comment_set.all(): # 'comment_set' is the default related_name
        print(f"  - {comment.text}")

from django.db.models import Prefetch
from your_app.models import Post, Comment # Assuming Comment has 'is_approved' and 'created_at'

Define a custom queryset for only approved comments, ordered by creation

approved_comments_queryset = Comment.objects.filter(is_approved=True).order_by('-created_at')

Fetch posts and only their approved comments, storing them in a custom attribute

posts_with_approved_comments = Post.objects.prefetch_related(
    Prefetch('comment_set', queryset=approved_comments_queryset, to_attr='approved_comments')
)

for post in posts_with_approved_comments:
    print(f"Post: {post.title}")
    # Access them via the custom attribute 'approved_comments'
    for comment in post.approved_comments:
        print(f"  - (Approved) {comment.text}")

from your_app.models import Post, Comment # Assuming Comment has a ForeignKey to an Author model

posts_with_nested_relations = Post.objects.prefetch_related(
    # Here, we prefetch comments, and within the comments prefetch their authors
    Prefetch('comment_set', queryset=Comment.objects.select_related('author'))
)

for post in posts_with_nested_relations:
    print(f"\nPost: {post.title}")
    for comment in post.comment_set.all():
        print(f"  - {comment.text} by {comment.author.name}") # Access comment.author directly!

from collections import namedtuple

Define a simple Point structure

Point = namedtuple('Point', ['x', 'y'])

Create instances

p1 = Point(10, 20)
p2 = Point(x=30, y=40)

print(f"Point 1: x={p1.x}, y={p1.y}")
print(f"Point 2: {p2[0]}, {p2[1]}") # Access by index

It's still a tuple!

print(f"Is p1 a tuple? {isinstance(p1, tuple)}")

Example with a Person

Person = namedtuple('Person', 'name age city')
person = Person('Alice', 30, 'New York')
print(f"Person: {person.name} is {person.age} from {person.city}")

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())

import numpy as np
arr = np.zeros((2, 3))