Practice Now
Python
Programming
Data Structures
Tuple
List Conversion

Convert tuple to list and back

Data Structures & Algorithms practice on Codemia

Step through 300 algorithm problems with animated visualisers that show the data structure changing as the code runs.

Practice algorithms
Data StructuresPython

Introduction

In Python, converting between tuples and lists is done with the built-in list() and tuple() constructors. list(my_tuple) creates a mutable list from a tuple, and tuple(my_list) creates an immutable tuple from a list. This is a common operation when you need to modify a sequence that was returned as a tuple, or when you need to use a sequence as a dictionary key (which requires immutability).

Tuple to List

python
1my_tuple = (1, 2, 3, 4, 5)
2my_list = list(my_tuple)
3
4print(my_list)        # [1, 2, 3, 4, 5]
5print(type(my_list))  # <class 'list'>
6
7# Now you can modify it
8my_list.append(6)
9my_list[0] = 10
10print(my_list)  # [10, 2, 3, 4, 5, 6]

List to Tuple

python
1my_list = [1, 2, 3, 4, 5]
2my_tuple = tuple(my_list)
3
4print(my_tuple)        # (1, 2, 3, 4, 5)
5print(type(my_tuple))  # <class 'tuple'>
6
7# Tuples are immutable — cannot modify
8# my_tuple[0] = 10  # TypeError: 'tuple' object does not support item assignment

Common Use Case: Modify a Tuple

Since tuples are immutable, the only way to "modify" one is to convert to a list, make changes, and convert back:

python
1# Original tuple
2coordinates = (10, 20, 30)
3
4# "Modify" by converting to list and back
5temp = list(coordinates)
6temp[1] = 25
7coordinates = tuple(temp)
8
9print(coordinates)  # (10, 25, 30)

Nested Tuples and Lists

list() and tuple() only convert the outermost level. Nested structures keep their original types:

python
1nested_tuple = ((1, 2), (3, 4), (5, 6))
2converted = list(nested_tuple)
3print(converted)        # [(1, 2), (3, 4), (5, 6)]
4print(type(converted[0]))  # <class 'tuple'> — inner tuples unchanged
5
6# Deep conversion requires recursion or comprehension
7deep_converted = [list(inner) for inner in nested_tuple]
8print(deep_converted)  # [[1, 2], [3, 4], [5, 6]]
python
1# Deep conversion in both directions
2def deep_to_list(obj):
3    if isinstance(obj, (tuple, list)):
4        return [deep_to_list(item) for item in obj]
5    return obj
6
7def deep_to_tuple(obj):
8    if isinstance(obj, (tuple, list)):
9        return tuple(deep_to_tuple(item) for item in obj)
10    return obj
11
12nested = ((1, [2, 3]), (4, (5, 6)))
13print(deep_to_list(nested))   # [[1, [2, 3]], [4, [5, 6]]]
14print(deep_to_tuple(nested))  # ((1, (2, 3)), (4, (5, 6)))

Converting for Dictionary Keys

Tuples can be dictionary keys because they are hashable (if their contents are hashable). Lists cannot:

python
1# Tuple as dictionary key — works
2point_data = {(0, 0): "origin", (1, 0): "right", (0, 1): "up"}
3print(point_data[(0, 0)])  # "origin"
4
5# List as dictionary key — fails
6# {[0, 0]: "origin"}  # TypeError: unhashable type: 'list'
7
8# Convert list to tuple for use as key
9coords = [0, 0]
10point_data[tuple(coords)] = "origin"

Converting for Function Arguments

Use * to unpack a list or tuple as function arguments:

python
1def add(a, b, c):
2    return a + b + c
3
4values_tuple = (1, 2, 3)
5values_list = [1, 2, 3]
6
7print(add(*values_tuple))  # 6
8print(add(*values_list))   # 6

Performance Comparison

python
1import timeit
2
3data = list(range(1000))
4
5# List to tuple
6timeit.timeit(lambda: tuple(data), number=100_000)  # ~0.5s
7
8# Tuple to list
9data_tuple = tuple(data)
10timeit.timeit(lambda: list(data_tuple), number=100_000)  # ~0.5s
11
12# Both are O(n) — every element is copied

Tuples use slightly less memory than lists because they are fixed-size:

python
1import sys
2
3data = list(range(100))
4print(sys.getsizeof(data))          # ~920 bytes (list)
5print(sys.getsizeof(tuple(data)))   # ~848 bytes (tuple)

Working with Named Tuples

python
1from collections import namedtuple
2
3Point = namedtuple('Point', ['x', 'y'])
4p = Point(10, 20)
5
6# Convert to list
7p_list = list(p)
8print(p_list)  # [10, 20]
9
10# Convert to dict (named tuples support this)
11p_dict = p._asdict()
12print(p_dict)  # {'x': 10, 'y': 20}
13
14# Modify and create new named tuple
15p_list[0] = 15
16p2 = Point(*p_list)
17print(p2)  # Point(x=15, y=20)
18
19# Or use _replace for immutable updates
20p3 = p._replace(x=15)
21print(p3)  # Point(x=15, y=20)

Common Pitfalls

  • Assuming conversion is deep: list(((1,2), (3,4))) gives [(1,2), (3,4)] — inner tuples remain tuples. For full conversion of nested structures, use a recursive function or list comprehension.
  • Modifying the converted list affects nothing: list(my_tuple) creates a new list. Changing the list does not affect the original tuple (and vice versa). They are independent copies (shallow copy).
  • Using lists as dictionary keys or set elements: Lists are unhashable and cannot be used as dictionary keys or in sets. Convert to tuples first: my_set.add(tuple(my_list)).
  • Forgetting single-element tuple syntax: (1) is not a tuple — it is the integer 1 in parentheses. A single-element tuple requires a trailing comma: (1,). list((1,)) gives [1], but list((1)) raises TypeError.
  • Performance with large sequences: Both list() and tuple() copy every element, which is O(n). For very large sequences, avoid unnecessary back-and-forth conversion. If you need mutability, keep the data as a list throughout.

Summary

  • list(my_tuple) converts a tuple to a mutable list; tuple(my_list) converts back
  • Conversion is shallow — nested structures retain their original types
  • Use list conversion when you need to modify an immutable tuple
  • Use tuple conversion when you need a hashable sequence (dictionary keys, set elements)
  • Both operations are O(n) and create independent copies (shallow)
  • Single-element tuples require a trailing comma: (value,)
Related reading
Course
Intermediate
27 lessons
15 hours
DSA Fundamentals

Master algorithmic patterns and data structures through hands-on LeetCode-style problems - from arrays and hashing to dynamic programming and advanced graphs.

View the course
Track what you have practised

A free account saves your progress, solutions and study plan across every problem on Codemia.

Data Structures & Algorithms practice on Codemia

Step through 300 algorithm problems with animated visualisers that show the data structure changing as the code runs.

Practice algorithms
Codemia
© 2026 Codemia
Resources
Legal
Social
All Rights Reserved.