Multiplication

The * (asterisk) operator in Python is a heavily overloaded lexical token whose behavior is dictated by its syntactic context. It functions primarily as a binary operator for arithmetic and sequence operations, a unary prefix operator for iterable unpacking, a syntax marker in function signatures for variadic arguments, a modifier in exception handling for exception groups, and a wildcard identifier in module imports.

Arithmetic Multiplication and Sequence Repetition

When used as a binary operator, * evaluates the operands by invoking the __mul__ or __rmul__ magic methods.

• Numeric Types: Performs standard mathematical multiplication.
• Sequence Types: When one operand is a sequence (e.g., list, tuple, str) and the other operand is an integer, it performs sequence repetition. This operation is commutative; it creates a new sequence containing multiple concatenated shallow copies of the original items regardless of operand order.

# Arithmetic evaluation
a = 5
b = 4
result = a * b          # Evaluates to 20


# Sequence repetition (commutative)
seq = [1, 2]
seq_result_1 = seq * 3  # Evaluates to [1, 2, 1, 2, 1, 2]
seq_result_2 = 3 * seq  # Evaluates to [1, 2, 1, 2, 1, 2]

Iterable Unpacking

As a unary prefix operator, * unpacks an iterable into its constituent elements. This behavior is defined by PEP 3132 (Extended Iterable Unpacking) and PEP 448 (Additional Unpacking Generalizations).

• Assignment Unpacking: Captures all remaining items in an iterable that are not assigned to explicit variables, packing them into a list. Only one starred expression is permitted in a single assignment target.
• Literal Displays: Expands iterables directly within list, tuple, or set literals.

# Assignment unpacking
first, *middle, last = (1, 2, 3, 4, 5)

# first evaluates to 1

# middle evaluates to [2, 3, 4]

# last evaluates to 5


# Literal display unpacking
iterable_one = [1, 2]
iterable_two = (3, 4)
combined_list = [*iterable_one, *iterable_two]  # Evaluates to [1, 2, 3, 4]
combined_set = {*iterable_one, *iterable_two}   # Evaluates to {1, 2, 3, 4}

Function Signatures: Packing and Unpacking

In the context of function definitions and function invocations, * manages the mapping of positional arguments.

• Parameter Packing (Variadic Positional Arguments): When prefixed to a parameter in a function definition, * collects an arbitrary number of unbound positional arguments into a tuple.
• Argument Unpacking: When prefixed to an iterable in a function call, * exhausts the iterable, passing its elements as individual positional arguments.
• Keyword-Only Argument Enforcement: When used as a standalone parameter (a bare *) in a function definition, it consumes no arguments but dictates that all subsequent parameters must be passed as keyword arguments.

# Parameter packing
def pack_args(*args):
    return args  # args is a tuple of positional arguments

pack_result = pack_args(1, 2, 3)  # Evaluates to (1, 2, 3)


# Argument unpacking
def add_three(x, y, z):
    return x + y + z

values = [10, 20, 30]
unpack_result = add_three(*values)  # Evaluates to 60


# Keyword-only enforcement
def configure(setting, *, strict, verbose):
    return (setting, strict, verbose)


# strict and verbose must be passed by keyword
config_result = configure("timeout", strict=True, verbose=False) 

Exception Group Handling

Introduced in Python 3.11 (PEP 654), the * token is appended to the except keyword to form the except* clause. This syntax is specifically designed to catch and unpack ExceptionGroup instances, allowing multiple exceptions of different types raised concurrently to be handled by separate except* blocks.

# Exception group unpacking (Python 3.11+)
try:
    raise ExceptionGroup("Multiple errors", [ValueError("bad value"), TypeError("bad type")])
except* ValueError as e:
    pass  # Handles the ValueError subset
except* TypeError as e:
    pass  # Handles the TypeError subset

Wildcard Imports

In the context of the import statement, * acts as a wildcard identifier. It binds all public names defined in the target module to the current local namespace. The definition of “public names” is determined by the module’s __all__ list; if __all__ is undefined, it imports all names that do not begin with an underscore (_).

# Wildcard import syntax
from math import *


# 'pi' and 'cos' are now bound in the local namespace
result = cos(pi)  # Evaluates to -1.0

Master Python with Deep Grasping Methodology!

Learn More