Python 教程

Appearance

Python 元组 ​

  • Python 元组是不可变序列。
  • 元组由以逗号分隔的值组成。
  • 由于元组是不可变的，我们不能添加或删除它的元素。
  • 如果元组元素不是不可变的，那么它们的属性是可以改变的。但是，我们不能直接改变元组元素本身。
  • 我们可以创建嵌套元组。
  • 我们可以通过索引访问元组元素。它还支持负索引，即从末尾到开头引用元素。
  • 我们还可以将元组元素解包为逗号分隔值。
  • 元组通常用于存储异构元素。它们也可以包含None 值。
  • 元组支持两个运算符：+ 用于连接元素，* 用于重复元素。
  • 元组支持切片操作，可以从源元组创建另一个元组。
  • 我们可以使用“in”和“not in”运算符来检查元组中是否存在某个元素。
  • 由于元组是一个序列，我们可以使用for 循环遍历它的元素。
  • Python 元组类有两个函数——count()和index()。

如何在Python中创建元组？ ​

我们可以通过将所有元素放在用逗号分隔的括号内来创建一个元组。

python
tuple_numbers = (1, 2, 3, 1)

我们可以在元组中保存不同类型的对象。

python
tup = 1, 2, 3, 1, None, "Hello"

我们来看一个嵌套元组的例子。

python
nested_tuple = ((1, 2), ("Hello", "Hi"), "Python")

我们可以通过不在括号内放置任何元素来创建一个空元组。

python
empty_tuple = ()

使用括号来定义元组边界是可选的，但最佳实践是使用括号。如果打印元组，元素始终会打印在括号内。

shell
>>> tup = 1, 2, "Hello"
>>> print(tup)
(1, 2, 'Hello')
>>>

创建包含单个元素的元组有点棘手。如果在括号内只放置一个值，它不会创建元组，而是会创建该值类型的对象。让我们通过一个简单的例子来验证这种行为。

python
single_item_tuple = ("Hello")
 
print(type(single_item_tuple))
 
single_item_tuple = (10)
 
print(type(single_item_tuple))

输出：

Python 元组示例

我们可以在值后面添加逗号，创建一个包含单个元素的元组。

python
single_item_tuple = "Hello",
 
print(type(single_item_tuple))
 
single_item_tuple = 10,
 
print(type(single_item_tuple))

Python 元组包含单个元素

如何访问元组元素？ ​

我们可以通过索引访问元组元素。索引值从 0 开始，一直到元组长度减 1。

python
tuple_numbers = (1, 2, 3, 4)
 
print(f'First element in tuple is {tuple_numbers[0]}')
print(f'Third element in tuple is {tuple_numbers[3]}')

如果元组大小小于指定的索引，则会抛出“ IndexError: 元组索引超出范围”错误。

shell
>>> tuple_numbers = (1, 2, 3, 4)
>>> tuple_numbers[10]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: tuple index out of range
>>>

元组也支持负索引。在这种情况下，元组元素是从末尾到开头检索的。负索引从 -1 开始，直到减去元组的长度。

python
tuple_numbers = (1, 2, 3, 4)
 
print(f'Last element in tuple is {tuple_numbers[-1]}')
print(f'Second Last element in tuple is {tuple_numbers[-2]}')
print(f'First element in tuple is {tuple_numbers[-4]}')

如果有一个嵌套元组，我们可以通过嵌套索引访问它的元素。

shell
>>> nested_tuple = (1, 2, (3, 4), (5, 6, 7))
>>> nested_tuple[2][0]
3
>>> nested_tuple[2][1]
4
>>> nested_tuple[3][0]
5
>>> nested_tuple[3][1]
6
>>> nested_tuple[3][2]
7
>>>

我们也可以使用负索引来处理嵌套元组。

shell
>>> nested_tuple = (1, 2, (3, 4), (5, 6, 7))
>>> 
>>> nested_tuple[-1][-1]
7
>>> nested_tuple[-2][1]
4
>>> nested_tuple[-2][-1]
4
>>> nested_tuple[3][-2]
6
>>>

下图展示了元组中索引的工作原理。

Python 元组索引

对元组进行切片 ​

我们可以使用切片来创建元组的子集。这在从源元组创建新元组时非常有用。切片技术使用两个用冒号分隔的索引。左侧索引包含在结果中，而右侧索引则不包含在结果中。

