python中列表与元组的区别是什么,python列表集合元组三者区别

2022-08-27 14:48:46 分类：python 阅读()

　　python中列表与元组的区别是什么,python列表集合元组三者区别

　　本文给大家带来了一些关于python的知识，主要介绍了列表和元组的相关问题。您可以使用灵活的列表和元组来存储数据。先简单了解一下列表和元组的基本用法，希望对你有帮助。

　　推荐：python学习教程

　　00-1010在我们的实际开发中，经常需要存储一组数据以供使用。如果学习其他语言，可能会知道数组的数据结构，所以它可以存储多个数据，访问数据可以通过数组下标获得。如果你是python开发者，可以使用更灵活的列表和元组来存储数据。我们先简单了解一下列表和元组的基本用法。

　　00-1010列表是动态的，其长度可以改变，并且可以随意添加、修改或删除元素。

　　

前言

a=list()

　　b=[]

　　#您可以通过范围快速创建列表

　　c=列表(范围(1，6))

　　打印( a: ，a)

　　打印( b: ，b)

　　打印( c: ，c)

　　# a: []

　　# b: []

　　# C: [1，2，3，4，5]

列表

append:在列表末尾添加一个元素。

　　l=[]

　　l . append(“python”)

　　l

　　[python]extend:用iterable对象中的所有元素扩展列表。

　　l=[python]

　　t=[java]

　　l .扩展

　　l

　　[python ， java]insert:在给定位置插入一个元素。第一个参数是要插入的元素的索引，所以list_name.insert(0，x)被插入到列表的头部。

　　l=[python ， java]

　　l.insert(1， go )

　　l

　　[Python ， Go ， Java]

初始化列表

Remove (x):从列表中删除第一个值为x的项。如果没有要删除的值，将会引发异常。

　　l=[python ， java]

　　l.remove(java )

　　l

　　[python]

　　l .移除(“测试”)

　　回溯(最近呼叫):

　　模块中文件“输入”的第1行

　　Error:list.remove (x) 3360x不在listpop删除列表中给定位置的元素并返回。如果没有给出位置，pop()将删除并返回列表中的最后一个元素。

　　l=[python ， java ， go]

　　流行乐()

　　去吧

　　l

　　[python ， java]

　　流行乐(1)

　　 java

　　流行乐(1)

　　回溯(最近呼叫):

　　模块中文件“输入”的第1行

　　IndexError:弹出索引

　　of rangedel: Python 中的关键字，专门用来执行删除操作，它不仅可以删除整个列表，还可以删除列表中的某些元素

　　

>>l = ["python", "java", "go", "js"]
　　>>del l[0:1]
　　>>l
　　['java', 'go', 'js']
　　>>del l[0]
　　>>l
　　['go', 'js']
clear(): 移除列表中的所有元素。等价于 del a[:]

　　

>>l = ["python", "java", "go", "js"]
　　>>l.clear()
　　>>l
　　[]
ps： 这里注意和del 的区别， clear是清空， del list_name 是删除，内存也释放

　　

修改元素

修改单个可以通过下标的方法

　　

>>l = ["python", "go", "java"]
　　>>l[0] = "PYTHON"
　　>>l
　　['PYTHON', 'go', 'java']
修改一组数据可以通过切片的方式

　　

>>l = ["python", "go", "java"]
　　>>l[0:2] = "PYTHON", "GO"
　　>>l
　　['PYTHON', 'GO', 'java']
　　>>l[0:2] = ["python", "go"]
　　>>l
　　['python', 'go', 'java']

查询元素

index(x) ：方法用来查找某个元素在列表中出现的位置（也就是索引），如果该元素不存在，则会导致 ValueError 错误

　　

>>l
　　['python', 'go', 'java']
　　>>l.index("python")
　　0
　　>>l.index("python1")
　　Traceback (most recent call last):
　　 File "<input>", line 1, in <module>
　　ValueError: 'python1' is not in list
count() :用来统计某个元素在列表中出现的次数

　　

>>l
　　['python', 'go', 'java']
　　>>l.count("PYTHON")
　　0
　　>>l.count("python")
　　1

其他操作

