# Basic for loop over iterable (list)
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:  # Iterates each element directly
    print(fruit)      # Output: apple \n banana \n cherry

# For loop with range() for numeric sequences
for i in range(3):    # Generates 0, 1, 2 (start=0, stop=3, step=1)
    print(i)          # Output: 0 \n 1 \n 2

for i in range(1, 6, 2):  # Start=1, stop=6, step=2
    print(i)              # Output: 1 \n 3 \n 5

# Index-aware with enumerate() (gets both index and value)
for index, fruit in enumerate(fruits, start=1):  # start=1 for 1-based indexing
    print(f"{index}: {fruit}")                   # Output: 1: apple \n 2: banana \n 3: cherry

# Parallel iteration with zip() (pairs multiple iterables)
names = ["Alice", "Bob", "Charlie"]
ages = [25, 30, 35]
for name, age in zip(names, ages):  # Stops at shortest iterable
    print(f"{name} is {age} years old")  # Output: Alice is 25 years old \n Bob is 30 years old \n Charlie is 35 years old

# Nested for loops (outer for rows, inner for columns; e.g., matrix)
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
for row in matrix:         # Outer: each sublist
    for num in row:        # Inner: each element in row
        print(num, end=' ')  # Output: 1 2 3 4 5 6 7 8 9 (space-separated)

# For loop in list comprehension (concise iteration with optional condition)
squares = [x**2 for x in range(5)]  # Basic comprehension
print(squares)  # Output: [0, 1, 4, 9, 16]

evens_squared = [x**2 for x in range(10) if x % 2 == 0]  # With condition (if)
print(evens_squared)  # Output: [0, 4, 16, 36, 64]

# Nested comprehension (flattens 2D list)
flattened = [num for row in matrix for num in row]  # Equivalent to nested for
print(flattened)  # Output: [1, 2, 3, 4, 5, 6, 7, 8, 9]

# For loop: Use for fixed iterations over iterables (e.g., processing lists)
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:  # Iterates each element
    print(fruit)      # Output: apple \n banana \n cherry

for i in range(3):    # Numeric sequence (start=0, stop=3)
    print(i)          # Output: 0 \n 1 \n 2

# While loop: Use when iterations depend on a dynamic condition (e.g., user input, convergence)
count = 0
while count < 3:      # Runs as long as condition is True
    print(count)
    count += 1       # Increment to avoid infinite loop! Output: 0 \n 1 \n 2

# Nested loops: Use for 2D data (e.g., matrices, grids); outer for rows, inner for columns
matrix = [[1, 2], [3, 4]]
for row in matrix:    # Outer: each sublist
    for num in row:   # Inner: elements in row
        print(num)    # Output: 1 \n 2 \n 3 \n 4

# Control statements: break (exit loop), continue (skip iteration)
for i in range(5):
    if i == 2:
        continue    # Skip 2
    if i == 4:
        break       # Exit at 4
    print(i)        # Output: 0 \n 1 \n 3

# List comprehension: Concise for loop alternative (use for simple transformations/filtering)
squares = [x**2 for x in range(5) if x % 2 == 0]  # Even squares
print(squares)  # Output: [0, 4, 16]

# For loop: Use for fixed iterations over iterables (e.g., processing lists)
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:  # Iterates each element
    print(fruit)      # Output: apple \n banana \n cherry

for i in range(3):    # Numeric sequence (start=0, stop=3)
    print(i)          # Output: 0 \n 1 \n 2

# While loop: Use when iterations depend on a dynamic condition (e.g., user input, convergence)
count = 0
while count < 3:      # Runs as long as condition is True
    print(count)
    count += 1       # Increment to avoid infinite loop! Output: 0 \n 1 \n 2

# Nested loops: Use for 2D data (e.g., matrices, grids); outer for rows, inner for columns
matrix = [[1, 2], [3, 4]]
for row in matrix:    # Outer: each sublist
    for num in row:   # Inner: elements in row
        print(num)    # Output: 1 \n 2 \n 3 \n 4

# Control statements: break (exit loop), continue (skip iteration)
for i in range(5):
    if i == 2:
        continue    # Skip 2
    if i == 4:
        break       # Exit at 4
    print(i)        # Output: 0 \n 1 \n 3

# List comprehension: Concise for loop alternative (use for simple transformations/filtering)
squares = [x**2 for x in range(5) if x % 2 == 0]  # Even squares
print(squares)  # Output: [0, 4, 16]

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