1172

How do I concatenate a list of strings into a single string?

For example, given ['this', 'is', 'a', 'sentence'], how do I get "this-is-a-sentence"?


For handling a few strings in separate variables, see How do I append one string to another in Python?.

For the opposite process - creating a list from a string - see How do I split a string into a list of characters? or How do I split a string into a list of words? as appropriate.

0

12 Answers 12

1987

Use str.join:

>>> words = ['this', 'is', 'a', 'sentence']
>>> '-'.join(words)
'this-is-a-sentence'
>>> ' '.join(words)
'this is a sentence'
11
  • 21
    Didn't understand, what's the '-' on the left supposed to be?? Apr 2, 2014 at 23:46
  • 12
    @LawrenceDeSouza The string you want to be joined; see the documentation, or this answer which goes into a bit more detail. Apr 6, 2014 at 6:53
  • 17
    I kind of expected sentence.join(" ") to work as well, since the reverse operation is list.split(" "). Any idea if this is going to be added to Python's methods for lists? Aug 23, 2015 at 10:02
  • 18
    @Wouter, it will not. On the one hand, only lists of strings can be joined; so list.join would be inappropriate for an arbitrary list. On the other, the argument of str.join can be any "iterable" sequence of strings, not just a list. The only thing that would make sense is a built-in function join(list, sep); there's one in the (basically obsolete) string module if you really want it.
    – alexis
    Sep 7, 2015 at 22:28
  • 2
    @Raghav you would have to call the str() method on the object, and that would convert it to the its string representation, ''.join(map(str, [obj1,obj2,obj3])) Dec 15, 2021 at 7:26
262

A more generic way (covering also lists of numbers) to convert a list to a string would be:

>>> my_lst = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> my_lst_str = ''.join(map(str, my_lst))
>>> print(my_lst_str)
12345678910
5
  • 3
    why is list comprehension necessary when the input is string? also map(str, my_lst) would be enough without enumerating the list =)
    – alvas
    Dec 1, 2015 at 8:58
  • 22
    Most of the answers to this question are considering the case when the list has strings in it. Mine is a generic way to convert lists to strings. In my example, the list is of type int but it could be any type that can be represented as a string.
    – Aaron S
    Dec 2, 2015 at 1:02
  • 5
    To add to this, map would also be useful when used with a lambda function. For example ' '.join(map(lambda x: ' $'+ str(x), my_lst)) would return '$1 $2 $3 $4 $5 $6 $7 $8 $9 $10'
    – ScottMcC
    Jun 22, 2017 at 3:17
  • 4
    adding a map actually helps with datatypes apart from string. Great!
    – appleboy
    Feb 28, 2019 at 7:55
  • 1
    In Python it is preferred to use generator expressions instead of map() and lambda. Updated example by @ScottMcC: ' '.join(f'${x}' for x in my_lst) evaluates to: '$1 $2 $3 $4 $5 $6 $7 $8 $9 $10' --- Note: The original example has unwanted space in ' $' Jul 15, 2023 at 6:02
66

It's very useful for beginners to know why join is a string method.

It's very strange at the beginning, but very useful after this.

The result of join is always a string, but the object to be joined can be of many types (generators, list, tuples, etc).

.join is faster because it allocates memory only once. Better than classical concatenation (see, extended explanation).

Once you learn it, it's very comfortable and you can do tricks like this to add parentheses.

>>> ",".join("12345").join(("(",")"))
Out:
'(1,2,3,4,5)'

>>> list = ["(",")"]
>>> ",".join("12345").join(list)
Out:
'(1,2,3,4,5)'
5
  • 3
    can someone explain what the second join() i.e. join(("(",")")) does? its like magic
    – cryanbhu
    Nov 12, 2020 at 7:17
  • 5
    ("(",")") is a tuple of two strings - the open parenthesis "(" and the close parenthesis ")". So the second join() joins those two strings using the output of the first join() as the separator (i.e., '1,2,3,4,5').
    – zepman
    Feb 18, 2021 at 16:47
  • Is this correct? "The result of join is always a string, but the object to be joined can be of many types (generators, list, tuples, etc)." The answer by Aaron S suggests that this is not true, you have to use map(str, ) if there are other types in the list.
    – O'Rooney
    Mar 28, 2022 at 21:42
  • 1
    @O'Rooney the answer is saying you can .join lists, tuples or generators, which are different types of collection, but they should only contain strings.
    – user3064538
    Aug 16, 2022 at 18:12
  • Okay voting this up because it is cute as eff, but seriously don't do this for code you want humans to understand. I concede it may be useful for code golf or evil.
    – Bob Stein
    Jun 29, 2023 at 19:59
21
>>> list_abc = ['aaa', 'bbb', 'ccc']

>>> string = ''.join(list_abc)
>>> print(string)
aaabbbccc

>>> string = ','.join(list_abc)
>>> print(string)
aaa,bbb,ccc

>>> string = '-'.join(list_abc)
>>> print(string)
aaa-bbb-ccc

>>> string = '\n'.join(list_abc)
>>> print(string)
aaa
bbb
ccc
1
  • The reverse use of the prompt sequence >>> on the output instead of commands is very confusing. Jul 15, 2023 at 6:10
18