sort：对列表中的元素进行排序

　　

>>l
　　['go', 'java', 'python']
　　>>l.sort(reverse=True)
　　>>l
　　['python', 'java', 'go']
　　>>l.sort()
　　>>l
　　['go', 'java', 'python']
reverse: 反转元素

　　

>>l = [1,2,3,4,5]
　　>>l.reverse()
　　>>l
　　[5, 4, 3, 2, 1]
copy: 返回列表的一个浅拷贝，等价于 a[:]

　　

>>l
　　[5, 4, 3, 2, 1]
　　>>a = l.copy()
　　>>a
　　[5, 4, 3, 2, 1]

python列表使用场景

1-使用列表实现栈

栈（stack)特点就是后进先出， 使用列表实现是非常容易的，要添加一个元素到堆栈的顶端，使用 append() 。要从堆栈顶部取出一个元素，使用 pop() ，不用指定索引。

　　

stack = []
　　stack.append(1)
　　stack.append(2)
　　stack.append(3)
　　stack.append(4)
　　stack.pop()
　　# 4
　　stack.pop()
　　# 3
　　stack.pop()
　　# 2
　　stack.pop()
　　# 1
　　# 注意捕捉错误

2-实现队列

from collections import deque
　　queue = deque(["python", "go", "java"])
　　queue.append("python")
　　queue.append("go")
　　print(queue)
　　queue.popleft()
　　queue.popleft()
　　print(queue)
返回结果

　　

deque(['python', 'go', 'java', 'python', 'go'])
　　deque(['java', 'python', 'go'])

列表推导式

a = [x ** 2 for x in range(10)]
　　b = [(x, y) for x in [1, 2, 3] for y in [3, 1, 4] if x != y]
　　# 嵌套列表推导式
　　matrix = [
　　 [1, 2, 3, 4],
　　 [5, 6, 7, 8],
　　 [9, 10, 11, 12],
　　]
　　c = [[row[i] for row in matrix] for i in range(4)]
　　print("a:", a)
　　print("b:", b)
　　print("c:", c)
返回

　　

