As seen earlier, NumPy has in-built support for broadcasting. This function mimics the broadcasting mechanism. It returns an object that encapsulates the result of broadcasting one array against the other.

The function takes two arrays as input parameters. Following example illustrates its use.

## Example

```import numpy as np
x = np.array([, , ])
y = np.array([4, 5, 6])

# it has an iterator property, a tuple of iterators along self's "components."

r,c = b.iters
print r.next(), c.next()
print r.next(), c.next()
print '\n'
# shape attribute returns the shape of broadcast object

print 'The shape of the broadcast object:'
print b.shape
print '\n'
c = np.empty(b.shape)

print c.shape
print '\n'
c.flat = [u + v for (u,v) in b]

print 'After applying the flat function:'
print c
print '\n'
# same result obtained by NumPy's built-in broadcasting support

print 'The summation of x and y:'
print x + y
```

Its output is as follows −

```Broadcast x against y:
1 4
1 5

The shape of the broadcast object:
(3, 3)

(3, 3)

After applying the flat function:
[[ 5. 6. 7.]
[ 6. 7. 8.]
[ 7. 8. 9.]]

The summation of x and y:
[[5 6 7]
[6 7 8]
[7 8 9]]
```
numpy_array_manipulation.htm