Python Tuple Exercises: 30 Coding Problems with Solutions

fruits = ("apple", "banana", "cherry", "date")

print("First element:", fruits[0])
print("Last element:", fruits[-1])
print("Length:", len(fruits))Code language: Python (python)

Explanation:

• fruits = ("apple", "banana", "cherry", "date"): Creates a tuple by enclosing comma-separated values in parentheses. Tuples are ordered and immutable once created.
• fruits[0]: Accesses the first element using zero-based indexing. The first item is always at index 0.
• fruits[-1]: Uses negative indexing to access the last element. -1 always refers to the final item, regardless of the tuple’s length.
• len(fruits): Returns the total count of elements in the tuple. Here it returns 4.

t = (50,)

print(t)
print(type(t))Code language: Python (python)

Explanation:

• t = (50,): The trailing comma after 50 is what tells Python this is a tuple, not just an integer wrapped in parentheses. Without the comma, type(t) would return <class 'int'>.
• print(t): Displays (50,). Python always includes the trailing comma in the output of a single-element tuple to make its type visually unambiguous.
• type(t): Confirms the variable is of type tuple. This is a useful sanity check when debugging single-item containers.

colors = ("red", "green")

repeated = colors * 3

print(repeated)Code language: Python (python)

Explanation:

• colors = ("red", "green"): Defines a two-element tuple to use as the base for repetition.
• colors * 3: The * operator on sequences means repetition, not multiplication. It concatenates the tuple with itself three times, producing a new six-element tuple.
• repeated: Stores the result. The original colors tuple is unaffected because tuples are immutable and * always produces a new object.

a = (1, 2)
b = (3, 4)
c = (5, 6)

combined = a + b + c

print(combined)Code language: Python (python)

Explanation:

• a = (1, 2), b = (3, 4), c = (5, 6): Three separate tuples, each holding two integers. None of them will be modified during this operation.
• a + b + c: The + operator on tuples performs concatenation, joining them left to right into a single new tuple. The elements from a come first, followed by b, then c.
• combined: Holds the resulting six-element tuple (1, 2, 3, 4, 5, 6). The originals a, b, and c remain intact.

numbers = (10, 20, 30, 40, 50, 60, 70)

sliced = numbers[2:5]

print(sliced)Code language: Python (python)

Explanation:

• numbers[2:5]: Extracts elements from index 2 up to but not including index 5. This gives (30, 40, 50), which are the elements at indices 2, 3, and 4.
• Start index (inclusive): The slice begins at index 2, which is the value 30.
• Stop index (exclusive): The slice stops before index 5, which is the value 60. That element is not included in the result.
• sliced: Stores the new tuple. Slicing never modifies the original tuple – it always returns a new object.

items = (1, 2, 3, 4, 5)
reversed_items = items[::-1]

print(reversed_items)Code language: Python (python)

Explanation:

• items[::-1]: Uses extended slice notation [start:stop:step]. Omitting start and stop means the slice covers the entire tuple. The step -1 tells Python to walk backwards, producing a reversed copy.
• reversed_items: Stores the new reversed tuple. The original items tuple is unchanged, because tuples are immutable and slicing always creates a new object.
• Alternative: tuple(reversed(items)) achieves the same result. reversed() returns an iterator, so wrapping it in tuple() is necessary to get a tuple back. The [::-1] slice is generally preferred for its brevity.

my_list = [10, 20, 30, 40, 50]

my_tuple = tuple(my_list)

print(my_tuple)
print(type(my_tuple))Code language: Python (python)

Explanation:

• my_list = [10, 20, 30, 40, 50]: A standard Python list – ordered and mutable. Lists support operations like .append() and .remove() that tuples do not.
• tuple(my_list): The tuple() constructor accepts any iterable and returns a new tuple containing the same elements in the same order. The original list is not modified.
• print(my_tuple): Confirms the values are preserved and now stored in a tuple: (10, 20, 30, 40, 50).
• type(my_tuple): Returns <class 'tuple'>, confirming the conversion was successful.

chars = ('a', 'b', 'c')

result = "".join(chars)

print(result)Code language: Python (python)

Explanation:

• chars = ('a', 'b', 'c'): A tuple of individual single-character strings. Each element must be a string for join() to work. Passing a tuple of integers would raise a TypeError.
• "".join(chars): Calls join() on an empty string, which acts as the separator placed between each element. With an empty separator, the characters are concatenated directly with nothing in between.
• result: Stores the final string "abc". The original tuple is unchanged.
• Alternative: Using "-".join(chars) would produce "a-b-c", which is useful when you need a readable separator between items.

fruits = ("apple", "banana", "cherry", "date")

print("cherry" in fruits)
print("mango" in fruits)Code language: Python (python)

