实例(Python 3.0+)#

1
>>> tup1 = ('Google', 'Runoob', 1997, 2000)
2
>>> tup2 = (1, 2, 3, 4, 5)
3
>>> tup3 = "a", "b", "c", "d"  # 不需要括号也可以
4
>>> type(tup3)
5
<class 'tuple'>

创建空元组

1
tup1 = ()

元组中只包含一个元素时，需要在元素后面添加逗号, ，否则括号会被当作运算符使用：

实例(Python 3.0+)#

1
>>> tup1 = (50)
2
>>> type(tup1)  # 不加逗号，类型为整型
3
<class 'int'>
4

5
>>> tup1 = (50,)
6
>>> type(tup1)  # 加上逗号，类型为元组
7
<class 'tuple'>

元组与字符串类似，下标索引从 0 开始，可以进行截取，组合等。

访问元组#

元组可以使用下标索引来访问元组中的值，如下实例:

实例(Python 3.0+)#

1
tup1 = ('Google', 'Runoob', 1997, 2000)
2
tup2 = (1, 2, 3, 4, 5, 6, 7)
3

4
print("tup1[0]: ", tup1[0])
5
print("tup2[1:5]: ", tup2[1:5])

以上实例输出结果：

1
tup1[0]:  Google
2
tup2[1:5]:  (2, 3, 4, 5)

修改元组#

元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例:

实例(Python 3.0+)#

1
tup1 = (12, 34.56)
2
tup2 = ('abc', 'xyz')
3
tup3 = tup1 + tup2
4
print(tup3)

以上实例输出结果：

1
(12, 34.56, 'abc', 'xyz')

删除元组#

元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组，如下实例:

实例(Python 3.0+)#

1
tup = ('Google', 'Runoob', 1997, 2000)
2
print(tup)
3
del tup
4
print("删除后的元组 tup: ")
5
print(tup)

以上实例元组被删除后，输出变量会有异常信息，输出如下所示：

1
删除后的元组 tup :
2
Traceback (most recent call last):
3
  File "test.py", line 8, in <module>
4
    print (tup)
5
NameError: name 'tup' is not defined

元组运算符#

与字符串一样，元组之间可以使用 +、+=和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。

元组索引，截取#

因为元组也是一个序列，所以我们可以访问元组中的指定位置的元素，也可以截取索引中的一段元素，如下所示：

元组：

1
tup = ('Google', 'Runoob', 'Taobao', 'Wiki', 'Weibo','Weixin')

运行实例如下：

实例#

1
>>> tup = ('Google', 'Runoob', 'Taobao', 'Wiki', 'Weibo', 'Weixin')
2
>>> tup[1]
3
'Runoob'
4
>>> tup[-2]
5
'Weibo'
6
>>> tup[1:]
7
('Runoob', 'Taobao', 'Wiki', 'Weibo', 'Weixin')
8
>>> tup[1:4]
9
('Runoob', 'Taobao', 'Wiki')
10
>>>

元组内置函数#

Python元组包含了以下内置函数

1
>>> tup = ('r', 'u', 'n', 'o', 'o', 'b')
2
>>> tup[0] = 'g'  # 不支持修改元素
3
Traceback (most recent call last):
4
  File "<stdin>", line 1, in <module>
5
TypeError: 'tuple' object does not support item assignment
6
>>> id(tup)  # 查看内存地址
7
4440687904
8
>>> tup = (1, 2, 3)
9
>>> id(tup)
10
4441088800  # 内存地址不一样了

练习题#

• 1. 创建元组 创建文件 test_tuple.py，完成以下操作：

  • 创建元组 t1 = (1, 2, 3, 4, 5)
  • 创建元组 t2 = ("a", "b", "c")
  • 创建只有一个元素的元组 t3 = (10,)（注意逗号）
  • 打印每个元组及其类型

  -> (元素1, 元素2, …)、(元素,) 单元素元组要加逗号#

  参考答案：

  1
  t1 = (1, 2, 3, 4, 5)
  2
  t2 = ("a", "b", "c")
  3
  t3 = (10,)
  4
  
  5
  print(f"t1: {t1}, 类型: {type(t1)}")
  6
  print(f"t2: {t2}, 类型: {type(t2)}")
  7
  print(f"t3: {t3}, 类型: {type(t3)}")

