计算机二级Python选择题题库 第四章 组合 共97题 带答案和解析

第四章 组合 共97题
1.以下关于Python列表的描述中，错误的是_×√
O列表的长度和内容都可以改变，但元素类型必须相同
O可以对列表进行成员关系操作、长度计算和分片
O列表可以同时使用正向递增序号和反向递减序号进行索引
O可以使用比较操作符(如>或<等)对列表进行比较
答案：选a
列表没有长度限制，元素类型可以不同，不需要预定义长度。

2. 以下关于Python字典的描述中，错误的是××
   O在定义字典对象时，键和值用冒号连接
   O在Python中，用字典来实现映射，通过整数索引来查找其中的元素
   O字典中的键值对之间没有顺序并且不能重复
   O字典中引用与特定键对应的值，用字典名称和中括号中包含键名的格式
   答案：选b
   python语言中通过字典类型实现映射。
   由于字典元素"键值对"中键是值的索引。
   因此，可以直接利用键值对关系索引元素。
   字典是存储可变数量键值对的数据结构，键和值可以是任意数据类型，通过键索引值，并可以通过键修改值。

3.以下用来处理Python列表的方法中，错误的是_××
O interleave
O append
O insert
O replace
答案：选a
append(x)：在列表最后增加一个元素x。
insert(i,x)：在列表第i位置增加元素x。
interleave()是Dataset的类方法，所以interleave是作用在一个Dataset上的，不是作用在列表上的。

4.以下代码的输出结果是______。√√
ls = [‘book’,23,[2010,‘studl’],20]
print(ls[2][1][-1])
O s
O studl
O 1
O结果错误
答案：选c
索引是列表的基本操作，用于获得列表中的一个元素。该操作沿用序列类型的索引方式，即正向递增序号和反向递减序号，使用中括号作为索引操作符，索引序号不能超过列表的元素范围，否则会出现IndexError错误。正向递增序号从0开始，反向递减序号从-1开始。
ls[2][1][-1]的执行过程：[2010,‘stud1’]-> stud1->1，即最后的结果是"1"。

5.以下代码的输出结果是______。××☆
d = {‘food’:{‘cake’:1,‘egg’:5}}
print(d.get(‘cake’,‘no this food’))
O egg
O 1
O food
O no this food
答案：选d
d.get(key,default)根据键信息查找并返回值信息。
如果key存在则返回相应值，否则返回默认值。
代码d.get(‘cake’,‘no this food’)运行时找不到键"cake"，因为这个元祖d里面就只有一个food键，所以输出结果：no this food；
但是如果将代码d.get(‘cake’,‘no this food’)修改为d[‘food’][‘cake’]，运行后输出结果：1。

26.以下代码的输出结果是______。×√
a = [[1,2,3], [4,5,6], [7,8,9]]
s = 0
for c in a:
for j in range(3):
s += c[j]
print(s)
答案：选d
Python通过保留字for实现遍历循环，使用方法如下：
for <循环变量> in <遍历结构>
<语句块>
遍历循环可以理解为从遍历结构中逐一提取元素，放在循环变量中，对于每个所提取的元素执行一次语句块。for语句的执行次数是根据遍历结构中元素个数确定的。
使用range()函数，可以指定语句块的循环次数。
题目中的代码循环过程如下：
c=[1,2,3]，j=0，c[0]=1，s=1；
c=[1,2,3]，j=1，c[1]=2，s=3；
c=[1,2,3]，j=2，c[2]=3，s=6；
c=[4,5,6]，j=0，c[0]=4，s=10；
c=[4,5,6]，j=1，c[1]=5，s=15；
c=[4,5,6]，j=2，c[2]=6，s=21；
c=[7,8,9]，j=0，c[0]=7，s=28；
c=[7,8,9]，j=1，c[1]=8，s=36；
c=[7,8,9]，j=2，c[2]=9，s=45。

7.在Python语言中，不属于组合数据类型的是_。√√
O列表类型
O字符串类型
O复数类型
O字典类型
答案：选c
Python语言中的组合数据类型包括集合类型、序列类型（列表类型）和映射类型（字典类型），而复数类型属于基本数据类型中的数字类型。

8.以下代码的输出结果是______。√√
vlist = list(range(5))
print(vlist)
O 0;1;2;3;4;
O 0 1 2 3 4
O 0, 1,2,3, 4,
O [0，1，2，3, 4]
答案：选d
range(a,b,s)的作用是从a到b以s为步长产生一个序列。
list(x)的作用是创建或将变量x转换成一个列表类型。
代码执行后的输出结果是[0, 1, 2, 3, 4]。

9.以下关于列表变量ls操作的描述中，错误的是__√√
O ls. reverse():反转列表ls中所有元素
O ls. append(x):在ls最后增加一个元素
O ls. copy0): 生成一-个新列表，复制ls的所有元素
O ls.clear(): 删除ls的最后一个元素
答案：选d
ls.clear()：删除ls中所有元素。
总结：python中关于删除list中的某个元素，一般有三种方法：remove、pop、del：
1、remove: 删除单个元素，删除首个符合条件的元素，按值删除
2.、pop: 删除单个或多个元素，按位删除(根据索引删除)
3、del：它是根据索引(元素所在位置)来删除

10.以下关于Python字典变量的定义中，错误的是__√×
O d = {1:[1,2]， 3:[3, 4]}
O d = {[1,2]:1， [3, 4]:3}
O d ={(1,2):1， (3, 4):3}
O d = {’张三’:1, '李四’:2}
答案：选b
Python语言中的字典使用大括号{}建立，每个元素是一个键值对，使用方式如下：
{<键1>:<值1>,<键2>:<值2>……<键n>:<值n>}
其中，键和值通过冒号连接，不同键值对通过逗号隔开。
字典中的键不可变，因此可以使用字符串、数字、元组等，但不能使用列表作为键。
A是数字，B是列表不可以，C是元组，D是字符串

11.列表listV = list (range(10))，以下能够输出列表listV中最大元素的是_√√
O print (listV. reverse(i) [0])
O print(listV. max()
O print (max(listV0))
O print (max (listV))
答案：选d
max(ls)是列表的常用操作函数，表示列表ls中的最大值。

12.以下代码的输出结果是______。√√
ls = []
for m in ‘AB’:
for n in ‘CD’:
ls.append(m+n)
print(ls)
O ABCD
O AABBCCDD
O ACADBCBD
O [‘AC’，’AD’， 'BC’，‘BD’]
答案：选d
Python通过保留字for实现遍历循环，使用方法如下：
for <循环变量> in <遍历结构>
<语句块>
遍历循环可以理解为从遍历结构中逐一提取元素，放在循环变量中，对于每个所提取的元素执行一次语句块。for语句的循环执行次数是根据遍历结构中元素个数确定的。
ls.append(x)方法是列表的常用操作方法，作用是在列表最后增加一个元素x。
题目中的代码循环过程如下：
m = A，n = C，m+n = AC；
m = A，n = D，m+n = AD；
m = B，n = C，m+n = BC；
m = B，n = D，m+n = BD。
代码执行后的输出结果是[‘AC’, ‘AD’, ‘BC’, ‘BD’]。

13.以下描述中，错误的是√√
O Python语言通过索引来访问列表中元素，索引可以是负整数.
O列表用方括号来定义，继承了序列类型的所有属性和方法
O Python列表是各种类型数据的集合，列表中的元素不能够被修改
O Python语言的列表类型能够包含其它的组合数据类型
答案：选c
列表是包含0个或多个元组的有序序列，属于序列类型。列表可以进行元素增加、删除、替换、查找等操作。

14.以下描述中，错误的是√√
O如果s是一个序列，s =[1,“ksate”, True]， s[3]返回True
O如果x不是s的元素，x not in s返回True .
O如果x是s的元素，x in s返回True
O如果s是一个序列，s =[1, “kate”, True]， s[-1]返回True
答案：选a
如果序列长度为L，正向递增需要以最左侧序列符号为0，向右依次递增，最右侧序列符号为L-1；反向递减序号以最右侧序列符号为-1，向左依次递减，最左侧序列符号为-L。
选项"如果s是一个序列，s = [1,“kate”,True]，s[3]返回True"中的索引序号"3"超过列表的元素范围，出现IndexError错误，返回的结果不是True。

15.以下代码的输出结果是______。√×
S = ‘Pame’
for i in range(len(S)):
print(S[-i],end=“”)
O ameP
O emaP
O Pema
O Pame
答案：选c
Python通过保留字for实现遍历循环，使用方法如下：
for <循环变量> in <遍历结构>
<语句块>
遍历循环可以理解为从遍历结构中逐一提取元素，放在循环变量中，对于每个所提取的元素执行一次语句块。for语句的循环执行次数是根据遍历结构中元素个数确定的。
len(S)：字符串S的长度，这里为4。i的取值范围为range(4)，即0、1、2、3。
题目中的代码循环过程如下：
i = 0，S[-i]=P；
i = 1，S[-i]=e；
i = 2，S[-i]=m；
i = 3，S[-i]=a。
代码执行后的输出结果是Pema。

16.以下代码的输出结果是______。√√
for s in “HelloWorld”:
if s==“W”:
continue
print(s,end=“”)
O Helloorld
O Hello
O World
O HelloWorld
答案：选a
Python通过保留字for实现遍历循环，使用方法如下：
for <循环变量> in <遍历结构>
<语句块>
遍历循环可以理解为从遍历结构中逐一提取元素，放在循环变量中，对于每个所提取的元素执行一次语句块。for语句的循环执行次数是根据遍历结构中元素个数确定的。
Python的单分支结构使用if保留字对条件进行判断，使用方法如下：
if <条件>：
<语句块>
其中，if、：和<语句块>前的缩进都是语法的一部分。<条件>是一个产生True或False结果的语句，当结果为True时，执行<语句块>，否则跳过<语句块>。
continue用来结束当前当次循环，即跳出循环体中下面尚未执行的语句，但不跳出当前循环。
题目中的代码循环过程如下：
s = H，输出结果H；
s = e，输出结果e；
s = l，输出结果l；
s = l，输出结果l；
s = o，输出结果o；
s = W，跳出当前当次循环，继续下一次循环；
s = o，输出结果o；
s = r，输出结果r；
s = d，输出结果d。
代码执行后的输出结果是Helloorld。

17.下面的d是一个字典变量，能够输出数字5的语句是______。√√
d = {‘food’:{‘cake’:1,‘egg’:5},‘cake’:2,‘egg’:3}
O print(d[’ egg’])
O print(d[’ food’ ][’ egg’])
O print(d[’ food’ ][-1])
O print(d[’ cake’ ] [1])
答案：选b
索引是按照一定顺序检索内容的体系。由于字典元素"键值对"中键是值的索引，因此，可以直接利用键值对关系索引元素。
字典中键值对的索引模式如下（采用中括号格式）：
<值> = <字典变量>[<键>]
d[‘food’][-1]和d[‘cake’][1]中括号里的内容不是键，与字典类型中的索引模式不一样；d[‘egg’]执行后的值是3，不是5。

18.以下代码的输出结果是______。√√
s =[4,2,9,1]
s.insert(2,3)
print(s)
O [4,2,9,2,1]
O [4,3,2,9,1]
O [4,2,3,9,1]
O [4,2,9,1,2,3]
答案：选c
s.insert(i,x)：在列表第i位置增加元素x。
列表中的索引值从0开始，s.insert(2,3)表示在列表的第三个位置增加元素3，则题目中的代码执行后输出结果为[4,2,3,9,1]。

19.以下代码的输出结果是______。√√
ls=[[1,2,3],[[4,5],6],[7,8]]
print(len(ls))
答案：3
len(ls)：列表ls中的元素个数（长度）。
代码执行后的输出结果是3，即ls=[[1,2,3],[[4,5],6],[7,8]]的长度为3。

20.以下代码的输出结果是______。√√
ls = [“2020”, “20.20”, “Python”]
ls.append(2020)
ls.append([2020, “2020”])
print(ls)
O [’ 2020’，’20.20’，’Python’， 2020]
O [’ 2020’，’20. 20’，’ Python’，2020， [2020， ’2020’ ]]
O [’ 2020’，20.20’，’ Python’，2020， 2020， ’ 2020’ ]
O [’ 2020’，’20.20’，‘Python’，2020，[’ 2020’ ]]
答案：选b
ls.append(x)：在列表ls最后增加一个元素x。
代码执行后的输出结果为[‘2020’, ‘20.20’, ‘Python’, 2020, [2020, ‘2020’]]。

21.以下代码的输出结果是______。×√
d ={“大海”:“蓝色”, “天空”:“灰色”, “大地”:“黑色”}
print(d[“大地”], d.get(“大地”, “黄色”))
O黑色 黑色
O黑色 灰色
O黑色 黄色
O黑色 蓝色
答案：选a
d.get(key,default)：键存在则返回相应值，否则返回默认值default。
代码执行后的输出结果：黑色 黑色。

22.以下选项，错误的是×
O Python的str、 tuple和list类型都属于序列类型
O组合数据类型可以分为3类：序列类型、集合类型和映射类型
O Python组合数据类型能够将多个数据组织起来，通过单一的表示使数据操作更有序、更容易理解
O序列类型是二维元素向量，元素之间存在先后关系，通过序号访问
答案：选d
序列类型是一维元素向量，元素之间存在先后关系，通过序号访问。

23.以下代码的输出结果是______。××☆
d = {}
for i in range(26):
d[chr(i+ord(“a”))] = chr((i+13) % 26 + ord(“a”))
for c in “Python”:
print(d.get(c,c), end=“”)
O Pabugl
O Plguba
O Cabugl
O Python
答案：选b
Python通过保留字for实现遍历循环，使用方法如下：
for <循环变量> in <遍历结构>
<语句块>
遍历循环可以理解为从遍历结构中逐一提取元素，放在循环变量中，对于每个所提取的元素执行一次语句块。for语句的循环执行次数是根据遍历结构中元素个数确定的。
chr(x)返回Unicode编码x对应的单字符
ord(x)返回单字符x表示的Unicode编码。
代码一开始生成一个空字典，第一个for循环用于向其中添加字典元素。range(26)表示i的取值范围是0至25之间的整数（包括0与25）。"a"对应的Unicode编码为97。
i=0时，chr(ord(“a”))=‘a’，chr((13) % 26 + ord(“a”))=chr(13+97)= ‘n’，则第三行赋值语句简化为d[‘a’]=‘n’,此时字典d为{‘a’: ‘n’}。
i=1时，chr(1+ord(“a”))= ‘b’，chr((1+13) % 26 + ord(“a”))=chr(14+97)= ‘o’，则第三行赋值语句简化为d[‘b’]=‘o’，此时字典d为{‘a’: ‘n’, ‘b’: ‘o’}。
依次类推，最后得出字典d为{‘a’: ‘n’, ‘b’: ‘o’, ‘c’: ‘p’, ‘d’: ‘q’, ‘e’: ‘r’, ‘f’: ‘s’, ‘g’: ‘t’, ‘h’: ‘u’, ‘i’: ‘v’, ‘j’: ‘w’, ‘k’: ‘x’, ‘l’: ‘y’, ‘m’: ‘z’, ‘n’: ‘a’, ‘o’: ‘b’, ‘p’: ‘c’, ‘q’: ‘d’, ‘r’: ‘e’, ‘s’: ‘f’, ‘t’: ‘g’, ‘u’: ‘h’, ‘v’: ‘i’, ‘w’: ‘j’, ‘x’: ‘k’, ‘y’: ‘l’, ‘z’: ‘m’}，简而言之，每个字母键对应的是Unicode编码比自己大13的字母值。
d.get(key, default)表示若键存在则返回相应值，否则返回默认值default。所以第二个for循环最后的输出结果为Plguba。

24.以下关于Python二维数据的描述中，错误的是_√√
O从CSV文件获得数据内容后，可以用replace ()来去掉每行最后的换行符
O CSV文件的每一行是一维数据，可以用列表、元组和字典表示
O若一个列表变量里的元素都是字符串类型，则可以用join()合成字符串
O列表中保存的二维数据，可以通过循环用write()写入CSV文件
答案：选b
高维数据由键值对类型的数据构成，采用对象方式组织，可以多层嵌套。
高维数据相比一维和二维数据能表达更加灵活和复杂的数据关系，可以用字典类型表示。
一维数据不用字典类型来表示。
逗号分隔型取值格式（Comma Separated Values，简称CSV），是一种纯文本格式，用来存储数据。
在CSV中，数据的字段由逗号分开，程序通过读取文件重新创建正确的字段，方法是每次遇到逗号时开始新一段数据。

25.以下程序的输出结果是______。√√
ll=[‘aa’,[2,3,3.0]]
print(ll.index(2))
O 2
O 3.0
O 3
O ValueError
答案：选d
索引序号从0开始，不能超过列表的元素范围。l1列表中只有两个元素，l1.index(2)表示取列表中第三个元素，会出错。

26.以下程序的输出结果是______。√√
for i in “Nation”:
for k in range(2):
if i == ‘n’:
break
print(i, end=“”)
O aattiioo
O NNaattiioo
O Nattiioon
O aattiioonn
答案：选b
range(start, stop[, step])表示计数从start开始，到stop结束，但不包括stop，步长默认为1。start默认从0开始，range(2)等价于range(0,2)，则k的取值范围为0、1。
break用来跳出最内层循环，脱离该循环后程序从循环后的代码继续执行。
第1次循环，i=N，k=0，if判断条件不成立，输出i的值为N。
第2次循环，i=N，k=1，if判断条件不成立，输出i的值为N。
第3次循环，i=a，k=0，if判断条件不成立，输出i的值为a。
第4次循环，i=a，k=1，if判断条件不成立，输出i的值为a。
……
第11次循环，i=n，k=0，if判断条件成立，跳出内层循环。
第12次循环，i=n，k=1，if判断条件成立，跳出内层循环。
最后输出为NNaattiioo。

27.以下程序的输出结果是______。××
x = [90,87,93]
y = (“Aele”, “Bob”,“lala”)
z = {}
for i in range(len(x)):
z[i] = list(zip(x,y))
print(z)
A.{0:[(90,‘Aele’),(87,‘Bob’),(93,‘lala’)],1:[(90,‘Aele’),(87,‘Bob’),(93,‘lala’)],2:[(90,‘Aele’),(87,‘Bob’),(93,‘lala’)]}
B.{0:(90,‘Aele’),1:(87,‘Bob’),2:(93,‘lala’)}
C.{0:[90,‘Aele’],1:[87,‘Bob’],2:[93,‘lala’]}
D.{0:([90,87,93],(‘Aele’,‘Bob’,‘lala’)),1:([90,87,93],(‘Aele’,‘Bob’,‘lala’)),2:([90,87,93],(‘Aele’,‘Bob’,‘lala’))}
答案：选a
len(ls)：列表ls的元素个数（长度）。
range(start, stop[, step])表示计数从start开始，到stop结束，但不包括stop，步长默认1。
start默认从0开始，range(len(x))等价于range(0,3)，则i的取值范围为0、1、2。
z = {}，z是一个空的元组类型，利用zip往里面添加元素。
zip()：将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
list(zip(x,y))，把x和y打包成一个list，添加到元组z当中。
由题面可知，每个键值对的值都是一样的。

28.以下程序的输出结果是______。√√☆
ss = set(“htslbht”)
sorted(ss)
for i in ss:
print(i,end = ‘’)
O tsblth
O htslbht
O hlbst
O hhlstt
答案：选c
set(x)函数将其他的组合数据类型变成集合类型，返回结果是一个无重复且排序任意的集合。4个选项中只有hlbst符合无重复的要求。

29.以下程序的输出结果是______。×√☆
ls1=[1,2,3,4,5]
ls2=ls1
ls2.reverse()
print(ls1)
O [5,4,3,2, 1]
O [1,2,3, 4, 5]
O 5,4,3,2, 1
O 1,2,3, 4, 5
答案：选a
ls.reverse()：将列表ls中的元素进行逆序反转。
对于列表类型，使用等号无法实现真正的赋值，不能产生新列表。
ls2 = ls1语句并不是拷贝ls1中的元素给变量ls2，而是新关联了一个引用。
即增加一个别名，ls1和ls2所指向的是同一套内容，所以修改了ls2的内容，ls1也是随之改变的。
#列表对象的赋值和拷贝函数操作的差别。
赋值：是指两个对象共享一块内存；
拷贝：是给第二个对象复制了一份新的变量；
因此，赋值的情况下，如果修改了ls2的内容，则ls1也就改变了

30.为以下程序填空，使得输出结果是{40:‘yuwen’,20:‘yingyu’,30:‘shuxue’}的选项是___。××☆
tb = {‘yingyu’:20, ‘shuxue’:30, ‘yuwen’:40}
stb = {}
for it in tb.items():
print(it)
________________
print(stb)
O stb[it[1]]=tb[it[0]]
O stb[it[1]]=stb[it[0]]
O stb[it[1]]=tb[it[1]]
O stb[it[1]]=it[0]
答案：选d
{}用于生成一个空字典，d.items()返回所有的键值对。
在本题中，变量it中每一次循环存储一对键值对。
题面要求将每一对键值对的键和值交换位置，使用语句stb[it[1]] = it[0]。

题意是将字典中的键值互换。tb.items()以列表形式(并非直接的列表，若要返回列表值还需调用list函数)返回可遍历的(键，值)元组数组。因此，for循环中it每次遍历得到的是一个元组，依次为(yingyu’,20)、(‘shuxue’ ,30)、(‘yuwen’ ,40)，然后将元组中序号为0的元素和序号为1的元素互换位置，实现字典中键值的互换，应填入stb[t[1]] = it[0]。

31.以下程序的输出结果是______。××☆
def hub(ss, x = 2.0,y = 4.0):
ss+= x * y
ss = 10
print(ss, hub(ss, 3))
O 22 None
O 10 None
O 10. 0 22.0
O 22. 0 None
答案：选b
全局变量指在函数之外定义的变量，在程序执行全过程有效。
ss是全局变量，最后输出为10，hub()函数没有返回值，最后输出为None。

32.以下程序的输出结果是______。××☆
ls = [12,44,23,46]
for i in ls:
if i == ‘44’:
print(‘found it! i = ‘,i)
break
else:
print(‘not found it …’)
O notfoundit…
O foundit!i=44
O foundit!i=44 .
notfoundit…
O foundit!i=’ 44’
notfoundit. . .
答案：选a
列表ls中的元素是数字类型，判断条件中的’44’是字符串类型，所以判断条件不符合，最后输出not found it …。
啊卧槽，这种题目老坑人了！

33.以下程序的输出结果是______。√队
x = 4
ca = ‘123456’
if str(x) in ca:
print(ca.replace(ca[x],str(x-2)))
O 5
O 123456
O 123426
O 2
答案：选c
ca.replace(ca[4],str(2))即ca.replace(5, str(2))
replace(old,new)方法将字符串中的old（旧字符串）替换成new（新字符串），old和new的长度可以不同。
x=4，if判断条件成立，将字符串ca中索引序号为4的元素（即第5个元素），换成字符’2’，则输出123426。

34.给以下程序填空，能输出{0:[90,‘Aele’],1:[87,‘Bob’],2:[93,‘lala’]}结果的选项是______。×√☆
x = [90,87,93]
y = (“Aele”, “Bob”,“lala”)
z = {}
for i in range(len(x)):
_______________
print(z)
O z[i]=[x[i],y[i]]
O z[i]=x[i],y[i]
O z[i]=list(zip(x, y))
O z[i]=x, y
答案：选a
zip()函数将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
zip是将所有元素都打包成元组，再返回元组对应的字符串
x[0]=90，y[0]= “Aele”，依此类推，能输出题面要求键值对的语句是z[i] = [x[i],y[i]]。
i=0的时候，x[0]=90，y[0]= “Aele”，是一一对应的。
使用zip函数，是将所有元素都打包成元组，再返回元组对应的字符串
z[i]=list(zip(x, y))
结果是这样的：{0:[(90,‘Aele’),(87,‘Bob’),(93,‘lala’)],1:[(90,‘Aele’),(87,‘Bob’),(93,‘lala’)],2:[(90,‘Aele’),(87,‘Bob’),(93,‘lala’)]}

35.以下程序的输出结果是______。√×
L1=[1,2,3,4]
L2=L1.copy()
L2.reverse()
print(L1)
#列表对象的赋值和拷贝函数操作的差别，
拷贝函数是给第二个对象复制了一份新的变量；
因此修改了ls2的内容，则ls1并没有改变
O 1,2,3,4.
O [4,3,2, 1]
O 4,3,2, 1
O [1,2,3, 4]
答案：选d
ls.copy()：复制ls中所有元素生成一个新列表。
题目中列表L1使用.copy()方法复制后赋值给变量L2，L2中元素的改变不会影响L1，所以最后输出L1的内容为[1, 2, 3, 4]。
列表赋值共享同一地址，所以会互相影响，一个改变另一个随之改变

36.以下程序的输出结果不可能的选项是______。√√
import random
ls=[2,3,4,6]
s=10
k=random.randint(0,2)
s+=ls[k]
print(s)
O 12
O 14
O 13
O 16
答案：选d
randint(a,b)：生成一个[a,b]之间的整数。
根据题意，k的取值范围为[0,2]，列表的索引序号从0开始，所以可能会取出列表ls的前三个元素，不可能取到第4个元素，即运算结果不可能是16。

37.以下程序的输出结果是______。√√
ls=[‘绿茶’,‘乌龙茶’,‘红茶’,‘白茶’,‘黑茶’]
x=‘乌龙茶’
print(ls.index(x,0))
答案：1
s.index(x)：序列s中第一次出现元素x的位置。
索引序号从0开始，所以第一次出现’乌龙茶’的位置是1。
总结：index()函数
str.index(sub [, start [, end]])
其中，str 表示要进行查找的原始字符串；
sub 代表要查找的子字符串；
start 和 end 分别表示字符串查找的起始和结束位置。
如果省略 start ，则默认从字符串开头查找；
如果省略 end ，则默认查找到字符串结尾。

38.关于字典的描述，错误的是_。××
O字典的元素以键为索引进行访问
O字典的一个键可以对应多个值
O字典长度是可变的
O字典是键值对的结合，键值对之间没有顺序
答案：选b
字典类型具有和集合类似的性质，即键值对之间没有顺序且不能重复。
字典元素“键值对”中键是值的索引，可以直接利用键值对关系索引元素，一个键对应一个值。
字典是存储可变数量键值对的数据结构，长度可变。

39.以下不是Python文件读写方法的是_√√√
O read
O readline
O writeline
O write
答案：选c
文件读取方法：read、readline、readlines、seek
文件写入方法：write、writelines
 
40.关于Python文件打开模式，表示错误的是√√
O ab
O rt
O nb
O wt
答案：选c
总结：文件打开方式
文件的打开方式有：‘r’、‘w’、‘x’、‘a’、‘b’、‘t’、‘+’。
其中’r’、‘w’、‘x’、‘a’可以和’b’、‘t’、'+'组合使用。

41.表格类型数据的组织维度最可能是√
O二维数据.
O 一维数据
O多维数据
O高维数据
答案：选a
二维数据，也称表格数据，由关联关系数据构成，采用二维表格方式组织，对应于数学中的矩阵，常见的表格都属于二维数据。
 
42.二维列表ls=[[9, 8], [7, 6], [5, 4], [3, 2], [1, 0]]， 能够获得数字4的选项是_√√
O ls[-2, 0]
O ls[3, 2]
O ls[2, 2]
O ls[-3,-1]
答案：选d
索引序列使用正向递增序号或反向递减序号。正向从0开始，代表第1个元素，反向从-1开始，代表最后一个元素。
获取数字4首先需要取到[5, 4]，序号为2或者-3。然后在[5, 4]中取4，序号为1或者-1，所以选择s[-3, -1]。

43.以下程序的输出结果是______。√√
x=dict()
type(x)
O <class’ set’>
O <class’ list’>
O <class’ dict’>
O <class’ tuple’ >
答案：选c
x=dict()：生成一个空字典，所以x为字典类型。

44.以下程序的输出结果是______。√√
lt=[‘绿茶’,‘乌龙茶’,‘红茶’,‘白茶’,‘黑茶’]
ls=lt
ls.clear()
print(lt)
O变量未定义的错误
O []
O [绿茶’,’乌龙茶’，红茶’，’白茶’，黑茶’]
O’绿茶’,'乌龙茶’，红茶,'白茶’，'黑茶’
答案：选b
ls.clear()：删除ls中所有元素。
对于列表类型，使用等号无法实现真正的赋值，不能产生新列表。ls = lt语句并不是拷贝lt中的元素给变量ls，而是新关联了一个引用，即增加一个别名，ls和lt所指向的是同一套内容，所以删除ls中的元素，lt也随之变成空列表。

45.以下不是Python文件操作方法的是_√√
O load
O seek
O read
O write
答案：选a
文件读取方法：read、readline、readlines、seek
文件写入方法：write、writelines

46.文件的追加写入模式是__。××
O x
O r
O a
O +
答案：选c
r：只读模式，如果文件不存在，返回异常。
x：创建写模式，文件不存在则创建，存在则返回异常。
a：追加写模式，文件不存在则创建，存在则在原文件最后追加内容。
+：与r/w/x/a一同使用，在原功能基础上增加同时读写功能。

47.表达键值对的字典类型最可能属于的数据组织维度是_×
O一维数据
O高维数据
O二维数据
O多维数据
答案：选b
高维数据由键值对类型的数据构成，采用对象方式组织，可以多层嵌套。

48.以下对CSV格式描述正确的是√
O CSV文件以英文逗号分割元素
O CSV文件以英文空格分割元素
O CSV文件以英文分号分割元素
O CSV文件以英文特殊符号分割元素
答案：选a
逗号分隔的存储格式叫做CSV格式，是一种通用的、相对简单的文件格式。

49.以下程序的输出结果是______。××
def mysort(ss,flag):
if flag:
return(sorted(ss,reverse = True))
else:
return(sorted(ss,reverse = False))
ss = [9,4,6,21]
print(mysort(ss,2))
O [4,6,9,21]
O [9, 4]
O [21,9,6,4]
O [9,4,6,21]
答案：选c
mysort(ss,flag)函数中，如果flag不为0，则返回元素从大到小排序后的列表；
如果flag为0，则返回元素从小到大排序后的列表。

50.执行以下程序后，要输出ab44cd46结果，该执行的选项是______。√×
ls = [‘ab’,‘44’,‘cd’,‘46’]
ls.reverse()
O print(‘’. join(ls[-1::]))
O print(‘’. join(ls))
O print(‘’. join(ls[1:]))
O print(‘’. join(ls[-1::-1]))
答案：选d
列表切片：<列表或列表变量>[N:M:K]
切片获取列表类型从N到M（不包含M）的以K为步长所对应的元素组成的列表。
ls[-1::-1]中，N为-1，K为-1，表示获取列表从后往前的所有元素，即46cd44ab，再执行ls.reverse()，将列表中的元素逆序输出，得到ab44cd46。

50. (改) 执行以下程序后，要输出46cd44ab结果，该执行的选项是______。√
    ls = [‘ab’,‘44’,‘cd’,‘46’]
    ls.reverse()
    O print(‘’. join(ls[-1::]))
    O print(‘’. join(ls))
    O print(‘’. join(ls[1:]))
    O print(‘’. join(ls[-1::-1]))
    答案：选b
    Join时不用逆序输出，reverse时逆序即可。

51.以下程序的输出结果是______。×
ss = [2,3,6,9,7,1]
for i in ss:
print(max(ss),end = ‘,’)
ss.remove(max(ss))
O 9,7,6
O 9,7,6,
O 9,7,6,3,2, 1,
O 9, 7,6,3,2, 1
答案：选b
for循环的作用是求出列表aa中的最大值并输出，以逗号结尾，将这个最大值移出ss列表。
第1次循环，i的取值为ss中的第1个元素，即2，此时最大值为9，输出最大值和逗号后，ss变为[2,3,6,7,1]；
第2次循环，i的取值为ss中的第2个元素，即3，此时最大值为7，输出最大值和逗号后，ss变为[2,3,6,1]；
第3次循环，i的取值为ss中的第3个元素，即3，此时最大值为6，输出最大值和逗号后，ss变为[2,3,1]；
ss中此时只有3个元素，i不再取值，循环结束。
因为此时，已经遍历到列表的最后了，已经完成遍历了，所以不再取值了。

52.以下语句的执行结果是______。×√☆
dd={‘a’:90,‘b’:87,‘c’:93}
print(max(dd),min(dd))
O c a
O 93 90
O c b
O 93 87
答案：选a
字典由键值对组成，max(d)输出的是最大值对应的键，min(d)输出的是最小值对应的键。
abc在ascii中，a最小，c最大
字典的操作函数max()和min()，分别返回最大值、最小值的函数都是对字典的键进行比较，所以最大值为’c，最小值为’a’,所以选D选项。

53.以下语句的执行结果是______。√
dd = {‘chinese’:200, ‘pe’:187, ‘Gana’:930}
print(dd.keys())
O 200,187,930
O ‘chinese’:‘pe’:‘Gana’
O dict_keys([‘chinese’,‘pe’,‘Gana’])
O [‘chinese’,‘pe’,‘Gana’]
答案：选c
字典由键值对组成，dd.keys()返回字典中的所有键的信息，返回结果是Python的一种内部数据类型dict_keys。

54.以下程序的输出结果不可能的选项是______。√√
import random
ls = [‘a’,‘b’,‘c’,‘d’]
print(random.sample(ls,2))
O [‘d’,‘a’]
O [‘d’,‘c’]
O [‘a’,‘d’,‘c’]
O [‘b’,‘d’]
答案：选c
sample(pop,k)：从pop类型中随机选取k个元素，以列表类型返回。
所以最后输出的是2个元素，不可能为3个元素。

55.以下程序的输出结果是______。√√
def myf(x = 2.0,y = 4.0):
global sp
sp += x * y
return(sp)
sp = 100
print(sp,myf(4,3))
O 112 100
O 100 112
O 100 100
O 112 112
答案：选b
程序自上向下执行，首先创建函数，此时函数未经过调用，无需执行，然后创建变量sp，并打印变量sp的值及函数的返回值，所以第一个值为100。 函数myf参数为4和3。 代入函数中，函数中使用了global关键字，诱导考生认为全局变量sp已经被修改，但是在打印过程中sp先打印，此时还未执行函数。经运算函数的返回值为112。

56.以下程序的输出结果是______。××☆
ss=[‘e’,‘h’,‘b’,‘s’,‘l’,‘p’]
for i in range(len(ss)):
print(max(ss),end=‘,’)
ss.remove(max(ss))
O s,p,l,h,e,b,
O s,p,l,h,e,b
O s,p,l
O s,p,l,
答案：选a
len(ss)=6，所以i的取值范围为0、1、2、3、4、5。
字符之间按照ASCII码值比较大小，26个小写字母中，a最小，z最大。
第1次循环，i的取值为0，输出列表ss中的最大值，即s，以及’,‘，将最大值移出列表，此时列表为[‘e’,‘h’,‘b’,‘l’,‘p’]；
第2次循环，i的取值为1，输出列表ss中的最大值，即p，以及’,'，将最大值移出列表，此时列表为[‘e’,‘h’,‘b’,‘l’]；
依次类推，最后输出"s,p,l,h,e,b,"。

56.（改）如果改一下题目，把range(len(ss))改成ss。√×☆
ss=[‘e’,‘h’,‘b’,‘s’,‘l’,‘p’]
for i in ss:
print(max(ss),end=‘,’)
ss.remove(max(ss))
O s,p,l,h,e,b,
O s,p,l,h,e,b
O s,p,l
O s,p,l,
答案：选d
i=e,输出’s,’ ss=[‘e’,‘h’,‘b’,‘l’,‘p’]
i=h,输出‘p,’,ss=[‘e’,‘h’,‘b’,‘l’]
i=b,输出’l,’, ss=[‘e’,‘h’,‘b’,]。此时i遍历到头了，输出结束
输出s,p,l,

57.以下程序的输出结果是______。××
print(len(list(‘i love python’)))
O 13
O 1
O 11
O 3
答案：选a
计算字符串长度时，空格也算作一个字符长度，所以长度为13。

58.以下程序的执行结果是______。√√
x = [90,87,93]
y = (“Aele”,“Bob”,“lala”)
z={}
for i in range(len(x)):
z[x[i]]=y[i]
print(z)
O {‘Aele’:90,‘Bob’:87,‘lala’:93}
O {‘90’:‘Aele’,‘87’:‘Bob’,‘93’:‘lala’}
O {‘Aele’:‘90’,‘Bob’:‘87’,‘lala’:‘93’}
O {90:‘Aele’,87:‘Bob’,93:‘lala’}
答案：选d
z是字典变量，由键值对组成，由z[x[i]]=y[i]可知，x[i]是键，y[i]是值，x列表中的元素为数字，y列表中的元素为字符，所以执行结果为{90:‘Aele’,87:‘Bob’,93:‘lala’}。

59.以下语句的执行结果是______。√√
dic = {90:‘Aele’,87:‘Bob’,93:‘lala’}
print(dic.pop(90,-1),len(dic))
O Aele 3
O-13
O Aele 2
O-12
答案：选c
pop(key[,default])方法删除字典给定键key及对应的值，返回值为被删除的值。key值必须给出，否则返回default值。
题中删除键90及其对应的值，返回值为Aele，此时字典中元素为2，则长度为2。

60.以下语句的执行结果是______。√
ls = [120,‘120’,int(‘120’),12*10]
print(ls.index(120),ls.count(120))
O 0 3
O 0 2
O 2 4
O 1 3
答案：选a
s.index(x)：序列s中第一次出现元素x的位置。
列表第一个元素为120，列表序号从0开始，则ls.index(120)返回值为0。
ls.count(120)用来求出列表中值为120的元素个数，除’120’是字符外，其余值均为120，个数为3。

61.不能返回列表数据类型的选项是×√
O range()
O s. split()
O dict. items ()
O s.lcut()
答案：选c
dict.items()返回字典中的所有键值对信息，返回结果是Python的一种内部数据类型dict_items。

62.关于Python组合数据类型的描述，错误的选项是√√
(A) 字符串、元组和列表都属于序列类型
(B)列表创建后，其内容可以被修改
©组合数据类型根据数据之间的关系分为三类:序列类型、集合类型和映射类型
(D) 集合类型的元素之间存在先后关系，能通过序号访问
答案：选d
集合内部元素之间随机排列，没有顺序之分。
组合数据类型根据数据的关系分为序列类型、集合类型和映射类型，其中序列类型又包含字符串、元组和列表。集合类型和映射类型都是没有顺序的数据类型，不能通过序号访问。本题选择A选项。

63.有一组获奖学生名单，从第1名到第6名的学生姓名为:张良，韩梅梅，李亮，王红，张晓晓,李梅。要求名单一旦创建，数据不能修改，不能打乱先后次序。适合存储该组数据的数据类型是√×
(A)集合类型
(B)列表类型
©元组类型
(D)字典类型
答案：选c
因为要存储多个学生姓名，有顺序的限制，所以集合不适合作为存储类型，且题目要求-但创建数据不能修改，不能打乱先后次序，那么列表和字典也不适合作为存储类型，只能选择元组类型。因为元组是不可改变且有顺序的组合数据类型。

64.以下程序的输出结果是______。√
def mysort(ss,flag):
if flag:
return(sorted(ss,reverse = True))
else:
return(sorted(ss,reverse = False))
ss = [1,2,4,3]
print(mysort(ss,2))
(A) [1, 2，4, 3]
(B) [4，3, 2, 1]
© [1，2，3, 4]
(D)[3，4，2，1]
答案：选b
但凡flag≠0，那么if flag就是True，sorted()函数进行排序，参数reverse = True，就是翻转。默认是从小到大，翻转就是从大到小。

65.（和50题对比）执行以下程序后，要输出46cd44ab结果，该执行的选项是______。√
ls = [‘ab’,‘44’,‘cd’,‘46’]
ls.reverse()
O print(‘’. join(ls[-1::]))
O print(‘’. join(ls))
O print(‘’. join(ls[1:]))
O print(‘’. join(ls[-1::-1]))
答案：选b
就是直接join一个字符串，下面已经有reverse函数了，join用空‘’进行分隔输出

66.(和51题对比，一个max一个min).以下程序的输出结果是______。√√
ss = [2,3,6,9,7,1]
for i in ss:
ss.remove(min(ss))
print(min(ss),end = ‘,’)
(A) 1,2,3,6,7, 9,
(B) 9,7,6,3,2, 1,
© 1,2,3,6,7,9
(D) 2,3,6
答案：选d
先remove最小值1，然后print新ss的最小值2，只有d选项是2开头的，选d
遍历列表ss，当循环执行时，每次删除一个最小的数字， 同时打印剩下最小的数字，此时列表的元素数量会发生变化，for循环又是控制循环次数的，所以当执行三次后，元素只剩三个，再想遍历第四个元素，列表已经不能满足了，所以三次的值分别为2,3,6。且print()函数含有参数end那么在每个输出后都得加上",“，所以答案为"2,3,6,”,选C选项。

67.以下程序的输出结果不可能的选项是√√
import random
ls = [‘a’,‘b’,‘c’,‘d’]
print(ls[int (random.random()*3)])
(A) ‘a’
(B) ‘d’
© ‘b’
(D) 'a’, 'b’,‘c’,'d’都有可能
答案：选b
random.random()生成一个0~1之间的随机浮点数
int取整是直接舍的，所以int (random.random()*3的可能取值是0、1、2
所以不可能取第三位d
题目中Is索引通过random库的random()函数生成，因为random()函数生成在[0,1) (包含0不包含1)的随机浮点数，所以乘三之后范围在[0,3) (包含0不包含3)，所以通过int()函数取整之后也不可能等于3,即索引小于3不可能通过索引取得字符串"d"。

68.关于Python列表类型的描述，错误的选项是√√
(A)列表创建后可以修改其中元素，但每个元素类型不能修改
(B)二维数据可以用列表类型表示
©列表类型的元素可以是列表
(D)列表类型的元素可以是字典
答案：选a
列表中的元素可以修改类型

69.以下代码的执行结果是√√
ls =[中国’，[‘北京’，’上海’，‘广州’]，[’河北省’，‘浙江省’，’广东省’]，300, 400, 500]
print(ls[-4][1][:2])
(A)河北
(B)浙江
©浙江省
(D)北京
答案：选b
(ls[-4][1][:2])
[-4]是[’河北省’，‘浙江省’，’广东省’]
[1]是浙江省
[:2]即[0:2]，不包括2，浙江

70.以下代码的执行结果是√√
[’ well’,’ good’ ,’best’ ,‘how’，do’，you’,‘do’,‘?’ ]
str 1 = s[3]+’ ’ + s[4]+’ '+ s[5]+’ '+ s[6]
print (str1)
(A) how do you do
(B) do you do?
© howdoyoudo
(D) 执行错误
答案：选a
中间用空格空开

71.关于Python列表操作的描述，错误的选项是√√
(A) ls是一个列表，ls. insert(x, j)可以在列表ls第j个位置插入一个元素x
(B) ls是一个列表，ls. remove (x)将列表ls中出现的第1个元素x删除
© ls是一个列表，ls. pop(i)可以返回列表ls中第i个元素，并删除列表中的该元素
(D) ls是一个列表，ls. append(x)可以在列表ls第1个位置插入一个元素x
答案：选d和a
insert(i，x)：在列表第i位置增加元素x。a选项也是错的题目有问题
ls.append(x)的作用是在列表ls最后增加一个元素x。

72.以下代码的执行结果是×√
s=[1，‘’Alice"，True]
print(s[1] and s[-1])
(A) True
(B) A1ice
© “Alice’
(D) 1
答案：选a
s[1] and s[-1]即‘’Alice” and True = True

73.为了使以下代码的执行结果是:中国，韩国，日本，巴基斯坦，蒙古√√
country = [’ 中国’，’韩国’，'日本’，” 巴基斯坦’，‘蒙古’]
n=1
for c in country:
if n < len(country):
print(______)
else:
print©
n=n+1
在横线处要补充的代码是
(A) c, sep=“,“
(B) c，”，”
© c
(D) c, end=”,‘’
答案：选d
print(c, end=",‘’)

74.以下语句的执行结果是√
dd = {‘chinese’ :200，’pe’:187,’ Gana’:930}
print (dd. keys())
(A) [’ chinese’ ,’pe’，’Gana’ ]
(B) dict_keys([‘chinese’,’pe’,’Gana’ ])
© 200，187, 930
(D)’chinese’,’pe’,’Gana’
答案：选b
字典输出键keys的类型dict_keys

75.以下语句的执行结果是√
d = {1:10, 2:2, 3:100}
print (d. get(3,99))
(A) 2
(B) 99
© 100
(D) 10
答案：选c
d. get(3,99)，键3在不在，在即返回3，不在即返回默认值99
本题主要考核字典的get()方法，get)方法从字典中寻找对应参数的键，找到即返回对应的值，找不到即返回自身的第二个参数。 题目中寻找3对应的键，可以发现字典中有3这个键，所以返回3对应的值，即为100。

76.以下程序的输出结果是×√
dd = {‘a’:90,‘b’ :87,‘c’ :93}
print([[dd[x]，x] for x in sorted(dd)])
(A) [[87, ‘b’]，[90, ‘a’]，[93, ‘c’]]
(B) [[93, ‘c’]，[90，’a’]，[87， ‘b’]]
© [[90,a]，[87, b]，[93,c]]
(D) [[90,’a’],[87,‘b’]，[93,’c’]]
答案：选d
sorted(dd)默认是按照键的升序，键a，再返回键名’a’
字典dd输出语句print()输出的是一个列表，列表由列表生成式产生，列表中含有多个[dd[x], x]元素，其中x从soted(dd)中遍历得到，sorted(dd)的值为[’a’,’b’,’c’], 代入[dd[x], x]依次计算得到90, 'a], [87, ‘b’],[93, 'c’]，所以选择B选项。

77.以下是某班5名同学的一组个人信息√√
学号、姓名、性别、年龄、身高、体重
xs001、张红、女、18、168、 55
xs002、王丽丽、女、19、165、 60
xs003、李华、男、18、178、66
xs004、赵亮、男、19、175、 65
xs005、张玲玲、女、18、160、 50
采用变量a存储以上信息用于统计分析，最适合的数据类型是
(A)字符串
(B)列表
©集合
(D)字典
答案：选b
列表可操作性大，可以修改

78.关于Python的循环控制，以下描述错误的是√√
(A) break将退出所有层次的循环
(B) continue将结束当次循环
© else也可以与循环搭配使用
(D) break和continue可以用于遍历循环和无限循环
答案：选a
break只是退出最内层的循环

79.以下对Python语言定位的表述正确的是( )√
A、数据分析专用语言
B、编译型语言
C、解释型脚本语言
D、机器语言
答案: C
Python是高级脚本语言，采用解释型方式执行，且自身属于通用语言可以完成各种不同的工作。

80.在time库中，可以进行程序计时的函数是( )×
A. perf_ counter()
B、sleep()
C、strtime()
D、strptime()
答案: A
time库中perf_counter()函数用于计时; sleep()函数用于暂停程序执行; strftime()和trptime()都是用于显示时间。

81.使用pip指令安装第三方库wordcloud的命令是( )√
A、install pip wordcloud
B、pip install wordcloud
C、pip wordcloud
D、install wordcloud pip
答案: B
使用pip安装模块的命令是pip install模块名。所以选择B选项。

82.执行以下程序,井输入"0"时，输出结果是( )√
try:
b = eval(input(请输入一个正整数: '))
print(100/b)
except ZeroDivisionError:
print(“错误1”)
except:
print(“错误2”)
A、错误2
B、错误1
C、100
D、2.03333333333335
答案: B
当输入0时，eval()函数将字符串”0”转化为数字0，然后执行print()语句内部的100/0， 0不能作为除数，所以会产生异常ZeroDivisionError，所以执行print(”错误1")。

83.以下代码的执行结果是()√
L1 = [‘月亮’,’河’,’宽宽’,’的’,’河’]
print(L1.index(‘河’))
A. 1
B. 3
C、2
D、4
答案: A
首先创建了L1例表，然后输出列表index(方法得到的结果。index()方法可以查询列表元素并返回对应索引值，仅返回查询到的第一个元表。题目中询字符串河"，所以返回的索引值应为1。

84.以下程序的输出结果是( )√
def mysort(s,flag):
if flag:
return(sorted(ss,reverse = True))
else:
return(sorted(ss,reverse = False))
ss=[1,2, 4, 3]
print(mysort(ss, -1)
A. [1,2,4,3]
B、[3,4.2,1]
C、[1,2,3, 4]
D、[4,3,2, 1]
答案: D
本题创建了函数，函数体内利用sorted()函数对形参ss进行排序，排序的方式根据形参1ag来确认。程序主体创建列表S，调用函数mysort(),传入实参ss及-1,根据-1可知，分支语句执行的是if分支，则排序方式按照从大到小进行排序。

85. 以下代码的执行结果是()√
    Is= []
    for i in range(11):
    ls.append(i**2)
    ls.reverse()
    print(Is)
    A、[100, 64, 36, 16, 4,0,1,9,25, 49, 81]
    B、[0, 1,4, 9, 16, 25, 36, 49, 64, 81, 100]
    C、[121, 100, 81, 64, 49, 36, 25, 16, 9,4, 1]
    D、[1,4,9, 16, 25, 36, 49, 64, 81, 100,121]
    答案: A
    观察题目中代码，每次循环都将列表添加一个i的平方，并且将列表逆序，根据分析，列表中数据依次为[0]、[1,0]、 [4,0,1]、 [9,1,0,4]、 [16,4,0,1,9]、 [25,9,1,0.4,16]、[36,16,4,0,1,9,25]、 [49,25,9,1,0,4,16,36]、[64,36,16,4,0,1,9,25.,49]、[81,49,25,9,1,0.4,16,36,64]和[100,64,36,16,4,0,1,9,25,49,81]。

86. 以下代码的执行结果是( )√
    Is= [“abc”, [“abcdef”, “123”, “xyz”], [“abc”, “xyz”, “123”], “abc”]
    print(len(Is[1][-3]))
    A、1
    B、6
    C、3
    D、出错
    答案: B
    通过索引嵌套取值，首先取ls的第2个元素为[“abcdef”, “123”, “xyz”]，然后所以取此元素的倒数第三个为"abcdef"，最后len()函数求得此元素的长度为6。

87.以下语句的输出结果是()√
dd = {‘chinese’:200,‘pe’:187,‘Gana’:930}
print(sorted(dd.keys()))
A. dict_ key("Gana’, ‘chinese’, ‘pe’])
B、‘Gana’, ‘chinese’, ‘pe’
C、[‘Gana’, ‘chinese’, ‘pe]
D、报错
答案: C
观察题目可以知道sorted()函数排序的数据是dd字典通过keys()方法返回的全部的键，所以从小到大比较三个字符串得到列表[Gana’, ‘chinese’, 'pe]。

88. 第1题:以下代码的执行结果是( )×
    dt={‘a’: 10, ‘b’ :20}
    print(type(dt[‘a’]))
    A、<class ‘tuple’>
    B、<class ‘str’>
    C、<class ‘int’>
    D、<class ‘dict’>
    答案: C
    首先创建了dt字典，然后利用type()函数得到的d通过a键取出值的数据类型，最后输出。当dt通过’a’键取值得到的数据为10, type(10)的返回值为<class ‘int’>。

89.关于全局变量和局部变量的描述，错误的选项是()√
A、全局变量在Python文件最外层声明时，语句前没有缩进
B、局部变量标识符不能与任何全局变量的标识符相同，即严格不能重名
C、在函数内部引用数字类型全局变量时，必须使用global保留字声明
D、在函数内部引用组合类型全局变量时，可以不通过global保留字声明
答案: B
在Python语言中局部变量可以是任意标志符，因为局部变量在函数结束时，并相当于被销毁，所以即使与全局变量同名，也可以正常运行。

90. 关于函数参数的描述，错误的选项是( )√
    A、采用参数名称传递参数，可以增加程序的可读性
    B、函数调用时，默认按照位置顺序传递参数
    C、采用参数名称传递参数，可以不按照参数的默认顺序
    D、函数的可选参数可以放在非可选参数的前面
    答案: D
    函数的参数顺序必须是可选参数放在非可选参数后面。

91.以下代码的执行结果是( )√
x= [3,4,5],[10,11],[12,13],14]]
print(len(x))
A、4
B、2
C、3
D、5
答案: B
先创建了x列表，然后用len()函数计算x列表的长度并输出。列表的长度就是列表中元素的数量，x列表有两个元素，分别是[3,4,5]和[10,11]、[12,13],14]，所以长度为2。

92.以下代码的执行结果是( )×
L1=[1,2,3,4]
st="
for i in L1:
st+= i
print(st)
A、‘1234’
B、10
C、1234
D、程序执行错误
答案: D
首先创建了L1列表和st空字符串，然后循环遍历列表，每次循环将遍历的元素拼接给st字符串。因为L1中的元素为数字类型不能和字符串拼接，所以会出现异常。

93.在以下程序后执行选项中代码,报错的是( )√
d = [{‘作者’: ‘Jone’,’密码’：*****,’收藏’:[]}"作品:[‘日出’,’平凡人生’]}]
A. print(d[0][‘作者’])
B、print(d[01[”作者’][4])
C、print([1][作品][0])
D、print(d[1][作品][1])
答案: B
A选项中d[0][作者]得到的结果为"jone’正确;
B选项在"jone’的基础上取索引的值错误;
C选项d[1][作品][0]得到的结果为’日出’正确;
D选项d[1][作品][1]得到的结果为’平凡人生’正确。

94.关于函数全局变量和局部变量的描述，错误的选项是()√
A、在函数内部引用局部变量时可以不用nonlocal保留字声明
B、在函数内部引用全局变量时一定要用global声明
C、全局变量指在函数外部创建的变量
D、在函数内部创建的局部变量，在函数外部不能引用
答案: B
在函数内部引用全局变量可以不使用globaI声明，如果是更改全局变量的话，一般是需要声明的。

95.关于Python组合数据类型的描述，正确的选项是( )√
A、列表类型的元素访问需要索引，有正向递增和反向递减两种方式
B、集合类型的元素访问需要索引，有正向递增和反向递减两种方式
C、元组类型和列表类型都属于集合类型
D、字典类型是“键-值"数据项的组合，各键值对元素之间有先后关系
答案: A
列表类型访问元素可以通过索引取值的方式，有正向递增索引和反向递减索引两种方式，A选项正确;
集合类型是无序的，所以没有索引，B选项错误;
元组类型和列表类型和集合类型无关，C选项错误;
字典类型是键值数据项的组合，但是字典没有顺序，所以D选项错误。

96.关于组合数据类型的描述，错误的选项是( )×
A、s是一个集合类型变量，则语句"x not in s"表示如果x不是s的元素，返回True, 否则返回False
B、赋值语句animal = “cat”, “dog”, “tiger”, “rabit”, 产生一个元组类型变量
C、s是一个集合类型变量,若s={235,10,50,10}， 则执行print(s)的结果可能是{10,235,50}
D、s是一个列表类型变量，则语句"x is in s"示如果x是s的元素，返回True,否则返回False
答案: D
not in表达式判断是否存在，如果不存在返回True,存在返回False，A选项正确;
直接将多个元素通过逗号赋值给一个变量，会自动将数据加上括号形成元组进行赋值，B选项正确;
集合是无序不可重复的数据类型，所以会自动去重，顺序也可能是任意形式，C选项正确;
判断是否存在是使用in关键字，不存在is in表示，D选项错误。本题选择D选项。

97.关于列表类型的描述，正确的选项是( )√
A. list(x)可以将一个整数x转换为列表[x]
B、列表Is=[1,2,3,4,5], s=ls[3:4]结果是4, 结果是整数类型
C、列表ls=[1,2,3,4,5], s=Is[3:4]结果是[4], 结果是列表类型
D、list({“a":1,”b":2})结果为[“a”, 1, “b”, 2]
答案: C
list()函数的参数需要是多元素数据类型，比如元组，字符串，字典等，当直接转换字典的时候，是对字典的键进行操作，等于舍弃字典的值，所以A选项错误，D选项错误;
切片[3.4]选取第4位元素到第5位元素 ，包含第4位不包含第5位，所以取到4，且返回值为列表类型，B选项错误，C选项正确。本题选择C选项。