Python元组

2025年4月24日 | 阅读 19 分钟

元组 (Tuple) 是 Python 中用于存储对象集合的内置数据结构。元组在索引、嵌套对象和重复性方面与 Python 列表非常相似；然而，两者之间的主要区别在于 Python 中的元组是不可变的，而 Python 列表是可变的。

让我们来看一个初始化 Python 元组的简单示例。

示例

# creating a tuple
T = (20, 'Tpointtech', 35.75, [20, 40, 60])

print(T)

立即执行

输出

(20, 'Tpointtech', 35.75, [20, 40, 60])

说明

在上面的示例中，我们创建了一个包含不同数据类型元素的简单元组。此元组中的每个元素都有一个索引，这意味着可以使用它在列表中的位置来访问它，如下所示：

T[0] = 20 (整数)
T[1] = 'TpointTech' (字符串)
T[2] = 35.75 (浮点数)
T[3] = [20, 40, 60] (嵌套列表)

Python 元组的特性

Python 中的元组是一种数据结构，它是：

有序：元组中的每个数据元素都有一个特定的顺序，这个顺序永不改变。
不可变：元组的数据元素一旦初始化就不能更改。

让我们看下面的示例，展示元组的不可变性。

示例

# creating a tuple  
my_tpl = (25, 16.25, 'TpointTech', [20, 40, 60], 3e8)  
print(my_tpl)

# trying to changing the element of the tuple  
# my_tpl[1] = 'welcome' # raise TypeError

立即执行

输出

(25, 16.25, 'TpointTech', [20, 40, 60], 300000000.0)

创建元组

所有对象（也称为“元素”）必须用逗号分隔，并用括号 () 括起来。虽然括号不是必需的，但建议使用。

元组可以包含任意数量的项，包括不同数据类型的项（字典、字符串、浮点数、列表等）。

让我们看下面的示例，演示在元组中包含不同数据类型：

示例

# Python program to show how to create a tuple

# Creating an empty tuple    
empty_tpl = ()    
print("Empty tuple: ", empty_tpl)    
    
# Creating a tuple having integers    
int_tpl = (13, 56, 27, 18, 11, 23)
print("Tuple with integers: ", int_tpl)    
    
# Creating a tuple having objects of different data types
mix_tpl = (6, "Tpointtech", 17.43)    
print("Tuple with different data types: ", mix_tpl)    
    
# Creating a nested tuple    
nstd_tpl = ("Tpointtech", {4: 5, 6: 2, 8: 2}, (5, 3, 15, 6))    
print("A nested tuple: ", nstd_tpl)

立即执行

输出

Empty tuple:  ()
Tuple with integers:  (13, 56, 27, 18, 11, 23)
Tuple with different data types:  (6, 'Tpointtech', 17.43)
A nested tuple:  ('Tpointtech', {4: 5, 6: 2, 8: 2}, (5, 3, 15, 6))

说明

在上面的代码片段中，我们创建了四个包含不同类型元素的元组。第一个元组是一个空元组，使用括号定义，中间没有元素。之后，我们定义了一个整数元组，包含 6 个整数值，用逗号分隔在括号内。第三个元组由三种不同数据类型的对象组成——整数、字符串和浮点数。最后，我们定义了一个元组作为另一个元组的单独对象。

访问元组元素

在 Python 中，我们可以使用索引来访问元组中的任何对象。元组的对象或元素可以通过引用索引号（在方括号 '[]' 内）来访问。

让我们看下面的示例，说明如何使用索引访问元组的元素：

示例

# Python program to show how to access tuple elements    

# Creating a tuple having six elements
sampleTuple = ("Apple", "Mango", "Banana", "Orange", "Guava", "Berries") 

# accessing the elements of a tuple using indexing
print("sampleTuple[0] =", sampleTuple[0])
print("sampleTuple[1] =", sampleTuple[1])
print("sampleTuple[-1] =", sampleTuple[-1])   # negative indexing
print("sampleTuple[-2] =", sampleTuple[-2])

立即执行

输出

sampleTuple[0] = Apple
sampleTuple[1] = Mango
sampleTuple[-1] = Berries
sampleTuple[-2] = Guava

说明

