Skip to main content

Python NumPy: How to Fix "AttributeError: module 'numpy' has no attribute 'X'" (e.g., array, int, float)

When working with NumPy, encountering an AttributeError: module 'numpy' has no attribute 'X' can be puzzling. This error indicates that you're trying to access an attribute or function X (like array, int, float, bool) directly from the imported NumPy module (e.g., np.X), but NumPy doesn't recognize that name. This typically happens for two main reasons: either a local file in your project is named numpy.py, "shadowing" the actual installed library, or you're attempting to use deprecated NumPy aliases for built-in Python types (like np.int instead of Python's int).

This guide will comprehensively explain both of these common causes, demonstrate how they lead to the AttributeError, and provide clear solutions, including renaming conflicting local files and using the correct, non-deprecated Python built-in types or NumPy's specific dtype objects.

Understanding the AttributeError with NumPy​

The AttributeError: module 'numpy' has no attribute 'X' means that when you try to use np.X (assuming you've imported NumPy as np), Python looks within the np object (which should be the NumPy module) for an attribute or sub-module named X. If it can't find X, it raises this error.

Cause 1: Local File Named numpy.py (Shadowing)​

This is a very common pitfall, especially for beginners. If you create a Python script in your project directory and name it numpy.py, Python's import mechanism might load your local file instead of the installed NumPy library when you write import numpy as np.

Reproducing the Error (e.g., for np.array)​

Imagine you have a file named numpy.py in your current working directory with the following content:

numpy.py
# This file is named numpy.py (Problematic!)
import numpy as np # This line tries to import this file itself!

try:
    # ⛔️ AttributeError: module 'numpy' has no attribute 'array'
    # (or 'partially initialized module' error if import recursion is detected)
    my_arr = np.array([10, 20, 30])
    print(my_arr)
except AttributeError as e:
    print(f"Error trying to use np.array: {e}")

When this numpy.py script runs, its import numpy as np statement refers to itself, not the installed library. Your local numpy.py file almost certainly doesn't define a function or class named array.

Solution: Rename Your Local numpy.py File​

The most straightforward solution is to rename your local script file to something else, for example, my_numpy_script.py, main.py, data_processing.py, etc. Avoid using names of standard libraries or installed packages for your own script files.

Corrected code (in a file named, e.g., main.py):

# This file is NOT named numpy.py
import numpy as np # Correctly imports the installed NumPy library

my_arr = np.array([10, 20, 30])
print(f"NumPy array created successfully: {my_arr}")

Output:

NumPy array created successfully: [10 20 30]

Diagnosing Shadowing: Checking np.__file__ and dir(np)​

  • np.__file__: After import numpy as np, print np.__file__.
    • If it points to your project directory (e.g., /path/to/your/project/numpy.py), your local file is shadowing the library.
    • If it points to the site-packages directory of your Python environment (e.g., .../lib/python3.x/site-packages/numpy/__init__.py), the correct library is loaded.
  • dir(np): Print dir(np).
    • If your local file is loaded, dir(np) will show very few attributes (mostly default module attributes and anything you defined in your local file). It will not list array, int, float, etc.
    • If the correct library is loaded, dir(np) will show a long list of NumPy's attributes.

If your numpy.py file contains import numpy as np and then tries to use np.array(), you might also see AttributeError: partially initialized module 'numpy' has no attribute 'array' (most likely due to a circular import). This is because the file is trying to import itself before it's fully loaded. Renaming the file also solves this.

Cause 2: Using Deprecated NumPy Aliases for Built-in Types (e.g., np.int, np.float)​

For a long time, NumPy provided aliases like np.int, np.float, np.bool, np.object, np.str that were largely equivalent to Python's built-in types (int, float, bool, object, str).

  • These aliases started being deprecated in NumPy 1.20.
  • They were completely removed in NumPy 1.24.

If you are using NumPy 1.24 or newer, attempting to use np.int, np.float, etc., will result in an AttributeError.

Reproducing the Error (e.g., for np.int)​

import numpy as np

print(f"NumPy version: {np.__version__}") # Check your NumPy version

try:
    # ⛔️ AttributeError: module 'numpy' has no attribute 'int'.
    # This will error if NumPy version >= 1.24
    my_integer = np.int(3.14159)
    print(my_integer)
except AttributeError as e:
    print(f"Error using np.int: {e}")

Output:

NumPy version: 2.0.2
Error using np.int: module 'numpy' has no attribute 'int'.
`np.int` was a deprecated alias for the builtin `int`. To avoid this error in existing code, use `int` by itself. Doing this will not modify any behavior and is safe. When replacing `np.int`, you may wish to use e.g. `np.int64` or `np.int32` to specify the precision. If you wish to review your current use, check the release note link for additional information.
The aliases was originally deprecated in NumPy 1.20; for more details and guidance see the original release note at:
    https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations

Explanation: Deprecation and Removal of Aliases​

The NumPy developers deprecated these aliases to reduce confusion with Python's built-in types and to encourage the use of more specific NumPy dtypes when needed (like np.int64, np.float32).

Solution: Use Native Python Types (int, float, bool, str, object)​

For simple type casting or checking, use Python's built-in types directly.

# ✅ Correct: Use Python's built-in int()
integer_from_float = int(3.14159)
print(f"int(3.14159): {integer_from_float}")    # Output: 3

string_to_int = int("123")
print(f"int('123'): {string_to_int}")           # Output: 123

# ✅ Correct: Use Python's built-in float()
float_from_string = float("3.14")
print(f"float('3.14'): {float_from_string}")    # Output: 3.14

# ✅ Correct: Use Python's built-in str()
string_from_int = str(456)
print(f"str(456): '{string_from_int}'")         # Output: '456'

Output:

int(3.14159): 3
int('123'): 123
float('3.14'): 3.14
str(456): '456'

Solution: Use NumPy's Specific Scalar Type Names (e.g., np.int64, np.float64, np.bool_)​

If you need to work with NumPy's specific data types (dtypes), use their actual names. These are not the deprecated aliases.

  • For boolean: np.bool_
  • For integers: np.int8, np.int16, np.int32, np.int64 (or np.int_ which often defaults to np.int64 or np.int32)
  • For floats: np.float16, np.float32, np.float64 (or np.float_, np.double)
  • For complex: np.complex64, np.complex128 (or np.complex_, np.cdouble)
  • For objects: np.object_
  • For strings: np.str_, np.unicode_
import numpy as np

# Using specific NumPy dtypes for casting or checking
value = np.float64(3.14) # Creates a NumPy float64 scalar
print(f"\nValue as np.float64: {value}, type: {type(value)}")

another_value = np.int32(100) # Creates a NumPy int32 scalar
print(f"Value as np.int32: {another_value}, type: {type(another_value)}")

# When creating arrays or using astype:
arr_float32 = np.array([1, 2, 3], dtype=np.float32)
print(f"Array with dtype=np.float32: {arr_float32}, dtype: {arr_float32.dtype}")

Output:

Value as np.float64: 3.14, type: <class 'numpy.float64'>
Value as np.int32: 100, type: <class 'numpy.int32'>
Array with dtype=np.float32: [1. 2. 3.], dtype: float32

As a last resort, if you have legacy code that heavily relies on the old aliases and can not be immediately updated, you could downgrade NumPy to a version prior to 1.24 (e.g., 1.23.x).

pip install "numpy<1.24.0"

However, this is not a sustainable long-term solution, as you'll miss out on new features, bug fixes, and security updates. Adapting your code to use native Python types or specific NumPy dtypes is the best practice.

Ensuring Correct Import Statements​

The standard convention is import numpy as np.

  • If you use import numpy, you must access functions like numpy.array(...).
  • If you use from numpy import array, you can use array(...) directly, but you won't have np.array (unless you also did import numpy as np). Using import numpy as np is generally preferred for clarity, as it makes it obvious that you're using a NumPy function.

Conclusion​

The AttributeError: module 'numpy' has no attribute 'X' typically signals one of two primary issues:

  1. Filename Shadowing: Your Python script is named numpy.py, causing it to import itself instead of the installed NumPy library. Solution: Rename your script file.
  2. Deprecated Aliases: You are using old NumPy aliases like np.int or np.float with a NumPy version (1.24+) where these have been removed. Solution: Use Python's built-in types (int, float, etc.) for general type conversion, or NumPy's specific dtype objects (np.int64, np.float32, np.bool_, etc.) when you need to specify NumPy data types.

By checking for local numpy.py files and updating your code to use current type conventions, you can resolve these AttributeErrors and ensure your NumPy code functions correctly.

Table of Contents