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