原文： https://www.programiz.com/python-programming/tuple

在本文中，您将学习有关 Python 元组的所有知识。 更具体地说，什么是元组，如何创建它们，何时使用它们以及您应该熟悉的各种方法。

Python 中的元组类似于列表。 两者之间的区别在于，一旦分配了元组，我们就无法更改其元素，而可以更改列表中的元素。

创建一个元组

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

元组可以具有任意数量的项，并且可以具有不同的类型（整数，浮点数，列表，字符串等）。

  1. # Different types of tuples
  3. # Empty tuple
  4. my_tuple = ()
  5. print(my_tuple)
  7. # Tuple having integers
  8. my_tuple = (1, 2, 3)
  9. print(my_tuple)
  11. # tuple with mixed datatypes
  12. my_tuple = (1, "Hello", 3.4)
  13. print(my_tuple)
  15. # nested tuple
  16. my_tuple = ("mouse", [8, 4, 6], (1, 2, 3))
  17. print(my_tuple)

输出

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

也可以在不使用括号的情况下创建元组。 这称为元组包装。

  1. my_tuple = 3, 4.6, "dog"
  2. print(my_tuple)
  4. # tuple unpacking is also possible
  5. a, b, c = my_tuple
  7. print(a)      # 3
  8. print(b)      # 4.6
  9. print(c)      # dog

输出：

  1. (3, 4.6, 'dog')
  2. 3
  3. 4.6
  4. dog

用一个元素创建一个元组有点棘手。

括号内仅包含一个元素是不够的。 我们将需要一个逗号结尾来表明它实际上是一个元组。

  1. my_tuple = ("hello")
  2. print(type(my_tuple))  # <class 'str'>
  4. # Creating a tuple having one element
  5. my_tuple = ("hello",)
  6. print(type(my_tuple))  # <class 'tuple'>
  8. # Parentheses is optional
  9. my_tuple = "hello",
  10. print(type(my_tuple))  # <class 'tuple'>

输出：

  1. <class 'str'>
  2. <class 'tuple'>
  3. <class 'tuple'>

访问元组元素

我们可以通过多种方式访问元组的元素。

1.索引

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

因此，具有 6 个元素的元组将具有从 0 到 5 的索引。尝试访问元组索引范围（在本示例中为 6，7，…）之外的索引将产生IndexError。

索引必须是整数，因此我们不能使用float或其他类型。 这将导致TypeError。

同样，使用嵌套索引访问嵌套元组，如下面的示例所示。

  1. # Accessing tuple elements using indexing
  2. my_tuple = ('p','e','r','m','i','t')
  4. print(my_tuple[0])   # 'p' 
  5. print(my_tuple[5])   # 't'
  7. # IndexError: list index out of range
  8. # print(my_tuple[6])
  10. # Index must be an integer
  11. # TypeError: list indices must be integers, not float
  12. # my_tuple[2.0]
  14. # nested tuple
  15. n_tuple = ("mouse", [8, 4, 6], (1, 2, 3))
  17. # nested index
  18. print(n_tuple[0][3])       # 's'
  19. print(n_tuple[1][1])       # 4

输出：

  1. p
  2. t
  3. s
  4. 4

2.负索引

Python 允许对其序列进行负索引。

索引 -1 表示最后一项，-2 表示倒数第二项，依此类推。

  1. # Negative indexing for accessing tuple elements
  2. my_tuple = ('p', 'e', 'r', 'm', 'i', 't')
  4. # Output: 't'
  5. print(my_tuple[-1])
  7. # Output: 'p'
  8. print(my_tuple[-6])

输出：

  1. t
  2. p

3.切片

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

  1. # Accessing tuple elements using slicing
  2. my_tuple = ('p','r','o','g','r','a','m','i','z')
  4. # elements 2nd to 4th
  5. # Output: ('r', 'o', 'g')
  6. print(my_tuple[1:4])
  8. # elements beginning to 2nd
  9. # Output: ('p', 'r')
  10. print(my_tuple[:-7])
  12. # elements 8th to end
  13. # Output: ('i', 'z')
  14. print(my_tuple[7:])
  16. # elements beginning to end
  17. # Output: ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')
  18. print(my_tuple[:])

