Exemples de Structures de Données Web Python

# Web Python Array Operations Examples
# Using Python lists for array operations with comprehensive CRUD functionality

# 1. Basic Array/List Operations
from typing import List, Any, Optional, Callable
import bisect

def create_array(elements: List[Any] = None) -> List[Any]:
    """
    Create a new array (list)

    Args:
        elements: Initial elements

    Returns:
        New list
    """
    return elements.copy() if elements else []

def add_element(array: List[Any], element: Any, position: Optional[int] = None) -> List[Any]:
    """
    Add element to array

    Args:
        array: Target array
        element: Element to add
        position: Position to insert (None = append)

    Returns:
        Modified array
    """
    if position is None:
        array.append(element)
    else:
        array.insert(position, element)
    return array

def remove_element(array: List[Any], element: Any) -> bool:
    """
    Remove element from array

    Args:
        array: Target array
        element: Element to remove

    Returns:
        True if removed
    """
    try:
        array.remove(element)
        return True
    except ValueError:
        return False

def remove_at(array: List[Any], index: int) -> Any:
    """
    Remove element at index

    Args:
        array: Target array
        index: Index to remove

    Returns:
        Removed element
    """
    if 0 <= index < len(array):
        return array.pop(index)
    return None

def get_element(array: List[Any], index: int) -> Any:
    """
    Get element at index

    Args:
        array: Target array
        index: Index to get

    Returns:
        Element at index
    """
    return array[index] if 0 <= index < len(array) else None

def update_element(array: List[Any], index: int, new_value: Any) -> bool:
    """
    Update element at index

    Args:
        array: Target array
        index: Index to update
        new_value: New value

    Returns:
        True if updated
    """
    if 0 <= index < len(array):
        array[index] = new_value
        return True
    return False

def find_index(array: List[Any], element: Any) -> int:
    """
    Find index of element

    Args:
        array: Target array
        element: Element to find

    Returns:
        Index or -1 if not found
    """
    try:
        return array.index(element)
    except ValueError:
        return -1

def contains(array: List[Any], element: Any) -> bool:
    """
    Check if array contains element

    Args:
        array: Target array
        element: Element to check

    Returns:
        True if contains
    """
    return element in array

def get_size(array: List[Any]) -> int:
    """
    Get array size

    Args:
        array: Target array

    Returns:
        Array length
    """
    return len(array)

def is_empty(array: List[Any]) -> bool:
    """
    Check if array is empty

    Args:
        array: Target array

    Returns:
        True if empty
    """
    return len(array) == 0

def clear_array(array: List[Any]) -> List[Any]:
    """
    Clear all elements

    Args:
        array: Target array

    Returns:
        Empty array
    """
    array.clear()
    return array

# 2. Sorting Operations
def bubble_sort(array: List[Any], key: Optional[Callable] = None, reverse: bool = False) -> List[Any]:
    """
    Bubble sort algorithm

    Args:
        array: Array to sort
        key: Sort key function
        reverse: Sort descending

    Returns:
        Sorted array
    """
    arr = array.copy()
    n = len(arr)

    for i in range(n):
        for j in range(0, n - i - 1):
            if key:
                a, b = key(arr[j]), key(arr[j + 1])
            else:
                a, b = arr[j], arr[j + 1]

            if reverse:
                should_swap = a < b
            else:
                should_swap = a > b

            if should_swap:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]

    return arr

