如何在 Python 中创建元组以及为什么要使用它们?

元组是 Python 中的一种内置数据类型,用于存储数据集合。 它类似于列表,但速度稍快。

然而,它的局限性使得列表在某些情况下更受欢迎。 在本文中,我将解释开始使用元组所需了解的一切。

什么是元组?

如前所述,元组是 Python 中用于存储数据集合的内置数据类型之一。 它类似于 Python 列表,因为它以可迭代的、类似数组的格式存储数据。 然而,与列表不同的是,元组是不可变的。 也就是说,一旦创建,其值就无法更改。

无法添加其他元素,也无法删除现有元素。 因此,元组非常适合存储不会更改的数据。 它甚至可能是不同类型数据的集合。 在下一节中,我们将讨论在 Python 中创建元组的不同方法。

如何在 Python 中创建元组?

在 Python 中至少有三种创建元组的方法。 在本节中,我们将介绍您在阅读他人代码时可能会使用和看到的三种最常用方法。

要运行以下代码示例,您需要安装 Python。 如果您还没有安装 Python,这里有一份安装 Python 的有用指南。 或者,您可以在 Google Colab 等在线 Python 运行时中运行您的代码。

#1。 使用元组文字(括号)

查看 Python 中定义的元组的最常见方法是将一组值放在括号之间。 这些值以逗号分隔。 以下示例说明了此方法:

# Creates a tuple by placing values between parentheses
values = (1, 2, 3)

# Printing out the tuple to the screen
print(values)

# Printing out the type of values variable
print(type(values))

运行此代码将产生以下结果:

正如您从输出中看到的那样,元组包含我们初始化它的值。 它也是 类型。

在 Python 中创建元组时,不需要括号。 因此,此值 = 1、2、3 与此值 = (1、2、3) 一样有效。 但是,建议您使用括号以使您的代码更易于理解。

在 Python 中用一个元素创建元组有点棘手。 除了将一个元素放在括号之间之外,您还需要添加一个尾随逗号。 下面举个例子来说明:

# Without trailing comma, this won't create a tuple
not_a_tuple = (1)

# With trailing comma, this will create a tuple
a_tuple = (1,)

# Printing not_a_tuple
print(not_a_tuple)

# Printing not_a_tuple's data type
print(type(not_a_tuple))

# Printing a_tuple
print(a_tuple)

# Printing a_tuple's data type
print(type(a_tuple))

运行上面的代码,你会看到 not_a_tuple 变成了一个值为 1 的 int。创建元组时要记住这一点很重要。

#2。 使用构造函数

在 Python 中创建元组的第二种方法是使用元组构造函数。 在此方法中,您调用该函数,将一个可迭代对象(如列表)作为参数传递。 这将被转换为一个元组。 这是一个例子:

# Creating tuple from a list of values
values = tuple([1, 2, 3])

# Printing out the values
print(values)

# Printing out the data type of the values identifier
print(type(values))

如您所见,使用该函数可获得与使用文字相同的结果。 但是,该函数使您能够基于动态值创建元组,例如其值仅在运行时已知的列表。 使用第一种方法,您必须在编写代码时知道构成元组的值或标识符。

  8 个自托管的强大搜索 🔍 适合您产品的引擎软件

#3。 创建一个空元组

当您在代码中使用元组时,您可能需要创建空元组。 空元组是按照您的预期创建的。 创建它们时,您可以使用元组构造函数或文字。 这是一个演示如何使用任一方法的示例:

# Using the tuple literal
empty_tuple_1 = ()

# Using the constructor
empty_tuple_2 = tuple()

空元组在表示一组空结果时很有用。 考虑以下功能:

def create_range(start, end):
    return tuple(range(start, end))

此函数创建一个元组,其值从开始到您传入的结束值。如果您想迭代函数的结果,您可以使用如下内容:

my_values = create_range(0, 5)

for value in my_values:
    pass

如果您将 5 和 5 提供给 create_range 函数,结果将是一个空元组。 如果您尝试对其进行迭代,您将只有零次迭代,并且您的代码将照常进行。

另一方面,如果没有空元组,而你得到的是 None 值,那么尝试迭代它会抛出错误。 为了防止程序崩溃,您必须对 create_range 函数返回 None 或表示空元组的任何其他值的边缘情况进行测试。

这会导致混乱的代码。 理想情况下,您会希望尽可能避免特殊情况。 这意味着所有函数的返回值都应该有一个相同的接口,以便您的代码尽可能在一般情况下工作。 在这种情况下,这意味着始终返回一个元组,尽管有时它会是空的。

