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?

--
"Sore wa himitsu desu."
To reply by email, remove
the small snack from address.
http://www.esatclear.ie/~rwallace

[Derek Thomson]

Russell Wallace wrote:

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]

"Derek Thomson" <de***@hiredgoons.org> wrote in message
news:40******@duster.adelaide.on.net...

Russell Wallace wrote:

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.

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
Regards,
Derek.

[Mark Jackson]

Derek Thomson <de***@hiredgoons.org> writes:

Russell Wallace wrote:

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
=====

This ought to work:

class ParticleDistributionBehaviorServer(
Microphysics__POA.ParticleDistributionBehavior):

--
Mark Jackson - http://www.alumni.caltech.edu/~mjackson
Hate to interrupt with a spelling flame, but it's "Cheney,"
not "Chaney." It may only be one letter, but it's 998 faces.
- Mike Peterson

[Derek Thomson]

John Roth wrote:

Derek Thomson wrote:

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]

Mark Jackson wrote:

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]

Russell Wallace wrote:

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 Maas, M+R Infosysteme, D-52070 Aachen, Hubert-Wienen-Str. 24
Tel [phone] Fax [phone] eMail pe********@mplusr.de
-------------------------------------------------------------------

[Peter Otten]

Peter Maas wrote:

Russell Wallace wrote:

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).'
...
}

d = {1: "Hi Peter, "

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

Peter

[David Bolen]

Peter Maas <pe********@mplusr.de> writes:

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]

On Wed, 07 Apr 2004 14:05:29 GMT, wa**************@eircom.net (Russell
Wallace) wrote:

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.

--
"Sore wa himitsu desu."

Not really it isn't ;-)

--
Christopher

[Russell Wallace]

On Wed, 07 Apr 2004 17:53:00 GMT, Christopher Koppler
<kl******@chello.at> wrote:

On Wed, 07 Apr 2004 14:05:29 GMT, wa**************@eircom.net (Russell
Wallace) wrote:

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 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 ;-)

^.^

--
"Sore wa himitsu desu."
To reply by email, remove
the small snack from address.
http://www.esatclear.ie/~rwallace

[Heather Coppersmith]

On Wed, 07 Apr 2004 14:05:29 GMT,
wa**************@eircom.net (Russell Wallace) wrote:

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

--
Heather Coppersmith
That's not right; that's not even wrong. -- Wolfgang Pauli