Skip to main content

Python NumPy: How to Resolve "AttributeError: 'numpy.ndarray' object has no attribute 'append'"

When transitioning from standard Python lists to NumPy arrays, a common mistake is to try adding an element using the .append() method, which results in the AttributeError: 'numpy.ndarray' object has no attribute 'append'. This error occurs because, unlike Python lists which are dynamic, NumPy arrays are designed with a fixed size in memory for high performance. As a result, they do not have an in-place .append() method.

The correct way to add elements to a NumPy array is to use the numpy.append() function, which creates and returns a new array with the added elements. This guide will explain why the error occurs, demonstrate the correct solution, and discuss important performance considerations.

Understanding the Error: NumPy Arrays vs. Python Lists​

The root of this error lies in the fundamental design differences between these two data structures:

  • Python list: A dynamic, mutable collection. It has an .append() method that efficiently adds an element to the end of the list in-place (modifying the original list).
  • NumPy ndarray: A fixed-size, homogeneous array stored in a contiguous block of memory. This structure is optimized for fast numerical operations. Because its size is fixed upon creation, it does not have an in-place .append() method.

The AttributeError is Python's way of telling you that the method you called (.append()) simply does not exist for ndarray objects.

Reproducing the AttributeError​

The error is triggered when you treat a NumPy array like a Python list.

Example of the code causing the error:

import numpy as np

arr = np.array([1, 2, 3])

try:
    # Incorrect: Attempting to use a list-style .append() method on a NumPy array
    arr.append(4)
except AttributeError as e:
    print(f"Error: {e}")

Output:

Error: 'numpy.ndarray' object has no attribute 'append'

Solution: Using the numpy.append() Function​

To add elements to a NumPy array, you must use the top-level numpy.append() function. This function takes the array and the new element(s) as arguments and returns a new array.

Solution:

import numpy as np

arr = np.array([1, 2, 3])

# âś… Correct: Use the numpy.append() function
new_arr = np.append(arr, 4)

print(f"Original array: {arr}")
print(f"New array with appended element: {new_arr}")

# You can also append multiple elements at once
new_arr_multiple = np.append(arr, [4, 5, 6])
print(f"New array with multiple appended elements: {new_arr_multiple}")

Output:

Original array: [1 2 3]
New array with appended element: [1 2 3 4]
New array with multiple appended elements: [1 2 3 4 5 6]

Important: numpy.append() Creates a New Array​

warning

The numpy.append() function does not modify the original array in-place. It allocates a new block of memory, copies the old data and the new data into it, and returns a completely new array. You must assign the result to a variable.

Verifying a New Array is Created:

import numpy as np

arr = np.array([1, 2, 3])
print(f"Original array ID: {id(arr)}")

# The result must be assigned to a new variable (or back to the original)
arr = np.append(arr, 4)
print(f"New array ID after append: {id(arr)}")
print(f"Final array content: {arr}")

Output:

Original array ID: 140229381711696
New array ID after append: 140229381711920
Final array content: [1 2 3 4]

As you can see from the different memory IDs, arr now points to a brand new object.

Performance Consideration: Avoid numpy.append() in Loops​

Because numpy.append() creates a new copy of the array with every call, using it repeatedly inside a loop is extremely inefficient and is a common anti-pattern.

Example of the inefficient way:

import numpy as np
import time

start_time = time.time()
inefficient_arr = np.array([])
for i in range(10000):
    # This creates 10,000 intermediate arrays. Very slow!
    inefficient_arr = np.append(inefficient_arr, i)
print(f"Inefficient method took: {time.time() - start_time:.4f} seconds")

Output:

Inefficient method took: 0.1325 seconds

The Efficient Way: Pre-allocation: The correct, high-performance approach is to pre-allocate an array of the final desired size (e.g., with np.zeros()) and then fill it using indexing.

import numpy as np
import time

start_time = time.time()
size = 10000
# Pre-allocate an array of the final size
efficient_arr = np.zeros(size, dtype=int)
for i in range(size):
    # Fill the array using indexing. This is very fast.
    efficient_arr[i] = i
print(f"Efficient method took: {time.time() - start_time:.4f} seconds")

Output:

Efficient method took: 0.0015 seconds
note

The pre-allocation method is orders of magnitude faster because it only allocates memory once.

Conclusion​

If you want to...The correct method is...Why?
Add an element to a NumPy arrayUse the numpy.append() functionndarray objects are fixed-size and have no .append() method.
Preserve the resultAssign the return value: arr = np.append(...)numpy.append() returns a new array; it does not modify the original.
Repeatedly add elements in a loopPre-allocate the array and fill it by indexnumpy.append() is very inefficient in loops due to repeated memory reallocation.

By understanding that NumPy arrays are fixed-size and using the appropriate numpy.append() function—while avoiding it in loops—you can write correct and performant NumPy code.

Table of Contents