python 列表操作方法详解及例子

原文链接：https://www.cnblogs.com/wj-1314/p/8433116.html 

      列表是Python中最基本的数据结构，列表是最常用的Python数据类型，列表是一个数据的集合，集合内可以放任何数据类型，可对集合方便的增删改查操作。Python已经内置确定序列的长度以及确定最大和最小的元素的方法

序号	函数	描述
1	list.append(self,p_object)	给列表后面追加新的对象
2	list.clear(self)	清空列表中的元素
3	list.copy(self)	浅复制列表
4	list.count(self,value)	统计某个元素在列表中出现的次数
5	list.extend(self,iterable)	在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）
6	list.index(self, value, start=None, stop=None)	从列表中找出某个值第一个匹配项的索引位置
7	list.insert(self,index,start=None,stop=None)	将对象插入列表
8	list.pop(self,index=None)	移除列表中的一个元素（默认最后一个），并返回该元素的值
9	list.remove(self,value)	移除列表中某个值的第一个匹配项，从左找到第一个指定元素
10	list.reverse(self,value)	反向列表中的元素
11	list.sort(self,key=None,reverse=False)	对原列表进行排序

 

一，List list()方法

　　list()方法将元祖转换为列表

　　注意：元祖与列表是非常相似的，区别在于元组的元素值不能修改，元祖是放在括号中，列表是放在方括号里面的。

1 2 3 4 5 6 7

a_tuple = ('123','abc',123) a_list = list(a_tuple) print(a_tuple) print(a_list) 结果： ('123', 'abc', 123) ['123', 'abc', 123]

二，创建一个列表

　　只要把逗号分隔的不同的数据项使用方括号括起来即可。如下：

1 2 3

a_list = [1,2,3,4,5,6] b_list = ['a','b','c','d'] c_list = ['a','b','c',1,2,3,4]

三，访问列表中的值

　　与字符串的索引一样，列表索引从0开始。列表可以进行截取、组合等。使用下标索引来访问列表中的值，同样你也可以使用方括号的形式截取字符，如下所示：

1 2 3 4 5 6 7 8 9 10

a_list = [1,2,3,4,5,6] b_list = ['a','b','c','d'] c_list = ['a','b','c',1,2,3,4] print(a_list[0]) print(b_list[1:3]) print(c_list[:]) 结果： 1 ['b', 'c'] ['a', 'b', 'c', 1, 2, 3, 4]

四，更新列表

　　可以对列表的数据项进行修改或更新，你也可以使用append()方法来添加列表项，如下所示：

1 2 3 4 5 6 7 8 9 10

a_list = [1,2,3,4,5,6] b_list = ['a','b','c','d'] c_list = ['a','b','c',1,2,3,4] a_list[0] = 123 print(a_list) b_list.append("efg") print(b_list) 结果： [123, 2, 3, 4, 5, 6] ['a', 'b', 'c', 'd', 'efg']

五，删除列表元素

　　1，可以使用 del 语句来删除列表的的元素，

　　2，可以使用pop（）移除某元素并返回该元素，

　　3，使用remove（）删除从左找到的第一个指定元素，如下实例：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

a_list = [1,2,3,4,5,6] b_list = ['a','b','c','d'] c_list = ['a','b','c',1,2,3,4，1] del a_list[2] print(a_list) b = b_list.pop() print(b) c = c_list.pop(2)  #也可以删除指定元素，并返回 print(c) d = c_list.remove(1) print(c_list) 结果： [1, 2, 4, 5, 6] d c ['a','b','c',2,3,4，1]

　　

 

六，列表脚本操作符

　　列表对 + 和 * 的操作符与字符串相似。+ 号用于组合列表，* 号用于重复列表。

