Array creation (array, arange, linspace) in Data Analysis Python - Time & Space Complexity

Time Complexity: Array creation (array, arange, linspace)

O(n)

Understanding Time Complexity

When we create arrays using functions like array, arange, or linspace, it is important to understand how the time to create these arrays grows as the size increases.

We want to know how the work done changes when we ask for bigger arrays.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

import numpy as np

size = 1000
arr1 = np.array(list(range(size)))
arr2 = np.arange(size)
arr3 = np.linspace(0, 10, size)

This code creates three arrays of the same size using three different NumPy functions.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Creating each element of the array one by one.
• How many times: Exactly size times for each array creation.

How Execution Grows With Input

As the requested array size grows, the time to create the array grows roughly in direct proportion.

Input Size (n)	Approx. Operations
10	10 operations
100	100 operations
1000	1000 operations

Pattern observation: Doubling the size roughly doubles the work needed to create the array.

Final Time Complexity

Time Complexity: O(n)

This means the time to create the array grows linearly with the number of elements you want.

Common Mistake

[X] Wrong: "Creating an array with linspace is faster because it just calculates start and end points."

[OK] Correct: Even though linspace calculates evenly spaced points, it still needs to generate each element, so the time grows with the number of points.

Interview Connect

Understanding how array creation scales helps you reason about data preparation steps in real projects, showing you can think about efficiency beyond just writing code.

Self-Check

"What if we create an array by repeating a single value n times? How would the time complexity change?"

Practice

1. What does the function np.arange(1, 5) produce in Python's NumPy?

easy

A. An array with values [1, 2, 3, 4, 5]

B. An array with values [1, 3, 5]

C. An array with values [0, 1, 2, 3, 4]

D. An array with values [1, 2, 3, 4]

Solution

1. Step 1: Understand np.arange parameters

   np.arange(start, stop) creates values from start up to but not including stop.

2. Step 2: Apply to np.arange(1, 5)

   Values start at 1 and go up to 4 (5 is excluded), so the array is [1, 2, 3, 4].

3. Final Answer:

   An array with values [1, 2, 3, 4] -> Option D

4. Quick Check:

   arange excludes stop = [1, 2, 3, 4] [OK]

Hint: Remember arange excludes the stop value [OK]

Common Mistakes:

• Including the stop value in the output
• Starting from 0 instead of the given start
• Confusing arange with linspace

2. Which of the following is the correct syntax to create a NumPy array from the list [10, 20, 30]?

easy

A. np.array([10, 20, 30])

B. np.linspace(10, 20, 30)

C. np.arange([10, 20, 30])

D. np.array(10, 20, 30)

Solution

1. Step 1: Recall np.array syntax

   np.array() takes a single list or iterable as input to create an array.

2. Step 2: Check each option

   np.array([10, 20, 30]) correctly passes a list inside brackets. np.array(10, 20, 30) passes separate arguments, which is invalid. np.arange([10, 20, 30]) uses arange incorrectly. np.linspace(10, 20, 30) uses linspace which is for ranges, not lists.

3. Final Answer:

   np.array([10, 20, 30]) -> Option A

4. Quick Check:

   np.array needs a list inside brackets [OK]

Hint: Use brackets [] inside np.array to pass a list [OK]

Common Mistakes:

• Passing multiple arguments instead of a list
• Using arange or linspace to convert lists
• Forgetting brackets around the list

3. What is the output of the following code?

import numpy as np
arr = np.linspace(0, 1, 5)
print(arr)

medium

A. [0. 0.5 1. ]

B. [0. 0.2 0.4 0.6 0.8]

C. [0. 0.25 0.5 0.75 1. ]

D. [0. 0.1 0.2 0.3 0.4]

Solution

1. Step 1: Understand np.linspace parameters

   np.linspace(start, stop, num) creates num evenly spaced points from start to stop inclusive.

2. Step 2: Apply to np.linspace(0, 1, 5)

   It creates 5 points between 0 and 1: 0.0, 0.25, 0.5, 0.75, 1.0.

3. Final Answer:

   [0. 0.25 0.5 0.75 1. ] -> Option C

4. Quick Check:

   linspace includes stop and divides evenly [OK]

Hint: linspace includes stop and divides into equal parts [OK]

Common Mistakes:

• Confusing linspace with arange step behavior
• Expecting stop to be excluded
• Wrong number of points generated

4. Identify the error in the following code snippet:

import numpy as np
arr = np.arange(0, 10, 3.5)
print(arr)

medium

A. arange does not accept float step values

B. The code runs correctly and prints [0. 3.5 7.]

C. arange requires integer start and stop values

D. Missing import statement for numpy

Solution

1. Step 1: Check np.arange with float steps

   NumPy's arange supports float step values, so 3.5 is valid.

2. Step 2: Predict output of np.arange(0, 10, 3.5)

   Values start at 0, then 3.5, then 7.0. Next would be 10.5 which exceeds stop 10, so stops.

3. Final Answer:

   The code runs correctly and prints [0. 3.5 7.] -> Option B

4. Quick Check:

   arange accepts float steps and excludes stop [OK]

Hint: arange allows float steps, output excludes stop [OK]

Common Mistakes:

• Assuming arange only works with integers
• Expecting stop value to be included
• Forgetting to import numpy

5. You want to create an array of exactly 4 numbers starting at 2 and ending at 5, including both ends. Which code snippet correctly does this?

hard

A. np.linspace(2, 5, 4)

B. np.arange(2, 5, 1)

C. np.arange(2, 6, 2)

D. np.linspace(2, 5, 3)

Solution

1. Step 1: Understand the requirement

   We need 4 numbers starting at 2 and ending at 5, including both ends.

2. Step 2: Check np.arange options

   np.arange(2, 5, 1) creates [2, 3, 4], only 3 numbers and excludes 5. np.arange(2, 6, 2) creates [2, 4], wrong number of elements and values.

3. Step 3: Check np.linspace options

   np.linspace(2, 5, 4) creates 4 evenly spaced numbers including 2 and 5: [2.0, 3.0, 4.0, 5.0]. np.linspace(2, 5, 3) creates only 3 numbers.

4. Final Answer:

   np.linspace(2, 5, 4) -> Option A

5. Quick Check:

   linspace fixes number of points including ends [OK]

Hint: Use linspace to fix number of points including start and stop [OK]

Common Mistakes:

• Using arange which excludes stop and depends on step size
• Choosing wrong number of points in linspace
• Confusing arange and linspace behavior