Python中的list列表

时间:2021-07-14
本文章向大家介绍Python中的list列表,主要包括Python中的list列表使用实例、应用技巧、基本知识点总结和需要注意事项,具有一定的参考价值,需要的朋友可以参考一下。

列表list

  • 一个队列,一个排列整齐的队伍
  • 列表内的个体称作元素,由若干元素组成列表
  • 元素可以是任意对象
  • 列表内元素有顺序,可以索引
  • 线性数据结构
  • 使用[]表示
  • 列表是可变的

列表list定义

  • list()
  • list(iterable)
  • 列表不可一开始定义大小
lst = list()
lst = list(range(5))
lst = [1,3,5]

列表访问

  • 索引,可使用索引访问
  • 支持正索引和负索引

列表查询

  • Index(value, [start. [stop]])
    • 通过值,从指定区间查找元组内的元素是否匹配
    • 匹配第一个返回索引
    • 匹配不到,抛出异常ValueError
  • count(value)
    • 返回列表中匹配value的次数
  • 时间复杂度
    • index和count方法都是O(n)
    • 随着列表数据规模增大, 效率降低
  • len(tuple)
    • 返回元素的个数

列表修改

  • 索引访问修改
    • list[index] = value
    • 索引不能超界

列表增加,插入

  • append(object) —> None
    • 列表尾部追加元素,返回None
    • 返回None意味着在列表原处修改
    • 时间复杂度是O(1)
  • insert(index, object) —> None
    • 在指定的索引index出插入元素object
    • 原处修改
    • 时间复杂度是O(n)
    • 索引超越上界,尾部追加
    • 索引超越下界,头部追加
  • extend(iteratable) —>None
    • 将可迭代对象的元素追加进来
    • 原处修改
  • + —> list
    • 连接操作,将两个列表连接起来
    • 产生新的列表,原列表不变
    • 本质上调用的是_add_()方法
  • * —> list
    • 重复操作,将本列表元素重复n次,返回新列表

删除元素

  • remove(value) —>None
    • 从左至右查找第一个匹配value的值
    • 就地修改
    • 效率较差
  • pop([inex]) —>None
    • 不指定索引index,就从尾部弹出一个元素
    • 指定索引index,就从索引出弹出一个元素
    • 不指定索引效率为O(1),指定索引为列表最开始的位置,则效率很低
  • clear() —>None
    • 清楚列表所有元素,剩下一个空列表

列表反转

  • reversed() —>None
    • 将列表元素反转,返回None
    • 就地修改
    • 所有元素替换位置

列表排序

  • sort(key=None, reverse=False). —>None
    • 对列表元素进行排序,就地修改,默认升序
    • reverse为True,则为降序
    • key是一个函数,指定key如何排序
      • Let.sort(key=functionname)

列表判断

  • in

    • 判断对象是否在列表中
    [3, 4] in [1, 2, [3, 4]]
    

列表复制

python中==和is的区别

  • ==是拿值来比较
  • is是拿id来比较
例:list1=list(range(5))
		list2=list(range(5))
		list1 == list2  返回 True
		list1 is list2   返回False
  • copy() —>List

    • shodow copy(浅拷贝)返回一个新的列表
    In [3]: lst0 = [1,2,[3,4,5],6]
    # copy为浅拷贝,即按照lst0的内容生成lst5
    In [4]: lst5 = list.copy(lst0)
    # 此时lst0和lst5的值一样,所以==判断为True
    In [5]: lst0 == lst5
    Out[5]: True
    # 但是id不同,故is判断为False
    In [6]: lst0 is lst5
    Out[6]: False
    # 修改lst0[3]的值,观察变化
    In [7]: lst0[3] = 20
    # 此时lst0和lst5的值不一样,所以==判断为False
    In [8]: lst0 == lst5
    Out[8]: False
    # 可观察lst0和lst5的值
    In [9]: lst0
    Out[9]: [1, 2, [3, 4, 5], 20]
    
    In [10]: lst5
    Out[10]: [1, 2, [3, 4, 5], 6]
    # 将lst的值恢复
    In [13]: lst0[3] = 6
    
    In [14]: lst0 == lst5
    Out[14]: True
    # 修改lst0中嵌套的列表的值,观察变化
    In [15]: lst0[2][2]= 20
    # 虽然只修改了lst0,但lst0和lst5的值依旧相同,原因就在于copy为浅复制,对于嵌套的其他对象,只是做了对象的引用而已
    In [16]: lst0 == lst5
    Out[16]: True
    
    In [17]: lst0
    Out[17]: [1, 2, [3, 4, 20], 6]
    
    In [18]: lst5
    Out[18]: [1, 2, [3, 4, 20], 6]
    
  • deepcopy(old) —>List

    • 深拷贝,无论有多少嵌套,得到的列表都和原来的无关。
    • 使用时,要导入copy
    In [21]: import copy
    
    In [22]: lst8 = [1, 2, [3, 4, 20], 6]
    
    In [23]: newlist = copy.deepcopy(lst8)
    
    In [24]: lst8 == newlist
    Out[24]: True
    
    In [25]: lst8 is newlist
    Out[25]: False
    # 无论有多少层,都不会影响旧列表
    In [26]: newlist[2][2] = 80
    
    In [27]: lst8 == newlist
    Out[27]: False
    
    In [28]: lst8
    Out[28]: [1, 2, [3, 4, 20], 6]
    
    In [29]: newlst
    
    In [30]: newlist
    Out[30]: [1, 2, [3, 4, 80], 6]
    

原文地址:https://www.cnblogs.com/larry-yu/p/15009840.html