python期末：组合数据

第6章 组合数据

1. 以下关于组合数据类型的描述，正确的是（ ）。

A.集合类型中的元素是有序的

B.序列类似和集合类型中的元素都是可以重复的

C.一个映射类型变量中的关键字可以是不同类型的数据

D.利用组合数据类型可以将多个数据用一个类型来表示和处理

2. 以下关于组合数据类型的描述，错误的是（ ）。

A.集合类型是一种具体的数据类型

B.序列类似和映射类型都是一类数据类型的总称

C.python 的集合类型跟数学中的集合概念一致，都是多个数据项的无序组合

D.字典类型的键可以用的数据类型包括字符串，元组，以及列表

3. 关于Python的组合数据类型，以下选项中描述错误的是（ ）。

A. 组合数据类型可以分为3类：序列类型、集合类型和映射类型

B. 序列类型是二维元素向量，元素之间存在先后关系，通过序号访问

C. Python的str、tuple和list类型都属于序列类型

D. Python组合数据类型能够将多个同类型或不同类型的数据组织起来，通过单一的表示使数据操作更有序、更容易

4. 以下选项，正确的是（ ）。

A. 序列类型是一维元素向量，元素之间存在先后关系，通过序号访问

B. 序列类型可以分为3类：字符串、字典和列表

C. 表示单一数据的类型被称为组合数据类型

D. Python的str、dict、tuple和list类型都属于序列类型

5. 以下关于组合类型的描述，错误的是（ ）。

A.可以用大括号创建字典，用中括号增加新元素

B.嵌套的字典数据类型可以用来表达高维数据

C.字典的 pop 函数可以返回一个键对应的值，并删除该键值对

D.空字典和空集合都可以用大括号来创建

6. 以下选项中不属于组合数据类型的是（ ）。

A.变体类型 B.字典类型 C.映射类型 D.序列类型

7. 以下不是组合数据类型的是（ ）。

A.集合类型 B.序列类型 C.映射类型 D.引用类型

8. 以下表达式，正确定义了一个集合数据对象的是（ ）。

A. x = { 200, ’flg’, 20.3} B. x = ( 200, ’flg’, 20.3)

C. x = [ 200, ’flg’, 20.3 ] D. x = {‘flg’ : 20.3}  

9. 关于列表的说法，描述有错误的是（ ）。

A.list是一个有序集合，没有固定大小           B.list可以存放任意类型的元素

C.使用list时，其下标可以是负数              D.list是不可变的数据类型

10.关于Python的列表，描述错误的选项是（ ）。

A.Python列表是包含0个或者多个对象引用的有序序列 B.Python列表用中括号[]表示

C.Python列表是一个可以修改数据项的序列类型 D.Python列表的长度不可变的

11.以下关于列表和字符串的描述，错误的是（ ）。

A.列表使用正向递增序号和反向递减序号的索引体系

B.列表是一个可以修改数据项的序列类型

C.字符和列表均支持成员关系操作符（in）和长度计算函数（len()）

D.字符串是单一字符的无序组合

12.关于 Python 序列类型的通用操作符和函数，以下选项中描述错误的是（ ）。

A.如果 x 不是 s 的元素，x not in s 返回 True

B.如果 s 是一个序列，s = [1,“kate”,True]，s[3] 返回 True

C.如果 s 是一个序列，s = [1,“kate”,True]，s[–1] 返回 True

D.如果 x 是 s 的元素，x in s 返回 True

13.以下关于列表操作的描述，错误的是（ ）。

A.通过 append 方法可以向列表添加元素

B.通过 extend 方法可以将另一个列表中的元素逐一添加到列表中

C.通过 insert(index,object) 方法在指定位置 index 前插入元素 object

D.通过 add 方法可以向列表添加元素

14.对于列表ls的操作，以下选项中描述错误的是（ ）。

A.ls.clear()：删除ls的最后一个元素 B.ls.copy()：生成一个新列表，复制ls的所有元素

