Skip to main content

How to Split Strings into Multiple Variables in Python

Splitting a string into multiple variables based on a delimiter is a common task in Python.

This guide demonstrates how to use the str.split() method to effectively divide a string and assign the resulting parts to separate variables, along with considerations for error handling and dealing with variable numbers of parts.

Basic String Splitting and Unpacking​

The core technique involves using str.split() to split the string and then unpacking the resulting list into individual variables:

my_str = 'tutorial reference com'
a, b, c = my_str.split(' ')  # Split on spaces

print(a)  # Output: tutorial
print(b)  # Output: reference
print(c)  # Output: com
  • my_str.split(' ') splits the string at each space, returning a list of substrings.
  • a, b, c = ... This is called unpacking. It assigns each element of the list to the corresponding variable.
  • The number of variables must match the number of elements in the list produced by split(). Otherwise, a ValueError will occur.

Using maxsplit for Limited Splits​

The maxsplit argument to split() controls the maximum number of splits:

my_str = 'tutorial reference com'
a, b = my_str.split(' ', 1)  # Split only once

print(a)  # Output: tutorial
print(b)  # Output: reference com
  • my_str.split(' ', 1) splits the string at the first space only, resulting in a list with two elements. The rest of the string is kept together in the second element.

Handling Missing or Extra Values​

If the number of parts after splitting might not always match the number of variables, you have a few options:

Using a Default Value with *​

Use the * operator to collect "extra" values into a list:

my_str = 'tutorial reference com extra'
a, b, *rest = my_str.split()
print(a)    # Output: tutorial
print(b)    # Output: reference
print(rest) # Output: ['com', 'extra']

my_str = 'tutorial reference'
a, b, *rest = my_str.split()
print(a)    # Output: tutorial
print(b)    # Output: reference
print(rest) # Output: [] (Empty list since there are no extras)
  • a, b, *rest: a gets the first part, b gets the second, and rest gets a list of all remaining parts (which could be empty). This avoids ValueError if there are more than two parts.

Using a try-except Block​

Use a try-except block to gracefully handle potential ValueError exceptions:

my_str = 'tutorial reference com'
try:
    a, b = my_str.split()  # Attempt to unpack into two variables
    print(a)
    print(b)
except ValueError:
    print("Incorrect number of values to unpack")
  • This approach catches the ValueError that occurs if there are too many or too few parts after splitting. This is crucial for robust code.

A better approach to prevent errors is to store the result of split into a list, and check if the length is correct:

my_str = 'tutorial reference com'

my_list = my_str.split(' ')

if len(my_list) == 3:
    a,b,c = my_list
    print(a)
    print(b)
    print(c)
else:
    print("Incorrect number of values to unpack")

Handling Leading/Trailing Delimiters and Empty Strings​

If your string might have leading/trailing spaces (or whatever your delimiter is), split() will produce empty strings in the result:

my_str = ' tutorial reference com '
print(my_str.split(' '))  # Output: ['', 'tutorial', 'reference', 'com', '']

To remove empty strings, use filter(None, ...):

my_str = ' tutorial reference com '
parts = list(filter(None, my_str.split(' ')))
print(parts) # Output: ['tutorial', 'reference', 'com']

# Now you can unpack if the length matches
if len(parts) == 3:
    a,b,c = parts
    print(a) # Output: tutorial
    print(b) # Output: reference
    print(c) # Output: com
  • The filter removes the empty strings, and the result can be unpacked into the variables, if the length is correct.

Choosing the Right Delimiter​

split() can use any string as a delimiter. For comma-separated values:

my_str = 'tutorial,reference,com'
a, b, c = my_str.split(',')  # Split on commas
print(a) # Output: tutorial
print(b) # Output: reference
print(c) # Output: com
  • The split() method takes a delimiter string as an argument, in this case the , comma character.

Table of Contents