列表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]
  

Python中的list列表

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