[ad_1]
\n<\/p>\n
It’s boilerplate code that protects users from accidentally invoking the script when they didn’t intend to. Here are some common problems when the guard is omitted from a script:<\/p>\n
If you import the guardless script in another script (e.g. If you have a custom class in the guardless script and save it to a pickle file, then unpickling it in another script will trigger an import of the guardless script, with the same problems outlined in the previous bullet.<\/p>\n<\/li>\n<\/ul>\n To better understand why and how this matters, we need to take a step back to understand how Python initializes scripts and how this interacts with its module import mechanism.<\/p>\n Whenever the Python interpreter reads a source file, it does two things:<\/p>\n it sets a few special variables like it executes all of the code found in the file.<\/p>\n<\/li>\n<\/ul>\n Let’s see how this works and how it relates to your question about the Let’s use a slightly different code sample to explore how imports and scripts work. Suppose the following is in a file called When the Python interpreter reads a source file, it first defines a few special variables. In this case, we care about the When Your Module Is the Main Program<\/strong><\/p>\n If you are running your module (the source file) as the main program, e.g.<\/p>\n the interpreter will assign the hard-coded string When Your Module Is Imported By Another<\/strong><\/p>\n On the other hand, suppose some other module is the main program and it imports your module. This means there’s a statement like this in the main program, or in some other module the main program imports:<\/p>\n The interpreter will search for your After the special variables are set up, the interpreter executes all the code in the module, one statement at a time. You may want to open another window on the side with the code sample so you can follow along with this explanation.<\/p>\n Always<\/strong><\/p>\n It prints the string It loads the It prints the string It executes the It prints the string It executes the second It prints the string Only When Your Module Is the Main Program<\/strong><\/p>\n Only When Your Module Is Imported by Another<\/strong><\/p>\n Always<\/strong><\/p>\n Summary<\/strong><\/em><\/p>\n In summary, here’s what’d be printed in the two cases:<\/p>\n You might naturally wonder why anybody would want this. Well, sometimes you want to write a Your module is a library, but you want to have a script mode where it runs some unit tests or a demo.<\/p>\n<\/li>\n Your module is only used as a main program, but it has some unit tests, and the testing framework works by importing Your module is mostly used as a main program, but it also provides a programmer-friendly API for advanced users.<\/p>\n<\/li>\n<\/ul>\n Beyond those examples, it’s elegant that running a script in Python is just setting up a few magic variables and importing the script. “Running” the script is a side effect of importing the script’s module.<\/p>\n Question: Can I have multiple Suppose the following is in import my_script_without_a_name_eq_main_guard<\/code>), then the latter script will trigger the former to run at import time<\/em> and using the second script’s command line arguments<\/em>. This is almost always a mistake.<\/p>\n<\/li>\nLong Answer<\/h1>\n
\n
__name__<\/code>, and then<\/p>\n<\/li>\n__name__<\/code> checks we always see in Python scripts.<\/p>\nCode Sample<\/h2>\n
foo.py<\/code>.<\/p>\n# Suppose this is foo.py.\n\nprint(\"before import\")\nimport math\n\nprint(\"before function_a\")\ndef function_a():\n print(\"Function A\")\n\nprint(\"before function_b\")\ndef function_b():\n print(\"Function B {}\".format(math.sqrt(100)))\n\nprint(\"before __name__ guard\")\nif __name__ == '__main__':\n function_a()\n function_b()\nprint(\"after __name__ guard\")\n<\/code><\/pre>\nSpecial Variables<\/h2>\n
__name__<\/code> variable.<\/p>\npython foo.py\n<\/code><\/pre>\n\"__main__\"<\/code> to the __name__<\/code> variable, i.e.<\/p>\n# It's as if the interpreter inserts this at the top\n# of your module when run as the main program.\n__name__ = \"__main__\" \n<\/code><\/pre>\n# Suppose this is in some other main program.\nimport foo\n<\/code><\/pre>\nfoo.py<\/code> file (along with searching for a few other variants), and prior to executing that module, it will assign the name \"foo\"<\/code> from the import statement to the __name__<\/code> variable, i.e.<\/p>\n# It's as if the interpreter inserts this at the top\n# of your module when it's imported from another module.\n__name__ = \"foo\"\n<\/code><\/pre>\nExecuting the Module’s Code<\/h2>\n
\n
\"before import\"<\/code> (without quotes).<\/p>\n<\/li>\nmath<\/code> module and assigns it to a variable called math<\/code>. This is equivalent to replacing import math<\/code> with the following (note that __import__<\/code> is a low-level function in Python that takes a string and triggers the actual import):<\/p>\n<\/li>\n<\/ol>\n# Find and load a module given its string name, \"math\",\n# then assign it to a local variable called math.\nmath = __import__(\"math\")\n<\/code><\/pre>\n\n
\"before function_a\"<\/code>.<\/p>\n<\/li>\ndef<\/code> block, creating a function object, then assigning that function object to a variable called function_a<\/code>.<\/p>\n<\/li>\n\"before function_b\"<\/code>.<\/p>\n<\/li>\ndef<\/code> block, creating another function object, then assigning it to a variable called function_b<\/code>.<\/p>\n<\/li>\n\"before __name__ guard\"<\/code>.<\/p>\n<\/li>\n<\/ol>\n\n
__name__<\/code> was indeed set to \"__main__\"<\/code> and it calls the two functions, printing the strings \"Function A\"<\/code> and \"Function B 10.0\"<\/code>.<\/li>\n<\/ol>\n\n
__name__<\/code> will be \"foo\"<\/code>, not \"__main__\"<\/code>, and it’ll skip the body of the if<\/code> statement.<\/li>\n<\/ol>\n\n
\"after __name__ guard\"<\/code> in both situations.<\/li>\n<\/ol>\n# What gets printed if foo is the main program\nbefore import\nbefore function_a\nbefore function_b\nbefore __name__ guard\nFunction A\nFunction B 10.0\nafter __name__ guard\n<\/code><\/pre>\n# What gets printed if foo is imported as a regular module\nbefore import\nbefore function_a\nbefore function_b\nbefore __name__ guard\nafter __name__ guard\n<\/code><\/pre>\nWhy Does It Work This Way?<\/h2>\n
.py<\/code> file that can be both used by other programs and\/or modules as a module, and can also be run as the main program itself. Examples:<\/p>\n\n
.py<\/code> files like your script and running special test functions. You don’t want it to try running the script just because it’s importing the module.<\/p>\n<\/li>\nFood for Thought<\/h2>\n
\n
__name__<\/code> checking blocks? Answer: it’s strange to do so, but the language won’t stop you.<\/p>\n<\/li>\nfoo2.py<\/code>. What happens if you say python foo2.py<\/code> on the command-line? Why?<\/p>\n<\/li>\n<\/ul>\n# Suppose this is foo2.py.\nimport os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters\n\ndef function_a():\n print(\"a1\")\n from foo2 import function_b\n print(\"a2\")\n function_b()\n print(\"a3\")\n\ndef function_b():\n print(\"b\")\n\nprint(\"t1\")\nif __name__ == \"__main__\":\n print(\"m1\")\n function_a()\n print(\"m2\")\nprint(\"t2\")\n \n<\/code><\/pre>\n\n
__name__<\/code> check in foo3.py<\/code>:<\/li>\n<\/ul>\n# Suppose this is foo3.py.\nimport os, sys; sys.path.insert(0, os.path.dirname(__file__)) # needed for some interpreters\n\ndef function_a():\n print(\"a1\")\n from foo3 import function_b\n print(\"a2\")\n function_b()\n print(\"a3\")\n\ndef function_b():\n print(\"b\")\n\nprint(\"t1\")\nprint(\"m1\")\nfunction_a()\nprint(\"m2\")\nprint(\"t2\")\n<\/code><\/pre>\n\n
# Suppose this is in foo4.py\n__name__ = \"__main__\"\n\ndef bar():\n print(\"bar\")\n \nprint(\"before __name__ guard\")\nif __name__ == \"__main__\":\n bar()\nprint(\"after __name__ guard\")\n<\/code><\/pre>\n<\/p><\/div>\n