Why dtypes matter for performance in NumPy - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a NumPy array with integer data type.

NumPy

import numpy as np
arr = np.array([1, 2, 3, 4], dtype=[1])
print(arr.dtype)

Drag options to blanks, or click blank then click option'

Abool

Bfloat64

Cstr

Dint32

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'float64' when integers are needed.

Using 'str' which is for text data.

Using int32 sets the array data type to 32-bit integers, which is efficient for integer data.

2fill in blank

medium

Complete the code to create a NumPy array of floats for better precision.

NumPy

import numpy as np
arr = np.array([1.0, 2.5, 3.1], dtype=[1])
print(arr.dtype)

Drag options to blanks, or click blank then click option'

Aint64

Bbool

Cfloat64

Dint32

Attempts:

3 left

💡 Hint

Common Mistakes

Using integer types for decimal numbers causes truncation.

Using boolean type which only stores True or False.

float64 is used for floating-point numbers with double precision, suitable for decimal values.

3fill in blank

hard

Fix the error in the code by choosing the correct dtype for a boolean array.

NumPy

import numpy as np
arr = np.array([True, False, True], dtype=[1])
print(arr.dtype)

Drag options to blanks, or click blank then click option'

Abool

Bfloat64

Cint32

Dstr

Attempts:

3 left

💡 Hint

Common Mistakes

Using integer or float types wastes memory for boolean data.

Using string type causes errors when printing dtype.

The bool dtype is used for arrays of True/False values, which is memory efficient.

4fill in blank

hard

Fill both blanks to create a NumPy array of integers and convert it to float for better precision.

NumPy

import numpy as np
arr = np.array([1, 2, 3], dtype=[1])
arr_float = arr.astype([2])
print(arr_float.dtype)

Drag options to blanks, or click blank then click option'

Aint32

Bfloat64

Cint64

Dbool

Attempts:

3 left

💡 Hint

Common Mistakes

Using boolean dtype initially causes wrong data representation.

Converting to integer instead of float loses decimal precision.

Start with an integer array (int32) and convert it to floating-point (float64) for decimal precision.

5fill in blank

hard

Fill both blanks to create a float array, check its size, and convert it to int to save memory.

NumPy

import numpy as np
arr = np.array([1.5, 2.3, 3.7], dtype=[1])
print(arr.nbytes)
arr_int = arr.astype([2])
print(arr_int.nbytes)
print(arr_int)

Drag options to blanks, or click blank then click option'

Afloat64

Bint32

Cfloat32

Dint64

Attempts:

3 left

💡 Hint

Common Mistakes

Using the same dtype for both arrays does not change memory usage.

Converting to float instead of int does not reduce memory.

Start with float64 for precision, then convert to int32 to reduce memory size. The printed sizes show memory usage before and after conversion.

Practice

1. Why is choosing the right dtype important when working with large NumPy arrays?

easy

A. It saves memory and speeds up calculations.

B. It changes the shape of the array.

C. It automatically fixes errors in data.

D. It makes the array compatible with all Python libraries.

Solution

1. Step 1: Understand what dtype controls

   Dtype defines the type and size of each element in the array, affecting memory use.

2. Step 2: Connect dtype to performance

   Smaller dtypes use less memory and allow faster processing, especially for large data.

3. Final Answer:

   It saves memory and speeds up calculations. -> Option A

4. Quick Check:

   Right dtype = better memory and speed [OK]

Hint: Smaller dtype means less memory and faster math [OK]

Common Mistakes:

• Thinking dtype changes array shape
• Believing dtype fixes data errors automatically
• Assuming dtype works the same for all libraries

2. Which of the following is the correct way to create a NumPy array of integers with dtype int8?

easy

A. np.array([1, 2, 3], dtype='float32')

B. np.array([1, 2, 3], dtype='int8')

C. np.array([1, 2, 3], dtype='str')

D. np.array([1, 2, 3], dtype='bool')

Solution

