import json
from collections import Counter, defaultdict
from itertools import combinations, permutations
import pandas as pd
from typing import Dict, List, Any, Optional
from pydantic import BaseModel, Field
import numpy as np

# 1. Create nested dictionary representing employee database
employee_db = {
    'employees': [
        {
            'id': 1,
            'name': 'Alice Johnson',
            'department': 'Engineering',
            'salary': 85000,
            'projects': ['Project A', 'Project B'],
            'skills': {'Python': 8, 'JavaScript': 6, 'SQL': 7},
            'hobbies': ['reading', 'hiking']
        },
        {
            'id': 2,
            'name': 'Bob Smith',
            'department': 'Marketing',
            'salary': 75000,
            'projects': ['Project C'],
            'skills': {'Photoshop': 9, 'SEO': 8, 'Copywriting': 7},
            'hobbies': ['gaming', 'cooking']
        },
        {
            'id': 3,
            'name': 'Charlie Brown',
            'department': 'Engineering',
            'salary': 92000,
            'projects': ['Project A', 'Project D'],
            'skills': {'Python': 9, 'C++': 7, 'Linux': 8},
            'hobbies': ['coding', 'swimming']
        }
    ]
}

# 2. JSON serialization and deserialization
print("JSON Serialization:")
json_data = json.dumps(employee_db, indent=2)
print(json_data)

print("\nJSON Deserialization:")
loaded_data = json.loads(json_data)
print(f"Loaded data type: {type(loaded_data)}")

# 3. Student class with methods
class Student(BaseModel):
    name: str
    age: int
    grades: List[float]
    major: str = Field(..., alias='major')
    
    def average_grade(self) -> float:
        return sum(self.grades) / len(self.grades)
    
    def is_honors_student(self) -> bool:
        return self.average_grade() >= 3.5
    
    def get_skill_level(self, skill: str) -> Optional[int]:
        if hasattr(self, 'skills') and skill in self.skills:
            return self.skills[skill]
        return None

# 4. Using Counter to analyze data
print("\nUsing Counter to analyze skills:")
all_skills = []
for emp in employee_db['employees']:
    all_skills.extend(emp['skills'].keys())
skill_counter = Counter(all_skills)
print("Skill frequencies:", skill_counter)

# 5. Using defaultdict for grouping data
print("\nUsing defaultdict to group employees by department:")
dept_groups = defaultdict(list)
for emp in employee_db['employees']:
    dept_groups[emp['department']].append(emp['name'])

for dept, names in dept_groups.items():
    print(f"{dept}: {names}")

# 6. Generator function for processing large datasets
def large_dataset_generator(size: int):
    """Generator that yields numbers from 1 to size"""
    for i in range(1, size + 1):
        yield i * 2  # Double each number

print("\nUsing generator to process large dataset:")
gen = large_dataset_generator(1000)
print("First 10 values from generator:", [next(gen) for _ in range(10)])

# 7. Using itertools for combinations and permutations

print("\nUsing itertools for combinations and permutations:")
data = ['A', 'B', 'C', 'D']
print("Combinations of 2 elements:", list(combinations(data, 2)))
print("Permutations of 3 elements:", list(permutations(data, 3)))

# 8. Handling missing data with pandas
print("\nHandling missing data with pandas:")
df = pd.DataFrame([
    {'name': 'Alice', 'age': 25, 'city': 'New York'},
    {'name': 'Bob', 'age': 30, 'city': None},
    {'name': 'Charlie', 'age': None, 'city': 'London'}
])

print("Original DataFrame:")
print(df)

# Fill missing values
df_filled = df.fillna({'age': df['age'].median(), 'city': 'Unknown'})
print("\nAfter filling missing values:")
print(df_filled)

# Drop rows with missing values
df_dropped = df.dropna()
print("\nAfter dropping rows with missing values:")
print(df_dropped)

# 9. Converting between data formats
print("\nConverting between data formats:")

# Dictionary to list of tuples
dict_to_list = [(k, v) for k, v in employee_db['employees'][0].items()]
print("Dictionary to list of tuples:", dict_to_list[:5])

# List to DataFrame
df_from_list = pd.DataFrame(employee_db['employees'])
print("\nList to DataFrame:")
print(df_from_list)

