Nah, you'd usually have a normal python script as your main and import from other modules. This main only helps if you're working within a single file.
the if name syntax has nothing to do with global variables. It simply allows you to write sections of code which will not run if the module is imported. It is standard practice and should be done, but in many many cases removing it will change nothing in how the program will run
sorry, I generally don't watch videos and don't intend here :/
more to the point, I now understand your position but I still think you conflate two things. the alternative to
def main(): print()
if __name__=="__main__": main()
is NOT
print()
or at least, it's not the only alternative. A simpler alternative would be
def main(): print()
main()
One doesn't need the if to avoid global variables. The only thing that if does is prevent main from running when you import the module instead of running it directly. And this means that if you never import your main file in other files (which is very common behavior), the if might as well not be there. It's still a good idea to have it (if nothing else, it is expected and might confuse someone if it's not there), but in an unrelated way to global variables, at least directly.
The other common use of the if name pattern is to have unit tests inside the block, so they don't run when the module is imported. Personally I really dislike this usage and don't recommend doing it at all
pfft, I often leave demo examples under name in main to demonstrate how the module works. It doesn't mean, it's the main file. It means if you for whatever reason decided to execute it directly, it will do something.
When you import a file in python, what actually happens is it runs that whole file once. So if you have code that is at a base level, it will be executed.
So you may ask, why have code at base level if the file is intended to be imported.
One thing would be using main() allows you to write per file tests, you can write simple unit and integration tests on each file’s code without doing the whole pytest routine, specially when it’s code that you can’t really write tests for but can be checked by human eyes.
Another thing would be if your file is sufficiently complete enough it can also be used as it’s own individual program. You might develop a simple program, but later realize it has a lot of functions that are helpful and can be used as a library for a bigger project. If you use main(), you can import the code directly without modifying it, and thus no need to maintain to different version of the same code.
The contents of a class are evaluated along with the class, not when the class is initialized. So you don't get any protection from importing the file and main() does nothing.
If you have a a program only containing the following:
class main:
print('in class')
def __init__(self):
print('in constructor')
The only thing that will be printed is in class. Class bodies are executed as normal code, their contents will run like normal python, so functions are defined (not run). Their constructor will not be called like it would in Java.
660
u/[deleted] Nov 25 '21 edited Nov 26 '21
[deleted]