Concepts / List Comprehensions

List Comprehensions

List concatenation with + joins two or more lists into a single new list without modifying the originals.

  • Programming

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.

[1, 2, 3]first list+concatenate[1, 2, 3, 4, 5, 6]new list[4, 5, 6]second listfirst sequencenext sequencecombined order
How do the elements from two input lists flow into one combined list?
python
Output (expected)
[1, 2, 3, 4, 5, 6]
[1, 2, 3]
[4, 5, 6]
Output
The result contains the first list followed by the second list. The two input lists still contain their original elements.

Predicting Concatenated Indices

What do you think happens?

Suppose a = [10, 20] and b = [30, 40, 50]. After c = a + b, which value is at c[3]?

  • 20

  • 30

  • 40

  • 50

Reveal answer
Answer:

40

The two elements from a occupy c[0] and c[1]. The elements from b then occupy c[2], c[3], and c[4], so b[1], which is 40, becomes c[3].

c[0]10c[1]20c[2]30c[3]40c[4]50next indexnext indexnext indexnext index
What element is at each index after two lists are joined?

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.

r[0]1r[1]2r[2]3r[3]1r[4]2r[5]3r[6]1r[7]2r[8]3next indexnext indexrepeat sequencenext indexnext indexrepeat sequencenext indexnext index
How does the original sequence map onto each repeated segment in the new list?
python
Output (expected)
[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

first[1, 2]first[1, 2]second[3, 4]second[3, 4]combined[1, 2, 3, 4]unchangedunchangedjoined intojoined into
What changes after concatenation or repetition, and which lists remain unchanged?

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

NeedOperatorOperand typesResult
Join list contents in sequence+List and listA new combined list
Repeat one list pattern*List and integerA new repeated list

Both operations create new list objects and leave their original lists unchanged.

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

  • Common mistake

    Expecting + to modify one of the original lists

    What it looks like
    first = [1, 2] and second = [3, 4] produce a new combined result when joined.
    Why it fails

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

    Do this instead

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

  • Common mistake

    Starting the second list at index 0 in the concatenated result

    What it looks like
    For [10, 20] + [30, 40, 50], treating 30 as result[0].
    Why it fails

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

    Do this instead

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

  • Common mistake

    Reading * as a request to multiply individual list values

    What it looks like
    Treating [1, 2, 3] * 3 as [3, 6, 9].
    Why it fails

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

    Do this instead

    Copy the complete sequence the specified number of times.

  • Common mistake

    Using an operand of the wrong type

    What it looks like

    Trying to concatenate a list with a non-list or repeat a list with a non-integer.

    Why it fails

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

    Do this instead

    Check the operand types before choosing + or *.

Apply the Index Rules

EASY

Given left = [7, 8, 9] and right = [10, 11], determine the value at each index of left + right. Then determine the value at each index of [0, 1] * 3. Finally, state which original lists remain unchanged.

Hints
  • Place every element of left first, starting at index 0.
  • Begin right immediately after the final element of left.
  • For repetition, write the complete [0, 1] pattern three times.
Worked example

Tracing two results

Predict joined = [7, 8, 9] + [10, 11] and repeated = [0, 1] * 3.

  1. 1
    Join the lists

    The first list supplies indices 0 through 2. The second list follows at indices 3 and 4, so joined is [7, 8, 9, 10, 11].

  2. 2
    Repeat the pattern

    The two-element pattern appears three times, so repeated is [0, 1, 0, 1, 0, 1].

  3. 3
    Check the inputs

    The original lists are not modified because both operations create new list objects.

Result

joined = [7, 8, 9, 10, 11] and repeated = [0, 1, 0, 1, 0, 1].

Key Takeaways

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

At a glance

  • Use + to place list elements from multiple lists into one new sequence.
  • Use * with a list and an integer to repeat the list's sequence.
  • Predict concatenated indices by placing the second list after the first.
  • Predict repeated indices by treating each copy as a complete segment.
  • Both operators create new list objects and leave their original lists unchanged.

Related Topics

Related concepts

More concepts starting with L