Importing files from different folder

Posted on

Problem :

I have the following folder structure:

├── app
│   └── folder
│       └──
└── app2
    └── some_folder

From inside in, how do I import a function from

I tried:

from import func_name

Solution :

Nothing wrong with:

from import func_name

Just make sure folder also contains an, this allows it to be included as a package. Not sure why the other answers talk about PYTHONPATH.

First import sys in

 import sys

Second append the folder path in

sys.path.insert(0, '/the/folder/path/name-package/')

Third Make a blank file called __ init in your subdirectory (this tells Python it is a package)

  • name-package
    • __ init

Fourth import the module inside the folder in

from name-package import name-module

I think an ad-hoc way would be to use the environment variable PYTHONPATH as described in the documentation: Python2, Python3

# Linux & OSX

# Windows
set PYTHONPATH=C:pathtodirWithScripts;%PYTHONPATH%

Your problem is that Python is looking in the Python directory for this file and not finding it. You must specify that you are talking about the directory that you are in and not the Python one.

To do this you change this:

from import func_name

to this:

from import func_name

By adding the dot you are saying look in this folder for the application folder instead of looking in the Python directory.

The answers here are lacking in clarity, this is tested on Python 3.6

With this folder structure:
---- myfolder/

Where has the content:

def myfunc():

The import statement in is:

from myfolder.myfile import myfunc

and this will print hello.

Try Python’s relative imports:

from import func_name

Every leading dot is another higher level in the hierarchy beginning with the current directory.

Problems? If this isn’t working for you then you probably are getting bit by the many gotcha’s relative imports has.
Read answers and comments for more details:
How to fix “Attempted relative import in non-package” even with

Hint: have at every directory level. You might need python -m application.app2.some_folder.some_file (leaving off .py) which you run from the top level directory or have that top level directory in your PYTHONPATH. Phew!

In Python 3.4 and later, you can import from a source file directly (link to documentation). This is not the simplest solution, but I’m including this answer for completeness.

Here is an example. First, the file to be imported, named

def announce():

The code that imports the file above, inspired heavily by the example in the documentation:

import importlib.util

def module_from_file(module_name, file_path):
    spec = importlib.util.spec_from_file_location(module_name, file_path)
    module = importlib.util.module_from_spec(spec)
    return module

foo = module_from_file("foo", "/path/to/")

if __name__ == "__main__":

The output:

<module 'foo' from '/path/to/'>
['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'announce']

Note that the variable name, the module name, and the filename need not match. This code still works:

import importlib.util

def module_from_file(module_name, file_path):
    spec = importlib.util.spec_from_file_location(module_name, file_path)
    module = importlib.util.module_from_spec(spec)
    return module

baz = module_from_file("bar", "/path/to/")

if __name__ == "__main__":

The output:

<module 'bar' from '/path/to/'>
['__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'announce']

Programmatically importing modules was introduced in Python 3.1 and gives you more control over how modules are imported. Refer to the documentation for more information.

Using sys.path.append with an absolute path is not ideal when moving the application to other environments. Using a relative path won’t always work because the current working directory depends on how the script was invoked.

Since the application folder structure is fixed, we can use os.path to get the full path of the module we wish to import. For example, if this is the structure:


And let’s say that you want to import the mango module. You could do the following in

import sys, os.path
mango_dir = (os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
+ '/another_folder/')
import mango

Of course, you don’t need the mango_dir variable.

To understand how this works look at this interactive session example:

>>> import os
>>> mydir = '/home/me/application/app2/some_folder'
>>> newdir = os.path.abspath(os.path.join(mydir, '..'))
>>> newdir
>>> newdir = os.path.abspath(os.path.join(mydir, '..')) + '/another_folder'
>>> newdir

And check the os.path documentation.

Also worth noting that dealing with multiple folders is made easier when using packages, as one can use dotted module names.

I was faced with the same challenge, especially when importing multiple files, this is how I managed to overcome it.

import os, sys

from os.path import dirname, join, abspath
sys.path.insert(0, abspath(join(dirname(__file__), '..')))

from root_folder import file_name

Worked for me in python3 on linux

import sys  
from scriptName import functionName #scriptName without .py extension  

Considering application as the root directory for your python project, create an empty file in application, app and folder folders. Then in your make changes as follows to get the definition of func_name:

import sys
sys.path.insert(0, r'/from/root/directory/application')

from import func_name ## You can also use '*' wildcard to import all the functions in file.

The best practice for creating a package can be running and accessing the other modules from a module like at highest level directory.

This structure demonstrates you can use and access sub package, parent package, or same level packages and modules by using a top level directory file

Create and run these files and folders for testing:

    |----- (Empty file)
    |------- (Contains: import subpackage_1.module_1)        
    |------- (Contains: print('module_0 at parent directory, is imported'))
    |------- subpackage_1/
    |           |
    |           |----- (Empty file)
    |           |----- (Contains: print('importing other modules from module_1...')
    |           |                             import module_0
    |           |                             import subpackage_2.module_2
    |           |                             import subpackage_1.sub_subpackage_3.module_3)
    |           |----- photo.png
    |           |
    |           |
    |           |----- sub_subpackage_3/
    |                        |
    |                        |----- (Empty file)
    |                        |----- (Contains: print('module_3 at sub directory, is imported')) 
    |------- subpackage_2/
    |           |
    |           |----- (Empty file)
    |           |----- (Contains: print('module_2 at same level directory, is imported'))

Now run

the output is

>>>'importing other modules from module_1...'
   'module_0 at parent directory, is imported'
   'module_2 at same level directory, is imported'
   'module_3 at sub directory, is imported'

Opening pictures and files note:

In a package structure if you want to access a photo, use absolute directory from highest level directory.

let’s Suppose you are running and you want to open photo.png inside

what must contain is:


image_path = 'subpackage_1/photo.png'


image_path = 'photo.png'

although and photo.png are at same directory.

│   ├───dir_a
│   │   ├───
│   │   └───
│   ├───dir_b
│   │   ├───
│   │   └───
│   ├───dir_c
│   └───dir_n

You can add the parent directory to PYTHONPATH, in order to achieve that, you can use OS depending path in the “module search path” which is listed in sys.path. So you can easily add the parent directory like following:


import sys
sys.path.insert(0, '..')

from dir_a.file_a import func_name

This works for me on windows

# on mainApp/app2 
import sys
sys.path.insert(0, sys.path[0]+'\app2')

import some_file

In my case I had a class to import. My file looked like this:

# /opt/path/to/code/
class LogHelper:
    # stuff here

In my main file I included the code via:

import sys
from log_helper import LogHelper

I’m quite special : I use Python with Windows !

I just complete information : for both Windows and Linux, both relative and absolute path work into sys.path (I need relative paths because I use my scripts on the several PCs and under different main directories).

And when using Windows both and / can be used as separator for file names and of course you must double into Python strings,
some valid examples :


(note : I think that / is more convenient than , event if it is less ‘Windows-native’ because it is Linux-compatible and simpler to write and copy to Windows explorer)

I bumped into the same question several times, so I would like to share my solution.

Python Version: 3.X

The following solution is for someone who develops your application in Python version 3.X because Python 2 is not supported since Jan/1/2020.

Project Structure

In python 3, you don’t need in your project subdirectory due to the Implicit Namespace Packages. See Is not required for packages in Python 3.3+

├── .gitignore
├── a
|   └──
└── b

Problem Statement

In, I would like to import a class A in under the folder a.


#1 A quick but dirty way

Without installing the package like you are currently developing a new project

Using the try catch to check if the errors. Code example:

import sys
    # The insertion index should be 1 because index 0 is this file
    sys.path.insert(1, '/absolute/path/to/folder/a')  # the type of path is string
    # because the system path already have the absolute path to folder a
    # so it can recognize while searching 
    from file_a import A
except (ModuleNotFoundError, ImportError) as e:
    print("{} fileure".format(type(e)))
    print("Import succeeded")

#2 Install your package

Once you installed your application (in this post, the tutorial of installation is not included)

You can simply

    from __future__ import absolute_import
    # now it can reach class A of in folder a 
    # by relative import
    from ..a.file_a import A  
except (ModuleNotFoundError, ImportError) as e:
    print("{} fileure".format(type(e)))
    print("Import succeeded")

Happy coding!

If the purpose of loading a module from a specific path is to assist you during the development of a custom module, you can create a symbolic link in the same folder of the test script that points to the root of the custom module. This module reference will take precedence over any other modules installed of the same name for any script run in that folder.

I tested this on Linux but it should work in any modern OS that supports symbolic links.

One advantage to this approach is that you can you can point to a module that’s sitting in your own local SVC branch working copy which can greatly simplify the development cycle time and reduce failure modes of managing different versions of the module.

I was working on project a that I wanted users to install via pip install a with the following file list:

└── a
    └── b

from setuptools import setup

setup (
    'a': ['b/*'],

recursive-include b *.*


from __future__ import absolute_import

from a.a import cats
import a.b


cats = 0


from __future__ import absolute_import

from a.b.b import dogs


dogs = 1

I installed the module by running the following from the directory with

python install

Then, from a totally different location on my filesystem /moustache/armwrestle I was able to run:

import a

Which confirmed that a.cats indeed equalled 0 and a.b.dogs indeed equalled 1, as intended.

Instead of just doing an import ..., do this :

from <MySubFolder> import <MyFile>

MyFile is inside the MySubFolder.

In case anyone still looking for a solution. This worked for me.

Python adds the folder containing the script you launch to the PYTHONPATH, so if you run

python application/app2/some_folder/

Only the folder application/app2/some_folder is added to the path (not the base dir that you’re executing the command in). Instead, run your file as a module and add a in your some_folder directory.

python -m application.app2.some_folder.some_file

This will add the base dir to the python path, and then classes will be accessible via a non-relative import.

Wow, I did not expect to spend so much time on this. The following worked for me:

OS: Windows 10

Python: v3.10.0

Note: Since I am Python v3.10.0, I am not using files, which did not work for me anyway.

├── app
│   └── folder
│       └──
└── app2
    └── some_folder

WY Hsu’s 1st solution worked for me. I have reposted it with an absolute file reference for clarity:

import sys
sys.path.insert(1, 'C:\Users\<Your Username>\application')
import app2.some_folder.some_file


Alternative Solution: However, this also worked for me:

import sys
sys.path.append( '.' )
import app2.some_folder.some_file


Although, I do not understand why it works. I thought the dot is a reference to the current directory. However, when printing out the paths to the current folder, the current directory is already listed at the top:

for path in sys.path:

Hopefully, someone can provide clarity as to why this works in the comments. Nevertheless, I also hope it helps someone.

The code below imports the Python script given by it’s path, no matter where it is located, in a Python version-safe way:

def import_module_by_path(path):
    name = os.path.splitext(os.path.basename(path))[0]
    if sys.version_info[0] == 2:   
        # Python 2
        import imp
        return imp.load_source(name, path)
    elif sys.version_info[:2] <= (3, 4):  
        # Python 3, version <= 3.4
        from importlib.machinery import SourceFileLoader
        return SourceFileLoader(name, path).load_module()
        # Python 3, after 3.4
        import importlib.util
        spec = importlib.util.spec_from_file_location(name, path)
        mod = importlib.util.module_from_spec(spec)
        return mod

I found this in the codebase of psutils, at line 1042 in (most recent commit as of 09.10.2020).

Usage example:

script = "/home/username/Documents/"
some_module = import_module_by_path(script)

Important caveat: The module will be treated as top-level; any relative imports from parent packages in it will fail.

This problem may be due Pycharm

I had the same problem while using Pycharm. I had this project structure




and code from configuration import settings in raised import error

the problem was that when I opened Pycharm, it considered that skylake is root path and ran this code

sys.path.extend(['D:\projects\skylake', 'D:/projects/skylake'])

To fix this I just marked backend directory as source root
enter image description here

And it’s fixed my problem

You can use importlib to import modules where you want to import a module from a folder using a string like so:

import importlib

scriptName = 'Snake'

script = importlib.import_module('Scripts\.%s' % scriptName)

This example has a which is the above code then a folder called Scripts and then you can call whatever you need from this folder by changing the scriptName variable. You can then use script to reference to this module. such as if I have a function called Hello() in the Snake module you can run this function by doing so:


I have tested this in Python 3.6

I usually create a symlink to the module I want to import. The symlink makes sure Python interpreter can locate the module inside the current directory (the script you are importing the other module into); later on when your work is over, you can remove the symlink. Also, you should ignore symlinks in .gitignore, so that, you wouldn’t accidentally commit symlinked modules to your repo. This approach lets you even successfully work with modules that are located parallel to the script you are executing.

ln -s ~/path/to/original/module/my_module ~/symlink/inside/the/destination/directory/my_module

Leave a Reply

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