How to join a list into a string in Python

1The separator joins the listRecommended

join is a method on str, so you call it on the glue and pass the list: separator.join(iterable). It reads backwards at first, but it's what lets any string join any iterable — a list, a tuple, a generator, even another string.

items = ["red", "green", "blue"]
print(", ".join(items))
print(" | ".join(items))
print("".join(items))

Prints red, green, blue, then red | green | blue, then redgreenblue. An empty separator concatenates with nothing between — that's the standard way to rebuild a string from a list of characters.

2Joining numbers and other non-strings

join refuses to guess how to stringify your objects, so a list of ints raises TypeError: sequence item 0: expected str instance, int found. The index in that message is the first offending item, which is handy when only one element is the odd one out. Fix it with map(str, ...) or a generator expression:

nums = [1, 2, 3]

try:
    print(", ".join(nums))
except TypeError as err:
    print("TypeError:", err)

print(", ".join(map(str, nums)))
print(", ".join(str(n) for n in nums))

The first line prints TypeError: sequence item 0: expected str instance, int found; both fixes print 1, 2, 3. map(str, ...) is marginally faster and shorter; the generator wins as soon as you need real formatting per item, e.g. f"{n:.2f}".

3Joining with a newline

"\n".join(lines) is the idiomatic way to build multi-line output — one print(), one write, no trailing blank line. Nest a second join inside a generator and you have a CSV-ish table in two lines:

lines = ["id,name", "1,ada", "2,linus"]
print("\n".join(lines))

print("---")

rows = [["ada", "1945"], ["linus", "1969"]]
print("\n".join(" | ".join(row) for row in rows))

The inner join builds each row, the outer one stitches the rows together — ada | 1945 then linus | 1969. For real CSV with quoting and escaping, use the csv module instead of hand-rolling it.

4Building the string in a loop

You can append with += and track the separator yourself. It works, and the result is identical — but strings are immutable, so in principle every += copies the whole accumulated string, making the loop quadratic in the number of items. CPython has an in-place optimisation that often hides this, but it only applies when the string has a single reference and it is not part of the language spec, so it can vanish without warning.

words = ["build", "run", "share"]

result = ""
for i, word in enumerate(words):
    if i:
        result += ", "
    result += word
print(result)
print(result == ", ".join(words))

Prints build, run, share and then True — same output, five extra lines, and an if i: guard purely to avoid a leading separator. join handles the "n − 1 separators" problem for free. If you really must accumulate incrementally, append to a list and join it at the end.

5Which should you use?

6Common variation: an Oxford-comma join

User-facing text usually wants a, b, and c rather than a, b, c. Join everything except the last item, then attach the last one with and — with a special case for one or two items:

def humanize(items):
    items = [str(i) for i in items]
    if len(items) <= 2:
        return " and ".join(items)
    return ", ".join(items[:-1]) + ", and " + items[-1]

print(humanize(["Python"]))
print(humanize(["Python", "Go"]))
print(humanize(["Python", "Go", "Rust"]))
print(humanize(["Python", "Go", "Rust", "C++"]))

Prints Python, Python and Go, Python, Go, and Rust, and Python, Go, Rust, and C++. The str(i) pass up front means it never raises the TypeError from section 2. Drop the comma before and if your style guide says so.