What is the split() method in Python?

Definition of the split() method in Python

The split() method is one of the most commonly used methods in Python for manipulating strings. It allows you to divide a string into a list of substrings based on a separator (also called a delimiter). By default, this separator is whitespace (spaces, tabs, newlines).

In other words, split() takes a single string and breaks it into multiple pieces, each becoming an element of a list. This is a fundamental operation that you will encounter in almost every Python project, whether for file processing, data analysis, or web development. If you want to master this kind of manipulation and many others, our comprehensive Python course will guide you step by step.

The basic syntax is as follows:

string.split(sep=None, maxsplit=-1)

Where:

• sep (optional): the separator used to split the string. Defaults to None, which means Python uses whitespace.
• maxsplit (optional): the maximum number of splits to perform. Defaults to -1, which means there is no limit.

Basic usage of split()

Let's start with the simplest case: splitting a sentence into words. When you call split() without any argument, Python splits the string at every whitespace character.

sentence = "Hello the world Python"
words = sentence.split()
print(words)
# Result: ['Hello', 'the', 'world', 'Python']

As you can see, the method returns a list containing each word of the sentence. This is extremely useful for counting words in a text or accessing a specific word by its index.

sentence = "Python is a powerful language"
words = sentence.split()

# Number of words
print(len(words))  # 5

# Access the first word
print(words[0])  # Python

# Access the last word
print(words[-1])  # language

You will notice here the use of the len function to get the number of elements in the resulting list.

Splitting with a custom separator

One of the great strengths of split() is the ability to specify any separator. This is particularly useful when you work with structured data like CSV files, logs, or URLs.

Splitting by a comma

csv_data = "Alice,28,Paris,Developer"
fields = csv_data.split(",")
print(fields)
# Result: ['Alice', '28', 'Paris', 'Developer']

Splitting by a semicolon

line = "name;firstname;age;city"
columns = line.split(";")
print(columns)
# Result: ['name', 'firstname', 'age', 'city']

Splitting by a newline

text = "First line\nSecond line\nThird line"
lines = text.split("\n")
print(lines)
# Result: ['First line', 'Second line', 'Third line']

Splitting by a multi-character string

The separator is not limited to a single character. You can use any string:

text = "Python-->Java-->JavaScript-->Rust"
languages = text.split("-->")
print(languages)
# Result: ['Python', 'Java', 'JavaScript', 'Rust']

The maxsplit parameter

The second parameter of split() allows you to limit the number of splits performed. This is very useful when you only want to extract the first elements of a string while keeping the rest intact.

sentence = "one two three four five"
result = sentence.split(" ", 2)
print(result)
# Result: ['one', 'two', 'three four five']

Here, Python performed only 2 splits, which produces a list of 3 elements. The third element contains the entire remainder of the string, unsplit.

A very common use case is to separate a key and its value:

config = "database_host=my-server.believemy.com"
key, value = config.split("=", 1)
print(key)    # database_host
print(value)  # my-server.believemy.com

By using maxsplit=1, we ensure that only the first = sign is taken into account, which is essential if the value itself contains = signs.

Difference between split() without argument and split(" ")

There is an important subtlety that many developers overlook: calling split() without an argument is not the same as calling split(" "). Here's why:

Let's see this in practice:

text = "  Hello   the    world  "

# Without argument
print(text.split())
# Result: ['Hello', 'the', 'world']

# With a space as argument
print(text.split(" "))
# Result: ['', '', 'Hello', '', '', 'the', '', '', '', 'world', '', '']

rsplit(): splitting from the right

Python also provides the rsplit() method which works identically to split(), but performs splits from the right of the string. Without the maxsplit parameter, the result is the same as split(). The difference only appears when you limit the number of splits.

path = "folder/subfolder/file.txt"

# split from the left
print(path.split("/", 1))
# Result: ['folder', 'subfolder/file.txt']

# rsplit from the right
print(path.rsplit("/", 1))
# Result: ['folder/subfolder', 'file.txt']

As you can see, rsplit() is ideal for extracting the last element of a path or a compound string.

splitlines(): splitting by lines

For splitting text into lines, Python offers a dedicated method: splitlines(). It automatically recognizes all types of line endings (\n, \r\n, \r), making it more robust than split("\n").

text = "Line 1\nLine 2\r\nLine 3\rLine 4"
lines = text.splitlines()
print(lines)
# Result: ['Line 1', 'Line 2', 'Line 3', 'Line 4']

Practical use cases

Parsing a simple CSV file

One of the most common use cases for split() is processing CSV files (without using an external library):

raw_data = """name,age,city
Alice,28,Paris
Bob,35,Lyon
Charlie,42,Marseille"""

lines = raw_data.strip().splitlines()
headers = lines[0].split(",")

for line in lines[1:]:
    values = line.split(",")
    for header, value in zip(headers, values):
        print(f"{header}: {value}")
    print("---")

This example uses zip to pair each header with its value, and f-string for clear output. It's an excellent exercise for understanding the interaction between multiple Python features.

Extracting information from a URL