在上面的示例中，我们创建了一个包含六个元素的元组。然后我们使用索引来访问元组的不同元素。

元组切片

切片元组意味着使用索引将元组分成更小的元组。为了切片元组，我们需要指定开始和结束索引值，这将返回一个包含指定对象的新元组。

我们可以使用冒号 ':' 运算符分隔开始和结束索引来切片元组，如下所示：

语法

让我们来看一个简单的示例，说明在 Python 中切片元组的方法。

代码

示例

# Python program to show how slicing works in Python tuples

# Creating a tuple
sampleTuple = ("Apple", "Mango", "Banana", "Orange", "Guava", "Berries")

# Using slicing to access elements of the tuple
print("Elements between indices 1 and 5: ", sampleTuple[1:5])

# Using negative indexing in slicing
print("Elements between indices 0 and -3: ", sampleTuple[:-3])

# Printing the entire tuple by using the default start and end values
print("Entire tuple: ", sampleTuple[:])    

立即执行

输出

Elements between indices 1 and 5:  ('Mango', 'Banana', 'Orange', 'Guava')
Elements between indices 0 and -3:  ('Apple', 'Mango', 'Banana')
Entire tuple:  ('Apple', 'Mango', 'Banana', 'Orange', 'Guava', 'Berries')

说明

在此示例中，我们定义了一个包含六个元素的元组——Apple、Mango、Banana、Orange、Guava 和 Berries。我们使用切片方法打印了范围从 1 到 5 的元素元组。然后我们使用切片中的负索引打印了范围从 0 到 -3 的元素。最后，我们仅使用冒号 ':' 运算符（不指定开始和结束索引值）打印了整个元组。

删除元组

与列表不同，元组是不可变数据类型，这意味着一旦创建，我们就无法更新元组的对象。因此，删除元组的元素也是不可能的。但是，我们可以使用 'del' 关键字删除整个元组，如下所示。

语法

让我们看下面的代码片段，说明使用 'del' 关键字删除元组的方法。

这是一个简单的示例，说明在 Python 中删除元组的方法。

示例

# Python program to show how to delete elements of a Python tuple

# Creating a tuple
sampleTuple = ("Apple", "Mango", "Banana", "Orange", "Guava", "Berries")
# printing the entire tuple for reference
print("Given Tuple:", sampleTuple)

# Deleting a particular element of the tuple using the del keyword
try:
    del sampleTuple[3]
    print(sampleTuple)
except Exception as e:
    print(e)

# Deleting the variable from the global space of the program using the del keyword
del sampleTuple

# Trying accessing the tuple after deleting it
try:
    print(sampleTuple)
except Exception as e:
    print(e)

立即执行

输出

 
Given Tuple: ('Apple', 'Mango', 'Banana', 'Orange', 'Guava', 'Berries')
'tuple' object doesn't support item deletion
name 'sampleTuple' is not defined

说明

在这里，我们定义了一个包含六个元素的元组——Apple、Mango、Banana、Orange、Guava 和 Berries。然后我们打印了整个元组作为参考。之后，我们使用了 try 和 except 块来使用 del 关键字删除元组中的特定元素。结果，出现了一个异常，提示 'tuple' 对象不支持项删除。然后我们使用 del 关键字删除了整个元组，并尝试打印它。结果，我们可以看到另一个异常，提示名称 'sampleTuple' 未定义。

更改元组中的元素

一旦创建了元组，由于其不可变性，我们就无法更改其元素。然而，有一种方法可以更新元组的元素。我们可以将元组转换为列表，更改列表，然后将列表转换回元组。

让我们来看一个简单的示例，说明如何在 Python 中更新元组的元素。

示例

# Python program to demonstrate the approach of changing the element in the tuple

# creating a tuple
fruits_tuple = ("mango", "orange", "banana", "apple", "papaya")

# printing the tuple before update
print("Before Changing the Element in Tuple...")
print("Tuple =", fruits_tuple)

# converting the tuple into the list
fruits_list = list(fruits_tuple)

# changing the element of the list
fruits_list[2] = "grapes"
print("Converting", fruits_tuple[2], "=>", fruits_list[2])

