Tuples are another fundamental data structure in Python, similar to lists but with one crucial difference: they are immutable. This means that once a tuple is created, its elements cannot be changed, added, or removed. Tuples are defined by enclosing elements in parentheses ().

Creating Tuples

python
# An empty tuple
empty_tuple = ()

# A tuple of integers
numbers_tuple = (1, 2, 3, 4, 5)

# A mixed-type tuple
mixed_tuple = (1, "hello", True, 3.14)

# A tuple with a single item (requires a trailing comma!)
single_item_tuple = ("only_one",)

# Tuple packing (parentheses are optional for creation if ambiguity isn't present)
packed_tuple = 10, 20, 30

print(empty_tuple)
print(numbers_tuple)
print(mixed_tuple)
print(single_item_tuple)
print(packed_tuple)
print(type(numbers_tuple)) # Output: <class 'tuple'>
print(type(single_item_tuple)) # Output: <class 'tuple'>
print(type(("not_a_tuple"))) # Output: <class 'str'> (without comma)

Accessing Tuple Elements (Indexing and Slicing)

Just like lists and strings, elements in a tuple can be accessed using indexing and slicing. Since tuples are ordered, these operations work exactly the same way.

python
my_tuple = ('P', 'y', 't', 'h', 'o', 'n')

print(my_tuple[0])    # Output: P
print(my_tuple[-1])   # Output: n
print(my_tuple[1:4])  # Output: ('y', 't', 'h')
print(my_tuple[::-1]) # Output: ('n', 'o', 'h', 't', 'y', 'P')

Immutability of Tuples

The key characteristic of tuples is immutability.

Once created, you cannot:

• Change an element (`my_tuple

json
[0]

= 'X'will raise aTypeError`).

• Add new elements (my_tuple.append('!') will raise an AttributeError).
• Remove elements (my_tuple.remove('P') or del my_tuple[0] will raise AttributeError/TypeError).

python
example_tuple = (1, 2, 3)
# example_tuple[0] = 10 # This would cause a TypeError
# example_tuple.append(4) # This would cause an AttributeError

Why Use Tuples? (Use Cases)

Despite their immutability, tuples are highly useful in several scenarios:

1. Data Integrity: When you need to ensure that data remains constant throughout the program's execution, tuples provide a safeguard against accidental modification.

2. Function Return Values: Functions can return multiple values, which Python handles as a tuple. This is a very common pattern.

   python
   def get_coordinates():
       return 10, 20 # Returns a tuple (10, 20)
   
   x, y = get_coordinates() # Tuple unpacking
   print(f"X: {x}, Y: {y}") # Output: X: 10, Y: 20

3. Dictionary Keys: Because tuples are immutable, they can be used as keys in dictionaries (lists cannot, as dictionary keys must be hashable, which requires immutability).

   python
   locations = {
       ("New York", "NY"): "Empire State Building",
       ("San Francisco", "CA"): "Golden Gate Bridge"
   }
   print(locations[("New York", "NY")]) # Output: Empire State Building

4. Faster Iteration: Tuples can sometimes be slightly faster to iterate over than lists, especially for large collections, because their fixed size allows for some optimizations.

5. Passing Immutable Data: When passing data to functions, using tuples guarantees that the original data cannot be accidentally modified by the function.

Tuple Methods

Tuples have fewer built-in methods than lists due to their immutability, but they do have:

• len(tuple): Returns the number of items.
• tuple.count(item): Returns the number of times an item appears.
• tuple.index(item): Returns the index of the first occurrence of an item. Raises ValueError if not found.

python
my_tuple = (1, 2, 2, 3, 4, 2)
print(len(my_tuple))       # Output: 6
print(my_tuple.count(2))   # Output: 3
print(my_tuple.index(3))   # Output: 3
# print(my_tuple.index(99)) # ValueError: tuple.index(x): x not in tuple

Choosing between lists and tuples depends on whether you need a mutable or immutable collection. If the data is meant to be constant, a tuple is generally the more appropriate choice for both clarity and integrity.

Key Takeaways:

• Tuples are ordered, immutable collections, defined with ().
• Elements cannot be changed, added, or removed after creation.
• Access elements via indexing and slicing, just like lists.
• Useful for data that should not change (e.g., coordinates, record attributes).
• Commonly used as function return values (tuple packing/unpacking) and dictionary keys.
• Methods include len(), count(), index().