Python split() and join() Explained with Examples

How-to basics · Updated November 22, 2026

The split() method breaks a string into a list of substrings based on a delimiter, while join() does the opposite—it concatenates a list of strings into a single string using a specified separator. These two methods are the core tools for parsing and assembling text in Python, and they work together to handle everything from CSV lines to file paths.

What Exactly Do split() and join() Do?

In Python, strings are immutable sequences of characters. split() is a method on a string object that returns a list of substrings. It scans the original string and cuts it wherever it finds the delimiter (default is any whitespace). For example:

text = "apple,banana,cherry"
fruits = text.split(",")
print(fruits)  # ['apple', 'banana', 'cherry']

join() is the inverse. It is called on a separator string and takes an iterable (like a list or tuple) of strings as its argument. It inserts the separator between each element and returns the combined string:

fruits = ['apple', 'banana', 'cherry']
text = ",".join(fruits)
print(text)  # apple,banana,cherry

Note that join() is a method of the separator, not of the list. This is a common source of confusion for beginners.

How split() Works: Parameters and Edge Cases

The full signature is str.split(sep=None, maxsplit=-1).

  • sep is the delimiter string. If omitted or None, split on any whitespace (spaces, tabs, newlines) and collapses consecutive whitespace.
  • maxsplit limits the number of splits. The remaining string becomes the last element. Default -1 means no limit.

Examples:

"a b  c".split()        # ['a', 'b', 'c'] (whitespace collapsed)
"a,b,c".split(',', 1)  # ['a', 'b,c']
"hello".split(',')     # ['hello'] (no delimiter found)

If sep is an empty string, Python raises a ValueError. Also, splitting on a delimiter that appears at the start or end produces empty strings in the list:

",a,".split(',')  # ['', 'a', '']

How join() Works: Requirements and Type Errors

join() expects an iterable of strings. If any element is not a string, you get a TypeError. For instance:

"-".join([1, 2])  # TypeError: sequence item 0: expected str instance, int found

You must convert non-strings first using str() or a list comprehension. Also, join() works with any iterable, not just lists—tuples, sets, generators, and even strings (though joining a single string just returns it).

" ".join(('a', 'b'))  # 'a b'
"".join(['a', 'b'])   # 'ab'

Common Use Cases in Real Code

These methods appear everywhere in Python scripts:

  • Parsing CSV lines: line.split(',') gives fields.
  • Reading configuration files where each line is key=value.
  • Building SQL queries or HTML fragments with join().
  • Cleaning user input by splitting on whitespace and rejoining with single spaces.
  • Handling file paths: os.path.join() is similar but platform-aware, and it’s not the same as string join().

For example, to normalize whitespace in a sentence:

s = "  Hello   world  "
normalized = " ".join(s.split())
print(normalized)  # "Hello world"

split() vs. splitlines() and Other Alternatives

Python also offers splitlines(), which splits on line boundaries like \n, \r\n, or \r, and keeps the line endings if you pass keepends=True. For regular expressions, re.split() allows splitting on patterns, not just a fixed string. For example, to split on multiple delimiters:

import re
re.split(r'[,;]', 'a,b;c')  # ['a', 'b', 'c']

For joining, there’s no regex alternative—join() is the only built-in. But for building strings from many parts, consider f-strings for readability when you have a fixed number of pieces.

Performance and Memory Considerations

Both methods are implemented in C and are very fast. However, split() creates a new list and new string objects for each substring, so for extremely large strings or repeated splitting, memory usage can spike. join() is more efficient than repeated string concatenation with + because it allocates the final size once, avoiding the O(n²) behavior of many concatenations in a loop.

If you need to split a huge file line by line, use file.read().splitlines() or iterate over the file object directly—that avoids loading the entire content into memory at once.

Frequently Asked Questions

Why does join() work on the separator, not the list?
It’s a design choice from Python’s early days. Because the separator can be any string, making it the method receiver allows you to join with different delimiters without changing the list. Also, it works with any iterable, not just lists.

What happens if I call split() with no arguments on a string with only spaces?
It returns an empty list [] because there are no non-whitespace characters. With a delimiter like ',', it returns [''] for an empty string.

Can I split a string into a fixed number of parts?
Yes, use maxsplit. For example, "a,b,c".split(',', 1) gives ['a', 'b,c']. This is handy when you only want the first field and the rest as one chunk.

How do I join a list of integers?
You need to convert each to a string first. Use a generator expression: ','.join(str(x) for x in [1, 2, 3]) yields '1,2,3'.

Is there a way to split on multiple characters at once without regex?
No built-in method does that directly. You can chain replace() to unify delimiters, but regex with re.split() is cleaner and more flexible.

Does split() modify the original string?
No, strings are immutable. Both methods return new objects; the original string remains unchanged.

Related

Try it: the Date Difference Calculator: days, months, years and weekdays between two dates, with the DATEDIF formulas.

More in How-to basics

Sources: Function behaviour and menu paths: Microsoft Support documentation for Excel. Method & sources

Spotted an error in this guide? Let us know.