Python 简明教程
Python - Join Tuples
Joining Tuples in Python
Joining tuples in Python refers to combining the elements of multiple tuples into a single tuple. This can be achieved using various methods, such as concatenation, list comprehension, or using built-in functions like extend() or sum().
连接元组并不修改原始元组，而是创建一个包含已组合元素的新元组。
Joining tuples does not modify the original tuples but creates a new tuple containing the combined elements.
Joining Tuples Using Concatenation ("+") Operator
Python 中的连接运算符，表示为 + ，用于将两个序列连接起来，例如字符串、列表或元组，生成一个序列。当应用于元组时，连接运算符将两个（或更多）元组的元素连接起来，创建一个包含这两个元组所有元素的新元组。
The concatenation operator in Python, denoted by +, is used to join two sequences, such as strings, lists, or tuples, into a single sequence. When applied to tuples, the concatenation operator joins the elements of the two (or more) tuples to create a new tuple containing all the elements from both tuples.
我们可以通过简单地使用 + 符号来连接它们，从而使用连接运算符连接元组。
We can join tuples using the concatenation operator by simply using the + symbol to concatenate them.
Example
在下面的示例中，我们连接两个元组“T1”和“T2”的元素，创建一个包含这两个元组所有元素的新元组“joined_tuple”−
In the following example, we are concatenating the elements of two tuples "T1" and "T2", creating a new tuple "joined_tuple" containing all the elements from both tuples −
# Two tuples to be joined
T1 = (10,20,30,40)
T2 = ('one', 'two', 'three', 'four')
# Joining the tuples
joined_tuple = T1 + T2
# Printing the joined tuple
print("Joined Tuple:", joined_tuple)以下是上面代码的输出： -
Following is the output of the above code −
Joined Tuple: (10, 20, 30, 40, 'one', 'two', 'three', 'four')Joining Tuples Using List Comprehension
List comprehension 是在 Python 中创建列表的一种简洁方法。它用于通过将表达式应用于现有可迭代对象（如列表、元组或范围）中的每个项来生成新列表。列表推导的语法为 −
List comprehension is a concise way to create lists in Python. It is used to generate new lists by applying an expression to each item in an existing iterable, such as a list, tuple, or range. The syntax for list comprehension is −
new_list = [expression for item in iterable]这将创建一个新列表，其中针对 iterable 中的每个 item 求 expression 。
This creates a new list where expression is evaluated for each item in the iterable.
我们可以通过遍历多个元组并将其元素附加到新元组中，使用列表解析连接元组。
We can join a tuple using list comprehension by iterating over multiple tuples and appending their elements to a new tuple.
Example
在此示例中，我们使用列表解析将两个元组 T1 和 T2 连接到单个元组中。结果元组 joined_tuple 包含 T1 和 T2 的所有元素−
In this example, we are joining two tuples, T1 and T2, into a single tuple using list comprehension. The resulting tuple, joined_tuple, contains all elements from both T1 and T2 −
# Two tuples to be joined
T1 = (36, 24, 3)
T2 = (84, 5, 81)
# Joining the tuples using list comprehension
joined_tuple = [item for subtuple in [T1, T2] for item in subtuple]
# Printing the joined tuple
print("Joined Tuple:", joined_tuple)上述代码的输出如下：
Output of the above code is as follows −
Joined Tuple: [36, 24, 3, 84, 5, 81]Joining Tuples Using extend() Function
Python extend() 函数用于将可迭代对象（如另一个列表）中的元素附加到列表末尾。此函数直接修改原始列表，将可迭代对象中的元素添加到列表末尾。
The Python extend() function is used to append elements from an iterable (such as another list) to the end of the list. This function modifies the original list in place, adding the elements of the iterable to the end of the list.
我们可以通过暂时将元组转换为列表来使用 extend() 函数连接元组，执行连接操作就像它们是列表一样，然后将结果列表转换回元组。
We can join tuples using the extend() function by temporarily converting the tuples into lists, performing the joining operation as if they were lists, and then converting the resulting list back into a tuple.
Example
在下面的示例中，我们通过将其转换为列表“L1”来扩展第一个元组“T1”，然后通过首先将其转换为列表“L2”来添加第二个元组“T2”的元素，最后将合并的列表转换回元组，有效地连接这两个元组−
In the following example, we are extending the first tuple "T1" by converting it into a list "L1", then adding elements from the second tuple "T2" by first converting it into a list "L2", and finally converting the merged list back into a tuple, effectively joining the two tuples −
T1 = (10,20,30,40)
T2 = ('one', 'two', 'three', 'four')
L1 = list(T1)
L2 = list(T2)
L1.extend(L2)
T1 = tuple(L1)
print ("Joined Tuple:", T1)获得的输出如下所示 −
The output obtained is as shown below −
Joined Tuple: (10, 20, 30, 40, 'one', 'two', 'three', 'four')Join Tuples using sum() Function
在 Python 中，sum() 函数用于将可迭代对象（例如列表、元组或集合）中的所有元素加起来。它接收一个可迭代对象作为其参数，并返回该可迭代对象中所有元素的总和。
In Python, the sum() function is used to add up all the elements in an iterable, such as a list, tuple, or set. It takes an iterable as its argument and returns the sum of all the elements in that iterable.
我们可以通过将元组作为参数提供给 sum() 函数来使用 sum() 函数连接元组。但是，由于 sum() 函数专门设计用于数字数据类型，因此此方法仅适用于包含数字元素的元组。它将加起来元组中所有数字元素并返回它们的总和。
We can join a tuple using the sum() function by providing the tuple as an argument to the sum() function. However, since the sum() function is specifically designed for numeric data types, this method only works for tuples containing numeric elements. It will add up all the numeric elements in the tuple and return their sum.
Syntax
以下是使用 sum() 函数在 Python 中连接元组的语法−
Following is the syntax for using the sum() function to join tuples in Python −
result_tuple = sum((tuple1, tuple2), ())其中，第一个参数是一个包含要连接的元组的元组。第二个参数是总和的起始值。由于我们正在连接元组，因此我们使用一个空元组 () 作为起始值。
Here, the first argument is a tuple containing the tuples to be joined. The second argument is the starting value for the sum. Since we are joining tuples, we use an empty tuple () as the starting value.
Example
在此示例中，首先将第一个元组的元素附加到一个空元组。然后附加第二个元组的元素，得到一个新的元组，它是这两个元组的连接结果−
In this example, the elements of the first tuple are first appended to an empty tuple. Then elements from the second tuple are appended, resulting in a new tuple that is a concatenation of the two −
T1 = (10,20,30,40)
T2 = ('one', 'two', 'three', 'four')
T3 = sum((T1, T2), ())
print ("Joined Tuple:", T3)执行上面的代码后，我们得到以下输出： -
After executing the above code, we get the following output −
Joined Tuple: (10, 20, 30, 40, 'one', 'two', 'three', 'four')Joining Tuples using for Loop
for loop 在 Python 中用于遍历一个序列（例如列表、元组、字符串或范围），并为序列中的每个元素执行一段代码块。该循环将持续到处理完所有元素为止。
A for loop in Python is used for iterating over a sequence (such as a list, tuple, string, or range) and executing a block of code for each element in the sequence. The loop continues until all elements have been processed.
我们可以通过遍历一个元组的元素并使用“+=”运算符将每个元素附加到另一个元组中，从而使用 for 循环连接元组。
We can join a tuple using a for loop by iterating over the elements of one tuple and appending each element to another tuple with the "+=" operator.
Example
在下面的示例中，我们遍历元组 T2 中的每个元素，并为每个元素将其附加到元组 T1，有效地连接这两个元组−
In the following example, we are iterating over each element in tuple T2, and for each element, we are appending it to tuple T1, effectively joining the two tuples −
T1 = (10,20,30,40)
T2 = ('one', 'two', 'three', 'four')
for t in T2:
T1+=(t,)
print (T1)我们得到了如下输出 −
We get the output as shown below −
(10, 20, 30, 40, 'one', 'two', 'three', 'four')