Python Class Undefined Issue After Import

In this article, we’ll explain a common problem in Python: the “Class is not defined” error occurs even after importing the class.

Read more: Python Tutorial

Background

In Python, we can use the import statement to import classes defined in other modules or files. However, sometimes, even after successfully importing a class, we still encounter the “Class is not defined” error when trying to use it. This often causes programs to not function properly and can be frustrating for developers.

Problem Analysis

This error typically occurs due to the following reasons:

1. Namespace Conflict

If the imported class has the same name as another class or variable in the current namespace, a “Class undefined” error may occur.

For example, if we import a class named “User” into a Python script, but a variable named “User” already exists in the script, due to the namespace conflict, when we try to use the imported class, Python cannot distinguish which “User” instance is being used, resulting in a “Class undefined” error.

class User:
pass

User = 123 # Conflict with imported class name

from other_module import User

# Use the imported User class
u = User() # Class not defined error

2. Import Path Error

When importing a class, Python searches for the specified module or file according to a specific search path. If the import path is incorrect or the file does not exist, a Class not defined error will occur.

For example, if we want to import a class named “Customer” from a module named “custom_module,” but misspelling the module name or setting the import path incorrectly will result in a Class not defined error.

# Import path error
from wrong_module import Customer

# Spelling error
from custom_module import Cutsomter

# Using the imported Customer class
c = Customer() # Class undefined error

3. Circular File Imports

Circular imports within imported modules or files can also cause Class undefined errors.

A circular import occurs when two or more modules import each other, forming a closed loop. Due to the Python interpreter’s execution order, when one module is imported, the class of another module may not yet be defined, resulting in a Class undefined error.

For example, let’s say we have two modules, “module1.py” and “module2.py,” which import each other:

# module1.py
from module2 import ClassB

class ClassA:
def __init__(self):
self.b = ClassB()

# module2.py
from module1 import ClassA

class ClassB:
def __init__(self):
self.a = ClassA()

In this case, when we import one of the modules and try to use a class within it, we get an error saying “Class is not defined.”

Solution

To address this issue, we can take the following solutions:

1. Modify the variable or module name

A simple way to avoid namespace conflicts is to modify the conflicting variable or module name so that it does not conflict with the name of the imported class.

# Change variable name
class User:
pass

my_user = 123

from other_module import User

u = User() # Use the imported User class

# Change module name
import custom_module

c = custom_module.Customer()

2. Check the import path

Ensure that the path to the imported module or file is set correctly and that the file exists. You can use either an absolute or relative path for imports.

# Absolute import
import sys
sys.path.append("/path/to/module")

import custom_module

# Relative import
from . import custom_module

# Or directly import using a relative path
from .custom_module import Customer

3. Refactoring the Code

If circular imports occur, you typically need to refactor your code to avoid them. Consider moving some code to other modules or using techniques like lazy imports.

# module1.py
class ClassA:
def __init__(self):
from module2 import ClassB
self.b = ClassB()

# module2.py
class ClassB:
def __init__(self):
from module1 import ClassA
self.a = ClassA()

Summary

In Python, when you encounter the “Class is not defined” error after importing a class, it may be due to namespace conflicts, incorrect import paths, or circular file imports. These issues can be resolved by modifying variable or module names, checking import paths, or refactoring the code. Fixing import errors promptly ensures proper code operation and avoids potential bugs and errors.