列表与常用操作
列表是一个序列, 用于顺序的存储数据。列表是有序的。
列表对象操作
新建列表
方式一: 使用list函数定义空列表
In [4]: lst = list()
方式二: 使用中括号定义空列表
In [5]: lst = []
方式三: 使用中括号定义带初始值的列表
In [6]: lst = [1, 2, 3]
方式四: 使用list函数把可迭代对象转换为列表
In [7]: lst = list(range(1, 10))
通常在定义列表的时候, 使用中括号, 在转换可迭代对象为列表时使用list函数
删除列表对象
需要使用del方法删除
截至2020年5月23日，本人暂时还未发现其他的方法
In [62]: lst
Out[62]: [3, 4, 5, 6, 7, 8, 9]
In [63]: del lst
In [64]: lst
---------------------------------------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-64-b5cada25ed2a> in <module>
----> 1 lst
NameError: name 'lst' is not defined
列表元素操作（增删查改）
访问列表元素
- 1、通过索引访问元素
- 2、index方法根据值返回第一个索引
- 3、count方法返回元素在列表里的个数
index和count的时间复杂度是O(n)的, 解释为: 线性复杂度, 效率与数据规模线性相关
通过索引(又称下标)访问
- 通过下表访问，从0开始
- 当下标超出范围时，会抛出IndexError
- 负数索引从右边开始, 索引从-1开始
In [13]: lst[0] # 通过下标访问,从0开始
Out[13]: 1
In [14]: lst[10] # 当下标超出范围时, 会抛出IndexError
---------------------------------------------------------------------------
IndexError Traceback (most recent call last)
<ipython-input-14-6ccb8eaab43e> in <module>()
----> 1 lst[10]
IndexError: list index out of range
In [15]: lst[-1] # 负数索引从右边开始, 索引从-1开始
Out[15]: 9
In [16]: lst[-11]
---------------------------------------------------------------------------
IndexError Traceback (most recent call last)
<ipython-input-16-07dd299f10ad> in <module>()
----> 1 lst[-11]
IndexError: list index out of range
L.index通过值查找索引
- 帮助手册：help(lst.index)
- 如存在多个值时，
index方法返回查找到的第一个索引 - L.index(value, [start, [stop]])：start参数指定从哪个索引开始查找，stop参数指定从哪个索引结束，但不包含该索引
- 当值不存在该范围的时候, 会抛出ValueError
- 凡是stop比start小, 总是抛出ValueError
In [20]: help(lst.index)
Help on built-in function index:
index(...) method of builtins.list instance
L.index(value, [start, [stop]]) -> integer -- return first index of value.
Raises ValueError if the value is not present.
In [17]: lst.index(4) # 通过值查找索引
Out[17]: 3
In [18]: lst = [1, 2, 3, 2, 4, 3, 5]
In [19]: lst.index(2) # index方法返回查找到的第一个索引
Out[19]: 1
In [21]: lst.index(2, 2) # start参数指定从哪个索引开始查找
Out[21]: 3
In [22]: lst.index(2, 2, 3) # end参数指定到哪个索引结束, 并且不包含该索引, 当值不存在该范围的时候, 会抛出ValueError
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-22-d805f3261138> in <module>()
----> 1 lst.index(2, 2, 3)
ValueError: 2 is not in list
In [23]: lst.index(2, 0, 3)
Out[23]: 1
In [24]: lst
Out[24]: [1, 2, 3, 2, 4, 3, 5]
In [25]: lst.index(2, -1, 0)
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-25-5c10c8921309> in <module>()
----> 1 lst.index(2, -1, 0)
ValueError: 2 is not in list
In [26]: lst.index(2, -4, -1) # start和stop可以为负数, 但是总是从左往右查找
Out[26]: 3 # 凡是stop比start小, 总是抛出ValueError
lst.index的实现
In [27]: def index(lst, value, start = 0, stop = -1):
...: i = start
...: for x in lst[start: stop]:
...: if x == value:
...: return i
...: i += 1
...: raise ValueError()
...:
L.count(value)统计值在列表中出现的个数
如果有值则返回正常的数量，如果没值就返回0
In [28]: help(lst.count)
Help on built-in function count:
count(...) method of builtins.list instance
L.count(value) -> integer -- return number of occurrences of value
In [29]: lst
Out[29]: [1, 2, 3, 2, 4, 3, 5]
In [30]: lst.count(2)
Out[30]: 2
In [31]: lst.count(3)
Out[31]: 2
In [32]: lst.count(5)
Out[32]: 1
In [33]: lst.count(8) # 查看不存在的值
Out[33]: 0
count方法返回值在列表里出现的次数
count方法的实现
In [34]: def count(lst, value):
...: c = 0
...: for x in lst:
...: if x == value:
...: c += 1
...: return c
...:
修改操作
修改元素有且只有下标操作这一种方法
下标操作修改
- 实例：lst[2] = 53
- 对超出范围的索引会抛出IndexError
In [34]: lst
Out[34]: [1, 2, 3, 2, 4, 3, 5]
In [35]: lst[2] = 53 # 修改列表的元素直接使用下标操作取出元素并对其赋值
In [36]: lst
Out[36]: [1, 2, 53, 2, 4, 3, 5]
修改元素有且只有这一种方法
In [37]: lst[10] = 53
---------------------------------------------------------------------------
IndexError Traceback (most recent call last)
<ipython-input-37-254c500b08c1> in <module>()
----> 1 lst[10] = 53
IndexError: list assignment index out of range
对超出范围的索引会抛出IndexError
增加操作
- L.append(object)增加
- L.insert(index, object)插入
- L.extend(iterable, /)批量添加
- list的连接操作
L.append(object)增加
原地追加、返回None
In [39]: help(lst.append)
Help on built-in function append:
append(...) method of builtins.list instance
L.append(object) -> None -- append object to end
In [40]: lst.append(9)
In [41]: lst
Out[41]: [1, 2, 53, 2, 4, 3, 5, 9]
L.insert(index, object)插入
- 原地修改list, 返回None
- insert当索引超出范围时:
- 索引是负数, 会在第0个元素前插入
- 索引是正数, 会在最后一个元素插入
append的时间复杂度是O(1), 常数时间 效率和数据的规模无关
insert的时间复杂度是O(n), 线性时间 效率和数据规模线性相关
In [42]: help(lst.insert)
Help on built-in function insert:
insert(...) method of builtins.list instance
L.insert(index, object) -- insert object before index
In [43]: lst.insert(1, 11)
In [44]: lst
Out[44]: [1, 11, 2, 53, 2, 4, 3, 5, 9]
In [47]: lst.insert(0, 'a')
In [48]: lst
Out[48]: ['a', 1, 11, 2, 53, 2, 4, 3, 5, 9]
In [50]: lst.insert(11, 'c') # 最后一个元素插入个c
In [51]: lst
Out[51]: ['a', 3, 1, 11, 2, 53, 2, 4, 3, 5, 9, 'c']
In [52]: lst.insert(100, 'd') # 超出索引位置插入, 是插入到最后一个元素
In [53]: lst
Out[53]: ['a', 3, 1, 11, 2, 53, 2, 4, 3, 5, 9, 'c', 'd']
In [54]: lst.insert(-100, 'e')
In [55]: lst
Out[55]: ['e', 'a', 3, 1, 11, 2, 53, 2, 4, 3, 5, 9, 'c', 'd']
L.extend(iterable, /)批量添加
- 原地修改, 返回None
- 与append的区别
- append操作单个元素
- 比如插入列表，会将该列表当作一个元素插入进去，不会如extend展开
- extend操作可迭代对象
- append操作单个元素
In [56]: lst
Out[56]: ['e', 'a', 3, 1, 11, 2, 53, 2, 4, 3, 5, 9, 'c', 'd']
In [57]: lst.extend([1, 2, 3])
In [58]: lst
Out[58]: ['e', 'a', 3, 1, 11, 2, 53, 2, 4, 3, 5, 9, 'c', 'd', 1, 2, 3]
In [59]: lst.extend(range(3))
In [60]: lst
Out[60]: ['e', 'a', 3, 1, 11, 2, 53, 2, 4, 3, 5, 9, 'c', 'd', 1, 2, 3, 0, 1, 2]
append操作单个元素
extend操作可迭代对象
append操作可迭代对象时, 整个元素都append进去
In [61]: lst.append(['a', 'b', 'c'])
In [62]: lst
Out[62]: ['e', 3, 0, 1, 2, ['a', 'b', 'c']]
list的连接操作
不修改list本身, 返回一个新list, 这叫list的连接操作
In [69]: lst = list(range(5))
In [70]: lst + ['a', 'b', 'c'] # 不修改list本身, 返回一个新list, 这叫list的连接操作
Out[70]: [0, 1, 2, 3, 4, 'a', 'b', 'c']
In [71]: lst # 并不修改list本身, 会生成一块新的内存
Out[71]: [0, 1, 2, 3, 4]
删除操作
- L.remove(value)根据值删除
- L.pop([index])根据索引删除并返回删除的数据
- L.clear()删除所有元素
- del方法根据索引删除
L.remove(value)根据值删除
- 原地修改, 返回None
- 当有多个值时从左至右删除第一个
- 当值不存在的时候, 会抛出ValueError
In [72]: help(lst.remove)
Help on built-in function remove:
remove(...) method of builtins.list instance
L.remove(value) -> None -- remove first occurrence of value.
Raises ValueError if the value is not present.
In [73]: lst = [1, 2, 3, 2, 4, 3, 5, 3, 4]
In [74]: lst
Out[74]: [1, 2, 3, 2, 4, 3, 5, 3, 4]
In [75]: lst.remove(1) # 原地修改, 返回None, 根据值删除元素
In [76]: lst
Out[76]: [2, 3, 2, 4, 3, 5, 3, 4]
In [77]: lst.remove(2) # 从左至右删除第一个
In [78]: lst
Out[78]: [3, 2, 4, 3, 5, 3, 4]
In [79]: lst.remove(10) # 当值不存在的时候, 会抛出ValueError
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-79-0db5c9e7363a> in <module>()
----> 1 lst.remove(10)
ValueError: list.remove(x): x not in list
L.pop([index])根据索引删除并返回删除的数据
- lst.pop()：返回并删除最后一个元素
- lst.pop(1)：返回并删除索引所在位置的元素
- 当索引不存在时, 抛出IndexError
- pop和remove的区别是pop根据索引删除元素, 并且会返回删除的元素
In [81]: help(lst.pop)
Help on built-in function pop:
pop(...) method of builtins.list instance
L.pop([index]) -> item -- remove and return item at index (default last).
Raises IndexError if list is empty or index is out of range.
In [80]: lst.pop() # 返回并删除最后一个元素
Out[80]: 4
In [82]: lst
Out[82]: [3, 2, 4, 3, 5, 3]
In [83]: lst.pop(1) # 返回并删除索引所在位置的元素
Out[83]: 2
In [84]: lst
Out[84]: [3, 4, 3, 5, 3]
In [85]: lst.pop(100) # 当索引不存在时, 抛出IndexError
---------------------------------------------------------------------------
IndexError Traceback (most recent call last)
<ipython-input-85-795b88347eea> in <module>()
----> 1 lst.pop(100)
IndexError: pop index out of range
pop不传递index参数, 时间复杂度是O(1)
pop传递index参数, 时间复杂度是O(n)
pop和remove的区别是pop根据索引删除元素, 并且会返回删除的元素
remove根据值删除元素, 返回None
L.clear()删除所有元素
In [86]: lst.clear() # 删除所有元素
In [87]: lst
Out[87]: []
del方法删除
- del方法是根据索引删除元素的
- 删除单个元素：del lst[0]
- 删除连续的多个元素：del lst[0:3]
In [57]: lst
Out[57]: ['1', 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
In [58]: del lst[0]
In [59]: lst
Out[59]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
In [60]: del lst[0:3]
In [61]: lst
Out[61]: [3, 4, 5, 6, 7, 8, 9]
其他操作
- 求list长度: len
- 反转列表reverse()方法
- 排序sort方法
- 浅copy与深copy
求list长度: len
In [88]: lst = list(range(4))
In [89]: lst
Out[89]: [0, 1, 2, 3]
In [90]: len(lst)
Out[90]: 4
反转列表reverse()方法
In [92]: lst.reverse() # 原地修改, 返回None, 反转列表
In [94]: lst
Out[94]: [3, 2, 1, 0]
排序sort方法
In [96]: help(lst.sort)
Help on built-in function sort:
sort(...) method of builtins.list instance
L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE*
In [95]: lst = [3, 1, 2, 4, 5, 7, 3, 2]
In [97]: lst.sort() # 原地修改, 返回None
In [98]: lst
Out[98]: [1, 2, 2, 3, 3, 4, 5, 7]
In [99]: lst.sort(reverse=True) # 逆序排列
In [100]: lst
Out[100]: [7, 5, 4, 3, 3, 2, 2, 1]
浅copy与影子拷贝以及深copy
In [101]: lst = list(range(3))
In [102]: lst
Out[102]: [0, 1, 2]
In [103]: lst2 = lst
In [104]: lst2[1] = 5 # lst2值修改了
In [105]: lst2
Out[105]: [0, 5, 2]
In [106]: lst # lst值改变了
Out[106]: [0, 5, 2]
复制操作是传递是引用, 也叫浅拷贝
copy方法
In [107]: help(lst.copy)
Help on built-in function copy:
copy(...) method of builtins.list instance
L.copy() -> list -- a shallow copy of L
In [108]: lst
Out[108]: [0, 5, 2]
In [109]: lst2 = lst.copy() # 影子拷贝
In [110]: lst2[1] = 2
In [111]: lst2
Out[111]: [0, 2, 2]
In [113]: lst
Out[113]: [0, 5, 2]
In [114]: lst = [1, [1, 2, 3], 2]
In [115]: lst2 = lst.copy()
In [116]: lst2[1][1] = 5
In [117]: lst2
Out[117]: [1, [1, 5, 3], 2]
In [118]: lst # lst依然改变了
Out[118]: [1, [1, 5, 3], 2]
赋值操作, 对可变对象是引用传递, 对不可变对象是值传递
深复制方法:
In [119]: import copy
In [120]: lst2 = copy.deepcopy(lst)
In [121]: lst2
Out[121]: [1, [1, 5, 3], 2]
In [122]: lst2[1][1] = 7
In [123]: lst2
Out[123]: [1, [1, 7, 3], 2]
In [124]: lst
Out[124]: [1, [1, 5, 3], 2]