C.ls.reverse()：列表ls的所有元素反转 D.ls.append(x)：在ls最后增加一个元素

15.下列删除列表中最后一个元素的函数是（ ）。

A. del          B. pop         C. remove          D. cut

16.下列函数中，用于使用函数对指定序列进行过滤的是（ ）。

A.map函数       B.select函数      C.filter函数         D.reduce函数

17.已知id(ls1) = 4404896968，以下程序的输出结果是（ ）。

ls1 = [1,2,3,4,5]

ls2 = ls1

ls3 = ls1.copy()

print(id(ls2),id(ls3))

A.4404896968 4404896904 B.4404896904 4404896968

C.4404896968 4404896968 D.4404896904 4404896904

18.以下程序的输出结果是（ ）。 (提示：ord(“a”)==97)

list_demo=[1,2,3,4,5,'a','b']

print(list_demo[1],list_demo[5])

A.1 5         B.2 a             C.1 97           D.2 97

19.下面代码的输出结果是（ ）。

ls = list(range(1,4))

print(ls)

A.{0,1,2,3} B.[1,2,3] C.{1,2,3} D.[0,1,2,3]

20.下面代码的输出结果是（ ）。

a = [5,1,3,4]

print(sorted(a,reverse = True))

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

21.字符串 s = “I love Python”，以下程序的输出结果是（ ）。

s = “I love Python”

ls = s.split()

ls.reverse()

print(ls)

A.‘Python’, ‘love’, ‘I’ B.Python love I C.None D.[‘Python’, ‘love’, ‘I’]

22.以下程序的输出结果是（ ）。

L2 = [1,2,3,4]

L3 = L2.reverse()

print( L3)

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

23.下面代码的输出结果是（ ）。

vlist = list(range(5))

print(vlist)

A.0 1 2 3 4 B.0,1,2,3,4, C.0;1;2;3;4; D.[0, 1, 2, 3, 4]

24.下面代码的输出结果是（ ）。

listV = list(range(5))

print(2 in listV)

A.False B.0 C.-1 D.True

25.以下程序的输出结果是（ ）。

ls = [“浣熊”,“豪猪”,“艾草松鸡”,“棉尾兔”,“叉角羚”]

x = “豪猪”

print(ls.index(x,0))

A.0 B.-4 C.-3 D.1

26.以下程序的输出结果是（ ）。

ls =list(“the sky is blue”)

a = ls.index(‘s’,5,10)

print(a)

A.4            B.5          C.10          D.9

27.阅读下面的程序：

list_demo=[1,2,1,3]

nums=set(list_demo)

for i in nums:

      print(i,end="")

程序执行的结果为（ ）。

A.1213          B.213            C.321            D.123

28.以下程序的输出结果是（ ）。

ss = set(“htslbht”)

sorted(ss)

for i in ss:

print(i,end = ‘’)

A. htslbht B. hlbst C.tsblh D.hhlstt

29.以下程序的输出结果是（ ）。

ss = list(set(“jzzszyj”))    

ss.sort()

print(ss)

A.[‘z’, ‘j’, ‘s’, ‘y’] B.[‘j’, ‘s’, ‘y’, ‘z’] C.[‘j’, ‘z’, ‘z’, ‘s’, ‘z’, ‘y’, ‘j’] D.[‘j’, ‘j’, ‘s’, ‘y’, ‘z’, ‘z’, ‘z’]

30.下面代码的执行结果是（ ）。

ls=[[1,2,3],[[4,5],6],[7,8]]

print(len(ls))

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

31.以下代码的输出结果是（ ）。

         ls=[[1,2,3],‘python’,[[4,5,‘ABC’],6],[7,8]]

         print(ls[2][1])

A、‘ABC’       B、p          C、4           D、6

32.以下程序的输出结果是（ ）。

frame = [[1,2,3],[4,5,6],[7,8,9]]

rgb = frame[::-1]

print(rgb)

A.[[1, 2, 3], [4, 5, 6]] B.[[7, 8, 9]]

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

