a = [1, 2, 3]
b = a
b.append(4)
print(a)
print(a is b)

# Step 1: Create a list and assign to variable 'a'
a = [1, 2, 3]
# Memory: a points to list object [1, 2, 3]
 
# Step 2: Assign 'a' to 'b'
b = a
# IMPORTANT: This does NOT copy the list!
# Both 'a' and 'b' now point to the SAME list object in memory
# Memory: a → [1, 2, 3] ← b
 
# Step 3: Modify list through 'b'
b.append(4)
# Since a and b point to the same object, 
# the change is visible through both variables
# Memory: a → [1, 2, 3, 4] ← b
 
# Step 4: Print results
print(a)        # [1, 2, 3, 4] - modified through b
print(a is b)   # True - same object in memory

b = a.copy()     # Method 1: copy() method
b = a[:]         # Method 2: slice notation
b = list(a)      # Method 3: list constructor

text = "Hello World"
print(text[0:5:2])
print(text[-5:-1])

text = "Hello World"
 
# Index map:
# Character: H   e   l   l   o       W   o   r   l   d
# Positive:  0   1   2   3   4   5   6   7   8   9   10
# Negative:-11 -10  -9  -8  -7  -6  -5  -4  -3  -2  -1
 
# Line 1: text[0:5:2]
# Format: [start:stop:step]
# start=0 (H), stop=5 (exclusive), step=2 (every 2nd char)
# Indices: 0, 2, 4 → Characters: 'H', 'l', 'o'
result1 = text[0:5:2]  # "Hlo"
 
# Line 2: text[-5:-1]
# start=-5 (W), stop=-1 (exclusive, before 'd')
# Indices: -5, -4, -3, -2 → Characters: 'W', 'o', 'r', 'l'
result2 = text[-5:-1]  # "Worl"

def outer():
    x = 10
    def inner():
        nonlocal x
        x += 5
        return x
    return inner()
 
print(outer())
print(outer())

def outer():
    x = 10  # Local variable in outer's scope
    
    def inner():
        nonlocal x  # Refers to x in enclosing (outer) scope
        x += 5      # Modify outer's x: 10 + 5 = 15
        return x    # Return 15
    
    return inner()  # Call inner() and return its result
 
# First call: outer()
# - x starts at 10 in a NEW local scope
# - inner() adds 5: x = 15
# - Returns 15
print(outer())  # 15
 
# Second call: outer()
# - FRESH call creates NEW local scope
# - x starts at 10 again (not preserved from first call)
# - inner() adds 5: x = 15
# - Returns 15
print(outer())  # 15

nums = [1, 2, 3, 4, 5]
result = [x**2 for x in nums if x % 2 == 1]
print(result)
print(sum(result))

nums = [1, 2, 3, 4, 5]
 
# List comprehension with filter
# Pattern: [expression for item in iterable if condition]
result = [x**2 for x in nums if x % 2 == 1]
 
# Step-by-step execution:
# x=1: 1 % 2 == 1? True  → 1**2 = 1   → include
# x=2: 2 % 2 == 1? False → skip
# x=3: 3 % 2 == 1? True  → 3**2 = 9   → include
# x=4: 4 % 2 == 1? False → skip
# x=5: 5 % 2 == 1? True  → 5**2 = 25  → include
 
# Result: [1, 9, 25]
 
print(result)       # [1, 9, 25]
print(sum(result))  # 1 + 9 + 25 = 35

def count_vowels(text):
    """
    Count the number of vowels in a string.
    
    Vowels are: a, e, i, o, u (case insensitive)
    
    Args:
        text: Input string to analyze
        
    Returns:
        int: Number of vowels found
        
    Examples:
        >>> count_vowels("Hello World")
        3
        >>> count_vowels("AEIOU")
        5
    """
    # Define vowels (both cases for easy comparison)
    vowels = "aeiouAEIOU"
    
    # Initialize counter
    count = 0
    
    # Iterate through each character in the text
    for char in text:
        # Check if character is a vowel
        if char in vowels:
            count += 1
    
    return count
 
 
# Alternative: More Pythonic one-liner
def count_vowels_v2(text):
    """One-liner using generator expression and sum."""
    return sum(1 for char in text.lower() if char in 'aeiou')
 
 
# Alternative: Using count method
def count_vowels_v3(text):
    """Using str.count() for each vowel."""
    text_lower = text.lower()
    return sum(text_lower.count(v) for v in 'aeiou')
 
 
