Python | Split on last occurrence of delimiter

The splitting of strings has always been discussed in various applications and use cases. One of the interesting variations of list splitting can be splitting the list on delimiter but this time only on the last occurrence of it. Let’s discuss certain ways in which this can be done.

Method #1: Using rsplit(str, 1) The normal string split can perform the split from the front, but Python also offers another method that can perform this very task from the rear end, hence increasing the versatility of applications. 

The original string : gfg, is, good, better, and best
The splitted list at the last comma : ['gfg, is, good, better', 'and best']

Method #2: Using rpartition() This function can also perform the desired reverse partition, but the drawbacks to using this is the construction of additional delimiter value and also the speed is slower than the above method and hence not recommended. 

The original string : gfg, is, good, better, and best
The splitted list at the last comma : ('gfg, is, good, better', ', ', 'and best')

Time Complexity: O(n)

Auxiliary Space: O(n)

Method #3 : Using split() and replace() methods.

The original string : gfg, is, good, better, and best
The splitted list at the last comma : ['gfg, is, good, better', ' and best']

Method #4: Using rfind() and slicing

• Initialize the test string and the delimiter.
• Find the index of the last occurrence of the delimiter in the test string using rfind().
• If the delimiter is found, split the test string into two parts using slicing, where the first part is the substring before the delimiter and the second part is the substring after the delimiter. Otherwise, return the test string as a list with a single element.
• Return the result.

The original string : gfg, is, good, better, and best
The splitted list at the last comma : ['gfg, is, good, better', 'and best']

Time Complexity: O(n), where n is the length of the test string, because the rfind() method iterates over the characters of the string once to find the index of the last occurrence of the delimiter, and the slicing operation takes constant time.
Auxiliary Space: O(n), because we are storing the test string and the result list in memory. However, the slicing operation creates a new string in memory, which takes additional space proportional to the length of the second part of the string (i.e., after the delimiter).

Method #5: Using rsplit() with maxsplit parameter

The original string : gfg, is, good, better, and best
The splitted list at the last comma : ['gfg, is, good, better', 'and best']

Time Complexity: O(n), where n is the length of the input string.
Auxiliary Space: O(1), as we are not using any extra data structure or list to store the output.

Method #6: Using the rindex() method and slicing:

Algorithm:

1. Initialize the input string.
2. Use rindex() method to get the last index of the delimiter.
3. Split the input string using slicing operator.
4. Return the split string as list.

The original string : gfg, is, good, better, and best
The splitted list at the last comma : ['gfg, is, good, better', 'and best']

Time complexity: O(1) – The time complexity of this code is constant, because we’re only performing a small number of operations on a fixed-size input.

Auxiliary Space : O(1) – The space complexity of this code is also constant, as we’re only creating a few variables that store a small amount of data.

Method #7: using numpy:

1. Import the numpy module and define a string test_string.
2. Print the original string.
3. Use the np.char.rpartition() function to split the string at the last occurrence of the delimiter “, “.
4. The function returns a tuple of three elements:
5. The first element contains the part of the string before the last occurrence of the delimiter.
6. The second element contains the last occurrence of the delimiter itself.
7. The third element contains the part of the string after the last occurrence of the delimiter.
8. Extract the first, second, and third elements of the returned tuple to get the desired result.

Output:
The original string : gfg, is, good, better, and best
The splitted list at the last comma : ('gfg, is, good, better', ', ', 'and best')

Time complexity: O(n), where n is the length of the string, because the function iterates through each character of the string once. The time complexity of the remaining operations is O(1). Therefore, the overall time complexity of the code is O(n).

Auxiliary Space: O(n), because the returned tuple contains three new strings, each of which can potentially be as long as the input string. However, in practice, the returned strings are likely to be smaller than the input string since they contain only a portion of the original string.