列表

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
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()函数生成的数值

#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:utf8

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)

十六，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 random

ch_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 random

ch_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: utf8

import random

choiceList = ['石头', '剪刀', '布']
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-8

new_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-8

new_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

root@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-8

new_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-8


new_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 -set2

for i in a:   #遍历set2中有的元素，但是set1没有的元素
    print i

有bug的脚本2：这个脚本适合长度一致的文件，一行一条数据；但是行尾出现多个空格，就会有bug

#!/usr/bin/env python
#coding:utf-8


new_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 - set1

a  = set1 - set2

for i in a:
    print i

完善的脚本1：

#!/usr/bin/env python
# coding:utf-8

import re

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('\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 - set1

a = set1 - set2

for i in a:
    print i

完善的脚本2：

#!/usr/bin/env python
# coding:utf-8

import re


p = 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 - set1

a = set1 - set2

for 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])