Python needs an actual default function
-
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.
-
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 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?
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.
️ -
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?
wrote on last edited by [email protected]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. -
Can you elaborate on this blood magic?
wrote on last edited by [email protected]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.
-
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. -
Alternative: put entry point code in file
__main__.py& run the containing package (eg,some_package) as a top-level expression (eg,python -m some_package).TIL. Thanks for that!
-
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.
-
How do you feel about other peoples Go code?
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.
-
Go code is always an abomination.
Succinctly and well put.
-
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 point of the name==main logic is that it checks if that is the file that was invoked (like running
python filename.py). If you just put a main() in the global scope it will be called either when the file is invoked or loaded (which can cause unintended consequences).Dumb person question: if it's good practice to do this so things don't go sideways, shouldn't it be a built-in feature/utility/function/whatever?
-
Your ld.so contains:Entry point address: 0x1d780EDIT: ...with which I meant, modulo brainfart: My
libc.so.6contains a proper entry address, while other libraries are pointing at0x0and coredump when executed.libc.sois a linker script, presumably because GNU compulsively overcomplicates everything....I guess that's enough for the kernel. It might be a linux-only thing, maybe even unintended and well linux doesn't break userspace.
Speaking of, I was playing it a bit fast and loose:
_startis merely the default symbol name for the entry label, I'm sure nasm and/or ld have ways to set it to something different.wrote on last edited by [email protected]Btw,
ld.sois a symlink told-linux-x86-64.so.2at least on my system. It is an statically linked executable. Theld.sois, in simpler words, an interpreter for the ELF format and you can run it:ld.so --helpEntry point address: 0x1d780
Which seems to be contained in the only executable
sectionsegment ofld.soLOAD 0x0000000000001000 0x0000000000001000 0x0000000000001000 0x0000000000028bb5 0x0000000000028bb5 R E 0x1000Edit: My understanding of this quite shallow; the above is a segment that in this case contains the entirety of the
.textsection. -
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.
-
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.
-
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. -
Can someone explain to me how to compile a C library with "main" and a program with main? How does executing a program actually work? It has an executable flag, but what actually happens in the OS when it encounters a file with an executable file? How does it know to execute "main"? Is it possible to have a library that can be called and also executed like a program?
There are a lot of other helpful replies in this thread, so I won't add much, but I did find this reference, which you could read if you have a lot of free time. But I particularly liked reading this summary:
- _start calls the libc __libc_start_main;
- __libc_start_main calls the executable __libc_csu_init (statically-linked part of the libc);
- __libc_csu_init calls the executable constructors (and other initialisatios);
- __libc_start_main calls the executable main();
- __libc_start_main calls the executable exit().
-
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. -
Dumb person question: if it's good practice to do this so things don't go sideways, shouldn't it be a built-in feature/utility/function/whatever?
wrote on last edited by [email protected]It is "built-in" as the name is part of python. However, Python runs top to bottom, rather than having a special entrypoint. So name is just a utility you can use in your design.
While it can be a good practice to define a main entrypoint, that's more of a design decision and not hard rule. Many applications would not benefit from it because there is only one way to actually call the application to begin with.
Edit: Also not a dumb question. All programming languages have unique elements to them due to how they were envisioned and or developed over time (Pythons 30 years old)
