什么是 Python 中的列表？

列表是 Python 中最灵活、最强大的容器之一。它类似于Java 等其他语言中的数组。

该榜单具有以下特点—— 

• 您可以使用 Python 列表同时存储多种类型的数据。
• 列表有助于保存数据序列并以其他方式进一步处理这些序列。 
• 列表是动态的。
• 列表是可变的。
• 列表是有序的。
• 索引用于遍历列表。

列表有助于存储多个项目，然后使用循环遍历它们。因为列表是动态的，所以您可以随时轻松地添加或删除项目。

什么是 Python 中的元组？

元组也是一种包含不同数据类型元素的序列数据类型。

它在存储项目集合时会派上用场，尤其是当您希望这些项目保持不变时。 

python 元组具有以下特征 - 

• 元组用于存储异构和同构数据。
• 元组本质上是不可变的。
• 元组是有序的
• 索引用于遍历元组。
• 元组类似于列表。它还保留了数据序列。

由于元组是不可变的，因此它们比列表更快，因为它们是静态的。

列表语法

列表以 [ ] 符号开头。 

这是在 python 中声明列表的示例。

num_list = [1,2,3,4,5]

打印（num_list）

alphabets_list = ['a','b','c','d','e']

打印（alphabets_list）

列表可以包含不同数据类型的数据。您可以按如下方式启动它 - 

mixed_list = ['a', 1,'b',2,'c',3,'4']

打印（混合列表）

您也可以创建嵌套列表。嵌套列表是列表中的列表。

nested_list = [1,2,3,[4,5,6],7,8]

打印（嵌套列表）

元组语法

元组以 () 符号开头。 

这是在 python 中声明元组的示例。

num_tuple = (1,2,3,4,5)

打印（num_tuple）

alphabets_tuple = ('a','b','c','d','e')

打印（alphabets_tuple）

列表可以包含不同数据类型的数据。您可以按如下方式启动它 - 

混合元组 = ('a', 1,'b,' 2,'c,' 3, '4')。

打印（混合元组）

您也可以创建嵌套列表。嵌套列表是列表中的列表。

nested_tuple = (1,2,3,(4,5,6),7,8)

打印（嵌套元组）

语法差异

列表和元组充当存储对象的容器。但是它的用例和语法也有所不同。

列表被方括号 [ ] 包围，而元组被圆括号 ( ) 包围。

在 python 中创建列表和元组。

list_numbers = [1,2,3,4,5]

tuple_numbers = (1,2,3,4,5)

打印（列表编号）

打印（tuple_numbers）

我们可以使用 type 函数来检查任何对象的数据类型。

类型（list_numbers）

类型（tuple_numbers）

Python 中列表和元组的区别（深入解释）

元组和列表之间的主要区别是元组是不可变的，而列表是可变的。因此，可以更改列表而不是元组。

由于元组的不变性，元组的内容一旦在 Python 中创建就不能更改。

没有办法不断改变元组。如果您尝试更改其中一项，则会出现错误消息：

名字=（“拉吉”，“约翰”，“贾比”，“拉贾”）

名字[2] = “凯莉”

追溯（最近一次通话）：

文件“<stdin>”，第 4 行，在 <module> 中

类型错误：“元组”对象不支持项目分配

如果您熟悉列表和地图，就会知道它们是可以修改的。您可以添加或删除项目或将它们重新分配给不同的变量。但是元组？好吧，你不能那样做。 

原因很简单：元组是不可变的，这意味着它们创建后就无法更改其内容。元组的长度也是固定的。它们在程序的整个生命周期中保持相同的长度。

那么我们为什么要使用像元组这样的不可变数据结构呢？嗯，原因之一是与列表和映射等可变数据结构相比，它们的开销很小。 

列表和元组的区别（表）

以下是列表和元组之间的区别 - 

可变列表与不可变元组

我们已经听说元组是不可变的，而列表是可变的。它只是意味着您可以更改列表中的现有值。但是如果它存储在元组中，则不能更改相同的值。

让我们举个例子来理解元组的不变性

创建一个新列表 list_num 并用 5 个值对其进行初始化。

list_num=[1,2,3,4,5]

让我们用 5 代替 3。

列表编号[2] = 5

打印（列表编号）

[1,2,5,4,5]

在元组中进行类似的操作。

