超星Python程序设计及应用（上）_2期末答案(学习通2023完整答案)
94 min read超星Python程序设计及应用（上）_2期末答案(学习通2023完整答案)
Python概述知识检测
1、超星程序Python脚本文件的设计扩展名为（ ）。
A、用上python
B、期末py
C、答案pt
D、学习pg
2、通完关于Python代码运行的整答描述中，不正确的超星程序是（ ）。
A、设计Python代码运行分为交互式和脚本式两种
B、用上程序员可以在交互式运行中便捷的期末获取语句运行的结果，交互式运行适用于实验性、答案验证性的学习操作
C、当代码量较大时，通完更适合组织在脚本文件中，采取一次性运行的方式，并且代码将以文件的形式被留存下来
D、假设在E盘根目录下有一个名为hello.py的Python脚本文件，在操作系统的命令行方式下运行它的方法是：python e:\hello
3、以下描述中正确的是（ ）。
A、Python是一种跨平台的计算机程序设计语言
B、Python是一种解释型脚本语言
C、解释是将源代码逐条转换成目标代码同时逐条运行目标代码的过程
D、Python具有丰富的第三方库，是人工智能的首选计算机语言
第2周 Python编程基础
Python编程基础检测
1、关于Python 中的变量描述错误的是（ ）。 知识点：对Python变量的理解
A、Python 不需要显式声明变量类型，在变量被赋值时由值决定变量的类型
B、变量通过变量名进行存取操作
C、Python中的变量可以随时更改自己保存的数据，不仅是取值的变化，也包括数据类型的变化
D、Python中，变量age与变量Age被看作是相同的变量
2、执行以下程序，输入5，输出的结果是（ ）。 a = input() b = a+6 print(b) 知识点：数据类型
A、11
B、'56'
C、56
D、运行出错
3、下面代码的输出结果是（ ）。 >>> x = 26.59 >>> print(type(x)) >>> y = "100083" >>> print(type(y)) 知识点：数据的类型
A、<class 'float'> <class 'str'>
B、<class 'int'> <class 'str'>
C、<class 'float'> <class 'int'>
D、<class 'int'> <class 'int'>
4、关于函数，下面说法不正确的是（ ）。 知识点：Python中的函数
A、Python的函数分为内置函数、标准库函数和第三方库函数
B、内置函数无需安装也无需导入即可使用
C、在Python标准环境中，标准库和第三方库都需要先安装，然后导入后使用
D、turtle是Python的标准库
5、以下程序执行时会有错误提示的是（ ）。 知识点：数据类型
A、print(str(125.68))
B、print(float(15))
C、print(int('4.6'))
D、print(2.6e3)
6、关于 Python 语言的注释，以下选项中描述错误的是（ ）。 知识点：注释的形式
A、Python 的单行注释以#开头
B、Python 的单行注释以单引号'开头
C、Python 的多行注释用三引号字符串实现，以三单引号开头和结尾，或者以三双引号开头和结尾
D、Python 语言有两种注释方式：单行注释和多行注释
7、在IDLE中使用 import math help(math.gcd) 查看math库中gcd函数的文档信息。 关于gcd()函数，下面说法正确的是（ ）。 知识点：查询Python帮助信息
A、它有两个参数，返回它们的最大公约数
B、它有两个参数，返回它们的最小公倍数
C、没有这个函数
D、它有三个参数，返回它们的最大公约数
8、下面程序段的输出结果是（ ）。 s="python''|'很\t有趣\n" print(len(s)) 知识点：转义字符
A、14
B、15
C、16
D、17
9、不够输出20个星号的语句是（ ）。 知识点：字符串的复制
A、print("试题及答案试题及答案试题及答案**")
B、print("*"*20)
C、print(20*"*")
D、print(20+"*")
10、在Python的海龟绘图中，以下说法错误的是（ ）。 知识点：turtle库基础知识
A、海龟绘图中画板的坐标原点位置在画板左上角
B、海龟绘图的整个画板对应平面直角坐标系，画板的大小可以设置
C、海龟绘图中left(angle)表示向左转angle角度，right(angle)表示向右转angle角度
D、海龟绘图中goto(x,y)实现画笔绝对定位，重新定位时通常用up()先抬起画笔
11、在Python语言中海龟绘图，关于circle()函数说法错误的是（ ）。 知识点：turtle库的circle()函数
A、circle()函数不仅能画圆，还能指定角度画弧，以及指定steps参数画圆的内接正多边形
B、circle(100, 180)在画笔前进方向的右侧画一个半圆
C、circle(100, 180)在画笔前进方向的左侧画一个半圆
D、circle(100, steps=6)在画笔前进方向的左侧画了半径为100像素的圆的内接正六边形
12、设有以下语句： m = eval(input("m=")) n = eval(input("n=")) 如果输入的m和n的取值为100和24，则输出： 100/24=4,100%24=6 如果输入的m和n取值为24和100，则输出： 24/100=0,24 % 100=24 那么，可以严格按照该格式输出的print()是（ ）。 知识点：字面量、变量、、数据类型、print 提示：format()的使用可以自行查询，我们将在第4章学习它的应用
A、print(str(m)+"/"+str(n)+"="+str(m//n),end=",") print(str(m)+"%"+str(n)+"="+str(m%n))
B、print(m/n=m//n) print(m%n=m%n)
C、print(m,"/",n,"=",m//n,end=",") print(m,"%",n,"=",m%n)
D、print("{ }/{ }={ }".format(m,n,m//n),end=",") print("{ }%{ }={ }".format(m,n,m%n))
13、在Python中表示如下字符串 I'm happy 的常量形式可以是（ ）。 知识点：字符串常量
A、"I'm happy"
B、I'm happy
C、'I'm happy'
D、'I\'m happy'
14、下面能够计算5的6次幂的方法包括（ ）。 知识点：算术运算
A、5*5*5*5*5*5
B、5**6
C、pow(5,6)
D、import math math.pow(5,6)
第3周 Python流程控制结构
Python流程控制测试
1、不能够正确表达下面语义的Python表达式是（ ）。 知识点：逻辑运算
A、Python中，判断一个商品的价格price是否在[1000,3000)之间的逻辑表达式为1000<=price<3000
B、人类按照地球绕太阳公转的时间制定了计时的立法，闰年满足的条件是：年号可以被4整除，但是不能被100整除，比如2020年是闰年，1900年不是闰年；年号能被400整除，例如2000年是闰年。表达闰年的逻辑表达式为：year%4==0 and year % 100!=0 or year%400==0
C、假设a,b,c表示能够构成三角形的三条边，那么它们能构成等边三角形的逻辑表达式为：a==b==c
D、假设math代表数学的成绩，English代表英语的成绩，那么数学和英语至少有一门高于95分的逻辑表达式为：math>95 or English >95
2、以下对 Python 程序缩进格式描述错误的选项是（ ）。 知识点：缩进。
A、不需要缩进的代码必须顶行写，前面不能留空白
B、缩进可以键入多个空格，也可以用 tab 键实现
C、严格的缩进可以约束程序结构，可以多层缩进
D、Python的缩进仅针对程序员，用来美化程序格式、提高程序可读性，
3、下面能正确输出如下turtle图的代码是（ ）。 知识点：循环的嵌套
A、import turtle turtle.width(5) turtle.color("green") for i in range(4): turtle.forward(200) turtle.right(90) for j in range(2): turtle.forward(50) turtle.right(90) turtle.hideturtle() turtle.done()
B、import turtle turtle.width(5) turtle.color("green") for i in range(4): turtle.forward(200) turtle.right(90) for j in range(4): turtle.forward(50) turtle.right(90) turtle.hideturtle() turtle.done()
C、import turtle turtle.width(5) turtle.color("green") for i in range(4): turtle.forward(200) turtle.right(90) turtle.forward(50) turtle.right(90) turtle.hideturtle() turtle.done()
D、import turtle turtle.width(5) turtle.color("green") for i in range(4): turtle.forward(200) turtle.right(90) for j in range(3): turtle.forward(50) turtle.right(90) turtle.hideturtle() turtle.done()
4、关于函数，以下选项中描述错误的是（ ）。 知识点：函数的理解
A、函数能完成特定的功能，对函数的使用不需要了解函数内部实现原理，只要了解函数的名字、参数和返回值即可
B、使用函数的主要目的是降低代码规模或者进行代码重用
C、Python函数体中一定会使用return语句返回值或者结束函数的运行
D、参数使函数实现了对不同的数据进行相同的加工处理
5、关于Python循环结构，以下选项中描述不正确的是（ ）。 知识点：循环结构的理解
A、for循环结构用遍历的方式对字符串或者range()对象中的每个元素进行操作
B、遇到break语句后，所有层次的循环都会结束
C、所有for循环功能都可以用while循环结构替代
D、使用while循环不需要预知循环次数
6、以下程序的输出结果是（ ）。 for s in 'xyab': for i in range(3): if s=='a': break print(s,end='') 知识点：循环的嵌套
A、xybxybxyb
B、xyxyxy
C、xxxyyybbb
D、xxxyyy
7、以下程序的输出结果是（ ）。 for i in range(3): for s in 'xyzabc': if s=='a': break print(s,end='') 知识点：循环的嵌套
A、xyzxyzxyz
B、xyzaxyzaxyza
C、xxxyyyzzz
D、xxxyyyzzzaaa
8、如果自定义一个函数draw_polygon()，能够画出下面的任一正多边形，那么这个函数的参数设计合理的是（ ）。 知识点：函数首部的设计
A、draw_polygon(n,side_length,pen_color,ploygon_color)
B、draw_polygon(n,side_length,ploygon_color)
C、draw_polygon(n,pen_color,ploygon_color)
D、draw_polygon(pen_color,ploygon_color)
9、下面程序的运行结果是（ ）。 x,y,z = 5,-2,8 if x>y: if y>=0: z=0 else: z+=2 print(z) 知识点：分支的逻辑
A、10
B、没有结果
C、0
D、8
10、下面程序的运行结果是（ ）。 import math x,y = 3,4 if x>math.sqrt(y): x,y = x**2,y**2 else: x,y = 2*x,2*y print(x,y) 知识点：分支的逻辑
A、9 16
B、3 4
C、6 8
D、提示语法错误
11、已知字符“▼”的Unicode码位为“25BC”。 下面的代码，能够正确输出如下图形的是（ ）。 知识点：for循环。
A、for i in range(4, 0, -1): print(" "*(4-i)+"\u25BC"*(2*i-1))
B、for i in range(4): print(" "*i+"\u25BC"*(7-2*i))
C、for i in range(4): for j in range(i): print(" ",end="") for j in range(7-2*i): print("\u25BC",end="") print()
D、for i in range(4): print(" "*(4-i)+"\u25BC"*(2*i-1))
12、下面的代码，能够正确判断一个正整数位数的是（ ）。 知识点：分支。
A、a = int(input("输入一个10000以内的正整数:")) if 0<a<10: print(str(a)+"是1位数") elif a<100: print(str(a)+"是2位数") elif a<1000: print(str(a)+"是3位数") elif a<10000: print(str(a)+"是4位数") else: print("数据有误")
B、a = int(input("输入一个10000以内的正整数:")) if 0<a<10000: print(str(a)+"是"+str(len(str(a)))+"位数") else: print("数据有误")
C、a = input("输入一个10000以内的正整数:") if 0<a<10: print(a+"是1位数") elif a<100: print(a+"是2位数") elif a<1000: print(a+"是3位数") elif a<10000: print(a+"是4位数") else: print("数据有误")
D、a = int(input("输入一个10000以内的正整数:")) if 1000<=a<10000: print(str(a)+"是4位数") elif a>=100: print(str(a)+"是3位数") elif a>=10: print(str(a)+"是2位数") elif a>0: print(str(a)+"是1位数") else: print("数据有误")
13、对若干个正数求和，输入“ok”结束，下面正确的代码是（ ）。 知识点：while循环。
A、s = 0 x = input() while x!="ok": s += int(x) print(s)
B、s = 0 while True: x = input() if x=="ok": break s += int(x) print(s)
C、s = 0 x = input() while x!="ok": s += int(x) x = input() print(s)
D、s = 0 while x!="ok": x = input() s += int(x) print(s)
14、生成[3,9]区间内的随机整数的正确表达是（ ）。 知识点：random模块 提示：用help()方法查看函数的说明，读懂Python提供的信息
A、import random random.randint(3,9)
B、import random random.randint(3,10)
C、import random random.randrange(3,10)
D、range(3,9)
第4周 Python容器数据类型（一）
Python容器数据类型测试（一）
1、下面代码的运行结果是（ ）。 s1 = "20201021" for ch in s1: if int(ch) < 2: continue else: s2 = s1.replace(ch, 'a') print(s1) print(s2) 知识点：字符串的不可变性，replace方法
A、20201021 a0a010a1
B、a0a010a1 a0a010a1
C、20201021 20201021
D、a0a010a1 20201021
2、以下代码的输出结果是（ ）。 print('{ :#>12.4}'.format('random')) 知识点：format方法
A、########rand
B、######random
C、random######
D、rand########
3、下面有一段英文绕口令，统计其中“wish”出现的次数以及它出现的所有位置，在代码段中需要填入的是（ ）。 str1 = "I wish to wish the wish you wish to wish, but if you wish the wish the witch wishes, I won't wish the wish you wish to wish." word = "wish" count = str1.count(word) order = "" pos = -4 for i in range(count): 此处应填入的代码是？ order += str(pos)+" " print("'wish'出现的次数:{ }".format(count)) print("'wish'出现的位置包括:{ }".format(order)) 知识点：字符串的find方法
A、pos = str1.find(word, pos+len(word))
B、pos = str1.find(word, pos)
C、pos = str1.find(word, len(word))
D、pos = str1.find(word, pos-len(word))
4、这是中国最美的几个地方，编写程序，按如下的方式实现输出时，需要填入的代码是（ ）。 001 云南罗平 002 四川稻城 003 广西龙脊梯田 004 新疆帕米尔高原 005 浙江乌镇 006 云南泸沽湖 str1 = "1、云南罗平；2、四川稻城；3、广西龙脊梯田；4、新疆帕米尔高原；5、浙江乌镇；6、云南泸沽湖" s1 = str1.split('；') for item in s1: s2 = item.split('、') 此处应填入的代码是？ 知识点：format方法，字符串的切分与列表
A、print('{ :0>3}'.format(s2[0]), s2[1])
B、print('{ :>3}'.format(s2[0]), s2[1])
C、print('{ :0>3}'.format(s2[1]), s2[2])
D、print('{ :>3}'.format(s2[1]), s2[2])
5、以下程序的输出结果是（ ）。 s = 'www.python.org' str1=s.split('.') str1.reverse() print(str1) 知识点：列表的reverse方法
A、['org', 'python', 'www']
B、'gro.nohtyp.www'
C、['www', 'python', 'org']
D、('org', 'python', 'www')
6、下面程序的输出结果是（ ）。 ls=["April","March","January","February","May","June"] ls.sort(reverse=True) print(ls) 知识点：排序
A、['May', 'March', 'June', 'January', 'February', 'April']
B、['April', 'February', 'January', 'June', 'March', 'May']
C、["January","February","March","April","May","June"]
D、["June","May","April","March","February","January"]
7、以下代码的输出结果是（ ）。 x=[1,2,3] ls=[4,5,6] for i in range(x[2]): ls.append(i*i) print(ls) 知识点：列表
A、[4, 5, 6, 0, 1, 4]
B、[4, 5, 6, 0, 1, 2]
C、[4, 5, 6, 0, 1]
D、[1, 4, 9]
8、以下代码的输出结果是（ ）。 ls = [[1,2,3],[4,5,6],[7,8,9]] lt = ls[::-1] print(lt) 知识点：序列的切片
A、[[7, 8, 9], [4, 5, 6], [1, 2, 3]]
B、[9, 8, 7, 6, 5, 4, 3, 2, 1]
C、[[1, 2, 3], [4, 5, 6]]
D、[[7, 8, 9]]
9、以下说法不正确的是（ ）。
A、Python中序列类型包含字符串、列表和元组三种
B、序列类型元素之间存在位置上的先后关系，元素都可以通过索引按位置访问，按位置进行修改
C、序列的索引包括正向索引和反向索引两种
D、Python中，容器式的数据类型可以分为三类：序列类型、集合类型和字典类型
10、s='abcdefg'，以下表示子串‘abcd’的选项是（ ）。 知识点：字符串索引及切片
A、s[0:4]
B、s[0,4]
C、s[:4]
D、s[,4]
11、下面说法正确的是（ ）。 知识点：列表->字符串
A、time = [23,59,59] print(":".join(time)) 的输出结果是23:59:59
B、time = ['23','59','59'] print(":".join(time)) 的输出结果是23:59:59
C、time = ['23','59','59'] t_str = "" for t in time: t_str += t+":" print(t_str) 程序输出结果是23:59:59
D、time = [23,59,59] t_str = "" for i in range(len(time)): if i<len(time)-1: t_str += str(time[i])+":" else: t_str += str(time[i]) print(t_str) 程序输出结果是23:59:59
12、求解下图所示的数字谜： def fun(x): qian,rest = divmod(x,1000) bai,rest = divmod(rest,100) shi,ge = divmod(rest,10) return qian, bai, shi, ge for x in range(1000, 2500): 此处应填入的代码是？ if 1000*d+100*c+10*b+a == 4*x: print('该四位数是：',x) 以上空白处可填入的代码是（ ）。 知识点：元组
A、(d,c,b,a) = fun(x)
B、(a,b,c,d) = fun(x)
C、a,b,c,d = fun(x)
D、d,c,b,a = fun(x)
第5周 Python容器数据类型（二）
Python容器数据类型测试（二）
1、下面叙述正确的是（ ）。 知识点：集合
A、以下代码的输出结果为8。 s = { 8,16,9,10,5} ls = list(s) ls.sort() print(ls[1])
B、以下代码的输出结果为16。 s = { 8,16,9,10,5} print(s[1])
C、以下代码的输出结果为5。 s = { 8,16,5,10,5} print(len(s))
D、以下代码的输出结果为{ 5,8,9,10,16}。 s = { 8,16,9,10,5} s.sort() print(s)
2、假设特等奖、一等奖、二等奖、三等奖的中奖概率分别为1%，6%，28%，65%。下面的程序模拟100次抽奖结果，统计每个奖项的中奖次数。提示：程序生成100个[0,1]区间随机数，通过判断每个随机数落在哪个中奖区间内完成统计。 下面应填入的代码是（ ）。 import random d_prize={ '特等奖': (0,0.01), '一等奖': (0.01,0.07), '二等奖': (0.07,0.35), '三等奖': (0.35,1.0) } result = dict() for i in range(100): 空1 for key,value in d_prize.items(): if value[0]<=num<value[1]: 空2 for item in result.items(): print(item) 知识点：random库、字典
A、空1：num = random.uniform(0,1) 空2：result[key] = result.get(key,0)+1
B、空1：num = random.randint(0,1) 空2：result[key] = result[key]+1
C、空1：num = random.randint(0,1) 空2：result[key] = result.get(key,0)+1
D、空1：num = random.uniform(0,1) 空2：result[key] = result[key]+1
3、以下关于容器数据类型的描述，正确的是（ ）。 知识点：容器数据类型
A、序列类型和集合类型中的元素都是可以重复的
B、集合类型中的元素是有位序的
C、字典类型中的关键字可以是任意类型
D、序列类型包含字符串、列表和元组，它们都可以进行索引和切片操作
4、如果要打乱一个序列ls中元素的排列，下面正确的做法是（ ）。 知识点：random库
A、import random random.shuffle(ls)
B、import random random.choice(ls)
C、import random random.sample(ls)
D、import random random.seed(ls)
5、下面正确的说法是（ ）。 知识点：随机种子seed()函数
A、运行下面的代码两次，输出的随机数是相同的。 import random print(random.randint(1,100))
B、运行下面的代码两次，输出的随机数是相同的。 import random random.seed(10) print(random.randint(1,100))
C、运行下面的代码两次，输出的随机数是相同的。 import random random.seed() print(random.randint(1,100))
D、运行下面的代码两次，输出的随机数是相同的。 import random from datetime import datetime random.seed(datetime.now()) print(random.randint(1,100))
6、以下程序不可能的输出结果是（ ）。 import random ls=[68,35,28,90,53] print(random.choice(ls)) 知识点：random库
A、68
B、35
C、28
D、82
7、生成100个[1,30]内的随机整数，输出每个数字出现的次数，以下选项中可以完成此功能的是（ ）。注意：输出不允许出现重复，每个数字仅输出一次。 知识点：集合、字典
A、import random num = [ ] for i in range(100): num.append(random.randint(1,30)) s = set(num) for item in s: print(item,':',num.count(item))
B、import random num = [ ] for i in range(100): num.append(random.randint(1,30)) d={ } for v in num: d[v] = num.count(v) for key,value in d.items(): print(key,':',value)
C、import random num = [ ] for i in range(100): num.append(random.randint(1,30)) s = set(num) for item in s: print(item,':',s.count(item))
D、import random num = [ ] for i in range(100): num.append(random.randint(1,30)) for item in num: print(item,':',num.count(item))
8、给出如下代码：ds={ '周一':'Mon.','周二':'Tues.','周三':'Wed.','周四':'Thur.','周五':'Fri.'}，以下选项中能输出“Wed.”的是（ ）。 知识点：字典
A、print(ds.keys())
B、print(ds.values())
C、print(ds['周三'])
D、print(ds.get('周三'))
9、下面创建一个字典，包含以下键值对： '黑': '?' '红': '?' '梅': '?' '方': '◆' 正确的创建方式包括（ ）。 知识点：字典
A、d = { '黑': '?', '红': '?', '梅': '?', '方': '◆'}
B、d = dict([('黑','?'), ('红','?'), ('梅','?'),('方', '◆')])
C、d = dict(('黑','?'), ('红','?'), ('梅','?'),('方', '◆'))
D、d = dict(黑='?', 红='?', 梅='?', 方='◆')
10、将一个字典的键、值互换，例如{ 160: 'Aric', 168: 'Lily', 155: 'Mary'}，转换为{ 'Aric': 160, 'Lily': 168, 'Mary': 155}，下面应填入的代码是（ ）。 d_src = { 160: 'Aric', 168: 'Lily', 155: 'Mary'} d_dst = { } for 空1 in 空2 : 空2 print(d_dst) 知识点：字典
A、空1：key, value 空2：d_src.items() 空3：d_dst[value] = key
B、空1：key, value 空2：d_src.items() 空3：d_dst[key] = value
C、空1：key 空2：d_src.keys() 空3：d_dst[ d_src[key] ] = key
D、空1：key, value 空2：d_src.values() 空3：d_dst[ value ] = key
11、编写程序模拟便签纸，记录用户所需信息。要求使用字典保存便签信息，将日期和时间作为键，内容作为值。 例如，Python课程的开课时间是2020.10.21 8:00，输出第4周和第5周的学习计划，结果如下： 2020-11-17 08:00:00 Python第4周学习内容：列表与元组 2020-11-25 08:00:00 Python第5周学习内容：集合与字典 以下代码中，在空白处应填入的代码是（ ）。 import datetime note={ } date = 空1 #设置时间为2020年10月21日8点整 word=['Python第4周学习内容：列表与元组', 'Python第5周学习内容：集合与字典'] week = 4 for i in range(2): date_now = date + datetime.timedelta(days=week*7) #时间计算到week周后 date_str = 空2 note[date_str] = word[i] week += 1 for key,value in note.items(): print(key) print(value) 知识点：datetime库
A、空1：datetime.datetime(2020,10,21,8,0) 空2：format(date_now,'%Y-%m-%d %H:%M:%S')
B、空1：datetime(2020,10,21,8,0) 空2：format(date_now,'%Y-%m-%d %H:%M:%S')
C、空1：datetime.datetime(2020,10,21,8,0) 空2：date_now.strftime('%Y-%m-%d %H:%M:%S')
D、空1：datetime(2020,10,21,8,0) 空2：date_now.strftime('%Y-%m-%d %H:%M:%S')
12、有如下字典： elements = { "hydrogen": { "number": 1, "weight": 1.00, "symbol": "H"}, "oxygen": { "number": 8, "weight": 15.99, "symbol": "O"}, "carbon": { "number": 6, "weight": 12.01, "symbol": "C"} } 如果要获取"oxygen"元素的化学符号，下面正确的书写是（ ）。 知识点：嵌套字典
A、elements["oxygen"]["symbol"]
B、elements["oxygen", "symbol"]
C、elements.get("oxygen", "symbol")
D、elements.get("oxygen").get("symbol")
第6周 Python编程进阶（一）
第6周 Python编程进阶（一）测试
1、关于程序的异常处理，以下选项中描述错误的是（ ）。 知识点：异常的概念
A、程序中的异常发生后，妥善处理后程序可以继续执行，所以异常处理提高了程序的健壮性
B、在try代码块中如果有异常发生，则跳过该代码块中剩下的部分，根据异常类型去匹配except后面的异常，匹配成功则执行该except子句的语句块
C、Python异常处理中，不论异常是否发生，finally子句中的代码总是会被执行
D、Python中一个try代码块只能对应一个处理异常的except代码块
2、以下代的码运行结果是（ ）。 try: s = "hello world" s[0] = "H" print(s) except: print("error") else: print("no error") finally: print("over") 知识点：异常的处理流程
A、error over
B、Hello world no error over
C、Hello world over
D、error
3、定义一个函数is_illegal，判断三个参数是否能构成三角形。如果不能形成三角形，则抛出自定义异常IllegalArgumentError。当用户输入三个数字后，调用该方法判断三边的合法性，如果不合法捕获异常、打印异常字符串，如果合法计算该三角形的面积。在下面的代码中完成填空。 import math class IllegalArgumentError(Exception): pass def is_illegal(a, b, c): if a>=b+c or b>=a+c or c>=a+b: 空1 try: a = float(input('请输入三角形的边长:\na=')) b = float(input('b=')) c = float(input('c=')) is_illegal(a, b, c) s = (a+b+c)/2 area = math.sqrt(s*(s-a)*(s-b)*(s-c)) print("三角形的面积为：",area) except ValueError: print('提示：请输入数字！') 空2 : #捕获IllegalArgumentError异常，输出异常字符串"无法构成三角形" print(e) 知识点：自定义异常的抛出和捕获
A、空1：raise IllegalArgumentError("无法构成三角形") 空2：except IllegalArgumentError as e
B、空1：raise IllegalArgumentError() 空2：except IllegalArgumentError as e
C、空1：raise IllegalArgumentError("无法构成三角形") 空2：except IllegalArgumentError
D、空1：raise IllegalArgumentError() 空2：except IllegalArgumentError
4、下面说法错误的是（ ）。 知识点：列表推导式
A、dict([(x, x**2) for x in range(6)]) 创建的字典是{ 0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
B、[[x*3+y for y in range(1,4)] for x in range(3)] 创建的是二维列表 [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
C、number = [-2, 4, 6, -5] string = 'ab' z = [(i, j) if i>0 else (-i, j) for i in number for j in string] 这段代码创建的列表为[(2, 'a'), (2, 'b'), (4, 'a'), (4, 'b'), (6, 'a'), (6, 'b'), (5, 'a'), (5, 'b')]
D、' '.join([i for i in range(1,11)])的运算结果为字符串'1 2 3 4 5 6 7 8 9 10'
5、以下关于函数的描述中，错误的是（ ）。 知识点：参数
A、只要是在globals（顶层）命名空间内定义的变量，在自定义函数内部都可以直接读取和赋值
B、globals（顶层）命名空间内定义的变量，如果是诸如数字、字符串的不可变类型，必须使用关键字global进行声明后才可以对其重新赋值
C、如果可变类型对象做函数的参数，那么在函数内部修改它的取值并将变化反应在实参上，必须用索引按位置进行赋值
D、如果不可变类型对象做函数的参数，那么在函数内部形参如何变化都不会影响实参的取值
6、关于Python函数参数传递的描述中，错误的是（ ）。 知识点：参数的传递
A、定义函数时，可以赋予参数默认的取值，调用函数时既可以不传递该参数使用默认值，也可以根据需要传递自定义取值
B、调用函数时，以键值对的方式写出参数的名字和取值，这种称为关键字参数，在关键字参数的后面不能再出现位置参数
C、即使使用关键字参数，也必须按照函数定义时的形参次序进行参数传递
D、定义函数时，不定长参数通常出现在形参列表的末尾，如果不在末尾，则其后面的参数必须带有默认值
7、如果函数定义为： def fun(user): pass 则下面对该函数的调用不合法的是（ ）。 知识点：参数
A、fun()
B、fun('Lily')
C、fun(1007)
D、fun(user="Lily")
8、下列说法不正确的是（ ）。 知识点：全局变量
A、x = 5 def fun(): x = 2 x = x * 3 print(x, end=' ') fun() print(x) 程序无误，输出结果为6 5
B、x = 5 def fun(): global x x = 2 x = x*3 print(x, end=' ') fun() print(x) 程序无误，输出结果为6 6
C、x = 5 def fun(): x = x * 3 print(x ,end=' ') fun() print(x) 程序无误，输出的结果为15 15
D、x = 5 def fun(): print(x, end=' ') fun() print(x) 程序无误，输出的结果为5 5
9、以下程序的输出结果是（ ）。 ls = [1,3,5] def func(x, y): ls[0] = 100 return x*y s = func('Py', 2) print(s, ls) 知识点：参数
A、PyPy [100, 3, 5]
B、PyPy [1, 3, 5]
C、PyPy
D、程序无法运行
10、要创建如下列表[5, 15, 25, 35, 45, 55, 65, 75, 85, 95]，可以采用的方法包括（ ）。 知识点：列表的创建
A、a = [] for x in range(10): a.append(x*10+5)
B、[x*10+5 for x in range(10)]
C、[for x in range(10): x*10+5]
D、a = [] for x in range(10): a[x] = x*10 + 5
11、已知有三个列表： lst1 = [1, 2, 3, 4] lst2 = ['醉乡民谣', '驴得水', '放牛班的春天', '美丽人生'] lst3 = ['美国', '中国', '法国', '意大利'] 如果要得到如下列表： [(1, '醉乡民谣', '美国'), (2, '驴得水', '中国'), (3, '放牛班的春天', '法国'), (4, '美丽人生', '意大利')] 可以采用的方法包括（ ）。 知识点：列表推导式，zip函数，enumerate函数
A、list(zip(lst1,lst2,lst3))
B、[(lst1[i], lst2[i], lst3[i]) for i in range(len(lst1))]
C、[(i+1, lst2[i], lst3[i]) for i in range(len(lst1))]
D、[ (i+1,x,y) for i,(x, y) in enumerate(zip(lst2, lst3))]
12、下列代码中，输出结果是字典类型对象 { 1: ('apple', 100), 2: ('banana', 50), 3: ('orange', 80)} 的选项是（ ）。 知识点：字典推导式，zip函数，enumerate函数
A、fruit = [('apple','banana','orange'), (100,50,80)] a= { i+1:item for i,item in enumerate(zip(*fruit)) }
B、fruit = ('apple', 'banana', 'orange') weight = (100, 50, 80) b= { i+1:item for i,item in enumerate(zip(fruit, weight)) }
C、fruit=[("apple",100),("banana",50),("orange",80)] c= { i+1:item for i,item in enumerate(zip(fruit))}
D、fruit = ('apple','banana','orange') weight = (100,50,80) d = { i+1:(a,b) for i,(a,b) in enumerate(zip(fruit, weight))}
第7周 Python编程进阶（二）
第7周 Python编程进阶（二）
1、已知func = lambda x, y : x*2+y，则func([1],[2,3])的结果是（ ）。 知识点：匿名函数
A、[4, 5]
B、[1, 2, 3]
C、[1, 1, 2, 3]
D、7
2、下列说法错误的是（ ）。 知识点：函数
A、已知元组列表x=[(2,3,10),(1,2,3),(2,6,7),(3,5,10)]，那么sorted(x, key=lambda item : item[0]+item[2])排序后，print(x)的输出结果是：[(1, 2, 3), (2, 6, 7), (2, 3, 10), (3, 5, 10)]
B、已知num=[2,3,4,5], print('*'.join(map(str, num)))的输出结果是：2*3*4*5
C、已知x=[5, 2, 3, 4, 9]，那么执行代码x = sorted(x[0::2], reverse=True)之后，x的值为[9,5,3]
D、下面代码定义了求解的函数，并计算x=9的取值 import math def log3(x): return math.log(x)/math.log(3) f = log3 print(f(9))
3、定义一个函数，计算x=3, y=5时函数的值。不能完成该功能的是（ ）。 知识点：函数做参数
A、import math def add(f,x,y): return f(x)+f(y) print(add(lambda x: math.sin(x*x),3,5))
B、import math def add(f,x,y): return f(x)+f(y) def func(x): return math.sin(x**2) print(add(func,3,5))
C、import math def func(x): return math.sin(x**2) ls=list(map(func,[3,5])) print(sum(ls))
D、import math def func(x): return math.sin(x**2) ls = list(filter(func,[3,5])) print(sum(ls))
4、使用函数式编程的方式，统计一句英文短文中每个单词出现的次数。请完成填空。 txt = "A computer is a device that can be instructed to carry out an arbitrary set of arithmetic or logical operations automatically." def word_count(word_list): #词频统计 word_list.sort() words=[] for word in word_list: if word not in words: times = word_list.count(word) #计数 print("{ }:{ }次".format(word,times)) words.append(word) #记录已统计的单词 def func(value, ops): for function in ops: value = function(value) operators = 填空 func(txt, operators) 知识点：函数式编程
A、[str.lower, str.split, word_count]
B、[lower, split, word_count]
C、[str.split, str.lower, word_count]
D、[split, lower, word_count]
5、编写程序用递归函数实现将字符串逆序，并把结果存放到列表中。下列选项不能完成该功能的是（ ）。 知识点：递归函数
A、s = 'abcdefg' ls = [] def str_reverse(length): if length == 0: return ls ls.append(s[length-1]) return str_reverse(length-1) print("".join(str_reverse(len(s))))
B、s = 'abcdefg' def str_reverse(ss): length = len(ss) if length <= 1: return ss return ss[-1] + str_reverse(ss[1:-1]) + ss[0] print("".join(list(str_reverse(s))))
C、ss = 'abcdefg' ls=[] def str_reverse(x): if x=='': return ls ls.append(x[-1]) return str_reverse(x[:-1]) print("".join(str_reverse(ss)))
D、s = 'abcdefg' def str_reverse(ss): length = len(ss) if length <= 1: return ss return ss[-1] + str_reverse(ss[1:-2]) + ss[0] print("".join(list(str_reverse(s))))
6、已知包文件夹test和模块fac.py的关系如下。 求阶乘的函数fac()定义如下： def fac(n): y = 1 for i in range(1, n+1): y = y * i return y 那么下列选项中，能够执行函数fac的是（ ）。 知识点：模块
A、import test.fac print(test.fac.fac(8))
B、import test.fac print(test.fac(8))
C、import test print(test.fac.fac(8))
D、import test print(test.fac(8))
7、已知位于同一文件夹下的两个文件，output.py和test.py的内容如下： #output.py def show(): print(__name__) #test.py import output if __name__=='__main__': output.show() 运行test.py的输出结果是（ ）。 知识点：模块和主模块
A、output
B、__main__
C、__name__
D、test
8、能够判断当前环境是主模块还是被导入的模块的属性是（ ）。 知识点：主模块
A、__name__
B、__path__
C、__package__
D、__file__
9、已知一个按升序排列的列表ls，使用二分法在该列表中查找某数字。现用递归函数实现该功能，请完成填空。 def binary_search(ls, target): if 空1 : print('未找到!') return midIndex = len(ls) // 2 if target <ls[midIndex]: 空2 elif target > ls[midIndex] : 空3 else: print('查找成功!') ls = [2,8,10,18,25,30,36,40,50,88] #升序排列 num = eval(input('请输入要查找的数：')) binary_search(ls, num) 在空白处可以填入的正确选项是（ ）。 知识点：递归函数
A、len(ls)==0 binary_search(ls[ :midIndex], target) binary_search(ls[midIndex+1: ], target)
B、not ls binary_search(ls[ :midIndex], target) binary_search(ls[midIndex+1: ], target)
C、len(ls)==0 binary_search(ls[midIndex+1: ], target) binary_search(ls[ :midIndex], target)
D、ls==[] binary_search(ls[midIndex+1: ], target) binary_search(ls[ :midIndex], target)
10、下列说法正确的是（ ）。 知识点：os库和os.path库
A、假设os模块已导入, 那么 for lib in ["numpy", "pandas", "matplotlib"]: os.system("pip install -U "+ lib) 的作用是批量安装、更新这三个库
B、假设os模块已导入，那么列表推导式: [filename for filename in os.listdir('D:\\source') if filename.endswith('.py')] 的作用是创建D:\source文件夹中所有扩展名为.py的文件名列表
C、Python标准库os.path中的方法isfile()可以用来测试给定的路径是否为文件
D、Python标准库os.path中的split()方法用于分割指定路径中主文件和文件扩展名
第8周 Python面向对象基础
Python面向对象基础测试
1、下面的代码运行后会报错。 class People(object): __name = "luffy" __age = 18 p1 = People() print(p1.__name, p1.__age) 知识点：类的基本使用
2、语句 pass 仅起到占位符的作用，并不会做任何操作。 知识点：类定义
3、在类定义的外部没有任何办法可以访问对象的私有成员。 知识点：访问权限
4、Python 中一切内容都可以称为对象。 知识点：类和对象
5、定义类时所有实例方法的第一个参数用来表示对象本身，在类的外部通过对象名来调用实例方法时不需要为该参数传值。 知识点：类和对象
6、Python中没有严格意义上的私有成员。 知识点：类和对象
7、Python 类的构造函数是__init__()。 知识点：构造函数
8、定义类时，在一个方法前面使用@classmethod 进行修饰，则该方法成为类方法。 知识点：类方法
9、Python中，通过对象不能调用类方法和静态方法。 知识点：类方法和静态方法
10、在 Python中可以为自定义类的对象动态增加新成员。 知识点：类的定义
11、现有如下代码， 请分两行写出其运行结果。 class People(object): def __init__(self): print("__init__") def __new__(cls, *args, **kwargs): print("__new__") return object.__new__(cls, *args, **kwargs) People() 知识点：类的定义和使用
12、请执行以下代码，说明错误出现的行数。 1. class Dog(object): 2. def __init__(self,name): 3. self.name = name 4. @property 5. def eat(self): 6. print(" %s is eating" %self.name) 7. 8. d = Dog("wangwang") 9. d.eat() 知识点：属性的定义和使用
13、如下学生类，使用一个计数器属性统计一共实例化了多少个学生。请输出程序运行结果。 class Student: count = 0 def __init__(self, name): self.name = name Student.count += 1 s1 = Student("zhang3") s2 = Student("li4") print(s1.count) 知识点：类和对象
第9周 Python面向对象进阶
Python面向对象进阶测试
1、关于面向对象的继承，以下选项中描述正确的是（ ）。 知识点：继承的概念
A、继承是类之间共享属性和操作的机制
B、继承是指一组对象所具有的相似性质
C、继承是指各对象之间的共同性质
D、继承是指一个对象具有另一个对象的性质
2、在面向对象方法中，一个对象请求另一对象为其服务的方式是通过发送（ ）。 知识点：基本理论
A、消息
B、命令
C、口令
D、调用语句
3、下列选项中，与class Person等价的是（ ）。 知识点：继承
A、class Person(Object)
B、class Person(object)
C、class Person: Object
D、class Person: object
4、以下能表示C类继承A类和B类的正确语句是（ ）。 知识点：多继承
A、class C:A,B
B、class C:A B
C、class C(A,B)
D、def class C(A,B)
5、下列程序的输出结果是（ ）。 class Parent: def func(self): print('AA') class Child(Parent): def func(self): print('BB') a=Parent() b=Child() con = [a, b] for x in con: x.func() 知识点：多态性
A、AA BB
B、BB AA
C、AA
D、BB
6、下列程序的输出结果是（ ）。 class Fruit(): def __init__(self): print('Fruit') def grow(self): print('Fruit grow') class Vegetable(): def __init__(self): print('Vegetable') def grow(self): print('Vegetable grow') class Tomato(Fruit,Vegetable): pass t = Tomato() t.grow() 知识点：多继承
A、Fruit Fruit grow
B、Fruit Vegetable grow
C、Vegetable Fruit grow
D、Vegetable Vegetable grow
7、Python 支持多继承，如果父类中有相同的方法名，而在子类中调用时没有指定父类名，则 Python解释器将从左向右按顺序进行搜索。 知识点：多继承
8、在设计派生类时，基类的私有成员默认是不会被继承的。 知识点：继承
9、子类能继承父类的一切属性和方法。
10、子类可以通过重写父类方法覆盖掉与父类同名的方法。 知识点：多态性
11、如果类属性和实例属性重名，对象优先访问类属性的值。 知识点：访问控制
12、使用类名获取到的值一定是类属性的值。 知识点：访问控制
13、静态方法中一定不能访问实例属性的值。 知识点：访问控制
14、下面这段代码的输出结果是（ ）。 class Parent(object): x = 1 class Child1(Parent): pass class Child2(Parent): pass print(Parent.x, Child1.x, Child2.x) Child1.x = 2 print(Parent.x, Child1.x, Child2.x) Parent.x = 3 print(Parent.x, Child1.x, Child2.x) 知识点：继承 提示：答案分为3行，每个数据之间用一个空格分隔。
15、使用实例a进行获取数据、设置数据和删除数据操作, 分别会触发类的哪个私有方法？ class A(object): pass a = A() a["key"] = "val" # 触发【 填空1 】方法 a = a["key"] # 触发【 填空2 】方法 del a["key"] # 触发【 填空3 】方法 知识点：运算符重载 提示：每行写出一个空的答案。
学习通Python程序设计及应用（上）_2
在上一篇文章中，我们已经介绍了Python的基本数据类型、运算符和表达式等内容。今天我们将进一步深入学习Python的数据类型和函数。
Python的数据类型
Python中常用的数据类型有：
- 数字（Number）：包括整数、浮点数、复数等
- 字符串（String）：由单引号、双引号或三引号括起来的字符序列
- 列表（List）：由一组任意类型的有序元素组成的序列
- 元组（Tuple）：与列表类似，但是一旦创建就不能修改
- 集合（Set）：由一组不重复且无序的元素组成的集合
- 字典（Dictionary）：由一组键值对组成的无序集合
Python的函数
函数是Python编程中一个非常重要的概念。在Python中，函数可以有多个参数，可以返回多个值，也可以接受其他函数作为参数。下面我们来看一下Python函数的定义方式：
def function_name(param1, param2, ...): # function body return return_value其中，function_name是函数的名称，param1、param2等是函数的参数，function body是函数体，return_value是函数的返回值。
下面是一个简单的例子，我们定义了一个函数add(num1, num2)，用于计算两个数的和：
def add(num1, num2): result = num1 + num2 return result上面的函数定义中，我们通过result = num1 + num2计算了两个数的和，然后使用return result语句返回结果。
函数调用时，可以直接使用函数名加上参数列表的方式进行调用：
result = add(1, 2)print(result) # 输出3上面的代码中，我们调用了函数add(1, 2)，并将返回值赋值给了变量result，然后使用print()函数对result进行输出。
Python的模块和包
Python的模块和包是组织Python代码的重要方式。模块是一组Python代码的集合，而包则是一组模块的集合。
在Python中，我们可以使用import语句导入其他模块或包中的定义。下面是一个简单的例子，我们导入了Python中的math模块，并使用其中的sqrt()函数计算了一个数的平方根：
import mathx = 16y = math.sqrt(x)print(y) # 输出4.0在上面的代码中，我们使用import math语句导入了Python中的math模块，然后使用math.sqrt()函数计算了一个数的平方根，并将结果输出。
总结
在本篇文章中，我们进一步深入学习了Python的数据类型和函数。Python的数据类型非常丰富，包括数字、字符串、列表、元组、集合、字典等。函数是Python编程中一个非常重要的概念，我们可以使用函数来组织代码，实现代码的复用和封装。同时，Python还支持模块和包的概念，可以帮助我们更好地组织代码，实现代码的模块化和分层。
在学习Python编程的过程中，我们需要不断加强自己的编程能力，掌握更多的编程技巧和工具，不断提升自己的编程水平。相信通过不断地学习和实践，我们一定能够在Python编程领域取得更好的成果。
学习通Python程序设计及应用（上）_2
在上一篇文章中，我们已经介绍了Python的基本数据类型、运算符和表达式等内容。今天我们将进一步深入学习Python的数据类型和函数。
Python的数据类型
Python中常用的数据类型有：
- 数字（Number）：包括整数、浮点数、复数等
- 字符串（String）：由单引号、双引号或三引号括起来的字符序列
- 列表（List）：由一组任意类型的有序元素组成的序列
- 元组（Tuple）：与列表类似，但是一旦创建就不能修改
- 集合（Set）：由一组不重复且无序的元素组成的集合
- 字典（Dictionary）：由一组键值对组成的无序集合
Python的函数
函数是Python编程中一个非常重要的概念。在Python中，函数可以有多个参数，可以返回多个值，也可以接受其他函数作为参数。下面我们来看一下Python函数的定义方式：
def function_name(param1, param2, ...): # function body return return_value其中，function_name是函数的名称，param1、param2等是函数的参数，function body是函数体，return_value是函数的返回值。
下面是一个简单的例子，我们定义了一个函数add(num1, num2)，用于计算两个数的和：
def add(num1, num2): result = num1 + num2 return result上面的函数定义中，我们通过result = num1 + num2计算了两个数的和，然后使用return result语句返回结果。
函数调用时，可以直接使用函数名加上参数列表的方式进行调用：
result = add(1, 2)print(result) # 输出3上面的代码中，我们调用了函数add(1, 2)，并将返回值赋值给了变量result，然后使用print()函数对result进行输出。
Python的模块和包
Python的模块和包是组织Python代码的重要方式。模块是一组Python代码的集合，而包则是一组模块的集合。
在Python中，我们可以使用import语句导入其他模块或包中的定义。下面是一个简单的例子，我们导入了Python中的math模块，并使用其中的sqrt()函数计算了一个数的平方根：
import mathx = 16y = math.sqrt(x)print(y) # 输出4.0在上面的代码中，我们使用import math语句导入了Python中的math模块，然后使用math.sqrt()函数计算了一个数的平方根，并将结果输出。
总结
在本篇文章中，我们进一步深入学习了Python的数据类型和函数。Python的数据类型非常丰富，包括数字、字符串、列表、元组、集合、字典等。函数是Python编程中一个非常重要的概念，我们可以使用函数来组织代码，实现代码的复用和封装。同时，Python还支持模块和包的概念，可以帮助我们更好地组织代码，实现代码的模块化和分层。
在学习Python编程的过程中，我们需要不断加强自己的编程能力，掌握更多的编程技巧和工具，不断提升自己的编程水平。相信通过不断地学习和实践，我们一定能够在Python编程领域取得更好的成果。
