[Tutor] Readabilty vs 80 characters

Evert Rol evert.rol at gmail.com
Thu Apr 19 16:01:53 CEST 2012

On 19 Apr, 2012, at 15:29 , Tino Dai wrote:

> Hi!
>      I have a question about style. In PEP-8, it says don't exceed 79 characters, but can this rule ever be trumped by 
> readability?

Yes, it obviously can.
I am a big fan of the 79 character "rule", though. Even with screens and terminals being well over 79 characters wide these days: with the 79 character limit, I can have multiple things side by side (*without* using multiple screens).

> Eg.
>      if someobject.filter(something) \
>           .filter(somethingreallyreallyreallyreallylong == somethingelsereallyreallylong) \
>           .filter(othethingreallylongreallyreally == ternarythingreallyreallyreallylong) \
>           .filter(thirdthingreallylessreallymaybelong == thirdotherthingreallylong) \
>           .first():
>           < do something >
>       if someobject.filter(something) \
>           .filter(somethingreallyreallyreallyreallylong == \
>                somethingelsereallyreallylong) \
>           .filter(othethingreallylongreallyreally == \
>               ternarythingreallyreallyreallylong ) \
>           .filter(thirdthingreallylessreallymaybelong == \
>                thirdotherthingreallylong) \
>           .first():
>           < do something >

I would let the parenthesis do the line breaking, so not use backslashes (a hidden space after a backslash can be hard to spot).

In my case, it would become something like:

     if someobject.filter(
         somethingreallyreallyreallyreallylong ==
         othethingreallylongreallyreally ==
         thirdthingreallylessreallymaybelong ==

Of course, this isn't very readable either: the filter() function starts at the end of a line, and the comparison is broken over two lines.
Note that I've left my editor (emacs) do the indentation. It would have helped to indent the second part of the comparison just a bit.

Then again, one can (and should) ask whether somethingreallyreallyreallyreallylong is really a good name for a variable.
Occasionally, it does happen in case of dicts within dicts within list, eg mylist[counter]['somekey']['anotherkey'], but those are the cases where you would assign this to a separate (temporary) variable.

> The first example is more readable to me but violates the 80 character rule. The second is less readable, but doesn't violate
> the 80 character rule.
> Is there a guideline or convention that pythonistas follow about this style case?

Not as such, I think.
But, if lines get long or indentation gets heavy (4 or more indents), it may be good to consider two things:
- move parts to a separate function
- assign parts to a temporary variable.

In your case, the outcome of the various comparisons could be assigned to individual variables:

result1 = somethingreallyreallyreallyreallylong == somethingelsereallyreallylong
result2 = othethingreallylongreallyreally == ternarythingreallyreallyreallylong
and then the last line becomes

Or, since filter() apparently returns a new object:
results1 = someobject.filter(something)
results2 = result1.filter(somethingreallyreallyreallyreallylong == somethingelsereallyreallylong)
results3 = result2.filter(othethingreallylongreallyreally == ternarythingreallyreallyreallylong)

In both cases, you have changed the backslashes into actual separate statements.
(And yes, those lines still are longer than 79 characters, but to me it becomes more readable overall, even if you would break those individual statements.)

So, basically, when you run into something like your suggestion here, try and see another way of breaking it up then just splitting across multiple lines.



> Thanks,
> Tino
> _______________________________________________
> Tutor maillist  -  Tutor at python.org
> To unsubscribe or change subscription options:
> http://mail.python.org/mailman/listinfo/tutor

More information about the Tutor mailing list