Wrap long lines in Python

Question

How do I wrap long lines in Python without sacrificing indentation    For example    def fun        print   0  Here is a really long sentence with  1   format 3  5    Suppose this goes over the 79 character recommended limit  The way I read it  here is how to indent it   def fun        print   0  Here is a really long   sentence with  1   format 3  5    However  with this approach  the indentation of the continued line matches the indentation of the fun    This looks kinda ugly  If someone was to go through my code  it would look bad to have uneven indentation because of this print statement   How do I indent lines like this effectively without sacrificing code readability

User · Answer

There are two approaches which are not mentioned above, but both of which solve the problem in a way which complies with PEP 8 and allow you to make better use of your space. They are:

msg = (
    'This message is so long, that it requires '
    'more than {x} lines.{sep}'
    'and you may want to add more.').format(
        x=x, sep=2*'\n')
print(msg)

Notice how the parentheses are used to allow us not to add plus signs between pure strings, and spread the result over multiple lines without the need for explicit line continuation '\' (ugly and cluttered). The advantages are same with what is described below, the difference is that you can do it anywhere. Compared to the previous alternative, it is visually better when inspecting code, because it outlines the start and end of msg clearly (compare with msg += one every line, which needs one additional thinking step to deduce that those lines add to the same string - and what if you make a typo, forgetting a + on one random line ?).

Regarding this approach, many times we have to build a string using iterations and checks within the iteration body, so adding its pieces within the function call, as shown later, is not an option.

A close alternative is:

msg = 'This message is so long, that it requires '
msg += 'many lines to write, one reason for that\n'
msg += 'is that it contains numbers, like this '
msg += 'one: ' + str(x) +', which take up more space\n'
msg += 'to insert. Note how newlines are also included '
msg += 'and can be better presented in the code itself.'
print(msg)

Though the first is preferable.

The other approach is like the previous ones, though it starts the message on the line below the print. The reason for this is to gain space on the left, otherwise the print( itself "pushes" you to the right. This consumption of indentation is the inherited by the rest of the lines comprising the message, because according to PEP 8 they must align with the opening parenthesis of print above them. So if your message was already long, this way it's forced to be spread over even more lines.

Contrast:

raise TypeError('aaaaaaaaaaaaaaaa' +
                'aaaaaaaaaaaaaaaa' +
                'aaaaaaaaaaaaaaaa')

with this (suggested here):

raise TypeError(
    'aaaaaaaaaaaaaaaaaaaaaaaa' +
    'aaaaaaaaaaaaaaaaaaaaaaaa')

The line spread was reduced. Of course this last approach does no apply so much to print, because it is a short call. But it does apply to exceptions.

A variation you can have is:

raise TypeError((
    'aaaaaaaaaaaaaaaaaaaaaaaa'
    'aaaaaaaaaaaaaaaaaaaaaaaa'
    'aaaaa {x} aaaaa').format(x=x))

Notice how you don't need to have plus signs between pure strings. Also, the indentation guides the reader's eyes, no stray parentheses hanging below to the left. The replacements are very readable. In particular, such an approach makes writing code that generates code or mathematical formulas a very pleasant task.

User · Answer

I d probably split the long statement up into multiple shorter statements so that the program logic is separated from the definition of the long string    gt  gt  gt  def fun            format string     0  Here is a really long                              sentence with  1           print format string format 3  5    If the string is only just too long and you choose a short variable name then by doing this you might even avoid having to split the string    gt  gt  gt  def fun            s     0  Here is a really long sentence with  1           print s format 3  5

User · Answer

You could use the following code where indentation doesn t matter    gt  gt  gt  def fun            return    0  Here is a really long            sentence with  1    format 3  5    You just need to enclose string in the parentheses

User · Answer

You can use the fact that Python concatenates string literals which appear adjacent to each other    gt  gt  gt  def fun            print   0  Here is a really long                    sentence with  1   format 3  5

User · Answer

I m surprised no one mentioned the implicit style above   My preference is to use parens to wrap the string while lining the string lines up visually   Personally I think this looks cleaner and more compact than starting the beginning of the string on a tabbed new line   Note that these parens are not part of a method call      they re only implicit string literal concatenation   Python 2   def fun        print    0  Here is a really               long sentence with  1    format 3  5    Python 3  with parens for print function    def fun        print    0  Here is a really               long sentence with  1    format 3  5     Personally I think it s cleanest to separate concatenating the long string literal from printing it   def fun        s      0  Here is a really             long sentence with  1    format 3  5      print s

User · Answer

def fun        print    0  Here is a really long               sentence with  1    format 3  5     Adjacent string literals are concatenated at compile time  just as in C  http   docs python org reference lexical analysis html string-literal-concatenation is a good place to start for more info

[python] Wrap long lines in Python

Examples related to python

Examples related to string