Edit from the future: Please don't use the answer below. This function was removed in Python 3 and Python 2 is dead. Even if you are still using Python 2 you should write Python 3 ready code to make the inevitable upgrade easier.


Although @Burhan Khalid's answer is good, I think it's more understandable like this:

from str import join

sentence = ['this','is','a','sentence']

join(sentence, "-") 

The second argument to join() is optional and defaults to " ".

5
  • 23
    This function is deprecated in 2.x and going to be removed in 3.x. That being the case, I wouldn't recommend using this over the other answer provided. Nov 19, 2015 at 20:28
  • @Mathew Green this answer and Burhan Khalid's answer use the same function in different ways, so his answer is deprecated as well. But thanks for pointing that out, gota figure out how to join in 3.x. But if you're using 2.x, it's not going away.
    – SilentVoid
    Nov 20, 2015 at 21:42
  • 3
    His isn't deprecated though. Your recommendation uses a function from Lib/string.py which is wholly different and deprecated whereas @BurhanKhalid answer uses the built-in string method which is not deprecated. His answer is the most correct one now and going forward whereas this is only good for now on 2.x. Nov 20, 2015 at 22:07
  • All that to say that if you want to promote this alternative you should also include a warning that this is not recommended for the reasons outlined in my previous comments. Nov 20, 2015 at 22:12
  • 2
    It's scary that I still get up-votes on this. Seriously, use python 3.
    – SilentVoid
    Nov 23, 2022 at 14:01
10

We can also use Python's reduce function:

from functools import reduce

sentence = ['this','is','a','sentence']
out_str = str(reduce(lambda x,y: x+"-"+y, sentence))
print(out_str)
2
  • 11
    Too much-unneeded complexity, why not just using join? Dec 2, 2019 at 11:36
  • In my cace join doesn't make all job, i need more symbols added, so reduce works better Nov 29, 2023 at 9:35
9

We can specify how we join the string. Instead of '-', we can use ' ':

sentence = ['this','is','a','sentence']
s=(" ".join(sentence))
print(s)
2

If you have a mixed content list and want to stringify it, here is one way:

Consider this list:

>>> aa
[None, 10, 'hello']

Convert it to string:

>>> st = ', '.join(map(str, map(lambda x: f'"{x}"' if isinstance(x, str) else x, aa)))
>>> st = '[' + st + ']'
>>> st
'[None, 10, "hello"]'

If required, convert back to the list:

>>> ast.literal_eval(st)
[None, 10, 'hello']
1
  • 2
    Why such overcomplication? str(aa) also gives "[None, 10, 'hello']"...
    – Tomerikoo
    Jan 19, 2022 at 14:51
1

If you want to generate a string of strings separated by commas in final result, you can use something like this:

sentence = ['this','is','a','sentence']
sentences_strings = "'" + "','".join(sentence) + "'"
print (sentences_strings) # you will get "'this','is','a','sentence'"
1
  • It works but this code better follows the logic of things: sentences_strings = ','.join(f"'{word}'" for word in sentence) As an important bonus you have the characters to enclose the strings ' in one place, not scattered over the whole expression. Jul 15, 2023 at 6:21
1

It's also possible to use str.format() to join values in a list by unpacking the list inside format() which inserts the values sequentially into the placeholders. It can handle non-strings as well.

lst1 = ['this', 'is', 'a', 'sentence']
lst2 = ['numbers', 1, 2, 3]
'{}-{}-{}-{}'.format(*lst1)       # 'this-is-a-sentence'
'{} {}, {} and {}'.format(*lst2)  # 'numbers 1, 2 and 3'

For a large list, we can use the list's length to initialize the appropriate number of placeholders. One of two ways could be used to do that:

  • ', '.join(['{}']*len(lst)).format(*lst)
    
  • ('{}, '*len(lst)).rstrip(', ').format(*lst)
    

A working example:

lst = [1.2345, 3.4567, 4.567, 5.6789, 7.8]
', '.join(['{}']*len(lst)).format(*lst)      # '1.2345, 3.4567, 4.567, 5.6789, 7.8'
('{}, '*len(lst)).format(*lst).rstrip(', ')

# with a float format specification
', '.join(['{:.2f}']*len(lst)).format(*lst)  # '1.23, 3.46, 4.57, 5.68, 7.80'
0
def eggs(someParameter):
    del spam[3]
    someParameter.insert(3, ' and cats.')


spam = ['apples', 'bananas', 'tofu', 'cats']
eggs(spam)
spam =(','.join(spam))
print(spam)
1
  • 4
    While this code snippet may be the solution, including an explanation really helps to improve the quality of your post. Remember that you are answering the question for readers in the future, and those people might not know the reasons for your code suggestion.
    – alan.elkin
    May 7, 2020 at 21:58
-1

Without .join() method you can use this method:

my_list=["this","is","a","sentence"]

concenated_string=""
for string in range(len(my_list)):
    if string == len(my_list)-1:
        concenated_string+=my_list[string]
    else:
        concenated_string+=f'{my_list[string]}-'
print([concenated_string])
    >>> ['this-is-a-sentence']

So, range based for loop in this example , when the python reach the last word of your list, it should'nt add "-" to your concenated_string. If its not last word of your string always append "-" string to your concenated_string variable.

Not the answer you're looking for? Browse other questions tagged or ask your own question.