> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Python 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:**
```python theme={"dark"}
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:
```python theme={"dark"}
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:**
```python theme={"dark"}
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)
```
Tired of Poor Python Skills? Fix That With Deep Grasping!
Learn More