正确答案： D

33.如果name = “全国计算机等级考试二级Python”，以下选项中输出错误的是（ ）。

A.print(name[:])     全国计算机等级考试二级Python

B.print(name[11:])   Python

C.print(name[:11])  全国计算机等级考试二级

D.print(name[0], name[8], name[–1])     全 试

34以下程序的输出结果是（ ）。

for i in reversed(range(10, 0, -2)):

print(i,end=" ")

A.0 2 4 6 8 10         B.12345678910       C.9 8 7 6 5 4 3 2 1 0    D.2 4 6 8 10

35.运行以下程序，输出结果的是：

str1 = “Nanjing University”

str2 = str1[:7] + " Normal " + str1[-10:]

print(str2)

A. Normal U B. Nanjing Normal C. Normal University D. Nanjing Normal University

36.以下程序的输出结果是（ ）。

L2 = [[1,2,3,4],[5,6,7,8]]

L2.sort(reverse = True)

print( L2)

A.[5, 6, 7, 8], [1, 2, 3, 4] B.[[8,7,6,5], [4,3,2,1]]

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

37.以下程序的输出结果是（ ）。

x = [‘90’,‘87’,‘90’]

n = 90

print(x.count(n))                               # print(x.count(str(n)))  结果为2

A.1 B.2 C.None D.0

38.以下代码的输出结果是（ ）。

         ls = [“2020”, “1903”, “Python”]

         ls.append(2050)

         ls.append([2020, “2020”])

         print(ls)

A、['2020', '1903', 'Python', 2020, [2050, '2020']] B、['2020', '1903', 'Python', 2020]

C、['2020', '1903', 'Python', 2050, [2020, '2020']] D、['2020', '1903', 'Python', 2050, ['2020']]

39.下面代码的输出结果是（ ）。

ls = [“F”,”f”]

def fun(a):

ls.append(a)

return

fun(“C”)

print(ls)

A.[‘F’, ‘f’] B.[‘C’] C.出错 D.[‘F’, ‘f’, ‘C’]

40.ls = [1,2,3,4,5,6], 以下关于循环结构的描述，错误的是（ ）。

A.表达式 for i in range(len(ls)) 的循环次数跟 for i in ls 的循环次数是一样的

B.表达式 for i in range(len(ls)) 的循环次数跟 for i in range(0,len(ls)) 的循环次数是一样的

C.表达式 for i in range(len(ls)) 的循环次数跟 for i in range(1,len(ls)+1) 的循环次数是一样的

D.表达式 for i in range(len(ls)) 跟 for i in ls 的循环中，i 的值是一样的

41.以下程序的输出结果是（ ）。

ls1 = [1,2,3,4,5]

ls2 = [3,4,5,6,7,8]

cha1 = []

for i in ls2:

if i not in ls1:

    cha1.append(i)

print(cha1)

A.(6, 7, 8) B.(1,2,6, 7, 8) C.[1,2,6,7,8] D.[6, 7, 8]

42.下面代码的输出结果是（ ）。

for s in  “abc”:

for i in range(3):

print (s,end="")

if s==”c”:

break

A.aaabccc B.aaabbbc C.abbbccc D.aaabbbccc

43.以下程序的输出结果是（ ）。

ls =list({‘shandong’:200, ‘hebei’:300, ‘beijing’:400})

print(ls)

A.[‘300’,‘200’,‘400’] B.[‘shandong’, ‘hebei’, ‘beijing’]

C.[300,200,400] D.‘shandong’, ‘hebei’, ‘beijing’

44.以下程序的输出结果是（ ）。

img1 = [12,34,56,78]

img2 = [1,2,3,4,5]

def displ():

print(img1)

def modi():

img1 = img2

modi()

displ()

A.( [1,2,3,4,5]) B.[12, 34, 56, 78] C.([12, 34, 56, 78]) D.[1,2,3,4,5]

45.以下程序的输出结果是（ ）。

