#Array Indexing and Slicing

import numpy as np

# Create 1D array
array = np.array([10, 20, 30, 40, 50, 60, 70, 80, 90, 100])
print("Original array:", array)
print("Array length:", len(array))
print()

# Forward indexing (starting from 0)
print("First element array[0]:", array[0])
print("Third element array[2]:", array[2])
print("Fifth element array[4]:", array[4])
print()

# Reverse indexing (starting from -1)
print("Last element array[-1]:", array[-1])
print("Second to last array[-2]:", array[-2])
print("Fifth from last array[-5]:", array[-5])

import numpy as np

array = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
print("Original array:", array)
print()

# Basic slice syntax: array[start:stop:step]
print("First 5 elements array[:5]:", array[:5])
print("Last 5 elements array[5:]:", array[5:])
print("Middle elements array[2:8]:", array[2:8])
print("All elements array[:]:", array[:])
print()

# Using step
print("Every other element array[::2]:", array[::2])
print("Every third element array[::3]:", array[::3])
print("Every other from index 1 array[1::2]:", array[1::2])
print()

# Reverse slicing
print("Reversed array[::-1]:", array[::-1])
print("Reversed every other array[::-2]:", array[::-2])
print("Last 5 elements array[-5:]:", array[-5:])
print("Middle from end array[-8:-2]:", array[-8:-2])

import numpy as np

# Create 2D array
array_2d = np.array([
    [1,  2,  3,  4],
    [5,  6,  7,  8],
    [9,  10, 11, 12],
    [13, 14, 15, 16]
])

print("2D array:")
print(array_2d)
print(f"Array shape: {array_2d.shape}")
print()

# Access single element
print("Row 1, Col 1 array_2d[0, 0]:", array_2d[0, 0])
print("Row 2, Col 3 array_2d[1, 2]:", array_2d[1, 2])
print("Last row, last col array_2d[-1, -1]:", array_2d[-1, -1])
print("Row 3, Col 2 array_2d[2, 1]:", array_2d[2, 1])
print()

# Access entire row
print("First row array_2d[0, :]:", array_2d[0, :])
print("Third row array_2d[2, :]:", array_2d[2, :])
print("Last row array_2d[-1, :]:", array_2d[-1, :])
print()

# Access entire column
print("First column array_2d[:, 0]:", array_2d[:, 0])
print("Third column array_2d[:, 2]:", array_2d[:, 2])
print("Last column array_2d[:, -1]:", array_2d[:, -1])

import numpy as np

array_2d = np.arange(20).reshape(4, 5)
print("Original array:")
print(array_2d)
print()

# Row slicing
print("First two rows array_2d[:2, :]:")  
print(array_2d[:2, :])
print()

print("Last two rows array_2d[2:, :]:")  
print(array_2d[2:, :])
print()

# Column slicing
print("First three columns array_2d[:, :3]:")  
print(array_2d[:, :3])
print()

print("Last two columns array_2d[:, -2:]:")  
print(array_2d[:, -2:])
print()

# Row and column slicing together
print("Middle 2x3 subarray array_2d[1:3, 1:4]:")  
print(array_2d[1:3, 1:4])
print()

# Using step
print("Every other row array_2d[::2, :]:")  
print(array_2d[::2, :])
print()

print("Every other column array_2d[:, ::2]:")  
print(array_2d[:, ::2])
print()

# Complex slicing
print("Every other row and column array_2d[::2, ::2]:")  
print(array_2d[::2, ::2])

import numpy as np

# 1D array integer array indexing
array = np.array([10, 20, 30, 40, 50, 60, 70, 80, 90, 100])
print("Original array:", array)

# Using index array
indices = np.array([0, 2, 4, 6])
print("Index array:", indices)
print("Selected elements:", array[indices])
print()

# Can repeat indices
repeated_indices = np.array([1, 1, 3, 3, 5])
print("Repeated indices:", repeated_indices)
print("Selected elements:", array[repeated_indices])
print()

# 2D array integer array indexing
array_2d = np.arange(12).reshape(3, 4)
print("2D array:")
print(array_2d)
print()

# Select specific rows
row_indices = np.array([0, 2])
print("Select rows 0 and 2:")
print(array_2d[row_indices])
print()

# Select specific position elements
row_idx = np.array([0, 1, 2])
col_idx = np.array([1, 2, 3])
print("Select positions (0,1), (1,2), (2,3):")
print(array_2d[row_idx, col_idx])

import numpy as np

# Create array
array = np.array([1, 5, 3, 8, 2, 9, 4, 7, 6])
print("Original array:", array)
print()

# Create boolean condition
condition = array > 5
print("Condition array > 5:", condition)
print("Elements satisfying condition:", array[condition])
print()

