Recursive import: 'import' vs. 'from ... import ...'

Question

I have two files that need to use different functions from each other.

file1.py:

import file2   # from file2 import y2

def x1():
    print "x1"

def x2():
    print "x2"
    file2.y2()

file2.py:

import file1   # from file1 import x1

def y1():
    file1.x1()
    print "y"

def y2():
    print "y2"

if __name__ == "__main__":
    y1()

I would like to know why using import file1 is working, but importing just the specific function from file1 (from file1 import x1) is not?

Traceback (most recent call last):
  File "file2.py", line 1, in <module>
    from file1 import x1
  File "file1.py", line 1, in <module>
    import file2
  File "file2.py", line 1, in <module>
    from file1 import x1
ImportError: cannot import name x1

I've read this about imports:

import X

Imports the module X, and creates a reference to that module in the current namespace. Then you need to define completed module path to access a particular attribute or method from inside the module (e.g.: X.name or X.attribute)

from X import *

Imports the module X, and creates references to all public objects defined by that module in the current namespace (that is, everything that doesn’t have a name starting with _) or whatever name you mentioned.

Or, in other words, after you've run this statement, you can simply use a plain (unqualified) name to refer to things defined in module X. But X itself is not defined, so X.name doesn't work. And if name was already defined, it is replaced by the new version. And if name in X is changed to point to some other object, your module won’t notice.

This makes all names from the module available in the local namespace.

don't use cyclic imports. if functions are so closely connected, they belong into the same module. — Daniel, Mar 25 '16 at 11:52
@Daniel Cyclic imports may be rare but they have their uses. Just because two modules are dependent on each other doesn’t mean they belong in the same module. Submodules for instance sometimes need to import their parent. — Konrad Rudolph, Mar 25 '16 at 11:53

score 4 · Accepted Answer · answered Apr 11 '16 at 19:27

Cyclic imports usually indicate design problems but in order to solve them you may write the import statement at the bottom like so:

def x1():
    print "x1"

def x2():
    print "x2"
    file2.y2()

from file2 import y2

Keep in mind it's a workaround. The reason from x import y doesn't work in case of cyclic imports is that when you reach the first from ... import ... you are passed to the second module and when the second module calls back the first, the interpreter realizes it's a never-ending cycle and continues with a partially imported module, which happens before you even define the functions meaning y2 doesn't exist yet.

score 0 · Answer 2 · answered Jan 22 '21 at 16:24

Another solution is to import modules only when you need them. For example, in your case, it could be solved by the below method:

file1.py

# insted of importing file2 here

def x1():
    print "x1"

def x2():
    print "x2"
    import file2    # import here when you need it
    file2.y2()

file2.py

This file content should be the same as mentioned in the question.

Recursive import: 'import' vs. 'from ... import ...'

2 Answers2