2-2、3 列表的使用

列表list定义，初始化

• list() -> new empty list

• list(iterable) -> new list initialized from iterable 's items （iterable 可迭代对象）

• 列表不可以一开始就定义大小

• 例子：

  list1 = list()
  list2 = []
  list3 = [2,6,9,'ab']
  list4 = list(range(5))
  print(list1)#结果为：[]
  print(list2)#结果为：[]
  print(list3)#结果为：[2, 6, 9, 'ab']
  print(list4)#结果为：[0, 1, 2, 3, 4]
  

  list5 = [1,'ab',True, None, [4,5,'abc'],str]
  print(list5)#结果为：[1, 'ab', True, None, [4, 5, 'abc'], <class 'str'>]
  

列表索引访问

• 索引，也叫下标
• 正索引：从左至右，从0开始，为列表中每一个元素编号
• 负索引：从右至左，从-1开始
• 正负索引不可以越界，否则引发异常IndexError
• 为了理解方便，可以认为列表是从左至右排列的，左边是头部，右边是尾部，左边是下界，右边是上界
• 列表通过索引访问
  • list[index]，index就是索引，使用中括号访问

列表查询

• index(value,[start,[stop]])
  • 通过值value，从指定区间查找列表内的元素是否匹配
  • 匹配第一个就立即返回索引
  • 匹配不到，抛出异常ValueError
• count(value)
  • 返回列表中匹配value的次数
• 时间复杂度
  • index和count方法都是O(n)
  • 随着列表数据规模的增大，而效率下降
• 如何返回列表元素的个数？如何遍历？如何设计高效？
  • len()
    list的长度属性，列表对象直接记录，加元素+1，减元素-1

如何查帮助

官方帮助文档

搜索关键字

IPython中

• help(keyword)
• keyword可以是变量、对象、类名、函数名、方法名

列表元素修改

索引访问修改
- list[index] = value
- 索引不要越界

列表增加、插入元素

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

列表 *重复的坑

* -> list

• 重复操作，将被列表重复n次，返回新的列表
• 例子

  x = [[1,2,3]]*3
  print(x)#结果为：[[1, 2, 3], [1, 2, 3], [1, 2, 3]]
  x[0][1] = 20
  print(x)#结果为：[[1, 20, 3], [1, 20, 3], [1, 20, 3]]
  

  y = [1]*5
  y[0] = 6
  y[1] = 7
  print(y)#结果为：[6, 7, 1, 1, 1]
  

列表删除元素

remove(value) -> None

• 从左至右查找第一个匹配value的值，移除该元素，返回None
• 直接修改原来列表
• 效率差

pop([index]) -> item

• 不指定索引index，就从列表尾部弹出一个元素
• 指定索引index，就从索引处弹出一个元素，索引超界抛出IndexError错误
• 指定索引的时间复杂度为O(n**2)，不指定索引的时间复杂度为O(1)

clear() -> None

• 清除列表所有元素，剩下一个空列表
• 应用计数-1，效率高，相当于快速格式化

列表其他操作

reverse() -> None

• 将列表元素反转，返回None
• 直接修改原来列表

sort(key=None,reverse=False) -> None

• 对列表元素进行排序，直接修改原来列表，默认升序
• reverse为True的时候是升序（1，2，3），False的时候是降序（3，2，1）
• key一个函数，指定key如何排序
  • list.sort(key=function)

in

• [3,4] in [1,2,[3,4]]
• for x in [1,2,3,4]

列表复制

例子

list0 = list(range(4))
list1 = list(range(4))
print(list0 == list1)#结果为：True
list2 = list0
list2[2] = 10 
print(list0)#结果为：[0, 1, 10, 3]

copy() -> list

• shadow copy返回一个新的列表
• 例子
  • 例子一：

    list0 = list(range(4))
    list1 = list0.copy()
    print(list1 == list0)# 结果为：True
    list1[2] = 10
    print(list1 == list0)#结果为：False
    

  • 例子二：

    list0 = [1,[2,3,4],5]
    list1 = list0.copy()
    print(list1 == list0)#结果为：True
    list1[2] = 30
    print(list1 == list0)#结果为：False
    print(list1)#结果为：[1, [2, 3, 4], 30]
    print(list0)#结果为：[1, [2, 3, 4], 5]
    list1[2] = 5
    list1[1][1] = 40
    print(list1 == list0)#结果为：True
    print(list1)#结果为：[1, [2, 40, 4], 5]
    print(list0)#结果为：[1, [2, 40, 4], 5]
    

  • 对比例子一和例子二

shadow copy

• 影子拷贝，也叫浅拷贝，遇到引用类型，只是复制了一个引用而已，类似指针
  

深拷贝

• copy模块提供了deepcopy
• 例子

  import copy# 调用copy模块
  list0 = [1,[2,3,4],5]
  list5 = list0
  list6 = copy.deepcopy(list0)
  print(list0)#结果为：[1, [2, 3, 4], 5]
  print(list5)#结果为：[1, [2, 3, 4], 5]
  print(list6)#结果为：[1, [2, 3, 4], 5]
  list5[1][1] = 60
  print(list0)#结果为：[1, [2, 60, 4], 5]
  print(list5)#结果为：[1, [2, 60, 4], 5]
  print(list6)#结果为：[1, [2, 3, 4], 5]
  print(list5 == list0)#结果为：True
  print(list6 == list0)#结果为：False