When writing Python scripts, be sure to add this!

People who use Python often write some scripts. Whether it is to improve work efficiency or to meet some specific needs, Python scripts are a common and useful thing.

However, I recently discovered a problem that I had never noticed before, which is whether to add if __name__ == "__main__":
to the script. This statement actually has a great impact on the use of the script. And there is a lot of knowledge in it.

Common Misunderstandings

Many friends are more casual when writing scripts. Simple scripts are written down directly without functions and executed sequentially. For more complex scripts, functions may be added. This way of writing is less readable, and people often cannot find the entry and sequence of program execution at a glance.

The way that the Python community recommends is to add the following statement when writing a script:

def main():
# do something
print("do something.")

if __name__ == "__main__":
main()

When most people see this, will they say, what does this mean? It’s not that important to add this!

Don’t be too busy and dismissive, let’s discuss it carefully together!

What’s the use

In the specific explanation if __name__ = = '__main__', let's intuitively feel it from a simple example.

# const.py
 
PI = 3.14
 
def train():
print("PI:", PI)
 
train()

# area.py
 
from const import PI
 
def calc_round_area(radius):
return PI * (radius ** 2)
 
def calculate():
print("round area: ", calc_round_area(2))
 
calculate()

Let’s take a look at the running results of area.py: The PI variables of

PI: 3.14
round area:12.56

are also brought over when running, and the printing in the function train()
in const.py is also brought here , and we only referenced the variable and not the function, so this is what we don't want to see.

The method to solve this problem is also very simple. We only need to add a sentence in const.py:

PI = 3.14

def train():
 print("PI:", PI)

if __name__ == "__main__":
 train()

Run area.py again, the output result is as follows:

round area:12.56

This is our expected result.

Program running entrance

It can be found from the above examples that if there is no if __name__=="__main__":, when importing the file as area.py, all the codes in const.py
will be is executed, and after adding it, only the imported part of the code will be run.

This is the obvious effect of if __name__=="__main__":. In fact, if __name__=="__main__": is equivalent to the program entry of
Python simulation. Since modules refer to each other, different modules may have such definitions, but there can only be one entry program. Which entry program is selected depends on the value of __name__.

Let’s look at a small program again:

print("look here")
print(__name__)
 
if __name__ == '__main__':
print("I'm test.py")

The running results of the program are as follows:

look here
__main__
I'm test.py

It can be found that the value of variable __name__ is __main__ at this time, So prints "I'm
test.py". If you run other files and call this file through the running file, the statement will not be printed because the program entry is incorrect and the statement will not be executed.

Code specification

With if __name__=="__main__": equivalent to Python
The program also has an entry function. We can clearly know that the logic of the program starts with Where, of course we need to consciously put the starting logic of the program here. In fact, this is also the approach recommended by PyCharm
.

Why do many excellent programming languages, such as C, Java, Golang, and C, have a main
entry function? I think a very important reason is that the program entry is unified and easy to read. .

Great effect in multi-process scenarios

If you use multiple processes for parallel computing, code similar to this:

import multiprocessing as mp

def useful_function(x):
return x * x

print("processing in parallel")
with mp.Pool() as p:
results = p.map(useful_function, [1, 2, 3, 4])
print(results)

Run this code, the console will Keep printing:

processing in parallel
processing in parallel
processing in parallel
processing in parallel
processing in parallel
processing in parallel
processing in parallel
processing in parallel
processing in parallel

and the program will keep reporting RuntimeError.

If you add if __name__=="__main__":, the program will proceed as expected:

import multiprocessing as mp

def useful_function(x):
return x * x

if __name__ == '__main__':
print("processing in parallel")
with mp.Pool() as p:
results = p.map(useful_function, [1, 2, 3, 4])
print(results)

Python's multi-program is to start multiple Python interpreters, each Each Python interpreter will import your script and copy a copy of the global variables and functions for the child process. If there is if
__name__=="__main__":, then the code behind it will not be imported, that is Will not be executed repeatedly. Otherwise, the code that creates multiple processes will be
imported and executed, thereby creating child processes infinitely recursively

Summary

if __name__==" __main__": Although it is not mandatory, I strongly recommend that you follow this specification when writing scripts.

The above is the detailed content of When writing Python scripts, be sure to add this!. For more information, please follow other related articles on the PHP Chinese website!