ChatGPT解决这个技术问题 Extra ChatGPT

Importing modules from parent folder

I am running Python 2.5.

This is my folder tree:

ptdraft/
  nib.py
  simulations/
    life/
      life.py

(I also have __init__.py in each folder, omitted here for readability)

How do I import the nib module from inside the life module? I am hoping it is possible to do without tinkering with sys.path.

Note: The main module being run is in the ptdraft folder.

Ross: I looked there. What should I do about it? I already have a __init__.py. S.Lott: I don't know how to check...
echo $PYTHONPATH from the shell; import sys; print sys.path from within Python. docs.python.org/tutorial/…
I strongly recommend skipping past all sys.path or PYTHONPATH answers and checking out np8's excellent answer. Yes, it's a long read. Yes, it looks like a lot of work. But it's the only answer that actually solves the problem correctly and cleanly.
Whatever happened to executable pseudocode? Why is it such a pain to import modules from a parent folder in Python? This is absurd.
Why is this such a pain? After reading through all the discussion and answers, there's still no reasonable simple solution.

D
Dennis

You could use relative imports (python >= 2.5):

from ... import nib

(What’s New in Python 2.5) PEP 328: Absolute and Relative Imports

EDIT: added another dot '.' to go up two packages


ValueError: Attempted relative import in non-package
@endolith: You have to be in a package, i.e., you must have an init.py file.
Attempted relative import beyond toplevel package
See also the following answer, since adding __init__.py is not the only thing you have to do: stackoverflow.com/questions/11536764/…
To be even more precise, you need an __init__.py file.
K
KetZoomer

Relative imports (as in from .. import mymodule) only work in a package. To import 'mymodule' that is in the parent directory of your current module:

import os
import sys
import inspect

currentdir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))
parentdir = os.path.dirname(currentdir)
sys.path.insert(0, parentdir) 

import mymodule

edit: the __file__ attribute is not always given. Instead of using os.path.abspath(__file__) I now suggested using the inspect module to retrieve the filename (and path) of the current file


something a little shorter: sys.path.insert(1, os.path.join(sys.path[0], '..'))
Any reason to avoid sys.path.append() instead of the insert?
@Tyler - It can matter if somewhere else then the parentdir, but in one of the paths allready specified in sys.path, there is another module with the name 'mymodule'. Inserting the parentdir as the first element of the sys.path list assures that the module from parentdir will be imported instead.
@JHolta If you're not dealing with packages, yours is the best solution.
@JHolta great idea. sys.path.insert(1, os.path.realpath(os.path.pardir)) works too.
n
np8

I posted a similar answer also to the question regarding imports from sibling packages. You can see it here.

Solution without sys.path hacks

Summary

Wrap the code into one folder (e.g. packaged_stuff)

Create a setup.py script where you use setuptools.setup().

Pip install the package in editable state with pip install -e

Import using from packaged_stuff.modulename import function_name

Setup

I assume the same folder structure as in the question

.
└── ptdraft
    ├── __init__.py
    ├── nib.py
    └── simulations
        ├── __init__.py
        └── life
            ├── __init__.py
            └── life.py

I call the . the root folder, and in my case it is located in C:\tmp\test_imports.

Steps

Add a setup.py to the root folder -- The contents of the setup.py can be simply

    from setuptools import setup, find_packages

    setup(name='myproject', version='1.0', packages=find_packages())

Basically "any" setup.py would work. This is just a minimal working example.

Use a virtual environment

If you are familiar with virtual environments, activate one, and skip to the next step. Usage of virtual environments are not absolutely required, but they will really help you out in the long run (when you have more than 1 project ongoing..). The most basic steps are (run in the root folder)

Create virtual env python -m venv venv

python -m venv venv

Activate virtual env . venv/bin/activate (Linux) or ./venv/Scripts/activate (Win)

. venv/bin/activate (Linux) or ./venv/Scripts/activate (Win)

Deactivate virtual env deactivate (Linux)

deactivate (Linux)

To learn more about this, just Google out "python virtualenv tutorial" or similar. You probably never need any other commands than creating, activating and deactivating.

Once you have made and activated a virtual environment, your console should give the name of the virtual environment in parenthesis

