Question

I am aware that the standard Python convention for line width is 79 characters. I know lines can be continued in a number of ways, such as automatic string concatenation, parentheses, and the backslash. What does not seem to be as clearly defined is how exactly the overflowing text should be formatted. Do I push it all the way back to col 1? To the col where the original line starts? To the start of the parentheses (if applicable)? For example, say I have something like this:

        self.someLongAttributeName = {'someLongKeyName':'someLongValueName',
                                      'anotherLongKeyName':'anotherLongValueName'}

Supposing that the format I used above would fit the 79 character limit, is the indentation of the second line correct?

Now suppose that the first line as shown above is > 79 characters. How should things look in that case?

NOTE: I know that a lot of people disagree with the 79-character convention. While I respect that there are a lot of pros and cons to each side of the issue, this debate is not relevant to my question. I am asking how to follow the convention, not whether or not I should, so please do not espouse the advantages of abandoning it in your reply. Thanks. =)

Answer 1

Supposing that the format I used above would fit the 79 character limit, is the indentation of the second line correct?

Yes, that’s how PEP 8 shows it in examples:

class Rectangle(Blob):

    def __init__(self, width, height,
                 color='black', emphasis=None, highlight=0):
        if width == 0 and height == 0 and \
           color == 'red' and emphasis == 'strong' or \
           highlight > 100:
            raise ValueError("sorry, you lose")
        if width == 0 and height == 0 and (color == 'red' or
                                           emphasis is None):
            raise ValueError("I don't think so -- values are %s, %s" %
                             (width, height))
        Blob.__init__(self, width, height,
                      color, emphasis, highlight)

But when the opening parenthesis/brace is already close to the 79th column, I usually just exploit this:

Two good reasons to break a particular rule:

(1) When applying the rule would make the code less readable, even for
    someone who is used to reading code that follows the rules.
[...]

And do something like

self.some_long_attribute_name = {
    'someLongKeyName': 'someLongValueName',
    'anotherLongKeyName': 'anotherLongValueName'
}

or

long_object_name.do_something_with_long_name(
    long_expression_returning_is_first_arg,
    long_expression_returning_is_second_arg
)