Element-wise * vs Matrix @

Until now, every multiplication we did was element-wise: runs * 2, runs / balls. Linear algebra introduces a completely different operation that also "multiplies" two arrays — matrix multiplication. Mixing the two up is one of the most common and most serious bugs in data-science code, because both often run without any error and simply give wrong numbers.

Definition

A matrix is a 2D array of numbers arranged in rows and columns. A vector is a 1D array.

Element-wise multiplication (A * B) multiplies the values at the same position in both arrays. The arrays must have the same shape (or be broadcastable), and the result has that same shape.

Matrix multiplication (A @ B, np.matmul(A, B), np.dot(A, B)) combines each row of A with each column of B by multiplying matching entries and adding them up. It needs the number of columns of A to equal the number of rows of B, and the result usually has a different shape.

• Same position — (A * B)[i, j] = A[i, j] * B[i, j]. Nothing else is involved.
• Row with column — (A @ B)[i, j] uses the entire row i of A and the entire column j of B.
• @ — the matrix-multiplication operator, added in Python 3.5 specifically for NumPy. It is the modern, preferred spelling.

Syntax

A * B               # element-wise product
A @ B               # matrix product (preferred)
np.matmul(A, B)     # same as A @ B
np.dot(A, B)        # same as A @ B for 1D and 2D arrays

Example — same two matrices, two very different answers

import numpy as np
X = np.array([[1, 2],
              [3, 4]])
Y = np.array([[5, 6],
              [7, 8]])
print("X * Y  (element-wise):")
print(X * Y)
print("X @ Y  (matrix multiplication):")
print(X @ Y)

X * Y  (element-wise):
[[ 5 12]
 [21 32]]
X @ Y  (matrix multiplication):
[[19 22]
 [43 50]]

How it works:

X * Y  (position by position)        X @ Y  (row · column)
[0,0] = 1*5 = 5                      [0,0] = 1*5 + 2*7 = 19
[0,1] = 2*6 = 12                     [0,1] = 1*6 + 2*8 = 22
[1,0] = 3*7 = 21                     [1,0] = 3*5 + 4*7 = 43
[1,1] = 4*8 = 32                     [1,1] = 3*6 + 4*8 = 50

Example — np.dot, @ and np.matmul agree for 2D arrays

A = np.array([[1, 2, 3],
              [4, 5, 6]])
B = np.array([[7, 8],
              [9, 10],
              [11, 12]])
print(np.dot(A, B))
print(A @ B)
print(np.matmul(A, B))
print(np.array_equal(A @ B, np.dot(A, B)), np.array_equal(A @ B, np.matmul(A, B)))

[[ 58  64]
 [139 154]]
[[ 58  64]
 [139 154]]
[[ 58  64]
 [139 154]]
True True

A (2, 3) matrix times a (3, 2) matrix gives a (2, 2) result — a different shape from both inputs. Element-wise multiplication of these two is not even possible:

try:
    A * B
except ValueError as e:
    print("ValueError:", e)

ValueError: operands could not be broadcast together with shapes (2,3) (3,2)

Comparison — * vs @ vs np.dot vs np.matmul

Note: for 1D and 2D arrays np.dot, @ and np.matmul give identical results. They only differ for scalars and 3D+ arrays — prefer @ and you will never hit those surprises.

Common mistakes

• ❌ Using * when you meant a weighted sum / matrix product — square matrices of equal shape give no error, just wrong numbers. ✅ Use @ whenever you want row-times-column sums.
• ❌ A @ 2 → ValueError: matmul: Input operand 1 does not have enough dimensions .... ✅ Scale with A * 2.
• ❌ Thinking A @ B == B @ A. ✅ Matrix multiplication is not commutative: the order changes the answer (and often the shape).
• ❌ Coming from MATLAB and expecting * to be matrix multiplication. ✅ In NumPy * is always element-wise.

Interview tip

Q: What is the difference between np.dot, np.matmul and *? A: * is element-wise multiplication. np.matmul (and @) is matrix multiplication and treats 3D+ arrays as stacks of matrices, but rejects scalars. np.dot is identical to matmul for 1D/2D arrays, also accepts scalars, and behaves differently for higher-dimensional arrays.