创建一个新的元组 tuple_num 并用五个值对其进行初始化。

tuple_num=(1,2,3,4,5)

让我们用 5 代替 3。

tup_num[2] = 7

它会出现以下错误 - 

[1,2,7,4,5]

追溯（最近一次通话）： 

 在 <module> 中文件“python”，第 3 行 

类型错误：“元组”对象不支持项目分配。

该错误清楚地表明元组中不支持项目分配。因此它是不可变的。

可用操作

由于列表是可变的，它有许多内置操作，您可以使用它们来获得不同的结果。让我们来看看这样的列表操作。

附加（）

它用于向列表中添加元素。元素被添加到列表的末尾。您一次只能添加一个元素。使用循环可以让您一次添加多个元素。

numList = [1,2,3]

numList.append(4)

numList.append(5)

numList.append(6)

使用循环插入

对于我在范围 (7, 9) 中：

    numList.append(i)

打印（numList）

延长（）

扩展操作用于像追加操作一样在列表的末尾添加元素。但是 extend() 允许您一次添加多个元素。

numList = [1,2,3]

numList.extend([4, 5, 6]) 

打印（numList）

插入（）

它允许您在列表中的给定位置添加新元素。与 append 不同，它不会在末尾添加元素。它有两个参数，第一个参数是位置，第二个参数是元素。您可以一次插入一个元素。因此，要插入多个元素，您可以使用循环。

numList = [1,2,3]

numList.insert(3, 4)

numList.insert(4, 5)

numList.insert(5, 6)

打印（numList）

消除（）

它用于从列表中删除一个元素。如果有多个元素，则只删除第一次出现的元素。

stringList = ['List', '让学习变得有趣！', '对我们来说！']

stringList.remove('让学习变得有趣！')

打印（字符串列表）

流行音乐（）

它用于从列表中的任何位置删除元素。Pop() 接受一个参数，即元素的位置。

numList = [1,2,3,4,5]

numList.pop(4)

打印（numList）

片。

它用于打印列表的一个子集。您必须指定切片操作的起始位置和结束位置。 

numList = [1,2,3,4,5,6,7,8,9]

print(numList[:9]) # 从头到尾打印索引

print(numList[2:]) # 从起始索引打印到列表末尾

print(numList[2:9]) # 从开始索引到结束索引打印

print(numList[:]) # 从头到尾打印列表

撤销（）

反转操作反转原始列表。如果想在不影响原列表的情况下进行倒转，应该使用带负索引的slice函数。

numList = [1,2,3,4,5,6,7,8,9]

print(numList[::-1]) # 不修改原列表

numList.reverse() # 修改原始列表

打印（numList）

长度（）

它返回列表的长度

numList = [1,2,3,4,5,6,7,8,9]

打印（len（numList））

分钟()

它返回列表中的最小值。仅当列表是同质的时，您才能成功使用最小操作。 

打印（分钟（[1, 2, 3]））

最大限度（）

它返回列表中的最大值。仅当列表是同质的时，您才能成功使用最小操作。 

打印（最大（[1, 2, 3]））

数数（）

计数操作返回列表中指定元素的计数。它以元素作为参数。

numList = [1,2,2,4,4,6,8,8,9]

打印（numList.count（3））

连接（）

它用于将两个列表合并为一个新列表。+ 号用于组合两个列表。

numList = [4,5]

stringList = ['Python', '很有趣！']

打印（数字列表+字符串列表）

乘（）

Python 还允许将列表乘以 n 次。结果列表是迭代 n 次的原始列表。

numList = [1,2,3,4,5,6,7,8,9]

打印（numList * 2）

指数（）

它用于根据索引位置查找元素。你需要给它传递两个参数，第一个是起始位置，第二个是结束位置。提供时，仅在由 begin 和 end 索引绑定的子列表中搜索元素。如果未提供，则在整个列表中搜索该元素。

print(stringList.index('HelloWorld')) # 在整个列表中搜索

print(stringList.index('HelloWorld', 0, 2)) # 从第 0 到第 2 个位置搜索

种类（）

它用于按升序对列表进行排序。您只能对同类列表执行此操作。在异构列表上使用 sort() 将引发错误。

numList = [4, 2, 6, 5, 0, 1]

numList.sort()

打印（numList）

