# Numpy broadcasting: A beginner’s guide

In this guide, we’ll talk about Numpy broadcasting from a beginner’s perspective. This guide assumes no prior knowledge of the topic so we’ll go right from the basics to help you get started.

“The term broadcasting describes how numpy treats arrays with different shapes during arithmetic operations. Subject to certain constraints, the smaller array is “broadcast” across the larger array so that they have compatible shapes. Broadcasting provides a means of vectorizing array operations so that looping occurs in C instead of Python.”

Let us take a small example to understand that. We add two arrays to different dimensions, to understand the broadcasting mechanism of NumPy.

```import numpy as np

arr = np.arange(3)
result = arr + 4
```

Here arr has one dimension(axis), which has length 3, on the other hand, 5. is a simple integer, which theoretically has 0 dimensions. Since they are of different dimensions, Numpy tries to broadcast (simply stretch) the smaller array along a specific axis making it suitable for the mathematical operation to take place.

Numpy broadcasting has a strict set of rules to make the operation on arrays consistent and fail-safe. These are two general rules of broadcasting in numpy:

• When we perform an operation on NumPy arrays, NumPy compares the shape of the array element-wise from right to left. Two dimensions are compatible only when they are equal or one of them is 1. If two dimensions are equal, the array is left intact. If the dimension is one, the array is broadcasted along that dimension. If none of the two conditions is satisfied, NumPy throws a ValueError, indicating the array cannot be broadcasted. The arrays are broadcasted if and only if all dimensions are compatible.
• The compared arrays need not have the same number of dimensions. The array having a smaller number of dimensions can be easily scaled along the missing dimension.

Here are few examples to understand the rules better:

```a = np.arange(12).reshape(4, 3)
print("Shape of a is:", a.shape)

b = np.arange(4).reshape(4, 1)
print("Shape of b is:", b.shape)

print("Sum: \n", a + b)
```

Sum of arrays having compatible dimensions: The arrays have dimension (4, 3) and (4, 1) which are compatible. The array b is stretched along the 2nd dimension to match the dimension of a.

```a = np.arange(16).reshape(4, 4)
print("Shape of a is:", a.shape)

b = np.arange(4).reshape(4, 2)
print("Shape of b is:", b.shape)

print("Sum: \n", a + b)
```

The dimensions are (4, 4) and (4, 2). The broadcasting fails because the broadcasted dimension has to be initially 1.

```a = np.arange(15).reshape(5, 3)
print("Shape of a is:", a.shape)

b = np.arange(3)
print("Shape of b is:", b.shape)

print("Sum: \n", a + b)
```

Here the dimensions of the arrays are (5, 3) and (3, ). Array b is having one less dimension. Since the comparison of dimension takes place from right to left, b is stretched along the 1st dimension.

```a = np.arange(32).reshape(4, 4, 1, 2)
print("Shape of a is:", a.shape)

b = np.arange(8).reshape(1,4,2)
print("Shape of b is:", b.shape)

print("Shape of the sum: \n", (a + b).shape)
```

It is important to note that more than one array can be broadcasted along more than one dimensions. Array a has dimensions (4, 4, 1, 2) and array b has dimension (1, 4, 2). Array a is stretched along the third dimension while array b is stretched along the 1st and 2nd dimension, giving the resulting array of dimension (4, 4, 4, 2).