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/v2.0.0/lesson_0_comments.ipynb
Image transcription:
# First we have to import comment_arguments from arglib
# Sadly arglib is not yet a standard library.
from arglib import comment_arguments
def add(*args, **kwargs):
c_args, c_kwargs = comment_arguments()
return sum([int(i) for i in args + c_args])
# Go ahead and change the comments.
# See how they are used as arguments.
result = add() # 1, 2
print(result)
# comment arguments can be combined with normal function arguments
result = add(1, 2) # 3, 4
print(result)
Output:
3
10
This is version v2.0.0 of the post: https://github.com/raldone01/python_lessons_py/tree/v2.0.0
Note:
v1.0.0 of the post can be found here: https://github.com/raldone01/python_lessons_py/tree/v1.0.0
Choosing lib as the name for my module was a bit devious.
I did it because I thought if I am creating something cursed why not go all the way?
Regarding misinformation:
I thought simply posting this in programmer humor was enough. Anyways, the techniques shown here are not yet regarded best practice. Decide carefully if you want to apply the shown concepts in your own code bases.
You must log in or register to comment.
IMO comments should never ever be parsed under any circumstances but I probably don’t know enough to really speak on this
No, your intuition is correct, this is extremely cursed.
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.
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
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.
Sure, but let’s just clarify that this is someone going out of their way to create this problem, using Python’s ability to read it’s own code.
Basically, you can load any text file, including a source code file, and do whatever you want with it.
So, a function can be written that finds out whatever’s calling it, reads that file, parses the comments, and uses them as values. This can also be done with introspection, using the same mechanism that displays tracebacks.
Conveniently Python keeps the comments around. 😄
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?
It’s a string, although sometimes Python conflates the two. The recommended way to make a multi-line comment is to just make a multi-line string and just don’t use it.
Comments should be removed before shipping.
Python is an interpreted language but for a compiled language absolutely (and obviously).
I guess there could be just a script before deployment.
Well now that causes breakage two dependencies down the line. Good luck with 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.
+1 to that!
Some languages use the comments to generate documentation. Something like
// function to add two numbers func Add(num1 int, num2 int)
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.
Comments aren’t normally accessible unless you (independently) open and read the source code file as you would with any arbitrary file.
capability is fine. Conflation is stupid. You can also use code to erase itself, but thinking that’s a good idea is generally wrong. But to remove that, you also remove the general ability to erase files.
That’s disgusting
checks the community to make sure I’m in programmer humor
Yeah that checks out
You know that this is acutally working right??? 😊
Yup, just one of those posts that could of course work in either
I fucking hate this, thanks OP
How do I delete this part of the python documentation?
Thank you, I hate it
I assume the people freaking out about how dumb python is didn’t bother to read the code and have never coded in python in their life, because the behavior here is totally reasonable. Python doesn’t parse comments normally, which is what you’d expect, but if you tell it to read the raw source code and then parse the raw source code for the comments specifically, of course it does.
You would never, ever accidentally do this.
…you’d also never, ever do it on purpose.
yeah frankly this post is borderline misinformation, they specifically import a library to read comments as arguments, it’s like redefining keywords in C and complaining about C being dumb
I’m going to say it just is misinformation, if that’s what “lib” is here.
Yeah. ‘lib’ isn’t a standard Python library, it’s the name of the abomination that this person created. Since python has quite a bit of useful introspection, they can do something like:
- get the stack
- find the exact call to
abomination.add() - reparse the text of that line, turn the text of the comment into actual numbers, and add them
Now, I don’t know if python keeps the comments around, so it may involve getting the filename and line number, reading the file, and manually extracting the comment text from that line.
It’s not even actually called lib. The line just straight up isn’t in the image “transcribed”, and it’s
from arglib import comment_argumentsin the original code.Yeah, I gave this one a downvote.
I updated the source after this post was made. The image transcription still holds. I did not update the image and the post text.
You can view the git history. I will tag the specific commit at the time of the post later and update it accordingly.
Ah, and you’re the author. That kind of changes the whole context here.
It doesn’t mean much, but have your upvote back.
Implementation of the
add()function is here: https://github.com/raldone01/python_lessons_py/blob/main/lib.pyYup, the function actually goes and finds the code that calls it and parses the comment.
Disgusting.
It is now directly in the notebook in the latest version: https://github.com/raldone01/python_lessons_py/blob/v2.0.0/lesson_0_comments.ipynb
This does not actually work, right? Right?
The
add()function (that is available in the source code) basically uses some built in debugging tools to find out where in the code the function is called, and then parses the comment from the file and uses it for adding stuff.I’ve never tried (becuse why would you…) but something similar can probably be built in any interpreted language
It’s not something Python does by design
Thanks :) ! Could you tell me what use case/purpose such function can have from a dev perspective?
This stuff is normally used for creating human readable error messages. E.g. printing the line of your code that actually set off the exception
This specific use case? To make a meme, mainly ¯\(ツ)/¯
As for the components: Parsing comments have been used for stuff like type hints / formatting / linting, tho generally not at run time (afaik).
The tooling for finding out where something is called from can be used to give a better understanding of where things go wrong when an exception happens or similar, to add to logs.
I would say that in general you don’t need either functionality except for certain edge-usecases
Thank you ! 😄
I’d say nothing that can’t be achieved by docstrings.
We actually use method comments for user documentation as well. Only on specific business methods, but it’s nice to have a good comment for the dev and a tooltip for the user at the same time.
Anakin:
Anakin:
It does workI know it at least partially worksclass add: count = 0 def __init__(self): add.count += 1 self.value = add.count def __str__(self): if self.value == 1: return "3" elif self.value == 2: return "7" else: return "32" result = add() # 1 2 print(result) result = add() # 3 4 print(result) result = add() # 3 4 5 20 print(result)they have to import a separate library to do this, it’s not a part of standard python, and this post is basically just misinformation
Every day further from god’s light etc…
This is some javascript level shit
It’s actually kind of nice to see this as a JS developer.
Not like, “Oh wow this is neat!”
But like, “Finally the golden child, Python, also has some fucked up shit”
They chose violence.
This is an affront to nature. Comments shouldn’t even make it past the scanner.
This is heresy.
As if I needed more reasons to start away from python
You can so stupid shit in any language. I admit Python doesn’t exactly make it difficult. A bit like JS, but different.
Do you stay away from C++ too? You can do this there too
https://en.cppreference.com/w/cpp/utility/source_location/line
Being able to get the line number is very different from comments being parsed.
Edit: didn’t realize this was custom code built to be cursed.
You should look at how OPs example works first maybe
The python interpreter isn’t parsing comments, the add() function is just getting the current line number from the call stack context, and using a regex to spit out the numbers to the right of the “#” on the current executing line of the source code.
Yeah fair I was just assuming this was standard library, I see your point now.
I feel sick
