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.
Use str.join:
>>> words = ['this', 'is', 'a', 'sentence']
>>> '-'.join(words)
'this-is-a-sentence'
>>> ' '.join(words)
'this is a sentence'
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?
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.str() method on the object, and that would convert it to the its string representation, ''.join(map(str, [obj1,obj2,obj3]))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
map(str, my_lst) would be enough without enumerating the list =)
int but it could be any type that can be represented as a string.
' '.join(map(lambda x: ' $'+ str(x), my_lst)) would return '$1 $2 $3 $4 $5 $6 $7 $8 $9 $10'
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 ' $'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)'
join() i.e. join(("(",")")) does? its like magic
("(",")") 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').
>>> 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
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 " ".
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)
join?
We can specify how we join the string. Instead of '-', we can use ' ':
sentence = ['this','is','a','sentence']
s=(" ".join(sentence))
print(s)
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']
str(aa) also gives "[None, 10, 'hello']"...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'
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'"
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.def eggs(someParameter):
del spam[3]
someParameter.insert(3, ' and cats.')
spam = ['apples', 'bananas', 'tofu', 'cats']
eggs(spam)
spam =(','.join(spam))
print(spam)
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.
