python数据类型-元组tuple[2023版]

python数据类型-元组tuple

转载请标明出处

元组是Python中的一种数据结构，用于存储多个元素的有序集合。它是一个不可变的序列，一旦创建，元组的元素不能被修改。元组使用圆括号 () 表示，元素之间用逗号分隔。与列表不同，元组的长度和元素内容都是固定的。元组可以包含不同类型的元素，如整数、浮点数、字符串等。它可以作为函数的参数、返回值或字典的键使用。由于元组是不可变的，它们在需要保持数据的不变性以及对数据进行快速读取的场景中很有用。
下面我们开始讲解元组的知识点：

元组的定义和特点

元组是Python中的一种数据结构，它是一个有序、不可变的序列。不可变意味着一旦创建，元组的元素不能被修改。以下是有关元组的一些知识点和对应的代码示例：

1. 创建元组：

   • 使用圆括号 () 创建一个空元组：

    empty_tuple = ()
   

   • 在定义元组时，使用逗号分隔各个元素：

    fruits_tuple = ('apple', 'banana', 'cherry')
   

   • 可以不使用圆括号创建元组，直接使用逗号分隔元素：

    colors_tuple = 'red', 'green', 'blue'
   

   • 可以通过调用函数来定义元组：

   colors_tuple=tuple(('apple', 'banana', 'cherry'))
   

2. 访问元组元素：

   • 使用索引来访问元组中的特定元素。索引从0开始，表示第一个元素，依次类推。也可以使用负数索引从元组的末尾开始反向访问元素：

    fruits_tuple = ('apple', 'banana', 'cherry')
    print(fruits_tuple[0])    # 输出：'apple'
    print(fruits_tuple[-1])   # 输出：'cherry'
   

3. 元组的长度：

   • 使用内置函数 len() 获取元组的长度（即元素的数量）：

    fruits_tuple = ('apple', 'banana', 'cherry')
    length = len(fruits_tuple)
    print(length)    # 输出：3
   

4. 元组的不可变性：

   • 元组一旦创建，就无法修改元素的值：

    fruits_tuple = ('apple', 'banana', 'cherry')
    fruits_tuple[0] = 'orange'  # 会引发 TypeError
   

5. 元组的特点：

   • 元组的长度和元素内容都是固定的，无法添加、修改或删除元素。
   • 元组可以包含不同类型的元素，如整数、浮点数、字符串等。

元组的内置函数和内置方法

元组在Python中有一些内置函数和方法可用。以下是一些常用的内置函数和方法：

1. 内置函数：
   • len(tuple): 返回元组中元素的数量。
   • max(tuple): 返回元组中最大的元素。
   • min(tuple): 返回元组中最小的元素。
   • sum(tuple): 返回元组中所有数值元素的和。

下面是这些内置函数的代码示例：

fruits_tuple = ('apple', 'banana', 'cherry')
length = len(fruits_tuple)
print(length)    # 输出：3

numbers_tuple = (10, 5, 8, 20)
maximum = max(numbers_tuple)
print(maximum)   # 输出：20

minimum = min(numbers_tuple)
print(minimum)   # 输出：5

sum_of_numbers = sum(numbers_tuple)
print(sum_of_numbers)   # 输出：43

2. 内置方法：
   • tuple.count(value): 返回元组中指定值的出现次数。
   • tuple.index(value): 返回元组中第一次出现指定值的索引。

下面是这些内置方法的代码示例：

fruits_tuple = ('apple', 'banana', 'cherry', 'apple')
count = fruits_tuple.count('apple')
print(count)    # 输出：2

index = fruits_tuple.index('cherry')
print(index)    # 输出：2

请注意，元组是不可变的，因此这些方法不会修改原始元组，而是返回相应的结果。

元组的比较和排序

元组在Python中可以进行比较和排序的操作。以下是相关的知识点和代码示例：

1. 元组的比较：
   • 元组可以使用比较运算符进行逐个元素的比较。从左到右逐个比较元组的对应元素，直到找到第一个不同的元素或比较完所有元素。比较的结果根据比较运算符的规则返回布尔值（True或False）。
   • 注意：元组的比较是按照元素的顺序进行的，如果第一个元素相等，则比较第二个元素，依此类推。