Explanation:

• "cherry" in fruits: Scans the tuple from left to right and returns True as soon as a matching element is found. Since "cherry" is present at index 2, the result is True.
• "mango" in fruits: Scans the entire tuple and finds no match, so it returns False.
• Performance note: The in operator on a tuple performs a linear scan, checking each element one by one. For very large collections where frequent lookups are needed, a set offers faster average-case membership testing.

votes = ("yes", "no", "yes", "yes", "no", "yes")

yes_count = votes.count("yes")
no_count = votes.count("no")

print("yes appears", yes_count, "times")
print("no appears", no_count, "times")Code language: Python (python)

Explanation:

• votes.count("yes"): Scans the entire tuple and returns the number of elements equal to "yes". The comparison is exact and case-sensitive, so "Yes" would not be counted.
• votes.count("no"): Repeats the scan for "no", returning 2. Each call to .count() is a separate linear scan of the tuple.
• Context: Tuples have only two built-in methods: .count() and .index(). This is intentional – tuples are designed to be lightweight and immutable, so they expose far fewer methods than lists.

person = ("Alice", 30, "Engineer", "Pune")

name, age, job, city = person

print("Name:", name)
print("Age:", age)
print("Job:", job)
print("City:", city)Code language: Python (python)

Explanation:

• name, age, job, city = person: Python matches each variable on the left to the corresponding element in the tuple by position. name gets "Alice", age gets 30, job gets "Engineer", and city gets "Pune".
• Count must match: If the number of variables does not equal the number of tuple elements, Python raises ValueError: too many values to unpack or ValueError: not enough values to unpack.
• Alternative: If you only need some values, use an underscore _ as a throwaway variable for positions you want to skip, e.g., name, _, job, _ = person.

a = 100
b = 200

a, b = b, a

print("After swap: a =", a, ", b =", b)Code language: Python (python)

Explanation:

• a, b = b, a: Python first evaluates the right-hand side b, a as a whole, creating the temporary tuple (200, 100). It then unpacks that tuple into a and b from left to right, assigning 200 to a and 100 to b.
• Why no temp variable is needed: The right-hand side is fully evaluated before any assignment takes place. This means the original values of both a and b are captured in the temporary tuple before either variable is overwritten.
• Classic alternative: In most other languages, swapping requires a third variable: temp = a; a = b; b = temp. Python’s tuple unpacking makes this unnecessary and is considered the idiomatic approach.

matrix = ((1, 2, 3), (4, 5, 6), (7, 8, 9))

element = matrix[1][2]

print(element)Code language: Python (python)

Explanation:

• matrix[1]: Accesses the element at index 1 of the outer tuple, which is the inner tuple (4, 5, 6).
• matrix[1][2]: Chains a second index onto the result. This accesses index 2 of the inner tuple (4, 5, 6), which is the value 6.
• General pattern: For any level of nesting, you chain one additional index operator per level. A triple-nested tuple would require three index operators: data[i][j][k].
• Immutability note: Even inside a nested structure, you cannot reassign any element. An attempt like matrix[1][2] = 99 raises a TypeError because tuples do not support item assignment at any level.

scores = (88, 95, 70, 62, 99, 74, 85)

total = sum(scores)
highest = max(scores)
lowest = min(scores)

print("Sum:", total)
print("Max:", highest)
print("Min:", lowest)Code language: Python (python)

Explanation:

• sum(scores): Iterates over the tuple and adds all elements together, returning the total 573. It accepts an optional second argument as a starting value, e.g., sum(scores, 100) would return 673.
• max(scores): Scans the tuple and returns the largest value. For numeric tuples, it compares by arithmetic value. For string tuples, it would compare lexicographically.
• min(scores): Scans the tuple and returns the smallest value, in this case 62. Like max(), it raises a ValueError if the tuple is empty.
• Combining results: You can derive the average by combining sum() and len(): sum(scores) / len(scores) gives 81.857..., extending this exercise naturally into a statistics summary.

students = (("Alice", 88), ("Bob", 73), ("Charlie", 95), ("Diana", 61))

sorted_students = tuple(sorted(students, key=lambda x: x[1]))
print("Sorted:", sorted_students)Code language: Python (python)

Explanation:

• sorted(students, key=lambda x: x[1]): The key parameter accepts a callable that is applied to each element before comparison. Here, lambda x: x[1] extracts the second item of every nested tuple as the sort criterion.
• lambda x: x[1]: A compact anonymous function that takes one argument x (a nested tuple) and returns its element at index 1. This avoids importing operator.itemgetter for a simple one-off sort.
• tuple(...): sorted() always returns a list. Wrapping the result in tuple() restores the immutable tuple type to match the original data structure.