s=’’

ls = [1,2,3,4]

for l in ls:

s += str(l)

print(s)

A.1,2,3,4 B.4321 C.4,3,2,1 D.1234

46.以下代码执行的输出结果是（ ）。

ls = []

def func(a,b):

ls.append(b)

return a * b

s = func(“Hello!”,2)

print(s,ls)

A.出错 B.Hello!Hello! C.Hello!Hello! [2]       D.Hello!Hello! []

47.、以下程序的输出结果是（ ）。

dat=[‘1’, ‘2’, ‘3’, ‘0’, ‘0’, ‘0’]

for item in dat:

if item == ‘0’:

dat.remove(item)                #注意：删除一个’0’后分，访问的数据顺序要多移动一位

print(dat) #3个0留一个0，4和5个0是留2个，

A.[‘1’, ‘2’, ‘3’] B.[‘1’, ‘2’, ‘3’, ‘0’, ‘0’] C.[‘1’, ‘2’, ‘3’, ‘0’, ‘0’, ‘0’] D.[‘1’, ‘2’, ‘3’, ‘0’]

48.运行以下程序，输出结果的是（ ）。

print(" love ".join([“Everyday”,“Yourself”,“Python”,]))

A.Everyday love Yourself B.Everyday love Python

C.love Yourself love Python D.Everyday love Yourself love Python

49.下程序的输出结果是（ ）。

a = [“a”,“b”,“c”]

b = a[::-1]

print(b)

A.[‘a’, ‘b’, ‘c’] B.‘c’, ‘b’, ‘a’ C.‘a’, ‘b’, ‘c’ D.[‘c’, ‘b’, ‘a’]

50.以下程序的输出结果是（ ）。

L1 =[‘abc’, [‘123’,‘456’]]

L2 = [‘1’,‘2’,‘3’]

print(L1 > L2)

A.False B.TypeError: ‘>’ not supported between instances of ‘list’ and ‘str’

C.1 D.True

51.下面代码的输出结果是（ ）。

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)

A.0         B.45          C.以上答案都不对       D.24

52.已知以下程序段，要想输出结果为 1,2,3，应该使用的表达式是（ ）。

x = [1,2,3]

z = []

for y in x:

z.append(str(y))

A.print(z) B.print(",".join(x)) C.print(x) D.print(",".join(z))

53.以下程序的输出结果是（ ）。

lcat =[“狮子”,“猎豹”,“虎猫”,“花豹”,“孟加拉虎”,“美洲豹”,“雪豹”]

for s in lcat:

if "豹" in s:

    print(s,end="")

    continue

A.猎豹 花豹  美洲豹 雪豹· B.猎豹

C.雪豹 D.猎豹花豹美洲豹雪豹

54.以下程序的输出结果是（ ）。

ls = [“石山羊”,“一角鲸”,“南极雪海燕”,“竖琴海豹”,“山蝰”]

ls.remove(“山蝰”)

str =” ”

print(“极地动物有”,end="")

for s in ls:

str = str + s + ","

print(str[:-1],end="。")

A.极地动物有石山羊,一角鲸,南极雪海燕,竖琴海豹,山蝰

B.极地动物有石山羊,一角鲸,南极雪海燕,竖琴海豹,山蝰。

C.极地动物有石山羊,一角鲸,南极雪海燕,竖琴海豹

D.极地动物有石山羊,一角鲸,南极雪海燕,竖琴海豹。

55.下面代码的输出结果是（ ）。

s =[“seashell”,”gold”,”pink”,”brown”,”purple”,”tomato”]

print(s[1:4:2])

A.[‘gold’,’pink’,’brown’] B.[‘gold’, ‘pink’]

C.[‘gold’,’pink’,’brown’,’purple’,’tomato’] D.[‘gold’, ‘brown’]

56.以下程序的输出结果是（ ）。

x = [90,87,93]

y = [“zhang”, “wang”,“zhao”]

print(list(zip(y,x)))

