def

[d. savitsky]

Martijn,

have you thought about writing a book? this is about the clearest
explanation of the 'python way' to do stuff that i have seen.

cheers,

doug


> Probably we cannot do what you're asking for, which I interpret as
something
> like this:
>
> foo()
>
> def foo():
>     print "foo!"
>
> This won't work, as at the point you try to call 'foo', the function foo
> has not yet been defined, as it definition statement (def foo()) has
> not yet been executed by the interpreter. The other way around does
> work:
>
> def foo():
>     print "foo!"
>
> foo()
>
> But, you don't want this, really (famous comp.lang.python maneuver).
Instead,
> you want to place those calls in the main() (or otherwise named) function
> of your module, in anything but the most trivial of scripts:
>
> def main()
>     foo()
>
> def foo():
>     print "foo!"
>
> Of course, if you run this module, nothing happens. You can fix this
> by placing a call to main at the bottom (just that single call,
> nothing more):
>
> def main():
>     foo()
>
> def foo():
>     print "foo!"
>
> main()
>
> But, you still don't want this usually, for the same reason you didn't
want
> the original solution: if you place code in the top-level of the module,
> you can only use that module to execute it, and you cannot properly
> import it anymore; as soon as you do that the first time, the top-level
> code would get executed, which wouldn't be what you want.
>
> Instead, the standard recommendation is to use this:
>
> def main():
>     foo()
>
> def foo():
>     print "foo!"
>
> if __name__ == "__main__":
>     main()
>
> The latter magic incantation checks if the global variable '__name__' is
> the string "__main__". This is only the case if the module is being
> executed directly by Python, not when it's imported by another module.
> This way, your main() function only gets executed when you actually
> execute your module, and you can still use the module's functionality
> in other programs through import, without problems.
>
> In the case when there is no plausible main() function for your module
> (it is a library), you can provide a self-test function instead. Instead
> of having a main() and calling that, you have a test().
>
> Of course for trivial scripts all this is unnecessary. The only advantage
of
> this strategy there is allows you to order your code in any order you
want,
> without having to worry about whether names are defined yet (but just
> calling main() at the bottom would accomplish this already).
>
> Hope this helps.
>
> Regards,
>
> Martijn
> --
> History of the 20th Century: WW1, WW2, WW3?
> No, WWW -- Could we be going in the right direction?