List Comprehensions

Two Ways to Build Larger Lists

Python provides two fundamental operators for combining and duplicating lists. The + operator concatenates lists by placing their elements in sequence. The * operator repeats a list a specified number of times. Both operations create a new list object, so neither operation modifies the original list or lists.

Joining Lists with Plus

List concatenation joins two or more lists into one new list. The elements from the first list occupy the first positions. The elements from the next list follow immediately after them. The original order within each input list is preserved.

first = [1, 2, 3]
second = [4, 5, 6]
combined = first + second

print(combined)
print(first)
print(second)

[1, 2, 3, 4, 5, 6]
[1, 2, 3]
[4, 5, 6]

The result contains the first list followed by the second list. The two input lists still contain their original elements.

Predicting Concatenated Indices

If the first list has length three, its elements occupy indices 0 through 2 in the result. The second list starts at index 3. More generally, the second list's first element appears immediately after the final element of the first list, and the rest of the second list continues from there.

Repeating a List with Asterisk

List repetition uses the * operator with a list and an integer. The integer specifies how many times the list's sequence appears in the new list. For example, repeating [1, 2, 3] three times produces [1, 2, 3, 1, 2, 3, 1, 2, 3]. The original list is not modified.

pattern = [1, 2, 3]
repeated = pattern * 3

print(repeated)
print(pattern)

[1, 2, 3, 1, 2, 3, 1, 2, 3]
[1, 2, 3]

A useful way to predict the indices is to treat each repetition as a complete segment. Here the original segment has three elements, so the first copy uses indices 0 through 2, the second uses 3 through 5, and the third uses 6 through 8.

New Results, Unchanged Inputs

The diagram separates the inputs from the result. After first + second, first and second retain their original contents, while combined refers to the newly created list. The same principle applies when a list is repeated: the repeated result is new, and the original list remains unchanged.

Choosing the Right Operator

Use concatenation when separate list segments or results need to be merged into one sequence. Use repetition when one pattern needs to appear several times, such as when creating a list with a repeated structure or pattern.

Common Prediction Errors

• Expecting + to modify one of the original lists

  Concatenation creates a new list object instead of performing an in-place modification.

  Fix: Store or use the result of first + second when you need the combined list.

• Starting the second list at index 0 in the concatenated result

  The second list follows the first list, so its elements receive later indices.

  Fix: Count the elements in the first list first; the second list begins immediately after them.

• Reading * as a request to multiply individual list values

  List repetition duplicates the list's sequence rather than multiplying each element.

  Fix: Copy the complete sequence the specified number of times.

• Using an operand of the wrong type

  Concatenation requires lists on both sides, while repetition requires a list and an integer.

  Fix: Check the operand types before choosing + or *.

Apply the Index Rules

Key Takeaways

1. The + operator concatenates two or more lists in order and returns a new list.
2. The * operator repeats a list's sequence a specified number of times and returns a new list.
3. Concatenation requires list operands; repetition requires a list and an integer.
4. After concatenation, the second list begins at the index immediately following the final index of the first list.
5. Neither operation modifies its original list or lists.