• 周二. 2月 7th, 2023

python 元组的详细用法

城主

12月 27, 2022 ,

在 Python 中,元组是一种不可变的序列类型。这意味着,一旦你创建了一个元组,就不能修改它。通常会使用元组来存储一些固定数量的相关值,比如二维空间中的坐标,或者一个人的姓名和年龄。

这是如何在 Python 中创建元组的一个示例:





>>> coordinates = (2, 3)
>>> name_and_age = ("John", 30)

你可以使用索引访问元组中的元素,就像使用列表一样:





>>> coordinates[0]
2
>>> name_and_age[1]
30

元组也支持切片,以及与列表相同的许多方法和操作,例如 len()count()index()

元组和列表的一个主要区别是元组是不可变的,这意味着你不能修改它们。例如,你不能向元组追加元素,也不能更改元组中的元素值。但是,你可以通过连接或切片原始元组来创建一个具有所需值的新元组。





>>> coordinates = (2, 3)
>>> new_coordinates = coordinates + (4, 5)
>>> new_coordinates
(2, 3, 4, 5)

元组通常与返回多个值的函数一起使用,因为它们提供了一种方便的方式来存储和解包返回的值。

除了可以使用索引和切片访问元组中的元素外,你还可以使用多种方法来操作元组。

例如,你可以使用 len() 函数来获取元组中的元素数量:





>>> t = (1, 2, 3, 4)
>>> len(t)
4

你也可以使用 count() 方法来统计元组中某个值出现的次数:





>>> t = (1, 2, 3, 3, 4)
>>> t.count(3)
2

还可以使用 index() 方法来查找元组中某个值的第一个索引:





>>> t = (1, 2, 3, 3, 4)
>>> t.index(3)
2

注意,如果元组中不存在你要查找的值,则会引发一个 ValueError 异常。

你还可以使用运算符 in 来判断元组中是否包含某个值:





>>> 3 in t
True
>>> 5 in t
False

另外,你还可以使用常见的运算符,如 +*,来进行元组的连接和复制。

例如,你可以使用 + 运算符来连接两个元组:





>>> t1 = (1, 2, 3)
>>> t2 = (4, 5, 6)
>>> t1 + t2
(1, 2, 3, 4, 5, 6)

你也可以使用 * 运算符来复制元组:





>>> t = (1, 2, 3)
>>> t * 3
(1, 2, 3, 1, 2, 3, 1, 2, 3)

解包是将多个值赋值给多个变量的过程。

阅读  Python 第三方库的用法详解

例如,你可以将一个元组的值解包到多个变量中:





>>> coordinates = (2, 3)
>>> x, y = coordinates
>>> print(x)  # Output: 2
>>> print(y)  # Output: 3

这种方法可以在函数返回多个值时非常有用:





def divide(x, y):
    quotient = x // y
    remainder = x % y
    return quotient, remainder

quotient, remainder = divide(10, 3)
print(quotient)  # Output: 3
print(remainder)  # Output: 1

解包也可以用于序列(包括元组和列表)的迭代中:





>>> numbers = [(1, 2), (3, 4), (5, 6)]
>>> for a, b in numbers:
...     print(a, b)
...
1 2
3 4
5 6

注意,当你解包时,变量的数量必须与元组或序列中的值的数量相匹配。否则,会引发一个 ValueError 异常。

另外,在 Python 中,元组是可以嵌套的。例如,你可以将一个元组包含在另一个元组中:





>>> t = ((1, 2), 3, 4)
>>> t[0]
(1, 2)

你也可以将一个列表包含在元组中:





>>> t = ([1, 2], 3, 4)
>>> t[0]
[1, 2]

但是,由于元组是不可变的,所以你无法在元组中直接修改嵌套的元组或列表。

除了可以使用方括号来创建元组外,你还可以使用 Python 的内置函数 tuple() 来创建元组。

例如,你可以使用 tuple() 函数将列表转换为元组:





>>> numbers = [1, 2, 3]
>>> t = tuple(numbers)
>>> t
(1, 2, 3)

你还可以使用 tuple() 函数将字符串转换为元组,其中每个字符都是一个元素:





>>> s = "hello"
>>> t = tuple(s)
>>> t
('h', 'e', 'l', 'l', 'o')

你还可以使用 tuple() 函数将迭代器或可迭代对象转换为元组:





