import numpy as np

# Array Creation - The foundation of NumPy
arr = np.array([1, 2, 3])
zeros = np.zeros((2, 3))        # 2x3 matrix of zeros
ones = np.ones((2, 2), dtype=int)  # Integer matrix
arange = np.arange(0, 10, 2)    # [0 2 4 6 8]
linspace = np.linspace(0, 1, 5) # [0.  0.25 0.5  0.75 1.  ]
print(linspace)

# Array Attributes - Master your data's structure
matrix = np.array([[1, 2, 3], [4, 5, 6]])
print(matrix.shape)  # Output: (2, 3)
print(matrix.ndim)   # Output: 2
print(matrix.dtype)  # Output: int64
print(matrix.size)   # Output: 6

# Indexing & Slicing - Precision data access
data = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(data[1, 2])      # Output: 6 (row 1, col 2)
print(data[0:2, 1:3])  # Output: [[2 3], [5 6]]
print(data[:, -1])     # Output: [3 6 9] (last column)

# Reshaping Arrays - Transform dimensions effortlessly
flat = np.arange(6)
reshaped = flat.reshape(2, 3)
raveled = reshaped.ravel()
print(reshaped)
# Output: [[0 1 2], [3 4 5]]
print(raveled)  # Output: [0 1 2 3 4 5]

# Stacking Arrays - Combine datasets vertically/horizontally
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
print(np.vstack((a, b)))  # Vertical stack
# Output: [[1 2 3], [4 5 6]]
print(np.hstack((a, b)))  # Horizontal stack
# Output: [1 2 3 4 5 6]

# Mathematical Operations - Vectorized calculations
x = np.array([1, 2, 3])
y = np.array([4, 5, 6])
print(x + y)       # Output: [5 7 9]
print(x * 2)       # Output: [2 4 6]
print(np.dot(x, y)) # Output: 32 (1*4 + 2*5 + 3*6)

# Broadcasting Magic - Operate on mismatched shapes
matrix = np.array([[1, 2, 3], [4, 5, 6]])
scalar = 10
print(matrix + scalar)
# Output: [[11 12 13], [14 15 16]]

# Aggregation Functions - Statistical power in one line
values = np.array([1, 5, 3, 9, 7])
print(np.sum(values))   # Output: 25
print(np.mean(values))  # Output: 5.0
print(np.max(values))   # Output: 9
print(np.std(values))   # Output: 2.8284271247461903

# Boolean Masking - Filter data like a pro
temperatures = np.array([18, 25, 12, 30, 22])
hot_days = temperatures > 24
print(temperatures[hot_days])  # Output: [25 30]

# Random Number Generation - Simulate real-world data
print(np.random.rand(2, 2))      # Uniform distribution
print(np.random.randn(3))        # Normal distribution
print(np.random.randint(0, 10, (2, 3)))  # Random integers

# Linear Algebra Essentials - Solve equations like a physicist
A = np.array([[3, 1], [1, 2]])
b = np.array([9, 8])
x = np.linalg.solve(A, b)
print(x)  # Output: [2. 3.] (Solution to 3x+y=9 and x+2y=8)

# Matrix inverse and determinant
print(np.linalg.inv(A))   # Output: [[ 0.4 -0.2], [-0.2  0.6]]
print(np.linalg.det(A))   # Output: 5.0

# File Operations - Save/load your computational work
data = np.array([[1, 2], [3, 4]])
np.save('array.npy', data)
loaded = np.load('array.npy')
print(np.array_equal(data, loaded))  # Output: True

# Interview Power Move: Vectorization vs Loops
# 10x faster than native Python loops!
def square_sum(n):
    arr = np.arange(n)
    return np.sum(arr ** 2)

print(square_sum(5))  # Output: 30 (0²+1²+2²+3²+4²)

# Pro Tip: Memory-efficient data processing
# Process 1GB array without loading entire dataset
large_array = np.memmap('large_data.bin', dtype='float32', mode='r', shape=(1000000, 100))
print(large_array[0:5, 0:3])  # Process small slice

import numpy as np
import scipy as sp

# Physical & mathematical constants - No more manual lookups!
from scipy import constants
print(constants.pi)          # 3.141592653589793
print(constants.golden)      # 1.618033988749895
print(constants.year)        # Seconds in a year: 31556925.9747
print(constants.eV)          # Electron volt in joules: 1.602176634e-19