清除（）

它清除列表中的所有元素并将其清空。

numList = [1,2,3,4,5,6,7,8,9]

numList.clear()

打印（numList）

不变性减少了元组具有的内置函数的数量。让我们来看看这样的元组操作。

分钟()

它返回元组中的最小值。仅当元组是同质的时，您才能成功使用最小操作。 

打印（最小值（（1、2、3）））

最大限度（）

它返回元组中的最大值。仅当元组是同质的时，您才能成功使用最小操作。 

打印（最大（（1、2、3）））

片。

它用于打印元组的一个子集。您必须指定切片操作的起始位置和结束位置。 

myTuple = [1,2,3,4,5,6,7,8,9]

print(myTuple[:9]) # 从头到尾打印索引

print(myTuple[2:]) # 从开始索引打印到元组结束

print(myTuple[2:9]) # 从开始索引到结束索引打印

print(myTuple[:]) # 从头到尾打印元组

长度（）

它返回元组的长度

myTuple = [1,2,3,4,5,6,7,8,9]

打印（len（myTuple））

删除()

元组是不可变的，但我们可以使用 del 操作删除元组元素。

元组 1 = (1, 3, 4, '测试', '红色')

删除（元组 1[1]）

元组中的成员资格

如果要检查某个元素是否属于元组，可以使用关键字来检查其成员资格。

元组 1 = (1, 3, 4, '测试', '红色')

打印（元组 1 中的 1）

打印（元组 1 中的 5）

尺寸比较

两种数据结构的长度不同。元组的长度是固定的，而列表的长度是可变的。因此，列表可以有不同的大小，但元组不能。

因为元组是不可变的，所以元组被分配了比列表开销更低的大块内存；而对于列表，分配的是小内存块。因此，当有大量元素时，元组往往比列表更快。

a= (1,2,3,4,5,6,7,8,9,0)

b= [1,2,3,4,5,6,7,8,9,0]

打印（'a='，a.__sizeof__（））

打印（'b='，b.__sizeof__（））

一=104

b=120

不同的用例

Python 的列表最适合在以下情况下存储数据： 

1. 可以将多种类型的数据存储在列表中，并且可以使用它们的索引来访问它们。
2. 列表非常适合对一组元素进行数学运算，因为 Python 允许您直接对列表执行这些操作。 
3. 如果您事先不知道有多少元素将存储在您的列表中，很容易根据需要增加或减少它的大小。

Python 的元组最适合存储以下情况的数据： 

1. 当您知道将进入对象字段的确切信息时，最好使用元组。 
2. 例如，如果您想存储网站的凭据，可以使用元组。 
3. 元组是不可变的（不可更改的），因此它们只能用作字典的键。但是如果你想使用一个列表作为键，首先把它变成一个元组。

例子

元组作为字典

由于元组是可散列的，因此您可以将它们用作字典的键。

元组键 = {}

tuplekey[('蓝色', '天空')] = '好'

tuplekey[('red','blood')] = '坏'

打印（元组键）

元组打包和解包

打包和解包提高了代码的可读性。 

打包意味着为元组分配多个值。

拆包意味着为单个变量赋值。

元组打包

person = ("Rohan", '6 ft', "员工")

打印（人）

元组拆包

person = ("Rohan", '6 ft', "员工")

(姓名、身高、职业) = 人

打印（名称）

打印（高度）

打印（专业）

什么时候使用元组而不是列表？

元组是不可变的。因此，它们主要用于存储不经常更改的数据。当您不想更改数据时，任何操作都可以将数据存储在元组中。

如果您希望集合中的数据是只读的、永不更改并且始终保持不变，则元组非常适合使用。

由于这种能力和数据永不更改的保证，您可以在字典和集合中使用元组，这要求其中的元素是不可变类型。

当您需要存储不随时间变化的值（例如一个人的生日或身高）时，它很有用。

通过Python 培训课程学习 Python 中的数据操作、字符串、条件语句、错误处理以及常用的 Python Web 框架 Django  。

结论

既然您已经深入了解 Python 中的列表和元组，请通过 Simplilearn 的Python 认证课程深入了解更多Python 概念。本课程涵盖 Python、数据操作、条件语句、shell 脚本和Django 的基础知识。立即获得 Python 认证并提升您的职业生涯！