# DataFrame to JSON
json_from_df = df_from_list.to_json(orient='records')
print("\nDataFrame to JSON:")
print(json_from_df)

# 10. Data validation with Pydantic
print("\nData validation with Pydantic:")
try:
    student1 = Student(
        name="David Wilson",
        age=22,
        grades=[85, 90, 78],
        major="Computer Science"
    )
    print("Valid student:", student1)
    print(f"Average grade: {student1.average_grade():.2f}")
    print(f"Honors student: {student1.is_honors_student()}")
except Exception as e:
    print("Validation error:", str(e))

# Advanced example: filtering and transforming data
print("\nAdvanced data transformation:")
# Filter engineering employees with high salaries
engineering_high_salary = [
    emp for emp in employee_db['employees']
    if emp['department'] == 'Engineering' and emp['salary'] > 80000
]

print("Engineering employees with salary > $80,000:")
for emp in engineering_high_salary:
    print(f"{emp['name']}: ${emp['salary']}")

# Calculate average salary by department
dept_salaries = defaultdict(list)
for emp in employee_db['employees']:
    dept_salaries[emp['department']].append(emp['salary'])

avg_dept_salary = {dept: sum(salaries)/len(salaries) 
                   for dept, salaries in dept_salaries.items()}
print("\nAverage salary by department:", avg_dept_salary)

# Complex data analysis using numpy
print("\nComplex data analysis using numpy:")
all_salaries = np.array([emp['salary'] for emp in employee_db['employees']])
print(f"Total employees: {len(all_salaries)}")
print(f"Average salary: ${np.mean(all_salaries):.2f}")
print(f"Median salary: ${np.median(all_salaries):.2f}")
print(f"Standard deviation: ${np.std(all_salaries):.2f}")

import cv2
import numpy as np
import matplotlib.pyplot as plt
from pathlib import Path

# 1. Load image and display basic information
def load_and_display_info(image_path):
    img = cv2.imread(image_path)
    if img is None:
        raise FileNotFoundError(f"Image not found: {image_path}")
    
    print("Image loaded successfully")
    print(f"Shape: {img.shape}")
    print(f"Data type: {img.dtype}")
    print(f"Dimensions: {len(img.shape)}")
    
    return img

# 2. Display image in different formats
def display_images(images, titles, figsize=(15, 10)):
    fig, axes = plt.subplots(2, 4, figsize=figsize)
    axes = axes.ravel()
    
    for i, (img, title) in enumerate(zip(images, titles)):
        if len(img.shape) == 2:  # Grayscale
            axes[i].imshow(img, cmap='gray')
        else:  # Color
            axes[i].imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
        axes[i].set_title(title)
        axes[i].axis('off')
    
    plt.tight_layout()
    plt.show()

# 3. Convert color spaces
def convert_color_spaces(img):
    # RGB to Grayscale
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    
    # RGB to HSV
    hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
    
    # Grayscale to RGB
    gray_rgb = cv2.cvtColor(gray, cv2.COLOR_GRAY2BGR)
    
    return gray, hsv, gray_rgb

# 4. Apply different filters
def apply_filters(img):
    # Gaussian blur
    gaussian = cv2.GaussianBlur(img, (5, 5), 0)
    
    # Median filter
    median = cv2.medianBlur(img, 5)
    
    # Bilateral filter
    bilateral = cv2.bilateralFilter(img, 9, 75, 75)
    
    return gaussian, median, bilateral

# 5. Edge detection
def edge_detection(img):
    # Convert to grayscale first
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    
    # Canny edge detection
    canny = cv2.Canny(gray, 100, 200)
    
    # Sobel edge detection
    sobel_x = cv2.Sobel(gray, cv2.CV_64F, 1, 0, ksize=3)
    sobel_y = cv2.Sobel(gray, cv2.CV_64F, 0, 1, ksize=3)
    sobel = np.sqrt(sobel_x**2 + sobel_y**2)
    
    return canny, sobel

# 6. Morphological operations
def morphological_operations(img):
    # Convert to grayscale
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    
    # Threshold to create binary image
    _, binary = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)
    
    # Erosion
    kernel = np.ones((5, 5), np.uint8)
    erosion = cv2.erode(binary, kernel, iterations=1)
    
    # Dilation
    dilation = cv2.dilate(binary, kernel, iterations=1)
    
    # Opening (erosion followed by dilation)
    opening = cv2.morphologyEx(binary, cv2.MORPH_OPEN, kernel)
    
    # Closing (dilation followed by erosion)
    closing = cv2.morphologyEx(binary, cv2.MORPH_CLOSE, kernel)
    
    return erosion, dilation, opening, closing

# 7. Thresholding methods
def thresholding_methods(img):
    # Convert to grayscale
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    
    # Simple thresholding
    _, thresh_simple = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)
    
    # Adaptive thresholding
    thresh_adaptive = cv2.adaptiveThreshold(gray, 255, cv2.ADAPTIVE_THRESH_MEAN_C, 
                                          cv2.THRESH_BINARY, 11, 2)

# Otsu's thresholding
    _, thresh_otsu = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
    
    return thresh_simple, thresh_adaptive, thresh_otsu

# 8. Image transformations
def image_transformations(img):
    # Get image dimensions
    h, w = img.shape[:2]
    
    # Rotation
    rotation_matrix = cv2.getRotationMatrix2D((w/2, h/2), 45, 1.0)
    rotated = cv2.warpAffine(img, rotation_matrix, (w, h))
    
    # Scaling
    scaled = cv2.resize(img, None, fx=0.5, fy=0.5, interpolation=cv2.INTER_LINEAR)
    
    # Translation
    tx, ty = 100, 50
    translation_matrix = np.float32([[1, 0, tx], [0, 1, ty]])
    translated = cv2.warpAffine(img, translation_matrix, (w, h))
    
    return rotated, scaled, translated

# 9. Feature detection
def feature_detection(img):
    # Convert to grayscale
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    
    # SIFT feature detection
    try:
        sift = cv2.SIFT_create()
        keypoints_sift, descriptors_sift = sift.detectAndCompute(gray, None)
        img_sift = cv2.drawKeypoints(img, keypoints_sift, None, color=(255, 0, 0))
    except:
        print("SIFT not available")
        img_sift = img.copy()
    
    # ORB feature detection
    orb = cv2.ORB_create()
    keypoints_orb, descriptors_orb = orb.detectAndCompute(gray, None)
    img_orb = cv2.drawKeypoints(img, keypoints_orb, None, color=(0, 0, 255))
    
    return img_sift, img_orb

# 10. Contour detection
def detect_contours(img):
    # Convert to grayscale
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    
    # Threshold to get binary image
    _, binary = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)
    
    # Find contours
    contours, _ = cv2.findContours(binary, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
    
    # Draw contours on original image
    contour_img = img.copy()
    cv2.drawContours(contour_img, contours, -1, (0, 255, 0), 2)
    
    return contour_img, len(contours)

# Main function to demonstrate all techniques
def main():
    # Load image
    image_path = "example.jpg"  # Replace with actual image path
    try:
        img = load_and_display_info(image_path)
    except Exception as e:
        print(f"Error loading image: {e}")
        return
    
    # Create output directory
    output_dir = Path("output_images")
    output_dir.mkdir(exist_ok=True)
    
    # 1. Display original image
    original_images = [img]
    original_titles = ["Original Image"]
    
    # 2. Convert color spaces
    gray, hsv, gray_rgb = convert_color_spaces(img)
    color_conversion_images = [gray, hsv, gray_rgb]
    color_conversion_titles = ["Grayscale", "HSV", "Grayscale RGB"]
    
    # 3. Apply filters
    gaussian, median, bilateral = apply_filters(img)
    filter_images = [gaussian, median, bilateral]
    filter_titles = ["Gaussian Blur", "Median Filter", "Bilateral Filter"]
    
    # 4. Edge detection
    canny, sobel = edge_detection(img)
    edge_images = [canny, sobel]
    edge_titles = ["Canny Edges", "Sobel Edges"]
    
    # 5. Morphological operations
    erosion, dilation, opening, closing = morphological_operations(img)
    morph_images = [erosion, dilation, opening, closing]
    morph_titles = ["Erosion", "Dilation", "Opening", "Closing"]
    
    # 6. Thresholding methods
    simple, adaptive, otsu = thresholding_methods(img)
    threshold_images = [simple, adaptive, otsu]
    threshold_titles = ["Simple Threshold", "Adaptive Threshold", "Otsu's Threshold"]
    
    # 7. Image transformations
    rotated, scaled, translated = image_transformations(img)
    transform_images = [rotated, scaled, translated]
    transform_titles = ["Rotated", "Scaled", "Translated"]
    
    # 8. Feature detection
    sift_img, orb_img = feature_detection(img)
    feature_images = [sift_img, orb_img]
    feature_titles = ["SIFT Features", "ORB Features"]
    
    # 9. Contour detection
    contour_img, num_contours = detect_contours(img)
    contour_images = [contour_img]
    contour_titles = [f"Contours ({num_contours} detected)"]
    
    # Combine all images for display

import os
import subprocess
import shutil
import tempfile
import psutil
from pathlib import Path
import sys

# 1. List files and directories with detailed information
def list_directory_details():
    print("Directory contents with details:")
    for entry in os.scandir('.'):
        try:
            stat = entry.stat()
            print(f"{entry.name:<20} {stat.st_size:>8} bytes, "
                  f"modified: {stat.st_mtime}")
        except Exception as e:
            print(f"{entry.name}: Error - {e}")

# 2. Create directory and move file
def create_and_move_file():
    # Create new directory
    new_dir = "test_directory"
    os.makedirs(new_dir, exist_ok=True)
    
    # Create a test file
    test_file = "test_file.txt"
    with open(test_file, 'w') as f:
        f.write("This is a test file.")
    
    # Move file to new directory
    destination = os.path.join(new_dir, test_file)
    shutil.move(test_file, destination)
    
    print(f"Moved {test_file} to {destination}")

# 3. Execute system command and capture output
def execute_system_command():
    # List processes using ps command
    result = subprocess.run(['ps', '-eo', 'pid,comm'], 
                          capture_output=True, text=True)
    
    print("\nRunning processes:")
    print(result.stdout)

# 4. Get user information
def get_user_info():
    print(f"\nCurrent user: {os.getlogin()}")
    print(f"Home directory: {os.path.expanduser('~')}")
    print(f"Current working directory: {os.getcwd()}")

# 5. Check if process is running
def check_process_running(process_name):
    for proc in psutil.process_iter(['name']):
        try:
            if process_name.lower() in proc.info['name'].lower():
                return True
        except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
            pass
    return False

# 6. Environment variables
def manage_environment_variables():
    # Get environment variables
    print(f"\nPATH variable: {os.environ.get('PATH')}")
    print(f"HOME variable: {os.environ.get('HOME')}")
    
    # Set a new environment variable
    os.environ['TEST_VAR'] = 'Hello from Python'
    print(f"Set TEST_VAR: {os.environ.get('TEST_VAR')}")

# 7. Temporary files
def use_temporary_files():
    # Create temporary file
    with tempfile.NamedTemporaryFile(delete=False) as temp:
        temp.write(b"This is a temporary file.")
        temp_path = temp.name
    
    print(f"Created temporary file: {temp_path}")
    
    # Clean up
    os.unlink(temp_path)
    print("Temporary file deleted.")

# Main function to demonstrate all techniques
def main():
    print("=== Operating System Operations Demo ===\n")
    
    # 1. List directory details
    list_directory_details()
    
    # 2. Create directory and move file
    create_and_move_file()
    
    # 3. Execute system command
    execute_system_command()
    
    # 4. Get user info
    get_user_info()
    
    # 5. Check if process is running
    print(f"\nIs Python running? {check_process_running('python')}")
    
    # 6. Manage environment variables
    manage_environment_variables()
    
    # 7. Use temporary files
    use_temporary_files()
    
    print("\nAll operations completed successfully.")

if __name__ == "__main__":
    main()

def quicksort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quicksort(left) + middle + quicksort(right)

# Example usage
arr = [3, 6, 8, 10, 1, 2, 1]
print(quicksort(arr))  # Output: [1, 1, 2, 3, 6, 8, 10]

def dfs(graph, start, visited=None):
    if visited is None:
        visited = set()
    visited.add(start)
    print(start, end=' ')

    for neighbor in graph[start]:
        if neighbor not in visited:
            dfs(graph, neighbor, visited)

# Example usage
graph = {
    'A': ['B', 'C'],
    'B': ['D', 'E'],
    'C': ['F'],
    'D': [],
    'E': ['F'],
    'F': []
}
dfs(graph, 'A')  # Output: A B D E F C

import heapq
from collections import defaultdict
import sys

def dijkstra(graph, start):
    # Priority queue: (distance, node)
    pq = [(0, start)]
    distances = {start: 0}
    visited = set()
    
    while pq:
        current_dist, current_node = heapq.heappop(pq)
        
        if current_node in visited:
            continue
        visited.add(current_node)
        
        for neighbor, weight in graph[current_node]:
            if neighbor not in distances or distances[neighbor] > current_dist + weight:
                distances[neighbor] = current_dist + weight
                heapq.heappush(pq, (distances[neighbor], neighbor))
    
    return distances

# Example usage
graph = defaultdict(list)
graph['A'] = [('B', 4), ('C', 2)]
graph['B'] = [('C', 1), ('D', 5)]
graph['C'] = [('D', 8)]
graph['D'] = []

distances = dijkstra(graph, 'A')
print(distances)  # Output: {'A': 0, 'B': 4, 'C': 2, 'D': 6}

def tower_of_hanoi(n, source, auxiliary, target):
    if n == 1:
        print(f"Move disk 1 from {source} to {target}")
        return
    tower_of_hanoi(n - 1, source, target, auxiliary)
    print(f"Move disk {n} from {source} to {target}")
    tower_of_hanoi(n - 1, auxiliary, source, target)

# Example usage
tower_of_hanoi(3, 'A', 'B', 'C')

import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.datasets import cifar10
from tensorflow.keras.utils import to_categorical

# Load and preprocess data
(x_train, y_train), (x_test, y_test) = cifar10.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0
y_train, y_test = to_categorical(y_train), to_categorical(y_test)

# Build CNN model
model = models.Sequential([
    layers.Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)),
    layers.MaxPooling2D((2, 2)),
    layers.Conv2D(64, (3, 3), activation='relu'),
    layers.MaxPooling2D((2, 2)),
    layers.Conv2D(64, (3, 3), activation='relu'),
    layers.Flatten(),
    layers.Dense(64, activation='relu'),
    layers.Dense(10, activation='softmax')
])

