The most efficient and easiest approach is to convert a tuple into a list using the list() Constructor. It is a built-in Constructor that accepts an iterable, such as a tuple, as an argument and returns a list.
Tuples are immutable objects, but lists are mutable objects. Converting a tuple to a list would be useful when modifying the sequence’s elements. Use the tuple() constructor for list-to-tuple conversion.
This method is O(n) time complexity and works for tuples of any size.
The list() Constructor creates a shallow copy.
# Creating a tuple with integers
numeric_tuple = (5, 10, 15, 20, 25)
print("Original Tuple:", numeric_tuple)
# Output: Original Tuple: (5, 10, 15, 20, 25)
print(type(numeric_tuple))
# Output: <class 'tuple'>
# Converting the tuple into a list
numeric_list = list(numeric_tuple)
print("Converted List:", numeric_list)
# Output: Converted List: [5, 10, 15, 20, 25]
print(type(numeric_list))
# Output: <class 'list'>
Empty tuple to list
If you want to convert an empty tuple to a list, you will get an empty list.
# Creating an empty tuple
empty_tuple = ()
print("Original Tuple:", empty_tuple)
# Output: Original Tuple: ()
print(type(empty_tuple))
# Output: <class 'tuple'>
# Converting the tuple into a list
empty_list = list(empty_tuple)
print("Converted List:", empty_list)
# Output: Converted List: []
print(type(empty_list))
# Output: <class 'list'>
Single-Element Tuples
Let’s create a single-element tuple and convert it into a list.
# Creating a single element tuple
single_tuple = (19, )
print("Original Tuple:", single_tuple)
# Output: Original Tuple: (19,)
print(type(single_tuple))
# Output: <class 'tuple'>
# Converting the tuple into a list
single_list = list(single_tuple)
print("Converted List:", single_list)
# Output: Converted List: [19]
print(type(single_list))
# Output: <class 'list'>
Named Tuples to Lists
You can import a namedtuple from the “collections” module. To create a namedtuple, use the namedtuple() Constructor.
You can convert a namedtuple to a list using list() Constructor.
from collections import namedtuple
Person = namedtuple('Person', ['name', 'age'])
p = Person('Krunal', 31)
# Converting to list (loses field names)
lst = list(p)
# Output: ['Krunal', 31]
# Preserve order via dictionary (if needed)
dict_p = p._asdict()
ordered_values = list(dict_p.values())
# Same as list(p)
Shallow Copy Issue
Since the list constructor creates a shallow copy, adding an element to a list after converting from a tuple will show that the tuple also reflects this addition.
tup = ([1, 2], 3) lst = list(tup) lst[0].append(3) # Modifies the original tuple's list! print(lst) # Output: ([1, 2, 3], 3) print(tup) # Output: ([1, 2, 3], 3)
To fix this issue, use the copy.deepcopy() to avoid unintended side effects.
import copy tup = ([1, 2], 3) print(tup) # Output: ([1, 2], 3) lst = copy.deepcopy(tup) # Perform deep copy lst[0].append(3) # This modification will NOT affect 'tup' print(lst) # Output: ([1, 2, 3], 3) print(tup) # Output: ([1, 2], 3) # Original remains unchanged
The output tuple is unaffected even after modifying the list.
Here are the four alternate ways to convert a tuple to a list:
- Using the list comprehension
- Using an asterisk(*) operator
- Using the map() Function
- Using a for loop
Approach 1: Using list comprehension
If you are dealing with a tuple of tuples and you want to convert it into a list of lists, you should definitely use “list comprehension”.
tpl_of_tpls = ((1, 2), (3, 4), (5, 6)) print(tpl_of_tpls) # Output: ((1, 2), (3, 4), (5, 6)) lst_of_lsts = [list(inner) for inner in tpl_of_tpls] print(lst_of_lsts) # Output: [[1, 2], [3, 4], [5, 6]]
Approach 2: Using an asterisk(*) operator
The unpacking operator * allows you to unpack the elements of a tuple into a new list.
# Creating a tuple number_tuple = (5, 10, 15, 20, 25) print(number_tuple) # Output: (5, 10, 15, 20, 25) print(type(number_tuple)) # Output: <class 'tuple'> number_list = [*number_tuple] print(number_list) # Output: [5, 10, 15, 20, 25] print(type(number_list)) # Output: <class 'list'>
Approach 3: Using the map()
The map() function applies a specified function to each item of an iterable and converts the result into a list.
# Creating a tuple number_tuple = (5, 10, 15, 20, 25) print(number_tuple) # Output: (5, 10, 15, 20, 25) print(type(number_tuple)) # Output: <class 'tuple'> number_list = list(map(lambda x: x, number_tuple)) print(number_list) # Output: [5, 10, 15, 20, 25] print(type(number_list)) # Output: <class 'list'>
Approach 4: Using a for loop
Create an empty list and use the append() method within a for loop to add each element of the tuple, one at a time.
# Creating a tuple
number_tuple = (5, 10, 15, 20, 25)
print(number_tuple)
# Output: (5, 10, 15, 20, 25)
print(type(number_tuple))
# Output: <class 'tuple'>
# Initialize an empty list
number_list = []
# Iterate over each element in the tuple
for item in number_tuple:
# Append each element to the list
number_list.append(item)
print(number_list)
# Output: [5, 10, 15, 20, 25]
print(type(number_list))
# Output: <class 'list'>
That’s all!
