Many languages start running your program by calling a function of
yours that must have a specific name. In C (and many C derived
languages), this is just called main()
; in Go, it's main.main()
(the main()
function in the main
package). Python famously
doesn't require any such function, and won't automatically call a
function called main()
even if you create it. Recently I read Why doesn’t Python have a main function?
( via
),
which puts forward one discussion for why this is so. However, I have
a somewhat different way of explaining this situation.
The core reason that Python doesn't require a main()
function is a
combination of its execution model (specifically for what happens when
you import something) and that under normal circumstances you start
Python programs by (implicitly) importing a single file of Python code.
So let's look at each of these parts.
In many languages things like functions, classes, and so on are
created (defined) by the interpreter or compiler as it parses the
source file. In Python, this is not quite the case; instead,
def
and class
are executable statements
,
and they define classes and functions when they execute (among other
things, this is part ofwhy metaclasses work).
When Python imports something, it simply executes everything in the
file (or the import more generally). When what's executed is def
and class
statements, you get functions and classes. When what's
executed is regular code, you get more complicated things happening,
including conditional imports or calling functions on the fly under
the right conditions. Or you can write an entire program that just
runs inline, as the file is imported.
(This has some interesting consequences, including what reloading a Python module really does .)
However, Python is not quite as unique here as it might look. Many
languages have some facility to run arbitrary code early on as the
program is 'loading', before the program starts normal execution
(Go has init()
functions, for example). Where Python is different
from these languages is that Python normally starts a program by
loading and executing a specific single file. Because Python is
only executing a single file, it's unambiguous what code is run in
what order and it's straightforward for the code in that file to
control what happens. In a sense, rather than picking an arbitrarily
named function for where execution (nominally) starts, Python is
able to sneakily pick an arbitrarily named file by having you provide
it.
(Compiled languages traditionally have a model where code from a bunch
of separate files is all sort of piled up together. In Python, you can't
really aggregate multiple files together into a shared namespace this
way; one way or another, you have to import
them and everything starts
from some initial file.)
Where this nice model breaks down and needs a workaround is if you
run a package with ' python -m ...
', where Python doesn't really
have a single file that you're executing (or it'd have to make __init__.py
serve double duty). As covered in the official
documentation's
__main__
— Top-level script environment
( via
),
Python adopts the arbitrary convention of loading a __main__.py
file from your package and declaring it more or less the point where
execution starts.
(Under at least some situations, your package's __init__.py
may
also be executed.)
PS: contrary to the original article's views
,
I strongly suggest that you have a main()
function
, because there are significant benefits to keeping your program importable
.
很遗憾的说,推酷将在这个月底关闭。人生海海,几度秋凉,感谢那些有你的时光。
以上就是本文的全部内容,希望本文的内容对大家的学习或者工作能带来一定的帮助,也希望大家多多支持 码农网
猜你喜欢:本站部分资源来源于网络,本站转载出于传递更多信息之目的,版权归原作者或者来源机构所有,如转载稿涉及版权问题,请联系我们。
算法设计、分析与实现
徐子珊 / 2012-10 / 65.00元
《算法设计、分析与实现:c、c++和java》由徐子珊编著,第1章~第6章按算法设计技巧分成渐增型算法、分治算法、动态规划算法、贪婪算法、回溯算法和图的搜索算法。每章针对一些经典问题给出解决问题的算法,并分析算法的时间复杂度。这样对于初学者来说,按照算法的设计方法划分,算法思想的阐述比较集中,有利于快速入门理解算法的精髓所在。一旦具备了算法设计的基本方法,按应用领域划分专题深入学习,读者可以结合已......一起来看看 《算法设计、分析与实现》 这本书的介绍吧!