NumPy array vs Python list performance - Visual Side-by-Side Comparison

Concept Flow - NumPy array vs Python list performance

Create Python list with numbers

↓

Create NumPy array with same numbers

↓

Measure time for sum with Python list

↓

Measure time for sum with NumPy array

↓

Compare times

↓

Show which is faster

We create a list and a NumPy array with the same numbers, measure how long it takes to sum each, then compare the times to see which is faster.

Execution Sample

NumPy

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(end - start)

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

This code sums one million numbers using a Python list and a NumPy array, timing each operation.

Execution Table

Step	Action	Data Structure	Operation	Time Taken (seconds)	Result
1	Create list	Python list	Store 1,000,000 integers	N/A	List of 1,000,000 integers
2	Create array	NumPy array	Convert list to array	N/A	NumPy array of 1,000,000 integers
3	Sum list	Python list	sum(lst)	0.080	499999500000
4	Sum array	NumPy array	np.sum(arr)	0.010	499999500000
5	Compare times	N/A	Check which is faster	N/A	NumPy sum is faster

💡 Finished timing both sum operations and compared results

Variable Tracker

Variable	Start	After Step 1	After Step 2	After Step 3	After Step 4	Final
lst	undefined	List with 1,000,000 integers	List unchanged	List unchanged	List unchanged	List unchanged
arr	undefined	undefined	NumPy array with 1,000,000 integers	NumPy array unchanged	NumPy array unchanged	NumPy array unchanged
sum_lst	undefined	undefined	undefined	499999500000	499999500000	499999500000
sum_arr	undefined	undefined	undefined	undefined	499999500000	499999500000

Key Moments - 3 Insights

Why is the NumPy sum operation faster than the Python list sum?

NumPy uses optimized C code and vectorized operations internally, which makes summing arrays much faster than Python's built-in sum that iterates element by element (see execution_table rows 3 and 4).

Does the sum result differ between the list and the NumPy array?

No, both produce the same sum result (499999500000), confirming correctness while showing performance difference (see execution_table rows 3 and 4).

Why do we convert the list to a NumPy array before summing?

NumPy functions operate on NumPy arrays, not Python lists. Conversion allows us to use NumPy's fast methods (see execution_table row 2).

Visual Quiz - 3 Questions

Look at the execution table, what is the time taken to sum the Python list?

A 0.010 seconds

B 1.000 seconds

C 0.080 seconds

D 0.000 seconds

💡 Hint

Check the 'Time Taken (seconds)' column at Step 3 in the execution_table.

At which step is the NumPy array created from the list?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look at the 'Action' and 'Data Structure' columns in the execution_table for when the array is created.

If the list size doubled, how would the sum times likely change?

A Both times would roughly double

B Python list sum time would double, NumPy sum time stays the same

C NumPy sum time would double, Python list sum time stays the same

D Both times would stay the same

💡 Hint

Consider that both sums iterate over all elements; see variable_tracker for size impact.

Concept Snapshot

NumPy arrays store data in contiguous memory, enabling fast operations.
Python lists store references, making operations slower.
Use np.sum() for fast summing of arrays.
Convert lists to arrays to gain speed.
NumPy is faster for large numeric data.
Timing shows NumPy sum is much quicker than Python sum.

Full Transcript

We start by creating a Python list with one million numbers. Then, we convert this list into a NumPy array. Next, we measure how long it takes to sum all numbers in the Python list using the built-in sum function. After that, we measure the time to sum the same numbers using NumPy's sum function on the array. We find that NumPy's sum is much faster. Both sums produce the same result, confirming correctness. This shows that NumPy arrays are more efficient for numeric operations than Python lists.

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