python
tuple_numbers = (1, 2, 3, 4, 5, 6, 7, 8)
 
print(tuple_numbers[1:3])
print(tuple_numbers[:4])
print(tuple_numbers[5:])
print(tuple_numbers[:-5])

输出：

Python 中的元组切片

元组是不可变的 ​

元组本质上是不可变的，因此我们不能添加、更新或删除其元素。但是，如果元素是可变的，那么它的属性就可以改变。

shell
>>> tup = (1,2)
>>> tup[0] = 10
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

让我们来看一个例子，其中元组元素是可变的，我们更改它们的属性。

python
list_fruits = ["Apple"]
 
tup = ("Hello", list_fruits)
 
print(tup)
 
list_fruits.append("Banana")
 
print(tup)

输出：

Python 元组及其可变元素

删除元组 ​

我们不能直接删除元组中的元素，但我们可以使用del语句删除元组本身。

shell
>>> tup = (1,2)
>>> print(tup)
(1, 2)
>>> del tup
>>> print(tup)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'tup' is not defined
>>>

元组连接（+运算符） ​

我们可以使用 + 运算符将元组元素连接起来创建一个新元组。

shell
>>> tuple1 = (1, 2)
>>> tuple2 = (3, 4)
>>> tuple3 = (5, 6, 7)
>>> 
>>> tuple_all = tuple1 + tuple2 + tuple3
>>> print(tuple_all)
(1, 2, 3, 4, 5, 6, 7)
>>>

重复元组元素（* 运算符） ​

元组还支持 * 运算符，用于创建一个新的元组，其中元素重复指定次数。

shell
>>> tup = (1, 2, (3, 4))
>>> 
>>> tup1 = tup * 3
>>> 
>>> print(tup1)
(1, 2, (3, 4), 1, 2, (3, 4), 1, 2, (3, 4))
>>>

Python 元组函数 ​

元组类有两个函数。

  • count(x)：返回给定元素出现的次数。
  • index(x, start, end) : 返回值的第一个索引。我们可以指定起始索引和结束索引，以便在元组中查找值。如果找不到该值，则会引发ValueError异常。
shell
>>> tup = (1, 2, 3, 1, 2, 1, 3, 2, 1)
>>> 
>>> tup.count(1)
4
>>> tup.count(2)
3
>>> tup.index(2)
1
>>> tup.index(2, 2)
4
>>> tup.index(2, 2, 6)
4
>>> tup.index(20)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: tuple.index(x): x not in tuple
>>>

元组成员资格测试（in、not in 运算符） ​

我们可以使用“in”运算符来检查元组是否包含某个元素。类似地，我们可以使用“not in”运算符来测试元组中是否不存在某个元素。

shell
>>> vowels = ("a", "e", "i", "o", "u")
>>> 
>>> "a" in vowels
True
>>> "x" in vowels
False
>>> 
>>> "a" not in vowels
False
>>> "x" not in vowels
True

遍历元组 ​

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

python
vowels = ("a", "e", "i", "o", "u")
 
for v in vowels:
    print(v)

如果要按相反的顺序遍历元组，可以使用 reversed() 函数。

python
for v in reversed(vowels):
    print(v)

元组与列表 ​

  • 元组是不可变的，而列表是可变的。
  • 与列表相比，元组更适合用于存储不同数据类型的序列。
  • 由于元组是不可变的，因此遍历元组比遍历列表略快。
  • 元组比列表更节省内存和空间。
  • 如果要向序列中添加或删除元素，请使用列表。

Python tuple() 内置函数 ​

我们还可以使用 tuple() 函数来创建元组。它接受一个可迭代参数，例如 List 和 String。它在将其他序列类型转换为元组时非常有用。

1. Python 列表转元组 ​

python
list_numbers = [1, 2, 3]
 
tuple_numbers = tuple(list_numbers)
print(tuple_numbers)  # (1, 2, 3)

2. Python字符串转元组 ​

python
s = "ABCD"
tuple_str = tuple(s)
print(tuple_str)  # ('A', 'B', 'C', 'D')

3. Python 范围到元组 ​

python
r = range(1, 10)
tuple_range = tuple(r)
print(tuple_range)

结论 ​

在Python中，元组是不可变的序列。当你需要只读序列时，请使用元组。

参考： ​