<p>In the previous chapter, we learned about lists, which are used to store multiple values in a single variable. Python also provides another useful collection type called a tuple. A tuple is similar to a list, but there is an important difference: <strong>Lists are mutable, while tuples are immutable.</strong></p>
<p>This means that after creating a tuple, its individual elements cannot normally be changed, added, or removed. Tuples are useful when you want to store a collection of values that should remain unchanged.</p>
<h2>What you will learn in this chapter:</h2>
<ul>
<li>What tuples are and how to create them</li>
<li>Accessing tuple elements and negative indexing</li>
<li>Tuple slicing and tuple unpacking</li>
<li>Looping through tuples and built-in tuple methods</li>
<li>Nested tuples and conversions between lists and tuples</li>
<li>Returning multiple values from functions</li>
<li>Practical examples, common mistakes, and mini projects</li>
</ul>
<h2>8.2 What is a Tuple?</h2>
<p>A tuple is an ordered collection of items. Tuples are generally written using parentheses <code>()</code>. Like lists, tuple elements have indexes beginning from 0.</p>
<h2>8.3 Creating a Tuple</h2>
<p>The simplest way to create a tuple is to use parentheses, or you can create a tuple containing numbers directly.</p>
<h2>8.4 Empty Tuple</h2>
<p>An empty tuple contains no elements and has a length of 0.</p>
<h2>8.5 Single-Item Tuple</h2>
<p>There is an important rule when creating a tuple with only one item. Writing <code>number = (10)</code> is treated by Python as an ordinary integer expression. To create a single-item tuple, you need a trailing comma: <code>number = (10,)</code>.</p>
<h2>8.6 Tuple Without Parentheses</h2>
<p>Python also allows you to create a tuple without parentheses (known as <em>tuple packing</em>), though using parentheses often makes code easier to read.</p>
<h2>8.7 Tuple Indexing & 8.8 Negative Indexing</h2>
<p>Tuple indexing works just like list indexing. Tuples also support negative indexing, where the last item has an index of <code>-1</code>.</p>
<h2>8.9 to 8.12 Tuple Slicing & Reversing</h2>
<p>You can extract portions of a tuple using slicing syntax <code>tuple[start:stop]</code>. Omitting start or stop values slices from the beginning or to the end respectively. You can also reverse a tuple using slicing with a step of <code>-1</code> (<code>numbers[::-1]</code>).</p>
<h2>8.13 Tuples Are Immutable & 8.14 Why Are Tuples Immutable?</h2>
<p>The most important property of a tuple is that it is <strong>immutable</strong>—you cannot directly change, add, or reassign elements. Immutability is useful for fixed configuration values, geographic coordinates, or records that should not be accidentally modified.</p>
<h2>8.15 Tuple Length & 8.16 Checking an Item</h2>
<p>Use the <code>len()</code> function to find the number of elements, and the <code>in</code> or <code>not in</code> operators to check if an item exists within a tuple.</p>
<h2>8.17 & 8.18 Looping Through a Tuple</h2>
<p>You can process each element in a tuple using either a <code>for</code> loop or a <code>while</code> loop with an index counter.</p>
<h2>8.19 to 8.21 Tuple Methods</h2>
<p>Because tuples are immutable, they have fewer methods than lists. The two commonly used tuple methods are:</p>
<ul>
<li><code>count()</code>: Returns the number of times a value appears in a tuple.</li>
<li><code>index()</code>: Returns the index of the first occurrence of a value.</li>
</ul>
<h2>8.22 Tuple Concatenation & 8.23 Repeating a Tuple</h2>
<p>Two tuples can be combined using the <code>+</code> operator to create a new tuple, and repeated using the <code>*</code> operator.</p>
<h2>8.24 to 8.27 Packing, Unpacking, and Swapping</h2>
<p>Tuple packing groups multiple values into a tuple automatically, while tuple unpacking assigns those elements to separate variables. Python also supports extended unpacking using the <code>*</code> operator (e.g., <code>first, *middle, last = numbers</code>) and clean variable swapping (<code>a, b = b, a</code>).</p>
<h2>8.28 & 8.29 Nested Tuples</h2>
<p>A tuple can contain other tuples, which is helpful for storing structured data like student records or matrices. You can easily loop through and unpack nested tuples.</p>
<h2>8.30 & 8.31 Converting Between Lists and Tuples</h2>
<p>You can convert an iterable/list into a tuple using <code>tuple()</code>, or convert a tuple into a list using <code>list()</code> if modification is necessary.</p>
<h2>8.32 Modifying a Tuple Indirectly</h2>
<p>While a tuple cannot be changed in-place, you can modify data indirectly by creating a new combined tuple (e.g., <code>numbers = numbers + (40,)</code>).</p>
<h2>8.33 to 8.36 Built-in Functions with Tuples</h2>
<p>Tuples can hold mixed data types and work seamlessly with built-in functions like <code>min()</code>, <code>max()</code>, <code>sum()</code>, and <code>len()</code> to calculate totals and averages.</p>
<h2>8.37 Tuple as a Function Return Value</h2>
<p>Tuples are commonly used when a function needs to return multiple values at once (e.g., returning both a total and a difference).</p>
<h2>8.38 to 8.42 Practical Examples</h2>
<p>Tuples excel at representing fixed real-world structures such as:</p>
<ul>
<li>Student Records</li>
<li>Coordinate Pairs $(X, Y)$</li>
<li>RGB Color Values</li>
<li>Days of the Week & Menu Items</li>
</ul>
<h2>8.43 Common Tuple Mistakes</h2>
<ol>
<li><strong>Forgetting the comma</strong> in a single-item tuple (<code>(10)</code> vs <code>(10,)</code>).</li>
<li><strong>Trying to modify a tuple</strong> in-place, which raises a <code>TypeError</code>.</li>
<li><strong>Incorrect unpacking</strong> where the number of variables does not match the number of tuple elements.</li>
</ol>
<h2>8.44 to 8.46 Mini Projects</h2>
<p>Tuples power compact and efficient mini-projects like Student Result Analyzers, Coordinate Managers, and Contact Record storage systems.</p>
<h2>8.47 When to Use a Tuple vs. 8.48 When to Use a List</h2>
<table border="1" cellpadding="8" cellspacing="0" style="width:100%; border-collapse: collapse; border-color: #cbd5e1;">
<thead>
<tr style="background-color: #f1f5f9;">
<th>Feature</th>
<th>List</th>
<th>Tuple</th>
</tr>
</thead>
<tbody>
<tr><td><strong>Syntax</strong></td><td><code>[]</code></td><td><code>()</code></td></tr>
<tr><td><strong>Mutable</strong></td><td>Yes</td><td>No</td></tr>
<tr><td><strong>Methods</strong></td><td><code>append()</code>, <code>remove()</code>, etc.</td><td><code>count()</code>, <code>index()</code></td></tr>
<tr><td><strong>Use Case</strong></td><td>Data that changes frequently</td><td>Fixed collections & records</td></tr>
</tbody>
</table>
<h2>8.49 Chapter Summary</h2>
<p>The key concept to remember from this chapter is: <strong>A list is mutable, while a tuple is immutable.</strong> Use tuples when data should remain constant, and lists when data needs to change dynamically.</p>
HTML Example
# Student Result Analyzer Example
def calculate_result(marks):
total = sum(marks)
average = total / len(marks)
return total, average
student = ("Aman", (85, 78, 92, 88))
name, marks = student
total, average = calculate_result(marks)
print("Student:", name)
print("Marks:", marks)
print("Total:", total)
print("Average:", average)