Skip to main content

How to Resolve "AttributeError: module 'X' has no attribute 'Y'" in Python

The AttributeError: module 'X' has no attribute 'Y' is a common Python error indicating that you're trying to access a variable, function, or class (Y) that doesn't exist directly within the specified module (X). This usually happens due to naming conflicts, circular imports, incorrect import statements, or simply trying to access a non-existent attribute.

This guide explains these causes and provides clear solutions.

Understanding the Error: Missing Attribute​

This error simply means that the specific name (Y) you're trying to use after the dot (.) is not defined within the module (X) you've imported or are trying to use.

Cause 1: Naming Conflict (Module Shadowing)​

This is a very frequent cause. If you create a Python file in your project with the same name as a standard library module or a third-party package you're trying to import (e.g., requests.py, datetime.py, email.py), your local file will "shadow" the intended module. Python will import your local file instead of the one you want.

Error Example:

  • You have main.py: 
    import requests # Trying to import the third-party library

    # print(dir(requests)) # Debugging step

    # requests.get(...) # ⛔️ AttributeError: module 'requests' has no attribute 'get'
  • And you also have a file named requests.py in the same directory: 
    # requests.py (your local file)
    def greet():
        print('This is my local requests file')

Python imports your requests.py instead of the installed requests library.

Solution: Rename Your Local File​

The best solution is to rename your local Python file to something unique that doesn't clash with standard library or installed package names. For example, rename requests.py to my_request_utils.py.

Checking for Built-in Name Clashes​

To see the names of modules built into your Python installation (which you should avoid using for your own filenames), you can run:

import sys
print(sys.builtin_module_names)

Cause 2: Circular Imports​

A circular import occurs when two (or more) modules import each other. This can lead to situations where one module tries to access an attribute from the other before it has been fully initialized, resulting in an AttributeError.

Error Example:

  • first_module.py: 
    import second_module # Imports second_module

    def first_function(): print('first function')

    # Tries to use second_function before second_module might be fully loaded
    # second_module.second_function() # ⛔️ AttributeError
  • second_module.py: 
    import first_module # Imports first_module (circular)

    def second_function(): print('second function')

    first_module.first_function()

Solution 1: Import within Function Scope (Use Cautiously)​

Moving the import statement inside the function that needs the other module can break the circular dependency at the module level.

# second_module.py (Modified)
def second_function():
    print('second function')
    import first_module # Import moved inside
    first_module.first_function()

# first_module.py remains the same for this example, but ideally refactor
import second_module
def first_function(): print('first function')
# second_module.second_function() # Call moved elsewhere or removed
warning

While this works, it can hide dependencies and might have performance implications if the import happens frequently. It's often a sign that your code structure could be improved.

The best way to resolve circular imports is usually to refactor your code.

Create a third module that imports both first_module and second_module and orchestrates the interaction between them, or move the shared dependencies to a separate, lower-level module.

  • first_module.py: def first_function(): print('first function')
  • second_module.py: def second_function(): print('second function')
  • main_logic.py: 
    import first_module
    import second_module

    first_module.first_function()
    second_module.second_function()

Cause 3: Incorrect Import Statement or Attribute Access​

Sometimes the error is simply due to a typo in the attribute name or an incorrect way of importing or accessing the desired object.

Example (Error):

  • another_file.py: 
    class Employee:
        def greet(self): return 'Hello'
  • main.py: 
    import another_file

    # print(dir(another_file)) # Debugging step

    # Trying to call greet directly on the module
    # another_file.greet() # ⛔️ AttributeError: module 'another_file' has no attribute 'greet'

Solution: Use dir() to Inspect the Module​

If you're unsure what attributes a module actually provides, use the dir() function:

import another_file
print(dir(another_file))
# Output might include: ['Employee', '__builtins__', '__cached__', ... ]

This shows you the available names within the another_file module.

Accessing Class Attributes/Methods Correctly​

In the example above, greet is a method of the Employee class. You need to create an instance of the class first:

import another_file

emp = another_file.Employee()    # Create an instance
print(emp.greet())               # Call the method on the instance -> Output: Hello

Conclusion​

The AttributeError: module 'X' has no attribute 'Y' is often caused by naming conflicts (shadowing) or circular imports.

  • Always check your filenames and import structure.
  • If the cause isn't immediately obvious, use print(dir(module_name)) to inspect the imported module's actual attributes and verify your import statements and attribute access logic.
  • Refactoring to avoid circular dependencies is usually the best long-term solution.

Table of Contents