Matrix Multiplication

The @ symbol in Python functions as a dual-purpose syntactic token, serving as syntactic sugar for applying decorators to callables and classes, and as a binary infix operator for matrix multiplication.

1. Decorator Syntax

When placed as a prefix immediately preceding a function, method, or class definition, @ acts as syntactic sugar for passing the defined object into a higher-order callable (the decorator) and rebinding the original identifier to the return value of that callable.

Syntax Visualization & Mechanics:

def simple_decorator(func):
    def wrapper():
        return func() + " (decorated)"
    return wrapper


# Using the @ operator
@simple_decorator
def target_function():
    return "original"


# The @ syntax above is strictly equivalent to this manual reassignment:
def manual_function():
    return "original"

manual_function = simple_decorator(manual_function)

If the decorator accepts arguments (a decorator factory), the @ operator evaluates the expression first, expecting it to return a callable, which is then applied to the target:

def decorator_factory(suffix):
    def decorator(func):
        def wrapper():
            return func() + suffix
        return wrapper
    return decorator


# The expression decorator_factory(...) is evaluated first
@decorator_factory(" (factory applied)")
def another_target():
    return "original"


# Strictly equivalent to:

# another_target = decorator_factory(" (factory applied)")(another_target)

2. Matrix Multiplication Operator

When used as a binary infix operator between two objects, @ invokes the matrix multiplication protocol. It is evaluated by calling the __matmul__() magic method on the left operand, or __rmatmul__() on the right operand if the left operand does not implement the operation or returns NotImplemented. The augmented assignment variant @= maps to the __imatmul__() method.

Syntax Visualization & Mechanics:

class MatrixMock:
    def __init__(self, value):
        self.value = value
        
    def __matmul__(self, other):
        if isinstance(other, MatrixMock):
            return MatrixMock(f"({self.value} @ {other.value})")
        return NotImplemented
        
    def __imatmul__(self, other):
        if isinstance(other, MatrixMock):
            self.value = f"({self.value} @= {other.value})"
            return self
        return NotImplemented

A = MatrixMock("A")
B = MatrixMock("B")


# Using the @ operator
C = A @ B  # Invokes A.__matmul__(B)


# Using the @= augmented assignment operator
A @= B     # Invokes A.__imatmul__(B)

Master Python with Deep Grasping Methodology!

Learn More