Core Python Programming (2nd Edition)

Most projects tend to consist of a single application and import any required modules. Thus it is
important to bear in mind that most modules are created solely to be imported rather than to execute as
scripts. We are more likely to create a Python library-style module whose sole purpose is to be imported
by another module. After all, only one of the modulesthe one that houses the main applicationwill be
executed, either by a user from the command line, by a batch or timed mechanism such as a Unix cron
job, via a Web server call, or through a GUI callback.
With that fact in hand, we should also remember that all modules have the ability to execute code. All
Python statements in the highest level of codethat is, the lines that are not indentedwill be executed on
import, whether desired or not. Because of this "feature," safer code is written such that everything is in
a function except for the code that should be executed on an import of a module. Again, usually only the
main application module has the bulk of the executable code at its highest level. All other imported
modules will have very little on the outside, and everything in functions or classes. (See Core Note that
follows for more information.)
Core Note: __name__ indicates how module was loaded
Because the "main" code is executed whether a module is imported or
executed directly, we often need to know how this module was loaded
to guide the execution path. An application may wish to import the
module of another application, perhaps to access useful code which
will otherwise have to be duplicated (not the OO thing to do).
However, in this case, you only want access to this other application's
code, not necessarily to run it. So the big question is, "Is there a way
for Python to detect at runtime whether this module was imported or
executed directly?" The answer is ... (drum roll ... ) yes! The __name__
system variable is the ticket.
3.4.2. Create Tests in the Main Body
● __name__ contains module name if imported
● __name__ contains '__main__' if executed directly
For good programmers and engineers, providing a test suite or harness for our entire application is the
goal. Python simplifies this task particularly well for modules created solely for import. For these
modules, you know that they would never be executed directly. Wouldn't it be nice if they were invoked
to run code that puts that module through the test grinder? Would this be difficult to set up? Not really.
The test software should run only when this file is executed directly, i.e., not when it is imported from
another module, which is the usual case. Above and in the Core Note, we described how we can
determine whether a module was imported or executed directly. We can take advantage of this
mechanism by using the __name__ variable. If this module was called as a script, plug the test code right
in there, perhaps as part of main() or test() (or whatever you decide to call your "second-level" piece of
code) function, which is called only if this module is executed directly.
The "tester" application for our code should be kept current along with any new test criteria and results,
and it should run as often as the code is updated. These steps will help improve the robustness of our
code, not to mention validating and verifying any new features or updates.