Python 表达式	结果	描述
len([1, 2, 3])	3	长度
[1, 2, 3] + [4, 5, 6]	[1, 2, 3, 4, 5, 6]	组合
['Hi!'] * 4	['Hi!', 'Hi!', 'Hi!', 'Hi!']	重复
3 in [1, 2, 3]	True	元素是否存在于列表中
for x in [1, 2, 3]: print x,	1 2 3	迭代

 

七，列表操作函数

　　　　1、cmp(list1, list2)：比较两个列表的元素 
　　　　2、len(list)：列表元素个数 
　　　　3、max(list)：返回列表元素最大值 
　　　　4、min(list)：返回列表元素最小值 
　　　　5、list(seq)：将元组转换为列表

八，列表排序

　　注意排序优先级：数字>大写字母>小写字母>符号>中文

　　1，永久性排序：sort()

　　2，临时性排序：sorted()

　　3，反转排序：reverse()

1 2 3 4 5 6 7 8 9 10 11 12

l1 = ["排序","?","123","w","W"] l2 = ['1','2','3'] a = l1.sort()      #永久性排序，就是这个列表就变了 print(l1) b =sorted(l2)    #临时性排序，就是可以赋值某个变量 print(b) c = l1.reverse() print(l1) 结果： ['123', '?', 'W', 'w', '排序'] ['1', '2', '3'] ['排序', 'w', 'W', '?', '123']

九，遍历列表

　　除了一般的遍历，还可以遍历切片列表

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

list=['1','2','3'] for value in list:#末尾加上冒号     print(value)#每次循环都把list列表中的值赋给value,赋值从索引号0开始#循环的语句需要缩进   结果： 1 2 3     list=['1','2','3','4','5','6','7'] for value in list[3:]:#遍历索引3之后的数值     print(value)   结果： 4 5 6 7

十，创建数值列表

　　1，使用range()函数生成一系列数值

　　2，遍历range()函数生成的数值

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

value=list(range(0,6))#range()生成0~6的数值,list()函数把数值转换成列表 print(value) 结果： [0, 1, 2, 3, 4, 5]   for value in range(0,6):#range(0,6)顺序生成从0到5的数值     print(value) 结果： 0 1 2 3 4 5   >>> range(1,5)#代表从1到5(不包含5)----------------[1, 2, 3, 4] >>> range(1,5,2) #代表从1到5，每次加2(不包含5)-----[1, 3] >>> range(5) #代表从0到5(不包含5)-----------------[0, 1, 2, 3, 4]

　　

十一，复制列表

　　1，复制整个列表

　　2，复制切片列表

1 2 3 4 5 6 7 8 9 10 11

list=['1','2','3','4','5'] list_2=list[:]#从起始索引到末尾索引 print(list_2) 结果： ['1', '2', '3', '4', '5']   list=['1','2','3','4','5'] list_2=list[:3]#从起始索引到索引3 print(list_2)#输出['1','2','3'] 结果： ['1', '2', '3', '4', '5']

十二，列表切片

切片操作（slice）可以从一个字符串中获取子字符串（字符串的一部分）。我们使用一对方括号、起始偏移量start、终止偏移量end 以及可选的步长step 来定义一个分片。

格式： [start:end:step]

• • [:] 提取从开头（默认位置0）到结尾（默认位置-1）的整个字符串
• • [start:] 从start 提取到结尾
• • [:end] 从开头提取到end - 1
• • [start:end] 从start 提取到end - 1
• • [start:end:step] 从start 提取到end - 1，每step 个字符提取一个
• • 左侧第一个字符的位置/偏移量为0，右侧最后一个字符的位置/偏移量为-1

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

