Python Lists: Append vs Extend – A Comprehensive Guide
Python lists are one of the most fundamental and flexible data structures in the language. Lists allow you to store ordered collections of items and efficiently access them by index. Two of the most commonly used methods for modifying lists are append() and extend(). While they seem similar at first glance, there are important differences in how they work. In this guide, we‘ll take an in-depth look at the append() and extend() methods, explain their functionality, and highlight when you should use each one.
The Basics of Python Lists
Before diving into append() and extend(), let‘s briefly review what Python lists are and how they work. A list is an ordered, mutable collection of items enclosed in square brackets. For example:
numbers = [1, 2, 3, 4, 5]
names = ["Alice", "Bob", "Charlie"]You can access individual list elements by their index, starting from 0:
print(numbers[0]) # Output: 1
print(names[1]) # Output: "Bob" Lists are mutable, meaning you can change their contents after creation. You can overwrite values at a specific index or use methods like append() and extend() to add new elements. Speaking of which, let‘s take a closer look at those…
The append() Method
The append() method adds a single element to the end of a list. Here‘s the general syntax:
my_list.append(item)The append() method modifies the original list in-place by adding the provided item as a new element at the end. Some examples:
numbers = [1, 2, 3]
numbers.append(4)
print(numbers) # Output: [1, 2, 3, 4]
names = ["Alice", "Bob"]
names.append("Charlie")
print(names) # Output: ["Alice", "Bob", "Charlie"]It‘s important to note that the append() method always adds the passed item as a single element, even if it‘s another list or collection:
my_list = [1, 2, 3]
my_list.append([4, 5])
print(my_list) # Output: [1, 2, 3, [4, 5]]As you can see, the entire [4, 5] list was added as the fourth element in my_list, rather than adding 4 and 5 as individual elements. This is where extend() comes into play…
The extend() Method
The extend() method adds all elements from one list (or any iterable) to the end of another list. The general syntax is:
list1.extend(list2) After calling extend(), list1 will contain all of its original elements, followed by each element from list2 in order. Importantly, the elements from list2 are added individually, rather than as a single nested list:
numbers = [1, 2, 3]
numbers.extend([4, 5])
print(numbers) # Output: [1, 2, 3, 4, 5]
names = ["Alice", "Bob"]
names.extend(["Charlie", "David"])
print(names) # Output: ["Alice", "Bob", "Charlie", "David"]As mentioned, you can extend a list with any iterable, not just another list. So tuples, sets, and even strings will work:
my_list = [1, 2, 3]
my_list.extend((4, 5))
print(my_list) # Output: [1, 2, 3, 4, 5]
my_list.extend({"a", "b"})
print(my_list) # Output: [1, 2, 3, 4, 5, "a", "b"]
my_list.extend("xyz")
print(my_list) # Output: [1, 2, 3, 4, 5, "a", "b", "x", "y", "z"] However, be careful when extending with a dict – only the dict‘s keys will be added to the list, not the values.
Append vs Extend: Key Differences
Now that we‘ve seen append() and extend() in action, let‘s summarize their key differences:
- Number of elements added:
- append() adds a single element to the end of a list
- extend() adds multiple elements to the end of a list
- Argument type:
- append() takes a single object as its argument, which becomes the last element
- extend() takes an iterable as its argument, and each element is added individually
- Nesting behavior:
- append() will add a passed list/iterable as a single nested element
- extend() will add each element from the passed iterable to the first level of the list
So as a general rule: use append() to add one new element, and extend() to add multiple elements from another collection.
Performance Considerations
In terms of time complexity, a single call to append() is O(1) – it always takes the same amount of time regardless of the list size, as it simply adds the new element to the end.
The complexity of extend() depends on the size of the iterable being added. Extending a list with another list of length N will take O(N) time, as each element must be added individually. So for very large lists, extend() will be slower than append().
However, it‘s usually still faster to use one extend() call rather than multiple append() calls in a loop. Here‘s an example comparing the two:
def append_multiple(my_list, new_elements):
for element in new_elements:
my_list.append(element)
def extend_once(my_list, new_elements):
my_list.extend(new_elements)
# Test with large lists
big_list = list(range(1_000_000))
new_elements = list(range(1_000))
%timeit append_multiple(big_list.copy(), new_elements)
# 694 µs ± 31.8 µs per loop
%timeit extend_once(big_list.copy(), new_elements)
# 254 µs ± 7.68 µs per loop As you can see, using extend() was over 2x faster than making 1,000 separate append() calls in a loop. This is because calling extend() only requires one full list traversal, while the append() loop requires 1,000 traversals. So in general, prefer extend() for adding many elements.
Practical Use Cases
To solidify your understanding, let‘s walk through a couple practical examples of when you might use append() and extend().
Imagine you‘re writing a program to track your expenses. You have a list called expenses that starts off empty. Each time you make a purchase, you add the cost to the list. In this case, you‘d use append() since you‘re adding a single value at a time:
expenses = []
expenses.append(10.50) # Buying lunch
expenses.append(5.75) # Coffee
expenses.append(8.00) # Parking
print(expenses)
# Output: [10.5, 5.75, 8.0] Now let‘s say you want to categorize your expenses. You make two new lists: food for meal costs and transport for things like gas and parking. At the end of the week, you want to combine all the lists into a master weekly_expenses list. This is a perfect use case for extend():
food = [10.50, 18.65, 15.26] # Lunch, Dinner, Breakfast
transport = [8.00, 5.50, 12.00] # Parking, Train, Gas
weekly_expenses = []
weekly_expenses.extend(expenses)
weekly_expenses.extend(food)
weekly_expenses.extend(transport)
print(weekly_expenses)
# Output: [10.5, 5.75, 8.0, 10.5, 18.65, 15.26, 8.0, 5.5, 12.0]By using extend(), we can combine the smaller lists into the final weekly_expenses list while keeping all the costs as individual elements for easy calculations later.
Conclusion
To recap, the append() method adds one element to the end of a list, while extend() adds multiple elements from an iterable to a list. Use append() to add single items and extend() to concatenate lists or add many elements at once.
Some key things to remember:
- append(item) always adds item as a single element
- extend(iterable) adds each element from the iterable individually
- extend() is usually faster than an append() loop for adding many elements
- Be careful using extend() with non-list iterables like dicts, as you may get unexpected results
I hope this in-depth look at append() vs extend() has been helpful! With a solid grasp of these key list methods, you‘ll be able to efficiently manipulate and combine lists in your Python projects. Happy coding!