# converting the list back into the tuple
fruits_tuple = tuple(fruits_list)

# printing the tuple after update
print("After Changing the Element in Tuple...")
print("Tuple =", fruits_tuple)

立即执行

输出

Before Changing the Element in Tuple...
Tuple = ('mango', 'orange', 'banana', 'apple', 'papaya')
Converting banana => grapes
After Changing the Element in Tuple...
Tuple = ('mango', 'orange', 'grapes', 'apple', 'papaya')

说明

在此示例中，我们创建了一个包含五个元素的元组——mango、orange、banana、apple 和 papaya。然后我们打印了元组作为参考。之后，我们使用 list() 方法将元组转换为列表。然后我们将列表索引为 2 的元素更改为 'grapes'，并使用 tuple() 方法将更新后的列表转换回元组。最后，我们打印了结果元组。结果，我们可以看到元组已更新，并且索引为 2 的元素也从 'banana' 更改为 'grapes'。

向元组添加元素

由于元组是不可变数据类型，它没有内置的 append() 方法来添加元素。但是，有几种方法可以用来向元组添加元素。

将元组转换为列表

为了向元组添加新元素，我们可以遵循与在更改元组元素时类似的方法。该方法遵循以下步骤：

步骤 1：将元组转换为列表。

步骤 2：使用 append() 方法将所需元素添加到列表中。

步骤 3：将列表转换回元组。

让我们看下面的代码片段，演示相同的操作。

示例

# Python program to demonstrate an approach of adding the element in the tuple by converting it into a list

# creating a tuple
fruits_tuple = ("mango", "orange", "banana", "apple", "papaya")

# printing the tuple before update
print("Before Adding a New Element in Tuple...")
print("Original Tuple =", fruits_tuple)

# converting the tuple into the list
fruits_list = list(fruits_tuple)

# changing the element of the list
fruits_list.append("blueberry")
print("Adding New Element -> 'blueberry'")

# converting the list back into the tuple
fruits_tuple = tuple(fruits_list)

# printing the tuple after update
print("After Adding a New Element in Tuple...")
print("Updated Tuple =", fruits_tuple)

立即执行

输出

 
Before Adding a New Element in Tuple...
Original Tuple = ('mango', 'orange', 'banana', 'apple', 'papaya')
Adding New Element -> 'blueberry'
After Adding a New Element in Tuple...
Updated Tuple = ('mango', 'orange', 'banana', 'apple', 'papaya', 'blueberry')

说明

在上面的代码片段中，我们创建了一个包含五个元素的元组——mango、orange、banana、apple 和 papaya。然后我们打印了元组作为参考。之后，我们使用 list() 方法将元组转换为列表。然后我们使用 append() 方法将新元素 'blueberry' 添加到列表中。之后，我们使用 tuple() 方法将更新后的列表转换回元组。最后，我们打印了结果元组。结果，我们可以看到元组已更新，并且元素 'blueberry' 已成功添加到给定的元组中。

将元组添加到元组

在 Python 中，我们可以将多个元组添加到元组中。因此，如果我们想向元组插入新元素，我们可以按照以下步骤操作：

步骤 1：创建一个包含我们想要添加的元素的新元组。

步骤 2：将新元组添加到现有元组中。

让我们来看一个说明此操作的示例。

代码

示例

# Python program to demonstrate an approach of adding the element in the tuple by adding a new tuple to the existing one

# creating a tuple
fruits_tuple = ("mango", "orange", "banana", "apple", "papaya")

# printing the tuple before update
print("Before Adding a New Element in Tuple...")
print("Original Tuple =", fruits_tuple)

# creating a new tuple consisting new element(s)
temp_tuple = ("pineapple", )

# adding the new tuple to the existing tuple
# fruits_tuple = fruits_tuple + temp_tuple
fruits_tuple += temp_tuple

# printing the tuple after update
print("Adding New Element -> 'pineapple'")
print("After Adding a New Element in Tuple...")
print("Updated Tuple =", fruits_tuple)

立即执行

输出

Before Adding a New Element in Tuple...
Original Tuple = ('mango', 'orange', 'banana', 'apple', 'papaya')
Adding New Element -> 'pineapple'
After Adding a New Element in Tuple...
Updated Tuple = ('mango', 'orange', 'banana', 'apple', 'papaya', 'pineapple')

