I am new to Python, but I have experience in other OOP languages. My
course does not explain the main method in python.
Please tell me how main method works in python
? I am confused because I am trying to compare it to Java.
def main():
# display
some lines
if __name__ == "__main__":
main()
How is main
executed and why do I need this strange if
to execute
main
. My code is terminated without output when I remove the
if
.
The minimal code -
class AnimalActions:
def quack(self): return self.strings['quack']
def bark(self): return
self.strings['bark']
class
Duck(AnimalActions):
strings = dict(
quack =
"Quaaaaak!",
bark = "The duck cannot bark.",
)
class Dog(AnimalActions):
strings =
dict(
quack = "The dog cannot quack.",
bark =
"Arf!",
)
def in_the_doghouse(dog):
print(dog.bark())
def in_the_forest(duck):
print(duck.quack())
def main():
donald =
Duck()
fido = Dog()
print("- In the
forest:")
for o in ( donald, fido ):
in_the_forest(o)
print("- In the doghouse:")
for o in (
donald, fido ):
in_the_doghouse(o)
if
__name__ == "__main__": main()
Answer
The Python approach to "main" is almost
unique to the language(*).
The semantics are a
bit subtle. The __name__
identifier is bound to the name of any
module as it's being imported. However, when a file is being executed then
__name__
is set to "__main__"
(the
literal string:
__main__
).
This is
almost always used to separate the portion of code which should be executed from the
portions of code which define functionality. So Python code often contains a line
like:
#!/usr/bin/env
python
from __future__ import print_function
import this, that,
other, stuff
class SomeObject(object):
pass
def some_function(*args,**kwargs):
pass
if __name__ == '__main__':
print("This
only executes when %s is executed rather than imported" %
__file__)
Using this
convention one can have a file define classes and functions for use in other programs,
and also include code to evaluate only when the file is called as a standalone
script.
It's important to understand that all of
the code above the if __name__
line is being executed,
evaluated, in both cases. It's evaluated by the interpreter when the file is imported or
when it's executed. If you put a print
statement before the
if __name__
line then it will print output every time any other
code attempts to import that as a module. (Of course, this would be
anti-social. Don't do
that).
I, personally, like these semantics. It
encourages programmers to separate functionality (definitions) from function (execution)
and encourages re-use.
Ideally almost
every Python module can do something useful if called from the command line. In many
cases this is used for managing unit tests. If a particular file defines functionality
which is only useful in the context of other components of a system then one can still
use __name__ == "__main__"
to isolate a block of code which
calls a suite of unit tests that apply to this
module.
(If you're not going to have any such
functionality nor unit tests than it's best to ensure that the file mode is NOT
executable).
Summary: if __name__ ==
has two primary use
'__main__':
cases:
- Allow a module to
provide functionality for import into other code while also providing useful semantics
as a standalone script (a command line wrapper around the
functionality) - Allow a module to define a suite of unit
tests which are stored with (in the same file as) the code to be tested and which can be
executed independently of the rest of the
codebase.
It's
fairly common to def main(*args)
and have if
simply call
__name__ == '__main__':
main(*sys.argv[1:])
if you want to define main in a manner
that's similar to some other programming languages. If your .py file is primarily
intended to be used as a module in other code then you might def
and calling
test_module()test_module()
in your
if __name__ == '__main__:'
suite.
- (Ruby also
implements a similar featureif __file__ ==
).
$0
No comments:
Post a Comment