Are line continuations needed?

[Russell Wallace]

Hi all,

Python lets you continue a single logical line across more than one
physical line, either by putting a \ at the end or letting it happen
automatically with an incomplete infix operator.

I'm wondering how often is this feature needed? Would there be any
problems if it weren't part of the language?

 

[Derek Thomson]

Hi all,

Python lets you continue a single logical line across more than one
physical line, either by putting a \ at the end or letting it happen
automatically with an incomplete infix operator.

I'm wondering how often is this feature needed? Would there be any
problems if it weren't part of the language?

I just needed to use this a few minutes ago, in a class declaration ...

class ParticleDistributionBehaviorServer \
(Microphysics__POA.ParticleDistributionBehavior):

I had to split the line to fit within 80 columns, and without the '\'
character I get the following error:

=====
$ python scoping_server.py --POA
File "scoping_server.py", line 8
class ParticleDistributionBehaviorServer
^
SyntaxError: invalid syntax
=====

So the fact that you don't need it in the case of incomplete expressions
eliminates *most* of the need for it, but there are still a few cases
where it is required.

Regards,
Derek.

 

[John Roth]

I just needed to use this a few minutes ago, in a class declaration ...

class ParticleDistributionBehaviorServer \
(Microphysics__POA.ParticleDistributionBehavior):

I had to split the line to fit within 80 columns, and without the '\'
character I get the following error:

=====
$ python scoping_server.py --POA
File "scoping_server.py", line 8
class ParticleDistributionBehaviorServer
^
SyntaxError: invalid syntax
=====

So the fact that you don't need it in the case of incomplete expressions
eliminates *most* of the need for it, but there are still a few cases
where it is required.

Technically, you could have split it at the period, but that
might be even worse in terms of readability.

BTW - why did it have to fit in 80 columns?

John Roth

 

[Mark Jackson]

I just needed to use this a few minutes ago, in a class declaration ...

class ParticleDistributionBehaviorServer \
(Microphysics__POA.ParticleDistributionBehavior):

I had to split the line to fit within 80 columns, and without the '\'
character I get the following error:

=====
$ python scoping_server.py --POA
File "scoping_server.py", line 8
class ParticleDistributionBehaviorServer
^
SyntaxError: invalid syntax
=====

This ought to work:

class ParticleDistributionBehaviorServer(
Microphysics__POA.ParticleDistributionBehavior):

 

[Derek Thomson]

>>
class ParticleDistributionBehaviorServer \
(Microphysics__POA.ParticleDistributionBehavior):

>> [snip]

So the fact that you don't need it in the case of incomplete expressions
eliminates *most* of the need for it, but there are still a few cases
where it is required.

Technically, you could have split it at the period, but that
might be even worse in terms of readability.

I didn't know that, but yes, it would be ugly.

BTW - why did it have to fit in 80 columns?

Because that's our coding standard. But it wouldn't matter if it was 120
columns, or in fact any number you specify - I can still construct an
example that won't work.

Regards,
Derek.

 

[Derek Thomson]

This ought to work:

class ParticleDistributionBehaviorServer(
Microphysics__POA.ParticleDistributionBehavior):

In fact it does work - I should have thought of that. I've just checked
in the change to CVS. Thanks!

Now I'll have to think of another case ... I'm sure there was another ...

Regards,
Derek.

 

[Peter Maas]

Python lets you continue a single logical line across more than one
physical line, either by putting a \ at the end or letting it happen
automatically with an incomplete infix operator.

I'm wondering how often is this feature needed? Would there be any
problems if it weren't part of the language?

Just had this example:

d = { 'key1' : 'A very very long string of several hundred '\
'characters. I could use a multi-line string but '\
'then either left white space would be part of the '\
'string or I would have to align it at column 0 '\
'(ugly). I could embed it into a pair of brackets '\
'but I see no advantage over \\. Finally I could '\
'put this string on a single line (also ugly and hard '\
'to read).'
...
}


Mit freundlichen Gruessen,

Peter Maas

 

[Peter Otten]

Just had this example:

d = { 'key1' : 'A very very long string of several hundred '\
'characters. I could use a multi-line string but '\
'then either left white space would be part of the '\
'string or I would have to align it at column 0 '\
'(ugly). I could embed it into a pair of brackets '\
'but I see no advantage over \\. Finally I could '\
'put this string on a single line (also ugly and hard '\
'to read).'
...
}

.... "what do you "
.... "think of this?"}

Peter

 

