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
  • drathvedro@lemm.ee
    8·
    7 hours ago

    I hate this shit being routinely used in PHP. Symfony uses those functional comments for routing, essentially scanning every controller file as text on every visit, to gather the url patterns above functions. Laravel uses Reflection, which is functionally the same thing, to provide arguments to controller functions. Also, kind of related, the project I’m working now has few functions that use backtrace to return different results based on where they are called from. It is indeed very cursed and I’m ripping out any usages of them whenever I see one.

    • piccolo@sh.itjust.works
      1·
      15 minutes ago

      Comment Annotations were a nessecary thing as php did not support a native way to do it. However, since php 8, there is now native attributes.

  • HStone32@lemmy.world
    331·
    23 hours ago

    This is an affront to nature. Comments shouldn’t even make it past the scanner.

  • would_be_appreciated@lemmy.mlEnglish
    52·
    2 days ago

    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.

    • Swedneck@discuss.tchncs.de
      23·
      21 hours ago

      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

  • bdonvr@thelemmy.club
    61·
    2 days ago

    IMO comments should never ever be parsed under any circumstances but I probably don’t know enough to really speak on this

    • jaxxed@lemmy.world
      3·
      3 hours ago

      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.

    • Artyom@lemm.ee
      6·
      17 hours ago

      This isn’t standard python. lib is 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, add is reading the file/REPL via __file__.

        • Artyom@lemm.ee
          1·
          37 minutes ago

          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.

      • lud@lemm.ee
        3·
        20 hours ago

        Python is an interpreted language but for a compiled language absolutely (and obviously).

        • raldone01@lemmy.worldOP
          17·
          2 days ago

          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.

          • ddplf@szmer.info
            12·
            2 days ago

            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.

    • bjorney@lemmy.ca
      6·
      2 days ago

      The add function 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

    • balsoft@lemmy.ml
      0·
      2 days ago

      It’s quite useful to parse comments and generate documentation from them, either as plain old hypertext or in your editor with LSP.

      • ramble81@lemm.ee
        3·
        2 days ago

        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.

        • kchr@lemmy.sdf.org
          1·
          3 hours ago

          Comments aren’t normally accessible unless you (independently) open and read the source code file as you would with any arbitrary file.

    • ByteOnBikes@slrpnk.net
      4·
      3 hours ago

      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”

    • OsrsNeedsF2P@lemmy.ml
      11·
      2 days ago

      Yup, the function actually goes and finds the code that calls it and parses the comment.

      Disgusting.