How Do split() and join() Work Together?

split breaks a string into a list of pieces using a separator, and join glues an iterable of strings back together using a separator you choose.

csv_line = "ada,99,grace,87"
fields = csv_line.split(",")
print(fields)                      # ['ada', '99', 'grace', '87']

print(",".join(fields))            # ada,99,grace,87
print("-".join(fields))            # ada-99-grace-87

# maxsplit limits how many splits happen
print("a,b,c".split(",", 1))       # ['a', 'b,c']

# join works on any iterable of strings
print("".join(str(n) for n in range(5)))    # 01234

Splitting on a comma gives four fields, and joining them with a comma reproduces the original string exactly. The maxsplit argument is the detail people miss: split(",", 1) splits only at the first comma, so the rest of the string stays in one piece. That is exactly what you want for a format where only the first separator is a delimiter.

Two variants of split are worth distinguishing. split() with no argument splits on any run of whitespace and throws away empty pieces, so it is the right call for counting words. split(",") splits on that literal separator and keeps empty pieces, so "a,,b".split(",") produces three elements with an empty string in the middle.

For join, the important points are that the separator belongs to the string you call it on, and that every element must already be a string. Passing an integer raises a TypeError, which is why the generator expression above converts with str first. And join accepts any iterable, so it works on a list, a tuple or a generator — which is why it is the natural counterpart to split.

Join is a method on the string because the separator is the thing you choose. The natural way to say the operation is comma-joined-items, so the comma is the object and joining is something you ask it to do. A standalone function would need the separator as the first argument, which reads less naturally and, more importantly, makes the common case verbose — you would have to write the separator twice in some formulations.

The performance benefit is the bigger reason it was designed this way. Python strings are immutable, so you cannot append to one in place. Building a string in a loop with the plus operator therefore creates a new string every iteration and copies everything accumulated so far, which makes the whole thing quadratic in the length of the result.

So result = "" followed by result += part inside the loop builds a new string on every iteration, while result = ",".join(parts) allocates the result once.

The join version allocates the result once and copies each piece into it, so it is linear in the total size. The concatenation version copies the growing string on every iteration, so it is quadratic. For a handful of items the difference is invisible; for a list of thousands it is the difference between instant and visibly slow.

That is the practical lesson to take away: to build a string from many pieces, collect the pieces in a list and join once at the end. The same rule applies to building bytes with b"".join and to f-strings that accumulate across a loop.