rakesh kumar

Posted on Dec 31, 2022 • Updated on Sep 4, 2023

Python Tuples

A collection of ordered and immutable objects
("Python", "tuples", "immutable", "object")
(23, 42, 12, 53, 64)
Creating a Tuple ()
Creating a tuple having objects of different data types
nested tuple
("Python", {4: 5, 6: 2, 8:2}, (5, 3, 5, 6))
create a tuple without using parentheses
4, 5.7, "Tuples", ["Python", "Tuples"]
access element index more than the length of a tuple
Accessing the index of a nested tuple
nested_tuple[0][3]
Using slicing to access elements of the tuple==tuple_[1:3]
Printing the entire tuple by using the default start and end values==tuple_[:]
Repetition Tuples in Python==tuple_ * 3

Python Tuples

A collection of ordered and immutable objects is known as a tuple. Tuples and lists are similar as they both are sequences. Though, tuples and lists are different because we cannot modify tuples, although we can modify lists after creating them, and also because we use parentheses to create tuples while we use square brackets to create lists.

Placing different values separated by commas and enclosed in parentheses forms a tuple. For instance,

Example

tuple_1 = ("Python", "tuples", "immutable", "object")  
tuple_2 = (23, 42, 12, 53, 64)  
tuple_3 = "Python", "Tuples", "Ordered", "Collection"

We represent an empty tuple by two parentheses enclosing nothing.

Empty_tuple = ()

We need to add a comma after the element to create a tuple of a single element.

Tuple_1 = (50,)

Creating a Tuple
All the objects (elements) must be enclosed in parenthesis (), each separated by a comma, to form a tuple. Although using parenthesis is not required, it is recommended to do so.

Whatever the number of objects, even of various data types, can be included in a tuple (dictionary, string, float, list, etc.).

Python program to show how to create a tuple

Creating an empty tuple

empty_tuple = ()  
print("Empty tuple: ", empty_tuple)

Creating tuple having integers

int_tuple = (4, 6, 8, 10, 12, 14)  
print("Tuple with integers: ", int_tuple)

Creating a tuple having objects of different data types

mixed_tuple = (4, "Python", 9.3)  
print("Tuple with different data types: ", mixed_tuple)

Creating a nested tuple

nested_tuple = ("Python", {4: 5, 6: 2, 8:2}, (5, 3, 5, 6))  
print("A nested tuple: ", nested_tuple)

Output:

Empty tuple:  ()
Tuple with integers:  (4, 6, 8, 10, 12, 14)
Tuple with different data types:  (4, 'Python', 9.3)
A nested tuple:  ('Python', {4: 5, 6: 2, 8: 2}, (5, 3, 5, 6))

Python program to create a tuple without using parentheses

Creating a tuple

tuple_ = 4, 5.7, "Tuples", ["Python", "Tuples"]

displaying the tuple created

print(tuple_)

Checking the data type of object tuple_

print( type(tuple_) )

trying to modify tuple_

try:  
    tuple_[1] = 4.2  
except:  
    print( TypeError )

Output:

(4, 5.7, 'Tuples', ['Python', 'Tuples'])
<class 'tuple'>
<class 'TypeError'>

Python program to show how to access tuple elements

Creating a tuple

tuple_ = ("Python", "Tuple", "Ordered", "Collection")  

print(tuple_[0])    
print(tuple_[1])

trying to access element index more than the length of a tuple

 print(tuple_[5])

except Exception as e:

print(e)

trying to access elements through the index of floating data type

try:

print(tuple_[1.0])

except Exception as e:

print(e)

Creating a nested tuple

nested_tuple = ("Tuple", [4, 6, 2, 6], (6, 2, 6, 7))

Accessing the index of a nested tuple

print(nested_tuple[0][3])         
print(nested_tuple[1][1])

Output:

Python
Tuple
tuple index out of range
tuple indices must be integers or slices, not float
l
6

Python program to show how slicing works in Python tuples

Creating a tuple

tuple_ = ("Python", "Tuple", "Ordered", "Immutable", "Collection", "Objects")

Using slicing to access elements of the tuple

