第十一章多元组

这一章，我们能讲解一下如何使用元组，元组是Python 的内置类型之一。元组是一种不可变的序列类型（Immutable），意思是一旦一个元组被创建，它的元素就不能被改变或删除。这是列表和元组最大的区别。还有，序列类型是指由多个元素按顺序排列的数据类型。

目录

11-1 创建一个元组
11-2 获取元组的元素
11-3 使用切片获取元组中包含指定范围元素的新元组
11-4 获取元组长度（元素个数）
11-5 将一个元组与另一个元组组合以创建一个新的元组
11-6 创建一个新的元组，将元组的元素重复指定
11-7 检查元组是否包含与指定值相同的元素
11-8 从字符串、列表、范围等创建元组
11-9 按升序或降序对元组的元素进行排序

11-1 创建一个元组

我们将解释如何创建一个新的元组。元组包含多个元素。除了通过为元素指定值来创建元组之外，我们还可以指定变量或创建重复相同元素指定次数的元组。

创建一个有值的元组

元组类型是通过在 小括号（）之间用逗号 (,) 分隔多个元素来定义的。格式如下。

(元素1, 元素2, ...)

如果只有一个元素，请添加一个逗号。

(元素1,)

严格来说，( ) 是可省略的。您可以通过用逗号分隔多个元素来定义元组。

t = 元素1,
t = 元素1, 元素2, ...

由于难以区分，因此我们一般在工作中始终用小括号来标注元组。

元素可以是 Python 可以处理的任何东西，例如数字和字符串。

(7, 8, 6, 5, 9)
("Orange", "Lemon", "Apple")

可以为同一元组中的每个元素指定具有不同数据类型的对象。

(30, "Qingdao", "Yuhua", True)

我们也可以为元素指定另一个元组。

("A", ("B", "C"), "D")

我们也可以创建一个包含空元素的元组。

()

也可以通过将创建的元组分配给数字或字符串等变量来使用创建的元组。

colortuple = ("White", "Black", "Red")

指定分配给变量的值作为元素

通过指定值创建元组时，我们可以通过指定赋值的变量来创建元组，而不是直接输入值。

x = 9
y = 18
numtuple = (x, y)
print(numtuple)

>> (9, 18)

如果为元素指定了变量名，那么它将被视为创建元组时分配给变量的值是直接写入的，而不是将变量引用设置为元素。所以前一个元组与创建的元组完全相同：

numlist = (9, 18)
print(numlist)

>> (9, 18)

在创建元组后为变量分配不同的值不会更改元组元素。

x = 9
y = 18
numtuple = (x, y)
print(numtuple)

>> (9, 18)

x = 20
print(numtuple)

>> (9, 18)

创建一个重复指定数量元素的元组

例如，要创建一个包含指定数量的具有特定值的元素的元组，您可以这样做：（请注意，如果元组只有一个元素，则逗号是必需的）。

元组 = (元素,) * 计数

例如，要创建一个包含 10 个元素且数值为 0 的元组：

numtuple = (0,) * 10
print(numtuple)

>> (0, 0, 0, 0, 0, 0, 0, 0, 0, 0)

与列表不同，元组以后不能更改，因此可能用得不多。

如果另一个元组被指定为重复元素，则通过重复元组中包含的指定数量的元素来创建新元组，而不是使用具有该元组的指定数量的元素创建新元组。

numtuple = (10, 20, 30) * 3
print(numtuple)

>> (10, 20, 30, 10, 20, 30, 10, 20, 30)

11-2 获取元组的元素

我们可以通过为创建的元组指定索引来获取元素。本节介绍如何获取元组的元素。

按索引获取元素

元组中的每个元素都按顺序分配了一个索引。第一个元素被分配索引 0 ，下一个元素 1 ，依此类推。您可以通过指定索引来获取元组元素。

元组 [索引]

以下示例按顺序获取元组的每个元素。

mytuple = ("Orange", "Lemon", "Apple")

print(mytuple[0])
>> Orange
print(mytuple[1])
>> Lemon
print(mytuple[2])
>> Apple

索引也可以指定为负值。元组中最后一个元素的索引为 -1，并分配为 -2、-3、… 向前移动。

