Type promotion in operations in NumPy - Step-by-Step Execution

Concept Flow - Type promotion in operations

Start with arrays of different types

↓

Perform operation (e.g., addition)

↓

Check types of operands

↓

Apply type promotion rules

↓

Result array has promoted type

↓

Output result with promoted type

When numpy arrays of different types are used in operations, numpy promotes their types to a common type that can hold all values safely before computing the result.

Execution Sample

NumPy

import numpy as np
arr1 = np.array([1, 2, 3], dtype=np.int32)
arr2 = np.array([1.5, 2.5, 3.5], dtype=np.float64)
result = arr1 + arr2
print(result)
print(result.dtype)

Adds an int32 array and a float64 array, showing how numpy promotes types to float64 for the result.

Execution Table

Step	Action	Operand 1 Type	Operand 2 Type	Promoted Type	Result Value	Result Type
1	Create arr1	int32	-	-	[1 2 3]	int32
2	Create arr2	-	float64	-	[1.5 2.5 3.5]	float64
3	Add arr1 + arr2	int32	float64	float64	[2.5 4.5 6.5]	float64
4	Print result	-	-	-	[2.5 4.5 6.5]	float64
5	Print result dtype	-	-	-	float64	dtype('float64')

💡 Operation completes with result promoted to float64 because float64 can hold int32 and float values safely.

Variable Tracker

Variable	Start	After Operation	Final
arr1	[1 2 3] (int32)	[1 2 3] (int32)	[1 2 3] (int32)
arr2	[1.5 2.5 3.5] (float64)	[1.5 2.5 3.5] (float64)	[1.5 2.5 3.5] (float64)
result	N/A	[2.5 4.5 6.5] (float64)	[2.5 4.5 6.5] (float64)

Key Moments - 2 Insights

Why is the result array's type float64 instead of int32?

Because numpy promotes types to the more general type that can hold all values safely. Here, float64 can hold both int32 and float64 values, so the result is float64 (see execution_table step 3).

Does the original int32 array change its type after the operation?

No, the original arrays keep their types unchanged. Only the result array has the promoted type (see variable_tracker for arr1 and result).

Visual Quiz - 3 Questions

Look at the execution table at step 3, what is the promoted type for the addition?

A float64

B int32

C int64

D object

💡 Hint

Check the 'Promoted Type' column at step 3 in the execution_table.

At which step does the result array get created with the promoted type?

A Step 2

B Step 3

C Step 1

D Step 4

💡 Hint

Look for the step where the addition happens and the result type is assigned.

If arr2 was int16 instead of float64, what would be the promoted type when adding to arr1 (int32)?

A int16

B float64

C int32

D object

💡 Hint

Consider numpy's type promotion rules for integer types of different sizes.

Concept Snapshot

Type promotion in numpy operations:
- When arrays of different types are combined, numpy promotes to a common type.
- The promoted type can hold all values without loss.
- Example: int32 + float64 -> float64 result.
- Original arrays keep their types unchanged.
- Result array has the promoted type.

Full Transcript

This visual execution shows how numpy promotes types when performing operations on arrays of different types. Starting with an int32 array and a float64 array, numpy adds them by promoting the int32 to float64 to avoid losing decimal information. The result array is float64 type. The original arrays remain unchanged. This ensures safe and accurate calculations.

Practice

1. What happens in NumPy when you add an integer array to a float array?

easy

A. The result array will have integer type, truncating floats.

B. The result array will have float type due to type promotion.

C. NumPy throws a type error and stops execution.

D. The result array will have string type.

Solution

1. Step 1: Understand type promotion in mixed operations

   When adding int and float arrays, NumPy promotes the int to float to avoid losing decimal information.

2. Step 2: Check the resulting data type

   The output array will have float dtype because float has higher precision than int.

3. Final Answer:

   The result array will have float type due to type promotion. -> Option B

4. Quick Check:

   int + float = float [OK]

Hint: Mixed int and float always promote to float [OK]

Common Mistakes:

• Assuming result stays integer and truncates decimals
• Thinking NumPy throws an error on mixed types
• Believing result becomes string type

2. Which of the following NumPy operations correctly promotes types when multiplying an int array by a float scalar?

easy

A. np.array([1, 2, 3]) * 2.0