print("Elements between indices 1 and 3: ", tuple_[1:3])

Using negative indexing in slicing

print("Elements between indices 0 and -4: ", tuple_[:-4])

Printing the entire tuple by using the default start and end values.

print("Entire tuple: ", tuple_[:])

Output:

Elements between indices 1 and 3:  ('Tuple', 'Ordered')
Elements between indices 0 and -4:  ('Python', 'Tuple')
Entire tuple:  ('Python', 'Tuple', 'Ordered', 'Immutable', 'Collection', 'Objects')

Repetition Tuples in Python

** Python program to show repetition in tuples **

tuple_ = ('Python',"Tuples")  
print("Original tuple is: ", tuple_)  

 Repeting the tuple elements  
tuple_ = tuple_ * 3  
print("New tuple is: ", tuple_)

Output:

Original tuple is:  ('Python', 'Tuples')
New tuple is:  ('Python', 'Tuples', 'Python', 'Tuples', 'Python', 'Tuples')

Tuple Methods
Tuple does not provide methods to add or delete elements, and there are only the following two choices.

Examples of these methods are given below.

Python program to show how to tuple methods (.index() and .count()) work

Creating a tuple

tuple_ = ("Python", "Tuple", "Ordered", "Immutable", "Collection", "Ordered")

Counting the occurrence of an element of the tuple using the count() method

print(tuple_.count('Ordered'))

Getting the index of an element using the index() method

print(tuple_.index('Ordered')) # This method returns index of the first occurrence of the element

Output:

2
2

Tuple Membership Test
Using the in keyword, we can determine whether an item is present in the given tuple or not.

Python program to show how to perform membership test for tuples

Creating a tuple

tuple_ = ("Python", "Tuple", "Ordered", "Immutable", "Collection", "Ordered")  

In operator  
print('Tuple' in tuple_)  
print('Items' in tuple_)  

 Not in operator  
print('Immutable' not in tuple_)  
print('Items' not in tuple_)

Output:

True
False
False
True
Iterating Through a Tuple
We can use a for loop to iterate through each element of a tuple.

Code

Python program to show how to iterate over tuple elements

Creating a tuple

tuple_ = ("Python", "Tuple", "Ordered", "Immutable")  

 Iterating over tuple elements using a for loop  
for item in tuple_:  
    print(item)

Output:

Python
Tuple
Ordered
Immutable
Changing a Tuple
Tuples, as opposed to lists, are immutable objects.

This implies that after a tuple's elements have been specified, we cannot modify them. However, we can modify the nested elements of an element if the element itself is a mutable data type like a list.

A tuple can be assigned to many values (reassignment).

Python program to show that Python tuples are immutable objects

Creating a tuple

tuple_ = ("Python", "Tuple", "Ordered", "Immutable", [1,2,3,4])

Trying to change the element at index 2

try:

tuple_[2] = "Items"

print(tuple_)

except Exception as e:

print( e )

But inside a tuple, we can change elements of a mutable object

tuple_[-1][2] = 10

print(tuple_)

Changing the whole tuple

tuple_ = ("Python", "Items")

print(tuple_)

Output:

'tuple' object does not support item assignment

('Python', 'Tuple', 'Ordered', 'Immutable', [1, 2, 10, 4])
('Python', 'Items')

Code

Python program to show how to concatenate tuples

 Creating a tuple  
tuple_ = ("Python", "Tuple", "Ordered", "Immutable")  

Adding a tuple to the tuple_  
print(tuple_ + (4, 5, 6))

Output:

('Python', 'Tuple', 'Ordered', 'Immutable', 4, 5, 6)

Advantages of Tuple over List
Tuples and lists are employed in similar contexts because of how similar they are. A tuple implementation has several benefits over a list, though. The following are a few of the primary benefits:

We generally employ lists for homogeneous data types and tuples for heterogeneous data types.
Tuple iteration is quicker than list iteration because tuples are immutable. There is such a modest performance improvement.
Tuples with immutable components can function as the key for a Python dictionary object. This feature is not feasible with lists.
Collecting data in a tuple will ensure that it stays write-protected if it never changes.

