What Is a Python Tuple?
- A Python tuple is similar to a list that stores multiple values inside parentheses (), but the main difference is, tuples cannot be changed after creation.
- You can store any type of data inside a tuple, such as numbers, strings, Booleans, lists, or even other tuple data.
- Imagine a tuple is like a sealed container; you can read what’s inside, but you cannot remove or replace anything.
Syntax of Tuple
tuple_name = (item1, item2, item3, ...)
- Tuple store items in separate commas.
- Parentheses are optional but recommended for clarity.
Multiple Unique Examples of Tuple
Example 1: Tuple of City Names
cities = ("Mumbai", "Delhi", "Chennai", "Kolkata")
print(cities)
Example 2: Tuple Showing Daily Attendance
attendance = (45, 48, 50, 44) # Monday → Thursday student count
print("Attendance on Wednesday:", attendance[2])
Example 3: Mixed Data Tuple
profile = ("Amit", 24, 72.5, False)
print("User age:", profile[1])
Example 4: Nested Tuple
schedule = (
("Math", "Science"), # Monday
("English", "History"), # Tuesday
)
print("Tuesday second class:", schedule[1][1])
Output:
Tuesday second class: History
Why We Are Using Tuples In Python?
- Tuples look simple, but they play an important role when your program needs data that should never change.
- Python consider tuples differently from lists, and gives them some advantages in performance and safety.
How Tuples Protect Your Data
Once we create a tuple, no one can add new items, remove old items, or modify any existing value.
This method makes our program perfect when we store permanent or fixed information, such as:
- Days of the week
- Coordinates on a map
- Default settings
- Student roll numbers
- App version numbers
Characteristics of Tuples
1) Ordered: A tuple refers to an exact order of collection; even if you print it multiple times or pass it through functions, the sequence remains unchanged.
2) Immutable: This means once a tuple is created, you cannot insert, delete, and update any elements. For example:
version_info = (1, 0, 5)
# version_info[1] = 2 # This will cause an error because tuples cannot be changed.
3) Allow Duplicates: Tuples do not require all values to be unique in a collection; you can store the same values multiple times.
scores = (10, 15, 10, 20, 10)
print(scores)
# Output: (10, 15, 10, 20, 10)
4) Tuple Can Store Different Data Types: A tuple can hold numbers, strings, Booleans, floats, lists, and even other tuples, all together.
student_record = (
"Arjun", # string
21, # integer
8.7, # float
True, # boolean
["Math", "AI"], # list
(2025, "Graduate") # another tuple
)
print(student_record)
How To Access Tuple Elements?
We can access each value of a tuple using an index.
Syntax for Accessing Tuple Elements
tuple_name[index]
Example 1: Access Elements Using Positive Index
devices = ("Laptop", "Tablet", "Smartphone", "Smartwatch")
print(devices[0]) # Output: Laptop
print(devices[2]) # Output: Smartphone
In this code:
- devices[0] → first item
- devices[2] → third item
Example 2: Access Elements Using Negative Index
colors = ("Red", "Green", "Blue", "Yellow")
print(colors[-1]) # Output: Yellow (last element)
print(colors[-3]) # Output: Green (third from end)
Negative indexing works like this:
- -1 → last item
- -2 → second last
- -3 → third last
Tuple Slicing In Python
Tuple slicing means we can extract a specific part of a tuple without modifying the original one.
Syntax:
tuple_name[start : end : step]
Let’s understand meaning of each:
- start → Index from where the slice should begin
- end → Index where the slice should stop
- step → Defines how many positions to skip while moving forward
Example of Slicing:
Here, we slice a tuple that stores temperatures recorded in a day.
temperatures = (23, 25, 28, 30, 27, 24, 22)
# Slice from index 1 to index 4 (25, 28, 30)
morning_slice = temperatures[1:4]
print(morning_slice)
Output:
(25, 28, 30)
Example 2: Slice with a step
We create a tuple of roll numbers and pick every 2nd roll number.
roll_numbers = (101, 102, 103, 104, 105, 106, 107)
# Pick every second student
alternate_students = roll_numbers[0:7:2]
print(alternate_students)
Output:
(101, 103, 105, 107)
Tuple Methods In Python
Tuples are immutable, but Python provides us with some useful built-in methods, and these methods help us analyze the data stored inside a tuple without modifying it.
| Method | Description |
|---|---|
| count() | Tells you how many times a specific value appears in the tuple |
| index() | Returns the index (position) of the first occurrence of a given value |
Example of Count() Method
Count() returns how many times a particular element exists in a tuple.
weekly_temps = (32, 34, 32, 31, 33, 32, 30)
# Count how many days recorded temperature 32°C
days_with_32 = weekly_temps.count(32)
print(days_with_32)
Output of the code:
3
Example of Index() Method
The index () method represents this differently; if the value occurs multiple times, only the first index is returned. Let’s see the example:
favorite_colors = ("red", "blue", "green", "blue", "yellow")
# Find the first index of "blue"
first_blue = favorite_colors.index("blue")
print(first_blue)
Output:
1
Index() and Count() Both Method Together
scores = (85, 90, 88, 90, 92, 90, 87)
# Count how many students scored 90
count_90 = scores.count(90)
# Find first position where score 90 appears
first_90_index = scores.index(90)
print("Total students scoring 90:", count_90)
print("First occurrence at index:", first_90_index)
Output of the code:
Total students scoring 90: 3
First occurrence at index: 1
Operations with Tuples
Tuples support several operations that help you combine, repeat, and check data quickly.
1. Concatenation:
Concatenation means attaching one tuple to another. This creates a new tuple without changing the original ones.
Example: Merging morning and evening bus timing
morning_times = (7, 8, 9)
evening_times = (5, 6, 7)
# Combine both schedules
full_day_schedule = morning_times + evening_times
print(full_day_schedule)
Output:
(7, 8, 9, 5, 6, 7)
2. Repetition
You can repeat the entire tuple multiple times. Let’s create a study reminder sequence that repeats 3 times.
reminder = ("Study",)
# Repeat 3 times
daily_plan = reminder * 3
print(daily_plan)
Output:
('Study', 'Study', 'Study')
3. Membership Test:
Use the in keyword to find out if a value exists in a tuple.
For example:
booked_seats = (12, 18, 22, 25)
# Check if seat 18 is booked
print(18 in booked_seats)
# Check if seat 20 is booked
print(20 in booked_seats)
Output:
True
False
Iterating Through a Tuple
A tuple can store multiple values, and also provides an easy method for loop to access those values instantly.
Example:
Suppose, tuple containing different modes of transport, and we want to print each transport method for a travel plan.
transport_modes = ("walk", "cycle", "bus", "train")
# Iterating through each item in the tuple
for mode in transport_modes:
print("Next step:", mode)
Output:
Next step: walk
Next step: cycle
Next step: bus
Next step: train
Converting Between Tuples and Lists
Sometimes we need the flexibility of a list and the safety of a tuple.
1) Converting a Tuple to a List
Tuples are immutable, but lists are editable. So when you need to update or modify data, convert the tuple into a list.
Simple example: Converting student roll numbers into a list so new roll numbers can be added.
roll_numbers = (21, 22, 23)
# Convert tuple into list to modify it
editable_rolls = list(roll_numbers)
print(editable_rolls)
Output:
[21, 22, 23]
2) Converting a List to a Tuple
When you want to lock the data so nobody can change it, convert the list into a tuple.
Example:
workshop_days = ["Monday", "Tuesday", "Wednesday"]
# Convert list to tuple for safety
fixed_schedule = tuple(workshop_days)
print(fixed_schedule)
Output:
('Monday', 'Tuesday', 'Wednesday')
Nested Tuples In Python
A nested tuple is simply a tuple that contains other tuples. It allows you to build structured, multi-level data.
Example:
Storing a classroom seating plan where each row is a tuple.
seating_plan = (
("A1", "A2", "A3"),
("B1", "B2", "B3"),
("C1", "C2", "C3")
)
# Print second row
print(seating_plan[1])
# Print seat C2
print(seating_plan[2][1])
Output:
('B1', 'B2', 'B3')
C2
- What is type casting in Python?
- What are numbers in Python?
- How we can use data types in Python?
- What are variables in Python?
- What are strings in Python?
M.Sc. (Information Technology). I explain AI, AGI, Programming and future technologies in simple language. Founder of BoxOfLearn.com.