List Methods: append(), extend(), and insert()

Two Ways to Build a Larger List

Python provides two operators for combining or duplicating lists. The + operator concatenates lists by placing their elements in sequence. The * operator repeats the elements of a list a specified number of times. Both operations produce a new list, so the original list or lists are not modified.

Reading Concatenated Indices

Concatenation preserves the order of each input list. Every element from the first list occupies the beginning of the new list. The elements from the second list then follow immediately after them. If the first list has three elements, its elements use indices 0 through 2 in the result, and the second list begins at index 3.

a = [1, 2, 3]
b = [4, 5, 6]
c = a + b

print(c)
print(c[0])
print(c[3])
print(a)
print(b)

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

In this example, c contains six elements. The elements from a occupy c[0] through c[2]. The elements from b begin at c[3], so b[0] becomes c[3], b[1] becomes c[4], and b[2] becomes c[5]. The printed values of a and b show that concatenation did not modify either original list.

Predicting Repeated Blocks

Repetition duplicates a complete list pattern. If the original list has n elements and it is repeated three times, the result contains three consecutive copies of the original pattern. The first copy occupies the earliest positions, the second copy follows it, and the third copy follows the second.

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

print(repeated)
print(repeated[0])
print(repeated[3])
print(repeated[6])
print(pattern)

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

The repeated list has nine elements. The first copy uses indices 0 through 2, the second uses indices 3 through 5, and the third uses indices 6 through 8. Notice that repeated values can appear at different indices because each copy occupies a different position in the result.

Separate Result Objects

The result of a + or * expression is a new list object. The input lists remain available and unchanged. This matters when the same input list is needed later: assigning the result to another name gives you a larger or repeated list while preserving the original list's contents.

Choosing the List Operation

Mistakes to Avoid

• Expecting a + b to change a or b directly.

  Concatenation creates a new list. The expression has a combined result, but the original lists remain unchanged.

  Fix: Store the result when you need to use it later: combined = a + b.

• Thinking repetition rearranges the elements.

  Repetition places complete copies of the original sequence one after another.

  Fix: Predict consecutive blocks: [1, 2, 3, 1, 2, 3, 1, 2, 3].

• Using the wrong index after concatenation.

  The second list does not restart at index 0 in combined. Its elements begin after all elements from a.

  Fix: Because a has three elements, b[0] becomes combined[3], b[1] becomes combined[4], and b[2] becomes combined[5].

• Treating the + and * operations as interchangeable.

  The first operation combines two list operands, while the second repeats one list using an integer.

  Fix: Use + for concatenation and * for repetition.

Practice the Prediction

1. The + operator concatenates lists in order and returns a new list. The * operator repeats a list pattern and returns a new list. In a concatenated result, the second list begins after all elements of the first. In a repeated result, each complete copy occupies its own consecutive block of indices. Neither operation modifies its original list. The supplied comparison also distinguishes append(), extend(), and insert() as operations for adding one item at the end, adding multiple items, or placing one item at a particular position.