==========================================================

Tuple Question

Create an empty tuple and add integers 1 to 5 to it.
Access the third element of a tuple containing names.
Given a tuple of numbers, calculate the sum of all the elements.
Create a tuple of fruits and check if a specific fruit is present.
Iterate through a tuple of words and print each word in uppercase.
Concatenate two tuples to create a new tuple.
Given a tuple of numbers, find the maximum and minimum values.
Write a function to convert a tuple to a list.
Find the index of a specific element in a tuple.
Create a tuple of strings and sort them in alphabetical order.
Count the occurrences of a specific element in a tuple.
Check if a given tuple is a palindrome.
Write a function to reverse a tuple.
Create a tuple of numbers and filter out the even numbers.
Write a function to find the product of elements in a tuple of numbers.
Given a tuple of words, create a new tuple with the lengths of the words.
Find the second largest element in a tuple of numbers.
Create a tuple of strings and capitalize the first letter of each string.
Write a function to merge two tuples into one, preserving the order.
Calculate the average of elements in a tuple of numbers.
Check if all elements in a tuple are greater than a specified value.
Write a function to find the intersection of two tuples.
Create a tuple of integers and find the sum and product of its elements.
Remove duplicate elements from a tuple.
Given two tuples of numbers, find the common elements between them.
Create a nested tuple and access its inner elements.
Convert a tuple of strings into a single string by joining them.
Create a tuple of mixed data types and find the count of integers and strings.
Write a function to rotate the elements of a tuple to the right by a specified number of positions.
Given a tuple of coordinates (x, y), calculate the distance from the origin for each point.
These questions cover various aspects of working with tuples in Python . =============================================================

# Task 1: Create an empty tuple and add integers 1 to 5 to it.
empty_tuple = ()
filled_tuple = empty_tuple + (1, 2, 3, 4, 5)
print("Task 1 - Tuple with Integers 1 to 5:", filled_tuple)

# Task 2: Access the third element of a tuple containing names.
names_tuple = ("Alice", "Bob", "Charlie", "David", "Eve")
third_name = names_tuple[2]
print("Task 2 - Third Element of Names Tuple:", third_name)

# Task 3: Given a tuple of numbers, calculate the sum of all the elements.
numbers_tuple = (10, 20, 30, 40, 50)
sum_of_elements = sum(numbers_tuple)
print("Task 3 - Sum of Elements in Numbers Tuple:", sum_of_elements)

# Task 4: Create a tuple of fruits and check if a specific fruit is present.
fruits_tuple = ("apple", "banana", "cherry", "date", "elderberry")
specific_fruit = "banana"
is_present = specific_fruit in fruits_tuple
print("Task 4 - Is '{}' Present in Fruits Tuple: {}".format(specific_fruit, is_present))

# Task 5: Iterate through a tuple of words and print each word in uppercase.
words_tuple = ("hello", "world", "python", "tuple")
for word in words_tuple:
    print("Task 5 - Uppercase Word:", word.upper())

# Task 6: Concatenate two tuples to create a new tuple.
tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)
concatenated_tuple = tuple1 + tuple2
print("Task 6 - Concatenated Tuple:", concatenated_tuple)

# Task 7: Given a tuple of numbers, find the maximum and minimum values.
numbers_tuple = (15, 30, 10, 45, 20)
max_value = max(numbers_tuple)
min_value = min(numbers_tuple)
print("Task 7 - Max Value:", max_value)
print("Task 7 - Min Value:", min_value)

# Task 8: Write a function to convert a tuple to a list.
def tuple_to_list(input_tuple):
    return list(input_tuple)

tuple_to_convert = (1, 2, 3, 4, 5)
converted_list = tuple_to_list(tuple_to_convert)
print("Task 8 - Converted List:", converted_list)

# Task 9: Find the index of a specific element in a tuple.
fruits_tuple = ("apple", "banana", "cherry", "date", "elderberry")
element_to_find = "date"
index_of_element = fruits_tuple.index(element_to_find)
print("Task 9 - Index of '{}' in Fruits Tuple: {}".format(element_to_find, index_of_element))