说明

在上面的代码片段中，我们创建了一个包含五个元素的元组——mango、orange、banana、apple 和 papaya。然后我们打印了元组作为参考。之后，我们创建了一个包含另一个元素 'blueberry' 的新元组。之后，我们使用 '+' 运算符将新元组添加到现有元组中。最后，我们打印了结果元组。结果，我们可以看到元组已更新，并且元素 'pineapple' 已成功添加到给定的元组中。

解包元组

在初始化元组时，我们通常将对象分配给它。这个过程称为“打包”元组。

然而，Python 提供了访问权限，可以将对象提取回变量。这个提取元组中的对象并将其分配给不同变量的过程称为“解包”元组。

让我们来看一个说明在 Python 中解包元组的方法的示例。

示例

 
# Python program to demonstrate an approach of unpacking a tuple

# creating a tuple (Packing a Tuple)
fruits_tuple = ("mango", "orange", "banana", "apple", "papaya")

# printing the given tuple for reference
print("Given Tuple :", fruits_tuple)

# unpacking a tuple
(varOne, varTwo, varThree, varFour, varFive) = fruits_tuple

# printing the results
print("First Variable :", varOne)
print("Second Variable :", varTwo)
print("Third Variable :", varThree)
print("Fourth Variable :", varFour)
print("Fifth Variable :", varFive)

立即执行

输出

 
Given Tuple : ('mango', 'orange', 'banana', 'apple', 'papaya')
First Variable : mango
Second Variable : orange
Third Variable : banana
Fourth Variable : apple
Fifth Variable : papaya

说明

在上面的代码片段中，我们创建了一个包含五个元素的元组——mango、orange、banana、apple 和 papaya。我们打印了初始化元组作为参考。之后，我们将元组解包，将右侧元组的每个元素分配给左侧的相应变量。最后，我们打印了不同已初始化变量的值。结果，元组被成功解包，并且值已分配给变量。

注意：在解包元组时，左侧的变量数量应等于给定元组中元素的数量。如果变量与元组的大小不匹配，我们可以使用星号 '*' 来将剩余元素存储为列表。

循环元组

Python 提供了不同的方法来循环遍历元组。其中一些方法如下：

使用 'for' 循环
使用 'while' 循环

让我们来看一个说明使用 'for' 循环遍历给定元组的示例。

这是一个简单的示例，说明了在 Python 中循环遍历元组的方法。

示例

# Python program to loop through a tuple

# creating a tuple
fruits_tuple = ("mango", "orange", "banana", "apple", "papaya")

# printing the given tuple for reference
print("Given Tuple :", fruits_tuple)

print("Looping with 'for' Loop:")
i = 1
# iterating through the tuple
for fruit in fruits_tuple:
    # printing the element
    print(i, "-", fruit)
    i += 1

print("\nLooping with 'while' Loop:")
# initializing an iterable with 0
j = 0
# using the while loop to iterate through the tuple
while j < len(fruits_tuple):
    # printing the element of the tuple
    print(j + 1, "-", fruits_tuple[j])
    # incrementing the index value by 1
    j += 1

立即执行

输出

Given Tuple : ('mango', 'orange', 'banana', 'apple', 'papaya')
Looping with 'for' Loop:
1 - mango
2 - orange
3 - banana
4 - apple
5 - papaya

Looping with 'while' Loop:
1 - mango
2 - orange
3 - banana
4 - apple
5 - papaya

说明

在此示例中，我们创建了一个包含一些元素的元组并打印它作为参考。然后我们使用 'for' 和 'while' 循环遍历元组的每个元素并打印它们。结果，元组的元素被成功打印。

Python 中的元组操作

下表显示了用于处理 Python 元组的不同运算符的列表。

序号。	Python 运算符	Python 表达式	结果	描述
1	+	(2, 4, 6) + (3, 5, 7)	(2, 4, 6, 3, 5, 7)	拼接
2	*	('Apple', ) * 3	('Apple', 'Apple', 'Apple')	重复
3	in, not in	4 in (2, 4, 6, 8, 10)	true	会员资格