如何访问元素

在 Python 中有两种访问元组元素的方法。 第一种方法是通过索引,第二种方法是通过解构元素。 首先,我们将研究如何通过索引访问元素。

按索引访问元素

通过索引访问元素类似于通过索引访问列表元素的方式。 这是使用方括号表示法完成的。 元组使用从零开始的索引系统,这意味着第一个元素的索引为 0,之后的元素为索引 1,直到最后一个元素。

下面的示例演示了如何通过索引访问元素:

# Creating a tuple
values = (1, 2, 3, 4)

# Accessing the first element
first_element = values[0]

# Accessing the fourth element(index 3)
fourth_element = values[3]

您也可以使用负索引。 索引为 -1 的元素是最后一个元素,索引为 -2 的元素是倒数第二个元素。

# Creating the tuple
values = (1, 2, 3, 4)

# Accessing the last element
last_element = values[-1]

# Accessing the second from last element
second_from_last_element = values[-2] 

此外,您还可以通过切片访问元组中元素的子集合。 这类似于对列表进行切片的方式。 表示法如下 [<start>: <end>: <skip>]. 以下示例演示了切片:

# Creating the tuple
values = (1, 2, 3, 4, 5, 6, 7)

# Getting the first three elements
values[1: 3]

# Getting every other element
values[::2]

遍历元素

元组是 Python 中的可迭代对象。 因此,您可以使用 for 循环遍历其元素,如以下示例所示:

values = (1, 2, 3, 4)

for value in values:
    print(value)

当您想要访问元组中的所有元素时,这种访问元素的方法是理想的。

  您可以在 Xbox One 上获得 Warzone Aimbot 吗?

通过解构访问元素

为了解释解构,请考虑以下我们尝试获取元组中不同元素的场景。

# Creating the tuple to record a user's information
person_record = (1, 'John Doe', '[email protected]')

# Accessing the different elements in the tuple to use in our code
id = person_record[1]
name = person_record[2]
email = person_record[3]

Python 允许我们使用更方便的方法来访问值,如下所示:

# Creating the tuple to record a user's information
person_record = (1, 'John Doe', '[email protected]')

id, name, email = person_record

这称为解构。 也就是说,第一个变量,在本例中为 id,将被分配元组中的第一个值,第二个变量将分配给第二个元素。 这一直持续到元组的末尾。 上面的例子等同于:

id, name, email = (1, 'John Doe', '[email protected]')

在这种情况下,我们不是将元组存储在变量中,而是立即对其进行解构。 当您将这一点与创建元组时不需要使用括号的知识结合起来时,您就可以编写这样的代码。

id, name, email = 1, 'John Doe', '[email protected]'

最后,您将拥有值为 1 的 id、name 和 email 变量、’John Doe’ 和 ‘[email protected]‘. 这是在 Python 中创建变量的一种方便而简洁的方法,您将在生产代码中看到这种方法。 它有助于了解这种优雅语法的核心是元组的概念。

元组和列表之间的区别

虽然两者相似,但一些关键差异使每一个都更适合特定的用例。 了解这些差异将帮助您决定要使用的最佳数据类型并编写更好、更高效的代码。

AspectTupleListMemory Storage存储在连续的内存中存储在内存的不同部分MutabilityImmutable(不能改变)Mutable(可以改变)速度访问更快访问更慢数据类型通常存储不同类型的数据通常存储相同类型的数据用例通常用于存储相似值的集合,例如marks。通常用于存储类似标记等值的集合。

元组的优点

#1。 它更快

由于元组的值存储在连续内存中的方式,与列表相比,访问这些值的速度更快。 但是,因为一旦创建就无法更改,元组并不总是用于存储值集合的最佳数据结构。

他们理想的用例是在内存中存储大量数据,这些数据不会改变但会在程序执行期间被多次访问。 在这种情况下,您的程序将极大地受益于元组的性能提升。

#2。 返回多个值

您可以使用元组从函数返回多个值并解构结果。 例如:

from random import randint

def create_two_numbers():
    first_num = randint(0, 9)
    second_num = randint(0, 9)

    return first_num, second_num

first_num, second_num = create_two_numbers()

在这个例子中,我们有一个函数创建两个随机数并在一个元组中返回它们。 return first_num, second_num 语句相当于写return (first_num, second_num)。 这是因为在创建元组时括号是可选的。 为了访问结果,我们正在解构它。

