这篇文章主要讲解了“python列表和元组使用实例分析”,文中的讲解内容简单清晰,易于学习与理解,下面请大家跟着小编的思路慢慢深入,一起来研究和学习“python列表和元组使用实例分析”吧!
前言
在我们实际开发中,经常需要将一组数据存储起来,以便使用。如果学习了其他的语言可能知道数组(Array)这个数据结构,它就可以将多个数据进行存储,访问数据可以通过数组下标的方式,的进行获取。如果你是python开发者,那么可以使用更加灵活的列表(list)和元组(tuple),来进行数据储存。下面我们先简单了解下列表和元组的基本使用。
列表
列表是动态的,长度可以改变,可以随意增加,修改或删除元素。
初始化列表
a = list()b = []# 可以通过range快速创建listc = list(range(1,6))print("a:", a)print("b:", b)print("c:", c)# a: []# b: []# c: [1, 2, 3, 4, 5]
添加元素
append:在列表的末尾添加一个元素
>>l = []>>l.append("python")>>l['python']
extend:使用可迭代对象中的所有元素来扩展列表
>>l = ["python"]>>t = ["java"]>>l.extend(t)>>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.remove("test")Traceback (most recent call last): File "<input>", line 1, in <module>ValueError: list.remove(x): x not in list
pop: 删除列表中给定位置的元素并返回它。如果没有给定位置,pop()
将会删除并返回列表中的最后一个元素
>>l = ["python", "java", "go"]>>l.pop()'go'>>l['python', 'java']>>l.pop(1)'java'>>l.pop(1)Traceback (most recent call last): File "<input>", line 1, in <module>IndexError: pop index out of range
del: 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()# 4stack.pop()# 3stack.pop()# 2stack.pop()# 1# 注意捕捉错误
2-实现队列
from collections import dequequeue = 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, 3print("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)# 4497372488l = l + (5,6)id(l)# 4494985832
列表修改
l = [1,2,3,4]id(l)# 4499169160l = 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
上面的运行结果显示: 元组初始化远快于列表 ,大概有五倍的差距,但是索引操作的时候速度没有多大差距
截止目前为止,我们可以简单总结列表和元组的区别有如下:
元组使用tuple()或()初始化,列表使用list()或[]初始化
元组是静态,而列表是动态
列表需要更多内存,元组需要更少内存
列表不可被hash,元组可以被hash
元组初始化效率高于列表,但索引操作没有多大差距
元组和列表使用场景
再说使用场景前先讲一下,在python后台,对静态数据做一些资源缓存,通常因为垃圾回收机制的存在,一些变量不使用,python就会回收他们所占的内存,但是对于一些静态变量(比如说元组),当他们占用不大时候(长度1~20的元组),python会暂时缓存这部分内存,这样下次就可以不再向操作系统发出请求,分配内存资源,而是直接使用用缓存中之前的内存空间,这样大大加快了程序的运行速度。所以一般有时候数据量不大,我经常使用元组替代列表。到目前为止我们可以简单的总结出场景可以如下所示:
如果数据不可变,我们就可以考虑使用元组,比如说性别类型,返回出去的城市信息等等
如果数据可变,我们就考虑使用列表,比如说用户当天访问的网页等等
拓展知识
创建空的列表,是使用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 itemfor 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: 00 ---> 11 22 33 4give next element: 10 21 ---> 32 4give next element: 20 21 4
list_3 为什么是[], 还记得之前我们说copy时候,copy等于[:](浅拷贝),所以轮询的和删除的不是同一内存的数据。
list_4可以结合list_2思考,因为第一次删除,第二次删除是下标2,但是数据变了,下标2的数据不是原来的2,而是3
感谢各位的阅读,以上就是“python列表和元组使用实例分析”的内容了,经过本文的学习后,相信大家对python列表和元组使用实例分析这一问题有了更深刻的体会,具体使用情况还需要大家实践验证。这里是编程网,小编将为大家推送更多相关知识点的文章,欢迎关注!