Python Import File

This short guide provides different ways to import another Python file into your main project. Use the examples to help you understand how it all works.

Why Import Another File in Your Python Program?

When working on big Python projects or trying to organize your code better, you need to know how to bring in code from other Python files. This is called “importing,” and it’s a crucial skill for reusing code and keeping things neat.

9 Ways to Import a File in Python

When you decide or already have multiple Python files in your project, it is important to know how to import another Python file into the main project. In Python, it can be done in many ways. Go through these methods and choose the best suited to your needs.

Basic Import: Load the Whole Module

Let’s start with the basics. When you import a Python file, you’re bringing in a whole module. Say you have a file named mod.py with a simple function:

# mod.py
def hello(name):
    print(f"Hello, {name}!")

Now, in another file, like main.py, you can import and use that function:

# main.py
import mod

mod.hello("John")

Here, we’re importing another Python file (mod.py) and using the hello function from it.

Import Python File with an Alias

Sometimes, module names can be long or might clash with other names in your code. To fix this, you can give the module a shorter name, known as an alias:

# main.py
import mod as m

m.hello("Alice")

This way, we can call other files using an alias (m) to make our code cleaner.

Import Specific Functions You Need

If you only want a specific part of a Python file, you can import just that. Let’s say you have a file called math.py:

# math.py
def add(x, y):
    return x + y

def subtract(x, y):
    return x - y

In your main.py, you can import just the functions you need:

# main.py
from math import add

result = add(5, 3)

Now, we’ll include the above file but only the add function this time.

Multiple Function Import

You can import multiple functions at once, like so:

# main.py
from math import add, subtract

result_add = add(5, 3)
result_subtract = subtract(8, 2)

Here, we’re importing another Python file (math.py) and using both the add and subtract functions.

Import Using (*) Wild Card

You can technically import everything from a file, but it’s generally not a good idea:

# main.py
from math import *

result_add = add(5, 3)

While this does the job, it’s not recommended because it can make your code messy and lead to problems.

Use Relative Imports

When your Python files are in the same project, you can use relative imports. Consider a project structure like this:

project/
|-- main.py
|-- utils/
|   |-- helpers.py

In your main.py, you can use a relative import:

# main.py
from utils import helpers

helpers.hello("Charlie")

This helps import another Python file within your project without making the code confusing.

You can also go up a level in your project structure:

# utils/helpers.py
from ..other_mod import some_func

This is useful when your files are organized hierarchically.

Import a Single Class

If your file has classes, you can import and use them:

# shapes.py
# N-Gon: A shape with n number of edges is called an "n-gon."
# For example, a triangle is a 3-gon, and a pentagon is a 5-gon.
class NGon:
    def __init__(self, sides, side_len, apothem_len):
        self.n = sides
        self.s = side_len
        self.a = apothem_len

    def area(self):
        return 0.5 * n * s * a

Now, let’s include the above Python file (shapes.py) into a new file:

# main.py
from shapes import NGon

my_ngon = NGon(5)
print(f"N-Gone Area: {my_ngon.area()}")

This approach is handy when your code revolves around object-oriented programming (OOP) principles.

Import Multiple Classes

You can bring in multiple classes from a file:

# main.py
from shapes import Circle, Square

my_circle = Circle(5)
my_square = Square(4)

Here, we’re importing another Python file (shapes.py) and using both the Circle and Square classes.

Import Modules from Different Dir

If your Python files are scattered in different directories, you can add the path dynamically:

# main.py
import sys
sys.path.append("/path/to/mod_directory")

import mod_in_another_dir

mod_in_another_dir.some_func()

This is handy when dealing with external libraries or modules not included in the Python standard library. However, always consider project structure and maintainability before resorting to this approach.

Using the path lib module can make path handling more robust:

# main.py
from pathlib import Path

mod_directory = Path("/path/to/mod_directory")
sys.path.append(str(mod_directory))

import mod_in_another_dir

mod_in_another_dir.some_func()

This ensures that your code works well across different platforms.

Must Read –
Python File Handling Quiz
Python Functions Quiz Part-1
10 Python Tricky Coding Exercises

Before You Leave

In this guide, we’ve covered different ways of importing code from other Python files. These methods are crucial for making your code modular and easy to manage. Choose the approach that suits your project’s structure and requirements.

As your projects grow, mastering the art of importing becomes key to writing clean, maintainable, and collaborative Python code.

Lastly, our site needs your support to remain free. Share this post on social media (Linkedin/Twitter) if you gained some knowledge from this tutorial.

Enjoy coding,
TechBeamers.