python re split multiple delimiters

Yvonne 101 Published: 07/11/2024

python re split multiple delimiters

I'd be happy to help!

Python's re module provides a powerful way to work with regular expressions, including splitting strings by multiple delimiters. Here are some examples and tips:

Example 1: Splitting by commas and semicolons

Suppose you have the following string:

s = "apple;banana,orange;pear,cherry"

You can split it into individual words using the re.split function with a regular expression that matches both commas and semicolons:

import re

delimiters = r'[;,]'


words = re.split(delimiters, s)


print(words)  # Output: ['apple', 'banana', 'orange', 'pear', 'cherry']

In this example, the regular expression [;,] matches either a comma or a semicolon.

Example 2: Splitting by multiple characters

Let's say you have a string that contains dates in various formats:

s = "2020-01-01,2021/02/03,2022-07-15"

You can split this string into individual dates using the re.split function with a regular expression that matches multiple characters (hyphens, forward slashes, and colons):

import re

delimiters = r'[/-]'


dates = re.split(delimiters, s)


print(dates)  # Output: ['2020', '01', '2021', '02', '03', '2022', '07', '15']

In this example, the regular expression [/-] matches either a hyphen, a forward slash, or a colon.

Tips and Variations

When splitting by multiple delimiters, you can use the re.split function with a single regular expression that matches all of them. For example: delimiters = r'[;,/-]'. If you need to preserve the delimiters in the output, you can modify the regular expression to capture them instead of just matching them. For example: delimiters = r'([;,/-])'. This will result in a list of tuples containing each word and its corresponding delimiter. To split by multiple delimiters with varying numbers of whitespace characters between them (e.g., commas, semicolons, or spaces), you can use the following regular expression: delimiters = r's*([;,])s*'. This will match zero or more whitespace characters followed by one of the delimiters. If your input string contains leading or trailing whitespace, be sure to trim it before splitting. You can do this using the strip method or a regular expression.

I hope these examples and tips help you work with multiple delimiters in Python using the re module!

python split multiple delimiters as one

A delightful question!

In Python, you can split a string into substrings using multiple delimiters with the split() method from the str class. To achieve this, you can pass a regular expression pattern to the split() method that includes all your delimiter characters.

Let's illustrate this with an example:

Suppose we have a string containing words separated by commas (,) and spaces (), and we want to split it into individual words based on these two delimiters. Here's how you can do it:

import re
Define the input string

s = "Hello, world! Foo, Bar baz"

Define a regular expression pattern that matches both comma and space

pattern = r'[,s]+'

Split the string using the defined pattern

words = re.split(pattern, s)


print(words)

This will output:

['Hello', 'world!', 'Foo', 'Bar', 'baz']

As you can see, the re.split() method has successfully split our input string into individual words based on both commas and spaces.

Here's how this works:

The regular expression pattern [,s]+ matches one or more occurrences of either a comma (,) or a whitespace character (s). This is achieved by creating a character class [] that contains the two delimiter characters, followed by the + quantifier which means "one or more". When re.split() is called with this pattern and our input string, it searches for all occurrences of the pattern in the input string. Each occurrence is replaced with an empty string (''), effectively splitting the input string into substrings at each delimiter position.

This approach can be extended to handle multiple delimiters by simply adding more characters to the character class. For example, if you also want to split on semicolons (;) and dashes (-), your regular expression pattern would become:

pattern = r'[,s;-]+'

By using a single call to re.split() with this extended pattern, you can efficiently process strings containing multiple delimiter characters.

Remember, in Python, you can always use the power of regular expressions to simplify and flexibly solve text processing tasks!

Related Articles