PS C:\tmp\test_imports> python -m venv venv
PS C:\tmp\test_imports> .\venv\Scripts\activate
(venv) PS C:\tmp\test_imports>

pip install your project in editable state

Install your top level package myproject using pip. The trick is to use the -e flag when doing the install. This way it is installed in an editable state, and all the edits made to the .py files will be automatically included in the installed package.

In the root directory, run

pip install -e . (note the dot, it stands for "current directory")

You can also see that it is installed by using pip freeze

(venv) PS C:\tmp\test_imports> pip install -e .
Obtaining file:///C:/tmp/test_imports
Installing collected packages: myproject
  Running setup.py develop for myproject
Successfully installed myproject
(venv) PS C:\tmp\test_imports> pip freeze
myproject==1.0

Import by prepending mainfolder to every import

In this example, the mainfolder would be ptdraft. This has the advantage that you will not run into name collisions with other module names (from python standard library or 3rd party modules).

Example Usage

nib.py

def function_from_nib():
    print('I am the return value from function_from_nib!')

life.py

from ptdraft.nib import function_from_nib

if __name__ == '__main__':
    function_from_nib()

Running life.py

(venv) PS C:\tmp\test_imports> python .\ptdraft\simulations\life\life.py
I am the return value from function_from_nib!

Also, why is this better or more elegant than using the sys.path approach?
@HomeroBarrocasSEsmeraldo Good questions. PYTHONPATH env var is untouched. This installs into site-packages, which is already on sys.path and where the code would typically be installed by end users. That's better than sys.path hacks (and you can include using PYTHONPATH in that category of path hacks) because it means the code in development should behave the same way for you as it does for other users. In contrast, when using path modifications, import statements would be resolved in a different way.
This is by far, THE best solution I've read. This creates a link to your current directory so all updates to the code is directly reflected into your working directory. In the event you need to delete this entry, Manually delete the egg file and remove the entry from easy-install in dist-packages (site-packages if you used pip).
why making the python import headache even more complicated? We have to write a setup file, a virtual env, a pip install? omg!
Is this amount of work to import a module still necessary in 2020 on python 3.8? I cannot believe how complicated this is.
M
MERose

It seems that the problem is not related to the module being in a parent directory or anything like that.

You need to add the directory that contains ptdraft to PYTHONPATH

You said that import nib worked with you, that probably means that you added ptdraft itself (not its parent) to PYTHONPATH.


Having to add everything to pythonpath is not a good solution if you are working with a lot of packages that are never going to be reused.
@JasonCheng: Then why are they packages?
For me this answer has worked out. However, to make it more explicit, the procedure is to import sys and then sys.path.append("..\<parent_folder>")
@JasonCheng you don't have to export the modified PYTHONPATH or your shell profile, you can also choose to set it only for a single call to python (so it is only modified on a per-execution basis) or you can put it in some kind of .env file (per-folder basis).
S
Shinbero

You can use OS depending path in "module search path" which is listed in sys.path . So you can easily add parent directory like following

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

If you want to add parent-parent directory,

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

This works both in python 2 and 3.


This is relative to the current directory, not even necessarily the one containing the main script.
This method is worked in PyCharm, but not in VS Code.
worked great for me! thanks! ... but i needed sibling dir, so my solution was sys.path.insert(0,'../sibling_dir')
@DavisHerring To fix it, use an absolute path.
@Jeyekomon: That merely replaces one of the several forms of fragility in this approach with another.
S
Serg Chernata

Don't know much about python 2. In python 3, the parent folder can be added as follows:

import sys 
sys.path.append('..')

...and then one is able to import modules from it


This only works if your current working directory is such that '..' leads to the directory with the module in question.
J
Joe Reynolds

If adding your module folder to the PYTHONPATH didn't work, You can modify the sys.path list in your program where the Python interpreter searches for the modules to import, the python documentation says:

When a module named spam is imported, the interpreter first searches for a built-in module with that name. If not found, it then searches for a file named spam.py in a list of directories given by the variable sys.path. sys.path is initialized from these locations: the directory containing the input script (or the current directory). PYTHONPATH (a list of directory names, with the same syntax as the shell variable PATH). the installation-dependent default. After initialization, Python programs can modify sys.path. The directory containing the script being run is placed at the beginning of the search path, ahead of the standard library path. This means that scripts in that directory will be loaded instead of modules of the same name in the library directory. This is an error unless the replacement is intended.

