python列表操作函数_python之列表操作的几个函数

Python中的列表是可变的，这是它却别于元组和字符串最重要的特点，元组和字符串的元素不可修改。列举一些常用的列表操作的函数和方法。

1，list.append(x)，将x追加到列表list末尾：

1 stack = [3,4,5] #定义列表

2 print(id(stack)) #打印列表的id值

3 stack.append(6) #将6追加到列表末尾

4 print(stack) #打印列表

5 print(id(stack)) #打猎列表的id值

6 stack.append(7) #将7追加到列表

7 print(stack) #打印列表

8 print(id(stack)) #打印列表的id值

9 '''总结：通过打印id发现，append是在原对象的基础上新增元素，并没有改变原对象在内存中的存储。'''

2，list.extend(L)，通过添加指定迭代器的所有元素来扩充列表，相当于a[len(a):] = L，其中L必须是可迭代的，如列表，字符串，字典，集合等。

1 #list.extend(L)，通过添加指定列表的所有元素来扩充列表，相当于，list[len(list):] = L

2 #参数L必须是可迭代的，可以是列表，元组，字符串，字典。集合。

3

4 a = [1] #定义原始列表

5 sTring = 'string' #定义字符串

6 listNumber = list(range(2,20,3)) #定义数字列表，步长为3

7 listString = ['a','b','d','e'] #定义字符串列表

8 dictTa = {'value':120131,'label':'Description','name':'Python',} #定义字典

9 setTa = set({'value':120131,'label':'Description','name':'Python',}) #定义集合

10

11 print(a) #打印原始的列表a

12 print(id(a)) #打印原始列表的id值

13

14 a.extend(sTring) #将字符串sTring作为参数传递给extend，以扩充原始列表a

15 print(type(sTring)) #打印下字符串列表的数据类型

16 print(a) #打印通过extend扩充字符串后的列表a

17 print(id(a)) #打印扩充后的列表的id值，与原始id值一样

18

19 a.extend(listNumber) #将数字列表listNumber作为参数传递给extend，以扩充列表a

20 print(type(listNumber)) #打印一下数字列表的数据类型

21 print(a) #打印通过extend扩充数字列表后的列表a

22 print(id(a)) #打印扩充数字列表后的id值

23

24 a.extend(listString) #将字符串列表作为参数传递给extend，以扩充列表a

25 print(type(listString)) #打印字符串列表的数据类型

26 print(a) #打印通过extend扩充字符串列表后的列表a

27 print(id(a)) #打印扩充字符串列表后的id值

28

29 a.extend(dictTa) #将字典dictTa作为参数传递给extend，以扩充列表

30 print(type(dictTa)) #打印字典的数据类型

31 print(a) #打印通过extend扩充字典列表后的列表a

32 print(id(a)) #打印扩充字典后的id值

33

34 a.extend(setTa) #将集合setTa作为参数传递给extend，以扩充列表a

35 print(type(setTa)) #打印集合setTa的数据类型

36 print(a) #打印通过extend扩充集合后的列表a

37 print(id(a)) #打印扩充集合后的id值