1. Step 1: Identify the dtype for 8-bit integers

   The dtype 'int8' means 8-bit signed integers, suitable for small integer values.

2. Step 2: Match dtype in array creation

   np.array([1, 2, 3], dtype='int8') uses dtype='int8', which correctly sets the array elements as 8-bit integers.

3. Final Answer:

   np.array([1, 2, 3], dtype='int8') -> Option B

4. Quick Check:

   int8 dtype = 8-bit integer array [OK]

Hint: Use dtype='int8' for small integers [OK]

Common Mistakes:

• Using float32 instead of int8 for integers
• Using string dtype for numbers
• Confusing bool with int8

3. What will be the output of this code?

import numpy as np
arr = np.array([1000, 2000, 3000], dtype='int16')
print(arr * 2)

medium

A. [-11272 -9520 -7120]

B. Error: dtype mismatch

C. [2000 4000 6000 8000]

D. [2000 4000 6000]

Solution

1. Step 1: Understand int16 range

   int16 can store values from -32768 to 32767.

2. Step 2: Check arr * 2 values

   1000*2=2000, 2000*2=4000, 3000*2=6000. All within range, no overflow.

3. Step 3: Re-evaluate multiplication and overflow

   Actually, 3000*2=6000 is within int16 range, but 3000*2=6000 is correct. However, the original code output is [-11272 -9520 -7120] due to overflow because 3000*2=6000 is within range, but 1000*2=2000, 2000*2=4000, 3000*2=6000 are all within range. So the output should be [2000 4000 6000].

4. Final Answer:

   [2000 4000 6000] -> Option D

5. Quick Check:

   Multiplied values within int16 range [OK]

Hint: Check if multiplied values fit dtype range [OK]

Common Mistakes:

• Assuming overflow always happens
• Confusing int16 range limits
• Expecting error on multiplication

4. The following code causes unexpected results. What is the main issue?

import numpy as np
arr = np.array([300, 400, 500], dtype='int8')
print(arr)

medium

A. int8 dtype cannot hold values larger than 127, causing overflow.

B. The array should be created with dtype='float32' instead.

C. The array elements must be strings, not integers.

D. NumPy arrays cannot have negative values.

Solution

1. Step 1: Check int8 value limits

   int8 stores values from -128 to 127. Values 300, 400, 500 exceed this range.

2. Step 2: Understand overflow effect

   Values wrap around due to overflow, causing unexpected negative or incorrect numbers.

3. Final Answer:

   int8 dtype cannot hold values larger than 127, causing overflow. -> Option A

4. Quick Check:

   int8 max 127, overflow if exceeded [OK]

Hint: Check dtype range before assigning large values [OK]

Common Mistakes:

• Thinking float32 fixes integer overflow
• Believing array elements must be strings
• Assuming NumPy disallows negatives

5. You have a large dataset of 1 million numbers ranging from 0 to 255. Which dtype choice will optimize memory and performance without losing data accuracy?

hard

A. Use dtype='int64' for maximum integer size.

B. Use dtype='float64' to handle all numbers precisely.

C. Use dtype='uint8' since it covers 0 to 255 exactly.

D. Use dtype='bool' to save memory.

Solution

1. Step 1: Analyze data range and dtype options

   Data ranges from 0 to 255, which fits exactly in unsigned 8-bit integer (uint8).

2. Step 2: Choose dtype that fits range and saves memory

   uint8 uses 1 byte per number, saving memory and speeding up calculations compared to int64 or float64.

3. Step 3: Exclude unsuitable options

   int64 and float64 use more memory than needed; bool cannot store numbers beyond 0 or 1.

4. Final Answer:

   Use dtype='uint8' since it covers 0 to 255 exactly. -> Option C

5. Quick Check:

   uint8 fits 0-255 perfectly, best for memory [OK]

Hint: Match dtype range exactly to data range [OK]

Common Mistakes:

• Choosing larger dtypes unnecessarily
• Using float for integer-only data
• Using bool for numeric data