list = [1, 2, 3, 4, 5, 6, 7] >>> list[0:] #列出索引0以后的---------[1, 2, 3, 4, 5, 6, 7] >>> list[1:] #列出索引1以后的---------[2, 3, 4, 5, 6, 7] >>> list[:-1] #列出索引-1之前的-------[1, 2, 3, 4, 5, 6] >>> list[1:3] #列出索引1到3之间的-----[2]     #形成reverse函数的效果: >>> list[::-1]#[7, 6, 5, 4, 3, 2, 1] >>> list[::-2]#[7, 5, 3, 1]     >>> range(1,5)#代表从1到5(不包含5)----------------[1, 2, 3, 4] >>> range(1,5,2) #代表从1到5，每次加2(不包含5)-----[1, 3] >>> range(5) #代表从0到5(不包含5)-----------------[0, 1, 2, 3, 4]

十三，tuple,dict,list之间的转换

　　直接声明的list和tuple无法通过dict()转换成dict类型

　　直接声明的dict可以通过tuple()和list()分别转换成tuple和list类型（结果只包含了keys），可是此时却能通过dict()反转回原来的dict类型

13-1、字典

1 2 3 4 5 6 7 8 9 10 11

dict = {'name': 'Zara', 'age': 7} #字典转为字符串 str(dict) #字典可以转为元组 tuple(dict) #字典可以转为元组 tuple(dict.values()) #字典转为列表 list(dict) #字典转为列表 dict.values

13-2、元组

1 2 3 4 5 6

tup=(1, 2, 3, 4, 5,6,7,8) #元组转为字符串 tup.__str__() #元组转为列表 list(tup) #元组不可以转为字典

13-3、列表

1 2 3 4 5 6

nums=[1, 3, 5, 7, 9, 11, 13]; #列表转为字符串 str(nums) #列表转为元组 tuple(nums) #列表不可以转为字典

13-4、字符串

1 2 3 4 5 6 7 8

str="(1,2,3)" #字符串转为元组 tuple(eval(str)) #字符串转为列表 list(eval("(1,2,3)")) #字符串转为字典 str1="{'name':'ljq', 'age':24}" eval(str1)

十四，列表的练习

写代码，要求实现下面每一个功能

　　li=['alex','eric','rain']

　　1，计算列表长度并输出

　　2，列表中追加元素“servn"，并输出添加后的列表

　　3，请在列表的第一个位置插入元素‘tony’，并输出添加后的列表

　　4，请修改列表位置元素‘kelly’，并输出修改后的列表

　　5，请在列表删除元素‘eric’，并输出删除后的列表

　　6，请删除列表中的第2个元素，并输出删除后的元素的值和删除元素后的列表

　　7，请删除列表中的第三个元素，并输出删除后的列表

　　8，请删除列表的第2到4个元素，并输出删除元素后的列表

　　9，请用for len range输出列表的索引

　　10，请使用enumrate输出列表元素和序号

　　11，请使用for循环输出列表中的所有元素

 

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40

# li = ['alex','eric','rain'] # 1,计算列表长度并输出 # print(len(li)) # 列表中追加元素“seven”，并输出添加后的列表 # li.append('seven') # print(li) # 请在列表的第1个位置插入元素“Tony”，并输出添加后的列表 # li.insert(1,'tony') # print(li) #请修改列表第2个位置的元素为“Kelly”，并输出修改后的列表 # li[1] ='kelly' # print(li) # 请删除列表中的元素“eric”，并输出修改后的列表 # a =li.pop(2) # print(li) # li.remove('eric') # print(li) # 请删除列表中的第2个元素，并输出删除元素后的列表 # b =li.pop(1) # print(b) # print(li) # 请删除列表中的第2至4个元素，并输出删除元素后的列表 # c = li[2:4] # d = set(li)-set(c) # # print(list(d)) # del li[1:4] # print(li) # 请将列表所有的元素反转，并输出反转后的列表 # e = li.reverse() # print(li) # 请使用for、len、range输出列表的索引 # for i in range(len(li)): #     print(i) # 请使用enumrate输出列表元素和序号（序号从100开始） # for index in enumerate(li): #     print(index) # for index,i in enumerate(li,100): #     print(index,i) # for i in li: #     print(i)

十五，写代码，有如下元组，请按照功能要求实现每一个功能

