Python Tuples详解！

发表于 更新于 分类于 阅读次数： 本文字数： 5.6k 阅读时长 ≈ 5 分钟

嗨，你好啊，我是猿java

Python Tuples（元组）是类似于列表的一种集合，元组中存储的值可以是任何类型，并且它们通过整数索引。这篇文章，我们将深入地分析 Python Tuples（元组）。

创建元组

在 Python 中，元组通过放置由“逗号”分隔的值序列来创建，可以使用或不使用括号来分组数据序列。

注意：不使用括号创建 Python元组被称为元组打包（Tuple Packing）。

下面通过一个示例展示在元组中添加元素：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 创建一个空元组
tuple1 = ()
print("初始空元组: ")
print(tuple1)

# 使用字符串创建元组
tuple1 = ('Hello', 'World')
print("\n使用字符串创建元组: ")
print(tuple1)

# 使用列表创建元组
list1 = [1, 2, 4, 5, 6]
print("\n使用列表创建元组: ")
print(tuple(list1))

# 使用内置函数创建元组
tuple1 = tuple('Python')
print("\n使用内置函数创建元组: ")
print(tuple1)

输出：

1
2
3
4
5
6
7
8
9
10
11
12
标准输出：初始空元组: 
()

使用字符串创建元组: 
('Hello', 'World')

使用列表创建元组: 
(1, 2, 4, 5, 6)

使用内置函数创建元组: 
('P', 'y', 't', 'h', 'o', 'n')

使用混合数据类型创建元组

Python元组可以包含任意数量的元素和任意数据类型（如字符串、整数、列表等）。元组也可以只包含一个元素，但这有点棘手。在括号中有一个元素是不够的，必须有一个尾随的“逗号”才能使其成为元组。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
tuple1 = (5,)
print("\n使用混合数据类型创建元组: ")
print(tuple1)

# 使用混合数据类型创建元组
tuple1 = (5, 'Welcome', 7, 'Python')
print("\n使用混合数据类型创建元组: ")
print(tuple1)

# 使用嵌套元组创建元组
tuple1 = (0, 1, 2, 3)
tuple2 = ('python', 'tuple')
tuple3 = (tuple1, tuple2)
print("\n使用嵌套元组创建元组: ")
print(tuple3)

# 使用重复创建元组
tuple1 = ('Hello',) * 3
print("\n使用重复创建元组: ")
print(tuple1)

# 使用循环创建元组
tuple1 = ('Hello')
n = 5
print("\n使用循环创建元组")
for i in range(int(n)):
    tuple1 = (tuple1,)
    print(tuple1)

输出：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
标准输出：使用混合数据类型创建元组: 
(5,)

使用混合数据类型创建元组: 
(5, 'Welcome', 7, 'Python')

使用嵌套元组创建元组: 
((0, 1, 2, 3), ('python', 'tuple'))

使用重复创建元组: 
('Hello', 'Hello', 'Hello')

使用循环创建元组
('Hello',)
(('Hello',),)
((('Hello',),),)
(((('Hello',),),),)
((((('Hello',),),),),)
  • 时间复杂度：O(1)
  • 空间复杂度：O(n)

Python 元组操作

下面是Python元组操作：

  • 访问元组
  • 元组连接
  • 元组切片
  • 删除元组

访问元组

在 Python 中，元组是不可变的，通常包含通过解包或索引访问的异构元素序列（在命名元组的情况下甚至可以通过属性访问）。列表是可变的，它们的元素通常是同质的，并通过遍历列表访问。

注意：在解包元组时，左侧变量的数量应等于给定元组a中的值的数量。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 通过索引访问元组
tuple1 = tuple("tuple")
print("\n元组的第一个元素: ")
print(tuple1[0])

# 元组解包
tuple1 = ("Hello", "World", "Tuple")

# 解包元组的值
a, b, c = tuple1
print("\n解包后的值: ")
print(a)
print(b)
print(c)

输出：

1
2
3
4
5
6
7
元组的第一个元素: 
t

解包后的值: 
Hello
World
Tuple
  • 时间复杂度：O(1)
  • 空间复杂度：O(1)

元组连接

元组的连接是将两个或更多元组连接在一起的过程。通过使用“+”运算符完成元组连接。元组的连接始终从原始元组的末尾开始。其他算术运算不适用于元组。

注意：只有相同的数据类型才能通过连接组合，如果将列表和元组组合会引发错误。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 元组连接
tuple1 = (0, 1, 2, 3)
tuple2 = ('Hello', 'Python', 'World')

tuple3 = tuple1 + tuple2

# 打印第一个元组
print("元组 1: ")
print(tuple1)

# 打印第二个元组
print("\n元组 2: ")
print(tuple2)

# 打印最终元组
print("\n连接后的元组: ")
print(tuple3)

输出：

1
2
3
4
5
6
7
8
元组 1: 
(0, 1, 2, 3)

元组 2: 
('Hello', 'Python', 'World')

连接后的元组: 
(0, 1, 2, 3, 'Hello', 'Python', 'World')
  • 时间复杂度：O(1)
  • 空间复杂度：O(1)

元组切片

元组的切片是从元组中获取特定范围或子元素集的过程。切片也可以用于列表和数组。列表中的索引结果是获取单个元素，而切片则允许获取一组元素。

注意：负增量值也可以用于反转元组的顺序。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# 元组切片

# 使用数字切片元组
tuple1 = tuple('Hello')

# 删除第一个元素
print("删除第一个元素: ")
print(tuple1[1:])