Knowing this, you can do the following in your program:

import sys
# Add the ptdraft folder path to the sys.path list
sys.path.append('/path/to/ptdraft/')

# Now you can import your module
from ptdraft import nib
# Or just
import ptdraft

Your answer is good, but may not always work and is not very portable. If the program was moved to a new location, /path/to/ptdraft would have to be edited. There are solutions that work out the current directory of the file and import it from the parent folder that way as well.
@Edward what are those techniques?
@Shuklaswag for example, the answer stackoverflow.com/questions/714063/….
E
Edward

Here is an answer that's simple so you can see how it works, small and cross-platform.
It only uses built-in modules (os, sys and inspect) so should work
on any operating system (OS) because Python is designed for that.

Shorter code for answer - fewer lines and variables

from inspect import getsourcefile
import os.path as path, sys
current_dir = path.dirname(path.abspath(getsourcefile(lambda:0)))
sys.path.insert(0, current_dir[:current_dir.rfind(path.sep)])
import my_module  # Replace "my_module" here with the module name.
sys.path.pop(0)

For less lines than this, replace the second line with import os.path as path, sys, inspect,
add inspect. at the start of getsourcefile (line 3) and remove the first line.
- however this imports all of the module so could need more time, memory and resources.

The code for my answer (longer version)

from inspect import getsourcefile
import os.path
import sys

current_path = os.path.abspath(getsourcefile(lambda:0))
current_dir = os.path.dirname(current_path)
parent_dir = current_dir[:current_dir.rfind(os.path.sep)]

sys.path.insert(0, parent_dir)

import my_module  # Replace "my_module" here with the module name.

It uses an example from a Stack Overflow answer How do I get the path of the current
executed file in Python?
to find the source (filename) of running code with a built-in tool.

from inspect import getsourcefile from os.path import abspath Next, wherever you want to find the source file from you just use: abspath(getsourcefile(lambda:0))

My code adds a file path to sys.path, the python path list
because this allows Python to import modules from that folder.

After importing a module in the code, it's a good idea to run sys.path.pop(0) on a new line
when that added folder has a module with the same name as another module that is imported
later in the program. You need to remove the list item added before the import, not other paths.
If your program doesn't import other modules, it's safe to not delete the file path because
after a program ends (or restarting the Python shell), any edits made to sys.path disappear.

Notes about a filename variable

My answer doesn't use the __file__ variable to get the file path/filename of running
code because users here have often described it as unreliable. You shouldn't use it
for importing modules from parent folder in programs used by other people.

Some examples where it doesn't work (quote from this Stack Overflow question):

• it can't be found on some platforms • it sometimes isn't the full file path

py2exe doesn't have a __file__ attribute, but there is a workaround When you run from IDLE with execute() there is no __file__ attribute OS X 10.6 where I get NameError: global name '__file__' is not defined


I did this and removed the new path entry with sys.path.pop(0) immediately after importing the desired module. However, subsequent imports still went to that location. For example, I have app/config, app/tools and app/submodule/config. From submodule, I insert app/ to import tools, then remove app/ and try to import config, but I get app/config instead of app/submodule/config.
I figured out that one of tools's imports was also importing config from the parent dir. So when I later tried to do sys.path.pop(0); import config inside submodule, expecting to get app/submodule/config, I was actually getting app/config. Evidently Python returns a cached version of a module with the same name instead of actually checking the sys.path for a module matching that name. sys.path in this case was being altered correctly, Python was just not checking it due to the same-named module already having been loaded.
I think this is the exact reference to the issue I had: docs.python.org/3/reference/import.html#the-module-cache
Some useful information from 5.3.1. The module cache on the documentation page: During import, the module name is looked up in sys.modules ... sys.modules is writable. Deleting a key will invalidate the cache entry for the named module, causing Python to search anew upon its next import. ... Beware though, as if you keep a reference to the module object, invalidate its cache then re-import, the two objects will be different. By contrast, importlib.reload() will reuse and reinitialise the module contents ...
Even shorter: os.path.realpath(getsourcefile(lambda:0) + "/../.."). Will get current source file appended with two parent directory symbols. I didn't use os.path.sep as getsourcefile was returns a string using / even on Windows. realpath will take care of popping off two directory entries from the full path (in this case, the filename, and then the current directory) which gives the parent directory.
i
itmatters