　　tu = ('alex','eric,'rain')

　　1，计算元组的长度并输出

　　2，获取元祖的第二个元素，并输出

　　3，获取元祖的第1-2个元素，并输出

　　4，请用for输出元祖的元素

　　5，请使用for,len,range输出元组的索引

　　6，请使用enumerate输出元组元素和序号，（从10开始）

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

tu = ('alex','eric','rain') # 　　1，计算元组的长度并输出 print(len(tu)) # 　　2，获取元祖的第二个元素，并输出 print(tu[1]) # 　　3，获取元祖的第1-2个元素，并输出 print(tu[0:2]) # 　　4，请用for输出元祖的元素 for i in tu:     print(i) # 　　5，请使用for,len,range输出元组的索引 for i in range(len(tu)):     print(i) # 　　6，请使用enumerate输出元组元素和序号，（从10开始） for index,i in enumerate(tu,10):     print(index,i)

　　

十六，list中的append和extend的区别

list.append(object) 向列表中添加一个对象object

list.extend(sequence) 把一个序列seq的内容添加到列表中

 举例如下：

使用append的时候，是将new_media看作一个对象，整体打包添加到music_media对象中。

1 2 3 4 5

music_media = ['compact disc', '8-track tape', 'long playing record'] new_media = ['DVD Audio disc', 'Super Audio CD'] music_media.append(new_media) print music_media >>>['compact disc', '8-track tape', 'long playing record', ['DVD Audio disc', 'Super Audio CD']]

　　

使用extend的时候，是将new_media看作一个序列，将这个序列和music_media序列合并，并放在其后面。

1 2 3 4 5

music_media = ['compact disc', '8-track tape', 'long playing record'] new_media = ['DVD Audio disc', 'Super Audio CD'] music_media.extend(new_media) print music_media >>>['compact disc', '8-track tape', 'long playing record', 'DVD Audio disc', 'Super Audio CD']

三种遍历列表的方法： 原文链接 http://www.javaxxz.com/thread-365029-1-1.html 

三种遍历列表里面序号和值的方法： 
 

1. 1 #!/usr/bin/env python
2. 2 # -*- coding: utf-8 -*-
3. 3 if __name__ == "__main__":  4     list = ["html", "js", "css", "python"]  5
4. 6     # 方法1 index（）
5. 7     print "遍历列表方法1："
6. 8     for i in list:  9         print ("序号：%s 值：%s" % (list.index(i) + 1, i)) 10
7. 11     print "\n遍历列表方法2："
8. 12     # 方法2 rang()/len()
9. 13     for i in range(len(list)): 14         print ("序号：%s 值：%s" % (i + 1, list[i])) 15
10. 16     # 方法3 enumerate()
11. 17     print "\n遍历列表方法3："
12. 18     for i, val in enumerate(list): 19         print ("序号：%s 值：%s" % (i + 1, val)) 20
13. 21     # 方法3
14. 22     print "\n遍历列表方法3 （设置遍历开始初始位置，只改变了起始序号）："
15. 23     for i, val in enumerate(list, 2): 24         print ("序号：%s 值：%s" % (i + 1, val))

运行代码后的结果如下图所示： 
 
  
在此介绍一下enumerate()方法，通过查看help()函数来查看，查询结果如下： 
 
最后提示一下，enumerate()函数的第二个参数只是改变了序号的起始值，并没有改变其他的东东 

以下原创练习：  声明一个列表，至少10个元素，然后循环输出，把第一个位置的元素输出一次，第二个输出两次，以此类推，然后把这个列表的顺序反过来放到另一个列表里。 

 

​
A_list = ['a','b','c','d','e','f','g','h','i','j']
B_list = []

for i,j in enumerate(A_list):
    time = 0
    while time <= int(i):
        print(j)
        time +=1
        
for i in range(len(A_list)):
    B_list.append(len(A_list)-i)
print(B_list)