A tuple in Python is an ordered, immutable (unchangeable) sequence of elements.
Tuples are similar to lists, but unlike lists, you cannot modify their elements after creation.
They are useful for storing fixed collections of data such as coordinates, database records, or configuration values.
🔹 Key Properties of Tuples
- Ordered: Elements have a defined order and can be accessed via indexing.
- Immutable: Once created, elements cannot be modified (no add/remove/update).
- Allow Duplicates: Can contain repeated values.
- Can Contain Mixed Data Types: Elements can be of different types.
- Faster than Lists: Because of immutability and fixed memory allocation.
🔹 Common Tuple Functions & Methods
| Function / Method | Description | Example |
|---|---|---|
len(tuple) | Returns the number of elements in the tuple. | len((1, 2, 3)) → 3 |
max(tuple) | Returns the largest element (for comparable data). | max((2, 5, 1)) → 5 |
min(tuple) | Returns the smallest element. | min((2, 5, 1)) → 1 |
sum(tuple) | Returns the sum of elements (numeric only). | sum((1, 2, 3)) → 6 |
tuple.count(x) | Returns the number of times x appears. | (1, 2, 2, 3).count(2) → 2 |
tuple.index(x) | Returns the index of the first occurrence of x. | (10, 20, 30).index(20) → 1 |
sorted(tuple) | Returns a sorted list of tuple elements. | sorted((3, 1, 2)) → [1, 2, 3] |
any(tuple) | Returns True if any element is True. | any((0, 1, 0)) → True |
all(tuple) | Returns True if all elements are True. | all((1, 2, 3)) → True |
🧩 Example 1: Creating and Accessing Tuples
my_tuple = ("apple", "banana", "cherry")
print("Tuple:", my_tuple)
print("First element:", my_tuple[0])
print("Last element:", my_tuple[-1])Output:
Tuple: ('apple', 'banana', 'cherry')
First element: apple
Last element: cherry🧩 Example 2: Nested Tuple and Indexing
nested = (1, 2, (3, 4), 5)
print("Inner element:", nested[2][1])Output:
Inner element: 4🧩 Example 3: Tuple Methods
numbers = (1, 2, 2, 3, 4, 2)
print("Count of 2:", numbers.count(2))
print("Index of 3:", numbers.index(3))Output:
Count of 2: 3
Index of 3: 3🧩 Example 4: Tuple Operations
a = (1, 2, 3)
b = (4, 5, 6)
c = a + b # Concatenation
print("Concatenated Tuple:", c)
print("Repeated Tuple:", a * 2)Output:
Concatenated Tuple: (1, 2, 3, 4, 5, 6)
Repeated Tuple: (1, 2, 3, 1, 2, 3)🧩 Example 5: Checking Membership
fruits = ("apple", "banana", "cherry")
print("banana" in fruits)
print("orange" not in fruits)Output:
True
True🧩 Example 6: Tuple Unpacking
person = ("Dheeraj", 24, "Cybersecurity")
name, age, field = person
print("Name:", name)
print("Age:", age)
print("Field:", field)Output:
Name: Dheeraj
Age: 24
Field: Cybersecurity🧩 Example 7: Using Tuple in max, min, sum
nums = (10, 5, 15, 20)
print("Max:", max(nums))
print("Min:", min(nums))
print("Sum:", sum(nums))Output:
Max: 20
Min: 5
Sum: 50🔹 In Summary
- Tuples are immutable, ordered, and can store heterogeneous data.
- Common operations include count, index, concatenation, unpacking, and membership tests.
- Being immutable, tuples are faster and hashable, making them usable as dictionary keys or elements in a set.
- Use tuples when you need fixed, read-only collections of data.