- cross-posted to:
- programmerhumor@lemmy.ml
- cross-posted to:
- programmerhumor@lemmy.ml
Also, do y’all call main() in the if block or do you just put the code you want to run in the if block?
You must log in or register to comment.
Depends on how lazy I am at the moment.
main.pyor did you not read the manual?The if block is where my arg parser goes
Does everyone call the function of the script main? I never use main(), just call the function what the program is supposed to do, this program calculates the IBNR? The function is called calculate_IBNR(), then at the end of the script if name = ‘main’: calculate_IBNR(test_params) to test de script, then is imported into a tkinter script to be converter to an exe with pyinstaller
I would put my code in a
def main(), so that the local names don’t escape into the module scope:if __name__ == '__main__': def main(): print('/s') main()(I didn’t see this one yet here.)
I’m a little new to Python standards. Is this better or worse than putting the
def main():outside the if statement (but callingmain()inside it)I intended this an sarcastic example; I think it’s worse than putting the main outside of the branch because of the extra indent-level. It does have an upside that the
main()doesn’t exist if you try import this as an module.I thought confusion about indent levels was the whole point of using python
One thing I really dislike about Python is the double underscore thing, just really looks ugly to me and feels excessive. Just give me my flow control characters that aren’t whitespace
I’m at peace with balanced underscores (like “dunder name equals dunder main”) and the internal ones for snake case, but in the unbalanced ones (prefixing unders and dunders for pseudo-private) still bug me. But at least, conventionally, it’s visually the same idea as Hungarian notation.
Php says hello
It really doesn’t. It’s a scripting language, functions are there but at it’s core it runs a script. The issue is that it was so easy to start with that people started doing everything in it, even though it sucks for anything past complex scripts
It is the excel of databases.
What’s the difference between a “scripting” language and a “real” one?
A scripting language controls an existing binary. A non-scripting language is used to create a new binary.
Scripting languages are real. Generally people consider dynamic languages scripting languages but it’s not that simple.
It’s a scripting language. What means that the computer runs it line by line, without needing to get the entire project first.
That is not how Python works. There are very few languages that work by executing line-by-line anymore. Unix shell scripts are one of the few holdouts. JavaScript also does it to a certain extent; the browser starts executing line-by-line while a compiler step works in the background. Once the compiler is done, it starts execution of the compiled form right where the line-by-line execution left off. It helps JavaScript be more responsive since it doesn’t have to wait for the compiler to finish.
Unix shell scripts are one of the few holdouts.
I don’t know if this applies to other shells, but bash will not only execute your script line-by-line, it will also read it line-by-line. Which means that you can modify the behavior of a running script by editing lines that have not yet been executed*. It’s absolutely bonkers, and I’m sure that it has caused more than one system failure, during upgrades.
* For example, if you run the following script
echo "hello" sleep 5 echo "goodbye"and then edit the third line before the 5 second sleep has elapsed, then the modified line will be executed.
I have run into the problem of modifying a bash script while it is running.
Python still has the
-ioption, and it still runs the same language as the files interface.The
-ioption is simply interactive mode. All commands still go through a compiler.
I didn’t say it wasn’t real, it’s just a scripting structure and not object oriented, so it doesn’t make sense for it to start by looking for a “main” object
not object oriented
I don’t think we have a name for what you are trying to say here.
(And yeah, “object oriented” isn’t it.)
procedural programming is more akin to that, but python has far to many oop concepts to be considered procedural imo
Procedural and OOP aren’t mutually exclusive terms. Most OOP programs are ultimately procedural in nature. Often, the only difference is that the first argument to the function is to the left the function name and separated by a dot.
fair, I just think it’s misleading to call python procedural, but it lines up with what the commenter above was describing and searching for the term for
I’d say the term “procedural” itself is an issue. Pretty much any language can be done that way if you choose. IIRC, the creator of Clojure wanted Java to work more that way, and he did it by having a single class full of functions. It’s not a natural way to write Java, and that’s why he invented Clojure.
What would make it “object oriented”?
You know what, I take that back: https://docs.python.org/3.13/faq/general.html#what-is-python
Excel recently added the ability to run python code lol
compared with other languages at the time, the ease of access and readability makes it worth it. plus, the heavy duty stuff is usually handled by more optimised code line numpy or sklearn…
Readability? Me eyes bleed from a day of partially staring at python code, and there is a whole another week of that ahead. Tzinch (Edit: Tzeentch) help me
Like in every programming language, it depends who wrote the code. OK, *nearly every programming language, see: LISP.
You can write cryptic, write-only programs in about any language, but you can even write readable and maintainable PERL scripts (despite people claiming this to be impossible).
As much as I am inclined to agree with this, still can’t
see: LISP
Also, see: Python with more than three lines of logic. I could suspect that’s just the me-versus-whitespaces thing, but no, YAML files do not get me dizzy in under thirty seconds of reading. Van Rossum made a huge miscalculation here
Everyone’s welcome to their opinion of course, but I find Python more readable than anything else and I resent the visual clutter required to make intentions plain in other languages. Feels like having a conversation where people say the words “comma”, “period”, etc.
I also spend more time with Python than anything else and I suspect these two facts about me relate, lol
Someone should get their hands on someone like me and someone like you and study their brains. I spend most time with PHP and C++, and Python looks like an attempt to write code like prose literature. Very interesting how much of this is habbit, as it can’t be just that: reading prose and poetry in English/Russian/Japanese never produced this kind of resentment
Still better than having to create a new class just to implement
public static void main(String[] args) {}Relevant Fireship video: https://youtu.be/m4-HM_sCvtQ
Since Java 21, this has been shortened significantly. https://www.baeldung.com/java-21-unnamed-class-instance-main
Only took 27 years to make the Java “Hello, world!” kinda sane.
Free standing functions in Java?! This can’t be true.
I know right? It even has var with implicit typing now. While I prefer Kotlin any day, there’s been quite a few qol improvements to Java over the last few years.
Sometimes I have the misfortune of working with python code written by someone else and I wonder how a language like this became anything more than a scripting language
I feel that Python is a bit of a ‘Microsoft Word’ of languages. Your own scripts are obviously completely fine, using a sensible and pragmatic selection of the language features in a robust fashion, but everyone else’s are absurd collections of hacks that fall to pieces at the first modification.
To an extent, ‘other people’s C++ / Bash scripts’ have the same problem. I’m usually okay with ‘other people’s Java’, which to me is one of the big selling points of the language - the slight wordiness and lack of ‘really stupid shit’ makes collaboration easier.
Now, a Python script that’s more than about two pages long? That makes me question its utility. The ‘duck typing’ everywhere makes any code that you can’t ‘keep in your head’ very difficult to reason about.
How many lines are in a page?
How do you feel about other peoples Go code?
I used it for a while and I think it’s been one of the best languages I’ve tried. C for example is too barebones for modern desktop apps. Apps written in Rust are great but most of the time, it’s just not worth the effort. And stuff like Python, JS is… uhh… where do I even begin
I think Go hits the sweet spot between these. Unlike C, it at least has some simple error/panic mechanism, GC so you don’t have to worry about memory much and some modern features on top of that. And unlike Python it can actually create reasonably snappy programs.
In any programming language, there will always be multiple cases where you need to link C libraries. CGo, although people don’t seem to be adoring it, is actually… okay? I mean of course it does still have some overhead but it’s still one of the nicer ways to link C libraries with your code. And Go being similar to C makes writing bindings so much easier
Multithreading in Go is lovely. Or as I read somewhere “you merely adopted multithreading, I was born with it”
Packaging is handled pretty nicely, pulling a library from the net is fairly trivial. And the standard directory structure for Go, although I’m not used to it, makes organizing stuff much easier and is easy to adopt
As you would’ve guessed from the amount of times I mentioned C in this comment, I basically see Go as the “bigger C for different situations”
Well now. My primary exposure to Go would be using it to take first place in my company’s ‘Advent of Code’ several years ago, in order to see what it was like, after which I’ve been pleased never to have to use it again. Some of our teams have used it to provide microservices - REST APIs that do database queries, some lightweight logic, and conversion to and from JSON - and my experience of working with that is that they’ve inexplicably managed to scatter all the logic among dozens of files, for what might be done with 80 lines of Python. I suspect the problem in that case is the developers, though.
It has some good aspects - I like how easy it is to do a static build that can be deployed in a container.
The actual language itself I find fairly abominable. The lack of exceptions means that error handling is all through everything, and not necessarily any better than other modern languages. The lack of overloads means that you’ll have multiple definitions of eg.
Math.mincluttering things up. I don’t think the container classes are particularly good. The implementation of pointers seems solely implemented to let you have null pointer exceptions, it’s a pointless wart.If what you’re wanting to code is the kind of thing that Google do, in the exact same way that Google do it, and you have a team of hipsters who all know how it works, then it may be a fine choice. Otherwise I would probably recommend using something else.
This is the most excellent summary of Go I have ever read. I agree with everything you’ve said, although as a fan of Scala and in particular its asynchronous programming ecosystem (cats for me, but I’ll forgive those who prefer the walled garden of zio) I would also add that, whilst its async model with go routines is generally pretty easy to use, it can shit the bed on some highly-concurrent workloads and fail to schedule stuff in time that it really should’ve, and because it’s such a mother-knows-best language there’s fuck all you can do to give higher priority to the threads that you happen to know need more TLC
Go code is always an abomination.
Succinctly and well put.
Sounds like a skill issue on your end
Agreed. I program mainly in C so its easier for me to make sense of bad C code than bad python code which just makes me cry
Does Lua rank far below python for you? I have so much rage against it. At least with Python I don’t have to do a bunch of steps to just get it to do something. May take me a while to get through bad Python code, but Lua makes my eyes bleed and I begin to regret my life choices in trying to understand wtf these people wrote.
Python people explaining fail to see the point: Yes we know dunders exist. We just want you to say: “Yeah, that is a bit hacky, isn’t it?”
Is it? I really don’t think so. What can you propose that’s better? I think
if __name__ == __main__works perfectly fine and can’t really think of anything that would be better.And you don’t have to use it either if you don’t want to anyway, so no, I don’t think it’s that much of a hack. Especially when the comic compares C as an example, which makes no sense to me whatsoever.
Tbh reserving “main” is just a hacky if not more so than checking
__name__if you actually understand language design.Reserving
mainis definitely more hacky. Try compiling multiple objects withmaindefined into a single binary - it won’t go well. This can make a lot of testing libraries rather convoluted, since some want to write their ownmainwhile others want you to write it because require all kinds of macros or whatever.On the other hand,
if __name__ == "__main__"very gracefully supports having multiple entrypoints in a single module as well as derivative libraries.Yeah, this is it.
What’s hacky about an introspective language providing environment to all of the executing code, so that the coder can make the decision about what to do?
It would by hacky if Python decided “We’ll arbitrarily take functions named “main” and execute them for you, even though we already started execution at the top of the file.”
For C, this is less so. The body of the file isn’t being executed, it’s being read and compiled. Without a function to act as a starting point, it doesn’t get executed.
What is not hacky then in a language design?
Letting the developer decide what the code should do.
I don’t understand. What do you mean by deciding what the code should do in the context of language design? Can you give a concrete example? I am confused because the “main” function is required when you make an executable. Otherwise, a library will not contain any main function and we could compile it just fine no? (Shared library)
Python is an interpreted language that doesn’t need a main function explicitly. You can define any package entry points you want at the package config level. (setup.py, etc)
example: What I meant was I prefer language that treat developers like adults. If I want ptrhon’s “ux” to hide some functions or objects I can do that with underscores, but nothing is private, a developer using my library can do whatever they want with it, access whatever internals they want (at their own risk of course)
aren’t most of not all conventions hacky anyways?
I use if__name__main__ often when working with AWS Lambda, but I also want to run it locally. Lambda wants to call a function with the params
eventandcontext. So I would do something like this:def handler(event, context): things return { 'statusCode': 200, 'body': 'Hello from Lambda!' } if __name__ == '__main__': event = {} context = {} response = handler(event, context) print(response)Diabolical
isn’t that just normal usage? …or, did I just whoosh and you were sarcastically saying that?
It is normal usage. Though personally I’d probably make another “main” function, to avoid declaring a bunch of global variables
Yeah. I like using
main()that way too. It’s usually just a high-level function that handles globals relevant to running in standalone and calling other functions to do work.indeed.
What kind of psychopath would put the code in the if block.
you can, no one stopping you
Looks at all the Python scripts in my bin folder that I wrote.
Never heard of
def main(): pass if __name__ == '__main__': main()?
I remember how weird this looked the first time I saw it and while I may now understand it, it still looks jank af
Python: I’m so readable that I’m practically executable pseudo-code
Also Python:
if __name__ == '__main__':. . .I still wonder why.
unless it’s for something that you want to work as an importable module and a standalone tool, then why do you need that?
The main two reasons that I can think of to include this even when you have no intention of importing this as a library are:
- For unit testing you will need to import as a module.
- Sometimes I will run a python interactive interpreter and then import my script so that I can do some manual testing without needing to change my main function or if stmt.
This is exactly why the conditional is used. It allows the script to function both as a standalone application and a library.
ETA: Probably would make sense to just treat it as default behavior in the interpreter and only require the conditional to overwrite in cases where
mainis not the main function and/or pre-processing is needed.Oh that is a good point actually. It’s been a while since I have done any serious Python, so I’m not sure why you couldn’t just use convention instead of this conditional.
For my part, if a Python script is meant to be executed, then I’ll give it a shebang, drop the .py, and simply mark it as executable in the filesystem. 🤷♂️
Now think about this, you have logic that doesn’t make sense when run directly, but you need it to be a library.
You have multiple name=main statements in some of your functions
I’m not sure I’m following the implication. Name=main is for scripts primary, is it not?
I’ve never thought to add more than one of these conditionals anyway…
So you might have a script that does stuff as a library, and it should get environment variables and other info from the calling script. You use the same script for doing one off stuff on different computers.
So you make it do something slightly different or make it set it’s path and look into the current folder when you run it directly. This change in logic could be in a few points in the script.
Heard of it, was too lazy to do it that way.
To be fair I now do it that way, but not when I was learning Python.
What is the point of this?
Not having tons of code in one if statement, but in a function.
I thought you were saying to literally use
def main(): pass, that’s why I was confusedAnd scope. Variables declared in the if can be read everywhere, variables declared in the function are limited to that function.
custom bin folders are a realm no God dares to tread
I can and I do
*trollface*
I work in an academic / research environment. Depending who wrote it, even seeing a
__name__ == "__main__"is a bit of a rare thing…python isn’t the only language to do “execute everything imported from a particular file and all top level statements get run”. both node and c# (but with restrictions on where top level statements can be) can do that type of thing, I’m sure there’s more.
python conventions are unique because they attempt to make their entrypoint also importable itself without side effects. almost no one needs to do that, and I imagine the convention leaked out from the few people that did since it doesn’t hurt either.
for instance in node this is the equivalent, even though I’ve never seen someone try before:
if (path.resolve(url.fileURLToPath(import.meta.url)).includes(path.resolve(process.argv[1]))) { // main things }Academic code is absolutely horrific.
Fortunately, it is possible to translate it for practical applications.
As someone in academia who writes code, I can confirm.
Do you also have nothing but love for those 50+ cell Jupyter notebooks that don’t use a single function and have everything in the global scope?
the best thing is when not even the author knows the correct order of running the cells; because of course it isn’t top-to-bottom.
Yeah, and also zero dependency management, so you are free to figure out what combination of Python, Tensorflow and Keras will make it not throw random exceptions.
And don’t forget the number one rule: you must use all the graphing libraries, all the time.
Why would you waste a function call on something so completely redundant?
~For real though, arg parsing goes in the if, then gets dispatched to whatever function call is needed to run the proper script.~
If the file is just a class I usually put example usage with some default arguments in that block by itself. There is no reason for a “main” function. It’s a nice obvious block that doesn’t run when someone imports the class but if they’re looking at the class there is a really obvious place to see the class usage. No confusion about what “main()” is meant to do.
if __name__ == '__main__': # MyClass example Usage my_object = MyClass() my_object.my_method()I definitely do for quick scripts, but I try to break this habit. The biggest advantage of
def main()is that variables are local and not accessible to other functions defined in the same script, which can sometimes help catch bugs or typos.
I call main() in the if
I always use
if "__main__" == main: __main__()…and earlier in the code:
def __main__(): while True: pass main = "__main__"This helps to prevent people from arbitrarily running my code as a library or executable when I don’t went them to.
Can you elaborate on this blood magic?
It simply swaps some things around to make things more confusing, then goes into an infinite loop (whether or not you import or execute it standalone). it’s no different than just including in the global scope:
while True: passI was kinda lazy with the fuckery, tbh. I could have gotten much more confusing, but don’t have too much time today. :-)
Lol OK I was wondering how would this run
And yes you should!!
The
ifblock is still in the global scope, so writing the code in it is a great way to find yourself scratching your head with a weird bug 30 minutes later.