# ===== Test Cases =====
if __name__ == "__main__":
    test_cases = [
        ("Hello World", 3),      # e, o, o
        ("AEIOU", 5),            # all uppercase vowels
        ("rhythm", 0),           # no vowels
        ("", 0),                 # empty string
        ("AaEeIiOoUu", 10),      # mixed case
    ]
    
    print("Testing count_vowels:")
    for text, expected in test_cases:
        result = count_vowels(text)
        status = "✓" if result == expected else "✗"
        print(f'  {status} count_vowels("{text}") = {result} (expected {expected})')

def word_frequency(words):
    """
    Count frequency of each word in a list.
    
    Args:
        words: List of words (strings)
        
    Returns:
        dict: Dictionary mapping each word to its count
        
    Examples:
        >>> word_frequency(['a', 'b', 'a'])
        {'a': 2, 'b': 1}
    """
    # Initialize empty frequency dictionary
    freq = {}
    
    # Count each word
    for word in words:
        if word in freq:
            # Word seen before - increment count
            freq[word] += 1
        else:
            # First occurrence - initialize count to 1
            freq[word] = 1
    
    return freq
 
 
# Alternative: Using dict.get()
def word_frequency_v2(words):
    """Using get() method to simplify logic."""
    freq = {}
    for word in words:
        # get(key, default) returns default if key doesn't exist
        freq[word] = freq.get(word, 0) + 1
    return freq
 
 
# Alternative: Using collections.Counter
def word_frequency_v3(words):
    """Using Counter from collections (most Pythonic)."""
    from collections import Counter
    return dict(Counter(words))
 
 
# ===== Test Cases =====
if __name__ == "__main__":
    test_cases = [
        ['a', 'b', 'a'],
        ['hello', 'world', 'hello', 'hello'],
        [],
        ['single'],
    ]
    
    print("Testing word_frequency:")
    for words in test_cases:
        result = word_frequency(words)
        print(f"  {words} → {result}")

def multiplication_table(n):
    """
    Print an n×n multiplication table.
    
    Args:
        n: Size of the table (positive integer)
        
    Example output for n=3:
        1 x 1 = 1
        1 x 2 = 2
        1 x 3 = 3
        2 x 1 = 2
        ...
        3 x 3 = 9
    """
    # Validate input
    if n <= 0:
        print("Please provide a positive integer.")
        return
    
    # Outer loop: rows (first multiplier)
    for i in range(1, n + 1):
        
        # Inner loop: columns (second multiplier)
        for j in range(1, n + 1):
            
            # Calculate product
            product = i * j
            
            # Print formatted result using f-string
            print(f"{i} x {j} = {product}")
 
 
# Alternative: Compact table format
def multiplication_table_compact(n):
    """Print table in grid format."""
    for i in range(1, n + 1):
        row = ""
        for j in range(1, n + 1):
            row += f"{i*j:4}"  # 4-character width for alignment
        print(row)
 
 
# ===== Test Cases =====
if __name__ == "__main__":
    print("3x3 Multiplication Table:")
    print("-" * 20)
    multiplication_table(3)
    
    print("\n3x3 Compact Format:")
    print("-" * 20)
    multiplication_table_compact(3)

def find_max_min(numbers):
    """
    Find maximum, minimum, and their difference in a list.
    
    Args:
        numbers: List of numeric values
        
    Returns:
        tuple: (maximum, minimum, difference) or (None, None, None) if empty
        
    Examples:
        >>> find_max_min([5, 2, 8, 1, 9])
        (9, 1, 8)
        >>> find_max_min([])
        (None, None, None)
    """
    # Handle empty list edge case
    # IMPORTANT: Check this first to avoid errors with min()/max()
    if not numbers:  # Empty list is falsy in Python
        return (None, None, None)
    
    # Find maximum and minimum using built-in functions
    maximum = max(numbers)
    minimum = min(numbers)
    
    # Calculate difference (range of values)
    difference = maximum - minimum
    
    return (maximum, minimum, difference)
 
 
# Alternative: Without using built-in min/max
def find_max_min_manual(numbers):
    """Manual implementation without min()/max()."""
    if not numbers:
        return (None, None, None)
    
    # Initialize with first element
    maximum = numbers[0]
    minimum = numbers[0]
    
    # Iterate through remaining elements
    for num in numbers[1:]:
        if num > maximum:
            maximum = num
        if num < minimum:
            minimum = num
    
    return (maximum, minimum, maximum - minimum)
 
 