a: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
　　b: [(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
　　c: [[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

元组

元组是静态，大小固定，不可以对元素进行增加，修改或删除的操作

　　

创建元组

a = 1, 2, 3
　　print("a", a)
　　b = (1, 2, 3)
　　print("b", b)
　　# 将字符串转换成元组
　　tup1 = tuple("hello")
　　print("将字符串转换成元组", tup1)
　　# 将列表转换成元组
　　list1 = ['Python', 'Java', 'C++', 'JavaScript']
　　tup2 = tuple(list1)
　　print("将列表转换成元组", tup2)
　　# 将字典转换成元组
　　dict1 = {'a': 100, 'b': 42, 'c': 9}
　　tup3 = tuple(dict1)
　　print("将字典转换成元组", tup3)
　　# 将区间转换成元组
　　range1 = range(1, 6)
　　tup4 = tuple(range1)
　　print("将区间转换成元组", tup4)
返回结果

　　

a (1, 2, 3)
　　b (1, 2, 3)
　　将字符串转换成元组 ('h', 'e', 'l', 'l', 'o')
　　将列表转换成元组 ('Python', 'Java', 'C++', 'JavaScript')
　　将字典转换成元组 ('a', 'b', 'c')
　　将区间转换成元组 (1, 2, 3, 4, 5)

访问元素

a = (1, 2, 3, 4, 5)
　　# 通过下标
　　print(a[0])
　　# 通过切片：a[start : end : step]
　　print(a[0:4:2])
返回结果

　　

1
　　(1, 3)

删除

a = (1, 2, 3, 4, 5)
　　del a

元组和列表区别

元组是静态，列表是动态

元组修改

　　

l = (1,2,3,4)
　　id(l)
　　# 4497372488
　　l = l + (5,6)
　　id(l)
　　# 4494985832
列表修改

　　

l = [1,2,3,4]
　　id(l)
　　# 4499169160
　　l = l + [5,6]
　　id(l)
　　# 4495787016
通过上面可以发现元组是不可以改变的，这里强调一点很多新手对这个 l = l + (5,6) 很不难理解，不是说元组不可以修改的吗，那为什么这里可以修改？记住这里虽然可以执行，但是他是创建了一个新的元组，这时候的 l 不是原来的 l, 可以通过 id 查询（或则执行 l[0] = -1 就会报错）

　　在这里我多说几句，这里的静态和动态，大白话来讲是列表是可以进行列表的操作（新增，删除，修改），一般操作行为下他的内存地址不变（通过id查看），这和他的实现有关，但是元组就会改变，所以新的元组和原来的不一样，一般时候有人（面试官或则开发不小心）会问你 a = ([1,2], 3,4), 为什么可以进行a[0].append(3)，但是id(a)前后不变，这就是0下标的元素是列表，列表可以修改的。

　　

列表需要更多内存，元组需要更少内存

list_t = []
　　print("列表初始化时候大小:", list_t.__sizeof__())
　　tuple_t = ()
　　print("元组初始化时候大小:", tuple_t.__sizeof__())
返回结果

　　

列表初始化时候大小: 40
　　元组初始化时候大小: 24
看到结果有没有发现列表比元组大18字节，那么问题来了：这18字节是怎么来的？这是由于列表是动态的，它需要存储指针来指向对应的元素（占用 8 个字节）。另外，由于列表中元素可变，所以需要额外存储已经分配的长度大小（占用 8 个字节），这样才能实时追踪列表空间的使用情况。但是对于元组，情况就不同了，元组长度大小固定，且存储元素不可变，所以存储空间也是固定的。

　　

列表不可被hash，元组可以被hash

tuple_t = (1, 2)
　　print("元组hash值:", hash(tuple_t))
　　list_t = [1, 2]
　　print("列表hash值:", hash(list_t))
执行结果

　　

Traceback (most recent call last):
　　 File "/Users/linjian/MonitorCenter/MonitorCenter/apps/t6.py", line 4, in <module>
　　 print("列表hash值:", hash(list_t))
　　TypeError: unhashable type: 'list'
　　元组hash值: 3713081631934410656
从上面的结果可以发现元组是可以被hash，但列表却是不可以。如果基础扎实的应该会反应过来，python中hash需要满足是不可变类型的数据结构(字符串str、元组tuple、对象集objects)

　　

执行效率

# 初始化一个相同元素的列表和元组使用情况
　　(djangoDemo) MonitorCenter % python -m timeit 'x=(1,2,3,4,5,6)'
　　100000000 loops, best of 3: 0.0103 usec per loop
　　(djangoDemo) MonitorCenter % python -m timeit 'x=[1,2,3,4,5,6]'
　　10000000 loops, best of 3: 0.0514 usec per loop
　　# 元组和列表索引操作对比
　　(djangoDemo) MonitorCenter % python -m timeit 'x=(1,2,3,4,5,6)' 'y=x[3]'
　　10000000 loops, best of 3: 0.0267 usec per loop
　　(djangoDemo) MonitorCenter % python -m timeit 'x=(1,2,3,4,5,6)' 'y=x[3]'
　　10000000 loops, best of 3: 0.0265 usec per loop
上面的运行结果显示： 元组初始化远快于列表 ，大概有五倍的差距，但是索引操作的时候速度没有多大差距

　　截止目前为止，我们可以简单总结列表和元组的区别有如下：

　　

  1. 元组使用tuple()或()初始化，列表使用list()或[]初始化
  2. 元组是静态，而列表是动态
  3. 列表需要更多内存，元组需要更少内存
  4. 列表不可被hash，元组可以被hash
  5. 元组初始化效率高于列表，但索引操作没有多大差距

元组和列表使用场景

再说使用场景前先讲一下，在python后台，对静态数据做一些资源缓存，通常因为垃圾回收机制的存在，一些变量不使用，python就会回收他们所占的内存，但是对于一些静态变量（比如说元组），当他们占用不大时候（长度1~20的元组），python会暂时缓存这部分内存，这样下次就可以不再向操作系统发出请求，分配内存资源，而是直接使用用缓存中之前的内存空间，这样大大加快了程序的运行速度。所以一般有时候数据量不大，我经常使用元组替代列表。到目前为止我们可以简单的总结出场景可以如下所示：

　　

  1. 如果数据不可变，我们就可以考虑使用元组，比如说性别类型，返回出去的城市信息等等
  2. 如果数据可变，我们就考虑使用列表，比如说用户当天访问的网页等等

拓展知识

创建空的列表，是使用list()效率好还是[]？

(djangoDemo) MonitorCenter % python -m timeit 'x=list()' 
　　10000000 loops, best of 3: 0.087 usec per loop
　　(djangoDemo) MonitorCenter % python -m timeit 'x=[]' 
　　100000000 loops, best of 3: 0.0177 usec per loop
通过上面的测试可以知道是[]快。list()函数调用，python中函数调用会创建stack并且会进行参数检查，[]是一个内置C函数，可以直接调用，因此效率更高。

　　

执行相乘操作时候，是 *= 效率好， 还是*？ 

(djangoDemo) MonitorCenter % python -m timeit 'x = [1,2,3]' 'x*=3'
　　10000000 loops, best of 3: 0.0903 usec per loop
　　(djangoDemo) MonitorCenter % python -m timeit 'x = [1,2,3]' 'x = x * 3'
　　10000000 loops, best of 3: 0.104 usec per loop
从结果可以看出是*效率会低点。*= 中会预分配，不足的时候扩容，但是* 会按照每次的量进行分配大小

　　

为什么输出是这样的？

list_1 = [1, 2, 3, 4]
　　list_2 = [1, 2, 3, 4]
　　list_3 = [1, 2, 3, 4]
　　list_4 = [1, 2, 3, 4]
　　for idx, item in enumerate(list_1):
　　 del item
　　for idx, item in enumerate(list_2):
　　 list_2.remove(item)
　　for idx, item in enumerate(list_3[:]):
　　 list_3.remove(item)
　　for idx, item in enumerate(list_4):
　　 list_4.pop(idx)
　　print("list_1", list_1)
　　print("list_2", list_2)
　　print("list_3", list_3)
　　print("list_4", list_4)
结果

　　

list_1 [1, 2, 3, 4]
　　list_2 [2, 4]
　　list_3 []
　　list_4 [2, 4]
list_2为什么输出是[2,4]? 因为在第一次删除后，list_2变成了 [2,3,4], 然后在删除轮循到到第二个数据也就是3（大部分都以为是2，但是2从原来的下表2变为1），可以参看下面的

　　

give next element: 0
　　0 ---> 1
　　1 2
　　2 3
　　3 4
　　give next element: 1
　　0 2
　　1 ---> 3
　　2 4
　　give next element: 2
　　0 2
　　1 4
list_3 为什么是[], 还记得之前我们说copy时候，copy等于[:]（浅拷贝），所以轮询的和删除的不是同一内存的数据。

　　list_4可以结合list_2思考，因为第一次删除，第二次删除是下标2，但是数据变了，下标2的数据不是原来的2，而是3

　　推荐学习：python教程以上就是python列表和元组详解（实例详解）的详细内容，更多请关注盛行IT软件开发工作室其它相关文章！

　　

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。

标签： python

相关文章阅读

  • python的列表排序方法,Python列表排序方法
  • python的列表排序方法,Python列表排序方法,Python 列表排序详解
  • python列表集合元组三者区别,python中数组和列表的区别
  • python中数组和列表的区别,python列表与元组的区别,python 元组和列表的区别
  • ,,python列表去重的5种常见方法实例
  • python列表排序sort按某个值排序,python列表排序方法sorted
  • python怎么算列表的平方,python列表平方和
  • 简述python中列表的基本操作及使用的函数,python列表命令
  • python对列表按照升序和降序的方式分别排列,python列表排序
  • python列表中set函数,python set 并集
  • Python列表逆序,Python range倒序
  • Python中sort排序,python列表排序sort按某个值排序
  • python 组合排列,python列表排序算法
  • 列表和元组都是python中常用的类型,python列表集合元组三者区别
  • Python列表转换为字符串,python中将列表转换成字符串
    • 留言与评论（共有 条评论）
       
    验证码：