Python Tuples: Basics

Grasp Python tuple: ordered sequence of elements that cannot be changed after creation. Ideal for data that requires fixed content and specific order, such as geometrical coordinates or representing a computer program’s instruction set.

What Is Tuple in Python?

Tuples in Python act like ordered collections of items, similar to lists. However, unlike lists, tuples are immutable, meaning you cannot change their contents after they are created. Think of a tuple as a fixed container that holds your data.

Python Tuple Example

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

Explanation

• Line 1: Creates a tuple named fruits containing a sequence of fruits.
• Line 2: Prints the entire tuple, showing the items within the parentheses.

Output

(‘apple’, ‘banana’, ‘cherry’)

Python Tuple Syntax

tuple_name = (item1, item2, …, itemN)

• tuple_name: Name you choose for tuple.
• ( ): Round brackets enclose the items in a tuple.
• item1, item2, etc.: Values you want to store in the tuple are separated by commas. These can be any data type in Python.

Key Characteristics of Python Tuples

Breakdown of the essential characteristics of tuples in Python:

• Ordered: Tuples maintain the order of items you put into them.
• Immutable: You cannot change items once a tuple is created.
• Versatile: Tuples can hold a mix of different data types, just like lists.
• Fixed Size: After creation, a tuple cannot grow or shrink. You can’t add new items to a tuple or delete existing ones.
• Supports Indexing and Slicing: You can access individual elements of a tuple using their index (like lists) or extract portions using slicing.

Methods for Creating Python Tuples

In Python, you can create a tuple containing no elements. This is useful when you need a placeholder tuple or want to initialize one that will be filled later.

Syntax

empty_tuple = ()

• Round brackets () are used to define the tuple.
• The absence of any elements within the parentheses indicates an empty tuple.

Example

shopping_cart = ()
print(shopping_cart)

Explanation

• Line 1: Assigns an empty tuple to the variable shopping_cart.
• Line 2: Prints the shopping_cart, displaying empty parentheses ().

Constructing Tuples Using Parentheses ( )

Tuples in Python are similar to shopping lists in that they hold multiple items in a specific order. You typically create tuples using a pair of parentheses (()). Inside the parentheses, you put the items you want in your tuple, separated by commas. Here’s how the syntax works:

Syntax

my_tuple = (item1, item2, item3…)

Example

# Create a tuple named fruits with three items
fruits = ("apple", "banana", "orange")

Adding Elements in Python Tuples

Tuples in Python are immutable, meaning their contents cannot be modified after creation. This makes them reliable for storing data that shouldn’t be changed. However, if you want to add elements to what seems like an existing tuple, here’s how you can achieve it:

Creating a New Tuple

1. Convert the original tuple to a list using list().
2. Append the new element(s) to the list using list.append().
3. Create a new tuple from the modified list using tuple().

Example

fruits = ("apple", "banana")  # Original tuple
fruits_list = list(fruits)
fruits_list.append("cherry")
fruits = tuple(fruits_list)
print(fruits)  # Output: ('apple', 'banana', 'cherry')

Explanation

• Line 1: Creates a tuple fruits with two elements.
• Line 2: Converts fruits to a list named fruits_list because lists are mutable (changeable).
• Line 3: Appends the string “cherry” to the fruits_list.
• Line 4: Creates a new tuple fruits from the modified fruits_list.
• Line 5: Prints the new fruits tuple, which now includes “cherry”.

Updating Elements in Python Tuples

While Python tuples are immutable, meaning their elements cannot be directly changed after creation, you can create a new tuple with the desired modifications. Here’s how to achieve this:

Creating a New Tuple

1. Convert the original tuple to a list using list().
2. Modify the element(s) at the desired index(es) in the list.
3. Create a new tuple from the modified list using tuple().

Example

colors = ("red", "green", "blue")  # Original tuple
colors_list = list(colors)
colors_list[1] = "yellow"
updated_tuple = tuple(colors_list)
print(updated_tuple)  # Output: ('red', 'yellow', 'blue')

Explanation