38 '''总结，1，id值并没有变，也就是内存中数据存储并没有变；39 2，字典和集合通过extend只扩充键，值没有一起被扩充；40 3，字典和集合通过extend扩充，41 字典的键是“有序”排列，即在字典中的位置是啥位置，扩充后在列表中也是对应；42 而集合的键是“随机”排列；

3，list.insert(i,x) 在列表的指定位置插入元素。其中第一个参数i指定列表索引位置，第二个为要插入的值x。如list.insert(0,x)，就是在列表的最前面插入元素x，list.insert(2,x)，就表示在列表索引为2的位置插入元素x；list.insert(len(list),x)，表示在列表末尾插入元素x，相当于list.append(x)。

1 a = [1,2,3,4,5]2 b = ['4','6','8','10']3 c = ['a','b','c','d','e']4 d = list(range(1,100,20))5

6 a.insert(3,6) #在列表a索引为3的位置插入数字6

7 a.insert(len(a),7) #在列表b末尾插入数字7，相当于a.append(7)

8 b.insert(5,'12') #在列表b索引为5的位置插入字符串12

9 b.insert(len(b),'14') #在列表b末尾插入字符串14，相当于b.append('14')

10 c.insert(3,'f') #在列表c索引为3的位置插入字符串'f'

11 c.insert(len(c),'g') #在列表c的末尾插入字符串g，相当于c.append('g')

12 d.insert(2,10) #在列表d索引为2的位置插入数字10

13 d.insert(len(d),100) #在列表d的末尾插入数字100，相当于d.append(100)

还有一个问题，如果insert指定的索引位置的值大于列表索引位置的最大值，即list.insert(i,x)，当i>len(list)的时候，x将会被追加到列表末尾，相当于list.append(x)。

4，list.remove(x) 删除列表中第一个值为x的元素。如果没有，将引发一个ValueError的错误。为了方便演示，创建一个首尾相同元素的列表。

1 #list.remove(x) 删除列表list中值为x的第一个元素，如果值不存在就会返回一个错误

2 a = ['a','b','c','d','e','a'] #定义首尾元素相同的列表，方便演示

3 b = a.remove('a') #删除列表a里第一个值为字符串a的元素并赋值给变量b

4 print(a) #打印列表，列表中第一次出现的a被删除

5 print(b) #打印b，返回None

6 c = a.remove('a') #再删a，就把最后一个a也从列表删除了

7 print(a) #打印是否符合预期

8 print(c) #打印c，返回None

5，list.pop([i]) 从列表的指定位置删除元素(本人理解为从列表指定位置弹出元素)，与remove不同，pop方法删除的元素是可以返回的。如果没有指定可选参数[i]的值，pop()从列表末尾开始删除。pop([i])方法中 i 两边的方括号表示这个参数是可选的，而不是要求输入一对方括号，经常在 Python 库参考手册中遇到这样的标记。为方便与remove对比，还是用上面的例子：

1 a = ['a','b','c','d','e','a'] #定义首尾元素相同的列表，方便演示

2 b = a.remove('a') #删除列表a里第一个值为字符串a的元素并赋值给变量b

3 print(a) #打印列表，列表中第一次出现的a被删除

4 print(b) #打印b，返回None

5 c = a.remove('a') #再删a，就把最后一个a也从列表删除了

6 print(a) #打印是否符合预期

7 print(c) #打印c，返回None

8

9 d = a.pop(1) #使用pop方法弹出列表a中索引为1的值

10 print(a) #打印列表a

11 print(d) #打印弹出的值，值为字符串c

6，list.clear() 移除列表中所有的项，但是保存列表list的数据类型，使用clear方法后，list返回一个空列表。等同于del list[:]

1 a = [1,2,3,4,5] #定义数字列表b

2 print(id(a)) #打印列表a的id值

3 a.clear() #使用方法clear()清空列表中所有项

4 print(a) #打印a，返回空列表

5 print(type(a)) #打印数据类型，返回

6 print(id(a)) #再次打印列表a的id值，与没删除之前一样

7

8 b = [2,3,4,5,6] #定义列表b

9 print(id(b)) #打印列表b的id值

10 del b[:] #删除列表b在内存中的副本，b[:]表示列表b的一个切片，也可以理解为副本.

11 print(b) #打印列表b，返回[]

12 print(type(b)) #查看列表b的数据类型，返回

13 print(id(b)) #查看被清空后的列表b的id值与未清空之前是否相同

14

15 c = [6,7,8,9,10] #定义列表c

16 print(c) #打印c，输出：[6, 7, 8, 9, 10]

17 del c #删除c

18 print(c) #打印c，NameError: name 'c' is not defined

问题：列表b和列表c都是使用的del语句，列表b使用切片，内存中还有位置；列表c是把整个对象都删除了，在内存中根本没有了位置。要恶补内存，数据，存储，对象的知识。

7，list.index(x) 返回列表list中第一个值为x的索引，如果没有将返回一个ValueError: xxx is not in list错误。其中xxx是引发错误的值。

1 a = [1,2,3,4,5] #定义数字列表

2 b = ['a','b','c','d','e','a'] #定义字符串列表

3

4 r1 = a.index(1) #获取值为1的索引

5 print(r1) #打印返回0

6 r1 = a.index(2) #获取列表a中值为2的索引

7 print(r1) #打印返回1

8 r1 = a.index(3) #获取列表a中值为3的索引

9 print(r1) #打印返回2

10 r1 = a.index(4) #获取列表a中值为4的索引

11 print(r1) #打印返回3

12 r1 = a.index(5) #获取列表a中值为5的索引

13 print(r1) #打印返回4

14 r1 = a.index(6) #尝试获取列表a中值为6的索引，因为值6根本不存在与列表中，返回错误ValueError: 6 is not in list

15

16

17 #循环读取索引

18 for index, value inenumerate(a):19 print(index)20

21 for index inrange(len(a)):22 print(index)23

24 r2 = b.index('a') #获取列表b中第一个值为a的索引

25 print(r2) #打印返回0

26 r2 = b.index('b') #获取列表b中第一个值为b的索引

27 print(r2) #打印返回1

28 r2 = b.index('c') #获取列表b中第一个值为c的索引

29 print(r2) #打印返回2

30 r2 = b.index('d') #获取列表b中第一个值为d的索引

31 print(r2) #打印返回3

32 r2 = b.index('e') #获取列表b中第一个值为e的索引

33 print(r2) #打印返回4

34 r2 = b.index('a') #还是获取列表b中第一个返回值为a的索引

35 print(r2) #打印还是返回0

36

37 #循环读取索引

38 for index, value inenumerate(b):39 print(index)40

41 for index inrange(len(b)):42 print(index)43

44

8，list.count(x) 统计x在列表list中出现的次数。

1 a = [1,2,3,4,5,5,1] #定义数字列表

2 b = ['a','b','c','d','e','a'] #定义字符串列表

3

4 print(a.count(1)) #计算数字1在列表a中出现的次数并打印

5 print(a.count(6)) #计算数字6在列表a中出现的次数并打印

6 print(b.count('a')) #计算字符串a在列表b中出现的次数并打印

7 print(b.count('c')) #计算字符串c在列表b中出现的次数并打印

9，list.sort() 对列表中的元素进行排序(永久)，与之对应的有临时排序sorted(list)。用法如下：

1 orginalAlist = [1,2,3,4,5,5,1] #定义数字列表

2 orginalBlist = ['a','b','c','d','e','a'] #定义字符串列表

3

4 sortedAlist = sorted(orginalAlist) #对列表A进行临时排序并赋值给变量sortedAlist

5 print(sortedAlist) #打印临时排序后的列表 [1, 1, 2, 3, 4, 5, 5]

6 print(orginalAlist) #打印原始列表 [1, 2, 3, 4, 5, 5, 1]

7

8 sortedBlist = sorted(orginalBlist) #对列表B进行临时排序并赋值给变量sortedBlist

9 print(sortedBlist) #打印临时排序后的列表 ['a', 'a', 'b', 'c', 'd', 'e']

10 print(orginalBlist) #打印原始列表 ['a', 'b', 'c', 'd', 'e', 'a']

11

12

13 orginalAlist.sort() #将列表orginalAlist用sort进行永久排序

14 print(orginalAlist) #打印列表 [1, 1, 2, 3, 4, 5, 5]

15

16 orginalBlist.sort() #将列表orginalBlist用sort进行永久排序

17 print(orginalBlist) #打印列表 ['a', 'a', 'b', 'c', 'd', 'e']

10，倒序排列列表中的元素，一般与sort配合使用。

1 orginalAlist = [1,2,3,4,5,5,1] #定义数字列表

2 orginalBlist = ['a','b','c','d','e','a'] #定义字符串列表

3

4 orginalAlist.reverse() #调用reverse倒序排列列表

5 print(orginalAlist) #打印 [1, 5, 5, 4, 3, 2, 1]

6

7 orginalBlist.reverse() #调用reverse倒序排列列表

8 print(orginalBlist) #打印 ['a', 'e', 'd', 'c', 'b', 'a']

9

10 orginalAlist.sort(reverse=True) #将列表orginalAlist先用sort进行排序，然后将reverse=True作为参数传递给sort，将排序好的列表进行倒序排列

11 print(orginalAlist) #打印排序好的倒序列表 [5, 5, 4, 3, 2, 1, 1]

12

13 orginalBlist.sort(reverse=True) #将列表orginalBlist先用sort进行排序，然后将reverse=True作为参数传递给sort，将排序好的列表进行倒序排列

14 print(orginalBlist) #打印排序好的倒序列表 ['e', 'd', 'c', 'b', 'a', 'a']

11，list.copy() 对列表进行浅复制，相当于list[:]

1 a = [1,2,3,4,5,5,1] #数字列表a

2 b = ['a','b','c','d','e','a'] #字符串列表b

3

4 a1 = a.copy() #将a复制一份并赋值给a1

5 a2 = a[:] #将a再复制一份并赋值给a2

6 print(a,a1,a2) #打印三个列表，一样

7 print(id(a),id(a1),id(a2)) #打印id，表示并不是同一个对象

8

9 b1 = b.copy() #将b复制一份并赋值给b1

10 b2 = b[:] #将b再复制一份并赋值给b2

11 print(b,b1,b2) #打印三个列表，内容一致

12 print(id(b),id(b1),id(b2)) #打印三个列表id，证明三个列表并不是同一个对象

代码并无实际应用意义，仅供交流学习使用，欢迎补充。