[David Bolen]

Just had this example:

d = { 'key1' : 'A very very long string of several hundred '\
'characters. I could use a multi-line string but '\
'then either left white space would be part of the '\
'string or I would have to align it at column 0 '\
'(ugly). I could embed it into a pair of brackets '\
'but I see no advantage over \\. Finally I could '\
'put this string on a single line (also ugly and hard '\
'to read).'
...
}

Actually that's unnecessary since you are already in a braced
expression from the dictionary constructor. So the lines are
implicitly continuation lines until you close the dictionary, and the
compilers combination of adjacent string constants still works. You
can drop the continuation characters and it'll give the same
dictionary.

I tend to construct parenthetical expressions if I can to avoid the
explicit line continuation character - mostly since I think it looks
nicer, but there are some cases where I prefer the contination.
There's normally an alternative to the continuation, but one that I
don't consider as readable.

For example, one place where I've used line continuations was in
explicit from imports, such as:

from some.package.exceptions import ExceptionName, OtherName, \
AnotherName, AndAnotherName

where I find this more readable than repeating the "from <package>
import" portion of the line multiple times.

I also use it to suppress leading newlines in triple quoted strings,
while permitting me to write the entire string at the same indent
level, e.g.:

MSG = """\
blah blah blah

and some more blah blah blah
"""

I'll also use it sometimes for string formatting operations (either
standalone or as part of print) where sometimes I think it looks nicer
than putting the entire expression in parenthesis), e.g.:

some_variable = 'This is a formatting string args %s %s %s' % \
(argument1, argument2, argument3)


-- David

 

[Christopher Koppler]

Hi all,

Python lets you continue a single logical line across more than one
physical line, either by putting a \ at the end or letting it happen
automatically with an incomplete infix operator.

I'm wondering how often is this feature needed? Would there be any
problems if it weren't part of the language?

I don't have any ready examples, but I do occasionally need it, if
only for readability porpoises, or more often to fit a line to a
certain length limit. If a parenthetical expression will work, and
doesn't look stranger (really can't think of a case), I'll use that.

But problems there'll surely be - with legacy code compatibility.

Not really it isn't ;-)

 

[Russell Wallace]

I don't have any ready examples, but I do occasionally need it, if
only for readability porpoises, or more often to fit a line to a
certain length limit. If a parenthetical expression will work, and
doesn't look stranger (really can't think of a case), I'll use that.

Okay, thanks.

But problems there'll surely be - with legacy code compatibility.

*nod* I was more asking whether it was a good idea to include it
originally than whether it could be removed now, though I suppose
since 3.0 is supposed to be breaking with backward compatibility,
there's the question of whether it should be retained there.

Not really it isn't ;-)

^.^

 

[Heather Coppersmith]

On Wed, 07 Apr 2004 14:05:29 GMT,

Python lets you continue a single logical line across more than
one physical line, either by putting a \ at the end or letting
it happen automatically with an incomplete infix operator.

I'm wondering how often is this feature needed? Would there be
any problems if it weren't part of the language?

Completely contrived:

if a == b or b == c or c == d or d == e or e == f or f == g ....

No, I can't imagine this sort of thing actually coming up, and
yes, it's "fixable" with some extra parenthesese:

if (a == b or b == c or c == d) or (d == e or e == f
or f == g ....

Regards,
Heather

 

[Jeff Epler]

I would not miss \-continuations much.

I think you're mistaken about continuations "automatically with an
incomplete infix operator": File "<stdin>", line 1
1 +
^
Did I misunderstand what you meant?

I would sorely miss lines continued due to the presence of nesting
expressions, like
d = {
'x': 1,
'y': 2
}
and
if (x == 3
and y == x * 4):
return True
These kinds of continued lines are IMO easier to get right than
\-continuations, because those rely on absence of whitespace in a place
where the presence rarely makes a visible difference (backslash space
newline is not a continuation).

Jeff

 

[Peter Maas]

d = { 'key1' : 'A very very long string of several hundred '\
'characters. I could use a multi-line string but '\ [...]

d = {1: "Hi Peter, "

... "what do you "
... "think of this?"}

You got me I know implicit line continuation but thought that
it applies only to cases where the strings are direct elements of
the bracket like in ["s1", "s2"]. OK, then my example should read

s = 'A very very long string of several hundred '\
'characters. I could use a multi-line string but '\
[...]

If there are more than three lines you will type less with a
pair of brackets.

Mit freundlichen Gruessen,

Peter Maas