Avoiding temporary arrays in NumPy - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of element-wise multiplication without temporary arrays

What is the output of this code that multiplies two numpy arrays element-wise without creating a temporary array?

NumPy

import numpy as np

x = np.array([1, 2, 3])
y = np.array([4, 5, 6])
result = np.multiply(x, y, out=x)
print(result)

A [5 7 9]

B [4 10 18]

C [1 2 3]

D [4 5 6]

💡 Hint

Look at the use of the 'out' parameter in np.multiply.

The 'out=x' argument tells numpy to store the result directly in array x, avoiding a temporary array. So x becomes [4, 10, 18].

❓ data_output

intermediate

Number of temporary arrays created in chained operations

Given the code below, how many temporary arrays are created during the computation?

NumPy

import numpy as np

x = np.array([1, 2, 3])
y = np.array([4, 5, 6])
z = np.array([7, 8, 9])
result = x + y + z

A 0

B 1

C 2

D 3

💡 Hint

Think about how numpy evaluates chained additions.

The expression x + y + z is evaluated as (x + y) + z. The first addition creates one temporary array, then adding z creates another temporary array before assigning to result. So 2 temporary arrays are created.

🔧 Debug

advanced

Why does this code create a temporary array?

Consider this code snippet. Why does it create a temporary array despite using in-place addition?

NumPy

import numpy as np

x = np.array([1, 2, 3])
y = np.array([4, 5, 6])
z = np.array([7, 8, 9])
x += y + z
print(x)

A Because x += y + z modifies x without any temporary arrays

B Because numpy does not support in-place operations

C Because in-place addition always creates a temporary array

D Because y + z creates a temporary array before adding to x

💡 Hint

Look at the order of operations and what y + z does.

The expression y + z creates a temporary array holding their sum before x is updated in-place. So a temporary array is created despite using '+='.

🚀 Application

advanced

Rewrite code to avoid temporary arrays

Which option rewrites the code below to avoid creating temporary arrays during the addition of three arrays?

NumPy

import numpy as np

x = np.array([1, 2, 3])
y = np.array([4, 5, 6])
z = np.array([7, 8, 9])
result = x + y + z

A

np.add(x, y, out=x)
np.add(x, z, out=x)
result = x

B result = np.add(np.add(x, y), z)

C result = x + (y + z)

D result = np.add(x, y + z)

💡 Hint

Use the 'out' parameter to store results in-place.

Option A uses np.add with the 'out' parameter to store intermediate results in x, avoiding temporary arrays. Other options create temporary arrays during addition.

🧠 Conceptual

expert

Why avoid temporary arrays in large data computations?

Why is it important to avoid creating temporary arrays in large numpy computations?

A To reduce memory usage and improve performance by minimizing data copying

B Because temporary arrays cause syntax errors in numpy

C Because numpy does not support temporary arrays for large data

D To make code shorter and easier to read

💡 Hint

Think about memory and speed when working with big data.

Temporary arrays use extra memory and slow down computations due to copying data. Avoiding them helps performance and reduces memory pressure.