# Task 10: Create a tuple of strings and sort them in alphabetical order.
strings_tuple = ("zebra", "apple", "cherry", "banana", "date")
sorted_tuple = tuple(sorted(strings_tuple))
print("Task 10 - Sorted Tuple:", sorted_tuple)

# Task 11: Count the occurrences of a specific element in a tuple.
numbers_tuple = (1, 2, 2, 3, 2, 4, 2, 5)
element_to_count = 2
count_of_element = numbers_tuple.count(element_to_count)
print("Task 11 - Count of '{}' in Numbers Tuple: {}".format(element_to_count, count_of_element))

# Task 12: Check if a given tuple is a palindrome.
def is_palindrome(input_tuple):
    return input_tuple == input_tuple[::-1]

palindrome_tuple = (1, 2, 3, 2, 1)
is_palindrome_result = is_palindrome(palindrome_tuple)
print("Task 12 - Is Tuple a Palindrome:", is_palindrome_result)

# Task 13: Write a function to reverse a tuple.
def reverse_tuple(input_tuple):
    return input_tuple[::-1]

tuple_to_reverse = (5, 4, 3, 2, 1)
reversed_tuple = reverse_tuple(tuple_to_reverse)
print("Task 13 - Reversed Tuple:", reversed_tuple)

# Task 14: Create a tuple of numbers and filter out the even numbers.
numbers_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9)
filtered_tuple = tuple(filter(lambda x: x % 2 != 0, numbers_tuple))
print("Task 14 - Filtered Tuple (Odd Numbers Only):", filtered_tuple)

# Task 15: Write a function to find the product of elements in a tuple of numbers.
def product_of_elements(input_tuple):
    result = 1
    for element in input_tuple:
        result *= element
    return result

numbers_to_multiply = (2, 3, 4, 5)
product = product_of_elements(numbers_to_multiply)
print("Task 15 - Product of Elements in Tuple:", product)

Output

Task 1 - Tuple with Integers 1 to 5: (1, 2, 3, 4, 5)
Task 2 - Third Element of Names Tuple: Charlie
Task 3 - Sum of Elements in Numbers Tuple: 150
Task 4 - Is 'banana' Present in Fruits Tuple: True
Task 5 - Uppercase Word: HELLO
Task 5 - Uppercase Word: WORLD
Task 5 - Uppercase Word: PYTHON
Task 5 - Uppercase Word: TUPLE
Task 6 - Concatenated Tuple: (1, 2, 3, 4, 5, 6)
Task 7 - Max Value: 45
Task 7 - Min Value: 10
Task 8 - Converted List: [1, 2, 3, 4, 5]
Task 9 - Index of 'date' in Fruits Tuple: 3
Task 10 - Sorted Tuple: ('apple', 'banana', 'cherry', 'date', 'zebra')
Task 11 - Count of '2' in Numbers Tuple: 4
Task 12 - Is Tuple a Palindrome: True
Task 13 - Reversed Tuple: (1, 2, 3, 4, 5)
Task 14 - Filtered Tuple (Odd Numbers Only): (1, 3, 5, 7, 9)
Task 15 - Product of Elements in Tuple: 120

# Task 16: Given a tuple of words, create a new tuple with the lengths of the words.
words_tuple = ("apple", "banana", "cherry", "date", "elderberry")
word_lengths = tuple(len(word) for word in words_tuple)
print("Task 16 - Word Lengths Tuple:", word_lengths)

# Task 17: Find the second largest element in a tuple of numbers.
numbers_tuple = (10, 20, 30, 40, 50)
sorted_numbers = sorted(numbers_tuple)
second_largest = sorted_numbers[-2]
print("Task 17 - Second Largest Element:", second_largest)

# Task 18: Create a tuple of strings and capitalize the first letter of each string.
strings_tuple = ("apple", "banana", "cherry", "date", "elderberry")
capitalized_strings = tuple(word.capitalize() for word in strings_tuple)
print("Task 18 - Capitalized Strings Tuple:", capitalized_strings)

