Array protocol and __array__ in NumPy - Time & Space Complexity

Time Complexity: Array protocol and __array__

O(n)

Understanding Time Complexity

We want to understand how fast operations run when using the array protocol and the __array__ method in numpy.

Specifically, how does the time to convert or interact with arrays grow as the data size increases?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

import numpy as np

class MyArray:
    def __init__(self, data):
        self.data = data
    def __array__(self, dtype=None):
        return np.array(self.data, dtype=dtype)

obj = MyArray([1, 2, 3, 4, 5])
arr = np.array(obj)

This code defines a class with a __array__ method that returns a numpy array from its data. Then numpy calls this method to create an array.

Identify Repeating Operations

Look at what repeats when numpy converts the object to an array.

• Primary operation: Copying or reading each element from the original data list to build the numpy array.
• How many times: Once for each element in the data (n times, where n is the data size).

How Execution Grows With Input

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

Input Size (n)	Approx. Operations
10	About 10 element copies
100	About 100 element copies
1000	About 1000 element copies

Pattern observation: Doubling the input size roughly doubles the work needed.

Final Time Complexity

Time Complexity: O(n)

This means the time to convert grows linearly with the number of elements in the data.

Common Mistake

[X] Wrong: "Calling __array__ is instant and does not depend on data size."

[OK] Correct: The method creates a new numpy array by copying data, so it must look at each element, which takes time proportional to the data size.

Interview Connect

Understanding how numpy uses __array__ helps you explain how data conversion works under the hood, a useful skill when discussing performance in data science tasks.

Self-Check

What if the __array__ method returned a view instead of copying data? How would the time complexity change?

Practice

1. What is the main purpose of the __array__ method in a custom Python class when working with NumPy?

easy

A. To create a plot from the array data

B. To allow the object to be converted automatically into a NumPy array

C. To perform element-wise multiplication on arrays

D. To define a new data type for NumPy arrays

Solution

1. Step 1: Understand the role of __array__

   The __array__ method is designed to let custom objects tell NumPy how to convert them into arrays.

2. Step 2: Identify the main purpose

   This method enables automatic conversion, so NumPy can work with the data efficiently.

3. Final Answer:

   To allow the object to be converted automatically into a NumPy array -> Option B

4. Quick Check:

   Conversion to NumPy array [OK]

Hint: Remember: __array__ means 'convert me to array' [OK]

Common Mistakes:

• Confusing __array__ with data type definition
• Thinking __array__ performs calculations
• Assuming __array__ creates plots

2. Which of the following is the correct way to define the __array__ method in a custom class to return a NumPy array?

easy

A. def __array__(self, dtype): return self.data.astype(dtype)

B. def __array__(self): return list(self.data)

C. def __array__(self): return self.data.tolist()

D. def __array__(self, dtype=None): return np.array(self.data, dtype=dtype)

Solution

1. Step 1: Check method signature

   The __array__ method should accept an optional dtype argument for flexibility.

2. Step 2: Verify return type

   It must return a NumPy array, so using np.array(self.data, dtype=dtype) is correct.

3. Final Answer:

   def __array__(self, dtype=None): return np.array(self.data, dtype=dtype) -> Option D

4. Quick Check:

   Correct signature and return type [OK]

Hint: Include dtype=None and return np.array inside __array__ [OK]

Common Mistakes:

• Omitting dtype parameter
• Returning list instead of np.array
• Using tolist() which returns Python list

3. Given the code below, what will be the output of print(np.array(obj))?

import numpy as np

class MyData:
    def __init__(self):
        self.data = [1, 2, 3]
    def __array__(self, dtype=None):
        return np.array(self.data, dtype=dtype)

obj = MyData()
print(np.array(obj))

medium

A. [1 2 3]

B. [[1 2 3]]

C. TypeError: object cannot be converted to array

D. [1, 2, 3]

Solution

1. Step 1: Understand __array__ method behavior

   The method returns a NumPy array created from the list [1, 2, 3].

2. Step 2: Predict np.array conversion

   Calling np.array(obj) triggers obj.__array__(), returning np.array([1, 2, 3]), which prints as [1 2 3].

3. Final Answer:

   [1 2 3] -> Option A

4. Quick Check:

   Custom __array__ returns array [1 2 3] [OK]

Hint: np.array calls __array__, returns array, prints without commas [OK]

Common Mistakes:

• Expecting Python list output with commas
• Thinking output is nested array
• Assuming TypeError due to custom class

4. What is wrong with this __array__ method implementation?

def __array__(self):
    return self.data.astype(float)

medium

A. It does not accept the optional dtype argument

B. astype cannot convert to float

C. Returning self.data directly is required

D. The method should return a list, not an array

Solution

1. Step 1: Check method signature

   The __array__ method should accept an optional dtype argument to allow flexible conversions.

2. Step 2: Identify missing dtype parameter

   This method lacks the dtype=None parameter, so it cannot handle dtype requests from NumPy.

3. Final Answer:

   It does not accept the optional dtype argument -> Option A

4. Quick Check:

   Missing dtype parameter [OK]

Hint: Always include dtype=None in __array__ method [OK]

Common Mistakes:

• Forgetting dtype argument
• Thinking astype cannot convert types
• Returning list instead of array

5. You have a custom class with a __array__ method that returns a NumPy array. You want to ensure that when you call np.array(obj, dtype=np.float64), the returned array respects the requested dtype. How should you modify the __array__ method?

hard

A. def __array__(self, dtype=None): return np.array(self.data)

B. def __array__(self): return np.array(self.data, dtype=np.float64)

C. def __array__(self, dtype=None): return np.array(self.data, dtype=dtype)

D. def __array__(self, dtype): return self.data.astype(dtype)

Solution

1. Step 1: Understand dtype propagation

   NumPy passes the requested dtype to __array__ as an argument; the method must accept it.

2. Step 2: Implement dtype-aware conversion

   Return np.array(self.data, dtype=dtype) so the requested dtype is applied correctly.

3. Final Answer:

   def __array__(self, dtype=None): return np.array(self.data, dtype=dtype) -> Option C

4. Quick Check:

   Accept dtype and pass to np.array [OK]

Hint: Pass dtype argument to np.array inside __array__ method [OK]

Common Mistakes:

• Ignoring dtype argument
• Hardcoding dtype inside method
• Not accepting dtype parameter