def quick_sort(array: List[Any], key: Optional[Callable] = None, reverse: bool = False) -> List[Any]:
    """
    Quick sort algorithm

    Args:
        array: Array to sort
        key: Sort key function
        reverse: Sort descending

    Returns:
        Sorted array
    """
    if len(array) <= 1:
        return array

    pivot = array[len(array) // 2]

    if key:
        pivot_value = key(pivot)
    else:
        pivot_value = pivot

    left = [x for x in array if (key(x) if key else x) < pivot_value]
    middle = [x for x in array if (key(x) if key else x) == pivot_value]
    right = [x for x in array if (key(x) if key else x) > pivot_value]

    if reverse:
        return quick_sort(right, key, reverse) + middle + quick_sort(left, key, reverse)
    else:
        return quick_sort(left, key, reverse) + middle + quick_sort(right, key, reverse)

def merge_sort(array: List[Any], key: Optional[Callable] = None, reverse: bool = False) -> List[Any]:
    """
    Merge sort algorithm

    Args:
        array: Array to sort
        key: Sort key function
        reverse: Sort descending

    Returns:
        Sorted array
    """
    if len(array) <= 1:
        return array

    mid = len(array) // 2
    left = merge_sort(array[:mid], key, reverse)
    right = merge_sort(array[mid:], key, reverse)

    return merge(left, right, key, reverse)

def merge(left: List[Any], right: List[Any], key: Optional[Callable], reverse: bool) -> List[Any]:
    """Merge two sorted arrays"""
    result = []
    i = j = 0

    while i < len(left) and j < len(right):
        left_val = key(left[i]) if key else left[i]
        right_val = key(right[j]) if key else right[j]

        if reverse:
            condition = left_val >= right_val
        else:
            condition = left_val <= right_val

        if condition:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1

    result.extend(left[i:])
    result.extend(right[j:])
    return result

def sort_array(array: List[Any], key: Optional[Callable] = None, reverse: bool = False, algorithm: str = 'builtin') -> List[Any]:
    """
    Sort array using specified algorithm

    Args:
        array: Array to sort
        key: Sort key function
        reverse: Sort descending
        algorithm: 'builtin', 'bubble', 'quick', 'merge'

    Returns:
        Sorted array
    """
    if algorithm == 'bubble':
        return bubble_sort(array, key, reverse)
    elif algorithm == 'quick':
        return quick_sort(array, key, reverse)
    elif algorithm == 'merge':
        return merge_sort(array, key, reverse)
    else:
        return sorted(array, key=key, reverse=reverse)

# 3. Searching Operations
def linear_search(array: List[Any], target: Any, key: Optional[Callable] = None) -> int:
    """
    Linear search

    Args:
        array: Array to search
        target: Target value
        key: Key function for comparison

    Returns:
        Index or -1 if not found
    """
    for i, element in enumerate(array):
        value = key(element) if key else element
        if value == target:
            return i
    return -1

def binary_search(array: List[Any], target: Any, key: Optional[Callable] = None) -> int:
    """
    Binary search (requires sorted array)

    Args:
        array: Sorted array to search
        target: Target value
        key: Key function for comparison

    Returns:
        Index or -1 if not found
    """
    left, right = 0, len(array) - 1

    while left <= right:
        mid = (left + right) // 2
        mid_value = key(array[mid]) if key else array[mid]

        if mid_value == target:
            return mid
        elif mid_value < target:
            left = mid + 1
        else:
            right = mid - 1

    return -1

def find_all(array: List[Any], target: Any, key: Optional[Callable] = None) -> List[int]:
    """
    Find all occurrences

    Args:
        array: Array to search
        target: Target value
        key: Key function for comparison

    Returns:
        List of indices
    """
    indices = []
    for i, element in enumerate(array):
        value = key(element) if key else element
        if value == target:
            indices.append(i)
    return indices

def find_min(array: List[Any], key: Optional[Callable] = None) -> Any:
    """
    Find minimum element

    Args:
        array: Array to search
        key: Key function for comparison

    Returns:
        Minimum element
    """
    if not array:
        return None
    return min(array, key=key) if key else min(array)

def find_max(array: List[Any], key: Optional[Callable] = None) -> Any:
    """
    Find maximum element

    Args:
        array: Array to search
        key: Key function for comparison

    Returns:
        Maximum element
    """
    if not array:
        return None
    return max(array, key=key) if key else max(array)

# 4. Transformation Operations
def map_array(array: List[Any], func: Callable[[Any], Any]) -> List[Any]:
    """
    Apply function to all elements

    Args:
        array: Source array
        func: Transform function

    Returns:
        New array
    """
    return [func(x) for x in array]

def filter_array(array: List[Any], predicate: Callable[[Any], bool]) -> List[Any]:
    """
    Filter elements by predicate

    Args:
        array: Source array
        predicate: Filter function

    Returns:
        Filtered array
    """
    return [x for x in array if predicate(x)]

def reduce_array(array: List[Any], func: Callable[[Any, Any], Any], initial: Any = None) -> Any:
    """
    Reduce array to single value

    Args:
        array: Source array
        func: Reduce function
        initial: Initial value

    Returns:
        Reduced value
    """
    if initial is not None:
        result = initial
        for x in array:
            result = func(result, x)
    else:
        result = array[0]
        for x in array[1:]:
            result = func(result, x)
    return result

def flatten_array(array: List[Any]) -> List[Any]:
    """
    Flatten nested array

    Args:
        array: Nested array

    Returns:
        Flattened array
    """
    result = []
    for element in array:
        if isinstance(element, list):
            result.extend(flatten_array(element))
        else:
            result.append(element)
    return result

def chunk_array(array: List[Any], size: int) -> List[List[Any]]:
    """
    Split array into chunks

    Args:
        array: Source array
        size: Chunk size

    Returns:
        List of chunks
    """
    return [array[i:i + size] for i in range(0, len(array), size)]

# 5. Advanced Operations
def rotate_array(array: List[Any], positions: int) -> List[Any]:
    """
    Rotate array

    Args:
        array: Source array
        positions: Positions to rotate (positive = right)

    Returns:
        Rotated array
    """
    if not array:
        return array

    positions = positions % len(array)
    return array[-positions:] + array[:-positions]

def reverse_array(array: List[Any]) -> List[Any]:
    """
    Reverse array

    Args:
        array: Source array

    Returns:
        Reversed array
    """
    return array[::-1]

def shuffle_array(array: List[Any]) -> List[Any]:
    """
    Shuffle array randomly

    Args:
        array: Source array

    Returns:
        Shuffled array
    """
    import random
    result = array.copy()
    random.shuffle(result)
    return result

def unique_array(array: List[Any], key: Optional[Callable] = None) -> List[Any]:
    """
    Get unique elements

    Args:
        array: Source array
        key: Key function for uniqueness

    Returns:
        Unique elements
    """
    if key:
        seen = set()
        result = []
        for item in array:
            k = key(item)
            if k not in seen:
                seen.add(k)
                result.append(item)
        return result
    else:
        return list(dict.fromkeys(array))

def intersect_arrays(arr1: List[Any], arr2: List[Any]) -> List[Any]:
    """
    Find intersection of two arrays

    Args:
        arr1: First array
        arr2: Second array

    Returns:
        Intersection
    """
    return list(set(arr1) & set(arr2))

def union_arrays(arr1: List[Any], arr2: List[Any]) -> List[Any]:
    """
    Find union of two arrays

    Args:
        arr1: First array
        arr2: Second array

    Returns:
        Union
    """
    return list(set(arr1) | set(arr2))

def difference_arrays(arr1: List[Any], arr2: List[Any]) -> List[Any]:
    """
    Find difference of two arrays

    Args:
        arr1: First array
        arr2: Second array

    Returns:
        Difference
    """
    return list(set(arr1) - set(arr2))

# 6. Statistical Operations
def sum_array(array: List[float]) -> float:
    """Calculate sum of array"""
    return sum(array)

def mean_array(array: List[float]) -> float:
    """Calculate mean of array"""
    return sum(array) / len(array) if array else 0

def median_array(array: List[float]) -> float:
    """Calculate median of array"""
    if not array:
        return 0

    sorted_arr = sorted(array)
    n = len(sorted_arr)
    mid = n // 2

    if n % 2 == 0:
        return (sorted_arr[mid - 1] + sorted_arr[mid]) / 2
    else:
        return sorted_arr[mid]

def mode_array(array: List[Any]) -> Any:
    """Calculate mode of array"""
    from collections import Counter
    if not array:
        return None

    counter = Counter(array)
    return counter.most_common(1)[0][0]

def std_deviation(array: List[float]) -> float:
    """Calculate standard deviation"""
    import math
    if len(array) < 2:
        return 0

    mean = mean_array(array)
    variance = sum((x - mean) ** 2 for x in array) / len(array)
    return math.sqrt(variance)

# Usage Examples
def demonstrate_array_operations():
    print("=== Web Python Array Operations Examples ===\n")

    # 1. Basic operations
    print("--- 1. Basic Operations ---")
    arr = create_array([3, 1, 4, 1, 5])
    print(f"Created: {arr}")
    add_element(arr, 9)
    print(f"After append: {arr}")
    add_element(arr, 2, position=0)
    print(f"After insert at 0: {arr}")
    print(f"Size: {get_size(arr)}")

    # 2. Sorting
    print("\n--- 2. Sorting ---")
    unsorted = [64, 34, 25, 12, 22, 11, 90]
    print(f"Original: {unsorted}")
    print(f"Bubble sort: {bubble_sort(unsorted.copy())}")
    print(f"Quick sort: {quick_sort(unsorted.copy())}")
    print(f"Builtin sort: {sort_array(unsorted.copy())}")

    # 3. Searching
    print("\n--- 3. Searching ---")
    data = [1, 3, 5, 7, 9, 11, 13]
    print(f"Array: {data}")
    print(f"Linear search for 7: {linear_search(data, 7)}")
    print(f"Binary search for 7: {binary_search(data, 7)}")
    print(f"Find all 1s: {find_all([1, 2, 1, 3, 1], 1)}")

    # 4. Transformations
    print("\n--- 4. Transformations ---")
    numbers = [1, 2, 3, 4, 5]
    print(f"Original: {numbers}")
    print(f"Map (x^2): {map_array(numbers, lambda x: x ** 2)}")
    print(f"Filter (even): {filter_array(numbers, lambda x: x % 2 == 0)}")
    print(f"Reduce (sum): {reduce_array(numbers, lambda a, b: a + b, 0)}")
    print(f"Flatten: {flatten_array([1, [2, 3], [4, [5]]])}")

    # 5. Advanced operations
    print("\n--- 5. Advanced Operations ---")
    data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    print(f"Original: {data}")
    print(f"Rotate 3: {rotate_array(data, 3)}")
    print(f"Reverse: {reverse_array(data)}")
    print(f"Unique: {unique_array([1, 2, 2, 3, 3, 3, 4])}")
    print(f"Chunk size 3: {chunk_array(data, 3)}")

    # 6. Statistical
    print("\n--- 6. Statistical Operations ---")
    numbers = [2, 4, 4, 4, 5, 5, 7, 9]
    print(f"Data: {numbers}")
    print(f"Sum: {sum_array(numbers)}")
    print(f"Mean: {mean_array(numbers):.2f}")
    print(f"Median: {median_array(numbers)}")
    print(f"Mode: {mode_array(numbers)}")
    print(f"Std deviation: {std_deviation(numbers):.2f}")

    print("\n=== All Array Operations Examples Completed ===")

# Export functions
# export { create_array, add_element, remove_element, remove_at, get_element, update_element }
# export { find_index, contains, get_size, is_empty, clear_array }
# export { bubble_sort, quick_sort, merge_sort, sort_array }
# export { linear_search, binary_search, find_all, find_min, find_max }
# export { map_array, filter_array, reduce_array, flatten_array, chunk_array }
# export { rotate_array, reverse_array, shuffle_array, unique_array }
# export { intersect_arrays, union_arrays, difference_arrays }
# export { sum_array, mean_array, median_array, mode_array, std_deviation }
# export { demonstrate_array_operations }

# Web Python Hash Table Examples
# Using Python dictionaries for key-value storage and efficient lookups

# 1. Basic Dictionary Operations
from typing import Any, Dict, List, Optional, Callable

def create_hash_table(elements: Dict[Any, Any] = None) -> Dict[Any, Any]:
    """
    Create a new hash table (dictionary)

    Args:
        elements: Initial key-value pairs

    Returns:
        New dictionary
    """
    return elements.copy() if elements else {}

def put(ht: Dict[Any, Any], key: Any, value: Any) -> None:
    """
    Add or update key-value pair

    Args:
        ht: Hash table
        key: Key
        value: Value
    """
    ht[key] = value

def get(ht: Dict[Any, Any], key: Any, default: Any = None) -> Any:
    """
    Get value by key

    Args:
        ht: Hash table
        key: Key to lookup
        default: Default value if key not found

    Returns:
        Value or default
    """
    return ht.get(key, default)

def remove(ht: Dict[Any, Any], key: Any) -> bool:
    """
    Remove key-value pair

    Args:
        ht: Hash table
        key: Key to remove

    Returns:
        True if removed
    """
    if key in ht:
        del ht[key]
        return True
    return False

def contains_key(ht: Dict[Any, Any], key: Any) -> bool:
    """
    Check if key exists

    Args:
        ht: Hash table
        key: Key to check

    Returns:
        True if key exists
    """
    return key in ht

def contains_value(ht: Dict[Any, Any], value: Any) -> bool:
    """
    Check if value exists

    Args:
        ht: Hash table
        value: Value to check

    Returns:
        True if value exists
    """
    return value in ht.values()

def get_size(ht: Dict[Any, Any]) -> int:
    """
    Get hash table size

    Args:
        ht: Hash table

    Returns:
        Number of key-value pairs
    """
    return len(ht)

def is_empty(ht: Dict[Any, Any]) -> bool:
    """
    Check if hash table is empty

    Args:
        ht: Hash table

    Returns:
        True if empty
    """
    return len(ht) == 0

def clear_hash_table(ht: Dict[Any, Any]) -> None:
    """
    Clear all entries

    Args:
        ht: Hash table
    """
    ht.clear()

def get_keys(ht: Dict[Any, Any]) -> List[Any]:
    """
    Get all keys

    Args:
        ht: Hash table

    Returns:
        List of keys
    """
    return list(ht.keys())

def get_values(ht: Dict[Any, Any]) -> List[Any]:
    """
    Get all values

    Args:
        ht: Hash table

    Returns:
        List of values
    """
    return list(ht.values())

def get_items(ht: Dict[Any, Any]) -> List[tuple]:
    """
    Get all key-value pairs

    Args:
        ht: Hash table

    Returns:
        List of tuples
    """
    return list(ht.items())

# 2. Advanced Operations
def update_hash_table(ht: Dict[Any, Any], other: Dict[Any, Any]) -> None:
    """
    Update with another dictionary

    Args:
        ht: Target hash table
        other: Source dictionary
    """
    ht.update(other)

def merge_hash_tables(ht1: Dict[Any, Any], ht2: Dict[Any, Any]) -> Dict[Any, Any]:
    """
    Merge two hash tables

    Args:
        ht1: First hash table
        ht2: Second hash table

    Returns:
        Merged hash table
    """
    result = ht1.copy()
    result.update(ht2)
    return result

def set_default(ht: Dict[Any, Any], key: Any, default: Any) -> Any:
    """
    Set default value if key doesn't exist

    Args:
        ht: Hash table
        key: Key
        default: Default value

    Returns:
        Value (existing or default)
    """
    return ht.setdefault(key, default)

def pop_value(ht: Dict[Any, Any], key: Any, default: Any = None) -> Any:
    """
    Remove and return value

    Args:
        ht: Hash table
        key: Key
        default: Default if key not found

    Returns:
        Removed value or default
    """
    return ht.pop(key, default)

def pop_item(ht: Dict[Any, Any]) -> tuple:
    """
    Remove and return arbitrary item

    Args:
        ht: Hash table

    Returns:
        (key, value) tuple
    """
    return ht.popitem()

# 3. Dictionary Comprehensions
def create_from_keys(keys: List[Any], value: Any) -> Dict[Any, Any]:
    """
    Create dict from keys with same value

    Args:
        keys: List of keys
        value: Value for all keys

    Returns:
        Dictionary
    """
    return {key: value for key in keys}

def create_from_mapping(keys: List[Any], func: Callable[[Any], Any]) -> Dict[Any, Any]:
    """
    Create dict by mapping keys through function

    Args:
        keys: List of keys
        func: Function to generate values

    Returns:
        Dictionary
    """
    return {key: func(key) for key in keys}

def filter_hash_table(ht: Dict[Any, Any], predicate: Callable[[tuple], bool]) -> Dict[Any, Any]:
    """
    Filter entries by predicate

    Args:
        ht: Hash table
        predicate: Filter function

    Returns:
        Filtered dictionary
    """
    return {k: v for k, v in ht.items() if predicate((k, v))}

def invert_hash_table(ht: Dict[Any, Any]) -> Dict[Any, Any]:
    """
    Invert key-value pairs

    Args:
        ht: Hash table

    Returns:
        Inverted dictionary
    """
    return {v: k for k, v in ht.items()}

# 4. Sorting Operations
def sort_by_keys(ht: Dict[Any, Any], reverse: bool = False) -> List[tuple]:
    """
    Sort entries by keys

    Args:
        ht: Hash table
        reverse: Sort descending

    Returns:
        Sorted list of tuples
    """
    return sorted(ht.items(), key=lambda x: x[0], reverse=reverse)

def sort_by_values(ht: Dict[Any, Any], reverse: bool = False) -> List[tuple]:
    """
    Sort entries by values

    Args:
        ht: Hash table
        reverse: Sort descending

    Returns:
        Sorted list of tuples
    """
    return sorted(ht.items(), key=lambda x: x[1], reverse=reverse)

def get_sorted_keys(ht: Dict[Any, Any], reverse: bool = False) -> List[Any]:
    """Get sorted keys"""
    return sorted(ht.keys(), reverse=reverse)

def get_sorted_values(ht: Dict[Any, Any], reverse: bool = False) -> List[Any]:
    """Get sorted values"""
    return sorted(ht.values(), reverse=reverse)

# 5. Lookup Operations
def find_keys_by_value(ht: Dict[Any, Any], value: Any) -> List[Any]:
    """
    Find all keys with given value

    Args:
        ht: Hash table
        value: Value to search

    Returns:
        List of keys
    """
    return [k for k, v in ht.items() if v == value]

def find_max_value(ht: Dict[Any, Any]) -> tuple:
    """
    Find entry with maximum value

    Args:
        ht: Hash table

    Returns:
        (key, value) tuple
    """
    return max(ht.items(), key=lambda x: x[1])

def find_min_value(ht: Dict[Any, Any]) -> tuple:
    """
    Find entry with minimum value

    Args:
        ht: Hash table

    Returns:
        (key, value) tuple
    """
    return min(ht.items(), key=lambda x: x[1])

# 6. Hash Table Utilities
def copy_hash_table(ht: Dict[Any, Any]) -> Dict[Any, Any]:
    """
    Create shallow copy

    Args:
        ht: Hash table

    Returns:
        Copy
    """
    return ht.copy()

def deep_copy_hash_table(ht: Dict[Any, Any]) -> Dict[Any, Any]:
    """
    Create deep copy

    Args:
        ht: Hash table

    Returns:
        Deep copy
    """
    import copy
    return copy.deepcopy(ht)

def to_string(ht: Dict[Any, Any], indent: int = 0) -> str:
    """
    Convert to formatted string

    Args:
        ht: Hash table
        indent: Indentation level

    Returns:
        Formatted string
    """
    import json
    return json.dumps(ht, indent=indent, default=str)

def from_tuples(items: List[tuple]) -> Dict[Any, Any]:
    """
    Create dict from list of tuples

    Args:
        items: List of (key, value) tuples

    Returns:
        Dictionary
    """
    return dict(items)

def from_lists(keys: List[Any], values: List[Any]) -> Dict[Any, Any]:
    """
    Create dict from two lists

    Args:
        keys: List of keys
        values: List of values

    Returns:
        Dictionary
    """
    return dict(zip(keys, values))

# 7. Specialized Hash Tables
def create_counter(items: List[Any]) -> Dict[Any, int]:
    """
    Count occurrences

    Args:
        items: List of items

    Returns:
        Dictionary with counts
    """
    counter = {}
    for item in items:
        counter[item] = counter.get(item, 0) + 1
    return counter

def create_index(items: List[Any], key_func: Callable[[Any], Any]) -> Dict[Any, List[Any]]:
    """
    Create index by key function

    Args:
        items: List of items
        key_func: Function to extract key

    Returns:
        Dictionary mapping keys to lists of items
    """
    index = {}
    for item in items:
        key = key_func(item)
        if key not in index:
            index[key] = []
        index[key].append(item)
    return index

def group_by(items: List[Any], key_func: Callable[[Any], Any]) -> Dict[Any, List[Any]]:
    """
    Group items by key function

    Args:
        items: List of items
        key_func: Function to extract key

    Returns:
        Grouped dictionary
    """
    groups = {}
    for item in items:
        key = key_func(item)
        if key not in groups:
            groups[key] = []
        groups[key].append(item)
    return groups

# 8. Nested Dictionary Operations
def get_nested(ht: Dict[Any, Any], *keys, default: Any = None) -> Any:
    """
    Get value from nested dictionary

    Args:
        ht: Hash table
        *keys: Keys for nested access
        default: Default value

    Returns:
        Nested value or default
    """
    current = ht
    for key in keys:
        if isinstance(current, dict) and key in current:
            current = current[key]
        else:
            return default
    return current

def set_nested(ht: Dict[Any, Any], *keys, value: Any) -> None:
    """
    Set value in nested dictionary

    Args:
        ht: Hash table
        *keys: Keys for nested access
        value: Value to set
    """
    current = ht
    for key in keys[:-1]:
        if key not in current:
            current[key] = {}
        current = current[key]
    current[keys[-1]] = value

def flatten_nested_dict(ht: Dict[Any, Any], parent_key: str = '', sep: str = '.') -> Dict[Any, Any]:
    """
    Flatten nested dictionary

    Args:
        ht: Hash table
        parent_key: Parent key prefix
        sep: Separator for keys

    Returns:
        Flattened dictionary
    """
    items = []
    for k, v in ht.items():
        new_key = f"{parent_key}{sep}{k}" if parent_key else k
        if isinstance(v, dict):
            items.extend(flatten_nested_dict(v, new_key, sep=sep).items())
        else:
            items.append((new_key, v))
    return dict(items)

# Usage Examples
def demonstrate_hash_table():
    print("=== Web Python Hash Table Examples ===\n")

    # 1. Basic operations
    print("--- 1. Basic Operations ---")
    ht = create_hash_table({'name': 'Alice', 'age': 30})
    print(f"Created: {ht}")
    put(ht, 'city', 'NYC')
    print(f"After put: {ht}")
    print(f"Get name: {get(ht, 'name')}")
    print(f"Contains 'age': {contains_key(ht, 'age')}")
    print(f"Keys: {get_keys(ht)}")
    print(f"Values: {get_values(ht)}")
    print(f"Size: {get_size(ht)}")

    # 2. Advanced operations
    print("\n--- 2. Advanced Operations ---")
    ht1 = {'a': 1, 'b': 2}
    ht2 = {'c': 3, 'd': 4}
    merged = merge_hash_tables(ht1, ht2)
    print(f"Merged: {merged}")
    set_default(ht1, 'e', 5)
    print(f"Set default: {ht1}")
    inverted = invert_hash_table({'a': 1, 'b': 2, 'c': 3})
    print(f"Inverted: {inverted}")

    # 3. Sorting
    print("\n--- 3. Sorting ---")
    data = {'apple': 5, 'banana': 2, 'cherry': 8, 'date': 1}
    print(f"Original: {data}")
    print(f"Sort by keys: {sort_by_keys(data)}")
    print(f"Sort by values: {sort_by_values(data)}")
    print(f"Max value: {find_max_value(data)}")
    print(f"Min value: {find_min_value(data)}")

    # 4. Lookup operations
    print("\n--- 4. Lookup Operations ---")
    scores = {'Alice': 95, 'Bob': 87, 'Charlie': 95, 'David': 92}
    print(f"Scores: {scores}")
    print(f"Keys with value 95: {find_keys_by_value(scores, 95)}")

    # 5. Specialized dictionaries
    print("\n--- 5. Specialized Dictionaries ---")
    items = ['apple', 'banana', 'apple', 'cherry', 'banana', 'apple']
    counter = create_counter(items)
    print(f"Counter: {counter}")

    data = [
        {'name': 'Alice', 'dept': 'IT'},
        {'name': 'Bob', 'dept': 'HR'},
        {'name': 'Charlie', 'dept': 'IT'}
    ]
    grouped = group_by(data, lambda x: x['dept'])
    print(f"Grouped by dept: {grouped}")

    # 6. Nested dictionaries
    print("\n--- 6. Nested Dictionaries ---")
    nested = {
        'user': {
            'name': 'Alice',
            'address': {
                'city': 'NYC',
                'zip': '10001'
            }
        }
    }
    print(f"Nested: {nested}")
    print(f"Get nested: {get_nested(nested, 'user', 'address', 'city')}")
    set_nested(nested, 'user', 'address', 'zip', value='10002')
    print(f"After set: {nested}")
    print(f"Flattened: {flatten_nested_dict(nested)}")

    print("\n=== All Hash Table Examples Completed ===")

# Export functions
# export { create_hash_table, put, get, remove, contains_key, contains_value }
# export { get_size, is_empty, clear_hash_table, get_keys, get_values, get_items }
# export { update_hash_table, merge_hash_tables, set_default, pop_value, pop_item }
# export { create_from_keys, create_from_mapping, filter_hash_table, invert_hash_table }
# export { sort_by_keys, sort_by_values, get_sorted_keys, get_sorted_values }
# export { find_keys_by_value, find_max_value, find_min_value }
# export { copy_hash_table, deep_copy_hash_table, to_string, from_tuples, from_lists }
# export { create_counter, create_index, group_by }
# export { get_nested, set_nested, flatten_nested_dict }
# export { demonstrate_hash_table }

# Web Python Linked List Examples
# Implementation of singly linked list with comprehensive operations

# 1. Node Class
class Node:
    """Linked list node"""

    def __init__(self, data: Any = None):
        self.data = data
        self.next: Optional['Node'] = None

    def __repr__(self):
        return f"Node({self.data})"

# 2. Linked List Class
class LinkedList:
    """Singly linked list implementation"""

    def __init__(self):
        self.head: Optional[Node] = None
        self.size = 0

    def __repr__(self):
        values = []
        current = self.head
        while current:
            values.append(str(current.data))
            current = current.next
        return " -> ".join(values) if values else "Empty List"

    def __len__(self):
        return self.size

    def __iter__(self):
        current = self.head
        while current:
            yield current.data
            current = current.next

    # 3. Insertion Operations
    def append(self, data: Any) -> None:
        """
        Append element to end

        Args:
            data: Data to append
        """
        new_node = Node(data)
        if not self.head:
            self.head = new_node
        else:
            current = self.head
            while current.next:
                current = current.next
            current.next = new_node
        self.size += 1

    def prepend(self, data: Any) -> None:
        """
        Add element to beginning

        Args:
            data: Data to prepend
        """
        new_node = Node(data)
        new_node.next = self.head
        self.head = new_node
        self.size += 1

    def insert_at(self, index: int, data: Any) -> bool:
        """
        Insert element at index

        Args:
            index: Insertion index
            data: Data to insert

        Returns:
            True if successful
        """
        if index < 0 or index > self.size:
            return False

        if index == 0:
            self.prepend(data)
            return True

        new_node = Node(data)
        current = self.head
        for _ in range(index - 1):
            current = current.next

        new_node.next = current.next
        current.next = new_node
        self.size += 1
        return True

    def insert_after(self, target_data: Any, new_data: Any) -> bool:
        """
        Insert after target element

        Args:
            target_data: Target element data
            new_data: New element data

        Returns:
            True if successful
        """
        current = self.head
        while current:
            if current.data == target_data:
                new_node = Node(new_data)
                new_node.next = current.next
                current.next = new_node
                self.size += 1
                return True
            current = current.next
        return False

    def insert_before(self, target_data: Any, new_data: Any) -> bool:
        """
        Insert before target element

        Args:
            target_data: Target element data
            new_data: New element data

        Returns:
            True if successful
        """
        if not self.head:
            return False

        if self.head.data == target_data:
            self.prepend(new_data)
            return True

        current = self.head
        while current.next:
            if current.next.data == target_data:
                new_node = Node(new_data)
                new_node.next = current.next
                current.next = new_node
                self.size += 1
                return True
            current = current.next
        return False

    # 4. Deletion Operations
    def delete(self, data: Any) -> bool:
        """
        Delete first occurrence of data

        Args:
            data: Data to delete

        Returns:
            True if deleted
        """
        if not self.head:
            return False

        if self.head.data == data:
            self.head = self.head.next
            self.size -= 1
            return True

        current = self.head
        while current.next:
            if current.next.data == data:
                current.next = current.next.next
                self.size -= 1
                return True
            current = current.next
        return False

    def delete_at(self, index: int) -> bool:
        """
        Delete element at index

        Args:
            index: Index to delete

        Returns:
            True if deleted
        """
        if index < 0 or index >= self.size:
            return False

        if index == 0:
            self.head = self.head.next
            self.size -= 1
            return True

        current = self.head
        for _ in range(index - 1):
            current = current.next

        current.next = current.next.next
        self.size -= 1
        return True

    def delete_head(self) -> bool:
        """
        Delete head element

        Returns:
            True if deleted
        """
        if not self.head:
            return False
        self.head = self.head.next
        self.size -= 1
        return True

    def delete_tail(self) -> bool:
        """
        Delete tail element

        Returns:
            True if deleted
        """
        if not self.head:
            return False

        if not self.head.next:
            self.head = None
        else:
            current = self.head
            while current.next.next:
                current = current.next
            current.next = None
        self.size -= 1
        return True

    # 5. Search Operations
    def find(self, data: Any) -> Optional[Node]:
        """
        Find node containing data

        Args:
            data: Data to find

        Returns:
            Node or None
        """
        current = self.head
        while current:
            if current.data == data:
                return current
            current = current.next
        return None

    def contains(self, data: Any) -> bool:
        """
        Check if data exists

        Args:
            data: Data to check

        Returns:
            True if exists
        """
        return self.find(data) is not None

    def index_of(self, data: Any) -> int:
        """
        Get index of data

        Args:
            data: Data to find

        Returns:
            Index or -1
        """
        current = self.head
        index = 0
        while current:
            if current.data == data:
                return index
            current = current.next
            index += 1
        return -1

    def get_at(self, index: int) -> Optional[Any]:
        """
        Get data at index

        Args:
            index: Index

        Returns:
            Data or None
        """
        if index < 0 or index >= self.size:
            return None

        current = self.head
        for _ in range(index):
            current = current.next
        return current.data

    # 6. Traversal Operations
    def to_list(self) -> list:
        """
        Convert to Python list

        Returns:
            List of data
        """
        result = []
        current = self.head
        while current:
            result.append(current.data)
            current = current.next
        return result

    def traverse(self, func: callable) -> None:
        """
        Apply function to each element

        Args:
            func: Function to apply
        """
        current = self.head
        while current:
            func(current.data)
            current = current.next

    def print_list(self) -> None:
        """Print linked list"""
        print(self)

    # 7. Update Operations
    def update(self, index: int, new_data: Any) -> bool:
        """
        Update data at index

        Args:
            index: Index
            new_data: New data

        Returns:
            True if updated
        """
        if index < 0 or index >= self.size:
            return False

        current = self.head
        for _ in range(index):
            current = current.next
        current.data = new_data
        return True

    # 8. Utility Operations
    def is_empty(self) -> bool:
        """
        Check if list is empty

        Returns:
            True if empty
        """
        return self.head is None

    def clear(self) -> None:
        """Clear all elements"""
        self.head = None
        self.size = 0

    def reverse(self) -> None:
        """Reverse the linked list"""
        prev = None
        current = self.head

        while current:
            next_node = current.next
            current.next = prev
            prev = current
            current = next_node

        self.head = prev

    def get_length(self) -> int:
        """
        Get length of list

        Returns:
            Length
        """
        return self.size

    def copy(self) -> 'LinkedList':
        """
        Create shallow copy

        Returns:
            New linked list
        """
        new_list = LinkedList()
        current = self.head
        while current:
            new_list.append(current.data)
            current = current.next
        return new_list

    # 9. Advanced Operations
    def count(self, data: Any) -> int:
        """
        Count occurrences of data

        Args:
            data: Data to count

        Returns:
            Count
        """
        count = 0
        current = self.head
        while current:
            if current.data == data:
                count += 1
            current = current.next
        return count

    def remove_duplicates(self) -> None:
        """Remove duplicate elements"""
        seen = set()
        current = self.head
        prev = None

        while current:
            if current.data in seen:
                prev.next = current.next
                self.size -= 1
            else:
                seen.add(current.data)
                prev = current
            current = current.next

    def sort(self, reverse: bool = False) -> None:
        """
        Sort the linked list

        Args:
            reverse: Sort descending
        """
        # Convert to list, sort, and rebuild
        data_list = self.to_list()
        data_list.sort(reverse=reverse)

        self.clear()
        for item in data_list:
            self.append(item)

    def find_middle(self) -> Optional[Any]:
        """
        Find middle element

        Returns:
            Middle data or None
        """
        if not self.head:
            return None

        slow = self.head
        fast = self.head

        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next

        return slow.data

    def has_cycle(self) -> bool:
        """
        Detect cycle using Floyd's algorithm

        Returns:
            True if cycle exists
        """
        if not self.head:
            return False

        slow = self.head
        fast = self.head

        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next

            if slow == fast:
                return True

        return False

    # 10. Static Creation Methods
    @classmethod
    def from_list(cls, data_list: list) -> 'LinkedList':
        """
        Create linked list from Python list

        Args:
            data_list: List of data

        Returns:
            New linked list
        """
        linked_list = cls()
        for item in data_list:
            linked_list.append(item)
        return linked_list

# 11. Utility Functions
def merge_sorted_lists(list1: LinkedList, list2: LinkedList) -> LinkedList:
    """
    Merge two sorted linked lists

    Args:
        list1: First sorted list
        list2: Second sorted list

    Returns:
        Merged sorted list
    """
    merged = LinkedList()
    current1 = list1.head
    current2 = list2.head

    while current1 and current2:
        if current1.data <= current2.data:
            merged.append(current1.data)
            current1 = current1.next
        else:
            merged.append(current2.data)
            current2 = current2.next

    while current1:
        merged.append(current1.data)
        current1 = current1.next

    while current2:
        merged.append(current2.data)
        current2 = current2.next

    return merged

def detect_intersection(list1: LinkedList, list2: LinkedList) -> Optional[Any]:
    """
    Detect intersection point of two lists

    Args:
        list1: First list
        list2: Second list

    Returns:
        Intersection data or None
    """
    # Get lengths
    len1, len2 = len(list1), len(list2)

    # Find starting points
    current1 = list1.head
    current2 = list2.head

    # Advance longer list
    for _ in range(abs(len1 - len2)):
        if len1 > len2:
            current1 = current1.next
        else:
            current2 = current2.next

    # Move both until intersection
    while current1 and current2:
        if current1 == current2:
            return current1.data
        current1 = current1.next
        current2 = current2.next

    return None

# Usage Examples
def demonstrate_linked_list():
    print("=== Web Python Linked List Examples ===\n")

    # 1. Basic operations
    print("--- 1. Basic Operations ---")
    ll = LinkedList()
    ll.append(1)
    ll.append(2)
    ll.append(3)
    print(f"After append: {ll}")
    ll.prepend(0)
    print(f"After prepend: {ll}")
    print(f"Length: {ll.get_length()}")
    print(f"Is empty: {ll.is_empty()}")

    # 2. Insertion
    print("\n--- 2. Insertion ---")
    ll.insert_at(2, 1.5)
    print(f"After insert at 2: {ll}")
    ll.insert_after(2, 2.5)
    print(f"After insert after 2: {ll}")

    # 3. Deletion
    print("\n--- 3. Deletion ---")
    ll.delete(1.5)
    print(f"After delete 1.5: {ll}")
    ll.delete_at(0)
    print(f"After delete at 0: {ll}")
    ll.delete_head()
    print(f"After delete head: {ll}")

    # 4. Search
    print("\n--- 4. Search ---")
    ll = LinkedList.from_list([10, 20, 30, 40, 50])
    print(f"List: {ll}")
    print(f"Contains 30: {ll.contains(30)}")
    print(f"Index of 30: {ll.index_of(30)}")
    print(f"Get at 2: {ll.get_at(2)}")
    print(f"Find middle: {ll.find_middle()}")

    # 5. Traversal
    print("\n--- 5. Traversal ---")
    print("Traverse with print:")
    ll.traverse(lambda x: print(f"  Item: {x}"))
    print(f"To list: {ll.to_list()}")

    # 6. Update
    print("\n--- 6. Update ---")
    ll.update(2, 35)
    print(f"After update index 2: {ll}")

    # 7. Advanced operations
    print("\n--- 7. Advanced Operations ---")
    ll = LinkedList.from_list([3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5])
    print(f"Original: {ll}")
    print(f"Count of 5: {ll.count(5)}")
    ll.remove_duplicates()
    print(f"After remove duplicates: {ll}")
    ll.reverse()
    print(f"After reverse: {ll}")
    ll.sort()
    print(f"After sort: {ll}")

    # 8. Merge
    print("\n--- 8. Merge Sorted Lists ---")
    list1 = LinkedList.from_list([1, 3, 5, 7])
    list2 = LinkedList.from_list([2, 4, 6, 8])
    print(f"List1: {list1}")
    print(f"List2: {list2}")
    merged = merge_sorted_lists(list1, list2)
    print(f"Merged: {merged}")

    # 9. Create from list
    print("\n--- 9. Create From List ---")
    data = [100, 200, 300, 400]
    ll_from_list = LinkedList.from_list(data)
    print(f"From list {data}: {ll_from_list}")

    # 10. Cycle detection
    print("\n--- 10. Cycle Detection ---")
    ll = LinkedList.from_list([1, 2, 3, 4])
    print(f"List: {ll}")
    print(f"Has cycle: {ll.has_cycle()}")

    print("\n=== All Linked List Examples Completed ===")

# Export classes and functions
# export { Node, LinkedList }
# export { merge_sorted_lists, detect_intersection, demonstrate_linked_list }