#3。 值被写保护

元组一旦创建就不可变。 因此,它们非常适合将在程序执行期间不会更改的数据存储在内存中。 它们确保您不会意外覆盖代码中其他地方的数据。

#4。 存储多种数据类型

元组允许您存储多种数据类型的值。 这允许您创建数据记录,例如将用户的详细信息存储在元组中。 您还可以存储更复杂的项目,例如函数、字典、其他元组,甚至列表。

常见的元组方法

#1。 数数()

tuple 对象包含 count 方法,该方法计算元素出现的次数。 例如:

# Creating a tuple with several numbers
values = (1, 2, 3, 4, 5, 4, 4, 6)

# Counting the number of fours
n_fours = values.count(4)

# Prining out the number of fours
print(n_fours)

从这个例子中,我们可以看到数字 4 在我们的元组中恰好出现了三次。

#2。 指数()

index 方法可用于查找元组中某个值第一次出现的索引。 如果该值不存在,将抛出 ValueError 异常。 下面是一些代码来说明 index 方法是如何工作的:

# Creating a tuple with several numbers
values = (1, 2, 3, 4, 5, 4, 4, 6)

# Search for index of 4
index_of_four = values.index(4)
print("Index of four:", index_of_four)

# Search for index of 9
index_of_nine = values.index(9)
print("Index of nine:", index_of_nine)

当我们运行上面的代码时,这是输出:

  错误:重新定义 ap_hack_apr_allocator_create

在本例中,4 的索引为 3,代码运行没有问题。 但是当要找到索引 9 时,程序抛出了一个异常。 在编写使用 index 方法的 Python 程序时,处理此类异常很重要。

#3。 长度()

与 Python 中的所有可迭代对象一样,元组具有长度属性,您可以在将元组作为参数传递给 len() 函数时访问该属性。

# Creating a tuple
values = (1, 2, 3, 4)

# Getting the length
length = len(values)

# Print the output
print(length)

这是运行上面代码的结果。

#4。 最小值() 和最大值()

min 和 max 方法通过循环遍历可迭代对象中的每个元素并比较它是否大于或小于它之前的元素来工作。 最后,max 将返回 iterable 中最大的元素,而 min 返回最小的元素。

有了数字,操作就很明显了。 对于字符串,Python 将使用字母顺序。 如果字符串按字母顺序写入,则由 min 返回的最小单词是第一个单词。 而最大的词就是最后一个词。 如果可迭代包含不同数据类型的混合,那么操作都将失败,因为 Python 不知道如何比较不同的数据类型。

这是一个代码示例:

# Creating tuple with values
values = (1, 2, 3, 4, 5)

# Getting the largest value
largest = max(values)

# Getting the smallest value
smallest = min(values)

# Output the results
print(largest)
print(smallest)

#5。 排序()

Python 中的 sorted 函数接受一个可迭代对象并返回一个已排序元素的列表。 您可以调用 sorted 函数,传入一个元组作为参数,然后获取在列表中排序的元组元素。 要将排序列表转换为元组,可以使用构造函数。 这是一个例子:

# Creating a tuple with values in random order
values = (1, 5, 3, 3, 2, 4)

# Using sorted to sort the values into a list
sorted_list = sorted(values)

# Converting the list into a tuple
sorted_tuple = tuple(sorted_list)

# Printing the output
print(sorted_tuple)

#6。 添加和乘以元组

两个元组的加法运算只是将它们连接在一起。 乘法运算重复元组元素的次数与您乘以的值相同。 下面举个例子来说明这两个例子。

# Create a tuple with some values
values = (1, 2, 3, 4, 5)

# Create a new tuple using addition
added = values + values

# Create a new tuple using multiplication
multiplied = values * 2

print("values + values =", added)
print("values * 2 =", multiplied)

最后的话

在本文中,您了解到:

  • 元组是用于存储值集合的类似列表的对象。
  • 与列表不同,它们是不可变的。
  • 它们比列表更快、更有效。
  • 它们可以使用括号构造并用逗号分隔值。
  • 它们也可以使用元组构造函数来构造。
  • 您可以使用从零开始的索引系统访问单个值。
  • 您还可以解构元组中的值。
  • 您还可以使用 for 循环迭代值。
  • 可用于元组的不同方法。

接下来,您可能想查看更多 Python 内容,例如 Python List Methods 和 Python Dictionary Methods。