# Compile and train
model.compile(optimizer='adam',
              loss='categorical_crossentropy',
              metrics=['accuracy'])

model.fit(x_train, y_train, epochs=10, validation_data=(x_test, y_test))

# Evaluate
test_loss, test_acc = model.evaluate(x_test, y_test)
print(f"Test Accuracy: {test_acc}")

import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.datasets import imdb
from tensorflow.keras.preprocessing.sequence import pad_sequences

# Load and preprocess data
vocab_size = 10000
max_length = 250
(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=vocab_size)
x_train = pad_sequences(x_train, maxlen=max_length)
x_test = pad_sequences(x_test, maxlen=max_length)

# Build RNN model
model = models.Sequential([
    layers.Embedding(vocab_size, 128, input_length=max_length),
    layers.SimpleRNN(64, return_sequences=False),
    layers.Dense(32, activation='relu'),
    layers.Dense(1, activation='sigmoid')
])

# Compile and train
model.compile(optimizer='adam',
              loss='binary_crossentropy',
              metrics=['accuracy'])

model.fit(x_train, y_train, epochs=5, validation_data=(x_test, y_test))

# Evaluate
test_loss, test_acc = model.evaluate(x_test, y_test)
print(f"Test Accuracy: {test_acc}")

import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.svm import SVC
from sklearn.metrics import accuracy_score

# Load dataset
X, y = datasets.make_classification(n_samples=100, n_features=2, n_redundant=0, n_informative=2, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Scale features
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)

# Train SVM with linear kernel
svm_linear = SVC(kernel='linear')
svm_linear.fit(X_train, y_train)

# Predict and evaluate
y_pred = svm_linear.predict(X_test)
accuracy = accuracy_score(y_test, y_pred)
print(f"Accuracy: {accuracy:.2f}")

# Plot decision boundary
plt.figure(figsize=(8, 6))
plt.scatter(X[:, 0], X[:, 1], c=y, cmap='viridis', edgecolor='k')
ax = plt.gca()
xlim = ax.get_xlim()
ylim = ax.get_ylim()

# Create grid to evaluate model
xx, yy = np.meshgrid(np.linspace(xlim[0], xlim[1], 50),
                     np.linspace(ylim[0], ylim[1], 50))
Z = svm_linear.decision_function(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)