# Task 19: Write a function to merge two tuples into one, preserving the order.
def merge_tuples(tuple1, tuple2):
    return tuple1 + tuple2

tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)
merged_tuple = merge_tuples(tuple1, tuple2)
print("Task 19 - Merged Tuple:", merged_tuple)

# Task 20: Calculate the average of elements in a tuple of numbers.
numbers_tuple = (10, 20, 30, 40, 50)
average = sum(numbers_tuple) / len(numbers_tuple)
print("Task 20 - Average:", average)

# Task 21: Check if all elements in a tuple are greater than a specified value.
numbers_tuple = (10, 20, 30, 40, 50)
specified_value = 15
all_greater = all(element > specified_value for element in numbers_tuple)
print("Task 21 - All Elements Greater Than {}: {}".format(specified_value, all_greater))

# Task 22: Write a function to find the intersection of two tuples.
def tuple_intersection(tuple1, tuple2):
    return tuple(set(tuple1) & set(tuple2))

tuple1 = (1, 2, 3, 4, 5)
tuple2 = (4, 5, 6, 7, 8)
intersection_result = tuple_intersection(tuple1, tuple2)
print("Task 22 - Intersection of Tuples:", intersection_result)

# Task 23: Create a tuple of integers and find the sum and product of its elements.
integers_tuple = (1, 2, 3, 4, 5)
sum_of_elements = sum(integers_tuple)
product_of_elements = 1
for element in integers_tuple:
    product_of_elements *= element
print("Task 23 - Sum of Elements:", sum_of_elements)
print("Task 23 - Product of Elements:", product_of_elements)

# Task 24: Remove duplicate elements from a tuple.
original_tuple = (1, 2, 2, 3, 4, 4, 5)
unique_tuple = tuple(set(original_tuple))
print("Task 24 - Unique Tuple:", unique_tuple)

# Task 25: Given two tuples of numbers, find the common elements between them.
tuple1 = (1, 2, 3, 4, 5)
tuple2 = (4, 5, 6, 7, 8)
common_elements = tuple(element for element in tuple1 if element in tuple2)
print("Task 25 - Common Elements:", common_elements)

# Task 26: Create a nested tuple and access its inner elements.
nested_tuple = ((1, 2), (3, 4), (5, 6))
inner_element = nested_tuple[1][0]
print("Task 26 - Inner Element:", inner_element)

# Task 27: Convert a tuple of strings into a single string by joining them.
strings_tuple = ("apple", "banana", "cherry")
joined_string = ', '.join(strings_tuple)
print("Task 27 - Joined String:", joined_string)

# Task 28: Create a tuple of mixed data types and find the count of integers and strings.
mixed_tuple = (1, "apple", 2, "banana", 3, "cherry")
count_integers = sum(1 for element in mixed_tuple if isinstance(element, int))
count_strings = sum(1 for element in mixed_tuple if isinstance(element, str))
print("Task 28 - Count of Integers:", count_integers)
print("Task 28 - Count of Strings:", count_strings)

# Task 29: Write a function to rotate the elements of a tuple to the right by a specified number of positions.
def rotate_tuple_right(input_tuple, positions):
    positions = positions % len(input_tuple)
    return input_tuple[-positions:] + input_tuple[:-positions]

tuple_to_rotate = (1, 2, 3, 4, 5)
rotated_tuple = rotate_tuple_right(tuple_to_rotate, 2)
print("Task 29 - Rotated Tuple:", rotated_tuple)

# Task 30: Given a tuple of coordinates (x, y), calculate the distance from the origin for each point.
import math

coordinates_tuple = ((3, 4), (0, 0), (1, 1), (-2, 2))
distances = tuple(math.sqrt(x**2 + y**2) for x, y in coordinates_tuple)
print("Task 30 - Distances from Origin:", distances)

OUTPUT
Good question with tuple===== .

Check if a given tuple is a palindrome.

write a function to find the product of elements in a tuple of numbers.
Given a tuple of words, create a new tuple with the lengths of the words.
Find the second largest element in a tuple of numbers..

Debug School

Python Tuples

Python Tuples

Tuple Question

Output

Top comments (0)