现在让我们看一个说明在 Python 中使用不同运算符处理元组的示例。

示例

 
# Python program to illustrate the use of operators in the case of tuples

# creating a tuple for concatenation
vegetables_tuple = ('Potato', 'Tomato', 'Onion')
# printing the tuple
print("Vegetables Tuple =>", vegetables_tuple)

# creating another tuple for concatenation
fruits_tuple = ('Mango', 'Apple', 'Orange')
# printing the tuple
print("Fruits Tuple =>", fruits_tuple)

# concatenating the tuples using the + operator
tuple_of_food_items = vegetables_tuple + fruits_tuple
# printing the resultant tuple
print("Concatenated Tuple: Tuple of Food Items =>", tuple_of_food_items)

# creating a tuple for repetition
sampleTuple = ('Mango', 'Grapes', 'Banana')

# printing the original tuple
print("Original tuple =>", sampleTuple)

# Repeating the tuple elements for 4 times using the * operator
sampleTuple = sampleTuple * 4

# printing the new tuple
print("New tuple =>", sampleTuple)

# creating a tuple for membership
test_tuple = (12, 23, 35, 76, 84)
# printing the tuple
print("Given tuple =>", test_tuple)

# test cases
n = 35
m = 47

# checking whether variable n and m belongs to the given tuple or not using the membership operator
if n in test_tuple:
    print("Yes.", n, "is present in the tuple", test_tuple)
else:
    print("No.", n, "is NOT present in the given tuple.")

if m in test_tuple:
    print("Yes.", m, "is present in the tuple", test_tuple)
else:
    print("No.", m, "is NOT present in the given tuple.")

立即执行

输出

Vegetables Tuple => ('Potato', 'Tomato', 'Onion')
Fruits Tuple => ('Mango', 'Apple', 'Orange')
Concatenated Tuple: Tuple of Food Items => ('Potato', 'Tomato', 'Onion', 'Mango', 'Apple', 'Orange')
Original tuple => ('Mango', 'Grapes', 'Banana')
New tuple => ('Mango', 'Grapes', 'Banana', 'Mango', 'Grapes', 'Banana', 'Mango', 'Grapes', 'Banana', 'Mango', 'Grapes', 'Banana')
Given tuple => (12, 23, 35, 76, 84)
Yes. 35 is present in the tuple (12, 23, 35, 76, 84)
No. 47 is NOT present in the given tuple.

说明

在此示例中，我们使用了连接运算符 '+'，将两个不同元组的元素添加到新元组中。我们使用重复运算符 '*' 将元组的元素重复给定的次数。我们还使用了成员运算符 'in' 来检查传入的项是否是元组的成员。

Python 元组方法

Python 元组是不可变项的集合，这使得在创建后很难更改或修改元组的对象。然而，Python 提供了两种内置方法来处理元组。这些方法如下：

count()
index()

现在让我们通过一些示例详细讨论这些方法。

count() 方法

count() 方法是 Python 的内置方法，用于计算元组中指定元素的出现次数。

语法

参数

item (必需): item 参数是要在元组中搜索的项。

指定项在元组中出现的次数。

现在让我们看下面的示例，说明在 Python 元组中使用 count() 方法。

示例

# Python program to demonstrate the use of count() method in the case of tuples

# creating tuples
T1 = (0, 2, 3, 6, 4, 2, 5, 6, 3, 2, 2, 6, 7, 2, 7, 8, 0, 1, 9, 1)
T2 = ('Apple', 'Orange', 'Mango', 'Apple', 'Banana', 'Mango', 'Mango', 'Orange', 'Mango', 'Apple')

# counting the occurrence of 2 in the tuple T1
resultOne = T1.count(2)

# counting the occurence of 'Mango' in the tuple T2
resultTwo = T2.count('Mango')

# printing the results
print("Tuple T1 =>", T1)
print("Total Occurrence of 2 in T1 =>", resultOne)

# printing the results
print("\nTuple T2 =>", T2)
print("Total Occurrence of 'Mango' in T2 =>", resultTwo)  

立即执行

