Exponentiation

The ** operator in Python serves two distinct syntactic roles depending on its lexical context: as a binary arithmetic exponentiation operator for numeric types, and as a mapping unpacking or packing token for dictionary-like objects.

Arithmetic Exponentiation

When used as a binary operator between two expressions, ** performs exponentiation, raising the left operand to the power of the right operand.

Underlying Mechanics: The operator delegates to the __pow__(self, other) magic method of the left operand. If the left operand does not support the operation or returns NotImplemented, Python falls back to the right operand’s __rpow__(self, other) method.

Associativity and Precedence: Unlike most Python operators, ** is right-associative. The expression x ** y ** z is evaluated as x ** (y ** z).

It also binds more tightly than unary arithmetic operators on its left, but less tightly than unary operators on its right.

# Basic syntax
result = 2 ** 3  # Evaluates to 8


# Right-associativity
chain = 2 ** 3 ** 2  # Evaluates to 512 (2 ** 9), not 64 (8 ** 2)


# Precedence with unary operators
neg_a = -3 ** 2   # Evaluates to -9. Parsed as -(3 ** 2)
neg_b = (-3) ** 2 # Evaluates to 9. Parsed as (-3) ** 2

Mapping Unpacking and Packing

When prefixed to an expression within a dictionary literal or a function call, ** acts as an unpacking operator. It is not a standalone operator that evaluates to a value; rather, it is a syntactic construct resolved by the Python parser to expand a mapping object into discrete key-value pairs.

Underlying Mechanics: Because Python utilizes duck typing, the operand following ** does not need to formally inherit from or register with the collections.abc.Mapping abstract base class. It only needs to implement the mapping protocol—specifically the keys() and __getitem__() methods. Python internally iterates over the mapping’s keys and retrieves the corresponding values to populate the target structure.

Contextual Syntax:

• Dictionary Displays: Expands the key-value pairs into a new dictionary literal. If duplicate keys exist, the values from the rightmost unpacked mapping overwrite previous values.
• Function Invocations: Expands the mapping into discrete keyword arguments. The keys must be strings. These string keys must match the function’s explicitly defined parameter names, unless the function signature includes a **kwargs catch-all parameter, in which case any valid string key is accepted. This unpacking is evaluated dynamically at runtime; the compiler emits a bytecode instruction (such as CALL_FUNCTION_EX) to handle the expansion during execution.
• Function Signatures: When used in a function definition (def func(**kwargs):), it acts as a packing parameter, capturing all unbound keyword arguments into a single dictionary bound to the specified identifier.

# Dictionary display unpacking
map1 = {'a': 1, 'b': 2}
map2 = {'b': 3, 'c': 4}
combined = {**map1, **map2}  # Evaluates to {'a': 1, 'b': 3, 'c': 4}


# Function invocation unpacking
def target_function(a, b):
    pass

args = {'a': 10, 'b': 20}
target_function(**args)  # Evaluated dynamically at runtime via CALL_FUNCTION_EX


# Function signature packing
def capture_kwargs(**kwargs):
    # kwargs is bound to a dictionary of passed keyword arguments
    pass

Master Python with Deep Grasping Methodology!

Learn More