# Multiple conditions
condition_and = (array > 3) & (array < 8)
print("Condition (array > 3) & (array < 8):", condition_and)
print("Elements satisfying condition:", array[condition_and])
print()

condition_or = (array < 3) | (array > 7)
print("Condition (array < 3) | (array > 7):", condition_or)
print("Elements satisfying condition:", array[condition_or])
print()

# 2D array boolean indexing
array_2d = np.random.randint(1, 10, (4, 4))
print("2D random array:")
print(array_2d)
print()

# Find elements greater than 5
mask = array_2d > 5
print("Positions of elements > 5:")
print(mask)
print("Values of elements > 5:", array_2d[mask])
print()

# Find max value position in each row
max_in_rows = array_2d == array_2d.max(axis=1, keepdims=True)
print("Max value positions in each row:")
print(max_in_rows)
print("Max values in each row:", array_2d[max_in_rows])

import numpy as np

# Create 2D array
array_2d = np.arange(24).reshape(6, 4)
print("Original array:")
print(array_2d)
print()

# Select specific rows (in order)
row_indices = [1, 3, 5]
print(f"Select rows {row_indices}:")
print(array_2d[row_indices])
print()

# Select specific rows (reordered)
row_indices_reorder = [5, 1, 3]
print(f"Select rows {row_indices_reorder} (reordered):")
print(array_2d[row_indices_reorder])
print()

# Select rows and columns together
row_idx = [0, 2, 4]
col_idx = [1, 3, 2]
print(f"Select positions {list(zip(row_idx, col_idx))}:")
print(array_2d[row_idx, col_idx])
print()

# Use grid indexing to select submatrix
rows = np.array([1, 3])
cols = np.array([0, 2])
print("Select intersection of rows 1,3 and cols 0,2:")
print(array_2d[np.ix_(rows, cols)])

import numpy as np

array_2d = np.arange(20).reshape(4, 5)
print("Original array:")
print(array_2d)
print()

# Combine integer index and slice
print("Row 2, first 3 columns array_2d[2, :3]:")
print(array_2d[2, :3])
print()

# Combine boolean index and slice
row_mask = np.array([True, False, True, False])
print("Select rows 1 and 3, last 3 columns:")
print(array_2d[row_mask, -3:])
print()

# Combine integer array index and slice
row_indices = [0, 2]
print("Select rows 0 and 2, middle 3 columns:")
print(array_2d[row_indices, 1:4])
print()

# Complex combined indexing
print("Select rows satisfying condition, specific columns:")
row_condition = array_2d[:, 0] % 2 == 0  # Rows where first column is even
col_indices = [1, 3, 4]  # Select columns 1, 3, 4
result = array_2d[row_condition][:, col_indices]
print(f"Row condition: {row_condition}")
print(f"Column indices: {col_indices}")
print("Result:")
print(result)

import numpy as np

# 1D array modification
array_1d = np.array([1, 2, 3, 4, 5])
print("Original 1D array:", array_1d)

# Modify single element
array_1d[2] = 99
print("After modifying index 2:", array_1d)

# Modify multiple elements
array_1d[[0, 4]] = [88, 77]
print("After modifying indices 0 and 4:", array_1d)
print()

# 2D array modification
array_2d = np.arange(12).reshape(3, 4)
print("Original 2D array:")
print(array_2d)

# Modify single element
array_2d[1, 2] = 999
print("After modifying position (1,2):")
print(array_2d)

# Modify entire row
array_2d[0, :] = [100, 101, 102, 103]
print("After modifying row 0:")
print(array_2d)

# Modify entire column
array_2d[:, 1] = [200, 201, 202]
print("After modifying column 1:")
print(array_2d)

import numpy as np

array = np.array([1, 5, 3, 8, 2, 9, 4, 7, 6])
print("Original array:", array)

# Set elements > 5 to 0
array[array > 5] = 0
print("After setting elements > 5 to 0:", array)

# Recreate array
array = np.array([1, 5, 3, 8, 2, 9, 4, 7, 6])
print("\nRecreated array:", array)

# Multiply even elements by 10
array[array % 2 == 0] *= 10
print("After multiplying even elements by 10:", array)

# Conditional replacement
array = np.array([1, 5, 3, 8, 2, 9, 4, 7, 6])
print("\nRecreated array:", array)

# Use np.where for conditional replacement
result = np.where(array > 5, array, 0)  # Keep values > 5, else 0
print("Using np.where conditional replacement:", result)

# Complex conditional replacement
result = np.where((array > 3) & (array < 8), array * 2, array)
print("Elements 3<x<8 multiplied by 2:", result)

import numpy as np

