Python 3 - 导入系统和相对导入概念

Question

I am fairly new to Python, specifically Python3; learning the ropes here.

Problem Summary : Can be summarized in not fully understanding how the import system works in Python and what exactly is relative import, though I'll mention what I actually understand and please correct me if there are any misconceptions here.

My Understanding : Python behaves differently whether a python file "file.py" is ran from the REPL using python file.py vs importing this file using import file.py , this behavior differs in the value assignment of __name__ variable; in the first case its given the value '__main__' and in the second case its given the value __file__ which is usually the fully qualified path followed to import this file. Upon importing a module; python doesn't save the hierarchy it has followed to fetch it, hence if there are modules needed to be imported within the same level of the previously imported module, then a fully qualified name is still needed.

---

Context:

Consider the following directory

Main:
|______ main.py
|
|______ PackageOne:
|
|______ ______ __init__.py
|
|______ ______ ModuleOne.py
|
|______ ______ PackageTwo:
|
|______ ______ ______ __init__.py
|
|______ ______ ______ ModuleTwo.py

structure details:

• main.py => program entry ("first file to be ran via IDE").

• PackageOne => a package folder containing an __init__.py initializer and a ModuleOne.py module.

  • __init__.py => the initializing python file of PackageOne which imports ModuleOne.py module and PackageTwo
  • ModuleOne.py a module python file that contains a function named FuncOne()

• PackageTwo => a package folder containing an __init__.py initializer and a ModuleTwo.py module.

  • __init__.py => the initializing python file of PackageTwo which imports ModuleTwo.py module
  • ModuleTwo.py a module python file that contains a function named FuncTwo() Files content:
    
    main.py :

  import PackageOne PackageOne / __init__ :

  print(f"From ParentPackage, Name:{ name }") import PackageTwo, ModuleOne

PackageOne / ModuleOne :

def FuncOne():
    print(__name__)

PackageTwo/ __init__ :

print(f"From ParentPackage, Name:{__name__}")
import ModuleTwo

PackageTwo/ ModuleTwo :

def FuncTwo():
    print(__name__)

---

Detailed Problem:

• A): An output of

No Module Named 'PackageTwo'

pops up. and upon removing PackageTwo from import, the same occurs for ModuleOne.

• B): Upon refactoring the code of files like so:
  

  PackageOne / __init__ :

   print(f"From ParentPackage, Name:{__name__}") from PackageOne import PackageTwo, ModuleOne

  PackageTwo/ __init__ :

   print(f"From ParentPackage, Name:{__name__}") from PackageOne.PackageTwo import ModuleTwo

Running main.py causes no problems whatsoever and prints out "From ParentPackage, Name:PackageOne" and "From ChildPackage, Name:PackageOne.PackageTwo", but trying to execute any of the __init__.py files directly outputs an error of

No Module Named:'PackageOne'

which seems counter-intuitive to the concept of modularity in the sense of dividing the code into small parts for reusability / readability, but not actually being able to run the code from the same scope its written in, or the flexibility of importing it from a different scope. Though I instantly thought maybe relative import would probably help solve this case? but it seems that my understanding of relative import is not concrete, so a brush up on this topic would really help.

Thank you!

Answer 1

I've found a way to some what solve this issue, but this wouldn't be considered a decent approach as it increases coupling between dependancies.

if __name__ != "__main__":
    import importlib
    my_module = importlib.import_module(f'{__name__}.ModuleOne')
else:
    import ModuleOne

importlib.import_module(f'{__name__}.ModuleOne') is a function that imports Modules and by providing the path / caller of the import keyword __name__ , I'am able to import ModuleOne from any scope.

this would be placed within the PackageOne \ __init__.py , by doing so I can easily run the __init__.py file directly or by importing it, but by explicitly typing a string representation of ModuleOne within the importing function it makes it impossible to auto-refactor upon changing the dependancies name. This answer is to some what guide myself in the direction of how things work and maybe find a better approach.

Answer 2

I think I've finally figured it out, there were a couple of missing information, please correct me if I am wrong.

1. from __a__ import __b__ can be in two contexts:

   • Script File: __a__ here can only be the name of a module or a sub directory, while __b__ can be an attribute of the module to be inserted. which begs the question, how to import modules from different directories if the python file is being ran as a script? we start adding the directory to the list of directories that python searches within using sys.path.append("directory path needed") , importing sys of course prior to that.

   • Module: module meaning that this python file is going to be imported into another module or directly into the script file that is being ran, hence the __a__ part can either be a module name from a directory that exists in the sys.path like the examples above, or a directory; for example from child import module . Note : It's important to know that when using Absolute paths its important to start the directory path from the root package up to the required package or module. Instead relative paths can be used.

   • Conclusion: __name__ when is evaluated to "__main__" due to running the python file as a script, its unable to traverse to other paths using the from keyword.

2. __init__.py files aren't meant to be ran as scripts hence they sometimes include importing modules or other packages using the from directory keyboard.

3. Correlation of the above two points, the relative import such from . import package from . import package is only valid for modules and __init__.py of packages which is a module itself and not scripts.

4. Sibling packages do not require changing directories to access each other.

---

Summary :

When working on a module you can use from directory and from . (relative paths) from . (relative paths) , but when working on a script if there is a specific module needed from a different directory then add it to the path using sys.path.append("directory") , finally __init__.py of packages are modules, not scripts. (if needed to work as a script/module then an if condition if __name__ != __main__: relative import or another work around is required).