列表
Python中的列表类似于C语言中的数组的概念，列表由内部的元素组成，元素可以是任何对象
Python中的列表是可变的
简单的理解就是：被初始化的列表，可以通过列表的API接口对列表的元素进行增删改查
1、定义列表
1.可以将列表当成普通的“数组”，它能保存任意数量任意类型的python对象
2.像字符串一样，列表也支持下标和切片操作
3.列表中的项目可以改变
# 列表的初始化lst = list()lst = []lst = [1,2,3]lst = list(range(10))
2、列表操作
1.使用in或not in判断成员关系
2.使用append方法向列表中追加元素
3、创建及访问列表
1.列表是有序、可变的数据类型
2.列表中可以包含不同类型的对象
3.列表可以由[]或工厂函数创建
4、列表操作符
由于列表也是序列类型，所以+、*、in、not in都适用于列表，但是需要注意参与运算的对象属于同一类型
>>> ['hello', 'world'] * 2 ['hello', 'world', 'hello', 'world'] >>> ['hello', 'world'] + 'new' Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: can only concatenate list (not "str") to list >>> ['hello', 'world'] + ['new'] ['hello', 'world', 'new']
5、作用于列表的函数
与字符串类似，列表也支持如下函数：
1、len()
2、max()
3、min()
4、sorted()
5、enumerate()
6、sum()
6、zip()
1、列表元素用中括号[]包裹，元素的个数及元素的值可以改变
Python包含以下函数:
| 序号 | 函数 |
|---|---|
| 1 | cmp(list1, list2) 比较两个列表的元素 |
| 2 | len(list) 列表元素个数 |
| 3 | max(list) 返回列表元素最大值 |
| 4 | min(list) 返回列表元素最小值 |
| 5 | list(seq) 将元组转换为列表 |
Python包含以下方法:
| 序号 | 方法 |
|---|---|
| 1 | list.append(obj) 在列表末尾添加新的对象 |
| 2 | list.count(obj) 统计某个元素在列表中出现的次数 |
| 3 | list.extend(seq) 在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表） |
| 4 | list.index(obj) 从列表中找出某个值第一个匹配项的索引位置 |
| 5 | list.insert(index, obj) 将对象插入列表 |
| 6 | list.pop([index]) 移除列表中的一个元素（默认最后一个元素），并且返回该元素的值 |
| 7 | list.remove(obj) 移除列表中某个值的第一个匹配项 |
| 8 | list.reverse() 反向列表中元素 |
| 9 | list.sort([func]) 对原列表进行排序 |
一， list()方法
list()方法将元组转换为列表
注意：元祖与列表是非常相似的，区别在于元组的元素值不能修改，元祖是放在小括号中，列表是放在中括号里面的。
a_tuple = ('123','abc',123)
a_list = list(a_tuple)
print(a_tuple)
print(a_list)
结果：
('123', 'abc', 123)
['123', 'abc', 123]
二，创建一个列表
只要把逗号分隔的不同的数据项使用方括号括起来即可。如下：
a_list = [1,2,3,4,5,6] b_list = ['a','b','c','d'] c_list = ['a','b','c',1,2,3,4]
三，访问列表中的值
与字符串的索引一样，列表索引从0开始。列表可以进行截取、组合等。使用下标索引来访问列表中的值，同样你也可以使用方括号的形式截取字符，如下所示：
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()方法来添加列表项，如下所示：
#!/usr/bin/env python
#-*- coding:utf-8 -*-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.append(b_list)
print a_list
a_list[0] = 123
print(a_list)
b_list.append("efg")
print(b_list)结果：[1, 2, 3, 4, 5, 6, ['a', 'b', 'c', 'd']]
[123, 2, 3, 4, 5, 6, ['a', 'b', 'c', 'd']]
['a', 'b', 'c', 'd', 'efg']
五，删除列表元素
1，可以使用 del 语句来删除列表的的元素，
2，可以使用pop（）移除某元素并返回该元素，
3，使用remove（）删除从左找到的第一个指定元素，
如下实例：
#!/usr/bin/env python #-*- coding:utf-8 -*-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()
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']
注意：如果出现列表输出编码问题，可按照下面这个方法
l1 = ["排序","?","123","w","W"]
l2 = ['1','2','3']
a = l1.sort() #永久性排序，就是这个列表就变了
print str(l1).decode('string_escape')
b =sorted(l2) #临时性排序，就是可以赋值某个变量
print b
c = l1.reverse()
print str(l1).decode("string_escape")
或者：
#!/usr/bin/env python #coding:utf-8 import json l1 = ["排序","?","123","w","W"] l2 = ['1','2','3'] a = l1.sort() #永久性排序，就是这个列表就变了 print json.dumps(l1,encoding="utf8",ensure_ascii=False) b =sorted(l2) #临时性排序，就是可以赋值某个变量 print b c = l1.reverse() print json.dumps(l1,encoding="utf8",ensure_ascii=False)
执行结果：
['123', '?', 'W', 'w', '排序'] ['1', '2', '3'] ['排序', 'w', 'W', '?', '123']
参考：http://www.caotama.com/57501.html
九，遍历列表
除了一般的遍历，还可以遍历切片列表
list=['1','2','3'] for value in list:#末尾加上冒号print(value)#每次循环都把list列表中的值赋给value,赋值从索引号0开始#循环的语句需要缩进结果： 1 2 3list=['1','2','3','4','5','6','7'] for value in list[3:]:#遍历索引3之后的数值print(value)结果： 4 5 6 7
十，创建数值列表
1，使用range()函数生成一系列数值
2，遍历range()函数生成的数值
#range()生成0~5的数值,list()函数把数值转换成列表
value=list(range(0,6)) 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，复制切片列表
list=['1','2','3','4','5'] list_2=list[:]#从起始索引到末尾索引 print(list_2) 结果： ['1', '2', '3', '4', '5']list=['1','2','3','4','5']
#从起始索引到索引3 list_2=list[:3] print(list_2) #输出['1','2','3']
十二，列表切片
切片操作（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
例子：
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]
十四，列表的练习
写代码，要求实现下面每一个功能
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循环输出列表中的所有元素
十五、具体实现：
#!/usr/bin/env python
#coding:utf8li = ['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)
十六，list中的append和extend的区别
list.append(object) 向列表中添加一个对象object
list.extend(sequence) 把一个序列seq的内容添加到列表中
举例如下：
使用append的时候，是将bList看作一个对象，整体打包添加到aList对象中
aList = ['11', '22', '33'] bList = ['44', '55'] aList.append(bList) print aList
执行结果：
['11', '22', '33', ['44', '55']]
使用extend的时候，是将bList看作一个序列，将这个序列和aList序列合并，并放在其后面。
aList = ['11', '22', '33'] bList = ['44', '55']
aList.extend(bList) print aList
执行结果：
['11', '22', '33', '44', '55']
清空列表参考：
https://www.cnblogs.com/BackingStar/p/10986775.html
列表操作实例：
>>> a = ["apple","banana","cat","dog"]
>>> b = ["banana","egg","fruit"]>>> a.append("glass") #追加，即在最后一个元素中新添加一个元素
>>> a
['apple', 'banana', 'cat', 'dog', 'glass']
>>>
>>>
>>> a.extend(b) #把b列表中的内容扩展到a列表中，但b列表中的内容在a内容后面
>>> a
['apple', 'banana', 'cat', 'dog', 'glass', 'banana', 'egg', 'fruit']>>> a.count("banana") #统计banana的个数
2
>>> a.index("banana") #返回列表中第一个匹配项的索引位置，
1
>>> a.index("banana")
1
>>> a.index("cat")
2
>>>
>>> >>> a.insert(5,"hair") #在索引为5的位置插入hair
>>> a
['apple', 'banana', 'cat', 'dog', 'glass', 'hair', 'banana', 'egg', 'fruit']
>>> >>> a.pop() #默认移除列表中的最后一项，并显示出来
'fruit'
>>> a.pop(5) #移除索引为5的元素
'hair'
>>> a
['apple', 'banana', 'cat', 'dog', 'glass', 'banana', 'egg']
>>>
>>> a.remove('glass') #移除列表中的第一个匹配项
>>> a
['apple', 'banana', 'cat', 'dog', 'banana', 'egg']
>>>
>>> a.reverse() #反序
>>> a
['egg', 'banana', 'dog', 'cat', 'banana', 'apple']
>>> a.sort() #排序
>>> a
['apple', 'banana', 'banana', 'cat', 'dog', 'egg']
>>> 列表嵌套：列表嵌套字典
>>> li = ['alex',123,{"k1":"v1","k2":{"vv":(11,22,123),"li":456}}]
>>> li[2]
{'k2': {'vv': (11, 22, 123), 'li': 456}, 'k1': 'v1'}
>>> li[2]['k2']
{'vv': (11, 22, 123), 'li': 456}
>>> li[2]['k2']['vv']
(11, 22, 123)
>>> li[2]['k2']['vv'][2]
123
>>>
练习1：
编写一个石头、剪刀、布的游戏。你和计算机各出一项，判断输赢。
提示：计算机出什么，可以使用random模块中的choice随机在一个列表中选择某一项
例子1：
#!/usr/bin/env python #-*- coding:utf-8 -*-import randomch_list = ["石头","剪刀","布"] computer = random.choice(ch_list) #random.choice从序列中获取一个随机元素。其函数原型为：random.choice(sequence) win_list = [["石头","剪刀"],["剪刀","布"],["布","石头"]] #列表嵌套列表prompt = """(0)石头 (1)剪刀 (2)布 请选择(012):"""ind = int(raw_input(prompt)) #输入0、1或2 player = ch_list[ind] #从ch_list列表中取出某一个值赋值给player变量print "Your choice : %s,Computer choice: %s" %(player,computer) if [player,computer] in win_list:print 'You Win!!!' elif player == computer:print '平局' else:print "You Lose"
执行结果：
(0)石头 (1)剪刀 (2)布 请选择(012):0 Your choice : 石头,Computer choice: 剪刀 You Win!!!
例子2：给结果添加颜色
#!/usr/bin/env python #-*- coding:utf-8 -*-import randomch_list = ["石头","剪刀","布"]
computer = random.choice(ch_list)win_list = [["石头","剪刀"],["剪刀","布"],["布","石头"]]prompt = """(0)石头 (1)剪刀 (2)布 请选择(012):"""ind = int(raw_input(prompt)) player = ch_list[ind]print "Your choice : %s,Computer choice: %s" %(player,computer) if [player,computer] in win_list:print '\033[31;1mYou Win!!!\033[0m' elif player == computer:print '\033[32;1m平局\033[0m' else:print "\033[31;You Lose\033[0m"
执行结果：
例子3：
#!/usr/bin/env python # coding: utf8import randomchoiceList = ['石头', '剪刀', '布'] winList = [['石头', '剪刀'], ['剪刀', '布'], ['布', '石头']] prompt = """\033[34;1m可选项如下： （0）石头 （1）剪刀 （2）布 请输入您的选择（输入数字即可）：\033[0m""" cchoice = random.choice(choiceList) #random.choice从序列中获取一个随机元素。此处即从choiceList列表中获取一个元素赋值给cchoice变量 uchoice = choiceList[int(raw_input(prompt))] #把输入的数字转换成整数，从choiceList中获取某个值再赋值给uchoice变量 bothChoice = [uchoice, cchoice] #把uchoice的值和cchoice的值放到列表bothChoice中print '您选择了%s, 我选择了%s' % (uchoice, cchoice) if cchoice == uchoice:print '\033[32;1m平手\033[0m' elif bothChoice in winList:print '\033[31;1mYou WIN!!!\033[0m' else:print '\033[31;1mYou LOSE!!!\033[0m'
执行结果：
可选项如下： （0）石头 （1）剪刀 （2）布 请输入您的选择（输入数字即可）：0 您选择了石头, 我选择了剪刀 You WIN!!!
比较2个文件中的内容，列出相同的元素和不同的元素：
注意：
1、有些知识涉及文件操作，不懂的话建议熟悉一下
2、通过粗略测试，这个脚本暂时只支持数字对比，
[root@host-192-168-3-6 work]# cat a.txt
123
456
789
234
567
345[root@host-192-168-3-6 work]# cat b.txt
123
345
456
567思路：
step1:打印出
#!/usr/bin/env python
#coding:utf-8
with open("/root/work/a.txt") as f1,open("/root/work/b.txt") as f2:for i in f1.readlines(): #读取所有行，以列表方式返回，然后遍历出列表中每个元素print i.strip('\n') #打印列表中每个元素step2：打印新列表
[root@host-192-168-3-6 work]# vim zgy.py
#!/usr/bin/env python
#coding:utf-8new_a = []
new_b = []same_list = []
diff_list = []with open("/root/work/a.txt") as f1,open("/root/work/b.txt") as f2:for i in f1.readlines():new_i = i.strip("\n")new_a.append(new_i)for j in f2.readlines():new_j = j.strip("\n")new_b.append(new_j)print new_a
print new_b[root@host-192-168-3-6 work]# python zgy.py
['123', '456', '789', '234', '567', '345']
['345', '456', '123', '567']step3：
[root@host-192-168-3-6 work]# vim zgy.py
#!/usr/bin/env python
#coding:utf-8new_a = []
new_b = []same_list = []
diff_list = []with open("/root/work/a.txt") as f1,open("/root/work/b.txt") as f2:for i in f1.readlines():new_i = i.strip("\n")new_a.append(new_i)for j in f2.readlines():new_j = j.strip("\n")new_b.append(new_j)if new_i in new_b:same_list.append(new_i)else:diff_list.append(new_i)#print new_a
#print new_b#print same_list
print diff_listroot@host-192-168-3-6 work]# python zgy.py
['789', '234']step4：[root@host-192-168-3-6 work]# vim zgy.py
#!/usr/bin/env python
#coding:utf-8new_a = []
new_b = []same_list = []
diff_list = []with open("/root/work/a.txt") as f1,open("/root/work/b.txt") as f2:for i in f1.readlines():new_i = i.strip("\n")new_a.append(new_i)for j in f2.readlines():new_j = j.strip("\n")new_b.append(new_j)if new_i in new_b:same_list.append(new_i)else:diff_list.append(new_i)#print new_a
#print new_b#print same_list
#print diff_list#打印相同的元素
for line in same_list:print line#打印不同的元素
for line in diff_list:print line
备注：这个脚本不完善
有bug的脚本：还是有bug;这个脚本适合长度一致的文件，一行一条数据；但是行尾出现多个空格，就会有bug
#!/usr/bin/env python
#coding:utf-8new_a = []
new_b = []#a.txt为全部元素，b.txt为部分元素
with open("G:/PycharmProject/fullstack2/week1/a.txt") as f1,open("G:/PycharmProject/fullstack2/week1/b.txt") as f2:for i in f1.readlines():new_i = i.strip("\n")new_a.append(new_i)for j in f2.readlines():new_j = j.strip("\n")new_b.append(new_j)set1 = set(new_a) #将list转换为set
set2 = set(new_b) #将list转换为set
#print set1 -set2 #打印set1中有的元素，但是set2没有的元素
#print set2 - set1 #打印set2中有的元素，但是set1没有的元素#a = set1 -set2for i in a: #遍历set2中有的元素，但是set1没有的元素print i
有bug的脚本2：这个脚本适合长度一致的文件，一行一条数据；但是行尾出现多个空格，就会有bug
#!/usr/bin/env python
#coding:utf-8new_a = []
new_b = []all_sum = "G:/PycharmProject/fullstack2/week1/a.txt"
part_sum = "G:/PycharmProject/fullstack2/week1/b.txt"with open(all_sum) as f1,open(part_sum) as f2:for i in f1.readlines():new_i = i.strip("\n")new_a.append(new_i)for j in f2.readlines():new_j = j.strip("\n")new_b.append(new_j)set1 = set(new_a)
set2 = set(new_b)
#print set1 -set2
#print set2 - set1a = set1 - set2for i in a:print i
完善的脚本1：
#!/usr/bin/env python
# coding:utf-8import renew_a = []
new_b = []all_sum = "G:/PycharmProject/test/a.txt"
part_sum = "G:/PycharmProject/test/b.txt"with open(all_sum) as f1, open(part_sum) as f2:for i in f1.readlines():new_i = re.sub('\s+','',i)new_a.append(new_i)for j in f2.readlines():new_j = re.sub('\s+','',j)new_b.append(new_j)set1 = set(new_a)
set2 = set(new_b)
# print set1 -set2
# print set2 - set1a = set1 - set2for i in a:print i
完善的脚本2：
#!/usr/bin/env python
# coding:utf-8import rep = re.compile('\s+')new_a = []
new_b = []all_sum = "G:/PycharmProject/test/a.txt"
part_sum = "G:/PycharmProject/test/b.txt"with open(all_sum) as f1, open(part_sum) as f2:for i in f1.readlines():new_i = re.sub(p, '', i) # sub(pattern, repl, string, count=0, flags=0)new_a.append(new_i)for j in f2.readlines():new_j = re.sub(p, '', j)new_b.append(new_j)set1 = set(new_a)
set2 = set(new_b)
# print set1 -set2
# print set2 - set1a = set1 - set2for i in a:print i
附加：
#compile:对正则表达式模式进行编译，返回一个正则表达式对象;不是必须要用这种方式，但是在大量匹配的情况下，可以提升效率 #re.compile(pattern,flags=0) #\s：匹配任何空白符
re.sub 函数详解命令：re.sub(pattern, repl, string, count=0, flags=0)re.sub 用于替换字符串的匹配项。如果没有匹配到规则，则原字符串不变。第一个参数：规则 第二个参数：替换后的字符串 第三个参数：字符串 第四个参数：替换个数。默认为0，表示每个匹配项都替换
练习：
第一题：
1，写代码，有如下列表，按照要求实现每一个功能
li = ['alex','wusir','eric','rain','alex']1)计算列表的长度并输出li = ['alex','wusir','eric','rain','alex']
s1 = len(li)2)列表中追加元素'seven',并输出添加后的列表li = ['alex','wusir','eric','rain','alex']
s2 = li.append('seven')
print(li)3)请在列表的第1个位置插入元素'Tony',并输出添加后的列表li = ['alex','wusir','eric','rain','alex']
li = ['alex','wusir','eric','rain','alex']
s3 = li.insert(1,'Tony')
print(li)4)请修改列表第2个位置的元素为'Kelly',并输出修改后的列表li = ['alex','wusir','eric','rain','alex']
li[2] = 'Kelly'
print(li)5)请将列表l2=[1,'a',3,4,'heart']的每一个元素添加到列表li中，一行代码实现，不允许循环添加。li = ['alex','wusir','eric','rain','alex']
l2=[1,'a',3,4,'heart']
li.extend(l2)
print(li)6)请将字符串s = 'qwert'的每一个元素添加到列表li中，一行代码实现，不允许循环添加。li = ['alex','wusir','eric','rain','alex']
s = 'qwert'
li.extend(s)
print(li)7)请删除列表中的元素'eric',并输出添加后的列表li = ['alex','wusir','eric','rain','alex']
li.remove('eric')
print(li)8)请删除列表中的第2个元素，并输出删除的元素和删除元素后的列表li = ['alex','wusir','eric','rain','alex']
print(li.pop(2))
print(li)9)请删除列表中的第2至4个元素，并输出删除元素后的列表li = ['alex','wusir','eric','rain','alex']
del li[2:4]
print(li)10)请将列表所有得元素反转，并输出反转后的列表li = ['alex','wusir','eric','rain','alex']
li.reverse()
print(li)11)请计算出'alex'元素在列表li中出现的次数，并输出该次数。li = ['alex','wusir','eric','rain','alex']
print(li.count('alex'))
第2题
2，写代码，有如下列表，利用切片实现每一个功能 li = [1,3,2,'a',4,'b',5,'c']1)通过对li列表的切片形成新的列表l1,l1 = [1,3,2]li = [1,3,2,'a',4,'b',5,'c'] li1 = li[:3] print(li1)2)通过对li列表的切片形成新的列表l2,l2 = ['a',4,'b']li = [1,3,2,'a',4,'b',5,'c'] li2 = li[3:6] print(li1)3)通过对li列表的切片形成新的列表l3,l3 = ['1,2,4,5]li = [1,3,2,'a',4,'b',5,'c'] li3 = li[::2] print(li3)4)通过对li列表的切片形成新的列表l4,l4 = [3,'a','b']li = [1,3,2,'a',4,'b',5,'c'] li4 = li[1:6:2] print(li3)5)通过对li列表的切片形成新的列表l5,l5 = ['c']li = [1,3,2,'a',4,'b',5,'c'] li5 = li[-1] print(li3)6)通过对li列表的切片形成新的列表l6,l6 = ['b','a',3]li = [1,3,2,'a',4,'b',5,'c'] li6 = li[-3:-8:-2] print(li6)
第三题：
3,写代码，有如下列表，按照要求实现每一个功能。 lis = [2,3,'k',['qwe',20,['k1',['tt',3,'1']],89],'ab','adv']1)将列表lis中的'tt'变成大写（用两种方式）。lis = [2,3,'k',['qwe',20,['k1',['tt',3,'1']],89],'ab','adv'] lis[3][2][1][0] = lis[3][2][1][0].upper() print(lis)lis = [2,3,'k',['qwe',20,['k1',['tt',3,'1']],89],'ab','adv'] lis[3][2][1][0] = 'TT' print(lis)2)将列表中的数字3变成字符串'100'（用两种方式）。lis = [2,3,'k',['qwe',20,['k1',['tt',3,'1']],89],'ab','adv'] lis[1] = 100 lis[3][2][1][1] = '100' print(lis)lis = [2,3,'k',['qwe',20,['k1',['tt',3,'1']],89],'ab','adv'] lis[1] = '100' lis[3][2][1][1] = str(lis[3][2][1][1] + 97) print(lis)3)将列表中的字符串'1'变成数字101（用两种方式）。lis = [2,3,'k',['qwe',20,['k1',['tt',3,'1']],89],'ab','adv'] lis[3][2][1][2] = 101 print(lis)lis = [2,3,'k',['qwe',20,['k1',['tt',3,'1']],89],'ab','adv'] lis[3][2][1][2] = 1 + 100 print(lis)
第4题答案
4,请用代码实现：li = ['alex','eric','rain'] 利用下划线将列表的每一个元素拼接成字符串"alex_eric_rain"li = ['alex','eric','rain'] li_new = '_'.join(li) print(li_new)
第5题
查找列表li中的元素，移除每个元素的空格，并找出以'A'或者'a'开头，并以'c'结尾的所有元素，并添加到一个新列表中,最后循环打印这个新列表。
li = ['taibai ','alexC','AbC ','egon',' Ritian',' Wusir',' aqc']
分析：
先输出每一个元素，每把每个元素去除空格
li = ['taibai ','alexC','AbC ','egon',' Ritian',' Wusir',' aqc'] for i in li:s = i.strip()print(s)
执行输出：
taibai alexC AbC egon Ritian Wusir aqc
找到以'A'或者'a'开头的
li = ['taibai ','alexC','AbC ','egon',' Ritian',' Wusir',' aqc']
for i in li:s = i.strip()if s.startswith("A") or s.startswith("a"):print(s)
执行输出：
alexC AbC aqc
并以'c'结尾的，使用endswith()方法。打印出匹配的结果
li = ['taibai ','alexC','AbC ','egon',' Ritian',' Wusir',' aqc']
for i in li:s = i.strip()if s.startswith("A") or s.startswith("a"):if s.endswith("c"):print(s)
执行输出：
aqc
将匹配的元素添加到一个新列表中,最后循环打印这个新列表，最终代码如下：
li = ['taibai ','alexC','AbC ','egon',' Ritian',' Wusir',' aqc']
#定义新列表
li_new = []
for i in li:#去除空格s = i.strip()#找出以'A'或者'a'开头if s.startswith("A") or s.startswith("a"):#找出以'c'结尾的所有元素if s.endswith("c"):#将匹配的元素追加到新列表中li_new.append(s)for j in li_new:print(j)
执行输出：
aqc
第6题
开发敏感词语过滤程序，提示用户输入评论内容，如果用户输入的内容中包含特殊的字符：
敏感词列表 li = ["苍老师","东京热","武藤兰","波多野结衣"]
则将用户输入的内容中的敏感词汇替换成***，并添加到一个列表中；如果用户输入的内容没有敏感词汇，则直接添加到上述的列表中。
解题过程
先定义2个变量，一个是敏感词，一个是用户输入内容
并设置一个含有敏感词的内容，判断是否含有敏感词
li = ["苍老师","东京热","武藤兰","波多野结衣"]
comment = "我要苍老师"
for i in li:if i in comment:print("含有敏感词")
执行输出：
含有敏感词
将敏感词替换成***，使用replace()方法替换，打印出输入内容
li = ["苍老师","东京热","武藤兰","波多野结衣"]
comment = "我要苍老师"
for i in li:if i in comment:print("含有敏感词")comment = comment.replace(i, "***")print(comment)
执行输出：
含有敏感词 我要***
将输入内容写入到新列表中，打印列表：
li = ["苍老师","东京热","武藤兰","波多野结衣"] comment = "我要苍老师" #新列表 comment_list = []for i in li:if i in comment:#将敏感词替换成***comment = comment.replace(i,"***")#添加到新列表 comment_list.append(comment)for j in comment_list:print(j)
执行输出：
我要***
将用户输入替换成input，完整代码如下：
li = ["苍老师","东京热","武藤兰","波多野结衣"]
comment = input("请输入评论：").strip()
#新列表
comment_list = []for i in li:if i in comment:#将敏感词替换成***comment = comment.replace(i,"***")#添加到新列表
comment_list.append(comment)
#打印列表
for j in comment_list:print(j)
执行输出：
第7题
有如下列表li = [1,3,4',alex',[3,7,8,'taibai'],5,'ritian']
循环打印列表中的每个元素，遇到列表则再循环打印出它里面的元素。
我想要的结果是(用两种方法实现，其中一种用range做)：
1 3 4 'alex' 3 7, 8 'taibai' 5 ritian
for循环 代码如下：
li = [1,3,4,'alex',[3,7,8,'taibai'],5,'ritian'] for i in li:#判断是否为列表if type(i) == list:#遍历子列表for j in i:print(j)else:print(i)
执行输出：
1 3 4 alex 3 7 8 taibai 5 ritian
range方式，代码如下：
li = [1,3,4,'alex',[3,7,8,'taibai'],5,'ritian'] for i in range(len(li)):#判断是否为列表if type(li[i]) == list:#遍历子列表for j in li[i]:print(j)else:print(li[i])
执行程序，效果同上。
2，默写第七题的两个方法实现的代码。
for循环 :
li = [1,3,4,'alex',[3,7,8,'taibai'],5,'ritian'] for i in li:#判断是否为列表if type(i) == list:#遍历子列表for j in i:print(j)else:print(i)
range方式：
li = [1,3,4,'alex',[3,7,8,'taibai'],5,'ritian'] for i in range(len(li)):#判断是否为列表if type(li[i]) == list:#遍历子列表for j in li[i]:print(j)else:print(li[i])