输出

 
Tuple T1 => (0, 2, 3, 6, 4, 2, 5, 6, 3, 2, 2, 6, 7, 2, 7, 8, 0, 1, 9, 1)
Total Occurrence of 2 in T1 => 5

Tuple T2 => ('Apple', 'Orange', 'Mango', 'Apple', 'Banana', 'Mango', 'Mango', 'Orange', 'Mango', 'Apple')
Total Occurrence of 'Mango' in T2 => 4

说明

在此示例中，我们使用 count() 方法来计算传入变量在给定元组中的出现次数。

index() 方法

index() 方法是 Python 的内置方法，用于搜索元组中的指定元素并返回其位置。

语法

参数

item (必需): item 参数是要在元组中搜索的项。
start (可选): start 参数表示搜索开始的起始索引。
end (可选): end 参数表示搜索结束的结束索引。

一个整数值，表示指定值首次出现的索引。

现在让我们看下面的示例，说明在 Python 元组中使用 index() 方法。

示例

 
# Python program to demonstrate the use of index() method in the case of tuples

# creating tuples
T1 = (0, 2, 3, 6, 4, 2, 5, 6, 3, 2, 2, 6, 7, 2, 7, 8, 0, 1, 9, 1)
T2 = ('Apple', 'Orange', 'Mango', 'Apple', 'Banana', 'Mango', 'Mango', 'Orange', 'Mango', 'Apple')

# searching for the occurrence of 2 in the tuple T1
resultOne = T1.index(2)
resultTwo = T1.index(2, 5)

# searching for the occurence of 'Mango' in the tuple T2
resultThree = T2.index('Mango')
resultFour = T2.index('Mango', 3)

# printing the results
print("Tuple T1 =>", T1)
print("First Occurrence of 2 in T1 =>", resultOne)
print("First Occurrence of 2 after 5th index in T1 =>", resultTwo)

# printing the results
print("\nTuple T2 =>", T2)
print("First Occurrence of 'Mango' in T2 =>", resultThree)
print("First Occurrence of 'Mango' after 3rd index in T2 =>", resultFour)

立即执行

输出

 
Tuple T1 => (0, 2, 3, 6, 4, 2, 5, 6, 3, 2, 2, 6, 7, 2, 7, 8, 0, 1, 9, 1)
First Occurrence of 2 in T1 => 1
First Occurrence of 2 after 5th index in T1 => 5

Tuple T2 => ('Apple', 'Orange', 'Mango', 'Apple', 'Banana', 'Mango', 'Mango', 'Orange', 'Mango', 'Apple')
First Occurrence of 'Mango' in T2 => 2
First Occurrence of 'Mango' after 3rd index in T2 => 5

说明

在此示例中，我们使用 index() 方法返回传入元素在给定元组中首次出现的索引值。

Python 元组的其他一些方法

除了 count() 和 index() 方法之外，我们还有一些其他方法可以处理 Python 中的元组。这些方法如下：

max()
min()
len()

现在让我们详细讨论这些方法。

max() 方法

Python 的 max() 方法用于返回元组中的最大值。

语法

参数

object (必需): object 参数可以是任何可迭代对象，如元组、列表等。

该可迭代对象（元组、列表等）中的最大元素。

现在让我们看下面的示例，说明使用 max() 方法查找给定元组中的最大整数。

示例

 
# Python program to demonstrate the use of max() method in the case of tuples

# creating a tuple
sampleTuple = (5, 3, 6, 1, 2, 8, 7, 9, 0, 4)

# printing the tuple for reference
print("Given Tuple =>", sampleTuple)

# using the max() method to find the largest element in the tuple
largest_element = max(sampleTuple)

# printing the result for the users
print("The Largest Element in the Given Tuple =>", largest_element)

立即执行

输出

 
Given Tuple => (5, 3, 6, 1, 2, 8, 7, 9, 0, 4)
The Largest Element in the Given Tuple => 9

说明

在示例中，我们使用了 max() 方法在给定的元组中查找最大元素。

min() 方法

Python 提供了一个名为 min() 的方法来查找元组中的最小值。

语法

参数

object (必需): object 参数可以是任何可迭代对象，如元组、列表等。

该可迭代对象（元组、列表等）中的最小元素。