url = "https://believemy.com/en/courses/formation-python"

# Extract the protocol
protocol, rest = url.split("://", 1)
print(protocol)  # https

# Extract the domain and path
domain, path = rest.split("/", 1)
print(domain)  # believemy.com
print(path)    # en/courses/formation-python

# Break down the path
segments = path.split("/")
print(segments)  # ['en', 'courses', 'formation-python']

Cleaning and transforming data

raw_tags = "  python , machine learning ,  data science , web  "
tags = [tag.strip() for tag in raw_tags.split(",")]
print(tags)
# Result: ['python', 'machine learning', 'data science', 'web']

Here, we combine split(",") with a list comprehension and strip() to clean each element. This is a very common pattern in Python.

Counting words in a text

def count_words(text):
    """Count the number of words in a text."""
    words = text.split()
    return len(words)

article = "Python is a popular and powerful programming language today"
print(count_words(article))  # 9

Here we use a function defined with def along with a docstring to document its purpose.

Joining after splitting: the join() method

The join() method is the natural complement to split(). If split() transforms a string into a list, join() does the opposite: it transforms a list into a string.

# Split
sentence = "Python is fantastic"
words = sentence.split()
print(words)  # ['Python', 'is', 'fantastic']

# Join with a dash
result = "-".join(words)
print(result)  # Python-is-fantastic

# Join with a space
result2 = " ".join(words)
print(result2)  # Python is fantastic

A classic use case is creating slugs for URLs:

title = "  What is the Split Method in Python ?  "
slug = "-".join(title.strip().lower().split())
print(slug)  # what-is-the-split-method-in-python-?

Best practices

Here are the essential recommendations for using split() effectively in your Python projects:

• Prefer split() without an argument for splitting natural text. This automatically handles multiple spaces and leading/trailing whitespace.
• Use maxsplit when you only need the first few elements. This improves performance and avoids unnecessary splits.
• Prefer splitlines() over split("\n") for splitting text into lines, as this method correctly handles all types of line endings.
• Remember to use strip() after a split() with an explicit separator, as spaces around elements are not automatically removed.
• Use unpacking to directly extract values into variables when you know the expected number of elements.
• Handle errors: always verify that the resulting list contains the expected number of elements before accessing them by index.

Common mistakes to avoid

Here are the most frequent pitfalls related to using split():

Forgetting that split() does not modify the original string

Strings in Python are immutable. The split() method returns a new list; it does not modify the original string:

text = "one two three"
text.split()  # Returns ['one', 'two', 'three'] but is not stored
print(text)   # "one two three" - unchanged

# You must store the result
words = text.split()
print(words)  # ['one', 'two', 'three']

Confusing split() without argument and split(" ")

We saw this earlier, but it is such a frequent mistake that it deserves repeating. Use split() without an argument for natural text.

Not handling empty strings

data = "a,,b,,c"
result = data.split(",")
print(result)  # ['a', '', 'b', '', 'c']

# Filter out empty strings
filtered_result = [x for x in data.split(",") if x]
print(filtered_result)  # ['a', 'b', 'c']

Calling split() on a non-string type

# This will cause an error
number = 12345
# number.split()  # AttributeError: 'int' object has no attribute 'split'

# Convert to string first
digits = str(number)
result = list(digits)
print(result)  # ['1', '2', '3', '4', '5']

Performance and alternatives

The split() method is very performant for most use cases. However, in certain specific situations, alternatives may be more suitable:

• re module (regular expressions): when the separator is complex or variable.
• csv module: for complex CSV files (with quotes, escaping, etc.).
• partition(): when you only want to split into 3 parts (before, separator, after).

import re

# Split by multiple separators at once
text = "word1,word2;word3:word4"
result = re.split(r"[,;:]", text)
print(result)  # ['word1', 'word2', 'word3', 'word4']

# Use partition() for a single split
email = "user@believemy.com"
name, sep, domain = email.partition("@")
print(name)    # user
print(domain)  # believemy.com

Frequently asked questions

Both methods work identically when called without the maxsplit parameter. The difference only appears when you limit the number of splits: split() splits from the beginning (left) of the string, while rsplit() splits from the end (right). For example, "a/b/c".split("/", 1) gives ['a', 'b/c'] while "a/b/c".rsplit("/", 1) gives ['a/b', 'c'].

No, the native split() method only supports one separator at a time. To split a string with multiple separators simultaneously, you need to use the re module (regular expressions) with the re.split() function. For example: re.split(r"[,;:]", text) will split the string at every comma, semicolon, or colon.

The behavior depends on whether a separator is provided or not. "".split() (without an argument) returns an empty list []. However, "".split(",") (with an explicit separator) returns [''], that is, a list containing one empty string. This is an important detail to keep in mind when processing data that may contain empty strings.

The split() method is just one of the many powerful methods Python offers for string manipulation. To master all these tools and build real-world projects, we recommend following our dedicated Python course. You will learn not only text manipulation, but also data structures, object-oriented programming, and much more, with hands-on exercises at every step.