numbers = (3, 14, 7, 22, 9, 41, 18, 5)

# Using filter()
filtered_filter = tuple(filter(lambda x: x > 10, numbers))
print("Using filter():", filtered_filter)

# Using a generator expression
filtered_comp = tuple(x for x in numbers if x > 10)
print("Using comprehension:", filtered_comp)Code language: Python (python)

Explanation:

• filter(lambda x: x > 10, numbers): Applies the lambda to every element and keeps only those for which it returns True. filter() returns a lazy iterator, so tuple() is needed to materialise the result.
• tuple(x for x in numbers if x > 10): A generator expression with an inline if condition. This is the more Pythonic style and is easier to read when the condition grows more complex.
• Order is preserved: Both approaches iterate through numbers from left to right, so qualifying elements appear in their original sequence in the output.

numbers = (1, 2, 3, 4, 5, 6)

def square(n):
    return n * n

# Using map()
squared_map = tuple(map(square, numbers))
print("Using map():", squared_map)

# Using a generator expression
squared_comp = tuple(x ** 2 for x in numbers)
print("Using comprehension:", squared_comp)Code language: Python (python)

Explanation:

• map(square, numbers): Applies square to each element of numbers one at a time and returns a lazy map iterator. Wrapping it in tuple() forces evaluation and collects all results.
• def square(n): A named function is used here instead of a lambda to keep the code readable and to make the intent self-documenting. For a one-liner, map(lambda x: x * x, numbers) works identically.
• x ** 2: The exponentiation operator is a clear and concise alternative to x * x. In the generator expression, it makes the transformation immediately obvious without needing a separate function definition.

keys = ("name", "age", "city")
values = ("Alice", 30, "Pune")

mapping = dict(zip(keys, values))
print(mapping)

# Alternative: dictionary comprehension
mapping_comp = {k: v for k, v in zip(keys, values)}
print(mapping_comp)Code language: Python (python)

Explanation:

• zip(keys, values): Pairs elements from both tuples by position, producing a lazy iterator of two-item tuples: ('name', 'Alice'), ('age', 30), and so on.
• dict(...): Consumes the zipped iterator and interprets each two-item tuple as a key-value pair, building the final dictionary in a single call with no explicit loop needed.
• {k: v for k, v in zip(keys, values)}: The dictionary comprehension equivalent. It is slightly more verbose but gives you room to add conditions or transform keys and values inline during construction.

t1 = (1, 2, 3, 4, 5, 6)
t2 = (4, 5, 6, 7, 8, 9)

# Using set intersection
common = tuple(sorted(set(t1) & set(t2)))
print("Common elements:", common)

# Alternative: generator expression (order-preserving)
common_ordered = tuple(x for x in t1 if x in set(t2))
print("Common elements (ordered):", common_ordered)Code language: Python (python)

Explanation:

• set(t1) & set(t2): Converts both tuples to sets and applies the & intersection operator, which returns a new set containing only the values present in both. This is an O(min(n, m)) operation, making it efficient for large inputs.
• tuple(sorted(...)): Since set intersection produces an unordered result, sorted() ensures the output is in ascending order before it is converted back to a tuple.
• x for x in t1 if x in set(t2): The generator expression approach converts t2 to a set once for O(1) membership checks, then iterates through t1 in order. This preserves the original sequence of t1 while still benefiting from fast set lookups.

colours = ("red", "green", "blue")
print("Original:", colours)

temp = list(colours)
temp[1] = "yellow"
colours_modified = tuple(temp)

print("Modified:", colours_modified)Code language: Python (python)

Explanation:

• list(colours): Creates a brand-new mutable list containing the same elements as the tuple. The original tuple is not touched at any point in this process.
• temp[1] = "yellow": Performs the desired in-place change on the list. This would raise a TypeError if attempted directly on the tuple, because tuples do not support item assignment.
• tuple(temp): Converts the modified list back into a new immutable tuple. The result is a separate object in memory; the variable colours still points to the original, unmodified tuple.

t = (1, 2, [3, 4, 5])
print("Before:", t)
print("Tuple id before:", id(t))

t[2].append(99)

print("After: ", t)
print("Tuple id after: ", id(t))
print("Same object?", id(t) == id(t))Code language: Python (python)

Explanation:

• t[2].append(99): t[2] retrieves the reference to the list stored at index 2. Calling .append() mutates that list object in place. The tuple’s slot at index 2 still holds the exact same reference; only the list’s contents have grown.
• id(t): Returns the unique memory address of the tuple object. Printing it before and after confirms the tuple itself is the same object in memory – its identity has not changed, even though its printed representation looks different.
• The immutability rule clarified: Tuple immutability means the tuple’s references cannot be rebound. You cannot do t[2] = something_else. But the object that a reference points to can change freely if that object is mutable – which is exactly what a list is.