The pathlib library (included with >= Python 3.4) makes it very concise and intuitive to append the path of the parent directory to the PYTHONPATH:

import sys
from pathlib import Path
sys.path.append(str(Path('.').absolute().parent))

is it possible to use init.py to circumvent this problem?
Thank you eric, I just removed the confusing part.
import sys from pathlib import Path sys.path.append(str(Path('.').absolute().parent))
FYI this doesn't work when running visual studio code in debug mode.The ability to import/export globally is on my wishlist for python4
It works for me in VS code debug mode + works for jupyter notebok instead of Path(file)
M
Mike

Here is more generic solution that includes the parent directory into sys.path (works for me):

import os.path, sys
sys.path.append(os.path.join(os.path.dirname(os.path.realpath(__file__)), os.pardir))

import os, sys\n sys.path.insert(0,os.path.pardir) same thing, but sorther :) (no line feeds in comments)
@antiveeranna, if you use os.path.pardir you won't be getting the realpath of the parent, just relative path from where you're calling the sys.path.insert()
This answer uses the __file__ variable which can be unreliable (isn't always the full file path, doesn't work on every operating system etc.) as StackOverflow users have often mentioned. Changing the answer to not include it will cause less problems and be more cross-compatible. For more information, see stackoverflow.com/a/33532002/3787376.
T
Thomas R

In a Jupyter Notebook (opened with Jupyter LAB or Jupyter Notebook)

As long as you're working in a Jupyter Notebook, this short solution might be useful:

%cd ..
import nib

It works even without an __init__.py file.

I tested it with Anaconda3 on Linux and Windows 7.


Wouldn't it make sense to add %cd - after the import, so the notebook's current directory stays unchanged.
It helps a lot especially when you need to import modules that also import other modules using relative paths.
Y
Yu N.

I found the following way works for importing a package from the script's parent directory. In the example, I would like to import functions in env.py from app.db package.

.
└── my_application
    └── alembic
        └── env.py
    └── app
        ├── __init__.py
        └── db
import os
import sys
currentdir = os.path.dirname(os.path.realpath(__file__))
parentdir = os.path.dirname(currentdir)
sys.path.append(parentdir)

So, a nice one-liner: sys.path.append(os.path.dirname(os.path.dirname(os.path.realpath(__file__))))
Modifying sys.path at all is usually a bad idea. You need some way (e.g., PYTHONPATH) for your library to be accessible to other code (or else it’s not really a library); just use that all the time!
R
Ravin Gupta

Above mentioned solutions are also fine. Another solution to this problem is

If you want to import anything from top level directory. Then,

from ...module_name import *

Also, if you want to import any module from the parent directory. Then,

from ..module_name import *

Also, if you want to import any module from the parent directory. Then,

from ...module_name.another_module import *

This way you can import any particular method if you want to.


This seems to be like it should be, but for some reason this doesn't work in the same way as the sys.path.append hacks above and I cannot import my lib like this. This is what I first tried to do before starting to google :) Ok, it was this ValueError: attempted relative import beyond top-level package
I did some testing and it seems that from ... import name does not mean "import name from top-level", but "import name from the parent's parent". I created a nested directory structure a1/.../a9 of nine directories where each one contains an __init__.py importing the next directory with from . import next_dir. The last directory had a file with from ....... import b which then imported a1/a2/a3/b. (tested with Python 3.8.2)
Used this solution for our library tests. The accepted answer is indeed a proper way of doing things but if I understand correctly that would require exposing the modules which we don't want
@juzzlin that is a separate issue. Please see stackoverflow.com/questions/30669474/….
A
Andong Zhan

import sys sys.path.append('../')


this will not work when executed from a different directory.
z
zviad

For me the shortest and my favorite oneliner for accessing to the parent directory is:

sys.path.append(os.path.dirname(os.getcwd()))

or:

sys.path.insert(1, os.path.dirname(os.getcwd()))

os.getcwd() returns the name of the current working directory, os.path.dirname(directory_name) returns the directory name for the passed one.

Actually, in my opinion Python project architecture should be done the way where no one module from child directory will use any module from the parent directory. If something like this happens it is worth to rethink about the project tree.

Another way is to add parent directory to PYTHONPATH system environment variable.


+1 for mentioning the possibility of having to restructure the project (as opposed to throwing a hack at the problem)
this doesn't get the parent, it gets the current
This is a bad idea because it depends on the current directory and not on the location of the file, and therefore it will do different things depending on where you happen be running the script from.
t
tjk

Though the original author is probably no longer looking for a solution, but for completeness, there one simple solution. It's to run life.py as a module like this:

cd ptdraft
python -m simulations.life.life

This way you can import anything from nib.py as ptdraft directory is in the path.


This is great approach for those who don't want to mess up sys.path or environment variables like PYTHONPATH , for more detail about -m you can check out this stackoverflow thread
If you're using vscode, you can do this automatically with the config at stackoverflow.com/questions/57455652/….
V
Vinoj John Hosan

Two line simplest solution

import os, sys
sys.path.insert(0, os.getcwd()) 

If parent is your working directory and you want to call another child modules from child scripts.

You can import all child modules from parent directory in any scripts and execute it as

python child_module1/child_script.py

This is the only one that worked for me and works best for my use-case: importing the main method from a folder of tests
G
Gin

https://i.stack.imgur.com/2S8pY.png


ok, you can click this link to download 「import_case」to check the source code case_repo
j
jheyse

same sort of style as the past answer - but in fewer lines :P

import os,sys
parentdir = os.path.dirname(__file__)
sys.path.insert(0,parentdir)

file returns the location you are working in


For me file is the filename without the path included. I run it using "ipy filename.py".
Hi @CurtisYallop in the example above we are adding the dir that contains the file [that we are currently in] that the python file is in. The os.path.dirname call with the file name should return the path of the file and we are adding THAT to to the path and not the file explicitly - HTH's :-)
You are assuming that __file__ always contains the path plus the file. Sometimes it contains only the filename without the path.
@CurtisYallop - not at all sir, I am assuming file is the file name and I am using os.path.dirname() to get the path for the file. Have you got an example of this not working? I would love the steps to reproduce
@CurtisYallop - No I am not! I am saying that: print /_/file/_/ will give you the filename in your example above "file.py" - I am then saying that you can use os.path.dirname() to pull the full path from that. If you are calling from some weird location and you would like that relational then you can easily find your working dir through the os module -- Jeez!
E
Erel Segal-Halevi

In a Linux system, you can create a soft link from the "life" folder to the nib.py file. Then, you can simply import it like:

import nib

This answer deserves more attentions. symlinks approach is orders of magnitude cleaner than most of the answers on this thread. yet, this is the first time I see someone suggests it.
I disagree. This is a no-portable solution that also mixes file system layer with python source code.
T
Thomas R

I have a solution specifically for git-repositories.

First I used sys.path.append('..') and similar solutions. This causes especially problems if you are importing files which are themselves importing files with sys.path.append('..').

I then decided to always append the root directory of the git repository. In one line it would look like this:

sys.path.append(git.Repo('.', search_parent_directories=True).working_tree_dir)

Or in more details like this:

import os
import sys
import git
def get_main_git_root(path):
    main_repo_root_dir = git.Repo(path, search_parent_directories=True).working_tree_dir
    return main_repo_root_dir
main_repo_root_dir = get_main_git_root('.')
sys.path.append(main_repo_root_dir)

For the original question: Based on what the root directory of the repository is, the import would be

import ptdraft.nib

or

import nib

Btw: this is how to install the git-library: pip install GitPython
S
Sida Zhou

Our folder structure:

/myproject
  project_using_ptdraft/
    main.py
  ptdraft/
    __init__.py
    nib.py
    simulations/
      __init__.py
      life/
        __init__.py
        life.py

The way I understand this is to have a package-centric view. The package root is ptdraft, since it's the top most level that contains __init__.py

All the files within the package can use absolute paths (that are relative to package root) for imports, for example in life.py, we have simply:

import ptdraft.nib

However, to run life.py for package dev/testing purposes, instead of python life.py, we need to use:

cd /myproject
python -m ptdraft.simulations.life.life

Note that we didn't need to fiddle with any path at all at this point.

Further confusion is when we complete the ptdraft package, and we want to use it in a driver script, which is necessarily outside of the ptdraft package folder, aka project_using_ptdraft/main.py, we would need to fiddle with paths:

import sys
sys.path.append("/myproject")  # folder that contains ptdraft
import ptdraft
import ptdraft.simulations

and use python main.py to run the script without problem.

Helpful links:

https://tenthousandmeters.com/blog/python-behind-the-scenes-11-how-the-python-import-system-works/ (see how __init__.py can be used)

https://chrisyeh96.github.io/2017/08/08/definitive-guide-python-imports.html#running-package-initialization-code

https://stackoverflow.com/a/50392363/2202107

https://stackoverflow.com/a/27876800/2202107


u
user3181121

Work with libraries. Make a library called nib, install it using setup.py, let it reside in site-packages and your problems are solved. You don't have to stuff everything you make in a single package. Break it up to pieces.


Your idea is good but some people may want to bundle their module in with their code - perhaps to make it portable and not require putting their modules in site-packages every time they run it on a different computer.
C
Casper Hansen

I had a problem where I had to import a Flask application, that had an import that also needed to import files in separate folders. This is partially using Remi's answer, but suppose we had a repository that looks like this:

.
└── service
    └── misc
        └── categories.csv
    └── test
        └── app_test.py
    app.py
    pipeline.py

Then before importing the app object from the app.py file, we change the directory one level up, so when we import the app (which imports the pipeline.py), we can also read in miscellaneous files like a csv file.

import os,sys,inspect
currentdir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))
parentdir = os.path.dirname(currentdir)
sys.path.insert(0,parentdir)

os.chdir('../')
from app import app

After having imported the Flask app, you can use os.chdir('./test') so that your working directory is not changed.


M
Miroslav Hinkov

It's seems to me that you don't really need to import the parent module. Let's imagine that in nib.py you have func1() and data1, you need to use in life.py

nib.py

import simulations.life.life as life
def func1():
   pass
data1 = {}
life.share(func1, data1)

life.py

func1 = data1 = None

def share(*args):
   global func1, data1
   func1, data1 = args

And now you have the access to func1 and data in life.py. Of course you have to be careful to populate them in life.py before you try to use them,


f
fx-kirin

I made this library to do this.

https://github.com/fx-kirin/add_parent_path

# Just add parent path
add_parent_path(1)

# Append to syspath and delete when the exist of with statement.
with add_parent_path(1):
   # Import modules in the parent path
   pass

m
mj_whales

This is the simplest solution that works for me:

from ptdraft import nib

J
JLT

Although it is against all rules, I still want to mention this possibility:

You can first copy the file from the parent directory to the child directory. Next import it and subsequently remove the copied file:

for example in life.py:

import os
import shutil

shutil.copy('../nib.py', '.')
import nib
os.remove('nib.py')

# now you can use it just fine:
nib.foo()

Of course there might arise several problems when nibs tries to import/read other files with relative imports/paths.


This is a creative solution! I probably wouldn't use it though.
I would strongly advise not to use this solution, but rather to make the parent directory a package as well or just append the parent directory to your sys.path (as suggested in the other answers). Copying/removing the file introduces a very tight dependency on the file location, which may be unnoticed when changing the project in the future (and thus makes the script less robust). Also it prevents the file from being cached and of course also creates slight overhead for the needed IO.
I understand people do downvote this post, since it is indeed bad practice, and I would never use it when writing a package or a reusable script, however it might still be worthwhile in some cases. For example, when you are running an interactive session and you just want to use some functions defined in a script in another location. I believe it is good practice that these kind of solutions are still mentioned on stackoverflow.
I understand your remark, @JLT and agree that it may be worth to include this on StackOverflow for reference. So why not update your answer to reflect your reasoning there, and mention some of the considerations/pitfalls which come with it?
R
Ricardo D. Quiroga

This works for me to import things from a higher folder.

import os
os.chdir('..')