Take the content of a list and append it to another list

Efficiently Appending One Python List to Another

Learn various methods to combine two Python lists, from simple concatenation to in-place extensions, and understand their performance implications.

Python lists are versatile data structures, and a common operation is combining their contents. Whether you need to create a new list containing elements from two existing lists or extend one list with the elements of another, Python offers several straightforward and efficient ways to achieve this. This article will explore the most common techniques, their use cases, and performance considerations.

Understanding List Appending vs. Extending

Before diving into the methods, it's crucial to distinguish between appending an element and extending a list. Appending adds a single item to the end of a list. If that item is another list, it will be added as a single nested list. Extending, on the other hand, iterates over an iterable (like another list) and adds each of its elements individually to the target list.

flowchart TD
    A[Start with List1 and List2]
    A --> B{Goal: Combine Lists?}
    B -->|Yes, create new list| C[Method 1: Concatenation (+)]
    B -->|Yes, modify List1 in-place| D[Method 2: extend()]
    B -->|Yes, modify List1 in-place| E[Method 3: Slice Assignment]
    B -->|No, add List2 as single item| F[Method 4: append()]
    C --> G[Result: New List3 with all elements]
    D --> G
    E --> G
    F --> H[Result: List1 with List2 as a nested element]
    G --> I[End]
    H --> I

Decision flow for combining Python lists

Method 1: Using the + Operator for Concatenation

The + operator is the most intuitive way to combine two lists into a new one. It creates a brand new list containing all elements from the first list, followed by all elements from the second list. The original lists remain unchanged.

list1 = [1, 2, 3]
list2 = [4, 5, 6]

list3 = list1 + list2
print(list3)
# Output: [1, 2, 3, 4, 5, 6]

print(list1)
# Output: [1, 2, 3] (list1 is unchanged)
print(list2)
# Output: [4, 5, 6] (list2 is unchanged)

Concatenating two lists using the + operator

Method 2: Using the extend() Method

The extend() method is a list method that adds all the elements of an iterable (like another list, tuple, or string) to the end of the current list. Unlike +, extend() modifies the list in-place and does not return a new list.

list_a = ['apple', 'banana']
list_b = ['cherry', 'date']

list_a.extend(list_b)
print(list_a)
# Output: ['apple', 'banana', 'cherry', 'date']

print(list_b)
# Output: ['cherry', 'date'] (list_b is unchanged)

Extending a list using the extend() method

Method 3: Using Slice Assignment

Slice assignment offers another way to extend a list in-place. By assigning an iterable to a slice at the end of the list, you can effectively append all its elements. This method is often considered less readable than extend() but achieves the same result.

my_list = [10, 20]
other_list = [30, 40, 50]

my_list[len(my_list):] = other_list
print(my_list)
# Output: [10, 20, 30, 40, 50]

# This also works with an empty slice at the end:
list_x = ['a', 'b']
list_y = ['c', 'd']
list_x[2:] = list_y
print(list_x)
# Output: ['a', 'b', 'c', 'd']

Extending a list using slice assignment

Method 4: Using append() (for nested lists)

While append() is primarily for adding a single element, if that element happens to be another list, it will add the entire list as a single item, resulting in a nested list structure. This is important to understand to avoid unintended results when trying to extend a list.

main_list = [1, 2]
sub_list = [3, 4]

main_list.append(sub_list)
print(main_list)
# Output: [1, 2, [3, 4]]

# If you then append another item, it goes after the nested list
main_list.append(5)
print(main_list)
# Output: [1, 2, [3, 4], 5]

Appending a list as a single element, creating a nested list