原文： https://howtodoinjava.com/python/python-tuples/

在 Pyhton 中，元组与list相似，但它是不可变的，并用可选的圆括号编写。

元组是：

  • 不变的
  • 有序
  • 异构
  • 带有索引（从零开始）
  • 带圆括号（可选，但建议）
  • 在迭代过程中更快，因为它是不可变的

元组对于创建对象很有用，该对象通常包含相关信息，例如： 员工信息。 换句话说，元组可以让我们将相关信息“块”在一起，并将其用作单个事物。

1.创建一个元组

元组中的元素用圆括号括起来，并用逗号分隔。 元组可以包含任意数量的不同类型的项。

  1. Tuple = (item1, item2, item3)
  1. tuple1 = ()        # empty tuple
  3. tuple2 = (1, "2", 3.0)
  5. tuple3 = 1, "2", 3.0

1.1 一个元素的元组

如果元组仅包含一个元素，则不将其视为元组。 它应该以逗号结尾，以指定解释器为元组。

  1. tupleWithOneElement = ("hello", )    # Notice trailing comma

1.2 嵌套元组

一个包含另一个元组作为元素的元组，称为嵌套元组。

  1. nestedTuple = ("hello", ("python", "world"))

2.访问元组项

我们可以使用方括号内的索引访问元组项。

  • 正索引从元组的开始开始计数。
  • 负索引从元组的末尾开始计数。
  • 索引的范围将创建带有指定项目的新元组（称为切片）。
  • 范围[m:n]表示从位置m（包括）到位置n（排除）。
  • 使用双索引访问嵌套元组的元素。
  1. Tuple = ("a", "b", "c", "d", "e", "f")
  3. print(Tuple[0])        # a
  4. print(Tuple[1])        # b
  6. print(Tuple[-1])    # f
  7. print(Tuple[-2])    # e
  9. print(Tuple[0:3])    # ('a', 'b', 'c')
  10. print(Tuple[-3:-1])    # ('d', 'e')
  12. Tuple = ("a", "b", "c", ("d", "e", "f"))
  14. print(Tuple[3])            # ('d', 'e', 'f')
  15. print(Tuple[3][0])        # d
  16. print(Tuple[3][0:2])    # ('d', 'e')

3.遍历元组

使用for循环，以遍历元组项。

  1. Tuple = ("a", "b", "c")
  3. for x in Tuple:
  4.   print(x)

4.检查项目是否存在于元组中

要检查元组是否包含给定元素，可以使用'in'关键字和'not in'关键字。

  1. Tuple = ("a", "b", "c", "d", "e", "f")
  3. if "a" in Tuple:
  4.   print("Yes, 'a' is present")        # Yes, 'a' is present
  6. if "p" not in Tuple:
  7.   print("No, 'p' is not present")    # No, 'p' is not present

5.对元组进行排序

使用内置的sorted()语言方法对元组中的元素进行排序。

  1. Tuple = ("a", "c", "b", "d", "f", "e")
  3. sortedTuple = sorted(Tuple)
  5. print (sortedTuple)    # ("a", "b", "c", "d", "e", "f")

6.元组的重复和连接

要重复一个元组的所有元素，请将其乘以所需因子N。

  1. Tuple = ("a", "b") 
  3. repeatedTuple = Tuple * 3
  5. print (repeatedTuple)    # ('a', 'b', 'a', 'b', 'a', 'b')

要连接/连接两个或多个元组，我们可以使用+运算符。

  1. Tuple1 = ("a", "b", "c") 
  2. Tuple2 = ("d", "e", "f")
  4. joinedTuple = Tuple1 + Tuple2
  6. print (joinedTuple)    # ("a", "b", "c", "d", "e", "f")

7.打包和解包元组

打包是指我们将一组值分配给变量的操作。 在打包时，元组中的所有项目都分配给一个元组对象。

在下面的示例中，所有三个值都分配给变量Tuple。

  1. Tuple = ("a", "b", "c")

解包称为将元组变量分配给另一个元组，并将元组中的各个项目分配给各个变量的操作。

在给定的示例中，将元组解包为新的元组，并将值a, b, c – 分配给变量x, y, z。

  1. Tuple = ("a", "b", "c")        # Packing
  3. (x, y, z) = Tuple
  5. print (x)    # a
  6. print (y)    # b
  7. print (z)    # c

在解包期间，分配左侧的元组中的元素数必须等于右侧的数量。

  1. Tuple = ("a", "b", "c")        # Packing
  3. (x, y, z) = Tuple        # ValueError: too many values to unpack (expected 2)
  5. (x, y, z, i) =    Tuple     # ValueError: not enough values to unpack (expected 4, got 3)

8.命名元组

Python 提供了一种称为namedtuple()的特殊类型的函数，该函数来自collection模块。

命名元组类似于字典，但是支持从值和键访问，其中字典仅支持按键访问。

  1. import collections
  3. Record = collections.namedtuple('Record', ['id', 'name', 'date'])
  5. R1 = Record('1', 'My Record', '12/12/2020')
  7. #Accessing using index
  8. print("Record id is:", R1[0])        # Record id is: 1
  10. # Accessing using key    
  11. print("Record name is:", R1.name)    # Record name is: My Record

9. Python 元组方法

9.1 any

如果该元组中至少存在一个元素，则返回True；如果该元组为空，则返回False。

  1. print( any( () ) )        # Empty tuple - False
  2. print( any( (1,) ) )    # One element tuple - True
  3. print( any( (1, 2) ) )    # Regular tuple - True

9.2 min()

返回元组的最小元素（整数）。

  1. Tuple = (4, 1, 2, 6, 9)
  3. print( min( Tuple ) )    # 1

9.3 max()

返回元组的最大元素（整数）。

  1. Tuple = (4, 1, 2, 6, 9)
  3. print( max( Tuple ) )    # 9

9.4 len()

返回元组的长度。

  1. Tuple = (4, 1, 2, 6, 9)
  3. print( len( Tuple ) )    # 5

9.5 sum()

返回元组的所有元素（整数）的总和。

  1. Tuple = (4, 1, 2, 6, 9)
  3. print( sum( Tuple ) )    # 22

10.总结

如上所述，元组不可变，有序和索引的异构元素集合。 它写有或没有圆括号。

元组对于创建对象类型和实例非常有用。

元组支持类似于list类型的操作，只有我们不能更改元组元素。

学习愉快！

阅读更多 ：

Python – 元组比较
Python – 列表与元组