• 2. 访问元组元素 创建文件 test_access.py，完成以下操作：

  • 创建元组 t = ("苹果", "香蕉", "橘子", "葡萄", "西瓜")
  • 打印第一个元素、最后一个元素
  • 打印索引 1 到 3 的切片

  -> tuple[0]、tuple[-1]、tuple[开始:结束]#

  参考答案：

  1
  t = ("苹果", "香蕉", "橘子", "葡萄", "西瓜")
  2
  
  3
  print(f"第一个: {t[0]}")      # 苹果
  4
  print(f"最后一个: {t[-1]}")   # 西瓜
  5
  print(f"切片 [1:3]: {t[1:3]}")  # ('香蕉', '橘子')

• 3. 元组拼接与重复 创建文件 test_concat.py，完成以下操作：

  • 创建元组 a = (1, 2, 3) 和 b = (4, 5, 6)
  • 用 + 拼接两个元组
  • 用 * 重复元组 3 次

  -> tuple1 + tuple2、tuple * 次数#

  参考答案：

  1
  a = (1, 2, 3)
  2
  b = (4, 5, 6)
  3
  
  4
  c = a + b
  5
  print(f"拼接: {c}")  # (1, 2, 3, 4, 5, 6)
  6
  
  7
  d = a * 3
  8
  print(f"重复: {d}")  # (1, 2, 3, 1, 2, 3, 1, 2, 3)

• 4. 元组常用函数 创建文件 test_func.py，完成以下操作：

  • 创建元组 t = (3, 1, 4, 1, 5, 9, 2, 6)
  • 用 len() 计算长度
  • 用 max() 获取最大值
  • 用 min() 获取最小值

  -> len(tuple)、max(tuple)、min(tuple)#

  参考答案：

  1
  t = (3, 1, 4, 1, 5, 9, 2, 6)
  2
  
  3
  print(f"长度: {len(t)}")    # 8
  4
  print(f"最大值: {max(t)}")  # 9
  5
  print(f"最小值: {min(t)}")  # 1

• 5. 元组与列表转换 创建文件 test_convert.py，完成以下操作：

  • 创建列表 lst = [1, 2, 3, 4, 5]
  • 用 tuple() 将列表转换为元组
  • 创建元组 t = (6, 7, 8)
  • 用 list() 将元组转换为列表

  -> tuple(列表)、list(元组)#

  参考答案：

  1
  lst = [1, 2, 3, 4, 5]
  2
  t = tuple(lst)
  3
  print(f"列表转元组: {t}")  # (1, 2, 3, 4, 5)
  4
  
  5
  t2 = (6, 7, 8)
  6
  lst2 = list(t2)
  7
  print(f"元组转列表: {lst2}")  # [6, 7, 8]

• 6. 元组遍历与删除 创建文件 test_iter.py，完成以下操作：

  • 创建元组 t = (10, 20, 30, 40, 50)
  • 用 for 循环遍历打印每个元素
  • 用 in 判断 30 是否在元组中
  • 用 del 删除整个元组，观察结果

  -> for x in tuple: print(x)、值 in tuple、del tuple#

  参考答案：

  1
  t = (10, 20, 30, 40, 50)
  2
  
  3
  # for 循环遍历
  4
  for x in t:
  5
      print(x, end=" ")  # 10 20 30 40 50
  6
  print()
  7
  
  8
  # in 判断
  9
  print(f"30是否在元组中: {30 in t}")  # True
  10
  
  11
  # del 删除
  12
  del t
  13
  # print(t)  # 报错：NameError: name 't' is not defined

• 7. 元组不可变性验证 创建文件 test_immut.py，完成以下操作：

  • 创建元组 t = (1, 2, 3)
  • 尝试修改 t[0] = 10，观察报错信息
  • 用 id() 查看修改前后元组的内存地址

  -> tuple[索引] = 值（会报错）、id(对象)#

  参考答案：

  1
  t = (1, 2, 3)
  2
  print(f"修改前: {t}")
  3
  print(f"修改前地址: {id(t)}")
  4
  
  5
  # 尝试修改会报错：TypeError: 'tuple' object does not support item assignment
  6
  # t[0] = 10
  7
  
  8
  t = (10, 2, 3)  # 重新赋值
  9
  print(f"重新赋值后: {t}")
  10
  print(f"重新赋值后地址: {id(t)}")  # 地址不同，是新对象