Integer types (int8, int16, int32, int64) in NumPy - Mini Project: Build & Apply

Working with Integer Types in NumPy

📖 Scenario: Imagine you are analyzing sensor data from a weather station. The data includes temperature readings that need to be stored efficiently using different integer types.

🎯 Goal: You will create NumPy arrays with specific integer types (int8, int16, int32, and int64) and observe their values and types.

📋 What You'll Learn

Create NumPy arrays with exact integer types: int8, int16, int32, int64

Assign specific values to each array as instructed

Print the arrays and their data types to see the difference

💡 Why This Matters

🌍 Real World

Storing sensor data efficiently is important in many fields like weather monitoring, where memory and speed matter.

💼 Career

Understanding integer types helps in data engineering and scientific computing jobs where data size and precision are critical.

1

Create a NumPy array with int8 type

Import NumPy as np and create a NumPy array called temp_int8 with values [120, -100, 0] and data type np.int8.

NumPy

import numpy as np
# Create a NumPy array called temp_int8 with values [120, -100, 0] and dtype np.int8
# Your code here

Hint

Use np.array() with the dtype parameter set to np.int8.

2

Create a NumPy array with int16 type

Create a NumPy array called temp_int16 with values [32000, -32000, 0] and data type np.int16.

NumPy

import numpy as np
temp_int8 = np.array([120, -100, 0], dtype=np.int8)
# Create a NumPy array called temp_int16 with values [32000, -32000, 0] and dtype np.int16
# Your code here

Hint

Use np.array() with the dtype parameter set to np.int16.

3

Create NumPy arrays with int32 and int64 types

Create two NumPy arrays: temp_int32 with values [2000000000, -2000000000, 0] and data type np.int32, and temp_int64 with values [9000000000000000000, -9000000000000000000, 0] and data type np.int64.

NumPy

import numpy as np
temp_int8 = np.array([120, -100, 0], dtype=np.int8)
temp_int16 = np.array([32000, -32000, 0], dtype=np.int16)
# Create temp_int32 with values [2000000000, -2000000000, 0] and dtype np.int32
# Create temp_int64 with values [9000000000000000000, -9000000000000000000, 0] and dtype np.int64
# Your code here

Hint

Create two arrays using np.array() with dtype set to np.int32 and np.int64 respectively.

4

Print the arrays and their data types

Print each array (temp_int8, temp_int16, temp_int32, temp_int64) and their data types using print() and the .dtype attribute.

NumPy

import numpy as np
temp_int8 = np.array([120, -100, 0], dtype=np.int8)
temp_int16 = np.array([32000, -32000, 0], dtype=np.int16)
temp_int32 = np.array([2000000000, -2000000000, 0], dtype=np.int32)
temp_int64 = np.array([9000000000000000000, -9000000000000000000, 0], dtype=np.int64)
# Print each array and its dtype below
# Your code here

Hint

Use print(array, array.dtype) for each array.

Practice

1. Which numpy integer type uses the least amount of memory?

easy

A. int64

B. int16

C. int8

D. int32

Solution

1. Step 1: Understand integer type sizes

   Each numpy integer type uses a different number of bits: int8 uses 8 bits, int16 uses 16 bits, int32 uses 32 bits, and int64 uses 64 bits.

2. Step 2: Identify the smallest size

   Since 8 bits is the smallest size, int8 uses the least memory.

3. Final Answer:

   int8 -> Option C

4. Quick Check:

   Smallest bits = int8 [OK]

Hint: Smaller int types use fewer bits and less memory [OK]

Common Mistakes:

• Confusing int8 with int16 or larger types
• Thinking int64 uses less memory
• Assuming int32 is smallest

2. Which of the following is the correct way to create a numpy array of type int16?

easy

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

B. np.array([1, 2, 3], type='int16')

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

D. np.array([1, 2, 3], type=int16)

Solution

1. Step 1: Recall numpy array creation syntax

   To specify the data type, use the parameter dtype with a string or numpy type.

2. Step 2: Check each option

   np.array([1, 2, 3], dtype='int16') uses dtype='int16', which is correct. Options B and D use type which is invalid. np.array([1, 2, 3], dtype=int8) uses dtype=int8, which is valid syntax but wrong type.

3. Final Answer:

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

4. Quick Check:

   Use dtype='int16' to set type [OK]

Hint: Use dtype='intXX' to set integer type in numpy array [OK]

Common Mistakes:

• Using 'type' instead of 'dtype'
• Passing dtype without quotes for string type
• Confusing int8 and int16 types

3. What will be the output of this code?

import numpy as np
arr = np.array([127, 128], dtype='int8')
print(arr)

medium

A. [127 128]

B. [127 -128]

C. [127 0]

D. Error: value out of range

Solution

1. Step 1: Understand int8 range

   int8 can store values from -128 to 127. The value 128 is outside this range.

2. Step 2: Observe overflow behavior

   When 128 is stored in int8, it wraps around to -128 due to overflow.

3. Final Answer:

   [127 -128] -> Option B

4. Quick Check:

   int8 overflow wraps 128 to -128 [OK]

Hint: int8 max is 127; values above wrap to negative [OK]

Common Mistakes:

• Expecting 128 to store correctly in int8
• Assuming error raised on overflow
• Thinking 128 becomes 0

4. Identify the error in this code snippet:

import numpy as np
arr = np.array([1000, 2000], dtype='int8')
print(arr)

medium

A. No error, prints [1000 2000]

B. SyntaxError due to dtype

C. ValueError: integer out of range

D. Values overflow and wrap around silently

Solution

1. Step 1: Check dtype and values

   The array uses int8 which can only hold -128 to 127, but values 1000 and 2000 are much larger.

2. Step 2: Understand numpy overflow behavior

   Instead of error, numpy silently wraps values using modulo 256, causing overflow.

3. Final Answer:

   Values overflow and wrap around silently -> Option D

4. Quick Check:

   int8 overflow wraps large values silently [OK]

Hint: Large values in small int types wrap silently, no error [OK]

Common Mistakes:

• Expecting ValueError on overflow
• Thinking values print as is
• Confusing syntax error with dtype

5. You have a large dataset of whole numbers ranging from -30000 to 30000. Which numpy integer type should you choose to store this data efficiently without overflow?

hard

A. int16

B. int32

C. int8

D. int64

Solution

1. Step 1: Identify the value range needed

   The data ranges from -30000 to 30000, so the integer type must cover at least this range.

2. Step 2: Check integer type ranges

   int8 covers -128 to 127 (too small), int16 covers -32768 to 32767 (fits range), int32 and int64 cover larger ranges but use more memory.

3. Step 3: Choose the smallest type that fits

   int16 fits the range and uses less memory than int32 or int64.

4. Final Answer:

   int16 -> Option A

5. Quick Check:

   int16 range covers ±30000 efficiently [OK]

Hint: Pick smallest int type covering data range to save memory [OK]

Common Mistakes:

• Choosing int8 which is too small
• Picking int64 unnecessarily
• Ignoring negative range limits