# Special functions - Solve advanced math problems effortlessly
from scipy import special

# Gamma function (extends factorial to complex numbers)
print(special.gamma(5))     # 24.0 (same as 4!)

# Bessel functions (critical for wave equations)
print(special.jv(0, 3.0))   # -0.2600519549019334 (J₀(3))

# Error function (statistics & diffusion)
print(special.erf(1.0))     # 0.8427007929497149

# Legendre polynomials (quantum mechanics)
print(special.legendre(3))  # 4th order: [5. 0. -7.5 0.]

# Optimization - Find minima/maxima like a pro
from scipy import optimize

# Minimize a scalar function (BFGS algorithm)
def f(x):
    return x**2 + 10*np.sin(x)
result = optimize.minimize(f, x0=0)
print(result.x)  # Output: [-1.30644001] (global minimum)

# Solve nonlinear equations
root = optimize.root(lambda x: x**3 - 2*x + 2, x0=0)
print(root.x)    # Output: [-1.76929235]

# Curve fitting (real interview favorite)
x_data = np.linspace(0, 10, 20)
y_data = 3*x_data**2 + 2 + np.random.normal(size=20)
popt, _ = optimize.curve_fit(lambda x, a, b: a*x**2 + b, x_data, y_data)
print(popt)      # Output: [~3.0, ~2.0] (coefficients)

# Integration - Beyond basic calculus
from scipy import integrate

# Definite integral (adaptive quadrature)
result, error = integrate.quad(lambda x: np.sin(x), 0, np.pi)
print(result)    # Output: 2.0 (exact area under sine wave)

# Double integral (physics applications)
area, _ = integrate.dblquad(
    lambda y, x: x*y,  # Integrand
    0, 1,              # x bounds
    lambda x: 0,       # y lower bound
    lambda x: 1-x      # y upper bound
)
print(area)      # Output: 0.08333333333333333 (1/12)

# ODE solver (model dynamic systems)
def pendulum(t, y):
    theta, omega = y
    return [omega, -0.25*omega - 5*np.sin(theta)]
sol = integrate.solve_ivp(pendulum, [0, 10], [np.pi-0.1, 0], t_eval=np.linspace(0,10,100))
print(sol.y[0][-1])  # Output: Final angle after 10s

# Interpolation - Fill missing data points
from scipy import interpolate

x = np.array([0, 1, 2, 3, 4])
y = np.array([0, 1, 0, 1, 0])
f = interpolate.interp1d(x, y, kind='cubic')

# Generate smooth curve
x_new = np.linspace(0, 4, 100)
y_new = f(x_new)

# Real-world use: Resample sensor data
print(f(2.5))  # Output: ~0.625 (smooth value between points)

# Linear algebra - Advanced matrix operations
from scipy import linalg

# Solve linear system with LU decomposition
A = np.array([[3, 2, 0], [2, 3, 2], [0, 2, 3]])
b = np.array([2, -3, 4])
x = linalg.solve(A, b, assume_a='pos')  # Positive definite matrix
print(x)  # Output: [ 2. -1.  2.]

# Eigenvalues/vectors (quantum mechanics)
vals, vecs = linalg.eig(A)
print(vals)  # Output: [5. 3. 1.] (eigenvalues)

# Matrix exponential (control theory)
expm = linalg.expm(A)
print(expm[0,0])  # Output: ~20.0855 (e³)

# Statistical distributions - Hypothesis testing
from scipy import stats

# Normal distribution analysis
samples = np.random.normal(loc=5, scale=2, size=1000)
print(stats.shapiro(samples))  # (0.998, 0.512) - p>0.05 = normal

# T-test (compare two groups)
group1 = np.random.normal(5, 1, 100)
group2 = np.random.normal(5.5, 1, 100)
t_stat, p_val = stats.ttest_ind(group1, group2)
print(p_val)  # Output: ~0.001 (significant difference)

# Chi-square test (categorical data)
observed = np.array([[30, 10], [10, 30]])
chi2, p, _, _ = stats.chi2_contingency(observed)
print(p)  # Output: 1.006e-05 (highly significant)

# 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}")