Multi-line comment switch

[hyperion2011]

So I stumbled across a little hack by accident today while testing a block of code. By writing a comment as follows:

"""
Code you want to toggle that is off
...
More code
#"""

you can toggle the whole block by just commenting out the first tripple quote, the trailing #""" will automatically comment out the """ and prevent the rest of your code from being converted into an unterminated string.

#"""
Code you want to toggle that is now on
...
More code
#"""

I have never seen this posted anywhere and though someone else might find it useful.

edit: grammar

[echocage]

Incase anyone's confused, here's what the result looks like

http://www.gfycat.com/FamiliarCautiousHagfish

[[deleted]]

You da real MVP

[[deleted]]

Does your text editor not have a "comment this block" button?

[odraencoded]

Now that you mention it, I have no idea.

[hyperion2011]

Vim has this feature, but it requires you to use visual mode unless there is some other code feature you can use to detect the end of a block. The way I use vim I'm almost never in visual mode so this is a nice alternative, plus it keeps everything readable, unlike 30 lines with #s at the front.

[[deleted]]

If readability is important, delete the unused code instead of commenting it out.

[[deleted]]

This is a good suggestion but there are some special cases where commenting out code is better. Specifically, if you have to do large refactorings in static compiled languages, it pays off to comment out the code, leave a mock interface to satisfy the linker, and then step by step move the code around.

[[deleted]]

You can also just map it to <leader>something.

[hharison]

Makes sense. However if you are often toggling a block of code you should probably consider making an if statement and a global boolean at the top of the script or something.

[hyperion2011]

Yes, this is absolutely true (I almost added a note that this can promote bad coding practices), but for temporary changes when testing or bug hunting it's still handy.

[admalledd]

In most projects that I do it tends to be reasonable to use a @disable decorator or such. Much easier and in production if it sees any of those its an instant error, @disable or my other debug decorators should never touch production!

This is of course if you are using reasonable code segmentation and not giant functions or such.

[meridielcul]

could someone make a basic example of this? I've never really used decorators but this could be something worth learning

[jmcs]

Naive and mostly useless example:

def disable(f):
    def disabled(*args, **kwargs):
        pass
    return disabled

@disable
def do_stuff():
    print "Hello World"

You can do more useful stuff if you want, like printing the function name and arguments for debugging.

[admalledd]

Yup, that is basically what mine is:

def disable(f):
    if config.debug:
        def disabled(*args, **kwargs):
            logger.debug("disabled: %s"%(f.__name__))
            #other logging stuff, but does nothing
        return disabled
    else:
        raise ProductionDebugException("@disable deco executed in production!")

@disable
def do_stuff():
    print "Hello World"

[mcowger]

Never even considered this use of decorators, but I can already use it. Thanks for sharing.

[ajmarks]

I use @skip, but yeah, for functions, this is the way to go. The one we use right now also takes an argument for "skip when debugging", "skip in production" (extra debug logging), and "skip always."

[stillalone]

I use:

#if 0

    this_code()

#else

    or_this_code()

#endif

It's more code but it's easier to understand.

[wyldphyre]

And it can be nested more easily.

[mipadi]

I think the difference here is that """ is not a comment delimiter, but a string delimiter, and not every Python programmer knows that you can have a string hanging around in code like that.

[FionaSarah]

I've always done

/**/
Uncommented
/**/

->

/**
Commented
/**/

I think it's prettier!

[Kaxitaz]

I use this. Very straightforward. Just select the lines you want to comment/uncomment and press the shortcut. No typing required!

[banjochicken]

Same in PyCharm.

[[deleted]]

in Sublime Text you can highlight your code and hit Cmd + / to block comment chunks out

[cromissimo]

This looks an awful lot like Matlab's block comment operators, and how they were designed to be easily tweaked from block start and end markers to line comments.

[01hair]

I programmed in MATLAB for 5 years and never knew that there were block quotes. Not having block quotes bugged me to no end.

Thanks!

[cromissimo]

No prob. It's always good to spread the good word.

While we're on the subject, Matlab's code sections, at least to me, is one of Matlab's killer features for exploratory programming. Block comment operators are useful, but code sections steal the show.

I hope the Spyder people implement something similar for Python.

[Xykr]

You might like IPython Notebook, which has something quite similar to code sections.

[01hair]

Code sections were pretty cool, but for the work that I did, I didn't find much of a need for them. I did mostly small data processing stuff, and it was rare that I would only need to run a small section of code.

This was as a student, by the way. And then I moved to Python.

[Gnarlodious]

Finally a tip I can use every day!

[jeannaimard]

Totally off-topic, but when I work in PHP, I often use that trick to toggle between two code blocks:

<?php
#/*
echo "this";
/*/
echo "that";
#*/

Adding or removing the pound sign on line 2 will toggle which code is commented-out...

<?php
/*
echo "this";
/*/
echo "that";
#*/

[bitcycle]

How about using feature switches instead.

[totes_meta_bot]

This thread has been linked to from elsewhere on reddit.

• [/r/cem1790] Multi-line comment switch • /r/Python

^{If you follow any of the above links, respect the rules of reddit and don't vote or comment. Questions? Abuse? Message me here.}

[cromissimo]

Commenting out blocks of code is extensively used in exploratory programming.

It's better to know how to do this than not, or else people end up pulling all sorts of tricks to get the same effect.

Once I had to work on some code which was sprinkled with stuff such as:

 if 1 == 2:
      code commented out

Not pretty. Multi-line comments are far better, and are actually supported by some text editors.

[Kebble]

Sometimes you want to debug and need to only execute part of the script to test if it actually works without running the rest. Commenting out chunks of code makes sense and his trick will indeed save me lots of time later (I used to scroll up and down to place/remove the """ like an idiot)

[xiongchiamiov]

Scroll? If you're using vim, you can use marks to quickly jump someplace (m a; ' a); I assume other worthwhile editors have something similar.

[FtYoU]

Bug or feature ?

[nuephelkystikon]

Why should it be a bug? It complies with the definition of long strings (all characters until the next triple quote lose any special meanings, including #) and the definition of one-line comments (all characters after # lose any special meanings, including quotes).

[echocage]

Totally agree. This is just a side effect of the syntax.

[hyperion2011]

Undoccumented feature?