# ===== Test Cases =====
if __name__ == "__main__":
    test_cases = [
        [5, 2, 8, 1, 9],      # Normal case
        [3],                   # Single element
        [],                    # Empty list
        [-5, -2, -8, -1],     # Negative numbers
        [1, 1, 1, 1],         # All same
    ]
    
    print("Testing find_max_min:")
    for nums in test_cases:
        result = find_max_min(nums)
        print(f"  {nums} → max={result[0]}, min={result[1]}, diff={result[2]}")

def factorial(n):
    """
    Calculate factorial of n using recursion.
    
    Factorial definition:
    - n! = n × (n-1) × (n-2) × ... × 2 × 1
    - 0! = 1 (by definition)
    - Negative numbers: undefined (return None)
    
    Args:
        n: Non-negative integer
        
    Returns:
        int: n! or None for negative input
        
    Examples:
        >>> factorial(5)
        120
        >>> factorial(0)
        1
    """
    # Handle negative input
    if n < 0:
        return None
    
    # Base case: 0! = 1 and 1! = 1
    if n == 0 or n == 1:
        return 1
    
    # Recursive case: n! = n × (n-1)!
    return n * factorial(n - 1)
 
 
# Trace for factorial(4):
# factorial(4) = 4 × factorial(3)
#              = 4 × (3 × factorial(2))
#              = 4 × (3 × (2 × factorial(1)))
#              = 4 × (3 × (2 × 1))
#              = 4 × (3 × 2)
#              = 4 × 6
#              = 24
 
 
# Alternative: Iterative version (no recursion)
def factorial_iterative(n):
    """Calculate factorial using iteration."""
    if n < 0:
        return None
    
    result = 1
    for i in range(2, n + 1):
        result *= i
    return result
 
 
# ===== Test Cases =====
if __name__ == "__main__":
    test_cases = [
        (0, 1),      # 0! = 1
        (1, 1),      # 1! = 1
        (5, 120),    # 5! = 120
        (10, 3628800),
        (-5, None),  # Negative
    ]
    
    print("Testing factorial:")
    for n, expected in test_cases:
        result = factorial(n)
        status = "✓" if result == expected else "✗"
        print(f"  {status} factorial({n}) = {result} (expected {expected})")

import pandas as pd
from sklearn.preprocessing import LabelEncoder, StandardScaler
 
data = {
    'Age': [25, 30, None, 35, 40],
    'Income': [30000, 50000, 45000, None, 60000],
    'Education': ['High School', 'Bachelor', 'Master', 'PhD', 'Bachelor'],
    'Purchased': ['No', 'Yes', 'Yes', 'No', 'Yes']
}
df = pd.DataFrame(data)

import pandas as pd
 
# Create the DataFrame
data = {
    'Age': [25, 30, None, 35, 40],
    'Income': [30000, 50000, 45000, None, 60000],
    'Education': ['High School', 'Bachelor', 'Master', 'PhD', 'Bachelor'],
    'Purchased': ['No', 'Yes', 'Yes', 'No', 'Yes']
}
df = pd.DataFrame(data)
 
print("Original DataFrame:")
print(df)
print()
 
# Calculate statistics before filling
age_median = df['Age'].median()    # Median of [25, 30, 35, 40] = 32.5
income_mean = df['Income'].mean()  # Mean of [30000, 50000, 45000, 60000] = 46250
 
print(f"Age median (excluding NaN): {age_median}")
print(f"Income mean (excluding NaN): {income_mean}")
print()
 
# Fill missing values
# Method 1: Using fillna with inplace
df['Age'].fillna(age_median, inplace=True)
df['Income'].fillna(income_mean, inplace=True)
 
# Method 2: Using assignment (alternative)
# df['Age'] = df['Age'].fillna(df['Age'].median())
# df['Income'] = df['Income'].fillna(df['Income'].mean())
 
print("After filling missing values:")
print(df)

from sklearn.preprocessing import LabelEncoder
 
# Create LabelEncoder instance
le = LabelEncoder()
 
# Fit and transform the Education column
df['Education_Encoded'] = le.fit_transform(df['Education'])
 
print("Encoding result:")
print(df[['Education', 'Education_Encoded']])
print()
 
# Show the mapping (classes are sorted alphabetically)
print("LabelEncoder mapping:")
for i, label in enumerate(le.classes_):
    print(f"  '{label}' → {i}")

from sklearn.svm import SVC
 
# Linear kernel
model_linear = SVC(kernel='linear')
 
# RBF kernel (default)
model_rbf = SVC(kernel='rbf')
 
# Polynomial kernel
model_poly = SVC(kernel='poly', degree=3)