Last week a junior dev on my team had a list of route stops and a tuple of fallback hubs, and asked which Python incantation would fold the tuple into the list. The answer is not a single incantation. There are four ways, and each one changes the list in a different way.
Adding a tuple to a list sounds like a corner case, but it shows up whenever you read a fixed-shape row from a database and want to merge it with a running list of results. Below are the four options, with runnable code and the actual output from a Python 3.13 session.
What we are starting with
A list in Python is an ordered, mutable collection. You can append, extend, slice-assign, and pop.
A tuple is an ordered, immutable collection. Once you create it, you cannot add, remove, or replace elements. The syntax is round brackets instead of square brackets.
a = [1, 2, 3]
b = (4, 5, 6)
print(type(a).__name__, type(b).__name__)
Method 1: append()
list.append puts one object on the end of the list. If you hand it a tuple, the tuple becomes a single nested element. The list grows by one slot, not by the tuple’s length.
a = [1, 2, 3]
b = (4, 5, 6)
a.append(b)
print(a)
Output
Notice the trailing parentheses. The tuple is sitting inside the list as one item. If you then iterate the list, that one item is a tuple of three integers.
Method 2: the + operator
The + operator on lists builds a brand new list. Wrap the tuple in square brackets to make it a one-element list, then concatenate. The original list a is unchanged, and the result lands in c.
a = [1, 2, 3]
b = (4, 5, 6)
c = a + [b]
print(c)
Output
Same visible result, different memory behaviour. Use + when you want a new list and you are okay paying the allocation cost. It is the right call in functional pipelines and in code that must not mutate the input.
Method 3: extend()
list.extend iterates the argument and appends every element. Hand it a tuple and each tuple element lands as its own list entry. No nesting.
a = [1, 2, 3]
b = (4, 5, 6)
a.extend(b)
print(a)
Output
extend is the most common answer to the question “how do I add a tuple to a list as separate items”. extend is also the right tool when the input is a generator, an iterable of database rows, or another list.
Method 4: slice assignment
Slicing a list with an empty range on the right side and assigning an iterable to it inserts every element at that position. The result is a mutation, not a copy.
a = [1, 2, 3]
b = (4, 5, 6)
a[len(a):] = b
print(a)
Output
Slicing past the end is a clean idiom for in-place append. Reading a[len(a):] = iterable is shorter than writing a.append for every element when the iterable is short.
Which one should I use
Pick append when you want the tuple to remain a tuple inside the list. Pick extend when you want the tuple’s elements to land as individual list items.
Pick + when you need a new list. Pick slice assignment when you want in-place mutation in a single statement.
Speed is a secondary concern at list sizes below a few thousand.
extend and slice assignment both mutate in place.
append and + leave the original list untouched when you use +. append mutates the original list, but the result is nested, not flat.
Conclusion
Adding a tuple to a list is one of those small Python operations where four idioms look similar and behave differently. The shape of the result tells you which method to reach for: nested tuple, flat elements, new list, or in-place insert.
Run the four snippets in a REPL and watch the output. The difference between [1, 2, 3, (4, 5, 6)] and [1, 2, 3, 4, 5, 6] is the difference between append and extend. Pick deliberately.
Does append add a tuple as one item or as separate items?
append adds the tuple as one nested item. The list grows by one slot, and the tuple sits inside it as a single element. To add the elements of the tuple as separate list items, use extend.
Is the + operator faster or slower than append?
The + operator creates a new list, so it costs O(n) memory and a copy. append mutates in place and is generally faster for adding a single item. For adding many elements, extend beats repeated append.
Can I use extend with any iterable?
Yes. extend accepts any iterable, including tuples, lists, sets, generators, and file objects. It loops the iterable and appends each yielded element to the list.
What is the difference between extend and slice assignment?
Both mutate the list in place. extend appends the elements to the end. Slice assignment a[len(a):] = iterable is equivalent to extend for end-of-list inserts and lets you choose the insert position with a different slice.
