53

Given this harmless little list:

>>> lst = ['o','s','s','a','m','a']

My goal is to Pythonically concatenate the little devils using one of the following ways:

A. A plain old string function to get the job done, short, no imports

>>> ''.join(lst)
'ossama'

B. Lambda, lambda, lambda

>>> reduce(lambda x, y: x + y, lst)
'ossama'

C. Globalization (do nothing, import everything)

>>> import functools, operator
>>> functools.reduce(operator.add, lst)
'ossama'

What are other Pythonic ways to achieve this magnanimous task?

Please rank (Pythonic level) and rate solutions giving concise explanations.

In this case, is the most pythonic solution the best coding solution?

Improve this question
1

6 Answers 6

Reset to default
72 
''.join(lst)

The only Pythonic way:

  • clear (that is what all the big boys do and what they expect to see),
  • simple (no additional imports needed, and stable across all versions),
  • fast (written in C) and
  • concise (on an empty string, join elements of iterable!).
Improve this answer
Sign up to request clarification or add additional context in comments.

3 Comments

While the reduce based solutions are elegant and the functional programmer in me appreciates them, I must agree that join() is indeed the only pythonic solution.
SilentGhost is right. Strings have a join method that accepts iterables, so using anything else is not pythonic.
So -- people, pls, check the "bytearray" native type my answer bellow). Join is ubeatable up to python 2.5, though.
40

Have a look at Guido's essay on Python optimization. It covers converting lists of numbers to strings. Unless you have a good reason to do otherwise, use the join example.

Improve this answer

Comments

18

Of course it's join. How do I know? Let's do it in a really stupid way:
If the problem was only adding 2 strings, you'd most likely use str1 + str2. What does it take to get that to the next level? Instinctively, for most (I think), will be to use sum. Let's see how that goes:

In [1]: example = ['a', 'b', 'c']
In [2]: sum(example, '')
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython console> in <module>()
    TypeError: sum() can't sum strings [use ''.join(seq) instead]

Wow! Python simply told me what to use! :)

Improve this answer

Comments

9

Here's the least Pythonic way:

out = ""
for x in range(len(lst)):
  for y in range(len(lst)):
    if x + y == len(lst)-1:
        out = lst[y] + out
Improve this answer

1 Comment

I bet there are ways to reduce pythonicity in that. ;)
6

I myself use the "join" way, but from Python 2.6 there is a base type that is little used: bytearray.

Bytearrays can be incredible useful -- for string containing texts, since the best thing is to have then in Unicode, the "join" way is the way to go -- but if you are dealing with binary data instead, bytearrays can be both more Pythonic and more efficient:

>>> lst = ['o','s','s','a','m','a']
>>> a = bytearray(lst)
>>> a
bytearray(b'ossama')
>>> print a
ossama

It is a built-in data type: no imports needed - just use then -- and you can use a bytearray instead of a list to start with - so they should be more efficient than the "join", since there isn’t any data copying to get the string representation for a bytearray.

Improve this answer

3 Comments

hmm..just checked: the "bytearray" constructor can get even an unicode string and an "encoding" argument so it can deal with unicode as well. eg. : a = bytearray(u"déja-vu", encoding="utf8")
except that bytearrays are neither pythonic nor efficient. They're intended for completely different purpose, and their behaviour in py2.6 is not the same as in py3k.
@SilentGhost: Thank you for your feedback - where can I read more about it? And even if they aren't as efficient as they mightlookat first, I doubt "join" could be faster simply due to the creation of a new strign object per part to concatenate. (I intend to do some benchmarking later today)
4

There is a great answer from SilentGhost, but just a few words about the presented reduce "alternative":

Unless you've got a very very very good reason to concatenate strings using + or operator.add (the most frequent one, that you've got few, fixed number of strings), you should use always join.

Just because each + generates a new string which is the concatenation of two strings, unlike join that only generates one final string. So, imagine you've got three strings:

A + B + C
-->
D = A + B
final = D + C

Ok, it doesn't seems not much, but you've got to reserve memory for D. Also, due Python's use of strings, generating a new, intermediate, string, it's somehow expensive...

Now, with five strings,

A + B + C + D + E
-->
F = A + B
G = F + C
H = G + D
final = H + E

Assuming the best scenario (if we do (A+B) + (C+D) + E, we'll end having three intermediate strings at the same time on memory), and that's generating three intermediate strings... You've got to generate a new Python object, reserve memory space, and release the memory a few times... Also there is the overhead of calling a Python function (that is not small).

Now think of it with 200 strings. We'll end up with a ridiculous big number of intermediate strings, each of which is consuming combining quite a lot of time on being a complete list over Python , and calling a lot of operator.add functions, each with its overhead...

Even if you use reduce functions, it won't help. It's a problem that has to be managed with a different approach: join, which only generates one complete Python string, the final one and calls one Python function.

(Of course, join, or other similar, specialized function for arrays.)

Improve this answer

Comments

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.