NumPy array vs Python list performance - Hands-On Comparison

NumPy array vs Python list performance

📖 Scenario: You want to understand how fast NumPy arrays are compared to regular Python lists when doing math operations on many numbers. This helps you choose the best tool for your data tasks.

🎯 Goal: You will create a Python list and a NumPy array with the same numbers, then measure and compare the time it takes to add 1 to every number in each.

📋 What You'll Learn

Create a Python list with numbers from 0 to 9999

Create a NumPy array with numbers from 0 to 9999

Measure the time to add 1 to every element in the Python list using a loop

Measure the time to add 1 to every element in the NumPy array using vectorized addition

Print both times to compare performance

💡 Why This Matters

🌍 Real World

Data scientists often need to process large amounts of numbers quickly. Knowing that NumPy arrays are faster than Python lists helps them write efficient code.

💼 Career

Understanding performance differences between data structures is important for roles like data analyst, data engineer, and machine learning engineer to optimize data processing.

1

Create a Python list and a NumPy array

Create a Python list called py_list with numbers from 0 to 9999 using range(10000). Then import NumPy as np and create a NumPy array called np_array from py_list.

NumPy

# Create py_list and np_array as described
# Your code here

Hint

Use list(range(10000)) for the Python list and np.array() to convert it to a NumPy array.

2

Set up timing variables

Import the time module. Create two variables called start_time_list and start_time_np to store the start times for timing the Python list and NumPy array operations.

NumPy

py_list = list(range(10000))
import numpy as np
np_array = np.array(py_list)
# Import time and create start_time_list and start_time_np variables
# Your code here

Hint

Use import time and create variables with initial value 0 to hold start times.

3

Measure time to add 1 to each element

Use time.time() to set start_time_list. Then create a new list result_list by adding 1 to each element in py_list using a for loop. Next, use time.time() to get end_time_list. Repeat timing for NumPy array addition by setting start_time_np, adding 1 to np_array with np_array + 1 saved as result_np, and getting end_time_np.

NumPy

py_list = list(range(10000))
import numpy as np
np_array = np.array(py_list)
import time
start_time_list = 0
start_time_np = 0
# Measure time for list addition
# Measure time for NumPy addition
# Your code here

Hint

Use time.time() before and after each operation to measure elapsed time. Use a for loop to add 1 to each list element. Use np_array + 1 for NumPy.

4

Print the timing results

Calculate the elapsed time for the Python list as end_time_list - start_time_list and for the NumPy array as end_time_np - start_time_np. Print both times with clear messages: print(f"Python list addition took: {list_time} seconds") and print(f"NumPy array addition took: {np_time} seconds").

NumPy

py_list = list(range(10000))
import numpy as np
np_array = np.array(py_list)
import time
start_time_list = time.time()
result_list = []
for x in py_list:
    result_list.append(x + 1)
end_time_list = time.time()
start_time_np = time.time()
result_np = np_array + 1
end_time_np = time.time()
# Calculate elapsed times and print them
# Your code here

Hint

Subtract start times from end times to get elapsed seconds. Use print() with f-strings to show results.

Practice

1. Which of the following is true about NumPy arrays compared to Python lists when working with large numeric data?

easy

A. Python lists use less memory than NumPy arrays for numbers.

B. Python lists are faster for numeric calculations than NumPy arrays.

C. NumPy arrays and Python lists have the same speed for math operations.

D. NumPy arrays perform mathematical operations faster than Python lists.

Solution

1. Step 1: Understand data structure differences

   NumPy arrays store data in a continuous block of memory optimized for numeric operations, unlike Python lists which store references to objects.

2. Step 2: Compare performance for math operations

   This memory layout allows NumPy to perform vectorized operations much faster than Python lists, which require looping in Python code.

3. Final Answer:

   NumPy arrays perform mathematical operations faster than Python lists. -> Option D

4. Quick Check:

   NumPy arrays faster for math = D [OK]

Hint: NumPy arrays are optimized for math speed, unlike lists. [OK]

Common Mistakes:

• Thinking Python lists are faster for math
• Assuming both have same speed
• Confusing memory usage with speed

2. Which of the following is the correct way to create a NumPy array from a Python list [1, 2, 3]?

easy

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

B. np.list([1, 2, 3])

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

D. np.array{1, 2, 3}

Solution

1. Step 1: Recall NumPy array creation syntax

   The function to create a NumPy array is np.array() and it takes a list as input.