# 反转元组
print("\n反转后的元组: ")
print(tuple1[::-1])

# 打印范围内的元素
print("\n打印范围 2-4 之间的元素: ")
print(tuple1[4:9])

输出：

1
2
3
4
5
6
7
8
删除第一个元素: 
('e', 'l', 'l', 'o')

反转后的元组: 
('o', 'l', 'l', 'e', 'H')

打印范围 2-4 之间的元素: 
('o',)
  • 时间复杂度：O(1)
  • 空间复杂度：O(1)

删除元组

元组是不可变的，因此不允许删除其部分内容。整个元组可以通过del()方法删除。

注意：删除元组后打印元组会导致错误。

1
2
3
4
5
6
# 删除元组

tuple1 = (0, 1, 2, 3, 4)
del tuple1

print(tuple1)

输出：

1
2
3
4
Traceback (most recent call last): 
File "/home/efa50fd0709dec08434191f32275928a.py", line 7, in 
print(Tuple1) 
NameError: name 'tuple1' is not defined

内置方法

内置方法 描述
index() 查找元组并返回给定值的索引
count() 返回指定值的出现频率

内置函数

内置函数 描述
all() 如果所有元素为真或元组为空，则返回True
any() 如果元组的任何一个元素为真，则返回True；如果元组为空，则返回False
len() 返回元组的长度或大小
enumerate() 返回元组的枚举对象
max() 返回给定元组的最大元素
min() 返回给定元组的最小元素
sum() 将元组中的数字相加
sorted() 输入元组元素并返回一个新的排序列表
tuple() 将可迭代对象转换为元组

元组与列表的比较：

相似之处 不同之处
可以用于列表和元组的函数：len(), max(), min(), sum(), any(), all(), sorted() 不能用于元组的方法：append(), insert(), remove(), pop(), clear(), sort(), reverse()
可以用于列表和元组的方法：count(), index() 我们通常使用元组来存储不同数据类型，而使用列表来存储相同数据类型。
元组可以存储在列表中。 遍历元组比遍历列表更快。
列表可以存储在元组中。 列表是可变的，而元组是不可变的。
元组和列表都可以嵌套。 包含不可变元素的元组可以用作字典的键。

常见问题

Python元组的特性是什么？

  • 不可变：一旦创建，元组的元素不能被修改、添加或删除。
  • 有序：元组保持元素的顺序，可以使用索引访问元素。
  • 允许重复元素：元组可以包含重复的值并保留元素的位置。
  • 可以包含混合数据类型：元组可以包含不同的数据类型，如整数、字符串和列表。
  • 可哈希：如果元组的所有元素都是可哈希的，元组本身可以用作字典键或集合元素。
  • 比列表快：由于其不可变性，元组在迭代和访问操作上通常比列表快。

如何在 Python中创建和使用元组？

  • 使用括号()创建元组，并用逗号分隔元素。
  • 元组也可以在没有括号的情况下创建。

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
# 创建元组
tuple1 = (1, 2, 3, 4)
tuple2 = (1, "hello", 3.14)
tuple3 = (1,)  # 一个元素的元组（注意逗号）

# 不使用括号创建元组
tuple4 = 1, 2, 3, 4

# 访问元素
print(tuple1[0])  # 输出: 1
print(tuple2[1])  # 输出: hello

# 切片
print(tuple1[1:3])  # 输出: (2, 3)

Python中的元组是可变的吗？

不，元组是不可变的。这意味着一旦创建，元组的元素不能被更改、添加或删除。尝试修改元组会导致TypeError。

示例：

1
2
3
4
5
6
tuple1 = (1, 2, 3)
# 尝试修改元素
try:
    tuple1[1] = 4
except TypeError as e:
    print(e)  # 输出: 'tuple' object does not support item assignment

如何在 Python中解包元组的元素？

元组解包允许你在一个语句中将元组的元素分配给多个变量。

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
# 解包元组
person = ("Alice", 30, "Engineer")
name, age, profession = person

print(name)        # 输出: Alice
print(age)         # 输出: 30
print(profession)  # 输出: Engineer

# 使用占位符解包
a, *b, c = (1, 2, 3, 4, 5)
print(a)  # 输出: 1
print(b)  # 输出: [2, 3, 4]
print(c)  # 输出: 5

在什么时候应该使用元组而不是列表？

在以下场景中应使用元组而不是列表：

  • 不可变性：当你需要一个固定的项目集合且不应被修改时。
  • 可哈希集合：当你需要在字典中使用复合键或在集合中使用元素，并且元组的元素是可哈希的。
  • 性能：当你需要一个比列表在迭代和访问上更节省内存和更快的替代品时。
  • 数据完整性：当你希望确保值集合在整个程序中保持不变时。

元组使用案例示例：

  • 表示固定记录：坐标、RGB颜色值、数据库行。
  • 函数返回值：返回多个值的函数可以使用元组。
  • 作为字典键使用：元组可以用作字典键。

总结

本文，我们对 Python Tuples进行了详细的分析，元组是一种不可变、有序的集合，可以包含任意类型的元素。元组通过逗号分隔的值创建，通常使用括号括起来。由于其不可变性，元组更安全且更高效，适用于需要固定数据集的场景。元组支持索引访问、切片、连接和解包操作，但不支持修改。常用内置函数包括len(), max(), min(), sum()等。元组也可以作为字典的键或集合的元素，适用于需要数据完整性和高性能的场景。

学习交流

如果你觉得文章有帮助，请帮忙转发给更多的好友，或关注公众号：猿java，持续输出硬核文章。

drawing