B. np.array([1, 2, 3]) * '2'

C. np.array([1, 2, 3]) * 2

D. np.array([1, 2, 3]) * np.array(['2', '3', '4'])

Solution

1. Step 1: Identify valid type promotion in multiplication

   Multiplying an int array by a float scalar promotes the result to float.

2. Step 2: Check each option for correct type promotion

   np.array([1, 2, 3]) * 2.0 multiplies by 2.0 (float), so result is float array. np.array([1, 2, 3]) * 2 multiplies by int 2, no promotion. The options involving strings cause errors.

3. Final Answer:

   np.array([1, 2, 3]) * 2.0 -> Option A

4. Quick Check:

   int array * float scalar = float array [OK]

Hint: Multiply int array by float scalar for float result [OK]

Common Mistakes:

• Using string instead of numeric scalar
• Expecting int result when multiplying by float
• Confusing string multiplication with numeric

3. What is the dtype of the result when you run this code?

import numpy as np
arr1 = np.array([1, 2, 3], dtype=np.int32)
arr2 = np.array([1.5, 2.5, 3.5], dtype=np.float64)
result = arr1 + arr2
dtype_result = result.dtype

medium

A. int32

B. object

C. float32

D. float64

Solution

1. Step 1: Identify input array dtypes

   arr1 is int32, arr2 is float64.

2. Step 2: Understand type promotion rules

   When adding int32 and float64, NumPy promotes to float64 to preserve precision.

3. Final Answer:

   float64 -> Option D

4. Quick Check:

   int32 + float64 = float64 [OK]

Hint: Higher precision float wins in mixed int-float ops [OK]

Common Mistakes:

• Assuming result is int32
• Confusing float32 with float64
• Expecting object dtype for numeric arrays

4. Consider this code snippet:

import numpy as np
arr = np.array([1, 2, 3], dtype=np.int8)
result = arr + 1.5

Why might the result's dtype not be what you expect if you change arr to np.int16?

medium

A. Because int16 promotes to string, causing unexpected dtype.

B. Because int16 does not promote and causes an error.

C. Because int16 promotes to float64, changing result dtype.

D. Because int16 promotes to int8, lowering precision.

Solution

1. Step 1: Understand type promotion with int8 and int16

   Adding float 1.5 to int8 promotes to float64. Similarly, int16 also promotes to float64.

2. Step 2: Explain why dtype changes with int16

   int16 has higher precision than int8 but still promotes to float64 when added to float, so result dtype is float64, not int16.

3. Final Answer:

   Because int16 promotes to float64, changing result dtype. -> Option C

4. Quick Check:

   int16 + float = float64 [OK]

Hint: Adding float promotes int16 to float64, not int16 [OK]

Common Mistakes:

• Thinking int16 causes error with float addition
• Assuming int16 promotes down to int8
• Believing result becomes string dtype

5. You have two arrays:

arr_int = np.array([1000, 2000], dtype=np.int16)
arr_float = np.array([0.1, 0.2], dtype=np.float32)

You want to add them and keep the result as float32 to save memory. Which code correctly achieves this with type promotion?

hard

A. result = arr_int.astype(np.float32) + arr_float

B. result = arr_int + arr_float.astype(np.float64)

C. result = arr_int + arr_float

D. result = arr_int.astype(np.int32) + arr_float

Solution

1. Step 1: Understand default type promotion

   Adding int16 and float32 promotes to float64 by default, increasing memory.

2. Step 2: Convert int16 to float32 before addition

   By converting arr_int to float32, adding float32 arrays keeps result as float32, saving memory.

3. Step 3: Check other options

   result = arr_int + arr_float.astype(np.float64) promotes to float64, increasing memory. result = arr_int + arr_float promotes to float64 by default. result = arr_int.astype(np.int32) + arr_float promotes int16 to int32, then adds float32, promoting to float64.

4. Final Answer:

   result = arr_int.astype(np.float32) + arr_float -> Option A

5. Quick Check:

   Cast int to float32 first to keep float32 result [OK]

Hint: Cast int to float32 before adding float32 to keep dtype [OK]

Common Mistakes:

• Ignoring default promotion to float64
• Casting float to float64 increasing memory
• Not casting int before addition