# Plot decision boundary and margins
plt.contour(xx, yy, Z, colors='k', levels=[-1, 0, 1], alpha=0.5,
            linestyles=['--', '-', '--'])
plt.scatter(svm_linear.support_vectors_[:, 0], svm_linear.support_vectors_[:, 1],
            s=100, facecolors='none', edgecolors='k')
plt.title("SVM with Linear Kernel")
plt.show()

import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score, confusion_matrix
import seaborn as sns

# Load dataset
data = datasets.load_iris()
X = data.data
y = data.target
feature_names = data.feature_names
target_names = data.target_names

# Split and scale data
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# Train KNN model with k=5
knn = KNeighborsClassifier(n_neighbors=5, metric='euclidean')
knn.fit(X_train_scaled, y_train)

# Predict and evaluate
y_pred = knn.predict(X_test_scaled)
accuracy = accuracy_score(y_test, y_pred)
print(f"Accuracy: {accuracy:.2f}")

# Confusion Matrix
cm = confusion_matrix(y_test, y_pred)
plt.figure(figsize=(6, 4))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=target_names, yticklabels=target_names)
plt.title('Confusion Matrix')
plt.ylabel('True Label')
plt.xlabel('Predicted Label')
plt.show()

# Visualize decision boundaries (for first two features only)
plt.figure(figsize=(8, 6))
X_plot = X[:, :2]  # Use only first two features for visualization
X_plot_scaled = scaler.fit_transform(X_plot)
knn_visual = KNeighborsClassifier(n_neighbors=5)
knn_visual.fit(X_plot_scaled, y)
h = 0.02
x_min, x_max = X_plot_scaled[:, 0].min() - 1, X_plot_scaled[:, 0].max() + 1
y_min, y_max = X_plot_scaled[:, 1].min() - 1, X_plot_scaled[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))
Z = knn_visual.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
plt.contourf(xx, yy, Z, alpha=0.3, cmap=plt.cm.Paired)
for i, color in enumerate(['red', 'green', 'blue']):
    idx = np.where(y == i)
    plt.scatter(X_plot_scaled[idx, 0], X_plot_scaled[idx, 1], c=color, label=target_names[i], edgecolors='k')
plt.xlabel(feature_names[0])
plt.ylabel(feature_names[1])
plt.title('KNN Decision Boundaries (First Two Features)')
plt.legend()
plt.show()

import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
from sklearn.model_selection import train_test_split, cross_val_score, GridSearchCV
from sklearn.preprocessing import StandardScaler
from sklearn.pipeline import Pipeline
from sklearn.svm import SVC
from sklearn.metrics import classification_report, confusion_matrix
import seaborn as sns

# Load dataset
data = datasets.load_iris()
X = data.data
y = data.target
feature_names = data.feature_names
target_names = data.target_names

# Split data into train and test sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

# Create a pipeline with preprocessing and model
pipeline = Pipeline([
    ('scaler', StandardScaler()),
    ('classifier', SVC(kernel='rbf', random_state=42))
])

# Train the model
pipeline.fit(X_train, y_train)

# Make predictions
y_pred = pipeline.predict(X_test)

# Evaluate the model
accuracy = pipeline.score(X_test, y_test)
print(f"Accuracy: {accuracy:.2f}")

# Classification report
print("Classification Report:")
print(classification_report(y_test, y_pred, target_names=target_names))

# Confusion Matrix
cm = confusion_matrix(y_test, y_pred)
plt.figure(figsize=(6, 4))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=target_names, yticklabels=target_names)
plt.title('Confusion Matrix')
plt.ylabel('True Label')
plt.xlabel('Predicted Label')
plt.show()

# Cross-validation
cv_scores = cross_val_score(pipeline, X_train, y_train, cv=5)
print(f"Cross-validation scores: {cv_scores}")
print(f"Mean CV Score: {cv_scores.mean():.2f} ± {cv_scores.std():.2f}")

# Hyperparameter tuning using GridSearchCV
param_grid = {
    'classifier__C': [0.1, 1, 10],
    'classifier__gamma': ['scale', 'auto', 0.1, 1]
}
grid_search = GridSearchCV(pipeline, param_grid, cv=5, scoring='accuracy')
grid_search.fit(X_train, y_train)

