Author Dusty Phillips Reviewers

[
 44 
]
As these two examples illustrate, all module-level code is executed immediately at 
the time it is imported. However, if it is inside a method or function, the function will 
be created, but its internal code will not be executed until the function is called. This 
can be a tricky thing for scripts (such as the main script in our e-commerce example) 
that perform execution. Often, we will write a program that does something useful, 
and then later find that we want to import a function or class from that module in a 
different program. However, as soon as we import it, any code at the module level is 
immediately executed. If we are not careful, we can end up running the first program 
when we really only meant to access a couple functions inside that module.
To solve this, we should always put our startup code in a function (conventionally, 
called 
main
) and only execute that function when we know we are running the 
module as a script, but not when our code is being imported from a different script. 
But how do we know this?
class UsefulClass:
'''This class might be useful to other modules.'''
pass
def main():
'''creates a useful class and does something with it for our 
module.'''
useful = UsefulClass()
print(useful)
if __name__ == "__main__":
main()
Every module has a 
__name__
special variable (remember, Python uses double 
underscores for special variables, such as a class's 
__init__
method) that specifies 
the name of the module when it was imported. When the module is executed directly 
with 
python module.py
, it is never imported, so the 
__name__
is arbitrarily set to the 
string 
"__main__"
. Make it a policy to wrap all your scripts in an 
if __name__ == 
"__main__":
test, just in case you write a function you will find useful to be imported 
by other code someday.
So, methods go in classes, which go in modules, which go in packages. Is that all 
there is to it?
www.it-ebooks.info

---

Chapter 2