Core Python Programming (2nd Edition)

14.4. Executing Other (Python) Programs
When we discuss the execution of other programs, we distinguish between Python programs and all
other non-Python programs, which include binary executables or other scripting language source code.
We will cover how to run other Python programs first, then how to use the os module to invoke external
programs.
14.4.1. Import
During runtime, there are a number of ways to execute another Python script. As we discussed earlier,
importing a module the first time will cause the code at the top level of that module to execute. This is
the behavior of Python importing, whether desired or not. We remind you that the only code that
belongs to the top level of a module are global variables, and class and function declarations.
Core Note: All modules executed when imported
This is just a friendly reminder: As already alluded to earlier in
Chapters 3 and 12, we will tell you one more time that Python
modules are executed when they are imported! When you import the
foo module, it runs all of the top-level (not indented) Python code, i.
e., "main()". If foo contains a declaration for the bar function, then def
foo(...) is executed. Why is that again?
Well, just think what needs to be done in order for the call foo.bar()
to succeed. Somehow bar has to be recognized as a valid name in the
foo module (and in foo 's namespace), and second, the interpreter
needs to know it is a declared function, just like any other function in
your local module.
Now that we know what we need to do, what do we do with code that
we do not want executed every time our module is imported? Indent it
and put it in the suite for the if __name__ == '__main__'.
These should be followed by an if statement that checks __name__ to determine if a script is invoked, i.
e., "if__name__ == '__main__'". In these cases, your script can then execute the main body of code, or,
if this script was meant to be imported, it can run a test suite for the code in this module.
One complication arises when the imported module itself contains import statements. If the modules in
these import statements have not been loaded yet, they will be loaded and their top-level code
executed, resulting in recursive import behavior. We present a simple example below. We have two
modules import1 and import2, both with print statements at their outermost level. import1 imports
import2 so that when we import import1 from within Python, it imports and "executes" import2 as well.
Here are the contents of import1.py:
# import1.py
print 'loaded import1'