A man does programming on a laptop

Import a Class from Another File in Python: Simple Ways

In complex programming scenarios, breaking down the program into separate modules or components, stored across various files, is a common practice. This approach reduces complexity and aids in easier debugging and code error identification. For instance, if you need to utilize a class from a different file, you’ll need to import that class into your current working file.

Importing a Specific Class Using the Import Command

To import a specific class, say ‘Square’, from a file named ‘MyFile.py’, you simply use the import statement in your main file: from MyFile import Square. This allows you to instantiate and use the ‘Square’ class in your main file.

# MyFile.py class Square: def __init__(self, val): self.val = val def getVal(self): return self.val * self.val
# main.py from MyFile import Square
squareInstance = Square(5) print(squareInstance.getVal())

Importing Multiple Classes from a Single File

When you have several classes, like ‘Square’ and ‘Add_Sub’ in ‘MyFile.py’, you can import all these classes into your main file. Using import MyFile, you can create objects of these classes in ‘main.py’, such as MyFile.Square(5) and MyFile.Add_Sub().

# MyFile.py class Square: # …
class Add_Sub: def add(self, a, b): return a + b def sub(self, a, b): return a – b
# main.py import MyFile
square = MyFile.Square(5) adder = MyFile.Add_Sub() print(“Square value:”, square.getVal()) print(“Addition:”, adder.add(2, 3)) print(“Subtraction:”, adder.sub(5, 2))

Importing All Classes from a Single File

To import all classes from a file, you can use the asterisk symbol (*) with the import command: from MyFile import *. This imports all classes from ‘MyFile.py’, allowing you to instantiate any class without specifying the filename.

# MyFile.py class Square: # …
class Add_Sub: def add(self, a, b): return a + b def sub(self, a, b): return a – b
# main.py import MyFile
square = MyFile.Square(5) adder = MyFile.Add_Sub() print(“Square value:”, square.getVal()) print(“Addition:”, adder.add(2, 3)) print(“Subtraction:”, adder.sub(5, 2))

To import all classes from ‘MyFile.py’:

# main.py from MyFile import *
square = Square(5) adder = Add_Sub() print(“Square value:”, square.getVal()) print(“Addition:”, adder.add(2, 3))

Importing Classes from a Different Folder in the Parent Directory

To import classes from a file in a different folder, such as ‘Inner_Project’, within a parent directory, use the ‘import sys’ command. Add the parent directory to the system path: sys.path.insert(0,”..”), followed by from Inner_Project.MyFile import Square.

# main.py import sys sys.path.insert(0, “..”) from Inner_Project.MyFile import Square
square = Square(5) print(“Square value:”, square.getVal())

Dynamically Importing a Class

Dynamic importing involves importing a class at runtime. This is done using the __import__ function and getattr to retrieve the class from a module. For instance, to dynamically import ‘MyClass’ from ‘module.py’, you would use module = __import__(“module”) and my_class = getattr(module, “MyClass”).

# module.py class MyClass: def greet(self, name): print(f”Hello, {name}!”)
# DynamicImport.py import sys
module_name = “module” class_name = “MyClass”
module = __import__(module_name) my_class = getattr(module, class_name) instance = my_class() instance.greet(“Alice”)

Unique Considerations in Class Importing

  • Namespace Clarity: Importing specific classes helps maintain a clear namespace;
  • Memory Efficiency: Importing only needed classes can be more memory-efficient;
  • Dependency Tracking: Specific imports make tracking dependencies easier;
  • Dynamic Flexibility: Dynamic importing allows for more flexible and adaptable code.

Comparative Table of Import Techniques

Import TechniqueUse CaseProsCons
Specific ClassSingle class usageClear namespace, memory efficientRequires multiple import statements for multiple classes
Multiple ClassesMultiple class usage in a fileOne import statement for all needed classesLess clarity in namespace
All ClassesWhen all classes in a file are neededSimplifies code with one import statementCan lead to memory inefficiency, cluttered namespace
Different FolderClasses in external directoriesAllows for organized project structureRequires modification of system path
DynamicRuntime determination of classesHighly flexible and adaptableMore complex, potential security risks

Best Practices for Importing Classes in Python

In addition to understanding various import techniques, adhering to best practices while importing classes in Python can significantly enhance code quality and maintainability. This section explores key practices every Python developer should consider.

  1. Use Absolute Imports Over Relative Imports: Absolute imports, which use the full path from the project’s root folder, are clearer and less prone to errors than relative imports. They make your code more readable and maintainable;
  2. Avoid Wildcard Imports: Although importing all classes from a file using from module import * seems convenient, it can lead to an unclear namespace and potential conflicts. Explicitly importing only the necessary classes or functions is a cleaner approach;
  3. Minimize Importing Inside Functions: Importing within functions can be useful for avoiding circular dependencies or reducing startup time. However, this practice should be used sparingly as it can lead to hidden dependencies and harder-to-read code;
  4. Organize Imports: Grouping and ordering imports systematically (standard library imports, third-party imports, and then local application imports) enhances readability and helps in understanding the dependencies of the module;
  5. Check for Module Availability: When dynamically importing modules or classes that might not be available in all environments, use a try-except block to handle ImportError. This is particularly relevant for optional dependencies;
  6. Use Aliases for Clarity: When importing modules with long or conflicting names, aliases can be used to maintain clarity and prevent namespace issues. For instance, import long_module_name as lmn makes the code cleaner;
  7. Regularly Refactor Imports: Periodically reviewing and refactoring imports can prevent ‘import bloat’, where unused or unnecessary imports accumulate over time. This keeps the code base clean and efficient.

By integrating these best practices into your Python coding workflow, you can create more robust, efficient, and maintainable code. These guidelines help in harnessing the full potential of Python’s modular design, facilitating easier code management and scalability.


This article detailed various methods of importing classes in Python. Importing classes from other files enhances the readability and usability of your code. We explored different techniques, including importing specific, multiple, or all classes, as well as dynamic importing.

Bruno Jennings

Leave a Reply

Your email address will not be published. Required fields are marked *

Related Posts