# Simulate data with outliers
np.random.seed(42)
data = np.random.normal(50, 10, 20)  # Normal data
data[5] = 200   # Outlier
data[15] = -50  # Outlier

print("Original data:")
print(data)
print(f"Data statistics: mean={np.mean(data):.2f}, std={np.std(data):.2f}")
print()

# Identify outliers (beyond 3 standard deviations)
mean_val = np.mean(data)
std_val = np.std(data)
threshold = 3 * std_val

outliers_mask = np.abs(data - mean_val) > threshold
print("Outlier positions:", np.where(outliers_mask)[0])
print("Outlier values:", data[outliers_mask])
print()

# Clean data: remove outliers
clean_data = data[~outliers_mask]
print("Cleaned data:")
print(clean_data)
print(f"Cleaned statistics: mean={np.mean(clean_data):.2f}, std={np.std(clean_data):.2f}")
print()

# Or replace outliers with median
data_replaced = data.copy()
median_val = np.median(data[~outliers_mask])
data_replaced[outliers_mask] = median_val
print("After replacing outliers with median:")
print(data_replaced)
print(f"Replaced statistics: mean={np.mean(data_replaced):.2f}, std={np.std(data_replaced):.2f}")

import numpy as np

# Create a simple "image" (8x8 grayscale)
np.random.seed(42)
image = np.random.randint(0, 256, (8, 8), dtype=np.uint8)
print("Original image:")
print(image)
print()

# Extract region of interest (ROI)
roi = image[2:6, 2:6]  # Extract center 4x4 region
print("Region of Interest (ROI):")
print(roi)
print()

# Image thresholding
threshold = 128
binary_image = (image > threshold).astype(np.uint8) * 255
print(f"Binary image (threshold={threshold}):")
print(binary_image)
print()

# Image masking
# Create circular mask
y, x = np.ogrid[:8, :8]
center_y, center_x = 4, 4
radius = 3
circle_mask = (x - center_x)**2 + (y - center_y)**2 <= radius**2

print("Circular mask:")
print(circle_mask.astype(int))
print()

# Apply mask
masked_image = image.copy()
masked_image[~circle_mask] = 0  # Set pixels outside circle to 0
print("Image with circular mask applied:")
print(masked_image)

import numpy as np

# Simulate student grade data
np.random.seed(42)
students = 100
subjects = 5
scores = np.random.normal(75, 15, (students, subjects))  # Mean 75, std 15
scores = np.clip(scores, 0, 100)  # Limit to 0-100 range

print(f"Score data shape: {scores.shape}")
print(f"Score range: {scores.min():.1f} - {scores.max():.1f}")
print()

# Find excellent students (average > 85)
average_scores = np.mean(scores, axis=1)
excellent_students = average_scores > 85
print(f"Number of excellent students: {np.sum(excellent_students)}")
print(f"Excellent student averages: {average_scores[excellent_students][:5]}")
print()

# Find students needing help (any subject < 60)
failing_mask = scores < 60
students_need_help = np.any(failing_mask, axis=1)
print(f"Students needing help: {np.sum(students_need_help)}")
print()

# Analyze each subject
subject_names = ['Math', 'Language', 'English', 'Physics', 'Chemistry']
for i, subject in enumerate(subject_names):
    subject_scores = scores[:, i]
    print(f"{subject}: mean={np.mean(subject_scores):.1f}, "
          f"max={np.max(subject_scores):.1f}, "
          f"min={np.min(subject_scores):.1f}, "
          f"pass rate={np.sum(subject_scores >= 60)/len(subject_scores)*100:.1f}%")

print()

# Find each student's best and worst subjects
best_subjects = np.argmax(scores, axis=1)
worst_subjects = np.argmin(scores, axis=1)

print("Best/worst subjects for first 5 students:")
for i in range(5):
    print(f"Student {i+1}: Best-{subject_names[best_subjects[i]]}, "
          f"Worst-{subject_names[worst_subjects[i]]}")

import numpy as np

array = np.arange(10)
print("Original array:", array)

# Slicing creates view (shared memory)
slice_view = array[2:8]
print("Slice view:", slice_view)
print("Shares memory:", np.shares_memory(array, slice_view))

# Modifying view affects original
slice_view[0] = 999
print("After modifying view, original:", array)
print()

# Fancy indexing creates copy (independent memory)
array = np.arange(10)  # Recreate
fancy_copy = array[[1, 3, 5, 7]]
print("Fancy index result:", fancy_copy)
print("Shares memory:", np.shares_memory(array, fancy_copy))

# Modifying copy doesn't affect original
fancy_copy[0] = 888
print("After modifying copy, original:", array)
print("Modified copy:", fancy_copy)