• Line 1: Creates a tuple colors with three color names.
• Line 2: Converts colors to a list named colors_list to allow modifications.
• Line 3: Changes the element at index 1 (which is “green”) to “yellow” within the colors_list.
• Line 4: Creates a new tuple updated_tuple from the modified colors_list.
• Line 5: Prints the updated_tuple, showing the update reflected.

Accessing Elements in Python Tuples

Tuples, like lists, allow you to access specific elements using their position within the tuple. This position is called an index, and it starts from 0. Here’s how to retrieve elements using indexing:

Syntax

element = my_tuple[index]

• index: The numerical position (0-based) of the element you want to retrieve.

Example

fruits = ("apple", "banana", "cherry")
first_fruit = fruits[0]
last_fruit = fruits[2]
print(first_fruit, last_fruit)

Explanation

• Line 1: Creates a tuple fruits containing three fruit names.
• Line 2: Assigns the element at index 0 (“apple”) to the variable first_fruit.
• Line 3: Assigns the element at index 2 (“cherry”) to the variable last_fruit (remember, indexing starts from 0).
• Line 4: Prints both first_fruit and last_fruit, demonstrating element access.

Output

apple cherry

Finding Elements in Python Tuples

The tuple.index() method helps you locate a specific element’s index (position) within the tuple. It’s useful when you want to know where an element is stored.

Syntax

element_index = my_tuple.index(value)

• my_tuple: Tuple you want to search in.
• value: Element you’re looking for.

Note: index() will only return the index of the first occurrence of the element. If the element appears multiple times, it will only find the index of the first one.

Example

colors = ("red", "green", "blue", "green", "yellow")
green_index = colors.index("green")
print(green_index)  # Output: 1 (since "green" is at index 1)

Explanation

• Line 1: Creates a tuple colors with various color names.
• Line 2: Uses colors.index("green") to find the index of the first occurrence of “green” in the colors tuple. It stores the index (which is 1) in the variable green_index.
• Line 3: Prints the green_index, showing the position of “green” in the tuple.

Deleting Elements from a Python Tuple

Since Python tuples are immutable, you can’t directly remove elements from them. However, you can create a new tuple that excludes the unwanted element. This approach provides a way to achieve the practical outcome of “deleting” an element.

Syntax

new_tuple = my_tuple[:index] + my_tuple[index + 1:]

• my_tuple: The original tuple you want to modify.
• index: The index of the element you want to exclude (avoid using negative indexing here).
• [:index]: Creates a new tuple from the beginning of my_tuple up to (but not including) the element at index index.
• [index + 1:]: Creates a new tuple starting from the element after index index to the end of my_tuple.
• +: Concatenates the two sliced tuples to form a new tuple without the excluded element.

Example

letters = ("a", "b", "c", "d", "e")
new_tuple = letters[:2] + letters[3:]  # Exclude element at index 2 ("c")
print(new_tuple)  # Output: ('a', 'b', 'd', 'e')

Explanation

• Line 1: Creates a tuple letters with some lowercase letters.
• Line 2: Uses slicing to create a new tuple new_tuple.
  • letters[:2]: Gets elements from the beginning (index 0) up to but not including index 2 (“c”), which results in (‘a’, ‘b’).
  • letters[3:]: Gets elements starting from index 3 (which is “d”) to the end, which results in (‘d‘, ‘e‘). The + operator combines these two sliced tuples into a new tuple new_tuple, excluding “c”.
• Line 3: Prints the new_tuple, showing that “c” has been removed (from the perspective of this new tuple).

Iterating Over Python Tuples

The for loop is a popular and straightforward way to iterate through each element in a Python tuple. It assigns a temporary variable to each element as you loop through the tuple.

Example

letters = ("a", "b", "c", "d")
for letter in letters:
    print(letter)  # Print each letter

Explanation

• Line 1: Creates a tuple letters with some lowercase letters.
• Line 2: Starts a for loop. The letter variable will hold each element (letter) from the letters tuple during each iteration.
• Line 3: The indented code block contains a print statement that prints the current value of the letter variable. This will print each letter in the tuple on a new line.