A.(‘zhang’, 90), (‘wang’, 87), (‘zhao’, 93) B.[[‘zhang’, 90], [‘wang’, 87], [‘zhao’, 93]]

C.[‘zhang’, 90], [‘wang’, 87], [‘zhao’, 93] D.[(‘zhang’, 90), (‘wang’, 87), (‘zhao’, 93)]

57.以下关于字典类型的描述，错误的是（ ）。

A.字典类型是一种无序的对象集合，通过键来存取

B.字典类型可以在原来的变量上增加或缩短

C.字典类型可以包含列表和其他数据类型，支持嵌套的字典

D.字典类型中的数据可以进行分片和合并操作

58.以下关于字典类型的描述，正确的是（ ）。

A.字典类型可迭代，即字典的值还可以是字典类型的对象

B.表达式 for x in d: 中，假设d是字典，则x是字典中的键值对

C.字典类型的键可以是列表和其他数据类型

D.字典类型的值可以是任意数据类型的对象

59.以下关于字典的描述，错误的是（ ）。

A.字典中元素以键信息为索引访问 B.字典长度是可变的

C.字典是键值对的集合 D.字典中的键可以对应多个值信息

60.字典 d={‘Name’: ‘Kate’, ‘No’: ‘1001’, ‘Age’: ‘20’}，表达式len(d)的值为（ ）。

A.12 B.9 C.6 D.3

61.下列选项中，正确定义了一个字典的是（ ）。

A.a=[‘a’,1,‘b’,2,‘c’,3]    B.b=(‘a’,1,‘b’,2,‘c’,3)    C.c={‘a’,1,‘b’,2,‘c’,3}      D.d={‘a’:1,‘b’:2,‘c’:3}

62.以下选项中，不是建立字典的方式是（ ）。

A.d = {[1,2]:1, [3,4]:3} B.d = {(1,2):1, (3,4):3}

C.d = {‘张三’:1, ‘李四’:2} D.d = {1:[1,2], 3:[3,4]}

63.以下关于字典操作的描述，错误的是（ ）。

A.del 用于删除字典或者元素 B.clear 用于清空字典中的数据

C.len 方法可以计算字典中键值对的个数 D.keys 方法可以获取字典的值视图

64.运行以下程序，当从键盘上输入{1:“清华大学”,2:“北京大学”}，运行结果的是：

x =eval(input())

print(type(x))

A. B. C. 出错 D.

65.以下程序的输出结果是（ ）。

dict = {‘Name’: ‘baby’, ‘Age’: 7}

print(dict.items())

A.[(‘Age’, 7), (‘Name’, ‘baby’)] B.(‘Age’, 7), (‘Name’, ‘baby’)

C.‘Age’:7, ‘Name’: ‘baby’ D.dict_items([(‘Age’, 7), (‘Name’, ‘baby’)])

66.以下程序的输出结果是（ ）。

d = {“zhang”:“China”, “Jone”:“America”, “Natan”:“Japan”}

print(max(d),min(d))

A.Japan America B.zhang:China Jone:America

C.China America D.zhang Jone

67.以下程序的输出结果是（ ）。

d = {“zhang”:“China”, “Jone”:“America”, “Natan”:“Japan”}

for k in d:

print(k, end="")

A.ChinaAmericaJapan               B.zhang:China Jone:America Natan:Japan

C.“zhang””Jone””Natan”             D.zhangJoneNatan

68.以下程序的输出结果是（ ）。

Da = {“北美洲”:“北极兔”,“南美洲”:“托哥巨嘴鸟”,“亚洲”:“大熊猫”,“非洲”:“单峰驼”,“南极洲”:“帝企鹅”}

Da[“非洲”] = “大猩猩”

print(Da)

A.(‘北美洲’: ‘北极兔’, ‘南美洲’: ‘托哥巨嘴鸟’, ‘亚洲’: ‘大熊猫’, ‘非洲’: ‘大猩猩’, ‘南极洲’: ‘帝企鹅’)

