其他分享
首页 > 其他分享> > python基础:什么是列表?什么是元组?列表与元组的区别

python基础:什么是列表?什么是元组?列表与元组的区别

作者:互联网

python作为最近几年最火的语言,已经成为几乎所有从业者首选的入门语言,但是直到今天,依然还有人分不清列表与元组的区别,以及它们使用上的技巧,今天icode9小编整理了一篇最完整的列表与元组的文章,大家一起来看看吧
 

什么是 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> 中

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

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

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

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

列表和元组的区别(表)

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

 

Python 列表

Python 元组

1个

列表是可变的

元组是不可变的

2个

迭代很耗时

迭代相对更快

3个

使用列表可以更轻松地插入和删除项目。

访问元素最好使用元组数据类型来完成。

4个

列表消耗更多内存

元组消耗小于列表

5个

列表有几个内置方法。

由于不变性,元组没有很多内置方法

6个

列表中更有可能发生意外更改或错误。

在元组中,由于不变性,更改和错误通常不会发生。

 

可变列表与不可变元组

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

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

创建一个新列表 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)))

加州理工学院 PGP 全栈开发探索计划
从基础到高级 - 全部学习!

最大限度()

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

打印(最大((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 认证并提升您的职业生涯!

标签:列表,元组,python
来源: