第六章可变序列-列表

学习要点

学习Python的可变序列的基本操作。
学习以列表为代表的可变序列的基本操作。

对标内容

理解列表类型的概念，掌握它的基础用法及操作：访问/更新、获取元素个数、遍历、转换为列表型数据、添加和删除、连接、排序等。

情景导入

考试结束了，一般要进行成绩统计和查找。为了提高查找的效率，我们一般会采用表格来记录这些数据。像这种用表格记录数据的情况，在我们生活中有很多，火车站的列车时刻表、飞机场的飞机起落信息表、餐馆里面的价目表等都是例子，我们在科学课上也借助表格进行过实验数据的统计。那么在Python中该如何表示这些表格中的数据呢？列表是一个非常好的选择。

列表

列表的应用场景

思考：有一个人的姓名(TOM)怎么书写存储程序？

答：变量。

思考：如果一个班级100位学⽣生，每个人的姓名都要存储，应该如何书写程序？声明100个变量量吗？

答：列表即可，列表一次性可以存储多个数据。

什么是列表

列表是Python中内置的有序、可变序列，列表的所有元素放在一对中括号“［］”中，并使用逗号分隔开。

列表的数据项不需要具有相同的类型。

列表的创建

列表的创建有多种方式，最常见的方式有两种：

一种是直接建立，创建时只需要将元素用逗号隔开，并且用中括号括起来就可以了，如下：

a=[1,'a',(3,5),2]

另一种则是使用list命令进行创建，list()用于将元组或字符串转换为列表，如下：

>>> list('Python')
['P', 'y', 't', 'h', 'o', 'n']

序列的通用操作

所谓序列，指的是一块可存放多个值的连续内存空间，这些值按一定顺序排列，可通过每个值所在位置的编号(称为索引)访问它们。

Python包含6种内建的序列，即列表、元组、字符串、Unicode字符串、 buffer对象和xrange对象。目前需要掌握列表、元组、字符串3种序列，Unicode字符串、 buffer对象和xrange对象不要求掌握。

下面我们以列表为例，看看序列都有哪些通用操作。

通用操作一序列的访问

列表是序列的一种，所以所有的元素都是有序号的，我们称序号为索引。

索引有两种表示方式，一种是从前往后的正方向索引，还有一种为从后往前的反方向索引。

正方向索引的第一个索引号为0，并非1，后面的索引号依次为1、 2……

反方向的索引，第一个索引号为-1，接下来依次为-2、-3……如图6-1 所示。

要访问列表中的值，只需要使用列表变量名加上下标(索引号)即可, 访问图6-1中第三个元素的值，只需要使用t[2]或者t[-3]即可。

>>> t=['a', 'b', 'c', 'd', 'e']
>>> t[2]
'c'
>>> t[-3]
'c'

通用操作一序列的嵌套

序列里面可以再套序列，这叫作序列的嵌套。被嵌套的序列是作为一个整体看待的，所以其下标为一个，如下例所示。

>>>list = ["a","b",[l,2,3],"c"]
>>>list[2]
[1,2,3]

在该案例中，[1,2,3]是作为一个整体看待的，是列表list的第3个元素，所以list[2]的值为[1,2,3]。

如果需要单独访问嵌套列表中的值，则需要进行列表下标的逐级分解，如下例所示，假设需要访问列表中的2。

>>>list = ["a","b", [l,2,3],"c"]
>>>list[2][1]    #第一个下标代表嵌套列表在整个列表中的位置，第二个下标代表2的位置
2

通用操作一序列的截取

你可以使用索引下标来访问列表中的值，也可以使用中括号[]的形式截取序列，要将图6-2中的第2个元素到第4个元素截取下来，则需要使用t[1,4]。

图6-2序列的截取

列表的截取又称作列表的切片，它需要使用两个索引下标来确定切片的起始位置和结束位置。

列表的截取格式为：变量[头下标：尾下标：步长]，其中步长为可选参数，如果没有步长参数，则代表步长为1；如果切片是从头开始或者是到最后结束，头下标和尾下标也可以没有，示例如下。

>>> t = ['a', 'b', 'c', 'd', 'e']
>>> t[:3]
['a', 'b', 'c']
>>> t[3:]
['d', 'e']
>>> t[-3:]
['c', 'd', 'e']

但是要注意：列表的切片不包含尾部下标对应元素的值，但如果冒号后面没有数字则代表包含最后一个列表元素的值。

例如对于图6-2， t[1:3]返回的值是[b,'c']而不是['b','c','d']，t[3：]返回的值是['d','e']。

注意：

1. 步长是选取间隔，正负整数均可，默认步长为1，正为从左往右，负为从右往左；
2. 开始位置下标/结束位置下标，正负整数均可，值为负代表从左往右倒数几个元素；
    开始位置下标：默认第一个元素，步长为负数时，默认最后一个元素
    结束位置下标：默认最后一个元素，步长为负数时，默认第一个元素
3. 不包含结束位置下标对应的数据
4. 切片始终以开始位置下标为开始，结束位置下标结束，确保切片[开始位置下标: 结束位置下标]区间有值，否则为空表

示例：

list1 = [1,2,3,4,5,6,7,8,9,10]
print(list1[2:8:3]) #[3, 6]
print(list1[2:8])   #[3, 4, 5, 6, 7, 8]
print(list1[2:])    #[3, 4, 5, 6, 7, 8, 9, 10]
print(list1[:])     #[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(list1[:-6:-1])#[10, 9, 8, 7, 6]

通用操作len()—取序列的长度

取一个序列的长度的命令为len()，返回值为该序列的元素的个数，如下例所示。

>>>T = [1,2,3,4,5]
>>>len(T)
5

如果有序列嵌套的情况，被嵌套的序列是作为一个整体来计算的，如下例所示。

>>>T = [1,2,3, ["a","b","c"],4,5,(10,9,8)]
>>>len(T)
7

通用操作in—检查元素是否包含在序列中

如果序列比较庞大，或者序列是在不断更新中，如何检查某一个元素是否在该序列中？需要使用in命令进行判断，其返回值是True或者False。所以往往该命令是结合条件语句使用的，如下例所示。

>>> T = [1,2,3,(10,9,8)]
>>> print(2 in T)
True
>>> print(8 in T)
False
>>> print((10,9,8) in T)
True

上例中，表面看有元素8，怎么返回值是False呢？这是因为8是在列表的嵌套元素(10,9,8)中，而in不检查序列嵌套元素里面的值，所以结果是False。

通用操作max()—找出序列中的最大元素

max()函数用来找出序列中的最大值，但要注意以下3点。

当序列内的元素均为数字类型时，max()将返回该序列里最大的数字，如下例所示。
```
>>> T = [21,2,3,4,5,8,0]
>>> print(max(T))
21
```
当序列内的元素均为字符串类型时，max()则是按照Unicode编码的顺序(具体见字符串相关内容)返回编码最大的元素，如下例所示。
```
>>>T = ["A", "a", "d", "2", "Python","我"]
>>>print(max(T))
我
```

当序列内既有数字类型，又有其他类型的元素时，max()是无法进行运算的，会报错，如下例所示。

>>> T = ["A", "a", "d", 2, "1"]
>>> max(T)
Traceback (most recent call last):
  File "<pyshell#1>", line 1, in <module>
    max(T)
TypeError: '>' not supported between instances of 'int' and 'str'

通用操作min()—找出序列中的最小元素

min()函数和max()函数的功能刚好相反，是找出序列中的最小元素。它和 max()函数一样，只能在序列内的元素均为数字类型或者均为字符串类型时才可以使用。

元素均为数字类型时：

>>> T = [21,2,3,4,5,8,0]
>>> print(min(T))
0

元素均为字符串类型时：

>>> T = ["A", "a", "d", "2", "Python","我“]
>>> print(min(T))
2

通用操作sum()—序列求和运算

sum()函数可以对全部由数字类型组成的序列进行求和，输出的结果为该序列所有数字的和，如下例所示。

>>>T = [21,2,3,4,5,8,0]
>>>print(sum(T))
43

说明：全部由数字类型组成的序列才能进行求和

通用操作一序列的加法运算

同一种类型的序列是可以进行加法运算的，但是这里的加法不同于数学中的加法，序列的加法相当于将两个序列结合在一起，如下例所示。

>>>T = [21,2,3,4,5,8,0]
>>>t = ['a', 'b', 'c']
>>>print (T+t)
[21,2,3,4,5,8,0,'a','b','c']

通用操作—序列的乘法运算

序列也可以进行乘法运算，但是序列只能和正整数相乘，代表的是将该序列重复正整数次，如下例所示。

>>>T = ['a', 'b', 'c', 'd']
>>>print(T*2)
['a', 'b','c','d','a','b','c','d']
>>> T*0
[]

列表的专用操作

更新列表中的值

列表值的更新又称作修改列表中的值，可以直接使用列表名加下标进行赋值，如下例所示。

>>>List = ['a','b','c','d','e']
>>>List[2] = 'aa'
>>>List
['a','b','aa','d','e']

利用列表切片技术，列表的值也可以同时更新多个，如下例所示。

>>> List =  ['a','b','c','d','e']
>>> List [1:4] = [1,2,3]
>>> List
['a', 1, 2, 3, 'e']

>>> List2 =  ['a','b','c','d','e']
>>> List2[0:5:2]
['a', 'c', 'e']
>>> List2[0:5:2]=[1,2,3]
>>> List2
[1, 'b', 2, 'd', 3]

列表元素的删除

删除列表中的值有多种方法，主要的有以下4种方法。

del()

作用：删除列表中的指定下标的值，如果没有指定下标，则是删除整个变量。

格式：del list_name(index)

参数：list_name代表列表名，index代表下标(可省略)，如下例所不。

删除单个元素

>>> List =  ['a','b','c','d','e']
>>> del List[1]
>>> List
['a', 'c', 'd', 'e']

>>> List =  ['a','b','c','d','e']
>>> del(List[4])
>>> List
['a', 'b', 'c', 'd']

说明：两种写法：

del List[0]

del(List[0])

删除整个列表

>>> List =  ['a','b','c','d','e']
>>> del List
>>> List
NameError: name List is not defined # 报错，没有找到'List'

pop()

作用：删除指定下标的元素，并返回被删除元素的内容，如果没有指定下标，则默认删除最后一个元素。

格式：list_name.pop(index)。

参数：list_name代表列表名，index代表下标，如下例所示。

>>> List = ['a', 'b', 'c', 'd', 'e']
>>> List.pop(1)
'b'
>>> List
['a', 'c', 'd', 'e']
>>> List = ['a', 'b', 'c', 'd', 'e']
>>> List.pop()
'e'
>>> List
['a', 'b', 'c', 'd']

>>> List = ['a', 'b', 'c', 'd', 'e']
>>> List.pop(2)
'c'
>>> List
['a', 'b', 'd', 'e']

remove()

作用：移除列表里面第一次出现的指定值的元素。我们有时候需要删除某一个元素，但是不知道它在列表的什么位置，这时候使用remove()最合适。

格式：list_name.remove(obj)。

参数：list_name代表列表名，obj代表需要移除的元素的值，但是需要注意的是，一定要确保obj在列表里，否则会报错ValueError，如下例所示。

>>> List = ['a', 'b', 'c', 'd', 'e']
>>> List.remove('c')
>>> List
['a', 'b', 'd', 'e']
>>> List = ['a', 'b', 'c', 'd', 'e']
>>> List.remove('f')
ValueError: list.remove(x) : x not in list # 报错

注意：

只会删除第一个

如果删除的元素不存在，则报错

clear()

作用：清除列表所有的元素，但是不删除列表，只是列表为空。

格式：list_name.clear()。

参数：list_name代表列表名。由于是清除列表里面的所有元素，所以该命令没有参数，如下例所示。

>>> List = ['a', 'b', 'c', 'd', 'e']
>>> List.clear()
>>> List
[]    #列表List依然存在，但是为空列表

添加列表元素

向列表里添加元素，主要有两种方法。

append()

作用：将元素添加到列表的末尾。

格式：list_name.append(obj) 。

参数：list_name代表列表名称；obj代表要插入的元素，元素可以是单个数据，也可以是列表、元组等，如下例所示。

>>> List = ['a', 'b', 'c', 'd', 'e']
>>> List.append(1)
>>> List
['a', 'b', 'c', 'd', 'e', 1]

insert()

作用：将元素插入指定的位置。

格式:list_name.insert(index, obj)。

参数：list.name代表列表名称；index代表列表的下标，该参数只能为整数； obj代表需要插入的元素，如下例所示。

>>> List = ['a', 'b', 'c', 'd', 'e']
>>> List.insert(2,"Python")
>>> List
['a', 'b', 'Python', 'c', 'd', 'e']

>>> List = ['a', 'b', 'c', 'd', 'e']
>>> List.insert(100,'f')
>>> List
['a', 'b', 'c', 'd', 'e', 'f']

注意：

如果指定索引比列表长度大，不会报错，会添加到最后。

查找元素

index()

作用：查找元素在列表中的位置，返回值为该元素在列表中的下标。

格式：list_name.index(obj, start, end)。

参数：list_name代表列表名称，obj代表要查找的元素的值，start代表开始查找的位置，end代表结束查找的位置。start, end为非必要选项，如果没有，则代表在整个列表里进行查找，如下例所示。

>>> List = ['a', 'b', 'c', 'd', 'e']
>>> List.index("c")
2
>>> List2 = ['a', 'b', 'c', 'd', 'e', 'a', 'b']
>>> List2.index("a")
0
>>> List2.index("a",2,6)
5

注意事项：index()查找的元素必须已经在列表中，如果该元素不存在，则会导致ValueError错误。

count()

作用：统计某个元素在列表中出现的次数，返回值为该元素的个数。

格式：list_name.count(obj)。

参数：list_name代表列表名，obj代表需要统计的元素，如下例所示。

>>> List = ['a', 'b', 'c', 'd', 'e', 'a', 'b']
>>> List.count('a')
2

注意事项：如果count()查找的对象不存在，则返回值为0，不会报错。

列表的排序

sort()

作用：对原列表进行排序，不返回新列表。如果指定参数，则使用指定的比较函数进行排序。

格式：list_name.sort(cmp=None, key=None, reverse=False)。

参数：list_name表示列表名称；cmp、key, reverse均为可选参数，cmp、key参数不要求掌握，这里不再赘述；reverse代表是否翻转，默认为不翻转(False )，如下例所示。

>>> List = ['e', 'b', 'a','d', 'c', 'f']
>>> List.sort()
>>> List
['a', 'b', 'c', 'd', 'e', 'f']

>>> List2 = ['e', 'b', 'a','d', 'c', 'f']
>>> List2.sort(reverse=True)
>>> List2
['f', 'e', 'd', 'c', 'b', 'a']

注意事项：

①sort()函数是在原内存地址上进行排序，所以sort()函数排序后会直接和原列表名进行绑定，会改变原列表的值；

②sort()函数和求最值函数max()、min()函数一样，要求待排列对象必须为同一类型，常见的为数字类型和字符串类型；

③字符串类型在排序时是按照Unicode码顺序进行的，具体请参考字符串相关章节；

④sort()函数默认是按照从小到大的顺序进行排列，字符串是按照Unicode 码从小到大的顺序排列，如下例所示；

>>> List = [122,23,1,9,-34,546,12.3]
>>> List.sort()
>>> List
[-34, 1, 9, 12.3, 23, 122, 546]

⑤ 如果 sort()加入了 reverse 参数，格式为 list_name.sort(reverse=1)或者list_name.sort(reverse=True)，其工作原理是首先将列表按照从小到大的顺序进行排序，然后再进行翻转，这样就形成了从大到小的倒序排序，如下例所示。

>>>List = [122,23,1,9,-34,546,12.3]
>>>List.sort(reverse=True)
>>>List
[546, 122, 23, 12.3, 9, 1, -34]

sorted()

作用：对可迭代的对象进行排序操作，会生成新的列表。

格式：sorted(iterable, cmp=None, key=None, reverse=False)。

参数：iterable为可迭代对象(在列表中即列表名)；cmp和key不要求掌握，在此不赘述；reverse代表是否翻转，默认为不翻转(False )，如下例所示。

>>> List = [122,23,1,9,-34,546,12.3]
>>> NewList = sorted(List,reverse=True)
>>> List
[122, 23, 1, 9, -34, 546, 12.3]
>>> NewList
[546, 122, 23, 12.3, 9, 1, -34]

注意事项： ① sorted()和sort() 一样，对待排序的对象有相同的要求；

② sorted()不是在原内存地址进行排序，是新建一个列表，所以不改变原来的列表值。

reverse()

作用：reverse()函数也是列表中的内置函数，用于反向排列列表中的元素。

格式：list_name.reverse() 。

参数：list_name代表列表名。

注意事项：reverse()并不进行排序，而是将列表里的元素进行顺序上的前后颠倒；另外，reverse()和sort()一样：都是在原列表中进行操作，所以没有返回值，但是会改变原列表的值，如下例所示。

>>> List = [122,23,1, 9,-34,546,12.3]
>>> List.reverse()
>>> List
[12.3, 546, -34, 9, 1, 23, 122]

注意：reverse不进行排序，只是前后颠倒。

列表的循环遍历

需求：依次打印列表中的各个数据。

while方法遍历

代码

name_list = ['Tom', 'Lily', 'Rose']
i = 0
while i < len(name_list):
    print(name_list[i])
    i += 1

执行结果

Tom
Lily
Rose

for方法遍历

代码

name_list = ['Tom', 'Lily', 'Rose']
for i in name_list:
    print(i)

执行结果
```
Tom
Lily
Rose
```

易错点

一个列表中的数据类型可以各不相同，可以同时分别为整数、浮点数、字符串等基本类型，甚至是列表、元组、字典、集合以及其他自定义类型的对象。
在嵌套的列表中，被嵌套的列表被作为一个整体看待。
求序列的最大值、最小值，要求序列内所有元素必须同时为数字类型或者是字符串类型，不能混合，且不能嵌套，否则会报错。
只有纯数字类型的序列才可以进行求和运算。
clear()和del()的区别：首先，del()中，列表名是在后面的括号中； clear()中，列表名是在clear()的前面，并且用.隔开。其次，del()可以只删除一个元素，如果不指定下标，只注明列表名，则删除整个变量，所以，列表也就不存在了；而clear()是清除列表里的所有元素，列表还在，只是为空，此时列表长度为0。
append() 一次只能追加一个元素到列表里面，如果追加的是列表或者元组，则是作为一个整体进行追加，如下例所示。
```
>>> List = ['a', 'b', 'c', 'd', 'e']
>>> List.append([1,2,3])
>>> List
['a', 'b', 'c', 'd', 'e', [1, 2, 3]]
```
sorted()和sort()的区别：sorted()是Python的内置函数，可用于所有可迭代对象；而sort()是列表的内置函数，仅用于列表的排序。列表的sort() 方法是对已经存在的列表进行操作，无返回值；而内置函数sorted()返回的是一个新的列表，而不是在原来的基础上进行的操作，所以不改变原列表的值。

模拟考题

考题1 单选题

已知列表a=[1,2,3], b=['4'],执行语句print(a+b)后，输出的结果是( )。

A. [1,2,3,4] B. [1,2,3,'4'] C. [T,'2','3','4'] D. 10

答案：B

解析：这是一个列表加法运算的题目，根据列表加法运算规则，加法运算是把后面的列表补充到前一个列表的后面，在补充时是不改变原列表中元素的数据类型的，所以，当['4']补充到列表a的后面时依然还是4,不能变成4,所以选择B。

考题2 单选题

列表 listV = list(range(10))，以下能够输出列表listV中最小元素的语句是（）。

A. print(min(listV)) B. print(listV.max()) C. print(min(listV())) D. print(listV.reveres()[0])

答案：A

解析：这是一道有多个考核点的题目，第一个考核点是新建列表的方式，list()函数就是将其他数据类型转换为列表；第二个考核点是range(10)生成的可迭代对象是0~9的整数，所以题目中的list(range(10))生成的列表为 [0,1,2,3,4,5,6,7,8,9]；第三个考核点是列表求最小值函数，该函数为min()，所以选择A。其他选项出错原因：B选项是求最大值并且格式错误；C选项的格式是错误的，listV是列表名，后面不能有括号；D选项的拼写和语法都是错误的，正确的拼写应该为listV.reverse()并且作为列表内置函数，不可以在后面加下标[0], 即使可以加，但是由于reverse()进行了翻转，第一个元素成了 9，并非最小的0。

考题3 单选题

运行如下程序，结果是()。

l=[1,"laowang",3.14,"laoli"]
l[0]=2
del l[1]
print(l)

A. [1, 3.14, 'laoli'] B. [2, 3.14, 'laoli'] C. ["laowang",3.14, 'laoli'] D. [2,"laowang",3.14,]

答案：B

解析：根据题意，我们逐条分析程序运行结果。程序运行第二行l[0]=2后，l列表变成了 [2,"laowang",3.14,"laoli"]；第三行del l[1]删除第二个元素，运行后，l变为[2,3.14,"laoli"],所以正确答案为B。

考题4 单选题

关于列表s的相关操作，描述不正确的是()。

A. s.append()：在列表末尾添加新的对象 B. s.reverse() :反转列表中的元素 C. s.count()：统计某个元素在列表中出现的次数 D. s.clear()：删除列表s的最后一个元素

答案：D

解析：clear()的作用是清除列表里面的所有元素，而并非最后一个元素。

考题5 单选题

已知列表lis=[T,'2‘,3],则执行print(2 in lis)语句输出的结果是()。

A. True B. true C. False D. false 答案：C

解析：首先选项B和D不符合Python的返回值的格式要求，排除在外；其次，根据题意，貌似2在列表中，但仔细观察，列表里的是字符串格式的2，而并非数字格式的2,那当然2 in list无法返回True，所以选择C。

考题6 单选题

运行如下代码，结果是()。

>>> l=["a",1,"b",[1,2]]
>>> print(len(l))

A. 3 B. 4 C. 5 D. 6

答案：B

解析：嵌套列表中，被嵌套的列表是被当作一个整体看待，所以[1,2]在整个大列表中是一个元素，加上前面的元素，一共有4个元素，len(l)的结果为4。

考题7 单选题

已知有列表a = [1, 2, 3, 4, 5]，以下语句中，不能输出[5, 4, 3, 2, 1]的是 ()。

A. print(a[:-6:-1]) B. print(a.sort(reverse=True)) C. print(sorted(a, reverse=True)) D. print([5, 4, 3, 2, 1])

答案：B

解析：从题目要求可知，输出的结果是原列表的反向排序。A选项a[:-6:-1]是从最后一个元素到倒数第6个元素(不含)，以步长为-1的形式取值，虽然列表a中只有5个元素，但是由于a[:-6:-1]不含第6个元素，所以不会报错, 因而A选项可以生成列表[5, 4, 3, 2, 1]； C选项是将a列表进行反向排序，所以也符合输出要求；D选项直接输出目标列表，自然符合要求；B选项看似也是将a列表反向排序，但是使用的是a.sort(reverse=True), sort()函数是没有返回值的，其作用是将原列表a进行排序，所以B选项要想输出目标列表，需要改成a.sort(reverse=True)，print(a)才可以。

考题8 单选题

已知列表a=[1,2,3,4,5]，执行a.insert(2,6)后结果是()。

A. [1,2,3,4,5,2,6] B. [1,2,3,4,5,6] C. [1,2,6,3,4,5] D. [1,2,3,6,4,5]

答案：C

解析：a.insert(2,6)的意思是在下标为2的位置插入一个元素6，所以正确答案是C。

列表单元测试题

模拟考题

一、单选题(共25题，每题2分，共50分)

1、已知列表a=[1, 2, '3']，执行语句print(a*2)后，输出的结果是？（）

A. [1, 2, '3', 1, 2, '3'] B. [1, 2, '3'] C. [2, 4, '6'] D. [1, 2, '3'，2]

2、下列属于列表的是？（）

A. str="python" B. list = ['1', '2', '3'] C. tup= ('1', '2', '3') D. dict = {'a': 1, 'b': 2, 'b': '3'}

3、数学课代表将同学们的数学成绩存放在列表S1中，s1=[99,92,87,90,100,95]，如果按照成绩由低到高输出，以下哪个程序可以实现？（）

s1=[99,92,87,90,100,95]
s2=sorted(s1) 
print(s2)

s1=[99,92,87,90,100,95] 
s2=sort() 
print(s2)

s1=[99,92,87,90,100,95] 
sort(reverse=True) 
print(s1)

s1=[99,92,87,90,100,95] 
s2=sorted(s1,reverse=True) 
print(s2)

4、

list1=[1,3,4] 
list2=[3,5,2] 
(list1+list2)*2

的值为？（）

A. [8,16,12] B. [1,3,4,3,5,2,1,3,4,3,5,2]

C. [1,3,4,1,3,4,3,5,2,3,5,2] D. [2,6,8,6,10,4]

5、有如下Python程序段：

lista=[1,2,3,4,5,6,7,8,9,10]
s=0
for i in range(0,len(lista),2):
    s=s+lista[i]
print("s=",s)

执行程序段后，输出的结果为？（）

A. 25 B. s=25 C. s=30 D. s=55

6、以下程序的运行结果是？（）

l =["兰溪","金华","武义","永康","磐安","东阳","义乌","浦江"]
for s in l:
    if"义"in s:
          print(s)

A. 兰溪金华武义 B. 武义义乌 C. 武义 D. 义乌

7、已知列表a=[1,2,3,4,5]，下列语句输出结果为False的是？（）

A. print(a[3]==a[-2]) B. print(a[:3]==a[:-2])

C. print(a[:1]==a[0]) D. print(a[2]==a[-3])

8、numbers = [1, 3, 2, 8], numbers[len(numbers) - 1]会返回什么？（）

A. 1 B. 3 C. 2 D. 8

9、执行下列代码后，运行结果是？（）

seq=['hello','good','morning']
s='*'.join(seq)
print(s)

A. hello*good*morning*

B. *hello*good*morning

C. hello*good*morning

D. hello\good*morning*

10、以下代码输出结果是？（）

ls = [888,'note',[2021,'Python',123],20]
print(ls[2][1])

A. note

B. Python

C. 2021

D. 结果错误

11、列表a=[1,2,3,4,5,6,7,8,9],对列表进行切片操作，要想得到[3,5,7]，以下切片正确的是？（）

A. a[-7:-2:-2]

B. a[2:7:2]

C. a[3:7:2]

D. a[2:7:-2]

12、若li=list(range(1,10,2))，则print(li)的结果是？（）

A. [0,2,4,6,8,10]

B. [1,3,5,7,9]

C. [1,2,3,4,5,6,7,8,9,10]

D. [0,2,4,6,8]

13、已知列表list9=[114,5,14,1,91,98,10]，下列说法错误的是？

A. print(max(list9))可以输出列表的最大值，输出结果为114

B. print(min(list9))可以输出列表的最小值，输出结果为1

C. print(list9.index(98))可以输出数值98第一个匹配项的索引位置，输出结果为6

D. list9.pop()可以移除列表中的最后一个元素

14、若s=["中国","I love you",[2022,100]]，则len(s)的值是？

A. 3

B. 4

C. 2022

D. ”中国“

15、关于Python中的列表，下列描述错误的是?( )

A. 列表是Python中内置可变序列，是若干元素的有序集合；

B. 列表中的每一个数据称为“元素”；

C. 在Python中，一个列表中的数据类型可以各不相同；

D. 可以使用s[1]来获取列表s的第一个元素。

16、以下代码的输出结果是?( )

ls = []
for m in '想念':
    for n in '家人':
        ls.append(m+n)
print(ls)

A. ["想念","家人"]

B. ["想想","念念","家人"]

C. ["想家想","人念家","念人"]

D. ["想家", "想人", "念家", "念人"]

17、下面代码的输出结果是?( )

list1 = [1,2,3]
list2 = [4,5,6]
print(list1+list2)

A. [4,5,6]

B. [1, 2, 3, 4, 5, 6]

C. [1,2,3]

D. [5,7,9]

18、执行以下程序

a=[33,55,22,77]
a.sort()
for i in a:
    print(i)

运行结果是？（）

A. 33 55 22 77

B. 22 33 55 77

C. 55 33 22 77

D. 77 55 33 22

19、下面程序的输出结果是？（）

a=[[1,2,3],[4,5,6]]
a.sort(reverse=True)
print(a)

A. [[4,5,6],[1,2,3]]

B. [6,5,4],[3,2,1]

C. [[6,5,4],[3,2,1]]

D. [4,5,6],[1,2,3]

20、已知a=list("zhangsan"),执行了a[1:7:2]后结果是？

A. [ 'h', 'a', 'n', 'g', 's', 'a', 'n']

B. ['z', 'h', 'a', 'n', 'g', 's', 'a']

C. [ 'h', 'a', 'n', 'g', 's', 'a']

D. ['h', 'n', 's']

21、下列关于Python列表的表达正确的是？

A. Python列表是包含0个或者多个对象引用的有序序列

B. python列表用小括号（）表示

C. 列表的长度是不可变的

D. Python列表的元素间用顿号、隔开

22、以下代码的输出结果是？（）

s= list(range(10))
print(10 not in s)

A. True

B. False

C. 0

D. -1

23、下列说法错误的是？

A. 列表的大小是固定的，不可以改变

B. len()方法可以返回列表的元素个数

C. 假设list2列表有十个元素，则list2[2]可以读取list2列表中的第三个元素

D. 列表的数据项不需要具有相同的类型

24、在空格处填入以下哪个语句，不能得到从大到小的排序结果是？（）

list1 =[1,5,9,67,4,44,99]
for i in range(2):
    a = int(input())
    list1.append(a)
______________
for i in list1:
    print(i,end = " ")

A. list1.sort()

B. list1 = sorted(list1,reverse=True)

C. list1.sort(reverse=True)

D. list1.sort() ; list1 = list1[-1::-1]

25、下列关于列表变量ls操作的描述中，错误的是？（）

A. min(ls):找出ls中最小元素

B. ls.remove(x):删除ls中所有x元素

C. ls.index(x):返回元素x在列表中的下标

D. ls.copy():生成一个新列表，复制ls的所有元素

二、判断题(共10题，每题2分，共20分)

26、d=( )，d是一个空列表。

正确错误

27、在Python中range,表示一个整数序列，对于浮点型和字符串类型是无效的。

正确错误

28、count() 方法用于统计某个元素在列表中出现的次数。

正确错误

29、if [3] in [1, 2, 3, 4]:与if 3 in [1, 2, 3, 4]:结果是一样的。

正确错误

30、片操作list(range(10))[0:8:2] 执行结果为（[0, 2, 4, 6，8]）

正确错误

31、运行下列代码后，list1的值为['a',1,2,3,7]。

 list1=[1,3,'a',2,7]
 list1.sort()

正确错误

32、不同类型的元素可以存储在同一个列表中。

正确错误

33、print(list) 打印空列表会提示错误。

正确错误

34、表达式[3] in [1,2,3]的值为True.( )

正确错误

35、[1,2] in [1,2,3,4,5,6]的结果为True

正确错误

三、编程题(共2题，共30分)

36、这次作文大赛，获得一等奖的同学有：“小张，小王，小强，小李，小周，小芳，小兰”。

请编程实现，输入某个同学的名字进行查找，是否在一等奖的同学名单里。

37、用编程实现对该列表[34,17,7,48,10,5]的处理

要求;把该偶数和奇数分别存储到新的列表中

答案

一、单选题

1、A 2、B 3、A 4、B

5、B

试题解析：本程序的功能是求[1,10]区间内的奇数之和，因此结果为25，答案为B。

6、B

试题解析：本题的意思是输出列表中所有带有义的元素，武义和义乌都符合，所有选择B

7、C 8、D

9、C

试题解析：理解用join方法连接字符串的方式

10、B 11、B 12、B 13、C 14、A 15、D

16、D 17、B 18、B 19、A 20、D 21、A

22、A 23、A

24、A

试题解析：本题主要考查列表的排序操作，sort()和sorted()函数都可以实现排序，但是两个函数只能实现从小到大的排序操作，所以这里需要将序列反向排列，A选项只做了排序，故选择A.

25、B

试题解析：本题考查列表中的min、remove、index、copy等操作，选项B中的remove移除的是列表中第一次出现的x元素，所以选择B。

二、判断题

26、错误 27、正确 28、正确 29、错误 30、错误

31、错误 32、正确 33、错误 34、错误 35、错误

三、编程题

36、参考程序：

li=['小张','小王','小强','小李','小周','小芳','小兰'] 
s=input('请输入获一等奖选手姓名：') 
if s in li: 
    print(s,'同学获得一等奖！')
else:
    print(s,'同学没有获得一等奖！')

37、参考程序：

a=[34,17,7,48,10,5]
b=[]
c=[]
while len(a)>0:
    s=a.pop()
    if  (s%2==0):
        b.append(s)
    else:
        c.append(s)
print(b)
print(c)

第六章 可变序列-列表

学习要点

对标内容

情景导入

列表

列表的应用场景

什么是列表

列表的创建

序列的通用操作

通用操作一序列的访问

通用操作一序列的嵌套

通用操作一序列的截取

通用操作len()—取序列的长度

通用操作in—检查元素是否包含在序列中

通用操作max()—找出序列中的最大元素

通用操作min()—找出序列中的最小元素

通用操作sum()—序列求和运算

通用操作一序列的加法运算

通用操作—序列的乘法运算

列表的专用操作

更新列表中的值

列表元素的删除

del()

pop()

remove()

clear()

添加列表元素

append()

insert()

查找元素

index()

count()

列表的排序

sort()

sorted()

reverse()

列表的循环遍历

while方法遍历

for方法遍历

易错点

模拟考题

列表单元测试题

模拟考题

答案

第六章可变序列-列表