在下面的示例中，通过指定负索引并输出到屏幕，依次获取元组的每个元素。

mytuple = ("Orange", "Lemon", "Apple")

print(mytuple[-1])
>> Apple
print(mytuple[-2])
>> Lemon
print(mytuple[-3])
>> Orange

如果您尝试通过指定元素不存在的索引来检索元素，则会发生 IndexError 错误。

mytuple = ("Orange", "Lemon", "Apple")
print(mytuple[3])

>> Traceback (most recent call last):
>>   File "<stdin>", line 1, in <module>
>> IndexError: tuple index out of range

查找元组中最后一个元素的索引

我们可以通过将元组指定为内置函数的 len 函数的参数来获取元组中元素的数量。

以下示例。

mytuple = ("Orange", "Lemon", "Apple")
print(len(mytuple))
>> 3

我们可以通过指定一个元组作为 len 函数的参数，我们能够获得元组中的 3 个元素。

元组第一个元素的索引从0开始，所以元组最后一个元素的索引是元素个数-1。所以最后一个元素的索引可以用 len(list) -1 获得。

mytuple = ("Orange", "Lemon", "Apple")
print(mytuple[len(mytuple) - 1])
>> Apple

示例代码

请看下面的示例。

animaltuple = ("Cat", "Dog", "Cow", "Monkey")

print("第一个元素是" + animaltuple[0] + " 。")
>> 第一个元素是 Cat 。
print("最后一个元素是" + animaltuple[len(animaltuple) - 1] + " 。")
>>最后一个元素是Monkey 。

这样我们就能够通过指定索引来获取元组的元素。

11-3 使用切片获取元组中包含指定范围元素的新元组

元组使用称为切片的功能来获取包含从起始索引到结束索引范围内的元素的新元组。在这里，我将解释如何使用切片功能，从元组中获取包含指定范围元素的新元组。

对元组使用切片功能

在元组上使用切片功能可以得到一个新的元组，该元组包含从开始位置到结束位置的指定范围内的元素。格式如下。

元组 [开始索引：结束索引]

指定范围时，指定范围的第一个元素的索引为起始索引，范围的最后一个元素的索引加1为结束索引。请参见下面的示例。

mytuple = ("A", "B", "C", "D", "E")

# 获取索引 2 到 3 的元素
mytuple[2:4]
--> ("C", "D")