def flatten(t):
    for item in t:
        if isinstance(item, tuple):
            yield from flatten(item)
        else:
            yield item

nested = (1, (2, 3), (4, (5, (6, 7))))
result = tuple(flatten(nested))
print("Flattened:", result)Code language: Python (python)

Explanation:

• isinstance(item, tuple): The base condition that separates recursive cases from base cases. If the current item is itself a tuple, the function dives into it; otherwise, the item is a plain value and is yielded directly to the caller.
• yield from flatten(item): Delegates iteration to the recursive call, forwarding every value it produces upward through the call stack. This avoids manually looping over the sub-results and keeps the function body concise.
• tuple(flatten(nested)): Since flatten is a generator function, calling it returns a lazy iterator. Passing that iterator to tuple() forces full evaluation and collects every yielded value into the final flat tuple.

import sys

data = range(1_000_000)
large_list  = list(data)
large_tuple = tuple(data)

list_size  = sys.getsizeof(large_list)
tuple_size = sys.getsizeof(large_tuple)
difference = list_size - tuple_size

print(f"List size:  {list_size:,} bytes")
print(f"Tuple size: {tuple_size:,} bytes")
print(f"Difference: {difference:,} bytes ({difference / 1024:.2f} KB)")Code language: Python (python)

Explanation:

• sys.getsizeof(): Returns the memory footprint of the container object itself in bytes. For a list, this includes extra capacity reserved for future appends (over-allocation). A tuple allocates exactly as much space as it needs and no more.
• Over-allocation in lists: Python lists maintain a buffer of spare slots to make .append() efficient. This means a list nearly always occupies more memory than a tuple of the same length, because the tuple has no need to grow and carries no such buffer.
• Shallow vs. deep size: sys.getsizeof() measures only the container, not the objects it references. Both the list and the tuple point to the same integer objects in memory, so the element memory is identical for both. The difference shown is purely the container overhead.

from collections import namedtuple

Employee = namedtuple("Employee", ["name", "department", "salary"])

employees = (
    Employee("Alice",   "Engineering", 95000),
    Employee("Bob",     "Marketing",   72000),
    Employee("Charlie", "Engineering", 88000),
)

for emp in employees:
    print(f"{emp.name} works in {emp.department} and earns ${emp.salary:,}")

top = max(employees, key=lambda e: e.salary)
print(f"Highest paid: {top.name} (${top.salary:,})")Code language: Python (python)

Explanation:

• namedtuple("Employee", [...]): Dynamically creates a new tuple subclass called Employee whose fields can be accessed by name. The result behaves exactly like a regular tuple for indexing, unpacking, and memory usage, but adds attribute-style access for clarity.
• emp.name, emp.department, emp.salary: Named field access makes the code self-documenting. Compare this to a plain tuple where emp[0], emp[1], emp[2] would give no indication of what each position represents.
• max(employees, key=lambda e: e.salary): Finds the Employee instance with the highest salary value. Because named tuples are still tuples, they work seamlessly with all built-in functions like max(), min(), and sorted().

d = {}

# Fully immutable tuple: works as a key
try:
    d[(1, 2)] = "immutable tuple"
    print(f"(1, 2) as key: success, value = \"{d[(1, 2)]}\"")
except TypeError as e:
    print(f"(1, 2) as key: TypeError - {e}")

# Tuple containing a list: raises TypeError
try:
    d[(1, [2])] = "tuple with list"
    print(f"(1, [2]) as key: success, value = \"{d[(1, [2])]}\"")
except TypeError as e:
    print(f"(1, [2]) as key: TypeError - {e}")

# Demonstrating hash() directly
print("\nhash((1, 2))  =", hash((1, 2)))
try:
    print("hash((1, [2])) =", hash((1, [2])))
except TypeError as e:
    print(f"hash((1, [2])): TypeError - {e}")Code language: Python (python)

Explanation:

• Hashability requirement: Python dictionaries and sets store keys by their hash value. For this to work correctly, a key’s hash must remain constant for its entire lifetime in the container. Objects whose value can change – such as lists – are deliberately made unhashable to prevent silent data corruption.
• Why (1, 2) is hashable: Both elements are integers, which are immutable. A tuple is hashable if and only if every element it contains is also hashable. Python computes the tuple’s hash from the hashes of its elements, so a fully immutable tuple produces a stable, reliable hash value.
• Why (1, [2]) is not hashable: The list [2] inside the tuple is mutable. If it were allowed as a dictionary key and then modified, the hash would change, making the key unretrievable. Python prevents this entirely by raising a TypeError at the moment you attempt to hash any tuple that contains a mutable element, however deeply nested.