列表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（浅拷贝）返回一个新的列表 ```python 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
```python
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]