B.[‘北美洲’: ‘北极兔’, ‘南美洲’: ‘托哥巨嘴鸟’, ‘亚洲’: ‘大熊猫’, ‘非洲’: ‘大猩猩’, ‘南极洲’: ‘帝企鹅’]

C.{“北美洲”:“北极兔”,“南美洲”:“托哥巨嘴鸟”,“亚洲”:“大熊猫”,“非洲”:“单峰驼”,“南极洲”:“帝企鹅”}

D.{‘北美洲’: ‘北极兔’, ‘南美洲’: ‘托哥巨嘴鸟’, ‘亚洲’: ‘大熊猫’, ‘非洲’: ‘大猩猩’, ‘南极洲’: ‘帝企鹅’}

69.下面代码的输出结果是（ ）。

d ={“大海”:“蓝色”, “天空”:“灰色”, “大地”:“黑色”}

print(d[“大地”], d.get(“大地”, “黄色”))

A.黑的 灰色      B.黑色 黑色         C.黑色 蓝色        D.黑色 黄色

70.以下代码的输出结果是（ ）。

d ={“大海”:“蓝色”, “天空”:“灰色”, “大地”:“黑色”}

print(d[“大地”], d.get(“天空”, “黄色”))

A、黑色  黑色 B、黑色  灰色 C、黑色  黄色 D、黑色  蓝色

71.给出如下代码：

DictColor = {“seashell”:“海贝色”,“gold”:“金色”,“pink”:“粉红色”,“brown”:“棕色”, “purple”:“紫色”,“tomato”:“西红柿色”}

以下选项中能输出“海贝色”的是（ ）。

A.print(DictColor.keys()) B.print(DictColor[“海贝色”])

C.print(DictColor.values()) D.print(DictColor[“seashell”])

72.假设将单词保存在变量 word 中，使用一个字典类型 counts={}，统计单词出现的次数可采用以下代码（ ）。

A.counts[word] = count[word] + 1

B.counts[word] = 1

C.counts[word] = count.get(word,1) + 1

D.counts[word] = count.get(word,0) + 1

73.以下代码的输出结果是（ ）。

          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="")

A、Plguba B、Cabugl C、Python D、Cython

74.给出如下代码

MonthandFlower={“1月”:“梅花”,“2月”:“杏花”,“3月”:“桃花”,“4月”:“牡丹花”,“5月”:“石榴花”,“6月”:“莲花”,“7月”:“玉簪花”,“8月”:“桂花”,“9月”:“菊花”,“10月”:“芙蓉花”,“11月”:“山茶花”,“12月”:“水仙花”}

n = input(“请输入1—12的月份:”)

print(n + “月份之代表花：” + MonthandFlower.get(str(n)+“月”))   

以下选项中描述正确的是（ ）。

A.代码实现了获取一个整数（1—12）来表示月份，输出该月份对应的代表花名

B.MonthandFlower是列表类型变量

C.MonthandFlower是一个元组

D.MonthandFlower是集合类型变量

75.元组变量t=(“cat”, “dog”, “tiger”, “human”)， t[::-1]的结果是（ ）。

A.{‘human’, ‘tiger’, ‘dog’, ‘cat’} B.[‘human’, ‘tiger’, ‘dog’, ‘cat’]

C.运行出错 D.(‘human’, ‘tiger’, ‘dog’, ‘cat’)

参考答案： 

1D 2D 3B 4A 5D 6A 7D 8A 9D 10D 11D 12B 13D 14A 15B 16C 17A 18B 19B 20B

21D 22D 23D 24D 25D 26D 27D 28B 29B 30A 31D 32D 33D 34D 35D 36D 37D 38C 39D 40D

41D 42B 43B 44B 45D 46C 47D 48D 49D 50D 51B 52D 53D 54D 55D 56D 57D 58D 59D 60D

61D 62A 63D 64D 65D 66D 67D 68D 69B 70B 71D 72D 73D 74A 75D