跳到主要内容

Python 元组

提示
  1. 元组不可变性：Python的元组一旦创建就不能修改，与可变的列表形成对比。
  2. 元组的创建和访问：元组通过圆括号和逗号创建，支持索引、负索引和切片等多种访问方式。
  3. 元组与列表的区别：元组适用于异质数据类型和固定数据，性能较列表更优，且可作为字典键。

Python中的元组类似于列表。两者之间的区别在于，一旦指定了元组的元素，我们就不能更改它，而列表的元素是可以更改的。

创建元组​

通过将所有元素（项目）放在圆括号()内，并用逗号分隔，来创建元组。虽然圆括号是可选的，但使用它们是一个好习惯。

元组可以包含任意数量的项目，这些项目可能是不同类型的（整数、浮点数、列表、字符串等）。

# 不同类型的元组
# 空元组
my_tuple = ()
print(my_tuple)

# 包含整数的元组
my_tuple = (1, 2, 3)
print(my_tuple)

# 包含混合数据类型的元组
my_tuple = (1, "Hello", 3.4)
print(my_tuple)

# 嵌套元组
my_tuple = ("mouse", [8, 4, 6], (1, 2, 3))
print(my_tuple)

输出

()
(1, 2, 3)
(1, 'Hello', 3.4)
('mouse', [8, 4, 6], (1, 2, 3))

在上面的示例中，我们创建了不同类型的元组，并在其中存储了不同的数据项。

如前所述，我们也可以在不使用圆括号的情况下创建元组：

my_tuple = 1, 2, 3
my_tuple = 1, "Hello", 3.4

创建只有一个元素的Python元组​

在Python中，创建只有一个元素的元组有点棘手。仅在圆括号内有一个元素是不够的。

我们需要一个尾随逗号来表明这是一个元组，

var1 = ("Hello") # 字符串
var2 = ("Hello",) # 元组

我们可以使用type()函数来了解变量或值属于哪个类。

var1 = ("hello")
print(type(var1)) # <class 'str'>

# 创建只有一个元素的元组
var2 = ("hello",)
print(type(var2)) # <class 'tuple'>

# 圆括号是可选的
var3 = "hello",
print(type(var3)) # <class 'tuple'>

这里，

  • ("hello")是一个字符串，所以type()返回var1的类为str，即<class 'str'>
  • ("hello",)和"hello",都是元组，所以type()返回var1的类为tuple，即<class 'tuple'>

访问Python元组元素​

像列表一样，元组的每个元素都由索引号**（0, 1, ...）表示，其中第一个元素位于索引0**。

我们使用索引号来访问元组元素。例如，

1. 索引​

我们可以使用索引运算符[]来访问元组中的一个项目，其中索引从0开始。

因此，一个有6个元素的元组将有从0到5的索引。尝试访问元组索引范围之外的索引（例如在此示例中的6,7,...）将引发IndexError。

索引必须是整数，所以我们不能使用浮点数或其他类型。这将导致TypeError。

同样，嵌套元组通过嵌套索引来访问，如下例所示。

# 使用索引访问元组元素
letters = ("p", "r", "o", "g", "r", "a", "m", "i", "z")

print(letters[0]) # 打印 "p"
print(letters[5]) # 打

印 "a"

在上面的示例中，

  • letters[0] - 访问第一个元素
  • letters[5] - 访问第六个元素

2. 负索引​

Python允许对其序列使用负索引。

索引**-1指的是最后一个项目，-2**指的是倒数第二个项目，以此类推。例如，

# 使用负索引访问元组元素
letters = ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')

print(letters[-1]) # 打印 'z'
print(letters[-3]) # 打印 'm'

在上面的示例中，

  • letters[-1] - 访问最后一个元素
  • letters[-3] - 访问倒数第三个元素

3. 切片​

我们可以使用切片运算符冒号:来访问元组中的一系列项目。

# 使用切片访问元组元素
my_tuple = ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')

# 第2到第4个索引的元素
print(my_tuple[1:4]) # 打印 ('r', 'o', 'g')

# 开始到第2个索引的元素
print(my_tuple[:-7]) # 打印 ('p', 'r')

# 第8个索引到结束的元素
print(my_tuple[7:]) # 打印 ('i', 'z')

# 开始到结束的元素
print(my_tuple[:]) # 打印 ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')

输出

('r', 'o', 'g')
('p', 'r')
('i', 'z')
('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')

这里，

  • my_tuple[1:4]返回一个元组，包含从索引1到索引3的元素。
  • my_tuple[:-7]返回一个元组，包含从开始到索引2的元素。
  • my_tuple[7:]返回一个元组，包含从索引7到结束的元素。
  • my_tuple[:]返回所有元组项目。

注意：当我们切片列表时，开始索引是包含的，但结束索引是排除的。

Python元组方法​

在Python中，不提供添加或删除项目的方法。只有以下两种方法可用。

Python元组方法的一些示例：

my_tuple = ('a', 'p', 'p', 'l', 'e',)

print(my_tuple.count('p')) # 打印 2
print(my_tuple.index('l')) # 打印 3

这里，

  • my_tuple.count('p') - 计算my_tuple中'p'的总数
  • my_tuple.index('l') - 返回my_tuple中'l'的第一次出现

在Python中遍历元组​

我们可以使用for循环来遍历元组的元素。例如，

languages = ('Python', 'Swift', 'C++')

# 遍历元组
for language in languages:
    print(language)

输出

Python
Swift
C++

检查Python元组中是否存在项目​

我们使用in关键字来检查元组中是否存在项目。例如，

languages = ('Python', 'Swift', 'C++')

print('C' in languages) # False
print('Python' in languages) # True

这里，

  • 'C'不在languages中，'C' in languages计算为False。
  • 'Python'在languages中，'Python' in languages计算为True。

Python元组相对于列表的优势​

由于元组与列表非常相似，它们在类似的情况下都会被使用。

然而，在某些情况下使用元组而不是列表有其特定的优势：

  • 我们通常使用元组来处理异质（不同）数据类型，而使用列表处理同质（相似）数据类型。
  • 由于元组是不可变的，遍历元组的速度比遍历列表更快。因此，有一定的性能提升。
  • 包含不可变元素的元组可以作为字典的键使用。在列表中，这是不可能的。
  • 如果你有不会改变的数据，将其实现为元组可以确保它保持写保护状态。
最后于 更新