2. Step 2: Check each option for syntax correctness

   np.array([1, 2, 3]) uses correct syntax. np.list([1, 2, 3]) uses a non-existent function np.list(). array([1, 2, 3]) misses the np. prefix. np.array{1, 2, 3} uses curly braces which is invalid.

3. Final Answer:

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

4. Quick Check:

   Correct NumPy array syntax = A [OK]

Hint: Use np.array() with square brackets for lists. [OK]

Common Mistakes:

• Using curly braces instead of square brackets
• Missing np prefix
• Using non-existent np.list() function

3. What will be the output of the following code?

import numpy as np
import time

lst = list(range(1000000))
arr = np.array(lst)

start = time.time()
sum_lst = sum(lst)
end = time.time()
print(round(end - start, 5))

start = time.time()
sum_arr = np.sum(arr)
end = time.time()
print(round(end - start, 5))

medium

A. The time to sum the list is less than the time to sum the NumPy array.

B. The time to sum the NumPy array is less than the time to sum the list.

C. Both times are exactly the same.

D. The code will raise an error because np.sum cannot sum arrays.

Solution

1. Step 1: Understand sum operation on list vs NumPy array

   Python's built-in sum() loops over the list in Python code, which is slower. NumPy's np.sum() uses optimized C code for fast summation.

2. Step 2: Predict timing results

   Because of this optimization, np.sum(arr) runs faster than sum(lst), so the printed time for NumPy sum is less.

3. Final Answer:

   The time to sum the NumPy array is less than the time to sum the list. -> Option B

4. Quick Check:

   NumPy sum faster than list sum = A [OK]

Hint: NumPy uses fast C code for sums, lists use slow Python loops. [OK]

Common Mistakes:

• Assuming Python sum is faster
• Thinking both times are equal
• Believing np.sum cannot sum arrays

4. The following code tries to multiply each element of a Python list by 2 using NumPy syntax but fails. What is the error?

lst = [1, 2, 3, 4]
result = lst * 2
print(result)

medium

A. It raises a TypeError because lists cannot be multiplied.

B. It prints [2, 4, 6, 8] as expected.

C. It prints [1, 2, 3, 4, 1, 2, 3, 4] instead of doubling values.

D. It raises a NameError because 'lst' is undefined.

Solution

1. Step 1: Understand list multiplication behavior

   Multiplying a Python list by 2 repeats the list elements, it does not multiply each element.

2. Step 2: Compare with NumPy array behavior

   NumPy arrays multiply each element by 2, but Python lists just repeat the list when multiplied by an integer.

3. Final Answer:

   It prints [1, 2, 3, 4, 1, 2, 3, 4] instead of doubling values. -> Option C

4. Quick Check:

   List * 2 repeats list, does not multiply elements = C [OK]

Hint: List * 2 repeats list; use np.array for element-wise multiply. [OK]

Common Mistakes:

• Expecting element-wise multiplication on lists
• Thinking it raises an error
• Confusing list and array multiplication

5. You have a large dataset of 1 million numbers stored as a Python list. You want to compute the mean efficiently. Which approach is best and why?

Option A:
mean = sum(lst) / len(lst)

Option B:
import numpy as np
arr = np.array(lst)
mean = np.mean(arr)

Option C:
mean = sum(lst) // len(lst)

Option D:
mean = np.sum(lst) / len(lst)

hard

A. Convert list to NumPy array and use np.mean for faster computation.

B. Use Python sum and len for mean; it's simple and fast enough.

C. Use integer division with sum and len for mean to speed up.

D. Use np.sum on list directly without conversion for best speed.

Solution

1. Step 1: Evaluate each option's efficiency

   Use Python sum and len for mean; it's simple and fast enough. uses Python sum which is slower on large lists. Use integer division with sum and len for mean to speed up. uses integer division which loses precision and is not faster. Use np.sum on list directly without conversion for best speed. tries np.sum on a list which works but is slower than on arrays.

2. Step 2: Identify best performance approach

   Convert list to NumPy array and use np.mean for faster computation. converts the list to a NumPy array and uses np.mean, which is optimized in C and much faster for large numeric data.

3. Final Answer:

   Convert list to NumPy array and use np.mean for faster computation. -> Option A

4. Quick Check:

   NumPy array + np.mean fastest for large numeric data = B [OK]

Hint: Convert list to NumPy array for fast numeric operations. [OK]

Common Mistakes:

• Using integer division losing decimal precision
• Using np.sum on list without conversion
• Assuming Python sum is fast enough for large data