HOWTO · Python
How to Convert Tuple to List in Python
This tutorial demonstrates how to convert tuples into lists in Python. Learn simple methods like using the list() constructor, list comprehension, and the unpacking operator. Each method is explained with practical examples to enhance your coding skills. Whether you're a beginner or an experienced developer, this guide will help you understand tuple-to-list conversion effectively.
On this page
To convert a tuple to a list in Python, pass the tuple to the list() constructor: list(my_tuple). Tuples are immutable and lists are mutable, so converting a tuple is how you get a changeable version of its data when you need to add, remove, or reorder elements. The conversion creates a new outer list; the elements themselves are not converted, and their order and values are preserved exactly. This article shows the direct conversion, the unpacking form, and the two standard ways to convert nested tuples, whose inner tuples need one extra step.
Convert a Tuple to a List with list()
The list() constructor accepts any iterable and builds a new list from its elements. It works for tuples of any content, including tuples that mix different types:
mixed_tuple = ('apple', 42, 3.14, True)
my_list = list(mixed_tuple)
print(my_list)
Output:
['apple', 42, 3.14, True]
Only the container changes. The string, integer, float, and Boolean inside the new list are the same objects as before, in the same order; nothing about them is converted. If you later modify my_list, the original tuple is unaffected, because the list is a separate object. For a flat tuple, this one call is the complete answer, and it is the method to reach for first.
Convert a Tuple to a List with Unpacking
You can also build the list by unpacking the tuple with the * operator inside a list display:
my_tuple = (1, 2, 3, 4, 5)
my_list = [*my_tuple]
print(my_list)
Output:
[1, 2, 3, 4, 5]
The expression [*my_tuple] unpacks the tuple’s elements into a new list. This form relies on generalized unpacking (PEP 448), so it is available in Python 3.5 and later; it does not work on Python 2 or on Python 3.4 and earlier. Unpacking is most useful when the new list combines several sequences at once, for example [*first, *second], where list() alone would need an extra concatenation step. For a plain single-tuple conversion it produces exactly the same list as list().
Convert Nested Tuples with a List Comprehension
A plain list() call converts only the outer container. If the tuple contains other tuples, the inner ones stay tuples:
nested = ((1, 2), (3, 4), (5, 6))
print(list(nested))
Output:
[(1, 2), (3, 4), (5, 6)]
To convert every inner tuple as well, apply list() to each row with a list comprehension:
nested = ((1, 2), (3, 4), (5, 6))
converted = [list(row) for row in nested]
print(converted)
Output:
[[1, 2], [3, 4], [5, 6]]
Each row is one inner tuple, and list(row) turns it into a list, so the result is a list of lists. The same pattern extends to deeper nesting by applying it at each level you need to change.
Convert Nested Tuples with map()
The map() function reaches the same result by applying list to every element of the outer tuple. Because map() returns an iterator, wrap it in list() to build the final list:
nested = ((1, 2), (3, 4), (5, 6))
converted = list(map(list, nested))
print(converted)
Output:
[[1, 2], [3, 4], [5, 6]]
map(list, nested) calls list once per inner tuple, which is exactly what the comprehension in the previous section spells out. Choose whichever form reads better in your code: the comprehension shows the per-element operation explicitly, while map() is compact when the conversion is a single existing function. Both leave the original nested tuple unchanged and return a new list of lists.