When writing Python scripts, be sure to add this!

PHPz
Release: 2023-04-14 19:40:01
forward
1354 people have browsed it

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()
Copy after login

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()
Copy after login
# 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()
Copy after login

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

PI: 3.14
round area:12.56
Copy after login

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()
Copy after login

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

round area:12.56
Copy after login

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")
Copy after login

The running results of the program are as follows:

look here
__main__
I'm test.py
Copy after login

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)
Copy after login

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
Copy after login

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)
Copy after login

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!

Related labels:
source:51cto.com
Statement of this Website
The content of this article is voluntarily contributed by netizens, and the copyright belongs to the original author. This site does not assume corresponding legal responsibility. If you find any content suspected of plagiarism or infringement, please contact admin@php.cn
Popular Tutorials
More>
Latest Downloads
More>
Web Effects
Website Source Code
Website Materials
Front End Template