homepage

I compiled python 3.0 on a cygwin platform.
Here is my modest function:
def List_to_String(lis):
# return str.join(lis, '')		# This is fast, but seems broke in 3.0
 s = ''				# This is really slow, but works in 3.0
 for l in lis: s = s + l
 return s
Here is my test case:
 def test_List_to_String(self):
 inp = ['f', 'r', 'e', 'd', ' ', 'i', 's']
 out = 'fred is'
 self.assertEqual(jefflib.List_to_String(inp), out)
Here is what happens when I try to run the commented out version (the
one with the join):
ERROR: test_List_to_String (__main__.TestJefflibFunctions)
----------------------------------------------------------------------
Traceback (most recent call last):
 File "./jefflib_test.py", line 96, in test_List_to_String
 self.assertEqual(jefflib.List_to_String(inp), out)
 File "/cygdrive/c/documents and
settings/deifikj/jeff/scripts/jefflib.py", lin
e 256, in List_to_String
 return str.join(lis)
TypeError: descriptor 'join' requires a 'str' object but received a 'list'
Of course, it worked fine in python 2.6.
I am baffled.

Try this---
def List_to_String(lis,separator=''):
 return separator.join(lis)

Thanks.
I want to learn what is wrong with the code I have though.
My main goal is to understand python 3.0 better, rather than
fixing a specific problem.

I did this to find out what are str.join's arguments---
$ python3 -c 'help(str.join)'
Help on method_descriptor:
join(...)
 S.join(sequence) -> str
 
 Return a string which is the concatenation of the strings in the
 sequence. The separator between elements is S.

>>> str.join(lis, '')
I doubt this really worked with 2.6.
Wasn't it something like:
>>> import string
>>> string.join(lis, '')

Yes, it was
 import string
 string.join(lis, '')
I am still a bit confused though.
Why doesn't my code of str.join(lis, '') work?
I don't think str is a reserved word.
I suppose that python might be able to deduce that str is of type
string, based on join being called on it.
Is the problem that python thinks my str is of type list?

"str" is not your string, it's not a string; "str" is a class name, a
standard type.
"str.join" is a unbound method. You can call it directly if you pass an
actual string object in front of the other arguments.
But the normal way to call methods is to use them on objects:
someString = ""
someList = ['f', 'r', 'e', 'd', ' ', 'i', 's']
someString.join(someList)

I fixed the code as follows:
return str.join('',lis)
I think it is readable, and I understand it.
Thanks everyone for clarifying everything

it is really a good help