What is a Python Tuple?
A tuple is an ordered collection of elements, enclosed in parentheses ( ) and separated by commas. Each element in the tuple is referred to as an item. Tuples can contain any data type and a single tuple can store a mix of data types.
Syntax:
tuple_name = (item1, item2, item3, ...)
Example:
# Tuple of integers
numbers = (1, 2, 3)
# Tuple of strings
fruits = ("apple", "banana", "cherry")
# Mixed data types
mixed_tuple = (1, "hello", 3.14, True)
# Nested tuple
nested_tuple = ((1, 2), ("a", "b"))
Characteristics of Tuples
- Ordered:
Elements are stored in a specific sequence and this order is preserved. - Immutable:
Once created, the elements in a tuple cannot be modified, added or removed. - Allow Duplicates:
Tuples can have duplicate values. - Heterogeneous Data:
Tuples can store elements of different data types.
Why Use Tuples?
- Immutability: Useful for fixed data, such as configuration settings or database keys.
- Faster than Lists: Tuples consume less memory and have faster iteration compared to lists.
- Hashable: Tuples can be used as keys in dictionaries if their elements are also hashable.
Creating a Tuple
You can create a tuple by placing elements inside parentheses ( ).
Examples:
# Empty tuple
empty_tuple = ()
# Tuple with one element (note the trailing comma)
single_element_tuple = (5,)
print(type(single_element_tuple)) # Output: <class 'tuple'>
# Tuple without parentheses (packing)
packed_tuple = 1, 2, 3
print(packed_tuple) # Output: (1, 2, 3)
Accessing Tuple Elements
You can access tuple elements using their index. Indexing in Python starts at 0.
Syntax:
tuple_name[index]
Examples:
fruits = ("apple", "banana", "cherry")
print(fruits[0]) # Output: apple
print(fruits[-1]) # Output: cherry (negative index starts from the end)
Tuple Slicing
Slicing allows you to extract a subset of a tuple.
Syntax:
tuple_name[start:end:step]
Examples:
numbers = (0, 1, 2, 3, 4, 5)
# Slice from index 1 to 4
print(numbers[1:5]) # Output: (1, 2, 3, 4)
# Slice with step
print(numbers[0:6:2]) # Output: (0, 2, 4)
# Slice in reverse order
print(numbers[::-1]) # Output: (5, 4, 3, 2, 1, 0)
Tuple Methods
Although tuples are immutable, they provide some useful methods:
| Method | Description |
|---|---|
| count() | Counts occurrences of a specified value. |
| index() | Returns the index of the first occurrence. |
Examples:
numbers = (1, 2, 2, 3, 4)
# Count occurrences
print(numbers.count(2)) # Output: 2
# Find index
print(numbers.index(3)) # Output: 3
Operations with Tuples
1. Concatenation:
You can combine two or more tuples using the + operator.
tuple1 = (1, 2)
tuple2 = (3, 4)
result = tuple1 + tuple2
print(result) # Output: (1, 2, 3, 4)
2. Repetition:
You can repeat a tuple using the * operator.
tuple1 = (1, 2)
result = tuple1 * 3
print(result) # Output: (1, 2, 1, 2, 1, 2)
3. Membership Test:
You can check if an element exists in a tuple using the in keyword.
fruits = ("apple", "banana", "cherry")
print("apple" in fruits) # Output: True
Iterating Through a Tuple
You can iterate through a tuple using a for loop.
Example:
fruits = ("apple", "banana", "cherry")
for fruit in fruits:
print(fruit)
Tuple Unpacking
You can extract values from a tuple into individual variables using unpacking.
Example:
numbers = (1, 2, 3)
a, b, c = numbers
print(a, b, c) # Output: 1 2 3
Converting Between Tuples and Lists
You can convert a tuple to a list and vice versa.
Examples:
# Tuple to list
tuple1 = (1, 2, 3)
list1 = list(tuple1)
print(list1) # Output: [1, 2, 3]
# List to tuple
list2 = [4, 5, 6]
tuple2 = tuple(list2)
print(tuple2) # Output: (4, 5, 6)
Nested Tuples
Tuples can contain other tuples, enabling multi-dimensional structures.
Example:
nested_tuple = ((1, 2), (3, 4), (5, 6))
print(nested_tuple[1]) # Output: (3, 4)
print(nested_tuple[1][0]) # Output: 3