Why " ".some_stri ng is often used ?

[Stéphane Ninin]

Hi all,

This is not the first time I see this way of coding in Python and
I wonder why this is coded this way:

Howto on PyXML
(http://pyxml.sourceforge.net/topics/howto/node14.html)
shows it on this function, but I saw that in many other pieces of code:

def normalize_white space(text):
"Remove redundant whitespace from a string"
return ' '.join(text.spl it())

Is there a reason to do instead of just returning join(text.split ()) ?
why concatenate " " to the string and not just returning the string instead ?

Thanks in advance for your explanations.

Regards,

--
Stephane Ninin

[Erik Max Francis]

"Stéphane Ninin" wrote:

Is there a reason to do instead of just returning join(text.split ()) ?
why concatenate " " to the string and not just returning the string
instead ?

Because they're not the same thing unless you've already done

from string import join

first. join is not a builtin function.

--
__ Erik Max Francis && ma*@alcyone.com && http://www.alcyone.com/max/
/ \ San Jose, CA, USA && 37 20 N 121 53 W && &tSftDotIotE
\__/ I get my kicks above the wasteline, sunshine
-- The American, _Chess_

[Stéphane Ninin]

Also sprach Erik Max Francis :

Is there a reason to do instead of just returning join(text.split ()) ?
why concatenate " " to the string and not just returning the string
instead ?

Because they're not the same thing unless you've already done

from string import join

first. join is not a builtin function.

Ok. Thanks.
I just realized that "." had also nothing to do with concatenation here.

[Steve Lamb]

On 2004-01-07, Erik Max Francis <ma*@alcyone.co m> wrote:

Because they're not the same thing unless you've already done

from string import join

first. join is not a builtin function.

You know, given the volumes of text Pythonistas write about Python not
falling to the Perlish trap of magic linenoise this certainly smacks of it,
don'tcha think? Wonder how this idiom slipped in. To think all this time I
have been doing:

import string
string.join()

--
Steve C. Lamb | I'm your priest, I'm your shrink, I'm your
PGP Key: 8B6E99C5 | main connection to the switchboard of souls.
-------------------------------+---------------------------------------------

[John Roth]

"Stéphane Ninin" <st************ @yahoo.fr> wrote in message
news:Xn******** *************** ***********@213 .228.0.4...

Hi all,

This is not the first time I see this way of coding in Python and
I wonder why this is coded this way:

Howto on PyXML
(http://pyxml.sourceforge.net/topics/howto/node14.html)
shows it on this function, but I saw that in many other pieces of code:

def normalize_white space(text):
"Remove redundant whitespace from a string"
return ' '.join(text.spl it())

Is there a reason to do instead of just returning join(text.split ()) ?
why concatenate " " to the string and not just returning the string instead ?

This particular idiom replaces sequences of multiple whitespace
charaters with a single blank.

And I agree, it's not entirely obvious why it's a string
method rather than a list method, since it operates on
a list, not on a string. The only explanation that makes
sense is that, as a list method, it would fail if the list
contained something other than a string. That's still
not very friendly, though.

John Roth
Thanks in advance for your explanations.

Regards,

--
Stephane Ninin

[Erik Max Francis]

John Roth wrote:

And I agree, it's not entirely obvious why it's a string
method rather than a list method, since it operates on
a list, not on a string. The only explanation that makes
sense is that, as a list method, it would fail if the list
contained something other than a string. That's still
not very friendly, though.

On the contrary, I think that's the best reason. Lists have nothing to
do with strings, and so very string-specific methods (discounting
system-wide things such as str or repr) being included in lists is not
the right approach. Furthermore, the methods associated with a list
tend to become the "pattern" that sequence types must fulfill, and it
sets a terribly bad precedent to attach whatever domain-specific
application that's needed into a sequence type just because it's easiest
on the eyes at the moment.

The .join method is inherently string specific, and belongs on strings,
not lists. There's no doubting that seeing S.join(...) for the first
time is a bit of a surprise, but once you understand the reasoning
behind it, it makes perfect sense and makes it clear just how much it
deserves to stay that way.

And above all, of course, if you think it personally looks ugly, you can

from string import join

or write your own join function that operates over sequences and does
whatever else you might wish. That's what the flexibility is there for.

--
__ Erik Max Francis && ma*@alcyone.com && http://www.alcyone.com/max/
/ \ San Jose, CA, USA && 37 20 N 121 53 W && &tSftDotIotE
\__/ Life is not a spectacle or a feast; it is a predicament.
-- George Santayana

[Peter Hansen]

John Roth wrote:

And I agree, it's not entirely obvious why it's a string
method rather than a list method, since it operates on
a list, not on a string. The only explanation that makes
sense is that, as a list method, it would fail if the list
contained something other than a string. That's still
not very friendly, though.

One could about as easily argue (and I believe several have done
this quite well in the past, better than I anyway) that you are
actually operating on the *string*, not the list. You are in
effect asking the string to act as a joiner for the elements in the
list, not asking the list to join itself using the specified
string.

At least, if you look at it that way, it might be easier to swallow.

-Peter

[Syver Enstad]

Peter Hansen <pe***@engcorp. com> writes:

John Roth wrote:

And I agree, it's not entirely obvious why it's a string
method rather than a list method, since it operates on
a list, not on a string. The only explanation that makes
sense is that, as a list method, it would fail if the list
contained something other than a string. That's still
not very friendly, though.

One could about as easily argue (and I believe several have done
this quite well in the past, better than I anyway) that you are
actually operating on the *string*, not the list. You are in
effect asking the string to act as a joiner for the elements in the
list, not asking the list to join itself using the specified
string.

At least, if you look at it that way, it might be easier to swallow.

Can't we have both. This is called a reversing method (Beck, Smalltalk
Best Practice Patterns) because it allows you to send several messages
to the same object instead of switching between different instances,
allowing the code to be more regular.

class MyList(list):
def join(self, aString):
return aString.join(se lf)
Like this:

lst = ['one', 'two', 'three']
print lst
print lst.join('\n')

I'd also like a reversing method for len

class MyList(list):
def len(self):
return len(self)

Often when I program against an instance I intuitively start each line
of code by writing the variable name and then a dot and then the
operation. The lack of a reversing method for len and join means that
my concentration is broken a tiny fraction of a second when I have to
remember to use another object or the global scope to find the
operation that I am after. Not a showstopper by any definition, but
irritating nonetheless.

--

Syver Enstad

[Christos TZOTZIOY Georgiou]

On Thu, 08 Jan 2004 03:50:04 -0800, rumours say that Erik Max Francis
<ma*@alcyone.co m> might have written:

[' '.join discussion]

And above all, of course, if you think it personally looks ugly, you can

from string import join

or write your own join function that operates over sequences and does
whatever else you might wish. That's what the flexibility is there for.

I believe str.join(string , sequence) works best for the functional types
(no need to rely on the string module).
--
TZOTZIOY, I speak England very best,
Ils sont fous ces Redmontains! --Harddix

[Christos TZOTZIOY Georgiou]

On 08 Jan 2004 16:34:39 +0100, rumours say that Syver Enstad
<sy************ *@online.no> might have written:

I'd also like a reversing method for len

class MyList(list):
def len(self):
return len(self)

You can always use the __len__ attribute in this specific case.

And now for the hack value:

class MyList(list):
import new as _new, __builtin__
def __getattr__(sel f, attr):
try:
return self._new.insta ncemethod( \
getattr(self.__ builtin__, attr), \
self, \
None)
except AttributeError:
raise AttributeError, \
"there is no '%s' builtin" % attr

allowing:

a=MyList()
a.append(12)
a.append(24)
a.len() 2 a.min() 12 a.max()

24

It works for all builtins that can take a list as a first argument.
Of course it should not be taken seriously :)
--
TZOTZIOY, I speak England very best,
Ils sont fous ces Redmontains! --Harddix