print("Best parameters:", grid_search.best_params_)
print("Best cross-validation score:", grid_search.best_score_)

# Final model with best parameters
best_model = grid_search.best_estimator_
final_predictions = best_model.predict(X_test)
final_accuracy = accuracy_score(y_test, final_predictions)
print(f"Final Accuracy with tuned model: {final_accuracy:.2f}")

import numpy as np
import matplotlib.pyplot as plt
from scipy.integrate import solve_ivp
from scipy.optimize import minimize
from scipy.signal import butter, filtfilt
from scipy.interpolate import interp1d

# 1. Numerical Integration: Solve a system of ODEs (e.g., predator-prey model)
def predator_prey(t, y):
    x, y = y  # x = prey, y = predator
    dxdt = 0.5 * x - 0.02 * x * y
    dydt = -0.4 * y + 0.01 * x * y
    return [dxdt, dydt]

# Initial conditions: [prey, predator]
initial_conditions = [40, 9]
t_span = [0, 100]
solution = solve_ivp(predator_prey, t_span, initial_conditions, t_eval=np.linspace(0, 100, 1000))

plt.figure(figsize=(10, 6))
plt.plot(solution.t, solution.y[0], label='Prey')
plt.plot(solution.t, solution.y[1], label='Predator')
plt.xlabel('Time')
plt.ylabel('Population')
plt.title('Predator-Prey Model Solution')
plt.legend()
plt.grid(True)
plt.show()

# 2. Optimization: Minimize a function
def objective_function(x):
    return x[0]**2 + x[1]**2 + 10 * np.sin(x[0]) * np.sin(x[1])

# Initial guess
x0 = [1, 1]
result = minimize(objective_function, x0, method='BFGS')

print("Optimization Result:")
print(f"Minimum value: {result.fun}")
print(f"Optimal point: {result.x}")

# Plot the function and minimum
x = np.linspace(-5, 5, 100)
y = np.linspace(-5, 5, 100)
X, Y = np.meshgrid(x, y)
Z = X**2 + Y**2 + 10 * np.sin(X) * np.sin(Y)

plt.figure(figsize=(8, 6))
contour = plt.contour(X, Y, Z, levels=50, cmap='viridis')
plt.colorbar(contour)
plt.scatter(result.x[0], result.x[1], color='red', s=100, label='Minimum')
plt.title('Function Minimization with SciPy')
plt.xlabel('x')
plt.ylabel('y')
plt.legend()
plt.grid(True)
plt.show()

# 3. Signal Processing: Filter a noisy sine wave
t = np.linspace(0, 10, 1000)
signal = np.sin(2 * np.pi * t) + 0.5 * np.random.randn(len(t))  # Noisy signal

# Design Butterworth filter
b, a = butter(4, 0.1, btype='low')  # Low-pass filter
filtered_signal = filtfilt(b, a, signal)

plt.figure(figsize=(10, 6))
plt.plot(t, signal, label='Noisy Signal', alpha=0.7)
plt.plot(t, filtered_signal, label='Filtered Signal', linewidth=2)
plt.xlabel('Time')
plt.ylabel('Amplitude')
plt.title('Low-Pass Filtering with SciPy')
plt.legend()
plt.grid(True)
plt.show()

# 4. Interpolation: Fit a smooth curve to scattered data
x_data = np.array([0, 1, 2, 3, 4])
y_data = np.array([0, 1, 0, 1, 0])
f = interp1d(x_data, y_data, kind='cubic')

x_new = np.linspace(0, 4, 100)
y_new = f(x_new)

plt.figure(figsize=(8, 6))
plt.scatter(x_data, y_data, color='red', label='Data Points')
plt.plot(x_new, y_new, label='Interpolated Curve', linewidth=2)
plt.xlabel('x')
plt.ylabel('y')
plt.title('Cubic Interpolation with SciPy')
plt.legend()
plt.grid(True)
plt.show()

x = [1, 2, 3]
y = x
y.append(4)
print(x)

def func(a, b=[]):
    b.append(a)
    return b

print(func(1))
print(func(2))

print(2 ** 3 ** 2)

list1 = [1, 2, 3]
list2 = list1.copy()
list2[0] = 10
print(list1)

a = [1, 2, 3]
b = a[:]
b[0] = 10
print(a)

x = "hello"
y = "world"
print(x + y)