Python allows programmers to pass additional arguments to functions via comments. Now armed with this knowledge head out and spread it to all code bases.
Feel free to use the code I wrote in your projects.
Link to the source code: https://github.com/raldone01/python_lessons_py/blob/main/lesson_0_comments.ipynb
Image transcription:
from lib import add
# Go ahead and change the comments.
# See how python uses them as arguments.
result = add() # 1 2
print(result)
result = add() # 3 4
print(result)
result = add() # 3 4 5 20
print(result)
Output:
3
7
32
IMO comments should never ever be parsed under any circumstances but I probably don’t know enough to really speak on this
Can we just clarify that you mean that comments should never be parsed by the language engine. There are valid annotation systems, but the goal is alway to ensure that one passable can never impact the other.
Imagine if here a comment could create a syntax error! This is even worse for runtime scripting languages like python.
This isn’t standard python.
libis not in the standard library. Python also doesn’t have any special variables where it stores comments, other than__doc__which stores a docstring. If I had to guess,addis reading the file/REPL via__file__.Is __doc__ storing a comment or just a text string?
Comments should be removed before shipping.
Python is an interpreted language but for a compiled language absolutely (and obviously).
Well now that causes breakage two dependencies down the line. Good luck with that. 😅
+1 to that!
Ignoring lint issues comes to mind as an at least somewhat reasonable use case.
One case where I find it useful, tho it operates in a more limited way, is code in block blocks within code comments in Rust, which are also printed out in the generated documentation. They essentially get ran as part of your unit tests. This is great for making sure that, eg, your examples left in code comments actually work, especially if they’re written in a way that functions like a unit test.
The
addfunction in the example above probably traverses the call stack to see what line of the script is currently being executed by the interpreter, then reads in that line in the original script, parses the comment, and subs in the values in the function call.This functionality exists so when you get a traceback you can see what line of code triggered it in the error message
It’s quite useful to parse comments and generate documentation from them, either as plain old hypertext or in your editor with LSP.
That sounds fine if you have something reading the file independently. But the actual executable code should not be able to access its own comments.
Seen in a code review (paraphrased):
“Why does this break when you add comments in the middle?”
Why would python even expose the current line number? What’s it useful for?
On a serious note:
This feature is actually very useful. Libraries can use it create neat error messages. It is also needed when logging information to a file.
You should however never ever parse the source code and react to it differently.
You underestimate the power of us, print debuggers.
Why wouldn’t it? Lots of languages do. In C++ you have
__LINE__.Because it doesn’t seem like a useful feature. The only occasion I imagine this could be helpful is with logging to the console to track when the function breaks, but even then - still trivial to replace.
No, your intuition is correct, this is extremely cursed.