>>> numbers = (i for i in range(1, 4))
>>> t = tuple(numbers)
>>> t
(1, 2, 3)

另外,你还可以使用内置函数 reversed() 来反转元组中的元素:





>>> t = (1, 2, 3)
>>> r = reversed(t)
>>> list(r)
[3, 2, 1]

注意,reversed() 函数返回的是一个反转的迭代器,而不是一个新的元组。如果你想要一个新的元组,可以将其转换为列表后再转换回元组。

阅读  Python lambda 函数的详细用法

最后,你可以使用 sorted() 函数将元组中的元素按照顺序排序:





>>> t = (3, 2, 1)
>>> s = sorted(t)
>>> s
[1, 2, 3]

注意,so

元组是不可变的序列类型,因此无法修改元组中的值。但是,你可以通过以下方法来模拟对元组的修改操作:

  • 将元组转换为列表,修改列表中的值,然后再将列表转换回元组。
  • 使用索引访问元组中的某个值,并将其赋值给新的变量。
  • 使用切片和连接操作创建新的元组。

例如,你可以将元组转换为列表,修改列表中的值,然后再将列表转换回元组:





>>> t = (1, 2, 3)
>>> l = list(t)
>>> l[1] = 4
>>> t = tuple(l)
>>> t
(1, 4, 3)

在 Python 中,你可以使用内置函数 enumerate() 来迭代元组,并获取每个元素的索引和值。

例如,你可以这样使用 enumerate() 函数:





>>> t = ("apple", "banana", "cherry")
>>> for index, value in enumerate(t):
...     print(index, value)
...
0 apple
1 banana
2 cherry

你还可以指定 enumerate() 函数的起始索引,以便从指定的索引开始计数:





>>> t = ("apple", "banana", "cherry")
>>> for index, value in enumerate(t, 1):
...     print(index, value)
...
1 apple
2 banana
3 cherry

在 Python 中,你可以使用内置函数 zip() 来将多个序列(包括元组)中的元素按照相同的索引进行合并。

例如,你可以将两个元组中的元素按照索引进行合并:





>>> t1 = ("apple", "banana", "cherry")
>>> t2 = ("red", "yellow", "purple")
>>> t3 = zip(t1, t2)
>>> print(t3)  # Output: <zip object at 0x...>
>>> print(list(t3))  # Output: [("apple", "red"), ("banana", "yellow"), ("cherry", "purple")]

你还可以将多个元组中的元素按照索引进行合并:





>>> t1 = ("apple", "banana", "cherry")
>>> t2 = ("red", "yellow", "purple")
>>> t3 = ("small", "medium", "large")
>>> t4 = zip(t1, t2, t3)
>>> print(list(t4))  # Output: [("apple", "red", "small"), ("banana", "yellow", "medium"), ("cherry", "purple", "large")]

你也可以使用 zip() 函数将字典中的键和值进行合并:





>>> d = { "name": "John", "age": 30 }
>>> t = zip(d.values(), d.keys())
>>> print(list(t))  # Output: [(30, "age"), ("John", "name")]

注意,zip() 函数返回的是一个迭代器,如果你想要一个可以重复使用的列表,可以将其转换为列表或元组。

阅读  Python 机器学习教程

在 Python 中,你可以使用内置函数 sum() 来计算元组中所有元素的总和。

例如,你可以这样使用 sum() 函数:





>>> t = (1, 2, 3)
>>> print(sum(t))  # Output: 6

你也可以使用 sum() 函数来计算浮点数元组中所有元素的总和:





>>> t = (1.5, 2.5, 3.5)
>>> print(sum(t))  # Output: 7.5

如果你想要计算元组中元素的平均值,你可以使用内置函数 mean() 或者自己计算:





>>> from statistics import mean
>>> t = (1, 2, 3)
>>> print(mean(t))  # Output: 2.0

>>> t = (1, 2, 3)
>>> print(sum(t) / len(t))  # Output: 2.0

注意,在 Python 3.9 中,可以使用内置函数 mean() 计算数字序列的平均值。如果你使用的是旧版本的 Python,则需要使用第三方库 statistics 来计算平均值。

另外,你还可以使用内置函数 min()max() 来查找元组中最小和最大的元素:





>>> t = (1, 2, 3)
>>> print(min(t))  # Output: 1
>>> print(max(t))  # Output: 3

注意,如果元组中包含非数字元素,则会引发 TypeError 异常。