python内置数据类型之列表

发表于 | 更新于 | 分类于 | 评论数： | 阅读次数：
|

1.什么是列表？

  1. 列表是有序的，线性数据结构；
  2. 列表可以使用索引；
  3. 列表的元素可以为任意对象（数字，字符串，对象，列表等）；
  4. 列表是可变化的；
  5. 使用[]表示；
  6. 列表的元素可以重复。

2.列表的定义

  1. list()方法,得到空列表
  2. []中括号，得到空列表
  3. [元素1，元素2，元素3，…]，带初始值得到的列表
  4. list(range()) 得到有值的列表

说明：通常在定义空列表时候使用[]，定义含有初始值的列表用list()方法。

3.列表的相关操作

1 .列表的访问

lst[#] 通过下标访问，从0开始。 
ps：如果#超过下标的范围时候会出现IndexError的错误。 
如果#为负号，则索引从右边开始，#无论为正负均有范围，超过范围会报错。 
1
2
3
4
5
6
7
lst = list(range(0,9)) #生产列表
l1 = lst[3] #通过正索引访问元素
l2 = lst[-1] #通过负索引访问元素
print(l1)
print(l2)
#说明，如果正负索引超界，则会报错。
#错误代码：IndexError: list index out of range
3
8

2 .列表元素查找

查找元素：L.index( value,[start[stop]]）方法：返回查找到的第一个value值的索引。

start表示从第几个索引开始，stop表示到哪个索引结束，均可省略。
b.但是如果出现stop，其前必须有start值，索引时包含start位置不包含stop位置。
c.如果匹配不到元素，则返回：ValueError: xx is not in list
d.index查找元素的时间复杂的为O(n)

1
2
lst = list(range(11,19)) 
print(lst)
[11, 12, 13, 14, 15, 16, 17, 18]
1
lst.index(13) #13的索引值为2
2

统计元素：L.count(value) 统计列表中出现多少个value值。
len(L)，求list列表的长度。

count方法的时间复杂的为O(n)

3 .列表元素操作

a.修改元素

直接赋值，L[#]=value。

#为列表的索引值
索引不能越界，会报错IndexError: list assignment index out of range
修改列表自身

1
2
3
4
lst = list(range(1,10)) 
lst[2]=111  
lst[4]=123
lst
[1, 2, 111, 4, 123, 6, 7, 8, 9]
b.增加元素

L.append(#)，修改L本身，并且追加在列表末尾。
L.extend([#1,#2,#3]) , 将可迭代对象扩展到列表末尾。
L+[‘a’,’b’,’c’] ，不修改列表本身，返回一个新的列表。

c.插入元素

L.insert(idx,#)，将在该idx前插入#，会修改L本身。

当idx为正数，且大于列表本身的索引数，
会实现append方法将插入在元素最末尾；当idx为负数，且小于-len(L)+1时将会插入到列表最前。
append的时间复杂度是O(1),效率和数据的规模无关。
insert的时间复杂度是O(n)，效率个数据规模正相关。

d.移除元素

L.remove(value)，修改自身，从左到右删除第一个匹配到的值。
L.pop(idx)，返回并删除索引指向的值。如果不指定idx，将删除列表最后的元素。

pop不指定值时，时间复杂度是O(1)的；
pop指定idx时，时间复杂度是O(n)的。

L.clear()，删除索引元素。慎用，会引起垃圾回收。

e.列表反转

reverse()，修改自身，反转列表元素。

f.列表排序

L.sort(),排序操作，修改自身，升序排列。 L.sort(reverse=True)，逆序排列。

4 .列表进阶

1. 列表复制

copy()方法，列表浅拷贝。遇到引用类型，仅仅复制引用地址。当原来引用类型的值发生变化时，拷贝后的列表的值也随之发生变化。

1
2
3
4
5
6
7
8
9
10
11
12
lst = list(range(4))
lst1 = lst.copy()
print(lst1)

#浅拷贝特性说明
lst = [1,[2,3,4],5]
lst1 = lst.copy()
lst1[1][2] = 11
lst[1][0]=22
print(lst)
print(lst1)
#lst = lst1,引用内的值改变，列表均发生变化。
[0, 1, 2, 3]
[1, [22, 3, 11], 5]
[1, [22, 3, 11], 5]

copy模块下的deepcopy() 提供了深拷贝方法。

1
2
3
4
5
6
7
import copy
lst = [1,[2,3,4],5]
lst1 = copy.deepcopy(lst)
lst1[1][2] = 11
print(lst)
print(lst1)
#lst != lst1  对比lst.copy方法。
[1, [2, 3, 4], 5]
[1, [2, 3, 11], 5]

2. 打乱列表

需要引入random模块

1
2
3
4
# random.shuffle(list)
lst = [1,323,4,-3,[1,3],None,(1,34),{1:3}]
random.shuffle(lst)  #修改自身，返回值为None，不能使用其他空间接受。
lst  #通过shuffle打乱后列表的顺序发生变化。
[323, {1: 3}, None, [1, 3], 1, -3, 4, (1, 34)]

random模块的其他对象：

1
2
3
import random
print(random.randint(1,11))  #返回[1,11] 之间的整数，注意左右闭区间
print(random.choice(range(11))) #从非空序列中随机挑选一个整数
11
0
1
2
3
import random
#randrange ([start,] stop [,step])  从指定的范围内，按指定基数递增的集合中获取一个随机数
random.randrange(1,7,2) #从[1,7)中，步长为2的数字中获取一个数
3

5. 总结

增删查改

增 append、extend ==> None
insert(index,value) ==> None，
+和*（重复） ==> new_list

删 remove(value)，无value，报错
clear() ==> None，会引起垃圾回收
pop[index] ==> value 弹出一个元素，从尾部，超界报错

查 list[index] ==> value，索引超界，报错
index（value） ==> index ，如果查找不到，报错

改 list[index] = new_value ==> None，索引超界，报错

其他操作：
反转
reversed()==> None

排序
sort(key=None,reverse=False) ==> None

统计长度
len(lst)

复制:
浅拷贝
copy

说明：

  1. copy 和 = 都可以获得一样的列表，这两种列表的区别是什么？

copy是浅拷贝一份新的数据，
= 只是修改引用计数。

  1. == 和 is的区别是什么？

== 需要值相等就返回true，
is 需要是同一个引用计数。

---------------- 谢谢光临 ----------------
0%