How does concatenation operator work on tuple in Python?

The concatenation operator (+) is used to join two or more tuples together in Python. This operation returns a new tuple that contains all the items of the original tuples, while keeping the original tuples unchanged.

In this article, we will discuss how the concatenation operator works on tuples in Python with practical examples.

How Concatenation Works

When you use the concatenation operator on tuples, Python creates a new tuple that includes all the elements from the tuples being concatenated. The original tuples remain unchanged since tuples are immutable in Python.

The concatenation operator (+) merges multiple tuples into one tuple without modifying the original tuples. This is particularly useful when you need to combine data from different sources while preserving the original data.

Syntax

Following is the syntax to concatenate two tuples in Python −

new_tuple = tuple1 + tuple2

Where the values of tuple1 and tuple2 remain unchanged, and a new tuple called new_tuple will be created.

Basic Tuple Concatenation

Let's start with a simple example of combining two tuples with numeric values −

# Create two tuples
tuple1 = (1, 2, 3)
tuple2 = (4, 5, 6)

# Concatenate tuples
result = tuple1 + tuple2

# Print the result
print("Original tuple1:", tuple1)
print("Original tuple2:", tuple2)
print("Concatenated result:", result)

Original tuple1: (1, 2, 3)
Original tuple2: (4, 5, 6)
Concatenated result: (1, 2, 3, 4, 5, 6)

Concatenate Tuples with Strings

We can also concatenate tuples containing string elements −

# Create two tuples with strings
tuple1 = ('Hello', 'TutorialsPoint')
tuple2 = ('Python', 'Programming')

# Concatenate tuples
result = tuple1 + tuple2

# Print the result
print("Result:", result)
print("Number of elements:", len(result))

Result: ('Hello', 'TutorialsPoint', 'Python', 'Programming')
Number of elements: 4

Concatenate Nested Tuples

Concatenation works seamlessly with nested tuples as well −

# Creating nested tuples
tuple1 = ((1, 2), (3, 4))
tuple2 = ((5, 6), (7, 8))

# Concatenating tuples
result = tuple1 + tuple2

print("Nested tuple concatenation:", result)
print("Accessing nested elements:", result[0], result[2])

Nested tuple concatenation: ((1, 2), (3, 4), (5, 6), (7, 8))
Accessing nested elements: (1, 2) (5, 6)

Using Loops with Tuple Concatenation

You can use loops to concatenate multiple tuples dynamically −

# Create a list of tuples
tuple_list = [(1, 2), (3, 4), (5, 6), (7, 8)]

# Initialize an empty tuple
result = ()

# Loop through the list and concatenate tuples
for tup in tuple_list:
    result += tup

print("Final concatenated tuple:", result)
print("Type:", type(result))

Final concatenated tuple: (1, 2, 3, 4, 5, 6, 7, 8)
Type: <class 'tuple'>

Key Points

• The + operator creates a new tuple without modifying the original tuples

• Concatenation preserves the order of elements from left to right

• You can concatenate tuples containing different data types

• The operation works with nested tuples, treating each nested tuple as a single element

• Multiple tuples can be concatenated in a single expression: result = tuple1 + tuple2 + tuple3

Conclusion

The concatenation operator (+) provides an efficient way to combine tuples in Python while maintaining immutability. Use it when you need to merge tuple data while preserving the original tuples for further operations.