以下是元组比较的代码示例：

tuple1 = (1, 2, 3)
tuple2 = (1, 2, 4)
tuple3 = (1, 2, 3)

print(tuple1 < tuple2)   # 输出：True
print(tuple1 == tuple3)  # 输出：True
print(tuple2 > tuple3)   # 输出：True

2. 元组的排序：
   • 使用内置函数 sorted() 可以对元组进行排序，返回一个新的排序后的列表，不会改变原始元组的顺序。
   • sorted() 函数接受一个可迭代对象作为参数，并返回一个包含排序后的元素的列表。

以下是对元组进行排序的代码示例：

numbers_tuple = (5, 2, 8, 1)
sorted_numbers = sorted(numbers_tuple)
print(sorted_numbers)   # 输出：[1, 2, 5, 8]

fruits_tuple = ('apple', 'banana', 'cherry')
sorted_fruits = sorted(fruits_tuple)
print(sorted_fruits)    # 输出：['apple', 'banana', 'cherry']

请注意，排序操作返回的是一个列表，而不是一个元组。如果需要得到一个排序后的元组，可以使用 tuple() 函数将排序后的列表转换为元组。

sorted_numbers_tuple = tuple(sorted_numbers)
print(sorted_numbers_tuple)   # 输出：(1, 2, 5, 8)

元组的常见应用

元组在实际编程中有许多常见的应用场景。以下是一些常见的应用：

1. 多个变量的同时赋值：
   • 元组可以用于同时给多个变量赋值。可以将元组的元素分别赋值给多个变量，变量的数量应与元组中的元素数量相匹配。

以下是多个变量的同时赋值的代码示例：

person = ('John', 25, 'USA')
name, age, country = person

print(name)     # 输出：'John'
print(age)      # 输出：25
print(country)  # 输出：'USA'

2. 函数返回多个值：
   • 函数可以使用元组来一次性返回多个值。可以将多个值组成一个元组，然后将该元组作为函数的返回值。

以下是函数返回多个值的代码示例：

def get_name_and_age():
    name = 'John'
    age = 25
    return name, age

result = get_name_and_age()
name, age = result

print(name)  # 输出：'John'
print(age)   # 输出：25

3. 字典中的键：
   • 元组可以作为字典中的键。由于元组是不可变的，因此可以用作字典的键，例如在需要将多个值关联在一起的情况下。

以下是使用元组作为字典键的代码示例：

student_scores = {('John', 'Smith'): 90, ('Emily', 'Brown'): 85}

score = student_scores[('John', 'Smith')]
print(score)  # 输出：90

这些是元组在实际编程中的一些常见应用场景。元组的不可变性使其在需要保持数据不变性、进行多个变量的同时赋值、函数返回多个值等方面非常有用。

元组在某些情况下比列表更有用

元组具有以下优点，使其在某些情况下比列表更适用：

1. 数据不变性（Immutable）：
   • 元组是不可变的，一旦创建，其元素无法修改。这种特性使得元组在需要保持数据不变性的场景下非常有用。例如，在存储固定数据、作为字典的键或哈希映射时，元组比列表更合适。

以下是元组在保持数据不变性方面的代码示例：

student = ('John', 'Doe', 25)
# student[0] = 'Jane'  # 会引发 TypeError，元组的元素不可修改

person_dict = {student: 'A'}
print(person_dict[('John', 'Doe', 25)])  # 输出：'A'

2. 哈希映射（Hashable）：
   • 元组是可哈希的，也就是说，可以用作字典的键或集合的元素。因为元组是不可变的，它们的哈希值在创建时就确定了，可以作为字典的键来进行快速查找和索引。

以下是元组作为字典键的代码示例：

person1 = ('John', 'Smith')
person2 = ('Emily', 'Brown')

person_scores = {person1: 90, person2: 85}

score = person_scores[('John', 'Smith')]
print(score)  # 输出：90

与列表相比，元组的不可变性和哈希性质使其具有在某些情况下更适用的优点。它们在需要保持数据不变性、进行哈希映射或作为函数的返回值时提供了更合适的解决方案。