列表

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包含以下函数:

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

Python包含以下方法:

序号方法
1list.append(obj)
在列表末尾添加新的对象
2list.count(obj)
统计某个元素在列表中出现的次数
3list.extend(seq)
在列表末尾一次性追加另一个序列中的多个值(用新列表扩展原来的列表)
4list.index(obj)
从列表中找出某个值第一个匹配项的索引位置
5list.insert(index, obj)
将对象插入列表
6list.pop([index])
移除列表中的一个元素(默认最后一个元素),并且返回该元素的值
7list.remove(obj)
移除列表中某个值的第一个匹配项
8list.reverse()
反向列表中元素
9list.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])

 

Logo

权威|前沿|技术|干货|国内首个API全生命周期开发者社区

更多推荐