输出：

  1. ('r', 'o', 'g')
  2. ('p', 'r')
  3. ('i', 'z')
  4. ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')

通过考虑索引位于元素之间，可以最好地可视化切片，如下所示。 因此，如果要访问范围，则需要将元组中的部分切片的索引。

Python 元组 - 图1

Python 中的元素切片

修改元组

与列表不同，元组是不可变的。

这意味着一旦分配了元组的元素就无法更改。 但是，如果元素本身是可变数据类型（如列表），则可以更改其嵌套项目。

我们还可以将元组分配给不同的值（重新分配）。

  1. # Changing tuple values
  2. my_tuple = (4, 2, 3, [6, 5])
  4. # TypeError: 'tuple' object does not support item assignment
  5. # my_tuple[1] = 9
  7. # However, item of mutable element can be changed
  8. my_tuple[3][0] = 9    # Output: (4, 2, 3, [9, 5])
  9. print(my_tuple)
  11. # Tuples can be reassigned
  12. my_tuple = ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')
  14. # Output: ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')
  15. print(my_tuple)

输出：

  1. (4, 2, 3, [9, 5])
  2. ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')

我们可以使用+运算符组合两个元组。 这称为连接。

我们也可以使用*运算符将重复元组中的元素给定次数。

+和*操作都产生一个新的元组。

  1. # Concatenation
  2. # Output: (1, 2, 3, 4, 5, 6)
  3. print((1, 2, 3) + (4, 5, 6))
  5. # Repeat
  6. # Output: ('Repeat', 'Repeat', 'Repeat')
  7. print(("Repeat",) * 3)

输出：

  1. (1, 2, 3, 4, 5, 6)
  2. ('Repeat', 'Repeat', 'Repeat')

删除元组

如上所述，我们不能更改元组中的元素。 这意味着我们不能删除或删除元组中的项目。

但是，可以使用关键字del完全删除一个元组。

  1. # Deleting tuples
  2. my_tuple = ('p', 'r', 'o', 'g', 'r', 'a', 'm', 'i', 'z')
  4. # can't delete items
  5. # TypeError: 'tuple' object doesn't support item deletion
  6. # del my_tuple[3]
  8. # Can delete an entire tuple
  9. del my_tuple
  11. # NameError: name 'my_tuple' is not defined
  12. print(my_tuple)

输出：

  1. Traceback (most recent call last):
  2.   File "<string>", line 12, in <module>
  3. NameError: name 'my_tuple' is not defined

元组方法

元组不提供添加项目或删除项目的方法。 仅以下两种方法可用。

Python 元组方法的一些示例：

  1. my_tuple = ('a', 'p', 'p', 'l', 'e',)
  3. print(my_tuple.count('p'))  # Output: 2
  4. print(my_tuple.index('l'))  # Output: 3

输出：

  1. 2
  2. 3

其他元组操作

1.元组成员资格测试

我们可以使用关键字in测试项目是否存在于元组中。

  1. # Membership test in tuple
  2. my_tuple = ('a', 'p', 'p', 'l', 'e',)
  4. # In operation
  5. print('a' in my_tuple)
  6. print('b' in my_tuple)
  8. # Not in operation
  9. print('g' not in my_tuple)

输出：

  1. True
  2. False
  3. True

2.遍历元组

我们可以使用for循环来遍历元组中的每个项目。

  1. # Using a for loop to iterate through a tuple
  2. for name in ('John', 'Kate'):
  3.     print("Hello", name)

输出：

  1. Hello John
  2. Hello Kate

元组优于列表的优势

由于元组与列表非常相似，因此它们都在类似的情况下使用。 但是，在列表上实现元组具有某些优点。 以下列出了一些主要优点：

  • 我们通常将元组用于异构（不同）数据类型，将列表用于同类（相似）数据类型。
  • 由于元组是不可变的，因此遍历元组比使用list更快。 因此，性能略有提高。
  • 包含不可变元素的元组可以用作字典的键。 对于列表，这是不可能的。
  • 如果您的数据没有变化，将其实现为元组将保证其保持写保护。