String Methods: split() and join()

One Assignment, Several Values

Unpacking lets one assignment statement distribute the elements of a sequence across multiple variables. Instead of assigning each element separately by index, you place the target variables on the left side and the sequence on the right side.

first, second = ("red", "blue")

The first element is assigned to first, and the second element is assigned to second. The same unpacking idea applies to tuples, lists, strings, and other sequence types.

Mapping Elements to Names

Read an unpacking assignment from left to right. The first target receives the first sequence element, the second target receives the second element, and so on. The variables do not receive the whole sequence; they receive the individual elements mapped to their positions.

Unpacking and Index Assignment

Unpacking is syntactic sugar for index-based assignment. In other words, the shorter unpacking form represents the same element-by-element mapping that could be written with indexes.

name1, name2 = ["Ada", "Grace"]

From Strings to Unpackable Parts

split() transforms one string into a list of substrings. That resulting sequence can be unpacked when the number of target variables matches the number of parts.

first, last = "Ada Lovelace".split()

first is Ada
last is Lovelace

The important sequence operation occurs after split(): the produced parts are assigned from left to right to the target variables.

Joining Parts into One String

join() combines multiple strings from a sequence into one string. A separator is used as the connection between the sequence elements.

parts = ["Ada", "Lovelace"]
full_name = " ".join(parts)

Ada Lovelace

split() and join() move in opposite directions: split() turns one string into multiple parts, while join() turns multiple string elements into one string. When split() creates exactly the parts expected by an unpacking assignment, the two ideas can be used together in a clear transformation.

When Counts Do Not Match

A correct unpacking assignment requires an exact count match. If the sequence has more or fewer elements than the target variables, the mismatch causes a ValueError.

• Using two target variables for a sequence with three elements

  The sequence contains more elements than the two target variables can receive, so the counts do not match.

  Fix: Provide three target variables or use a sequence containing two elements.

• Using three target variables for a sequence with two elements

  There are fewer sequence elements than target variables.

  Fix: Make the number of targets equal to the number of sequence elements.

• Assuming split() always produces the number of parts you expected

  The resulting sequence contains three parts, but the assignment has only two target variables.

  Fix: Check the parts produced by split() before unpacking them, then adjust the targets or the input.

Practice the Transformation

Key Takeaways

1. Unpacking assigns multiple variables from a sequence in one statement.
2. The assignment follows element order: the first target receives the first element, the second target receives the second element, and so on.
3. Unpacking is syntactic sugar for equivalent index-based assignments.
4. split() produces a list of substrings that can be unpacked when the element count matches the target count.
5. join() combines string elements into one string using a separator.
6. A mismatch between target variables and sequence elements causes a ValueError.