现在让我们看下面的示例，说明使用 min() 方法查找给定元组中的最小整数。

示例

# Python program to demonstrate the use of min() method in the case of tuples

# creating a tuple
sampleTuple = (5, 3, 6, 1, 2, 8, 7, 9, 0, 4)

# printing the tuple for reference
print("Given Tuple =>", sampleTuple)

# using the min() method to find the smallest element in the tuple
smallest_element = min(sampleTuple)

# printing the result for the users
print("The Smallest Element in the Given Tuple =>", smallest_element)

立即执行

输出

 
Given Tuple => (5, 3, 6, 1, 2, 8, 7, 9, 0, 4)
The Smallest Element in the Given Tuple => 0

说明

在示例中，我们使用了 min() 方法在给定的元组中查找最小元素。

len() 方法

Python 的 len() 方法用于查找给定序列（如元组、列表、字符串等）的长度。

语法

参数

object (必需): object 参数可以是任何可迭代对象，如元组、列表等。

该可迭代对象（元组、列表等）中的元素数量。

现在让我们看下面的示例，说明使用 len() 方法查找给定元组的长度。

示例

# Python program to demonstrate the use of len() method in the case of tuples

# creating a tuple
sampleTuple = (5, 3, 6, 1, 2, 8, 7, 9, 0, 4)

# printing the tuple for reference
print("Given Tuple =>", sampleTuple)

# using the len() method to find the length of the tuple
length_of_tuple = len(sampleTuple)

# printing the result for the users
print("Number of Elements in the Given Tuple =>", length_of_tuple)

立即执行

输出

 
Given Tuple => (5, 3, 6, 1, 2, 8, 7, 9, 0, 4)
Number of Elements in the Given Tuple => 10

说明

在示例中，我们使用了 len() 方法在给定的元组中查找其中存在的元素总数。

结论

总之，Python 元组是一种重要的数据结构，它允许我们将一个项目集合存储在单个变量中。与列表不同，元组是不可变的，这意味着它们的值在创建后不能更改。当我们需要确保数据在整个程序中保持不变时，它们非常有用。元组可以存储多种数据类型，支持索引和切片，并且比列表更节省内存。了解如何使用元组有助于提高 Python 代码的可靠性和性能。

Python 元组 - 选择题

1. 以下哪种是创建 Python 元组的正确方法？

tpl_1 = [16, 2, 3]
tpl_1 = {1, 2, 3}
tpl_1 = (1, 2, 3)
tpl_1 = <1, 2, 3>

答案：c) tpl_1 = (1, 2, 3)

2. Python 中的列表和元组的主要区别是什么？

元组更快且不可变
列表是不可变的
元组占用更多内存
列表不能嵌套

答案：a) 元组更快且不可变

3. 哪个方法可用于计算值在元组中出现的次数？

add()
count()
index()
find()

答案：b) count()

4. len((4, 5, 6)) 的输出是什么？

1
2
3
Error

答案：c) 3

5. 元组可以包含不同数据类型的元素吗？

不能
仅字符串
仅整数
是的

答案：d) 是

下一主题Python 元组方法

← 上一个下一个 →

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Python教程

Python变量和数据类型

Python控制语句

Python数据结构

Python函数

Python模块

Python OOP

Python异常处理

Python文件处理

Python搜索和排序

Python高级主题

Python MySQL

Python MongoDB

Python SQLite

Python MCQ

Python Tkinter (GUI)

Python Web Blocker

Python内置函数

Python字符串函数

Python列表

Python字典

Plotly

相关教程

Python元组

示例

Python 元组的特性

示例

创建元组

示例

访问元组元素

示例

元组切片

示例

删除元组

示例

更改元组中的元素

示例

向元组添加元素

将元组转换为列表

示例

将元组添加到元组

示例

解包元组

示例

注意：在解包元组时，左侧的变量数量应等于给定元组中元素的数量。如果变量与元组的大小不匹配，我们可以使用星号 '*' 来将剩余元素存储为列表。

循环元组

示例

Python 中的元组操作

示例

Python 元组方法

count() 方法

示例

index() 方法

示例

Python 元组的其他一些方法

max() 方法

示例

min() 方法

示例

len() 方法