I am kind of confused on what the import statements does in python so to understand that i have this sample test.py script:
def functionA():
import test
print("a1")
def functionB():
print("b")
print("t1")
functionA()
print("m1")
When i execute this test.py script using the following command:
python3 test.py
I get the following:
t1
t1
a1
m1
a1
m1
It would be great if someone can explain to me why i get the following output and what exactly is happening.
The flow of execution is a little hard to understand. But here it is
When you execute your file using
python3 test.pyit executes the script whose first line generatest1Now it calls functionA() which imports your script(so executing your script second time) which gives
t1then it calls functionA() again but this time test is already imported so the next line of execution isa1. then we execute line 3 which givesm1. Now we come outside the functionA()'s (first call) import and executea1and then we exit first functionA() call and print
m1
For more info refer this link
import usually does not do.
import test executes the script how come functionA() doesn't execute infinitely? I was expecting the program to never terminate and keep executing itself. What makes it terminate?TLDR: import loads each module only once per interpreter session. However, the main module is special in that it can be imported in two variants.
The import statement is responsible for two things:
Notably, if the module has already been loaded (it is in sys.modules), the module is not loaded again. Only the name binding happens in this case.
This is why importing the module recursively does not rerun its code infinitely.
The main module, that is the initial module run, is special in that it can regularly exist with two variants:
__main__, set automatically by running the module, andtest, set automatically by importing the module.Notably, these two versions are not identical. Every module with an if __name__ == "__main__": guard runs different code, and thus achieves different state.
This is why the __main__ module can be loaded twice, once under the name __main__ and once under its own name.
For this code in specific, the sequence is like this:
python3 test.py sets up test.py to be imported as __main__.__main__ yet. Python executes test.py to create the module.
functionA and functionB are defined,print("t1") is called,functionA is called,
import test is run,
test yet. Python executes test.py to create the module.
functionA and functionB are defined,print("t1") is called,functionA is called,import test is run,
test already exists (though not completely).test module to the name test.print("a1") is called,print("m1") is called,print("a1") is called,print("m1") is called,
importyou understand? What output you would have expected instead? Why are you confused by the output you get?import testdoes, and why it seemingly imports the module twice (but not more).