#获取索引 0 到 2 的元素
mytuple[0:3]
--> ("A", B", "C")

# 获取索引 3 的元素
mytuple[3:4]
--> ("D",)

切片允许您获得包含一系列元素的新元组。请注意，即使只有一个元素，它也会作为元组获取。

示例代码

请看下面的示例。

animaltuple = ("Cat", "Lion", "Cow", "Dog", "Giraffe")

print(animaltuple[1:4])
>> ('Lion', 'Cow', 'Dog')
print(animaltuple[0:2])
>> ('Cat', 'Lion')
print(animaltuple[2:3])
>> ('Cow',)

这样我们能够使用切片从已创建的元组中获取包含一些元素的新元组。

省略开始或结束索引

使用 切片功能时可以省略开始或结束索引。

如果省略起始索引，则假定为 0。0 是元组中第一个元素的索引，因此如果省略起始索引，则范围是从元组的第一个元素到指定的结束索引。

mytuple = ("A", "B", "C", "D", "E")

# 获取从第一个索引到 3 的元素
mytuple[:4]
--> ("A", B", "C", "D")

如果省略结束索引，则假定 len(tuple) 值。如果将元组指定为 len 函数的参数，则返回元组中元素的数量，因此如果省略结束索引，则范围将从指定的起始索引到元组的最后一个元素。

mytuple = ("A", "B", "C", "D", "E")

# 获取从索引2到末尾的元素
mytuple[2:]
--> (C", "D", "E")

如果您同时省略起始索引和结束索引，则会得到一个包含原始元组所有元素的新元组，因为范围是从元组的第一个元素到最后一个元素。

mytuple = ("A", "B", "C", "D", "E")

# 从第一个到最后一个索引获取元素
mytuple[:]
--> ("A", "B", "C", "D", "E")

示例代码

请看下面的示例。

animaltuple = ("Cat", "Lion", "Cow", "Dog", "Giraffe")

print(animaltuple[:3])
>> ('Cat', 'Lion', 'Cow')
print(animaltuple[2:])
>> ('Cow', 'Dog', 'Giraffe')
print(animaltuple[:])
>> ('Cat', 'Lion', 'Cow', 'Dog', 'Giraffe')

这样我们就可以在使用切片时通过省略开始或结束索引来指定范围。

11-4 获取元组长度（元素个数）

我们可以使用内置的 len 函数来获取指定为参数的对象的元素的长度和数量。如果将元组指定为参数，则可以获得元组中包含的元素数。格式如下。

len(元组)

获取参数中指定的元组中的元素数。

len(("Red", "Blue", "Green"))
--> 3

len((10, 20, 30, 40, 50))
--> 5

示例代码

请看下面的示例。

animallist = ("Monkey", "Cat", "Dog", "Cow")

print("元素个数为" + str(len(animallist)) + " 。")
>> 元素个数为 4 。

这样我们就能够使用 len 函数获取元组的长度（元素数）。

11-5 将一个元组与另一个元组组合以创建一个新的元组

元组是不可变的，因此我们不能更改创建的元组，但我们可以将它与另一个元组组合以创建一个新的元组。这里我们解释如何通过连接另一个元组来创建一个新的元组。

通过加入另一个元组来创建一个新的元组

我们可以在元组上使用 + 运算符将其与另一个元组组合以创建新元组。

元组A + 元组B

使用两个元组的元素创建一个新列表。

具体写如下。

tuple1 = ("A", "B", "C")
tuple2 = ("D", "E")
tuple3 = tuple1 + tuple2
print(tuple3)
--> ("A", "B", "C", "D", "E")

示例代码

请看下面的示例。

redtuple = ("Orange", "Strawberry")
yellowtuple = ("Lemon", "Banana", "Grapefruit")

# 合并 redtuple 和 yellowtuple
fruittuple = redtuple + yellowtuple

print(fruittuple)
>> ('Orange', 'Strawberry', 'Lemon', 'Banana', 'Grapefruit')

这样我们就能够通过连接两个元组来创建一个新的元组。

11-6 创建一个新的元组，将元组的元素重复指定

我们可以在元组上使用 * 运算符来创建一个新的元组，该元组将反复元组的元素。在这里，我们将解释如何创建一个新的元组，该元组将按指定的次数反复元组的元素。

创建一个新的元组，该元组将按指定的次数反复元组的元素

我们可以在元组上使用 * 运算符来创建一个新的元组，该元组将反复元组的元素

元组 * 次数

创建一个新的元组，该元组将元组的元素重复指定的次数。

具体写如下。

tuple = ("A", "B", "C")
newtuple = tuple * 3
print(newtuple)
--> ("A", "B", "C", "A", "B", "C", "A", "B", "C")

示例代码

请看下面的示例。

basetuple = ("Yes", "No")

mytuple = basetuple * 4
print(mytuple)
>> ('Yes', 'No', 'Yes', 'No', 'Yes', 'No', 'Yes', 'No')

这样我们就能够使用元组元素的 4 次迭代创建一个新元组。

11-7 检查元组是否包含与指定值相同的元素

如果创建的元组中包含与指定值相同的元素，我将解释如何获取元素的数量和元素的索引。使用 in 运算符检查是否包含元素，使用 count 方法检查元素数量，使用 index 方法检查索引。

检查是否包含与指定值具有相同值的元素

使用 in 运算符检查元组是否包含具有给定值的元素。

値 in 元组

如果元组的元素中存在与指定值相同的元素，则表达式变为 True。否则为假。

具体写如下。

mytuple = ("A", "B", "C", "D", "E")

print("B" in mytuple)
>> True
print("D" in mytuple)
>> True
print("G" in mytuple)
>> False

请注意，如果您使用 not in 运算符而不是 in 运算符，则如果存在与指定值相同的值，它将返回 False，否则返回 True。

获取元组中有多少个元素包含与指定值相同的值

这是一种获取元组中包含多少与指定值具有相同值的元素的方法。使用元组类型可用的计数方法。

元组.count(値)

返回与指定参数具有相同值的元素数。如果找不到则返回 0。

具体写如下。

mytuple = ("A", "B", "A", "A", "C")

print(mytuple.count("A"))
>> 3
print(mytuple.count("B"))
>> 1
print(mytuple.count("D"))
>> 0

获取与指定值相同的元素的索引

如何获取与元组中指定值具有相同值的元素的索引。使用元组类型可用的索引方法。

元组.index(値)

返回找到的与参数中指定的值具有相同值的元素的索引。如果找到多个元素，则返回第一个元素的索引。

具体写如下。

mytuple = ("A", "B", "A", "A", "C")

print(mytuple.index("A"))
>> 0
print(mytuple.index("B"))
>> 1
print(mytuple.index("C"))
>> 4

请注意，如果找不到，将发生 ValueError 错误。

mytuple = ("A", "B", "A", "A", "C")

print(mytuple.index("D"))

>> Traceback (most recent call last):
>>   File "<stdin>", line 1, in <module>
>> ValueError: tuple.index(x): x not in tuple

11-8 从字符串、列表、范围等创建元组

我们将解释如何从其他对象（如字符串、列表和范围）创建元组。

有一个元组类型构造函数，它通过将可迭代对象指定为参数来创建元组对象。

class tuple([iterable])

可迭代对象是列表、元组、字符串、字典等。

从另一个元组创建一个元组

首先，通过将另一个元组指定为参数来创建一个元组对象。

mytuple = ("A", "B", "C")
newtuple = tuple(mytuple);

print(newtuple)
>> ('A', 'B', 'C')

创建了一个与参数中指定的元组具有相同元素的元组。请注意，元组是不可变对象，因此两个元组是同一个对象。

从字符串创建元组

接下来，让我们通过指定一个字符串作为参数来创建一个元组对象。

mytuple = tuple("Hello Python")
print(mytuple)
>> ('H', 'e', 'l', 'l', 'o', ' ', 'P', 'y', 't', 'h', 'o', 'n')

创建一个新元组，其中一个元素对应指定为参数的字符串中的每个字符。

从列表创建元组

接下来，让我们通过指定一个列表作为参数来创建一个元组对象。

mytuple = tuple(["A", "B", "C"])
print(mytuple)
>> ('A', 'B', 'C')

通过复制参数中指定的列表的元素来创建新的元组。

从range创建一个元组

range类型是一个对象，它具有从构造函数中指定为自变量的起始编号到结束编号​​的连续编号。

class range(stop)
class range(start, stop[, step])

它有从开始到结束的连续数值作为元素。如果省略 start，则 0 是起始编号。

让我们通过将范围类型对象指定为参数来创建元组对象。

mytuple = tuple(range(10))
print(mytuple)
>> (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

这样我们就能够创建一个列表，其中包含从 0 到 9 的连续数字作为元素。

11-9 按升序或降序对元组的元素进行排序

说明如何使用元素值按升序或降序对创建的元组中包含的元素进行排序。对于排序，使用 sorted 函数并从生成的列表对象创建一个元组对象

对元素进行排序

要对元素进行排序，请使用内置的排序函数。格式如下。

newlist = sorted(iterable, *, key=None, reverse=False)

除了第一个参数外，其他参数都可以省略，基本用法如下。

newlist = sorted(iterable)

对指定为第一个参数的可迭代对象（字符串、列表、元组、字典等）的元素进行排序，并将其作为新对象返回。排序前的对象保持原样，排序后的结果作为新的列表类型对象返回。

即使将元组指定为参数，排序后的结果也会返回列表类型的对象。因此，如果要将排序结果作为元组获取，则需要从列表类型对象创建元组。

newtuple = tuple(newlist)

排序是通过使用 < 运算符比较元素值来完成的。稍后再试，但是如果元组元素中混合了数字和字符串，就无法进行比较，会出现TypeError错误。

具体写如下。

mytuple = ("C", "A", "B")

# 开始排列
newlist = sorted(mytuple)

# 从列表中创建一个元组
newtuple = tuple(newlist)

print(mytuple)
--> ("C", "A", "B")
print(newtuple)
--> ("A", "B", "C")

示例代码

请看以下两个示例。

numtuple = (55, 78, 92, 82, 65)

newnumlist = sorted(numtuple)
newnumtuple = tuple(newnumlist)

print("Before:", numtuple)
>> Before: (55, 78, 92, 82, 65)
print("After: ", newnumtuple)
>> After:  (55, 65, 78, 82, 92)

animaltuple = ("Dog", "Cat", "Bear", "Deer")

newanimallist = sorted(animaltuple)
newanimaltuple = tuple(newanimallist)

print("Before:", animaltuple)
>> Before: ('Dog', 'Cat', 'Bear', 'Deer')
print("After: ", newanimaltuple)
>> After:  ('Bear', 'Cat', 'Deer', 'Dog')

这样我们就可以使用 sorted 函数对列表元素进行排序。

当元素值的数据类型不同时

元组的元素可以有不同数据类型的值，但是在排序的时候，元素值是用>运算符进行比较的，所以允许用>运算符进行比较。这取决于是否

比如即使元素值的数据类型不同，如果是整数和浮点数也可以排序。

numtuple = (5, 3.14, 4.78, 4)
newlist = sorted(numtuple)

print(tuple(newlist))
>> (3.14, 4, 4.78, 5)

但是，如果元素值是数字和字符串的混合，排序会导致TypeError错误。

mytuple = ("80", 75, 45, "68")
newlist = sorted(mytuple)

>> Traceback (most recent call last):
>>   File "<stdin>", line 1, in <module>
>> TypeError: '<' not supported between instances of 'int' and 'str'

排序时在升序和降序之间切换

使用 sorted 函数时，默认按升序排序。要按降序排序，请执行以下操作：

newlist = sorted(iterable, reverse=True)

以 reverse=True 作为参数运行排序函数。

具体写如下。

mytuple = ("C", "A", "B")

#开始排列
newlist = sorted(mytuple, reverse=True)

#从列表中创建一个元组
newtuple = tuple(newlist)

print(mytuple)
--> ("C", "A", "B")
print(newtuple)
--> ("C", "B", "A")

示例代码

请看下面的示例。

colortuple = ("Blue", "Red", "Green", "White", "Black")

upcolortuple = tuple(sorted(colortuple))
downcolortuple = tuple(sorted(colortuple, reverse=True))

print("Orig:", colortuple)
>> Orig: ('Blue', 'Red', 'Green', 'White', 'Black')
print("ASC: ", upcolortuple)
>> ASC:  ('Black', 'Blue', 'Green', 'Red', 'White')
print("DESC:", downcolortuple)
>> DESC: ('White', 'Red', 'Green', 'Blue', 'Black')

这样我们就可以使用 sorted 函数，对元组的元素分别进行升序和降序排序。

将元素值传递给另一个函数并使用返回值进行排序

排序时，不是原样使用元素值进行比较，而是将元素值传递给指定的函数，使用返回值进行比较，如下：

newlist = sorted(iterable, key=函数名)

对于可以指定的函数，指定一个带一个参数的函数。

比如取绝对值后要排序，指定内置的abs函数。

mytuple = (5, -4, -7, 6)

tuple(sorted(mytuple))
--> (-7, -4, 5, 6)

tuple(sorted(mytuple, key=abs))
--> (-4, 5, 6, -7)

根据每个元素值的绝对值排序。

例如，如果要按字符串长度排序，请使用内置的 len 函数。

mytuple = ("apple", "pen", "desk", "banana")

tuple(sorted(mytuple))
--> ('apple', 'banana', 'desk', 'pen')

tuple(sorted(mytuple, key=len))
--> ('pen', 'desk', 'apple', 'banana')

这样我们可以获取每个元素值的字符长度并按长度排序。

示例代码

请看下面的示例。

mytuple = ("C", "b", "A", "E", "d")

sorttuple = tuple(sorted(mytuple))
lowersorttuple = tuple(sorted(mytuple, key=str.lower))

print(mytuple)
>> ('C', 'b', 'A', 'E', 'd')
print(sorttuple)
>> ('A', 'C', 'E', 'b', 'd')
print(lowersorttuple)
>> ('A', 'b', 'C', 'd', 'E')

这次，我们讲解了，用字符串类型 str.lower() 的方法来作为参数指定的函数，进行排列的方法。