def demonstrate_basic_unpacking():
    """
    Show how asterisk unpacks sequences into function arguments.
    """
    def print_coordinates(x, y, z):
        print(f"Position: ({x}, {y}, {z})")
    
    # Traditional way
    point = [1, 2, 3]
    print_coordinates(point[0], point[1], point[2])
    
    # Using asterisk unpacking
    print_coordinates(*point)
    
    # Works with any sequence type
    point_tuple = (4, 5, 6)
    print_coordinates(*point_tuple)
    
    # Even works with strings (though be careful!)
    coords = "123"
    print_coordinates(*coords)

def demonstrate_sequence_unpacking():
    """
    Show how asterisk works with multiple sequences.
    """
    def merge_sequences(*sequences):
        """Merge multiple sequences into a single list."""
        result = []
        for seq in sequences:
            result.extend(seq)
        return result
    
    # Combine multiple lists
    numbers = [1, 2, 3]
    letters = ['a', 'b', 'c']
    symbols = ['!', '@', '#']
    
    # Merge them all
    combined = [*numbers, *letters, *symbols]
    print("Combined sequence:", combined)
    
    # Works with different sequence types
    tuple_nums = (4, 5, 6)
    set_letters = {'x', 'y', 'z'}
    mixed_result = [*numbers, *tuple_nums, *set_letters]
    print("Mixed sequences:", mixed_result)

def demonstrate_dict_unpacking():
    """
    Show how double asterisk works with dictionaries.
    """
    # Basic dictionary merging
    defaults = {'theme': 'dark', 'language': 'en'}
    user_settings = {'theme': 'light'}
    
    # Merge with precedence to user settings
    final_settings = {**defaults, **user_settings}
    print("Merged settings:", final_settings)
    
    # Multiple dictionary merging
    base_config = {'host': 'localhost', 'port': 8000}
    development = {'debug': True}
    logging = {'log_level': 'DEBUG'}
    
    # Combine all configurations
    config = {**base_config, **development, **logging}
    print("Full config:", config)
    
    # Function parameter unpacking
    def create_user(**user_data):
        return {
            'id': 123,
            **user_data,
            'created_at': '2024-01-01'
        }
    
    user = create_user(name='Alice', email='alice@example.com')
    print("Created user:", user)

def demonstrate_advanced_args():
    """
    Show complex uses of asterisk in function definitions.
    """
    def process_data(required, *args, **kwargs):
        print(f"Required argument: {required}")
        print(f"Positional args: {args}")
        print(f"Keyword args: {kwargs}")
    
    # Various ways to call the function
    process_data("hello", 1, 2, 3, x=10, y=20)
    
    # Unpacking with a mix of arguments
    values = [1, 2, 3]
    options = {'color': 'blue', 'size': 'large'}
    process_data("world", *values, **options)
    
    # Partial unpacking
    def greet(prefix, *names, suffix='!'):
        for name in names:
            print(f"{prefix} {name}{suffix}")
    
    people = ['Alice', 'Bob', 'Charlie']
    greet("Hello", *people, suffix='!!!')

def demonstrate_matrix_operations():
    """
    Show how asterisk helps with matrix manipulations.
    """
    # Transpose a matrix using zip
    matrix = [
        [1, 2, 3],
        [4, 5, 6]
    ]
    
    # Basic transpose
    transposed = list(zip(*matrix))
    print("Transposed matrix:", transposed)
    
    # Rotate a matrix clockwise
    def rotate_matrix(matrix):
        return list(zip(*matrix[::-1]))
    
    square_matrix = [
        [1, 2, 3],
        [4, 5, 6],
        [7, 8, 9]
    ]
    
    rotated = rotate_matrix(square_matrix)
    print("Rotated matrix:", rotated)
    
    # Unpack multiple rows for processing
    def process_rows(*rows):
        return [sum(row) for row in rows]
    
    row_sums = process_rows(*matrix)
    print("Row sums:", row_sums)

def demonstrate_practical_applications():
    """
    Show real-world uses of asterisk operator.
    """
    # 1. Splitting into head and tail
    def process_sequence(first, *rest):
        print(f"First item: {first}")
        print(f"Remaining items: {rest}")
    
    numbers = [1, 2, 3, 4, 5]
    process_sequence(*numbers)
    
    # 2. Building command-line arguments
    def run_command(cmd, *args, **flags):
        command = [cmd, *args]
        for key, value in flags.items():
            command.extend([f'--{key}', str(value)])
        return command
    
    cmd = run_command('git', 'commit', message='Update', author='me')
    print("Command:", cmd)
    
    # 3. Flexible data processing
    def analyze_data(*datasets, method='sum'):
        if method == 'sum':
            return [sum(data) for data in datasets]
        return [len(data) for data in datasets]
    
    data1 = [1, 2, 3]
    data2 = [4, 5, 6]
    results = analyze_data(data1, data2, method='sum')
    print("Analysis results:", results)