总分：100分
得分：86.0分
+ 2.0
正确答案
若 a = 'abcd' ，若想将 a 变为 'ebcd' ，则下列语句正确的是
A.a[0] = 'e'
B.replace('a', 'e')
C.a[1] = 'e'
D.a = 'e' + a[1:]
回答正确
D
正确答案
D
+ 2.0 分
3 .
下列不合法的Python变量名是
A.Python2
B.N.x
C.sum
D.Hello_World
回答正确
B
正确答案
B
+ 2.0 分
4 .
执行以下两条语句后，lst的结果是 1. lst = [3, 2, 1] 2. lst.append(lst)
A.[3, 2, 1, [3, 2, 1]]
B.[3, 2, 1, […]]，其中“…”表示无穷递归
C.抛出异常
D.[3, 2, 1, lst]
回答正确
B
正确答案
B
+ 2.0 分
5 .
下列不是Python语言关键字的是
A.open
B.if
C.lambda
D.finally
回答正确
A
正确答案
A
+ 2.0 分
6 .
与x > y and y > z 语句等价的是
A.x > y > z
B.not x < y or not y < z
C.not x < y or y < z
D.x > y or not y < z
回答正确
A
正确答案
A
+ 2.0 分
7 .
以下哪条语句定义了一个Python字典
A.{ }
B.{1, 2, 3}
C.[1, 2, 3]
D.(1, 2, 3)
回答正确
A
正确答案
A
+ 2.0 分
8 .
执行下面操作后，list2的值是： 1. list1 = ['a', 'b', 'c'] 2. list2 = list1 3. list1.append('de')
A.['a', 'b', 'c']
B.['a', 'b', 'c', 'de']
C.['d', 'e', 'a', 'b', 'c']
D.['a', 'b', 'c', 'd', 'e']
回答正确
B
正确答案
B
+ 2.0 分
9 .
下列运算符的使用错误的是：
A.1 + 'a'
B.[1, 2, 3] + [4, 5, 6]
C.3 * 'abc'
D.-10 % -3
回答正确
A
正确答案
A
+ 2.0 分
10 .
字符串是一个字符序列，例如，字符串s，从右侧向左第3个字符用什么索引？
A.s[3]
B.s[-3]
C.s[0:-3]
D.s[:-3]
回答正确
B
正确答案
B
+ 2.0 分
11 .
获得字符串s长度的方法是什么？
A.s.len()
B.s.length
C.len(s)
D.length(s)
回答正确
C
正确答案
C
+ 2.0 分
12 .
Python中布尔变量的值为
A.真，假
B.0,1
C.T,F
D.True，False
回答正确
D
正确答案
D
+ 2.0 分
13 .
对负数取平方根，即使用函数math.sqrt(x)，其中x为负数，将产生
A.什么都不产生
B.虚数
C.程序崩溃
D.ValueError错误
回答正确
D
正确答案
D
+ 2.0 分
14 .
下列哪一项不是Python的数据类型：
A.string
B.float
C.rational
D.int
回答正确
C
正确答案
C
+ 2.0 分
15 .
下面哪一个不是Python语言的合法命名：
A.monthly
B._Monthly3_
C.monTHly
D.3monthly
回答正确
D
正确答案
D
+ 2.0 分
16 .
Python中，用于获取用户输入的命令为：
A.input
B.read
C.get
D.for
回答正确
A
正确答案
A
+ 2.0 分
17 .
用于生成和计算出新的数值的一段代码称为：
A.表达式
B.赋值语句
C.生成语句
D.标识符
回答正确
A
正确答案
A
+ 2.0 分
18 .
以下关于Python数值运算描述错误的是哪一项？
A.Python支持+=、%=这样的增量赋值操作符。
B.在Python 2.x中，默认情况下10/3 == 3的判别结果是False，而Python 3.x中则不同。
C.Python内置支持复数运算，可以使用j或者J来表示。
D.%运算符表示运算对象取余。
回答正确
B
正确答案
B
+ 2.0 分
19 .
以下关于字符串处理的描述错误的是哪一项？
A.print （'C:\file\time'），输出结果是C:\file\time。
B.Python 2.x中字符串是以单引号或双引号括起来的任意文本，如果字符串赋值的时候，内部有单引号或双引号时如果不想使用转义字符常常可以使用r运算符来表示。
C."\"符号可以被用来表示转义符号，例如'doesn\'t'和"doesn't"都表示字符串doesn't。
D.被单引号('...')或者双引号("...")包围的都是字符串。
回答正确
A
正确答案
A
+ 2.0 分
20 .
以下关于字符串处理正确的是哪一项？
A.字符串是自带索引的，对变量word = "Python"，word
B.+号可以用来拼接两个字符串，对于以下代码的输出字符串是Python 1. >>> prefix = "Py" 2. >>> prefix + 'thon'
C.字符串的索引有两个边界，前边界和后边界都是包括的。
D.对于字符串"apple"， 3 * "apple"的结果为"3apple"。
回答正确
B
正确答案
B
+ 2.0 分
21 .
字符串是一个字符序列，例如，字符串s，从右侧向左第3个字符用什么索引？
A.s[3]
B.s[-3]
C.s[0:-3]
D.s[:-3]
回答正确
B
正确答案
B
+ 2.0 分
22 .
关于赋值语句的作用，正确的描述是（ )。
A.将变量绑定到对象
B.每个赋值语句只能给一个变量赋值
C.将变量改写为新的值
D.变量和对象必须类型相同
回答正确
A
正确答案
A
+ 2.0 分
23 .
若 a = 'abcd' ，若想将 a 变为 'ebcd' ，则下列语句正确的是（ )。
A.a[0] = 'e'
B.replace('a', 'e')
C.a[1] = 'e'
D.a = 'e' + a[1:]
回答正确
D
正确答案
D
+ 2.0 分
24 .
下列不合法的Python变量名是（ )。
A.Python2
B.N_x
C.sum
D.Hello$World
回答正确
D
正确答案
D
+ 0.0 分
25 .
下列不是Python语言关键字的是（ ）。
A.else
B.print
C.lambda
D.finally
回答错误
B
正确答案
A
+ 2.0 分
26 .
下列运算符的使用错误的是（ ）。
A.1 + 'a'
B.[1, 2, 3] + [4, 5, 6]
C.3 * 'abc'
D.-10 % -3
回答正确
A
正确答案
A
+ 2.0 分
27 .
用于生成和计算出新的数值的一段代码称为：
A.赋值语句
B.表达式
C.生成语句
D.标识符
回答正确
B
正确答案
B
+ 2.0 分
28 .
以下关于Python数值运算描述错误的是哪一项？
A.Python支持+=、%=这样的增量赋值操作符。
B.默认情况下10/3 == 3的判别结果是True
C.Python内置支持复数运算，可以使用j或者J来表示。
D.%运算符表示运算对象取余。
回答正确
B
正确答案
B
+ 2.0 分
29 .
下列哪个语句在Python中是非法的（ ）。
A.x = y = z = 1
B.x = (y = z + 1)
C.x, y = y, x
D.x += y
回答正确
B
正确答案
B
+ 2.0 分
30 .
下面哪个不是Python合法的标识符（ ）。
A.int32
B.40XL
C.self
D.__name__
回答正确
B
正确答案
B
+ 2.0 分
31 .
下列哪种说法是错误的（ ）。
A.除字典类型外，所有标准对象均可以用于布尔测试
B.空字符串的布尔值是False
C.空列表对象的布尔值是False
D.值为0的任何数字对象的布尔值是False
回答正确
A
正确答案
A
+ 2.0 分
32 .
Python不支持的数据类型有（ ）。
A.char
B.int
C.float
D.list
回答正确
A
正确答案
A
+ 2.0 分
33 .
以下不能创建一个字典的语句是 （ ）。
A.dict1 = {}
B.dict2 = { 3 : 5 }
C.dict3 = {[1,2,3]: “uestc”}
D.dict4 = {(1,2,3): “uestc”}
回答正确
C
正确答案
C
+ 2.0 分
34 .
关于字符串下列说法错误的是（ ）。
A.字符应该视为长度为1的字符串
B.字符串以\0标志字符串的结束
C.既可以用单引号，也可以用双引号创建字符串
D.在三引号字符串中可以包含换行回车等特殊字符
回答正确
B
正确答案
B
+ 2.0 分
35 .
下列表达式的值为True的是（ ）。
A.(2**=3)<(2*=3)
B.3>2>2
C.1==1 and 2!=1
D.not(1==1 and 0!=1)
回答正确
C
正确答案
C
+ 0.0 分
36 .
type(1+2L*3.14)的结果是（ ）。
A.<class ‘int’>
B.<class ‘long’>
C.<class ‘float’>
D.<class ‘str’>
回答错误
B
正确答案
C
+ 0.0 分
37 . 填空题 困难 2分
把下列数学表达式转换成等价的Python表达式。
___、___、___、___、___ 提示：math.sin(x)函数返回的x弧度的正弦值，math.cos(x)函数返回的x弧度的余弦值，math.sqrt(x)函数返回数字x的平方根。函数请参考第四章。
回答错误
(-b-math.sqrt(b**2-4*a*c))/(2*a)、(x**2+y**2)/(2*a**2)、(x_val+y_val+z_val)/math.sqrt(x_val**3+y_val**3+z_val**3)、result=((3+a)**2)/(2*c)+4*d、import math result=2*math.sin((x+y)/2)*math.cos((x-y)/2)
正确答案
(-b+（b*b-4*a*c)**(1/2))/(2*a)、(x*x+y*y)/(2*a*a)、(x+y+z)/((x**3+y**3+z**3)**(1/2))、((3+a)**2)/(2*c+4*d)、2*sin((x+y)/2)*cos((x-y)/2)
+ 0.0 分
38 . 填空题 困难 2分
数学上3<x<10 表示成正确的Python表达式为___
回答错误
x<10 and x>3
正确答案
（x>3）and（x<10）
+ 0.0 分
39 . 填空题 困难 2分
以3为实部4为虚部，Python复数的表达形式为___
回答错误
3+4j或3+4J。
正确答案
3+4j
+ 0.0 分
40 . 填空题 困难 2分
假设列表对象aList的值为[3, 4, 5, 6, 7, 9, 11, 13, 15, 17]，那么切片aList[3:7]得到的值是___
回答错误
6,7,9,11
正确答案
[6,7,9,11]
+ 2.0 分
41 . 填空题 困难 2分
语句[5 for i in range(10)]执行结果为___
回答正确
[5,5,5,5,5,5,5,5,5,5]
正确答案
[5,5,5,5,5,5,5,5,5,5]
+ 0.0 分
42 . 填空题 困难 2分
Python内置函数___可以返回列表、元组、字典、集合、字符串以及range对象中元素个数。
回答错误
len
正确答案
len()
+ 2.0 分
43 . 填空题 困难 2分
计算下列表达式的值（可在上机时验证），设a=7,b=-2,c=4。 （1）3 * 4 ** 5 / 2：___ （2）a * 3 % 2：___ （3）a%3 +b*b- c//5：___ （4）b**2-4*a*c：___
回答正确
1536、1、5、-108
正确答案
1536.0、1、5、-108
+ 1.0 分
44 . 简答题 困难 1分
Python数据类型有哪些？分别什么用途？
回答正确
Numbers(数字型)：
即我们常说的1，2，3等等这些数字，Python有两个常见的数据类型转化函数：int和float，一般数据类型可以用来做一些算术功能，如加减乘除乘方等等，还可以用作比较功能，一般返回的是true和false，也就是大于、等于、小于、小于等于诸如此类的有很多，这里就不一一解释了。
String(字符串)：
字符串是Python中比较常见的数据类型之一，能够使用str函数将其他类型的数据强制转换为字符串类型，有三种生成方法，即单引号'XXX'，双引号"XXX"，三引号'''XXX
'''，其中三引号一般用于字符串内容较长的时候。
List(列表)：
列表可以说是Python中最为活跃的一个数据类型，使用也很频繁，操作也很多，可以通过list函数或方括号[]进行列表的创建。常见函数如求长度，用len，合并多个列表用+，列表元素重复*等等。
Tuple(元组)：
元组可以看成是一种不可修改的特殊列表，可以通过小括号()或者tuple函数来创建，即便是只有一个元素，元组中的元素最后也要有逗号。常见操作有求长度len，元组元素重复*，元组拼接+，查看最值max、min等。
Dictionary(字典)：字符串、列表、元组都是有序的数据类型，字典是无序的数据类型，主要是用来存放具有一定映射关系的数据。可以通过两种方法创建，1、{}2、dict函数创建。
set(集合)：
集合不能有重复元素，可以看作是列表和字典的“杂合体”，可以通过三种方式创建，1、set函数，空集合只能用这种方法;2、{}创建，3、创建冻集合，frozenst。
正确答案
Python 数值类型用于存储数值。整型(int) ：通常被称为是整型或整数，是正或负整数，不带小数点。长整型(long) ：无限大小的整数，整数最后是一个大写或小写的L。在Python3里，只有一种整数类型 int，没有Python2 中的 Long。浮点型(float)：浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.78e2就是2.78 x 102 = 278）复数(complex)：复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示，复数的虚部以字母j或J结尾。如：2+3j。
+ 1.0 分
45 . 简答题 困难 1分
求列表s=[9，7，8，3，2，1，55，6]中的元素个数，最大数，最小数？如何在列表s中添加一个元素10？如何从列表s中删除一个元素55？
回答正确
s = [9, 7, 8, 3, 2, 1, 55, 6]
count = len(s)
print("元素个数：", count)
max_num = max(s)
print("最大数：", max_num)
min_num = min(s)
print("最小数：", min_num)
s.append(10)
print(s)
s.remove(55)
print(s)
正确答案
s=[9，7，8，3，2，1，55，6] len(s) max(s) min(s) s.append(10) print(s) s.remove(55) print(s)
+ 1.0 分
46 . 简答题 困难 1分
元组与列表主要区别？s=（9，7，8，3，2，1，55，6）能添加元素吗？
回答正确
元组（tuple）和列表（list）是Python中的两种不同的数据结构。
主要区别如下：
元组是不可变的（immutable），而列表是可变的（mutable）。这意味着元组的元素不能被修改、删除或添加，而列表的元素可以被修改、删除或添加。
元组使用圆括号（）表示，而列表使用方括号[]表示。
对于给定的元组s = (9, 7, 8, 3, 2, 1, 55, 6)，不能直接添加元素。由于元组是不可变的，无法通过类似s.append(10)的方法向元组中添加元素。
正确答案
元组不能添加元素，列表可以添加元素
+ 1.0 分
47 . 简答题 中等 1分
Python数据类型有哪些？分别什么用途？
回答正确
Numbers(数字型)：
即我们常说的1，2，3等等这些数字，Python有两个常见的数据类型转化函数：int和float，一般数据类型可以用来做一些算术功能，如加减乘除乘方等等，还可以用作比较功能，一般返回的是true和false，也就是大于、等于、小于、小于等于诸如此类的有很多，这里就不一一解释了。
String(字符串)：
字符串是Python中比较常见的数据类型之一，能够使用str函数将其他类型的数据强制转换为字符串类型，有三种生成方法，即单引号'XXX'，双引号"XXX"，三引号'''XXX
'''，其中三引号一般用于字符串内容较长的时候。
List(列表)：
列表可以说是Python中最为活跃的一个数据类型，使用也很频繁，操作也很多，可以通过list函数或方括号[]进行列表的创建。常见函数如求长度，用len，合并多个列表用+，列表元素重复*等等。
Tuple(元组)：
元组可以看成是一种不可修改的特殊列表，可以通过小括号()或者tuple函数来创建，即便是只有一个元素，元组中的元素最后也要有逗号。常见操作有求长度len，元组元素重复*，元组拼接+，查看最值max、min等。
Dictionary(字典)：字符串、列表、元组都是有序的数据类型，字典是无序的数据类型，主要是用来存放具有一定映射关系的数据。可以通过两种方法创建，1、{}2、dict函数创建。
set(集合)：
集合不能有重复元素，可以看作是列表和字典的“杂合体”，可以通过三种方式创建，1、set函数，空集合只能用这种方法;2、{}创建，3、创建冻集合，frozenst。
正确答案
Python 数值类型用于存储数值。 整型(int) ：通常被称为是整型或整数，是正或负整数，不带小数点。 长整型(long) ：无限大小的整数，整数最后是一个大写或小写的L。在Python3里，只有一种整数类型 int，没有Python2 中的 Long。 浮点型(float)：浮点型由整数部分与小数部分组成，浮点型也可以使用科学计数法表示（2.78e2就是2.78 x 102 = 278） 复数(complex)：复数由实数部分和虚数部分构成，可以用a + bj,或者complex(a,b)表示，复数的虚部以字母j或J结尾。如：2+3j。
+ 1.0 分
48 . 简答题 中等 1分
把下列数学表达式转换成等价的Python表达式。 提示：math.sin(x)函数返回的x弧度的正弦值，math.cos(x)函数返回的x弧度的余弦值，math.sqrt(x)函数返回数字x的平方根。函数请参考第四章。
回答正确
1.(-b-math.sqrt(b**2-4*a*c))/(2*a)
2.(x**2+y**2)/(2*a**2)
3.(x_val+y_val+z_val)/math.sqrt(x_val**3+y_val**3+z_val**3)
4.result=((3+a)**2)/(2*c)+4*d
5.import math
result=2*math.sin((x+y)/2)*math.cos((x-y)/2)
正确答案
（1）（-b+（b*b-4*a*c）**（1/2））/（2*a） （2）（x*x+y*y）/（2*a*a） （3）（x+y+z）/（（x**3+y**3+z**3）**（1/2）） （4）（（3+a）**2）/（2*c+4*d） （5）2*sin（（x+y）/2）*cos（（x-y）/2）
+ 1.0 分
49 . 简答题 中等 1分
数学上3
回答正确
3
正确答案
（x>3）and（x<10）
+ 1.0 分
50 . 简答题 中等 1分
以3为实部4为虚部，Python复数的表达形式为（ ）
回答正确
3+4j或3+4J。
正确答案
3+4j
+ 1.0 分
51 . 简答题 中等 1分
表达式[1, 2, 3]*3的执行结果为（ ）
回答正确
[1,2,3,1,2,3,1,2,3]
正确答案
〔1,2,3,1,2,3,1,2,3〕
+ 1.0 分
52 . 简答题 中等 1分
假设列表对象aList的值为[3, 4, 5, 6, 7, 9, 11, 13, 15, 17]，那么切片aList[3:7]得到的值是 （ ）
回答正确
[6,7,9,11]
正确答案
[ 6,7, 9, 11]
+ 1.0 分
53 . 简答题 中等 1分
语句[5 for i in range(10)] 执行结果为（ ）
回答正确
[5,5,5,5,5,5,5,5,5,5]
正确答案
[5, 5, 5, 5, 5, 5, 5, 5, 5, 5]
+ 1.0 分
54 . 简答题 中等 1分
Python内置函数（ ）可以返回列表、元组、字典、集合、字符串以及range对象中元素个数。
回答正确
len
正确答案
len()
+ 1.0 分
55 . 简答题 中等 1分
计算下列表达式的值（可在上机时验证），设a=7,b=-2,c=4。 （1）3 * 4 ** 5 / 2 （2）a * 3 % 2 （3）a%3 +b*b- c//5 （4）b**2-4*a*c
回答正确
（1）1536
（2）1
（3）5
（4）-108
正确答案
（1）1536.0 （2）1 （3）5 （4）-108
+ 1.0 分
56 . 简答题 中等 1分
求列表s=[9，7，8，3，2，1，55，6]中的元素个数，最大数，最小数？如何在列表s中添加一个元素10？如何从列表s中删除一个元素55？
回答正确
s = [9, 7, 8, 3, 2, 1, 55, 6]
count = len(s)
print("元素个数：", count)
max_num = max(s)
print("最大数：", max_num)
min_num = min(s)
print("最小数：", min_num)
s.append(10)
print(s)
s.remove(55)
print(s)
正确答案
s=[9，7，8，3，2，1，55，6] len(s) max(s) min(s) s.append(10) print(s) s.remove(55) print(s)
+ 1.0 分
57 . 简答题 中等 1分
元祖与列表主要区别？s=（9，7，8，3，2，1，55，6）能添加元素吗？
回答正确
元组（tuple）和列表（list）是Python中的两种不同的数据结构。
主要区别如下：
元组是不可变的（immutable），而列表是可变的（mutable）。这意味着元组的元素不能被修改、删除或添加，而列表的元素可以被修改、删除或添加。
元组使用圆括号（）表示，而列表使用方括号[]表示。
对于给定的元组s = (9, 7, 8, 3, 2, 1, 55, 6)，不能直接添加元素。由于元组是不可变的，无法通过类似s.append(10)的方法向元组中添加元素。
正确答案
元祖不能添加元素，列表可以添加元素
第1-2章作业1
总分：100分
得分：85.0分
+ 2.0 分
1 .
下面不属于python特性的是（ ）。
A.简单易学
B.开源的免费的
C.属于低级语言
D.高可移植性
回答正确
C
正确答案
C
+ 2.0 分
2 .
Python脚本文件的扩展名为（ ）。
A..python
B..py
C..pt
D..pg
回答正确
B
正确答案
B
+ 2.0 分
3 .
下列关于程序设计语言的描述，正确的是（ ）。
A.机器语言要通过编译才能被计算机接受
B.早期人们使用机器语言编写计算机程序
C.机器语言又称为高级语言
D.现在人们普遍使用机器语言编写计算机程序
回答正确
B
正确答案
B
+ 1.0 分
4 . 简答题 困难 2分
Python语言有哪些特点和缺点？
回答正确
优点
1. 简单易学：Python 的语法简单且易于理解，使初学者能够迅速上手。
2. 高级语言：Python 是一种高级编程语言，提供了丰富的内置函数和库，可以简化编程任务。
3. 多用途性：Python 可用于多种不同类型的应用，包括Web开发、数据分析、人工智能、科学计算等。
4. 开源：Python 是开源的，允许开发者自由使用和修改它。
5. 广泛的社区支持：Python 有一个庞大的社区，提供了丰富的文档、库和工具，可以加速开发过程。
6. 跨平台：Python 可以在多个操作系统上运行，包括Windows、Linux、macOS等。
7. 动态类型：Python 是一种动态类型语言，允许变量在运行时动态更改类型。
8. 内置数据结构：Python 提供了丰富的内置数据结构，如列表、字典、集合等，使数据处理更加方便。
缺点：
1. 执行速度较慢：与一些编译型语言相比，Python 的执行速度较慢，特别是对于CPU密集型任务。
2. 全局解释器锁（GIL）：Python 中的 GIL 限制了多线程程序的并行性能。
3. 不适合低级编程：Python 不适用于编写底层系统代码或嵌入式系统，因为它的性能和内存控制能力有限。
4. 依赖库的版本问题：某些 Python 库的不同版本之间可能不兼容，这可能会导致依赖管理问题。
5. 内存消耗：Python 的一些特性可能导致较高的内存消耗，特别是在处理大型数据集时。
正确答案
Python支持命令式编程、函数式编程，完全支持面向对象程序设计，语法简洁清晰，并且拥有大量的几乎支持所有领域应用开发的成熟扩展库。 Python为我们提供了非常完善的基础代码库，覆盖了网络、文件、GUI、数据库、文本等大量内容。用Python开发，许多功能不必从零编写，直接使用现成的即可。除了内置的库外，Python还有大量的第三方库，也就是别人开发的，供你直接使用的东西。当然，如果你开发的代码通过很好的封装，也可以作为第三方库给别人使用。 Python同时也支持伪编译将Python源程序转换为字节码来优化程序和提高运行速度，可以在没有安装Python解释器和相关依赖包的平台上运行。 任何编程语言都有缺点，Python缺点主要有： （1）运行速度慢。 （2）代码不能加密。 （3）用缩进来区分语句关系的方式还是给很多初学者带来了困惑。最常见的情况是tab和空格的混用会导致错误。
+ 1.0 分
5 . 简答题 困难 2分
Python基本输入输出函数是什么？
回答正确
print() 函数：
input() 函数：
正确答案
用Python进行程序设计，输入是通过input( )函数来实现的，input( )的一般格式为： x=input('提示：') 该函数返回输入的对象。可输入数字、字符串和其它任意类型对象。 Python 3.7中使用print()函数进行输出。
+ 1.0 分
6 . 简答题 困难 2分
如何在IDLE中运行和调试Python程序？
回答正确
1. 打开 IDLE：首先，打开你的 Python 安装，并启动 IDLE。你可以在开始菜单或应用程序目录中找到 IDLE。
2. 创建新文件：在 IDLE 中，选择 "文件" -> "新建文件" 或使用快捷键 Ctrl + N 来创建一个新的 Python 文件。
3. 编写 Python 代码：在新建的文件中，编写你的 Python 代码。你可以输入你的程序代码，并保存文件。
4. 运行程序：保存好代码后，可以选择 "运行" -> "运行模块" 或使用快捷键 F5 来运行你的程序。IDLE 将执行你的代码，并在 Shell 窗口中显示输出结果。
5. 调试程序：要在 IDLE 中进行调试，你可以使用内置的调试器。在你的代码中插入断点，然后选择 "运行" -> "调试模块" 或使用快捷键 F5 来启动调试器。当程序执行到断点时，它会停下来，允许你逐步执行代码、查看变量值等。你可以在调试器窗口中看到程序的状态。
6. 断点管理：你可以在代码中插入断点，以便在特定位置停止程序的执行。在需要设置断点的行上单击左侧的行号，或使用快捷键 Ctrl + F12。
7. 调试器控制：在调试器中，你可以使用控制按钮来执行操作，如继续执行、单步执行、逐出执行等。这些按钮通常位于调试器窗口的顶部或底部。
8. 查看变量：在调试器中，你可以查看变量的当前值，以便检查程序状态。通常，调试器窗口的一部分会显示当前变量值。
9. 结束调试：当完成调试时，你可以选择 "运行" -> "停止调试" 或关闭调试器窗口来结束调试会话。
正确答案
在“Python Shell”窗口中单击“Debug”菜单中的“Debugger”菜单项，就可以启动IDLE的交互式调试器。这时，IDLE会打开的“Debug Control”窗口，并在“Python Shell”窗口中输出“[DEBUG ON]”并后跟一个“>>>”提示符。这样，我们就能像平时那样使用这个“Python Shell”窗口了，只不过现在输入的任何命令都是允许在调试器下。 我们可以在“Debug Control”窗口查看局部变量和全局变量等有关内容。
+ 1.0 分
7 . 简答题 困难 2分
为什么要在程序中加入注释？怎么在程序中加入注释？ 一个好的、可读性强的程序一般包含20%以上的注释。
回答正确
解释代码目的：注释可以提供关于代码的目的和意图的解释。这对其他开发者来说尤其有用，因为他们可能需要理解你的代码以维护、修改或扩展它。
提高代码可读性：良好的注释可以增强代码的可读性，使其更易于理解。清晰的注释可以帮助读者更快地理解代码的工作原理。
方便调试和错误排查：注释可以帮助你自己或其他人更容易地调试代码，因为它们可以提供关于代码逻辑和特定部分的信息，有助于定位和修复错误。
文档化代码：注释可以充当代码的文档，提供如何使用函数、类或模块的指南，以及输入和输出的说明。
正确答案
方法一：以#开始，表示本行#之后的内容为注释。 #循环输出0到9数字 for i in range(10): print (i, end=' ') 方法二：包含在一对三引号'''...'''或"""..."""之间且不属于任何语句的内容将被解释器认为是注释。
+ 1.0 分
8 . 简答题 中等 2分
Python语言有哪些特点和缺点？
回答正确
优点
1. 简单易学：Python 的语法简单且易于理解，使初学者能够迅速上手。
2. 高级语言：Python 是一种高级编程语言，提供了丰富的内置函数和库，可以简化编程任务。
3. 多用途性：Python 可用于多种不同类型的应用，包括Web开发、数据分析、人工智能、科学计算等。
4. 开源：Python 是开源的，允许开发者自由使用和修改它。
5. 广泛的社区支持：Python 有一个庞大的社区，提供了丰富的文档、库和工具，可以加速开发过程。
6. 跨平台：Python 可以在多个操作系统上运行，包括Windows、Linux、macOS等。
7. 动态类型：Python 是一种动态类型语言，允许变量在运行时动态更改类型。
8. 内置数据结构：Python 提供了丰富的内置数据结构，如列表、字典、集合等，使数据处理更加方便。
缺点：
1. 执行速度较慢：与一些编译型语言相比，Python 的执行速度较慢，特别是对于CPU密集型任务。
2. 全局解释器锁（GIL）：Python 中的 GIL 限制了多线程程序的并行性能。
3. 不适合低级编程：Python 不适用于编写底层系统代码或嵌入式系统，因为它的性能和内存控制能力有限。
4. 依赖库的版本问题：某些 Python 库的不同版本之间可能不兼容，这可能会导致依赖管理问题。
5. 内存消耗：Python 的一些特性可能导致较高的内存消耗，特别是在处理大型数据集时。
正确答案
Python支持命令式编程、函数式编程，完全支持面向对象程序设计，语法简洁清晰，并且拥有大量的几乎支持所有领域应用开发的成熟扩展库。 Python为我们提供了非常完善的基础代码库，覆盖了网络、文件、GUI、数据库、文本等大量内容。用Python开发，许多功能不必从零编写，直接使用现成的即可。除了内置的库外，Python还有大量的第三方库，也就是别人开发的，供你直接使用的东西。当然，如果你开发的代码通过很好的封装，也可以作为第三方库给别人使用。 Python同时也支持伪编译将Python源程序转换为字节码来优化程序和提高运行速度，可以在没有安装Python解释器和相关依赖包的平台上运行。 任何编程语言都有缺点，Python缺点主要有： （1）运行速度慢。 （2）代码不能加密。 （3）用缩进来区分语句关系的方式还是给很多初学者带来了困惑。最常见的情况是tab和空格的混用会导致错误。
+ 1.0 分
9 . 简答题 中等 2分
Python基本输入输出函数是什么？
回答正确
print() 函数：
input() 函数：
正确答案
用Python进行程序设计，输入是通过input( )函数来实现的，input( )的一般格式为： x=input('提示：') 该函数返回输入的对象。可输入数字、字符串和其它任意类型对象。 Python 3.5中使用print()函数进行输出。
+ 1.0 分
10 . 简答题 中等 2分
如何在IDLE中运行和调试Python程序？
回答正确
1. 打开 IDLE：首先，打开你的 Python 安装，并启动 IDLE。你可以在开始菜单或应用程序目录中找到 IDLE。
2. 创建新文件：在 IDLE 中，选择 "文件" -> "新建文件" 或使用快捷键 Ctrl + N 来创建一个新的 Python 文件。
3. 编写 Python 代码：在新建的文件中，编写你的 Python 代码。你可以输入你的程序代码，并保存文件。
4. 运行程序：保存好代码后，可以选择 "运行" -> "运行模块" 或使用快捷键 F5 来运行你的程序。IDLE 将执行你的代码，并在 Shell 窗口中显示输出结果。
5. 调试程序：要在 IDLE 中进行调试，你可以使用内置的调试器。在你的代码中插入断点，然后选择 "运行" -> "调试模块" 或使用快捷键 F5 来启动调试器。当程序执行到断点时，它会停下来，允许你逐步执行代码、查看变量值等。你可以在调试器窗口中看到程序的状态。
6. 断点管理：你可以在代码中插入断点，以便在特定位置停止程序的执行。在需要设置断点的行上单击左侧的行号，或使用快捷键 Ctrl + F12。
7. 调试器控制：在调试器中，你可以使用控制按钮来执行操作，如继续执行、单步执行、逐出执行等。这些按钮通常位于调试器窗口的顶部或底部。
8. 查看变量：在调试器中，你可以查看变量的当前值，以便检查程序状态。通常，调试器窗口的一部分会显示当前变量值。
9. 结束调试：当完成调试时，你可以选择 "运行" -> "停止调试" 或关闭调试器窗口来结束调试会话。
正确答案
在“Python Shell”窗口中单击“Debug”菜单中的“Debugger”菜单项，就可以启动IDLE的交互式调试器。这时，IDLE会打开的“Debug Control”窗口，并在“Python Shell”窗口中输出“[DEBUG ON]”并后跟一个“>>>”提示符。这样，我们就能像平时那样使用这个“Python Shell”窗口了，只不过现在输入的任何命令都是允许在调试器下。 我们可以在“Debug Control”窗口查看局部变量和全局变量等有关内容。
+ 1.0 分
11 . 简答题 中等 2分
为什么要在程序中加入注释？怎么在程序中加入注释？
回答正确
解释代码目的：注释可以提供关于代码的目的和意图的解释。这对其他开发者来说尤其有用，因为他们可能需要理解你的代码以维护、修改或扩展它。
提高代码可读性：良好的注释可以增强代码的可读性，使其更易于理解。清晰的注释可以帮助读者更快地理解代码的工作原理。
方便调试和错误排查：注释可以帮助你自己或其他人更容易地调试代码，因为它们可以提供关于代码逻辑和特定部分的信息，有助于定位和修复错误。
文档化代码：注释可以充当代码的文档，提供如何使用函数、类或模块的指南，以及输入和输出的说明。
正确答案
一个好的、可读性强的程序一般包含20%以上的注释。 方法一：以#开始，表示本行#之后的内容为注释。 #循环输出0到9数字 for i in range(10): print (i, end=' ') 方法二：包含在一对三引号'''...'''或"""..."""之间且不属于任何语句的内容将被解释器认为是注释。
+ 2.0 分
12 .
当需要在字符串中使用特殊字符时，python使用（ ）作为转义字符。
A.\
B./
C.#
D.%
回答正确
A
正确答案
A
+ 0.0 分
13 .
下面（ ）不是有效的变量名。
A._demo
B.banana
C.Numbr
D.my-score
回答错误
C
正确答案
D
+ 2.0 分
14 .
幂运算运算符为（ ）。
A.*
B.**
C.%
D.//
回答正确
B
正确答案
B
+ 2.0 分
15 .
关于a or b的描述错误的是（ ）。
A.若a=True b=True 则 a or b ==True
B.若a=True b=False 则 a or b ==True
C.若a=True b=True 则 a or b ==False
D.若a=False b=False 则 a or b ==False
回答正确
C
正确答案
C
+ 2.0 分
16 .
优先级最高的运算符为（ ）。
A./
B.//
C.*
D.()
回答正确
D
正确答案
D
+ 2.0 分
17 .
下面程序的运行结果为（ ）。 a=10 def setNumber(): a=100 setNumber() print(a)
A.10
B.100
C.10100
D.10010
回答正确
A
正确答案
A
+ 2.0 分
18 .
关于a or b的描述错误的是（ ）。
A.若a=True b=True 则 a or b ==True
B.若a=True b=False 则 a or b ==True
C.若a=True b=True 则 a or b ==False
D.若a=False b=False 则 a or b ==False
回答正确
C
正确答案
C
+ 2.0 分
19 .
下面程序的运行结果为（ ）。 def swap(list): temp=list[0] list[0]=list[1] list[1]=temp list=[1,2] swap(list) print(list)
A.[1,2]
B.[2,1]
C.[2,2]
D.[1,1]
回答正确
B
正确答案
B
+ 2.0 分
20 .
在每个python类中，都包含一个特殊的变量（）。它表示当前类自身，可以使用它来引用类中的成员变量和成员函数。
A.this
B.me
C.self
D.与类同名
回答正确
C
正确答案
C
+ 0.0 分
21 .
Python定义私有变量的方法为（ ）。
A.使用__private 关键字
B.使用public关键字
C.使用__xxx__定义变量名
D.使用__xxx定义变量名
回答错误
C
正确答案
D
+ 2.0 分
22 .
在print函数的输出字符串中可以将（ ）作为参数，代表后面指定要输出的字符串
A.%d
B.%c
C.%s
D.%t
回答正确
C
正确答案
C
+ 2.0 分
23 .
字符串是一个字符序列，例如，字符串s，从右侧向左第3个字符用什么索引？
A.s[3]
B.s[-3]
C.s[0:-3]
D.s[:-3]
回答正确
B
正确答案
B
+ 2.0 分
24 .
关于赋值语句的作用，正确的描述是
A.变量和对象必须类型相同
B.每个赋值语句只能给一个变量赋值
C.将变量改写为新的值
D.将变量绑定到对象
回答正确
D
正确答案
D
+ 2.0 分
25 .
若 a = 'abcd' ，若想将 a 变为 'ebcd' ，则下列语句正确的是
A.a[0] = 'e'
B.replace('a', 'e')
C.a[1] = 'e'
D.a = 'e' + a[1:]
回答正确
D
正确答案
D
+ 2.0 分
26 .
下列不合法的Python变量名是
A.Python2
B.N.x
C.sum
D.Hello_World
回答正确
B
正确答案
B
+ 2.0 分
27 .
执行以下两条语句后，lst的结果是 1. lst = [3, 2, 1] 2. lst.append(lst)
A.[3, 2, 1, [3, 2, 1]]
B.[3, 2, 1, […]]，其中“…”表示无穷递归
C.抛出异常
D.[3, 2, 1, lst]
回答正确
B
正确答案
B
+ 2.0 分
28 .
下列不是Python语言关键字的是
A.open
B.if
C.lambda
D.finally
回答正确
A
正确答案
A
+ 2.0 分
29 .
与x > y and y > z 语句等价的是
A.x > y > z
B.not x < y or not y < z
C.not x < y or y < z
D.x > y or not y < z
回答正确
A
正确答案
A
+ 1.0 分
30 . 单选题 简单 1分
以下哪条语句定义了一个Python字典
A.{ }
B.{1, 2, 3}
C.[1, 2, 3]
D.(1, 2, 3)
回答正确
A
正确答案
A
+ 1.0 分
31 . 单选题 简单 1分
执行下面操作后，list2的值是： 1. list1 = ['a', 'b', 'c'] 2. list2 = list1 3. list1.append('de')
A.['a', 'b', 'c']
B.['a', 'b', 'c', 'de']
C.['d', 'e', 'a', 'b', 'c']
D.['a', 'b', 'c', 'd', 'e']
回答正确
B
正确答案
B
+ 1.0 分
32 . 单选题 简单 1分
下列运算符的使用错误的是：
A.1 + 'a'
B.[1, 2, 3] + [4, 5, 6]
C.3 * 'abc'
D.-10 % -3
回答正确
A
正确答案
A
+ 1.0 分
33 . 单选题 简单 1分
字符串是一个字符序列，例如，字符串s，从右侧向左第3个字符用什么索引？
A.s[3]
B.s[-3]
C.s[0:-3]
D.s[:-3]
回答正确
B
正确答案
B
+ 1.0 分
34 . 单选题 简单 1分
获得字符串s长度的方法是什么？
A.s.len()
B.s.length
C.len(s)
D.length(s)
回答正确
C
正确答案
C
+ 1.0 分
35 . 单选题 简单 1分
Python中布尔变量的值为
A.真，假
B.0,1
C.T,F
D.True，False
回答正确
D
正确答案
D
+ 1.0 分
36 . 单选题 简单 1分
对负数取平方根，即使用函数math.sqrt(x)，其中x为负数，将产生
A.什么都不产生
B.虚数
C.程序崩溃
D.ValueError错误
回答正确
D
正确答案
D
+ 1.0 分
37 . 单选题 简单 1分
下列哪一项不是Python的数据类型：
A.string
B.float
C.rational
D.int
回答正确
C
正确答案
C
+ 1.0 分
38 . 单选题 简单 1分
下面哪一个不是Python语言的合法命名：
A.monthly
B._Monthly3_
C.monTHly
D.3monthly
回答正确
D
正确答案
D
+ 1.0 分
39 . 单选题 简单 1分
Python中，用于获取用户输入的命令为：
A.input
B.read
C.get
D.for
回答正确
A
正确答案
A
+ 1.0 分
40 . 单选题 简单 1分
用于生成和计算出新的数值的一段代码称为：
A.表达式
B.赋值语句
C.生成语句
D.标识符
回答正确
A
正确答案
A
+ 1.0 分
41 . 单选题 简单 1分
以下关于Python数值运算描述错误的是哪一项？
A.Python支持+=、%=这样的增量赋值操作符。
B.在Python 2.x中，默认情况下10/3 == 3的判别结果是False，而Python 3.x中则不同。
C.Python内置支持复数运算，可以使用j或者J来表示。
D.%运算符表示运算对象取余。
回答正确
B
正确答案
B
+ 1.0 分
42 . 单选题 简单 1分
以下关于字符串处理的描述错误的是哪一项？
A.print （'C:\file\time'），输出结果是C:\file\time。
B.Python 2.x中字符串是以单引号或双引号括起来的任意文本，如果字符串赋值的时候，内部有单引号或双引号时如果不想使用转义字符常常可以使用r运算符来表示。
C."\"符号可以被用来表示转义符号，例如'doesn\'t'和"doesn't"都表示字符串doesn't。
D.被单引号('...')或者双引号("...")包围的都是字符串。
回答正确
A
正确答案
A
+ 1.0 分
43 . 单选题 简单 1分
以下关于字符串处理正确的是哪一项？
A.字符串是自带索引的，对变量word = "Python"，word
B.+号可以用来拼接两个字符串，对于以下代码的输出字符串是Python 1. >>> prefix = "Py" 2. >>> prefix + 'thon'
C.字符串的索引有两个边界，前边界和后边界都是包括的。
D.对于字符串"apple"， 3 * "apple"的结果为"3apple"。
回答正确
B
正确答案
B
+ 1.0 分
44 . 单选题 简单 1分
字符串是一个字符序列，例如，字符串s，从右侧向左第3个字符用什么索引？
A.s[3]
B.s[-3]
C.s[0:-3]
D.s[:-3]
回答正确
B
正确答案
B
+ 1.0 分
45 . 单选题 简单 1分
关于赋值语句的作用，正确的描述是（ )。
A.将变量绑定到对象
B.每个赋值语句只能给一个变量赋值
C.将变量改写为新的值
D.变量和对象必须类型相同
回答正确
A
正确答案
A
+ 1.0 分
46 . 单选题 简单 1分
若 a = 'abcd' ，若想将 a 变为 'ebcd' ，则下列语句正确的是（ )。
A.a[0] = 'e'
B.replace('a', 'e')
C.a[1] = 'e'
D.a = 'e' + a[1:]
回答正确
D
正确答案
D
+ 1.0 分
47 . 单选题 简单 1分
下列不合法的Python变量名是（ )。
A.Python2
B.N_x
C.sum
D.Hello$World
回答正确
D
正确答案
D
+ 0.0 分
48 . 单选题 简单 1分
下列不是Python语言关键字的是（ ）。
A.else
B.print
C.lambda
D.finally
回答错误
B
正确答案
A
+ 1.0 分
49 . 单选题 简单 1分
下列运算符的使用错误的是（ ）。
A.1 + 'a'
B.[1, 2, 3] + [4, 5, 6]
C.3 * 'abc'
D.-10 % -3
回答正确
A
正确答案
A
+ 1.0 分
50 . 单选题 简单 1分
用于生成和计算出新的数值的一段代码称为：
A.赋值语句
B.表达式
C.生成语句
D.标识符
回答正确
B
正确答案
B
+ 1.0 分
51 . 单选题 简单 1分
以下关于Python数值运算描述错误的是哪一项？
A.Python支持+=、%=这样的增量赋值操作符。
B.默认情况下10/3 == 3的判别结果是True
C.Python内置支持复数运算，可以使用j或者J来表示。
D.%运算符表示运算对象取余。
回答正确
B
正确答案
B
+ 1.0 分
52 . 单选题 简单 1分
下列哪个语句在Python中是非法的（ ）。
A.x = y = z = 1
B.x = (y = z + 1)
C.x, y = y, x
D.x += y
回答正确
B
正确答案
B
+ 1.0 分
53 . 单选题 简单 1分
下面哪个不是Python合法的标识符（ ）。
A.int32
B.40XL
C.self
D.__name__
回答正确
B
正确答案
B
+ 0.0 分
54 . 单选题 简单 1分
下列哪种说法是错误的（ ）。
A.除字典类型外，所有标准对象均可以用于布尔测试
B.空字符串的布尔值是False
C.空列表对象的布尔值是False
D.值为0的任何数字对象的布尔值是False
回答错误
D
正确答案
A
+ 1.0 分
55 . 单选题 简单 1分
Python不支持的数据类型有（ ）。
A.char
B.int
C.float
D.list
回答正确
A
正确答案
A
+ 1.0 分
56 . 单选题 简单 1分
以下不能创建一个字典的语句是 （ ）。
A.dict1 = {}
B.dict2 = { 3 : 5 }
C.dict3 = {[1,2,3]: “uestc”}
D.dict4 = {(1,2,3): “uestc”}
回答正确
C
正确答案
C
+ 1.0 分
57 . 单选题 简单 1分
关于字符串下列说法错误的是（ ）。
A.字符应该视为长度为1的字符串
B.字符串以\0标志字符串的结束
C.既可以用单引号，也可以用双引号创建字符串
D.在三引号字符串中可以包含换行回车等特殊字符
回答正确
B
正确答案
B
+ 1.0 分
58 . 单选题 简单 1分
下列表达式的值为True的是（ ）。
A.(2**=3)<(2*=3)
B.3>2>2
C.1==1 and 2!=1
D.not(1==1 and 0!=1)
回答正确
C
正确答案
C
+ 1.0 分
59 . 单选题 简单 1分
type(1+2L*3.14)的结果是（ ）。
A.<class ‘int’>
B.<class ‘long’>
C.<class ‘float’>
D.<class ‘str’>
回答正确
C
正确答案
C
+ 1.0 分
60 . 单选题 简单 1分
当需要在字符串中使用特殊字符时，python使用（ ）作为转义字符。
A.\
B./
C.#
D.%
回答正确
A
正确答案
A
+ 1.0 分
61 . 单选题 简单 1分
下面（ ）不是有效的变量名。
A._demo
B.banana
C.Numbr
D.my-score
回答正确
D
正确答案
D
+ 1.0 分
62 . 单选题 简单 1分
幂运算运算符为（ ）。
A.*
B.**
C.%
D.//
回答正确
B
正确答案
B
+ 1.0 分
63 . 单选题 简单 1分
关于a or b的描述错误的是（ ）。
A.若a=True b=True 则 a or b ==True
B.若a=True b=False 则 a or b ==True
C.若a=True b=True 则 a or b ==False
D.若a=False b=False 则 a or b ==False
回答正确
C
正确答案
C
+ 1.0 分
64 . 单选题 简单 1分
优先级最高的运算符为（ ）。
A./
B.//
C.*
D.()
回答正确
D
正确答案
D
+ 1.0 分
65 . 单选题 简单 1分
下面程序的运行结果为（ ）。 a=10 def setNumber(): a=100 setNumber() print(a)
A.10
B.100
C.10100
D.10010
回答正确
A
正确答案
A
+ 1.0 分
66 . 单选题 简单 1分
关于a or b的描述错误的是（ ）。
A.若a=True b=True 则 a or b ==True
B.若a=True b=False 则 a or b ==True
C.若a=True b=True 则 a or b ==False
D.若a=False b=False 则 a or b ==False
回答正确
C
正确答案
C
+ 1.0 分
67 . 单选题 简单 1分
下面程序的运行结果为（ ）。 def swap(list): temp=list[0] list[0]=list[1] list[1]=temp list=[1,2] swap(list) print(list)
A.[1,2]
B.[2,1]
C.[2,2]
D.[1,1]
回答正确
B
正确答案
B
+ 1.0 分
68 . 单选题 简单 1分
在每个python类中，都包含一个特殊的变量（）。它表示当前类自身，可以使用它来引用类中的成员变量和成员函数。
A.this
B.me
C.self
D.与类同名
回答正确
C
正确答案
C
+ 0.0 分
69 . 单选题 简单 1分
Python定义私有变量的方法为（ ）。
A.使用__private 关键字
B.使用public关键字
C.使用__xxx__定义变量名
D.使用__xxx定义变量名
回答错误
C
正确答案
D
+ 1.0 分
70 . 单选题 简单 1分
在print函数的输出字符串中可以将（ ）作为参数，代表后面指定要输出的字符串
A.%d
B.%c
C.%s
D.%t
回答正确
C
正确答案
C
+ 1.0 分
71 . 单选题 简单 1分
字符串是一个字符序列，例如，字符串s，从右侧向左第3个字符用什么索引？
A.s[3]
B.s[-3]
C.s[0:-3]
D.s[:-3]
回答正确
B
正确答案
B
平时作业3-第3-4章
总分：100分
得分：69.0分
+ 0.0 分
1 . 编程题 困难 2分
输出成绩的对应等级
回答错误
输入一个百分制的成绩，经判断后输出该成绩的对应等级。其中，90分以上为“A”，80~89分为“B”，70~79分为“C”，60~69分为“D”，60分以下为“E”。
score = int(input(""))
if score >= 90:
grade = "A"elif score >= 80:
grade = "B"elif score >= 70:
grade = "C"elif score >= 60:
grade = "D"else:
grade = "E"
print('',grade)
正确答案
a=input("")a=int(a)if a>89:
print("A")elif a>79 and a <90:
print("B")elif a>69 and a <80:
print("C")elif a>59 and a <70:
print("D")else:
print("E")
简单的分支判断既可以实现。
+ 2.0 分
2 . 编程题 困难 2分
计算并输出优惠价
回答正确
某百货公司为了促销，采用购物打折的办法。1000元以上者，按九五折优惠；2000元以上者，按九折优惠；3000元以上者，按八五折优惠；5000元以上者，按八折优惠。编写程序，输入购物款数，计算并输出优惠价。
def calculate_discount(price):
if price >= 5000:
discount_price = price * 0.8
elif price >= 3000:
discount_price = price * 0.85
elif price >= 2000:
discount_price = price * 0.9
elif price >= 1000:
discount_price = price * 0.95
else:
discount_price = price
return discount_price
price = float(input(""))discounted_price = calculate_discount(price)print("优惠价为：", discounted_price)
正确答案
a=input("")a=int(a)if a>=5000:
print("优惠价为：",a*0.8)
elif a>=3000:
print("优惠价为：",a*0.85)
elif a>=2000:
print("优惠价为：",a*0.9)
elif a>=1000:
print("优惠价为：",a*0.95)else:
print("没有优惠哦！ 价格为：",a)
简单的分支判断既可以实现。
+ 2.0 分
3 . 编程题 困难 2分
求阶乘
回答正确
编写程序，求1!+3!+5!+7!+9!。
# 递归函数：计算阶乘def factorial(n):
if n == 0 or n == 1:
return 1
else:
return n * factorial(n-1)
result = 0
# 循环计算每个奇数的阶乘并累加for i in range(1, 10, 2):
result += factorial(i)
print(result)
正确答案
L = [1, 3, 5, 7, 9]
def func(n):
if n == 1:
return 1
else:
return n * func(n-1)
total = 0
for i in L:
total = total + func(i)print(total)
+ 0.0 分
4 . 编程题 困难 2分
计算公式s的值，s =1 + (1 + 2) + (1 + 2 + 3) + … + (1 + 2 + 3 + … + n)
回答错误
编写程序，计算下列公式中s的值（n是运行程序时输入的一个正整数）。
s =1 + (1 + 2) + (1 + 2 + 3) + … + (1 + 2 + 3 + … + n)
n = input("")s = 0 # 初始化s的值为0# 遍历1到n，分别求出每个括号内的和并累加到s中for i in range(1, n+1):
s += sum(range(1, i+1))print("",s)
正确答案
m=input("")m=int(m)n=1s=0a=0while n <=m:
a=a+n
s=s+a
n+=1print(s)
a是一个数的累加代表一项，s是公式和，每求一次a加到s中。
+ 1.0 分
5 . 简答题 困难 2分
“百马百瓦问题”：有100匹马驮100块瓦，大马驮3块，小马驮2块，两个马驹驮1块。问大马、小马、马驹各有多少匹？
回答正确
for big_horse in range(1, 34): # 大马的数量范围为1到33，因为至少有一个大马
for small_horse in range(1, 50): # 小马的数量范围为1到49，因为至少有一个小马
for foal in range(1, 100): # 马驹的数量范围为1到99，因为至少有一个马驹
if ((big_horse * 3) + (small_horse * 2) + (foal * 1)) == 100: # 检查总瓦数是否等于100
print("大马数量：", big_horse)
print("小马数量：", small_horse)
print("马驹数量：", foal)
break # 找到一组解后即停止遍历
正确答案
for i in range(34):
for j in range(51):
k=100-i-j
if 3*i+2*j+k/2==100 and k%2==0:
print("大马有：",i,"小马有： ",j,"马驹有： ",k)
+ 1.0 分
6 . 简答题 困难 2分
有一个数列，其前三项分别为1、2、3，从第四项开始，每项均为其相邻的前三项之和的1/2，问：该数列从第几项开始，其数值超过1200。
回答正确
a, b, c = 1, 2, 3 # 初始化前三项
n = 3 # 记录项数，初始为3
while c <= 1200:
a, b, c = b, c, (a + b + c) / 2 # 更新前三项，计算下一项
n += 1 # 项数加一
print("该数列从第", n, "项开始，其数值超过1200。")
正确答案
a=[0 for x in range(0, 100)] a[0]=1 a[1]=2 a[2]=3 i=3 while 1: a[i]=(a[i-1]+a[i-2]+a[i-3])/2 if a[i]>1200: print(i+1) break
使用序列，a[i]=a[i-1]+a[i-2]+a[i-3]。
+ 1.0 分
7 . 简答题 困难 2分
找出1与100之间的全部“同构数”。“同构数”是这样一种数，它出现在它的平方数的右端。例如，5的平方是25，5是25中右端的数，5就是同构数，25也是一个同构数，它的平方是625。
回答正确
def is_automorphic(number):
square = number ** 2
str_number = str(number)
str_square = str(square)
if str_number == str_square[-len(str_number):]:
return True
return False
automorphic_numbers = []
for number in range(1, 101):
if is_automorphic(number):
automorphic_numbers.append(number)
print("1到100之间的全部同构数：", automorphic_numbers)
正确答案
for i in range(1,101): k=i*i if i<10: if k%10==i: print(i) elif i<100: if k%100==i: print(i) else: if k%1000==i: print(i)
+ 1.0 分
8 . 简答题 困难 2分
猴子吃桃问题。猴子第一天摘下若干个桃子，当即吃了一半，还不过瘾，又多吃了一个，第二天早上将剩下的桃子吃掉一半，又多吃了一个。以后每天早上都吃前一天剩下的一半再加一个。到第10天早上想再吃时，发现只剩下一个桃子了。求第一天共摘了多少个桃子。
回答正确
def calculate_peach_number():
remain_peaches = 1 # 第10天早上只剩下1个桃子
for day in range(9, 0, -1): # 逆推第9天到第1天
today_peaches = (remain_peaches + 1) * 2 # 当天摘的桃子数
remain_peaches = today_peaches # 剩余桃子数等于当天摘的桃子数
return remain_peaches
# 输出结果
print("第一天共摘了", calculate_peach_number(), "个桃子。")
正确答案
程序分析：采取逆向思维的方法，从后往前推断。
程序源代码：
x2 = 1
for day in range(9,0,-1):
x1 = (x2 + 1) * 2
x2 = x1
print (x1)
+ 0.0 分
9 . 编程题 困难 2分
球自由落体
回答错误
def calculate_height(initial_height, time):
g = 9.8 # 重力加速度，单位：m/s^2
# 计算球离地面的高度
height = initial_height - 0.5 * g * time ** 2
return height
# 输入初始高度和时间
initial_height = float(input("请输入球的初始高度（单位：米）："))
time = float(input("请输入经过的时间（单位：秒）："))
result = calculate_height(initial_height, time)print("球离地面的高度为：{:.2f} 米".format(result))
正确答案
Sn = 100.0
Hn = Sn / 2for n in range(2,11):
Sn += 2 * Hn
Hn /= 2print ( 'Total of road is %f' % Sn)print ('The tenth is %f meter' % Hn)
+ 0.0 分
10 . 编程题 困难 2分
统计字符
回答错误
def count_characters(string):
char_count = {} # 使用字典来存储字符及其出现次数
for char in string:
if char in char_count: # 如果字符已经在字典中，增加计数
char_count[char] += 1
else: # 如果字符不在字典中，添加新的键值对
char_count[char] = 1
return char_count
# 调用函数并输出结果
input_string = input("请输入一个字符串：")result = count_characters(input_string)for char, count in result.items():
print("字符 '{0}' 出现了 {1} 次".format(char, count))
正确答案
oStr = input('')
str_num = 0
spac_num = 0
figue_num = 0
other_num=0 for strs in oStr:
if strs.isalpha(): #字母
str_num +=1
elif strs.isdigit():#数字
figue_num +=1
elif strs == ' ': #空格
spac_num +=1
else:
other_num+=1print ('英文字母有：%d' %str_num)print ('数字有：%d'%figue_num)print ('空格有：%d'%spac_num)print ('其它字符有：%d'%other_num)
+ 1.0 分
11 . 简答题 困难 2分
一个数如果恰好等于它的因子之和，这个数就称为“完数”。例如6=1＋2＋3.编程找出1000以内的所有完数。
回答正确
for num in range(1, 1001): # 遍历1到1000之间的每个数
factors = [] # 存储因子的列表
for i in range(1, num): # 查找num的因子
if num % i == 0: # 如果i是num的因子
factors.append(i) # 将i添加到列表中
if sum(factors) == num: # 如果因子之和等于num本身
print(num) # 输出找到的完数
正确答案
for j in range(2,1001):
k = []
n = -1
s = j
for i in range(1,j):
if j % i == 0:
n += 1
s -= i
k.append(i)
if s == 0: #是完数
print (j)
for i in range(n):
print(k[i],end=' ')
print(k[n])
+ 1.0 分
12 . 简答题 中等 2分
输入一个整数n，判断其能否同时被5和7整除，如能则输出“xx能同时被5和7 整除”，否则输出“xx不能同时被5和7 整除”。要求“xx”为输入的具体数据。
回答正确
n = int(input("请输入一个整数：")) # 输入一个整数
if n % 5 == 0 and n % 7 == 0: # 如果n能同时被5和7整除
print("{0}能同时被5和7整除".format(n)) # 输出提示信息
else: # 如果n不能同时被5和7整除
print("{0}不能同时被5和7整除".format(n)) # 输出提示信息
正确答案
a=input("输入一个整数：") a=int(a) if a%5==0 and a%7==0: print(a," 能同时被5和7整除") else: print(a," 不能同时被5和7整除")
+ 1.0 分
13 . 简答题 中等 2分
输入一个百分制的成绩，经判断后输出该成绩的对应等级。其中，90分以上为“A”，80~89分为“B”，70~79分为“C”，60~69分为“D”，60分以下为“E”。
回答正确
score = int(input(""))
if score >= 90:
grade = "A"
elif score >= 80:
grade = "B"
elif score >= 70:
grade = "C"
elif score >= 60:
grade = "D"
else:
grade = "E"
print('',grade)
正确答案
a=input("输入百分制成绩：") a=int(a) if a>89: print("A") elif a>79 and a<90: print("B") elif a>69 and a<80: print("C") elif a>59 and a<70: print("D") else: print("E")
+ 1.0 分
14 . 简答题 中等 2分
某百货公司为了促销，采用购物打折的办法。1000元以上者，按九五折优惠；2000元以上者，按九折优惠；3000元以上者，按八五折优惠；5000元以上者，按八折优惠。编写程序，输入购物款数，计算并输出优惠价。
回答正确
money = int(input("请输入购物金额：")) # 输入购物金额
if money >= 5000: # 如果购物金额大于等于5000元
cost = money * 0.8 # 打八折
elif money >= 3000: # 如果购物金额大于等于3000元
cost = money * 0.85 # 打八五折
elif money >= 2000: # 如果购物金额大于等于2000元
cost = money * 0.9 # 打九折
elif money >= 1000: # 如果购物金额大于等于1000元
cost = money * 0.95 # 打九五折
else: # 如果购物金额小于1000元
cost = money # 不打折
print("优惠后的价格为：{:.2f}元".format(cost)) # 输出优惠后的价格
正确答案
a=input("输入购物款数：") a=int(a) if a>=5000: print("优惠价为：",a*0.8) elif a>=3000: print("优惠价为：",a*0.85) elif a>=2000: print("优惠价为：",a*0.9) elif a>=1000: print("优惠价为：",a*0.95) else: print("没有优惠哦！ 价格为：",a)
+ 1.0 分
15 . 简答题 中等 2分
编写一个求整数n阶乘（n!）的程序。
回答正确
def factorial(n):
if n == 0 or n == 1: # 如果n等于0或1，直接返回1
return 1
else:
return n * factorial(n - 1) # 否则递归调用factorial函数，计算n-1的阶乘，再乘以n
n = int(input("请输入一个整数：")) # 输入一个整数
print("{0}的阶乘为：{1}".format(n, factorial(n))) # 输出计算结果
正确答案
n=input("输入整数n：") n=int(n) s=1 m=1 while m<=n: s*=m m=m+1 print(s)
+ 1.0 分
16 . 简答题 中等 2分
编写程序，求1!+3!+5!+7!+9!。
回答正确
def factorial(n):
if n == 0 or n == 1:
return 1
else:
return n * factorial(n - 1)
result = 0 # 存储计算结果的变量
for i in range(1, 10, 2): # 遍历1到9之间的奇数
result += factorial(i) # 计算阶乘并累加到结果中
print("计算结果为：", result)
正确答案
sum=0 s=1 m=1 while m<=9: s*=m if m%2==1: sum+=s m=m+1 print(sum)
+ 1.0 分
17 . 简答题 中等 2分
编写程序，计算下列公式中s的值（n是运行程序时输入的一个正整数）。 s =1 + (1 + 2) + (1 + 2 + 3) + … + (1 + 2 + 3 + … + n) s =1 + (1 + 2) + (1 + 2 + 3) + … + (1 + 2 + 3 + … + n)
回答正确
n = int(input("请输入一个正整数：")) # 输入一个正整数
s = 0 # 初始化s的值
sum_n = 0 # 初始化(1 + 2 + 3 + ... + n)的值
for i in range(1, n+1): # 遍历1到n之间的每个数
sum_n += i # 计算(1 + 2 + 3 + ... + n)的值
s += sum_n # 计算s的值
print("s的值为：", s)
正确答案
m=input("输入项数") m=int(m) n=1 s=0 a=0 while n<=m: a=a+n s=s+a n+=1 print(s) s =12+ 22 + 32 + … + (10×n+2) s =12+ 22 + 32 + … + (10×n+2) m=input("输入项数") m=int(m) n=1 s=0 while n<= m: a=10*n+2 s=s+a n+=1 print(s) s =1×2-2×3+3×4-4×5+ … +(-1) (n-1) ×n×(n+1) s =1×2-2×3+3×4-4×5+ … +(-1) (n-1) ×n×(n+1) m=input("输入项数") m=int(m) n=1 s=0 f=1 while n<=m: s=s+f*n*(n+1) f=-f n+=1 print(s)
+ 1.0 分
18 . 简答题 中等 2分
“百马百瓦问题”：有100匹马驮100块瓦，大马驮3块，小马驮2块，两个马驹驮1块。问大马、小马、马驹各有多少匹？
回答正确
def solve_horses_watts():
for x in range(1, 34): # 大马数量范围是1到33
for y in range(1, 50): # 小马数量范围是1到49
z = 100 - x - y # 马驹数量可以通过总数量减去大马和小马的数量得到
if 3*x + 2*y + z/2 == 100:
return x, y, z
x, y, z = solve_horses_watts()
print("大马有", x, "匹")
print("小马有", y, "匹")
print("马驹有", z, "匹")
正确答案
for i in range(34): for j in range(51): k=100-i-j if 3*i+2*j+k/2==100 and k%2==0: print("大马有：",i,"小马有： ",j,"马驹有： ",k)
+ 1.0 分
19 . 简答题 中等 2分
有一个数列，其前三项分别为1、2、3，从第四项开始，每项均为其相邻的前三项之和的1/2，问：该数列从第几项开始，其数值超过1200。
回答正确
def find_term():
sequence = [1, 2, 3] # 前三项
term = 4 # 第四项开始
while sequence[-1] <= 1200:
next_value = (sequence[-1] + sequence[-2] + sequence[-3]) / 2
sequence.append(next_value)
term += 1
return term
result = find_term()
print("数列从第", result, "项开始，其数值超过1200。")
正确答案
a=[0 for x in range(0, 100)] a[0]=1 a[1]=2 a[2]=3 i=0 while 1: i=i+1 if i>2: a[i]=a[i-1]+a[i-2]+a[i-3] if a[i]>1200: print("该数列从第 ",i+1," 项开始，其数值超过1200") break
+ 1.0 分
20 . 简答题 中等 2分
找出1与100之间的全部“同构数”。“同构数”是这样一种数，它出现在它的平方数的右端。例如，5的平方是25，5是25中右端的数，5就是同构数，25也是一个同构数，它的平方是625。
回答正确
def is_automorphic(number):
square = number ** 2
str_number = str(number)
str_square = str(square)
if str_number == str_square[-len(str_number):]:
return True
return False
automorphic_numbers = []
for number in range(1, 101):
if is_automorphic(number):
automorphic_numbers.append(number)
print("1到100之间的全部同构数：", automorphic_numbers)
正确答案
for i in range(1,101): k=i*i if i<10: if k%10==i: print(i) elif i<100: if k%100==i: print(i) else: if k%1000==i: print(i)
+ 1.0 分
21 . 简答题 中等 2分
猴子吃桃问题。猴子第一天摘下若干个桃子，当即吃了一半，还不过瘾，又多吃了一个，第二天早上将剩下的桃子吃掉一半，又多吃了一个。以后每天早上都吃前一天剩下的一半再加一个。到第10天早上想再吃时，发现只剩下一个桃子了。求第一天共摘了多少个桃子。
回答正确
def calculate_peach_number():
remain_peaches = 1 # 第10天早上只剩下1个桃子
for day in range(9, 0, -1): # 逆推第9天到第1天
today_peaches = (remain_peaches + 1) * 2 # 当天摘的桃子数
remain_peaches = today_peaches # 剩余桃子数等于当天摘的桃子数
return remain_peaches
# 输出结果
print("第一天共摘了", calculate_peach_number(), "个桃子。")
正确答案
程序分析：采取逆向思维的方法，从后往前推断。 程序源代码： x2 = 1 for day in range(9,0,-1): x1 = (x2 + 1) * 2 x2 = x1 print (x1)
+ 1.0 分
22 . 简答题 中等 2分
一球从100米高度自由落下，每次落地后反跳回原高度的一半；再落下，求它在 第10次落地时，共经过多少米？第10次反弹多高？
回答正确
def calculate_distance_and_height(height, times):
total_distance = height # 初始下落距离等于初始高度
bounce_height = height # 反弹高度等于初始高度
for _ in range(1, times+1):
total_distance += 2 * bounce_height # 每次下落和反弹，总距离增加两倍的反弹高度
bounce_height /= 2 # 反弹高度每次减半
return total_distance, bounce_height
# 示例用法
height = 100 # 初始高度为100米
times = 10 # 第10次落地
total_distance, bounce_height = calculate_distance_and_height(height, times)
print("第10次落地时共经过的距离：", total_distance, "米")
print("第10次反弹的高度：", bounce_height, "米")
正确答案
Sn = 100.0 Hn = Sn / 2 for n in range(2,11): Sn += 2 * Hn Hn /= 2 print ( 'Total of road is %f' % Sn) print ('The tenth is %f meter' % Hn)
+ 1.0 分
23 . 简答题 中等 2分
输入某年某月某日，判断这一天是这一年的第几天？ 程序分析：以3月5日为例，应该先把前两个月的加起来，然后再加上5天即本年的第几天，特殊情况，闰年2月29天。
回答正确
def calculate_day_of_year(year, month, day):
days_in_months = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
if is_leap_year(year):
days_in_months[1] = 29
total_days = 0
for i in range(month - 1):
total_days += days_in_months[i]
total_days += day
return total_days
def is_leap_year(year):
if (year % 4 == 0 and year % 100 != 0) or year % 400 == 0:
return True
else:
return False
# 从键盘获取输入的年月日
year = int(input("请输入年份："))
month = int(input("请输入月份："))
day = int(input("请输入日期："))
# 调用函数计算这一天是该年的第几天
result = calculate_day_of_year(year, month, day)
print("这一天是该年的第", result, "天")
正确答案
import math year=int(input('输入某年某月某日，判断这一天是这一年的第几天。\n请输入年：')) month=int(input('请输入月：')) day=int(input("请输入日：")) Day_month=[31,28,31,30,31,30,31,31,30,31,30,31] if year%4==0 and year%100!=0 or year%400==0: Day_month[1]=29 i=0 s=0 while i
+ 1.0 分
24 . 简答题 中等 2分
输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数。
回答正确
def count_characters(string):
letter_count = 0
space_count = 0
digit_count = 0
other_count = 0
for char in string:
if char.isalpha(): # 英文字母判断
letter_count += 1
elif char.isspace(): # 空格判断
space_count += 1
elif char.isdigit(): # 数字判断
digit_count += 1
else: # 其他字符
other_count += 1
return letter_count, space_count, digit_count, other_count
# 调用函数统计字符类型数量
text = input("请输入一行字符：")
result = count_characters(text)
print("英文字母数量:", result[0])
print("空格数量:", result[1])
print("数字数量:", result[2])
print("其他字符数量:", result[3])
正确答案
oStr = input('请输入一串字符:') str_num = 0 spac_num = 0 figue_num = 0 other_num=0 for strs in oStr: if strs.isalpha(): #字母 str_num +=1 elif strs.isdigit():#数字 figue_num +=1 elif strs == ' ': #空格 spac_num +=1 else: other_num+=1 print ('英文字母有：%d' %str_num) print ('数字有：%d'%figue_num) print ('空格有：%d'%spac_num) print ('其它字符有：%d'%other_num)
+ 1.0 分
25 . 简答题 中等 2分
题目：求s=a+aa+aaa+aaaa+aa...a的值，其中a是一个数字。例如2+22+222+2222+22222(此时共有5个数相加)，几个数相加由键盘控制。
回答正确
def calculate_sequence(a, n):
total = 0
current_term = a
for i in range(n):
total += current_term
current_term = current_term * 10 + a
return total
# 从键盘获取输入的数字和相加的个数
a = int(input("请输入一个数字 a："))
n = int(input("请输入相加的个数 n："))
# 调用函数计算序列的值
result = calculate_sequence(a, n)
print("序列的值为：", result)
正确答案
程序分析：关键是计算出每一项的值。 源代码： from functools import reduce Tn = 0 Sn = [] n = int(input('n = :\n')) a = int(input('a = :\n')) for count in range(n): Tn = Tn + a a = a * 10 Sn.append(Tn) print (Tn) print(reduce(lambda x,y : x + y, [2, 4, 5, 7, 12])) print(reduce(lambda x,y : x + y, Sn)) print (sum(Sn))
+ 1.0 分
26 . 简答题 中等 2分
一个数如果恰好等于它的因子之和，这个数就称为“完数”。例如6=1＋2＋3.编程找出1000以内的所有完数。
回答正确
def find_perfect_numbers():
perfect_numbers = []
for number in range(2, 1001):
factors = []
for i in range(1, number):
if number % i == 0:
factors.append(i)
if sum(factors) == number:
perfect_numbers.append(number)
return perfect_numbers
# 调用函数找出1000以内的所有完数
perfect_nums = find_perfect_numbers()
print("1000以内的所有完数：", perfect_nums)
正确答案
for j in range(2,1001): k = [] n = -1 s = j for i in range(1,j): if j % i == 0: n += 1 s -= i k.append(i) if s == 0: #是完数 print (j) for i in range(n): print(k[i],end=' ') print(k[n]) 结果： 6 1 2 3 28 1 2 4 7 14 496 1 2 4 8 16 31 62 124 248
+ 2.0 分
27 .
使用（ ）关键字来创建python自定义函数。
A.function
B.func
C.procedure
D.def
回答正确
D
正确答案
D
+ 2.0 分
28 .
关于函数参数传递中，形参与实参的描述错误的是（ ）。
A.python实行安值传递参数。值传递指调用函数时将常量或变量的值（实参） 传递给函数的参数（形参）
B.实参与形参存储在各自的内存空间中，是两个不相关的独立变量
C.在参数内部改变形参的值，实参的值一般是不会改变的。
D.实参与形参的名字必须相同
回答正确
D
正确答案
D
+ 2.0 分
29 .
（ ）模块是python标准库中最常用的模块之一。通过它可以获取命令行参数，从而实现从程序外部向程序内部传递参数的功能，也可以获取程序路径和当前系统平台等信息。。
A.sys
B.platform
C.math
D.time
回答正确
A
正确答案
A
+ 2.0 分
30 .
（ ）表达式是一种匿名函数，是从数学里的λ得名，
A.lambda
B.map
C.filter
D.zip
回答正确
A
正确答案
A
+ 2.0 分
31 .
( )函数用于将指定序列中的所有元素作为参数调用指定函数，并将结果构成一个新的序列返回
A.lambda
B.map
C.filter
D.zip
回答正确
B
正确答案
B
+ 2.0 分
32 .
（ ）函数以一系列列表作为参数，将列表中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
A.lambda
B.map
C.filter
D.zip
回答正确
D
正确答案
D
+ 2.0 分
33 .
（ ）函数是指直接或间接调用函数本身的函数
A.递归
B.闭包
C.lambda
D.匿名
回答正确
A
正确答案
A
+ 1.0 分
34 . 单选题 简单 1分
使用（）函数接收用输入的数据
A.accept （）
B.input （）
C.readline（）
D.login（）
回答正确
B
正确答案
B
+ 0.0 分
35 . 单选题 简单 1分
关于函数的下列说法不正确的是：
A.函数可以没有参数
B.函数可以有多个返回值
C.函数可以没有return语句
D.函数都有返回值
回答错误
D
正确答案
B
+ 0.0 分
36 . 单选题 简单 1分
对于函数ask，以下调用错误的是哪一项？ 1. def ask(prompt = "Do you like Python? ", hint = "yes or no"): 2. while True: 3. answer = raw_input(prompt) 4. if answer.lower() in ('y', 'yes'): 5. print "Thank you" 6. return True 7. if answer.lower() in ('n', 'no'): 8. print "Why not " 9. return False 10. else: 11. print hint
A.answer.lower() 是调用了string自带函数lower()，将输入转换为小写字母。
B.调用函数ask()，在交互页面输入N，则会继续打印yes or no提示你继续输入。
C.调用函数ask()，在交互页面输入x，则会打印yes or no，如果继续输入y，则会打印Thank you并退出ask()函数的执行同时返回值True。
D.函数调用ask("Do you like Python? ")与ask()效果一致
回答错误
C
正确答案
B
+ 0.0 分
37 . 单选题 简单 1分
在Python中，以下关于函数的描述错误的是哪一项？
A.在Python中，关键字参数是让调用者通过使用参数名区分参数，在使用时不允许改变参数列表中的参数顺序。
B.在Python中，默认参数的值可以修改。
C.在Python中，引入了函数式编程的思想，函数本身亦为对象。
D.在Python中，函数的return语句可以以元组tuple的方式返回多个值。
回答错误
B
正确答案
A
+ 1.0 分
38 . 单选题 简单 1分
（ ）函数是指直接或间接调用函数本身的函数。
A.匿名
B.闭包
C.lambda
D.递归
回答正确
D
正确答案
D
+ 1.0 分
39 . 单选题 简单 1分
在print函数的输出字符串中可以将（ ）作为参数，代表后面指定要输出的字符串。
A.%d
B.%c
C.%t
D.%s
回答正确
D
正确答案
D
+ 1.0 分
40 . 简答题 困难 1分
编写一个函数判断一个数是否为素数，并通过调用该函数求出所有三位数的素数。
回答正确
def is_prime(num):
if num < 2:
return False
for i in range(2, int(num ** 0.5) + 1):
if num % i == 0:
return False
return True
def find_prime_numbers():
prime_numbers = []
for num in range(100, 1000):
if is_prime(num):
prime_numbers.append(num)
return prime_numbers
result = find_prime_numbers()
print(result)
正确答案
import math
def IsPrime(Num):
if Num ==1:
return False
for i in range(2,int(math.sqrt(Num))+1):
if Num%i==0:
return False
return True
oList = []
for i in range(100,999+1):
if IsPrime(i)==True:
oList.append(i)
print(oList)
+ 1.0 分
41 . 简答题 困难 1分
编写一个函数，求满足以下条件的最大的n值： 12+22+32+42+…+n2<1000
回答正确
def find_max_n():
sum = 0
n = 1
while sum + n ** 2 < 1000:
sum += n ** 2
n += 1
return n - 1
result = find_max_n()
print(result)
正确答案
（答案13） 非递归实现 def s(): sum=0 n=0 while sum<1000: n=n+1 sum=sum+n*n return n-1 print(s()) 递归实现： def s(sum,n): if sum>=1000: return n-1 else: n=n+1 sum=sum+n*n return s(sum,n) sum=0 n=0 print(s(sum,n)) 验证： sum=0 for i in range(1,15): sum=sum+i*i print(i,sum) 1 1 2 5 3 14 4 30 5 55 6 91 7 140 8 204 9 285 10 385 11 506 12 650 13 819 14 1015
+ 1.0 分
42 . 简答题 困难 1分
反序输出输入的5个字符。
回答正确
def reverse_string():
input_string = input("请输入5个字符：")
reversed_string = input_string[::-1]
print("反序输出结果：", reversed_string)
reverse_string()
正确答案
#对于str类型，python并没有reverse函数。然而，通过反向步进切片，我们可以高效地反转一串字符串。 def revser(s): return s[::-1] print(revser("abcde"))
+ 1.0 分
43 . 简答题 困难 1分
编写一递归函数将所输入的5个字符按相反的顺序排列出来。（递归）
回答正确
def reverse_string_recursive(string, length):
if length == 0:
return ""
else:
return string[length-1] + reverse_string_recursive(string, length-1)
def reverse_input_string():
input_string = input("请输入5个字符：")
reversed_string = reverse_string_recursive(input_string, len(input_string))
print("反序输出结果：", reversed_string)
reverse_input_string()
正确答案
def shuru(n):
if n==0:
return
c=input() #仅输入1个字符
shuru(n-1)
print(c)
shuru(5)
+ 1.0 分
44 . 简答题 困难 1分
编写一个函数multi()，参数个数不限，返回所有参数的乘积。
回答正确
def multi(*args):
result = 1
for num in args:
result *= num
return result
正确答案
def multi(*num):
sum=1
for i in num :
sum=sum*i
return sum
print(multi(2,3,4))
+ 1.0 分
45 . 简答题 困难 1分
编写一个函数，功能是求两个正整数m和n的最大公约数。
回答正确
def gcd(m, n):
if m < n:
m, n = n, m # 交换m和n，使m >= n
while n != 0: # 辗转相除法
rem = m % n
m = n
n = rem
return m
正确答案
def gcd(m, n):
if m < n:
m, n = n, m
while n != 0:
temp = m % n
m = n
n = temp
return m
print(gcd(24,36))
+ 1.0 分
46 . 简答题 困难 1分
求一元二次方程ax2+bx+c=0的根，用3个函数分别求当b2-4ac大于0，等于0和小于0时的根，并输出结果。要求从主函数输入a,b,c的值。
回答正确
import math
def get_root1(a, b, c):
"""当b^2-4ac大于0时，计算并返回两个实数根"""
delta = b**2 - 4*a*c
x1 = (-b + math.sqrt(delta)) / (2*a)
x2 = (-b - math.sqrt(delta)) / (2*a)
return x1, x2
def get_root2(a, b, c):
"""当b^2-4ac等于0时，计算并返回唯一一个实数根"""
x = -b / (2*a)
return x
def get_root3(a, b, c):
"""当b^2-4ac小于0时，提示无实数根"""
print("对不起，方程无实数根。")
# 主函数
a = float(input("请输入一元二次方程中的系数a："))
b = float(input("请输入一元二次方程中的系数b："))
c = float(input("请输入一元二次方程中的常数项c："))
if b**2 - 4*a*c > 0:
root1, root2 = get_root1(a, b, c)
print("方程的两个实数根分别为：", root1, root2)
elif b**2 - 4*a*c == 0:
root = get_root2(a, b, c)
print("方程的唯一一个实数根为：", root)
else:
get_root3(a, b, c)
正确答案
import math
def m(a,b,c):
delta = b ** 2 - 4 * a *c
root = math.sqrt(delta)
s1 = (-b + root) / (2 * a)
s2 = (-b - root) / (2 * a)
print('实根为:', s1, s2)
def n(a,b,c):
delta = (b ** 2 - 4 * a *c)*(-1)
root = complex(0,math.sqrt(delta))
s1 = (-b + root) / (2 * a)
s2 = (-b - root) / (2 * a)
print('虚根为', s1, s2)
+ 1.0 分
47 . 简答题 困难 1分
编写一个函数，求方程ax2+bx+c=0的根，用1个函数分别求当b2-4ac大于0，等于0和小于0时的根，并输出结果。要求从主函数输入a,b,c的值。
回答正确
import math
def solve_quadratic_equation(a, b, c):
discriminant = b ** 2 - 4 * a * c
if discriminant > 0:
root_1 = (-b + math.sqrt(discriminant)) / (2 * a)
root_2 = (-b - math.sqrt(discriminant)) / (2 * a)
return root_1, root_2
elif discriminant == 0:
root = -b / (2 * a)
return root
else:
return "No real roots available."
a = float(input("请输入a的值："))
b = float(input("请输入b的值："))
c = float(input("请输入c的值："))
roots = solve_quadratic_equation(a, b, c)
print("方程的根：", roots)
正确答案
import math
def solve(a,b,c):
if a == 0:
return –c/b;
else:
if b*b-4*a*c < 0:
x1=complex((-b)/(2*a),math.sqrt(abs((b*b-4*a*c))))
x2=complex((-b)/(2*a),-math.sqrt(abs((b*b-4*a*c))))
elif b*b-4*a*c == 0:
x1=(-b)/(2*a)
x2=(-b)/(2*a)
elif b*b-4*a*c > 0:
x1=(-b+math.sqrt(b*b-4*a*c))/(2*a)
x2=(-b-math.sqrt(b*b-4*a*c))/(2*a)
return (x1,x2)
x = int(input("请输入a:"))
y = int(input("请输入b:"))
z = int(input("请输入c:"))
print("求解：",solve(x,y,z))
+ 1.0 分
48 . 简答题 困难 1分
编写一个函数，调用该函数能够打印一个由指定字符组成的n行金字塔。其中，指定打印的字符和行数n分别由两个形参表示。
回答正确
def print_pyramid(char, n):
for i in range(1, n+1):
print(' '*(n-i), end='')
print(char*(2*i-1))
print_pyramid('*', 5)
正确答案
def jinzita(n):
for i in range(1,n): #[1,2,3,4,...n-1]
print(''*(20-(i-1))+'*'*(2*i-1))
#主程序
a= int (input("输入打印行数："))
jinzita(a+1)
+ 1.0 分
49 . 简答题 困难 1分
编写一个判断n是完数的函数，
回答正确
def is_perfect_number(n):
if n <= 0:
return False
factors = []
for i in range(1, n):
if n % i == 0:
factors.append(i)
if sum(factors) == n:
return True
else:
return False
number = int(input("请输入一个正整数："))
result = is_perfect_number(number)
if result:
print(number, "是完数")
else:
print(number, "不是完数")
正确答案
def judge(n):
sum=0
for i in range(1,n):
if n%i == 0:
sum += i
if sum == n:
print(n,"是完数！")
else:
print(n,"不是完数！")
+ 1.0 分
50 . 简答题 困难 1分
十进制转二进制
回答正确
def decimal_to_binary(decimal):
if decimal == 0:
return '0'
binary = ''
while decimal > 0:
binary = str(decimal % 2) + binary
decimal = decimal // 2
return binary
number = int(input("请输入一个十进制数："))
result = decimal_to_binary(number)
print("转换后的二进制数为:", result)
正确答案
def binary(n):
list = []
while n//2 != 0:
list.append(n%2)
n = n // 2
if n//2 == 0:
list.append(n%2)
break
list.reverse()
for t in list:
print(t,end='')
print()
+ 1.0 分
51 . 简答题 中等 1分
实现回文字符串
回答正确
def is_palindrome(string):
string = string.lower()
string = "".join(filter(str.isalnum, string))
return string == string[::-1]
string = input("请输入一个字符串：")
if is_palindrome(string):
print("是回文字符串")
else:
print("不是回文字符串")
正确答案
def huiwen(e):
x=0
y=len(e)-1
while x<y:
if(e[x] != e[y]):
break
x+=1
y-=1
if(x<y):
flag=0
else:
flag=1
return flag
e=input("请输入一串字符\n")
if(huiwen(e)):
print("这是回文字符串\n")
else:
print("这不是回文字符串\n")
+ 1.0 分
52 . 简答题 中等 1分
统计字符串中有多少个单词
回答正确
统计字符串中有多少个单词
正确答案
def geshu(e):
a=e.split(' ')
return len(a)
e=input("请输入一句话\n")
print("这句话中有%d个单词"%geshu(e))
+ 1.0 分
53 . 简答题 困难 1分
编写一个函数判断一个数是否为素数，并通过调用该函数求出所有三位数的素数。
回答正确
def is_prime(number):
if number < 2:
return False
for i in range(2, int(number**0.5) + 1):
if number % i == 0:
return False
return True
primes = []
for number in range(100, 1000):
if is_prime(number):
primes.append(number)
print("所有三位数的素数：", primes)
正确答案
import math
def IsPrime(Num):
if Num ==1:
return False
for i in range(2,int(math.sqrt(Num))+1):
if Num%i==0:
return False
return True
oList = []
for i in range(100,999+1):
if IsPrime(i)==True:
oList.append(i)
print(oList)
+ 1.0 分
54 . 简答题 中等 1分
编写一个函数，将华氏温度转换为摄氏温度。公式为C=(F-32)×5/9。
回答正确
def fahrenheit_to_celsius(fahrenheit):
celsius = (fahrenheit - 32) * 5 / 9
return celsius
# 调用函数
fahrenheit = float(input("请输入华氏温度："))
celsius = fahrenheit_to_celsius(fahrenheit)
print("摄氏温度为:", celsius)
正确答案
def m(a): return (a-32)*5/9 a=int(input('输入华氏温度')) c=m(a) print(c)
+ 1.0 分
55 . 简答题 中等 1分
编写一个函数判断一个数是否为素数，并通过调用该函数求出所有三位数的素数。
回答正确
def is_prime(number):
if number < 2:
return False
for i in range(2, int(number ** 0.5) + 1):
if number % i == 0:
return False
return True
# 求所有三位数素数
primes = []
for num in range(100, 1000):
if is_prime(num):
primes.append(num)
# 输出结果
print("所有三位数素数为:")
print(primes)
正确答案
import math def IsPrime(Num): if Num ==1: return False for i in range(2,int(math.sqrt(Num))+1): if Num%i==0: return False return True oList = [] for i in range(100,999+1): if IsPrime(i)==True: oList.append(i) print(oList)
+ 1.0 分
56 . 简答题 中等 1分
编写一个函数，求满足以下条件的最大的n值：（答案13） 12+22+32+42+…+n2<1000
回答正确
def find_max_n():
total = 0
n = 1
while total + n ** 2 < 1000:
total += n ** 2
n += 1
return n - 1
# 调用函数
max_n = find_max_n()
print("满足条件的最大n值为:", max_n)
正确答案
非递归实现 def s(): sum=0 n=0 while sum<1000: n=n+1 sum=sum+n*n return n-1 print(s()) 递归实现： def s(sum,n): if sum>=1000: return n-1 else: n=n+1 sum=sum+n*n return s(sum,n) sum=0 n=0 print(s(sum,n)) 验证： sum=0 for i in range(1,15): sum=sum+i*i print(i,sum) 1 1 2 5 3 14 4 30 5 55 6 91 7 140 8 204 9 285 10 385 11 506 12 650 13 819 14 1015
+ 1.0 分
57 . 简答题 中等 1分
反序输出输入的5个字符。
回答正确
def reverse_output():
input_chars = input("请输入5个字符：")
if len(input_chars) != 5:
print("输入的字符数量不正确！")
return
reversed_chars = input_chars[::-1]
print("反序输出的字符为:", reversed_chars)
# 调用函数
reverse_output()
正确答案
#对于str类型，python并没有reverse函数。然而，通过反向步进切片，我们可以高效地反转一串字符串。 def revser(s): return s[::-1] print(revser("abcde"))
+ 1.0 分
58 . 简答题 中等 1分
编写一递归函数将所输入的5个字符按相反的顺序排列出来。（递归）
回答正确
def reverse_output_recursive(chars, index):
if index < 0:
return
print(chars[index], end="")
reverse_output_recursive(chars, index - 1)
# 主函数
def main():
input_chars = input("请输入5个字符：")
if len(input_chars) != 5:
print("输入的字符数量不正确！")
return
reverse_output_recursive(input_chars, len(input_chars) - 1)
print()
# 调用主函数
main()
正确答案
def shuru(n): if n==0: return c=input() #仅输入1个字符 shuru(n-1) print(c) shuru(5)
+ 1.0 分
59 . 简答题 中等 1分
编写一个函数multi()，参数个数不限，返回所有参数的乘积。
回答正确
def multi(*args):
result = 1
for num in args:
result *= num
return result
正确答案
def multi(*num): sum=1 for i in num : sum=sum*i return sum print(multi(2,3,4))
+ 1.0 分
60 . 简答题 中等 1分
编写一个函数，功能是求两个正整数m和n的最大公约数。
回答正确
def gcd(m, n):
if n == 0:
return m
else:
return gcd(n, m % n)
正确答案
def gcd(m, n): if m < n: m, n = n, m while n != 0: temp = m % n m = n n = temp return m print(gcd(24,36))
+ 1.0 分
61 . 简答题 中等 1分
求一元二次方程ax2+bx+c=0的根，用3个函数分别求当b2-4ac大于0，等于0和小于0时的根，并输出结果。要求从主函数输入a,b,c的值。
回答正确
import math
def find_root1(a, b, c):
delta = b ** 2 - 4 * a * c
if delta < 0:
print("方程无实根！")
return None
else:
x1 = (-b + math.sqrt(delta)) / (2 * a)
x2 = (-b - math.sqrt(delta)) / (2 * a)
return x1, x2
def find_root2(a, b, c):
delta = b ** 2 - 4 * a * c
if delta < 0:
print("方程无实根！")
return None
elif delta == 0:
x = -b / (2 * a)
return x, None
else:
x1 = (-b + math.sqrt(delta)) / (2 * a)
x2 = (-b - math.sqrt(delta)) / (2 * a)
return x1, x2
def find_root3(a, b, c):
delta = b ** 2 - 4 * a * c
if delta < 0:
x1 = (-b + complex(0, math.sqrt(-delta))) / (2 * a)
x2 = (-b - complex(0, math.sqrt(-delta))) / (2 * a)
return x1, x2
else:
print("方程有实根！")
return None
# 主函数
def main():
a, b, c = map(float, input("请输入一元二次方程ax^2+bx+c=0中的a、b、c：").split())
roots1 = find_root1(a, b, c)
roots2 = find_root2(a, b, c)
roots3 = find_root3(a, b, c)
if roots1:
print("当b^2-4ac大于0时，方程的根为：x1={:.2f}，x2={:.2f}".format(roots1[0], roots1[1]))
if roots2[0]:
print("当b^2-4ac等于0时，方程的根为：x={:.2f}".format(roots2[0]))
if roots3:
print("当b^2-4ac小于0时，方程的根为：x1={:.2f}，x2={:.2f}".format(roots3[0], roots3[1]))
# 调用主函数
main()
正确答案
import math def m(a,b,c): delta = b ** 2 - 4 * a *c root = math.sqrt(delta) s1 = (-b + root) / (2 * a) s2 = (-b - root) / (2 * a) print('实根为:', s1, s2) def n(a,b,c): delta = (b ** 2 - 4 * a *c)*(-1) root = complex(0,math.sqrt(delta)) s1 = (-b + root) / (2 * a) s2 = (-b - root) / (2 * a) print('虚根为', s1, s2) a = float(input('输入 a :')) b = float(input('输入 b :')) c = float(input('输入 c :')) if a == 0: s = -c/b print('实根为:', s) else: delta = b ** 2 - 4 * a *c if delta == 0: s = -b/(2 * a) print('实根为:', s) elif delta < 0: n(a,b,c) else: m(a,b,c)
+ 1.0 分
62 . 简答题 中等 1分
编写一个函数，求方程ax2+bx+c=0的根，用1个函数分别求当b2-4ac大于0，等于0和小于0时的根，并输出结果。要求从主函数输入a,b,c的值。
回答正确
import math
def solve_equation(a, b, c):
discriminant = b**2 - 4*a*c
if discriminant > 0:
root1 = (-b + math.sqrt(discriminant)) / (2 * a)
root2 = (-b - math.sqrt(discriminant)) / (2 * a)
return root1, root2
elif discriminant == 0:
root = -b / (2 * a)
return root
else:
return "无实数根"
# 主函数
def main():
a = float(input("请输入a的值："))
b = float(input("请输入b的值："))
c = float(input("请输入c的值："))
roots = solve_equation(a, b, c)
if isinstance(roots, tuple):
print("方程的根为：", roots[0], "和", roots[1])
elif isinstance(roots, float):
print("方程的根为：", roots)
else:
print(roots)
# 调用主函数
main()
正确答案
import math def solve(a,b,c): if a == 0: return –c/b; else: if b*b-4*a*c < 0: x1=complex((-b)/(2*a),math.sqrt(abs((b*b-4*a*c)))) x2=complex((-b)/(2*a),-math.sqrt(abs((b*b-4*a*c)))) elif b*b-4*a*c == 0: x1=(-b)/(2*a) x2=(-b)/(2*a) elif b*b-4*a*c > 0: x1=(-b+math.sqrt(b*b-4*a*c))/(2*a) x2=(-b-math.sqrt(b*b-4*a*c))/(2*a) return (x1,x2) x = int(input("请输入a:")) y = int(input("请输入b:")) z = int(input("请输入c:")) print("求解：",solve(x,y,z))
+ 1.0 分
63 . 简答题 中等 1分
编写一个函数，调用该函数能够打印一个由指定字符组成的n行金字塔。其中，指定打印的字符和行数n分别由两个形参表示。
回答正确
def print_pyramid(char, n):
for i in range(n):
print(" " * (n - i - 1) + char * (2 * i + 1))
# 调用函数打印金字塔
print_pyramid("*", 5)
正确答案
def jinzita(n): for i in range(1,n): #[1,2,3,4,...n-1] print(' '*(20-(i-1))+'*'*(2*i-1)) #主程序 a= int (input("输入打印行数：")) jinzita(a+1)
+ 1.0 分
64 . 简答题 中等 1分
判断完数
回答正确
def is_perfect_number(number):
factors = []
for i in range(1, number):
if number % i == 0:
factors.append(i)
return sum(factors) == number
# 调用函数判断数字是否为完数
print(is_perfect_number(6))
正确答案
def judge(n): sum=0 for i in range(1,n): if n%i == 0: sum += i if sum == n: print(n,"是完数！") else: print(n,"不是完数！") if __name__ == "__main__": n = int(input("请输入一个数：")) judge(n)
+ 1.0 分
65 . 简答题 中等 1分
十进制转二进制
回答正确
def decimal_to_binary(n):
binary = ""
while n > 0:
binary = str(n % 2) + binary
n //= 2
return binary
# 调用函数将十进制数转换为二进制字符串
n = 123
binary = decimal_to_binary(n)
print("十进制数", n, "转换为二进制数为", binary)
正确答案
def binary(n): list = [] while n//2 != 0: list.append(n%2) n = n // 2 if n//2 == 0: list.append(n%2) break list.reverse() for t in list: print(t,end='') print() if __name__ == "__main__": n = int(input("请输入一个数：")) binary(n)
+ 1.0 分
66 . 简答题 中等 1分
回文字符串
回答正确
def generate_palindrome(string):
return string + string[::-1]
# 调用函数生成回文字符串
print(generate_palindrome("hello"))
正确答案
def huiwen(e): x=0 y=len(e)-1 while x
+ 1.0 分
67 . 简答题 中等 1分
字符串中有多少个单词
回答正确
def count_words(string):
words = string.split()
return len(words)
# 调用函数计算字符串中的单词数量
text = "This is a sample sentence."
word_count = count_words(text)
print("字符串中的单词数量为:", word_count)
正确答案
def geshu(e): a=e.split(' ') return len(a) e=input("请输入一句话\n") print("这句话中有%d个单词"%geshu(e))
平时作业4-第5章
总分：100分
得分：74.5分
+ 2.0 分
1 .
调用open函数可以打开指定文件，在open（）函数中访问模式参数使用（ ）表示只读。
A.a
B.w+
C.r
D.w
回答正确
C
正确答案
C
+ 2.0 分
2 .
下列哪项不是Python中对文件的读取操作：
A.read
B.readall
C.readlines
D.readline
回答正确
B
正确答案
B
+ 2.0 分
3 .
在读写文件之前，必须通过以下哪个方法创建文件对象：
A.create
B.folder
C.File
D.open
回答正确
D
正确答案
D
+ 0.0 分
4 .
以下不能创建一个字典的语句是：
A.dict = {}
B.dict = {(4,5,6):'dictionary'}
C.dict= {4：6}
D.dict = {[4,5,6]:'dictionary'}
回答错误
C
正确答案
D
+ 2.0 分
5 .
以下描述中错误的是哪一项？
A.字符串的格式化，'{:.2f}'.format(math.pi) 与 '%.2f' % math.pi 在运算结果上相同。
B.Python中的同一种序列互相之间可以进行比较，按照字典序进行排序，例如 (1, 2, 3, 4) < (1, 2, 4) 的运算结果是True。
C.打开一个文本文件，f = open('test.txt', 'r+'); 则 f.seek(5) 表示在打开的文件里寻找数字5。
D.打开一个文本文件，在对其进行读取，f = open('test.txt', 'r+'); f.read() ;read函数内不带参数是读取整个文本文件内容并返回
回答正确
C
正确答案
C
+ 0.0 分
6 .
以下不能作为字典的key的是哪一个选项？
A.num
B.listA =
C.123
D.tupleA = ('sum')
回答错误
B
正确答案
C
+ 1.0 分
7 . 简答题 困难 2分
编写程序，打开任意的文本文件，读出其中内容，判断该文件中某些给定关键字如“中国”出现的次数。
回答正确
def count_keyword_occurrences(file_path, keyword):
try:
with open(file_path, 'r', encoding='utf-8') as file:
content = file.read()
count = content.count(keyword)
return count
except FileNotFoundError:
print("文件不存在")
except Exception as e:
print("发生错误:", str(e))
file_path = input("请输入文件路径：")
keyword = input("请输入关键字：")
occurrences = count_keyword_occurrences(file_path, keyword)
print("关键字 '{}' 出现的次数为：{}".format(keyword, occurrences))
正确答案
n=0
#hellofile=open("d:\\152\\612.txt")
filename = input("please input filename")
hellofile=open("d:\\152\\"+filename)
filecontent=hellofile.readlines()
hellofile.close()
print(filecontent) #['中国\n', '美国\n', '中国人民\n', '日本\n', '中国人']
for s in filecontent:
n=n+s.count("中国")
print(n)
+ 1.0 分
8 . 简答题 困难 2分
编写程序，打开任意的文本文件，在指定的位置产生一个相同文件的副本，即实现文件的拷贝功能。
回答正确
def copy_file(file_path, new_file_path):
try:
with open(file_path, 'r', encoding='utf-8') as file:
content = file.read()
with open(new_file_path, 'w', encoding='utf-8') as new_file:
new_file.write(content)
print("文件拷贝成功")
except FileNotFoundError:
print("文件不存在")
except Exception as e:
print("发生错误:", str(e))
# 输入文件路径和新文件路径
file_path = input("请输入要拷贝的文件路径：")
new_file_path = input("请输入新文件的路径：")
# 调用函数进行文件拷贝
copy_file(file_path, new_file_path)
正确答案
#方法一：
def copy_file(oldfile,newfile):
oldFile=open(oldfile,"r")
newFile=open(newfile,"w")
while True:
filecontent=oldFile.read(50)
if filecontent=="":
break
newFile.write(filecontent)
oldFile.close()
newFile.close()
return
#主程序
copy_file("d:\\152\\612.txt","d:\\152\\615.txt")
#方法二：
import shutil
shutil.copyfile("d:\\152\\612.txt","d:\\152\\615.txt")
#方法三：
def main():
# 用户输入文件名
f1 = input("Enter a soucefile:").strip()
f2 = input("Enter a soucefile:").strip()
# 打开文件
infile = open(f1,"r")
outfile = open(f2,"w")
# 拷贝数据
countLines = countChars = 0
for line in infile:
countLines += 1
countChars += len(line)
outfile.write(line)
print(countLines,"linesand",countChars,"chars copied")
infile.close()
outfile.close()
main()
【运行结果】
Enter a soucefile:s.txt
Enter a soucefile:q.txt
46 lines and 1500chars copied
+ 1.0 分
9 . 简答题 中等 2分
用Windows“记事本”创建一个文本文件，其中每行包含一段英文。试读出文件的全部内容，并判断： （1）该文本文件共有多少行？ （2）文件中以大写字母P开头的有多少行？ （3）一行中包含字符最多的和包含字符最少的分别在第几行？
回答正确
def count_lines(file_path):
try:
with open(file_path, 'r', encoding='utf-8') as file:
lines = file.readlines()
return len(lines)
except FileNotFoundError:
print("文件不存在")
except Exception as e:
print("发生错误:", str(e))
def count_start_with_P(file_path):
try:
with open(file_path, 'r', encoding='utf-8') as file:
lines = file.readlines()
count = 0
for line in lines:
if line.startswith('P'):
count += 1
return count
except FileNotFoundError:
print("文件不存在")
except Exception as e:
print("发生错误:", str(e))
def find_max_min_length_line(file_path):
try:
with open(file_path, 'r', encoding='utf-8') as file:
lines = file.readlines()
max_length_line = ''
max_length = 0
min_length_line = ''
min_length = float('inf')
for index, line in enumerate(lines):
length = len(line.strip())
if length > max_length:
max_length = length
max_length_line = line
if length < min_length:
min_length = length
min_length_line = line
return (max_length_line, index+1), (min_length_line, index+1)
except FileNotFoundError:
print("文件不存在")
except Exception as e:
print("发生错误:", str(e))
# 输入文件路径
file_path = input("请输入文件路径：")
# 统计行数
line_count = count_lines(file_path)
print("该文本文件共有 {} 行".format(line_count))
# 统计以大写字母P开头的行数
p_count = count_start_with_P(file_path)
print("文件中以大写字母P开头的行数为：{}".format(p_count))
# 找到包含字符最多和最少的行
max_length_line, min_length_line = find_max_min_length_line(file_path)
print("包含字符最多的行是第{}行，内容是：{}".format(max_length_line[1], max_length_line[0]))
print("包含字符最少的行是第{}行，内容是：{}".format(min_length_line[1], min_length_line[0]))
正确答案
（1）
file1=open("d:\\152\\test.txt")
filecontent=file1.readlines() #列表
file1.close()
a=len(filecontent)
print(a)
（2）
>>> s="pig"
>>> s.startswith('p')
True
>>> s="hello"
>>> s.startswith('p')
False
file1=open("d:\\test.txt")
filecontent=file1.readlines() #列表
print(filecontent)
file1.close()
a=len(filecontent)
n=0
for s in filecontent:
if s.startswith('P')==True:
print(s)
n+=1
print("以大写字母P开头的有",n,"行")
（3）
file1=open("d:\\test.txt")
filecontent=file1.readlines() #列表
print(filecontent)
file1.close()
a=len(filecontent)
n=1
maxnum=0
for s in filecontent:
k=len(s)
if k>maxnum:
maxnum=k
pos=n
n+=1
print("一行中包含字符最多的是",pos,"行")
print("一行字符最多的是",maxnum)
+ 1.0 分
10 . 简答题 中等 2分
编写程序，打开任意的文本文件，读出其中内容，判断该文件中某些给定关键字如“中国”出现的次数。
回答正确
def count_keyword_occurrences(file_path, keyword):
try:
with open(file_path, 'r', encoding='utf-8') as file:
content = file.read()
count = content.count(keyword)
return count
except FileNotFoundError:
print("文件不存在")
except Exception as e:
print("发生错误:", str(e))
file_path = input("请输入文件路径：")
keyword = input("请输入关键字：")
occurrences = count_keyword_occurrences(file_path, keyword)
print("关键字 '{}' 出现的次数为：{}".format(keyword, occurrences))
正确答案
n=0 #hellofile=open("d:\\152\\612.txt") filename = input("please input filename") hellofile=open("d:\\152\\"+filename) filecontent=hellofile.readlines() hellofile.close() print(filecontent) #['中国\n', '美国\n', '中国人民\n', '日本\n', '中国人'] for s in filecontent: n=n+s.count("中国") print(n)
+ 1.0 分
11 . 简答题 中等 2分
编写程序，打开任意的文本文件，在指定的位置产生一个相同文件的副本，即实现文件的拷贝功能。
回答正确
def copy_file(file_path, new_file_path):
try:
with open(file_path, 'r', encoding='utf-8') as file:
content = file.read()
with open(new_file_path, 'w', encoding='utf-8') as new_file:
new_file.write(content)
print("文件拷贝成功")
except FileNotFoundError:
print("文件不存在")
except Exception as e:
print("发生错误:", str(e))
# 输入文件路径和新文件路径
file_path = input("请输入要拷贝的文件路径：")
new_file_path = input("请输入新文件的路径：")
# 调用函数进行文件拷贝
copy_file(file_path, new_file_path)
正确答案
方法一： def copy_file(oldfile,newfile): oldFile=open(oldfile,"r") newFile=open(newfile,"w") while True: filecontent=oldFile.read(50) if filecontent=="": break newFile.write(filecontent) oldFile.close() newFile.close() return #主程序 copy_file("d:\\152\\612.txt","d:\\152\\615.txt") 方法二： import shutil shutil.copyfile("d:\\152\\612.txt","d:\\152\\615.txt") 方法三： def main(): # 用户输入文件名 f1 = input("Enter a soucefile:").strip() f2 = input("Enter a soucefile:").strip() # 打开文件 infile = open(f1,"r") outfile = open(f2,"w") # 拷贝数据 countLines = countChars = 0 for line in infile: countLines += 1 countChars += len(line) outfile.write(line) print(countLines,"lines and",countChars,"chars copied") infile.close() outfile.close() main() 【运行结果】 Enter a soucefile:s.txt Enter a soucefile:q.txt 46 lines and 1500chars copied
+ 1.0 分
12 . 简答题 中等 2分
用Windows“记事本”创建一个文本文件，其中每行包含一段英文。试读出文件的全部内容，并判断： （1）该文本文件共有多少行？ （2）文件中以大写字母P开头的有多少行？ （3）一行中包含字符最多的和包含字符最少的分别在第几行？
回答正确
def count_lines(file_path):
try:
with open(file_path, 'r', encoding='utf-8') as file:
lines = file.readlines()
return len(lines)
except FileNotFoundError:
print("文件不存在")
except Exception as e:
print("发生错误:", str(e))
def count_start_with_P(file_path):
try:
with open(file_path, 'r', encoding='utf-8') as file:
lines = file.readlines()
count = 0
for line in lines:
if line.startswith('P'):
count += 1
return count
except FileNotFoundError:
print("文件不存在")
except Exception as e:
print("发生错误:", str(e))
def find_max_min_length_line(file_path):
try:
with open(file_path, 'r', encoding='utf-8') as file:
lines = file.readlines()
max_length_line = ''
max_length = 0
min_length_line = ''
min_length = float('inf')
for index, line in enumerate(lines):
length = len(line.strip())
if length > max_length:
max_length = length
max_length_line = line
if length < min_length:
min_length = length
min_length_line = line
return (max_length_line, index+1), (min_length_line, index+1)
except FileNotFoundError:
print("文件不存在")
except Exception as e:
print("发生错误:", str(e))
# 输入文件路径
file_path = input("请输入文件路径：")
# 统计行数
line_count = count_lines(file_path)
print("该文本文件共有 {} 行".format(line_count))
# 统计以大写字母P开头的行数
p_count = count_start_with_P(file_path)
print("文件中以大写字母P开头的行数为：{}".format(p_count))
# 找到包含字符最多和最少的行
max_length_line, min_length_line = find_max_min_length_line(file_path)
print("包含字符最多的行是第{}行，内容是：{}".format(max_length_line[1], max_length_line[0]))
print("包含字符最少的行是第{}行，内容是：{}".format(min_length_line[1], min_length_line[0]))
正确答案
（1） file1=open("d:\\152\\test.txt") filecontent=file1.readlines() #列表 file1.close() a=len(filecontent) print(a) （2） >>> s="pig" >>> s.startswith('p') True >>> s="hello" >>> s.startswith('p') False file1=open("d:\\test.txt") filecontent=file1.readlines() #列表 print(filecontent) file1.close() a=len(filecontent) n=0 for s in filecontent: if s.startswith('P')==True: print(s) n+=1 print("以大写字母P开头的有",n,"行") （3） file1=open("d:\\test.txt") filecontent=file1.readlines() #列表 print(filecontent) file1.close() a=len(filecontent) n=1 maxnum=0 for s in filecontent: k=len(s) if k>maxnum: maxnum=k pos=n n+=1 print("一行中包含字符最多的是",pos,"行") print("一行字符最多的是",maxnum)
+ 2.0 分
13 .
以下关于Python文件的描述，错误的选项是_________。
A.二进制文件和文本文件的操作步骤都是“打开-操作-关闭”
B.在open()打开文件之后，文件的内容并没有在内存中
C.open()只能打开一个已经存在的文件
D.在文件读写之后，需要调用close()才能确保文件被保存在磁盘中
回答正确
C
正确答案
C
+ 2.0 分
14 .
以下关于Python中CSV文件的描述，错误的选项是_________。
A.CSV文件可用于不同工具间进行数据交换
B.CSV文件格式是一种通用的、相对简单的文件格式，应用于程序之间转移表格数据
C.CSV文件通过多种编码表示字符
D.CSV文件的每一行是一维数据，可以使用Python中的列表数据类型表示
回答正确
C
正确答案
C
+ 2.0 分
15 .
以下关于Python文件‘+’打开模式的描述，正确的选项是_________。
A.追加写模式
B.与r/w/a/x一同使用，在原功能基础上增加同时读写功能
C.只读模式
D.覆盖写模式
回答正确
B
正确答案
B
+ 2.0 分
16 .
以下关于Python文件的描述，错误的选项是_________。
A.readlines()函数读入文件内容后返回一个列表，元素划分依据是文本文件中的换行符
B.read()函数一次性读入文本文件的全部内容后，返回一个字符串
C.readline()函数读入文本文件的一行，返回一个字符串
D.二进制文件和文本文件都是可以用文本编辑器编辑的文件
回答正确
D
正确答案
D
+ 2.0 分
17 .
以下关于Python文件的描述，错误的选项是_________。
A.open()函数的参数处理模式‘b’表示以二进制数据处理文件
B.open()函数的参数处理模式‘+’表示可以对文件进行读和写操作
C.readline()函数表示读取文件的下一行，返回一个字符串
D.open()函数的参数处理模式‘a’表示以追加方式打开文件，删除已有内容
回答正确
D
正确答案
D
+ 2.0 分
18 .
Python文件读取方法read(size)的含义是_________。
A.从头到尾读取文件所有内容
B.从文件中读取一行数据
C.从文件中读取多行数据
D.从文件中读取指定size大小的数据，如果size为负数或者空，则读取到文件结束
回答正确
D
正确答案
D
+ 2.0 分
19 . 填空题 简单 2分
Python语句print(1,2,3,4,5,sep='-',end='!')的输出结果是____________。
回答正确
1-2-3-4-5!
正确答案
1-2-3-4-5!
print()函数用于打印一行内容，即将多个以分隔符（sep，默认为空格）分隔的值（value，...，以逗号分隔的值），写入到指定文件流（file，默认为控制台sys.stdout）。参数end指定换行符；flush指定是否强制写入到流
+ 2.0 分
20 . 填空题 简单 2分
Python语句“for i in range(5): print(i, end=' ')”的输出结果是___ ______、_________、_________、_________、_________。
回答正确
无、1、2、3、4
正确答案
0、1、2、3、4
print()函数用于打印一行内容，即将多个以分隔符（sep，默认为空格）分隔的值（value，...，以逗号分隔的值），写入到指定文件流（file，默认为控制台sys.stdout）。参数end指定换行符；flush指定是否强制写入到流。
+ 0.5 分
21 . 填空题 简单 2分
在Python程序中，可以通过列表___________访问命令行参数。___________为Python脚本名，___________为第一个参数名，___________为第二个参数名。
回答正确
sys.argv、sys.argv[0]、sys.argv[1]、sys.argv[2]
正确答案
sys.argv、argv[0]、argv[1]、argv[2]
程序中可以通过列表sys.argv访问命令行参数。argv[0]为Python脚本名，argv[1]为第一个参数，argv[2]为第二个参数，依此类推。
+ 2.0 分
22 . 填空题 简单 2分
Python程序使用___________模块命名的命令行参数。 （注意：英文区分大小写）
回答正确
argparse
正确答案
argparse
argparse模块是用于命名的命令行参数，生成帮助信息的python标准模块。
+ 2.0 分
23 . 填空题 简单 2分
如果在程序运行时，需要提示用户输入密码，则可以使用模块___________，以保证用户输入的密码在控制台中不回显。（注意：英文区分大小写）
回答正确
getpass
正确答案
getpass
如果在程序运行时，需要提示用户输入密码，则可以使用模块getpass，以保证用户输入的密码在控制台中不回显。
+ 2.0 分
24 . 填空题 简单 2分
Python语言使用___________语句实现上下文管理协议。（注意：英文区分大小写）
回答正确
with
正确答案
with
文件对象支持使用with语句，确保打开的文件自动关闭。
+ 2.0 分
25 . 填空题 简单 2分
Python语言中，使用sys模块中的___________、___________和___________，可以查看对应的标准输入、标准输出和标准错误流文件对象。（注意：英文区分大小写）
回答正确
sys.stdin、sys.stdout、sys.stderr
正确答案
sys.stdin、sys.stdout、sys.stderr
（1）使用sys模块的sys.stdin、sys.stdout和sys.stderr，可以查看对应的标准输入、标准输出和标准错误流文件对象。（2）标准输入流文件对象默认对应于控制台键盘。标准输出流文件对象和错误输出流文件对象默认对应于控制台，其区别仅在于后者是非缓冲的。
+ 0.0 分
26 . 填空题 简单 2分
Python可以使用函数____________打开文件。（注意：英文区分大小写）
回答错误
open()
正确答案
open
使用open()函数打开或创建一个文件时，其默认的打开模式为只读文本文件。文本文件用于储存文本字符串，默认编码为Unicode。
+ 1.0 分
27 . 填空题 简单 2分
文件操作可以使用_________方法关闭流，以释放资源。通常采用_________语句，以保证系统自动关闭打开的流。（注意：英文区分大小写）
回答正确
close()、with
正确答案
close、with
写入文件完成后，应该使用close方法关闭流，以释放资源，并把缓冲的数据更新到文件中。
+ 0.0 分
28 . 填空题 简单 2分
打开随机文件后，可以使用实例方法____________进行定位。（注意：英文区分大小写）
回答错误
seek()
正确答案
seek
文件对象支持seek方法，seek通过字节偏移量将读取/写入位置移动到文件中的任意位置，从而实现文件的随机访问。
+ 2.0 分
29 . 填空题 简单 2分
____________模块提供处理用于循环处理输入、输入重定向、管道或一个或多个文本文件的函数和辅助对象。（注意：英文区分大小写）
回答正确
fileinput
正确答案
fileinput
无。
+ 2.0 分
30 . 填空题 简单 2分
可以使用____________模块中提供的函数，实现Python对象的系列化。（注意：英文区分大小写）
回答正确
pickle
正确答案
pickle [或者]cPickle [或者]marshal
对象序列化也称为串行化，将对象转换为数据形式，并转储到磁盘文件或通过网络实现跨平台传输。
+ 1.0 分
31 . 简答题 中等 2分
请编写程序生成随机密码。具体要求如下。 （1）使用random库，采用0x1010作为随机数种子。 （2）密码由26个字母大小写、10个数字字符以及“!、@、#、$、%、^、&、*”等8个特殊符号组成。 （3）每个密码长度固定为10个字符。 （4）程序运行每次产生10个密码，每个密码一行。 （5）每次产生的10个密码首字符不能一样。 （6）程序运行后产生的密码保存在“随机密码.txt”文件中。
回答正确
import random
# 设置随机数种子
random.seed(0x1010)
# 密码可选字符
characters = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*'
# 生成10个密码
passwords = []
for _ in range(10):
while True:
password = random.sample(characters, 9) # 随机选择9个字符
password.insert(0, random.choice(characters[52:])) # 首字符为随机选择的大写字母或特殊符号
password = ''.join(password)
if password[0] != password[1]: # 首字符和第二个字符不能相同
break
passwords.append(password)
# 将密码保存到文件
with open('随机密码.txt', 'w') as file:
for password in passwords:
file.write(password + '\n')
正确答案
import random random.seed(0x1010) s="abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ1234567890! @#$%^&*" ls=[] excludes=" " while len(ls)< 10: pwd=" " for i in range(10): pwd+=s[random.randint(0,len(s)-1)] if pwd[0] in excludes: continue ls.append(pwd) excludes+= pwd[0] fo=open("随机密码.txt","w") fo.write("\n".join(ls)) fo.close()
+ 1.0 分
32 . 简答题 困难 2分
编写程序，实现一个简单的基于字典数据结构的通信录管理系统。系统采用JSON文件来保存数据。通信录设计为字典{name：tel}。程序开始时从addressbook.json文件中读取通信录，然后显示主菜单，具体包括如下功能： （1）显示通讯录清单。如果通信录字典中存在用户信息，则显示通讯录清单，包括姓名和电话号码；如果通信录字典中不存在任何用户信息，则提示“通讯录为空”。 （2）查询联系人。提示用户输入姓名name，在通信录字典中查询该键，如果存在，输出联系人信息；如果不存在，提示是否新建联系人。 （3）插入新的联系人。提示用户输入姓名name，在通信录字典中查询该键，如果存在，提示是否更新联系人信息；如果不存在，提示输入电话号码，并插入字典键-值对。 （4）删除已有联系人。提示用户输入姓名name，在通信录字典中查询该键，如果不存在，输出“联系人不存在”的提示信息；如果存在，从通信录字典中删除键-值对，并输出信息。 （5）退出。保存通信录字典到addressbook.json中，退出循环。
回答正确
import json
import os
# 读取通信录
if os.path.exists('addressbook.json'):
with open('addressbook.json', 'r') as f:
address_book = json.load(f)
else:
address_book = {}
while True:
# 显示主菜单
print("========================================")
print("1. 显示通讯录清单")
print("2. 查询联系人")
print("3. 插入新的联系人")
print("4. 删除已有联系人")
print("5. 退出")
print("========================================")
choice = input("请输入功能序号：")
if choice == '1':
# 显示通讯录清单
if len(address_book) == 0:
print("通讯录为空")
else:
for name, tel in address_book.items():
print(name.ljust(20), tel)
elif choice == '2':
# 查询联系人
name = input("请输入姓名：")
if name in address_book.keys():
print(name.ljust(20), address_book[name])
else:
new_choice = input("该联系人不存在，是否新建联系人（Y/N）？")
if new_choice.upper() == 'Y':
tel = input("请输入电话号码：")
address_book[name] = tel
elif choice == '3':
# 插入新的联系人
name = input("请输入姓名：")
if name in address_book.keys():
update_choice = input("该联系人已存在，是否更新联系人信息（Y/N）？")
if update_choice.upper() == 'Y':
tel = input("请输入电话号码：")
address_book[name] = tel
else:
tel = input("请输入电话号码：")
address_book[name] = tel
elif choice == '4':
# 删除已有联系人
name = input("请输入姓名：")
if name in address_book.keys():
del address_book[name]
print("联系人已删除")
else:
print("联系人不存在")
elif choice == '5':
# 保存通信录并退出
with open('addressbook.json', 'w') as f:
json.dump(address_book, f)
print("通讯录已保存，程序已退出")
break
else:
# 输入有误
print("输入有误，请重新输入")
正确答案
"""简易通信录程序""" import os, json ab = {} #通信录保存在字典中name:tel #从JSON文件中读取通信录 if os.path.exists("addressbook.json"): with open(r'addressbook.json', 'r', encoding='utf-8') as f: ab = json.load(f) while True: print("|---欢迎使用通讯录程序---|") print("|---1：显示通讯录清单 ---|") print("|---2：查询联系人资料 ---|") print("|---3：插入新的联系人 ---|") print("|---4：删除已有联系人 ---|") print("|---0：退出 -------------|") choice = input('请选择功能菜单(0-4):') if choice == '1': if(len(ab)==0): print("通讯录为空") else: for k, v in ab.items(): print("姓名={},联系电话={}".format(k, v)) elif choice == '2': name = input("请输入联系人姓名：") if(name not in ab): ask = input("联系人不存在，是否增加用户资料(Y/N)") if ask in ["Y", "y"]: tel = input("请输入用户联系电话：") ab[name] = tel else: print("联系人信息：{} {}".format(name, ab[name])) elif choice == '3': name=input("请输入联系人姓名：") if(name in ab): print("已存在联系人：{} {}".format(name, ab[name])) ask = input("是否修改用户资料(Y/N)") if ask in ["Y", "y"]: tel = input("请输入用户联系电话：") dict[name] = tel else: tel = input("请输入用户联系电话：") ab[name] = tel elif choice == '4': name = input("请输入联系人姓名：") if(name not in ab): print("联系人不存在：{}".format(name)) else: tel = ab.pop(name) print("删除联系人：{} {}".format(name, tel)) elif choice == '0': #保存到JSON文件并退出循环 with open(r'addressbook.json', 'w', encoding='utf-8') as f: json.dump(ab, f) break
+ 2.0 分
33 . 编程题 中等 2分
长方形面积
回答正确
请编写一个名为arg_parse.py的程序，命令行参数所输入的长和宽的值（假设默认的长为10，宽为5），计算并输出长方形的面积。
import argparse
# 创建ArgumentParser对象
parser = argparse.ArgumentParser(description="Calculate the area of a rectangle.")
# 添加长和宽的参数
parser.add_argument('-l', '--length', type=float, default=10, help='the length of the rectangle')
parser.add_argument('-w', '--width', type=float, default=5, help='the width of the rectangle')
# 命令行参数
args = parser.parse_args()
# 计算面积并输出
area = args.length * args.width
print(area)
正确答案
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--length', default=10, type=int, help='长度')
parser.add_argument('--width', default=5, type=int, help='宽度')
args = parser.parse_args()
area = args.length * args.widthprint(area)
argparse模块是用于命名的命令行参数，生成帮助信息的python标准模块。
+ 2.0 分
34 . 编程题 中等 2分
正方形的周长和面积
回答正确
请编写一个名为arg_parse2.py的程序，命令行参数所输入的边长的值（假设默认的边长为10），计算并输出正方形的周长和面积。
import argparse
# 创建ArgumentParser对象
parser = argparse.ArgumentParser(description='计算正方形的周长和面积')
# 添加参数选项
parser.add_argument('--length', type=int, default=10, help='正方形的边长')
# 命令行参数
args = parser.parse_args()
# 获取边长值
length = args.length
# 计算周长
perimeter = 4 * length
# 计算面积
area = length ** 2
# 输出结果print(perimeter, area)
正确答案
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--side', default=10, type=int, help='边长')args=parser.parse_args()
perimeter= 4 * args.side
area = args.side * args.sideprint(perimeter, area)
argparse模块是用于命名的命令行参数，生成帮助信息的python标准模块。
+ 2.0 分
35 . 编程题 中等 2分
读取并显示内存文本文件的内容
回答正确
请编写程序，利用StringIO将数据'Hello'和'Python'写入内存文本文件中，要求每写入一行数据均换行。然后，读取并显示内存文本文件的内容。
import io
# 创建StringIO对象并写入数据
stream = io.StringIO()
stream.write('Hello\n')
stream.write('Python\n')
# 将文件指针移到文件开头
stream.seek(0)
# 读取文件内容并输出
content = stream.read()
print(content)
正确答案
from io import StringIOf = StringIO('Hello\nPython\n')for s in f:
print(s.strip())
StringIO实现了内存文本文件的读取操作，常用作字符串的缓存。
+ 2.0 分
36 . 编程题 中等 2分
读取并显示内存二进制文件内容
回答正确
请编写程序，利用BytesIO将字节数据'程序设计'写入内存二进制文件中，要求每写入一行数据均换行。然后，读取并显示内存二进制文件的内容。
import io
# 创建BytesIO对象并写入数据
stream = io.BytesIO()
stream.write('程序设计\r\n'.encode())
stream.write('程序设计\r\n'.encode())
# 将文件指针移到文件开头
stream.seek(0)
# 读取文件内容并输出while True:
line = stream.readline()
if not line:
break
print(line.rstrip()) # 去掉行末的换行符
正确答案
from io import BytesIO
f = BytesIO()
f.write('程序设计'.encode('utf-8'))
f.seek(0) #定位到开始位置
b=f.read() #读取文件内容print(b) #显示文件内容print(f.getvalue()) #显示文件内容
BytesIO实现了内存二进制文件的读取操作，常用作字节码的缓存。
+ 2.0 分
37 .
以下关于Python文件的描述，错误的选项是_________。
A.二进制文件和文本文件的操作步骤都是“打开-操作-关闭”
B.在open()打开文件之后，文件的内容并没有在内存中
C.open()只能打开一个已经存在的文件
D.在文件读写之后，需要调用close()才能确保文件被保存在磁盘中
回答正确
C
正确答案
C
+ 0.0 分
38 .
以下关于Python中CSV文件的描述，错误的选项是_________。
A.CSV文件可用于不同工具间进行数据交换
B.CSV文件格式是一种通用的、相对简单的文件格式，应用于程序之间转移表格数据
C.CSV文件通过多种编码表示字符
D.CSV文件的每一行是一维数据，可以使用Python中的列表数据类型表示
回答错误
D
正确答案
C
+ 2.0 分
39 .
以下关于Python文件‘+’打开模式的描述，正确的选项是_________。
A.追加写模式
B.与r/w/a/x一同使用，在原功能基础上增加同时读写功能
C.只读模式
D.覆盖写模式
回答正确
B
正确答案
B
+ 2.0 分
40 .
以下关于Python文件的描述，错误的选项是_________。
A.readlines()函数读入文件内容后返回一个列表，元素划分依据是文本文件中的换行符
B.read()函数一次性读入文本文件的全部内容后，返回一个字符串
C.readline()函数读入文本文件的一行，返回一个字符串
D.二进制文件和文本文件都是可以用文本编辑器编辑的文件
回答正确
D
正确答案
D
+ 2.0 分
41 .
以下关于Python文件的描述，错误的选项是_________。
A.open()函数的参数处理模式‘b’表示以二进制数据处理文件
B.open()函数的参数处理模式‘+’表示可以对文件进行读和写操作
C.readline()函数表示读取文件的下一行，返回一个字符串
D.open()函数的参数处理模式‘a’表示以追加方式打开文件，删除已有内容
回答正确
D
正确答案
D
+ 2.0 分
42 .
Python文件读取方法read(size)的含义是_________。
A.从头到尾读取文件所有内容
B.从文件中读取一行数据
C.从文件中读取多行数据
D.从文件中读取指定size大小的数据，如果size为负数或者空，则读取到文件结束
回答正确
D
正确答案
D
+ 2.0 分
43 . 填空题 简单 2分
Python语句print(1,2,3,4,5,sep='-',end='!')的输出结果是___。
回答正确
1-2-3-4-5!
正确答案
1-2-3-4-5!
+ 2.0 分
44 . 填空题 简单 2分
Python语句“for i in range(10): print(i, end=' ')”的输出结果是____。
回答正确
0 1 2 3 4 5 6 7 8 9
正确答案
0 1 2 3 4 5 6 7 8 9
+ 0.5 分
45 . 填空题 简单 2分
在Python程序中可以通过列表___访问命令行参数。____为Python脚本名，____为第一个参数名，_____为第二个参数名。
回答正确
sys.argv、sys.argv[0]、sys.argv[1]、sys.argv[2]
正确答案
sys.argv、argv[0]、argv[1]、argv[2]
+ 2.0 分
46 . 填空题 简单 2分
Python程序使用_____模块命名的命令行参数。
回答正确
argparse
正确答案
argparse
+ 1.0 分
47 . 填空题 简单 1分
如果在程序运行时需要提示用户输入密码，则可以使用模块_____，以保证用户输入的密码在控制台中不回显。
回答正确
getpass
正确答案
getpass
+ 1.0 分
48 . 填空题 简单 1分
Python语言使用______语句实现上下文管理协议。
回答正确
with
正确答案
with
+ 1.0 分
49 . 填空题 简单 1分
在Python语言中，使用sys模块中的______、_____和______，可以查看对应的标准输入、标准输出和标准错误流文件对象。
回答正确
sys.stdin、sys.stdout、sys.stderr
正确答案
sys.stdin、sys.stdout、sys.stderr
+ 0.0 分
50 . 填空题 简单 1分
Python可以使用函数______打开文件。
回答错误
open()
正确答案
open
+ 0.5 分
51 . 填空题 简单 1分
Python文件操作可以使用____方法关闭流，以释放资源。通常采用____语句，以保证系统自动关闭打开的流。
回答正确
close()、with
正确答案
close、with
+ 0.0 分
52 . 填空题 简单 1分
在Python语言中，当打开随机文件后，可以使用实例方法____进行定位。
回答错误
seek()
正确答案
seek
+ 1.0 分
53 . 填空题 简单 1分
在Python语言中，____模块提供处理用于循环处理输入、输入重定向、管道或一个或多个文本文件的函数和辅助对象。
回答正确
fileinput
正确答案
fileinput
+ 0.0 分
54 . 填空题 简单 1分
Python语言可以使用_____模块中提供的函数实现Python对象的序列化。
回答错误
pickle
正确答案
pickle/cPickle/marshal
平时作业5--第6章
总分：100分
得分：78.0分
+ 2.0 分
1 .
( )不是用于处理中文的字符编码。
A.gb2312
B.gbk
C.big5
D.ascii
回答正确
D
正确答案
D
+ 2.0 分
2 .
( )可以返回x的整数部分
A.math.ceil()
B.math.fabs()
C.math.pow(x,y)
D.math.trunc(x)
回答正确
D
正确答案
D
+ 2.0 分
3 .
关于列表数据结构，下面描述正确的是
A.可以不按顺序查找元素
B.必须按顺序插入元素
C.不支持 in 运算符
D.所有元素类型必须相同
回答正确
A
正确答案
A
+ 2.0 分
4 .
字符串函数strip()的作用是什么？
A.按照指定字符分割字符串为数组
B.连接两个字符串序列
C.去掉字符串两侧空格或指定字符
D.替换字符串中特定字符
回答正确
C
正确答案
C
+ 0.0 分
5 .
"abc"的长度是3，"老师好"的长度是多少？
A.1
A.1
B.3
B.3
C.6
C.6
D.9
D.9
回答错误
C
正确答案
B、C
+ 2.0 分
6 .
字符串是一个连续的字符序列，用什么方式打印出可以换行的字符串？
A.使用转义符\\
B.使用\n
C.使用空格
D.使用“\换行”
回答正确
B
正确答案
B
+ 2.0 分
7 .
下列哪项类型数据是不可变化的：
A.集合
B.字典
C.元组
D.列表
回答正确
C
正确答案
C
+ 2.0 分
8 .
对于字典d={'abc':1, 'qwe':2, 'zxc':3}，len(d)的结果为：
A.6
B.3
C.12
D.9
回答正确
B
正确答案
B
+ 2.0 分
9 .
以下关于列表表述中错误的是哪一项？
A.可以用“==”比较两个列表是否相同。
B.Python的列表可以嵌套，形成二维列表。
C.“+”号可以用来拼接两个列表。
D.列表与字符串一样都是不可变的。
回答正确
D
正确答案
D
+ 2.0 分
10 .
以下关于Python的说法中正确的是哪一项？
A.Python中函数的返回值如果多于1个，则系统默认将它们处理成一个字典。
B.递归调用语句不允许出现在循环结构中。
C.在Python中，一个算法的递归实现往往可以用循环实现等价表示，但是大多数情况下递归表达的效率要更高一些。
D.可以在函数参数名前面加上星号*，这样用户所有传来的参数都被收集起来然后使用，星号在这里的作用是收集其余的位置参数，这样就实现了变长参数。
回答正确
D
正确答案
D
+ 0.0 分
11 .
以下关于Python自带数据结构的运算结果中错误的是哪一项？
A.l = [1, 2, 3, 4]; l.insert(2, -1); 则l为 [1, 2, -1, 4]。
B.l = [1, 2, 3, 4]; l.pop(1); 则l结果为[1, 3, 4]。
C.l = [1, 2, 3, 4]; l.pop(); 则l.index(3) 结果为2。
D.l = [1, 2, 3, 4]; l.rerverse(); 则l[1]为3。
回答错误
D
正确答案
A
+ 2.0 分
12 .
以下关于Python自带数据结构的运算结果中正确的是哪一项？
A.l = [1, 2, 3, 4, 5]; del l[2:4]; 则运算之后l为[1, 2, 3]。
B.basket = ['apple', 'banana', 'apple', 'orange'] ; fruit = set(basket); fruit2 = set(['apple', 'melo']); len(fruit | fruit2) 的结果是5。
C.basket = ['apple', 'banana', 'apple', 'orange'] ; fruit = set(basket); len(fruit) 的运算结果是4。
D.l = [2, 1, 3, 5, 4]; l.remove(3); l.sort(); 则运算之后l为[1, 2, 4, 5]
回答正确
D
正确答案
D
+ 2.0 分
13 .
以下关于Python自带数据结构的运算结果中正确的是哪一项？
A.scores = {'Jack': 90, 'Mike': 80, 'Jay': 85, 'Bill': 60}; del scores['Bill']; len(scores)的结果是6。
B.scores = {'Jack': 90, 'Mike': 80, 'Jay': 85, 'Bill': 60}; s = dict(Jack=90, Mike=80, Jay=85, Bill=60); 则scores == s 判断结果是False。
C.scores = {'Jack': 90, 'Mike': 80, 'Jay': 85, 'Bill': 60}; 无法执行命令 scores['Bill']=90; 因为原来的字典中已经有了一个值为90了。
D.scores = {'Jack': 90, 'Mike': 80, 'Jay': 85, 'Bill': 60}; sorted(scores.keys())的运算结果是 ['Bill', 'Jack', 'Jay', 'Mike']
回答正确
D
正确答案
D
+ 2.0 分
14 .
以下描述中错误的是哪一项？
A.在遍历列表的同时可以修改列表本身，例如如下的代码可以做到。 words = ['I', 'love', 'Python'] for w in words: if len(w) > 4: words.insert(0, w)
B.当在序列中循环访问元素时，如果要获取元素的下标，可以使用enumerate() 函数，例如 for i in enumerate(list)。
C.如果要倒序遍历访问序列中的元素，可以对该序列使用reversed() 函数，例如 for i in reversed(list)。
D.对字典进行遍历访问时，可以通过items()函数同时得到key, value值。例如 for k, v in scores.items()
回答正确
A
正确答案
A
+ 2.0 分
15 .
对于一个列表aList和一个元组bTuple，以下函数调用错误的选项是哪一个？
A.sorted(aList)
B.sorted(bTuple)
C.aList.sort()
D.bTuple.sort()
回答正确
D
正确答案
D
+ 2.0 分
16 .
（ ）函数以一系列列表作为参数，将列表中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
A.lambda
B.map
C.zip
D.filter
回答正确
C
正确答案
C
+ 2.0 分
17 .
关于列表数据结构，下面描述正确的是（ )。
A.不支持 in 运算符
B.必须按顺序插入元素
C.可以不按顺序查找元素
D.所有元素类型必须相同
回答正确
C
正确答案
C
+ 2.0 分
18 .
以下哪条语句定义了一个Python字典（ ）。
A.{1:2,2:3 }
B.{1, 2, 3}
C.[1, 2, 3]
D.(1, 2, 3)
回答正确
A
正确答案
A
+ 0.0 分
19 .
以下关于Python自带数据结构的运算结果中错误的是哪一项？
A.l =
B.l =
C.l =
D.l =
回答错误
A
正确答案
D
+ 2.0 分
20 .
算法是指（）
A.数学的计算公式
B.程序设计语言的语句序列
C.问题的精确描述
D.解决问题的精确步骤
回答正确
D
正确答案
D
+ 2.0 分
21 .
以下描述中错误的是哪一项？
A.在遍历列表的同时可以修改列表本身，例如如下的代码可以做到。 words = ['I', 'love', 'Python'] for w in words: if len(w) > 4: words.insert(0, w)
B.当在序列中循环访问元素时，如果要获取元素的下标，可以使用enumerate() 函数，例如 for i in enumerate(list)。
C.如果要倒序遍历访问序列中的元素，可以对该序列使用reversed() 函数，例如 for i in reversed(list)。
D.对字典进行遍历访问时，可以通过items()函数同时得到key, value值。例如 for k, v in scores.items()
回答正确
A
正确答案
A
+ 1.0 分
22 . 简答题 中等 2分
定义一个圆柱体类Cylinder，包含底面半径和高两个属性（数据成员）；包含一个可以计算圆柱体体积的方法。然后编写相关程序测试相关功能。
回答正确
import math
class Cylinder:
def __init__(self, radius, height):
self.radius = radius
self.height = height
def volume(self):
return math.pi * self.radius ** 2 * self.height
正确答案
class Cylinder:
num=3.14
def __init__(self,a,b):
self.r=a
self.h=b
def volume(self):
r=float(self.r)
h=float(self.h)
self.v=r*r*h*Cylinder.num
def print(self):
print(self.v)
#主函数
a=input("请输入圆柱体的半径:")
b=input("请输入圆柱体的高:")
c1=Cylinder(a,b)
c1.volume()
print("圆柱体的体积为:")
c1.print()
+ 1.0 分
23 . 简答题 中等 2分
定义一个学生类，包括学号、姓名和出生日期三个属性（数据成员）；包括一个用于给定数据成员初始值的构造函数；包含一个可计算学生年龄的方法。编写该类并对其进行测试。
回答正确
import datetime
class Student:
def __init__(self, id, name, birthdate):
self.id = id
self.name = name
self.birthdate = birthdate
def age(self):
today = datetime.date.today()
age = today.year - self.birthdate.year
if today < datetime.date(today.year, self.birthdate.month, self.birthdate.day):
age -= 1
return age
正确答案
class Student:
def __init__(self,a,b,c):
self.number=a
self.name=b
self.birthday=c
def Age(self):
self.age=2017-int(self.birthday[0:4])
def print(self):
print("学生的学号为:",self.number)
print("学生的名字为:",self.name)
print("学生的生日为:",self.birthday)
print("学生的年龄为:",self.age)
#主函数
a,b,c=input("请输入学生的学号、名字以及生日(空格隔开):").split(' ')
s1=Student(a,b,c)
s1.Age()
s1.print()
+ 1.0 分
24 . 简答题 中等 2分
简述面向对象程序设计的概念及类和对象的关系，在Python语言中如何声明类和定义对象？
回答正确
使用 class 关键字声明类，定义类的属性和方法。
使用 __init__ 方法定义构造函数初始化对象属性。
使用类名加括号的形式创建对象，并初始化对象属性。
调用对象的方法和属性进行各种操作。
正确答案
略
+ 1.0 分
25 . 简答题 中等 2分
简述面向对象程序设计中继承与多态性的作用是什么？
回答正确
代码重用：继承允许子类继承父类的属性和方法，减少了代码的冗余和重复编写，提高了代码的复用性。
简化代码设计：通过继承，可以将共同的属性和行为放在父类中，避免了在每个子类中重复编写相同的代码，使得代码更加简洁、清晰。
增强程序的灵活性：继承和多态性允许通过子类对父类进行修改、扩展或重写，使得程序可以根据需求进行定制和拓展，更加灵活可变。
简化代码调用：多态性可以使用父类类型的引用变量来引用子类类型的对象，无需关心实际对象的类型，提供了一种统一的接口和调用方式。
提高可扩展性和可维护性：通过继承和多态性，系统可以方便地添加新的子类，而无需修改现有的代码，从而提高了代码的可扩展性和可维护性。
正确答案
略
+ 1.0 分
26 . 简答题 中等 2分
定义一个圆柱体类Cylinder，包含底面半径和高两个属性（数据成员）；包含一个可以计算圆柱体体积的方法。然后编写相关程序测试相关功能。
回答正确
import math
class Cylinder:
def __init__(self, radius, height):
self.radius = radius
self.height = height
def calculate_volume(self):
volume = math.pi * self.radius**2 * self.height
return volume
# 测试代码
cylinder = Cylinder(3, 5) # 创建一个半径为3、高为5的圆柱体对象
volume = cylinder.calculate_volume() # 计算圆柱体体积
print("圆柱体的体积为:", volume)
正确答案
class Cylinder: num=3.14 def __init__(self,a,b): self.r=a self.h=b def volume(self): r=float(self.r) h=float(self.h) self.v=r*r*h*Cylinder.num def print(self): print(self.v) #主函数 a=input("请输入圆柱体的半径:") b=input("请输入圆柱体的高:") c1=Cylinder(a,b) c1.volume() print("圆柱体的体积为:") c1.print()
+ 1.0 分
27 . 简答题 中等 2分
定义一个学生类，包括学号、姓名和出生日期三个属性（数据成员）；包括一个用于给定数据成员初始值的构造函数；包含一个可计算学生年龄的方法。编写该类并对其进行测试。
回答正确
import datetime
class Student:
def __init__(self, student_id, name, birthdate):
self.student_id = student_id
self.name = name
self.birthdate = birthdate
def calculate_age(self):
today = datetime.date.today()
age = today.year - self.birthdate.year
if today < datetime.date(today.year, self.birthdate.month, self.birthdate.day):
age -= 1
return age
# 测试代码
student = Student('20210001', '张三', datetime.date(2000, 5, 10)) # 创建一个学生对象
age = student.calculate_age() # 计算学生年龄
print("学生年龄：", age)
正确答案
class Student: def __init__(self,a,b,c): self.number=a self.name=b self.birthday=c def Age(self): self.age=2017-int(self.birthday[0:4]) def print(self): print("学生的学号为:",self.number) print("学生的名字为:",self.name) print("学生的生日为:",self.birthday) print("学生的年龄为:",self.age) #主函数 a,b,c=input("请输入学生的学号、名字以及生日(空格隔开):").split(' ') s1=Student(a,b,c) s1.Age() s1.print()
+ 1.0 分
28 . 简答题 中等 2分
定义一个shape类，利用它作为基类派生出Rectangle、Circle等具体形状类，已知具体形状类均具有两个方法GetArea和GetColor，分别用来得到形状的面积和颜色。最后编写一个测试程序对产生的类的功能进行验证。
回答正确
class Shape:
def __init__(self, color):
self.color = color
def GetArea(self):
pass
def GetColor(self):
return self.color
class Rectangle(Shape):
def __init__(self, color, width, height):
super().__init__(color)
self.width = width
self.height = height
def GetArea(self):
return self.width * self.height
class Circle(Shape):
def __init__(self, color, radius):
super().__init__(color)
self.radius = radius
def GetArea(self):
import math
return math.pi * self.radius**2
# 测试代码
rectangle = Rectangle("红色", 5, 4) # 创建一个红色的矩形对象
area = rectangle.GetArea() # 计算矩形的面积
color = rectangle.GetColor() # 获取矩形的颜色
print("矩形的面积：", area)
print("矩形的颜色：", color)
circle = Circle("蓝色", 3) # 创建一个蓝色的圆形对象
area = circle.GetArea() # 计算圆形的面积
color = circle.GetColor() # 获取圆形的颜色
print("圆形的面积：", area)
print("圆形的颜色：", color)
正确答案
略
+ 2.0 分
29 . 填空题 简单 2分
面向对象的程序设计具有三个基本特征：____ _______、___________和___________。
回答正确
封装、继承、多态
正确答案
封装、继承、多态
面向对象的程序设计具有三个基本特征：封装、继承和多态，可以大大增加程序的可靠性、代码的可重用性和程序的可维护性，从而提高程序开发效率。
+ 2.0 分
30 . 填空题 简单 2分
Python语句序列“x='123';print(isinstance(x, int))”的运行结果为____________。（注意：英文区分大小写）
回答正确
False
正确答案
False
collections.abc模块中定义了抽象基类Iterable，使用内置的isinstance，可以判断一个对象是否为可迭代对象。
+ 2.0 分
31 . 填空题 简单 2分
在Python中创建对象后，可以使用____________运算符来调用其成员。
回答正确
.正确答案
.在创建实例对象后，可以使用“.”运算符来调用其成员。
+ 2.0 分
32 . 填空题 简单 2分
Python类体中，____ _______是一个类方法，创建对象时调用，返回当前对象的一个实例，一般无需重载该方法。___________方法即构造函数（构造方法），用于执行类的实例的初始化工作。对象创建后调用，初始化当前对象的实例，无返回值。___________方法即析构函数，用于实现销毁类的实例所需的操作，如释放对象占用的非托管资源。（注意：英文区分大小写）
回答正确
__new__、__init__、__del__
正确答案
__new__、__init__、__del__
（1）__new__方法是一个类方法，创建对象时调用，返回当前对象的一个实例，一般无需重载该方法。（2）__init__方法即构造函数（构造方法），用于执行类的实例的初始化工作。创建完对象后调用，初始化当前对象的实例，无返回值。（3）_del__方法即析构函数（析构方法），用于实现销毁类的实例所需的操作，如释放对象占用的非托管资源（例如，打开的文件、网络连接等）。
+ 2.0 分
33 . 填空题 简单 2分
在Python中，实例变量在类的内部通过____________访问，在外部通过对象实例访问。（注意：英文区分大小写）
回答正确
self
正确答案
self
通过“self.变量名”定义的属性，称为实例对象属性，也称为实例对象变量。实例对象变量在类的内部通过self访问，在外部通过对象实例访问。
+ 2.0 分
34 . 填空题 简单 2分
下列Python语句的程序运行结果为___ ______、_________。 class parent: def __init__(self, param): self.v1 = param class child(parent): def __init__(self, param): parent.__init__(self, param) self.v2 = param obj = child(100); print ("%d %d" % (obj.v1, obj.v2))
回答正确
100、100
正确答案
100、100
__init__方法即构造函数（构造方法），用于执行类的实例的初始化工作。创建完对象后调用，初始化当前对象的实例，无返回值。
+ 2.0 分
35 . 填空题 简单 2分
下列Python语句的程序运行结果为____________。 class Account: def __init__(self, id): self.id = id; id = 888 acc = Account(100); print(acc.id)
回答正确
100
正确答案
100
__init__方法即构造函数（构造方法），用于执行类的实例的初始化工作。创建完对象后调用，初始化当前对象的实例，无返回值。
+ 2.0 分
36 . 填空题 中等 2分
下列Python语句的程序运行结果为____________。 class account: def __init__(self, id, balance): self.id = id; self.balance = balance def deposit(self, amount): self.balance += amount def withdraw(self, amount): self.balance -= amount acc1 = account('1234', 100); acc1.deposit(500) acc1.withdraw(200); print(acc1.balance)
回答正确
400
正确答案
400
一般情况下，类方法的第一个参数一般为self，这种方法称之为对象实例方法。对象实例方法对类的某个给定的实例进行操作，可以通过self显式地访问该实例。
+ 2.0 分
37 . 填空题 简单 2分
下列Python语句的程序运行结果为___________。 class A: def __init__(self, a, b, c): self.x = a + b + c a = A(6,2,3); b = getattr(a, 'x'); setattr(a, 'x', b+1);print(a.x)
回答正确
12
正确答案
12
一般情况下，类方法的第一个参数一般为self，这种方法称之为对象实例方法。对象实例方法对类的某个给定的实例进行操作，可以通过self显式地访问该实例。
+ 0.0 分
38 . 填空题 中等 2分
阅读下面Python语句，请问输出结果是什么？____________ d1 = {'a':[1,2], 'b':2}; d2= d1.copy(); d1['a'][0]=6 sum = d1['a'][0] + d2['a'][0]; print(sum)
回答错误
12
正确答案
7
Python复制一般是浅拷贝，即复制对象时，对象中包含的子对象并不复制，而是引用同一个子对象。
+ 2.0 分
39 . 填空题 中等 2分
下列Python语句的程序运行结果为____________。 list1=[1,2,3]; list2=[3,4,5];dict1={'1':list1, '2':list2};dict2=dict1.copy() dict1['1'][0]=15; print(dict1['1'][0] + dict2['1'][0])
回答正确
30
正确答案
30
copy模块的deepcopy函数递归复制对象中包含的子对象。
+ 2.0 分
40 . 填空题 中等 2分
下列Python语句的程序运行结果为____________。 import copy list1=[1,2,3]; list2=[3,4,5]; dict1={'1':list1, '2':list2} dict2=copy.deepcopy(dict1); dict1['1'][0]=15 print(dict1['1'][0] + dict2['1'][0])
回答正确
16
正确答案
16
copy模块的deepcopy函数递归复制对象中包含的子对象。
+ 0.0 分
41 . 填空题 中等 2分
下列Python语句的程序运行结果为____________。 class Person: def __init__(self, id): self.id = id mary = Person(123); mary.__dict__['age'] = 18 mary.__dict__['gender'] = 'female'; print(mary.age + len(mary.__dict__))
回答错误
20
正确答案
21
“object.__dict__”返回对象的属性字典，本题为{'id': 123, 'age': 18, 'gender': 'female'}。
+ 2.0 分
42 . 编程题 中等 2分
温度转换
回答正确
编写程序，利用静态方法实现那摄氏温度转换为华氏温度，要求输入摄氏温度，输出华氏温度。
class Temperature: @staticmethod
def celsius_to_fahrenheit(celsius):
fahrenheit = celsius * (9/5) + 32
return fahrenheit
celsius = float(input("请输入摄氏温度： "))
fahrenheit = Temperature.celsius_to_fahrenheit(celsius)print(f"{fahrenheit:.1f}")
正确答案
class TemperatureConverter: @staticmethod
def c2f(t_c): #摄氏温度到华氏温度的转换
t_c = float(t_c)
t_f = (t_c * 9/5) + 32
return t_f#测试代码
t_c = float(input("请输入摄氏温度： "))
t_f = TemperatureConverter.c2f(t_c)print(t_f)
Python也允许声明属于与类的对象实例无关的方法，称之为静态方法。静态方法不对特定实例进行操作，在静态方法中访问对象实例会导致错误。静态方法通过装饰器@staticmethod来定义。
+ 1.0 分
43 . 编程题 中等 2分
温度转换
回答正确
编写程序，利用静态方法实现华氏温度转换为摄氏温度，要求输入华氏温度，输出摄氏温度。
class Temperature: @staticmethod
def fahrenheit_to_celsius(fahrenheit):
celsius = (fahrenheit - 32) * (5/9)
return celsius
fahrenheit = float(input("请输入华氏温度： "))
celsius = Temperature.fahrenheit_to_celsius(fahrenheit)print(f"{celsius:.1f}")
正确答案
class TemperatureConverter: @staticmethod
def f2c(t_f): #华氏温度到摄氏温度的转换
t_f = float(t_f)
t_c = (t_f - 32) * 5 /9
return t_c#测试代码
t_f = float(input("请输入华氏温度： "))
t_c = TemperatureConverter.f2c(t_f)print(t_c)
Python也允许声明属于与类的对象实例无关的方法，称之为静态方法。静态方法不对特定实例进行操作，在静态方法中访问对象实例会导致错误。静态方法通过装饰器@staticmethod来定义。
+ 0.0 分
44 . 编程题 中等 2分
列表的运算符重载
回答错误
编写程序，实现列表的运算符重载，“+”、“-”、“*”、“/”表示每个元素增加指定的数值，并重载返回列表的长度、显示列表的内容。假设测试列表的内容为(1, 2, 3, 4, 5)，列表每个元素增加2并显示列表内容，接着列表每个元素减少2并显示列表内容，再接着列表每个元素乘以4并显示列表内容，再接着列表每个元素除以2并显示列表内容，最后输出列表的长度。
class MyList:
def __init__(self, data):
self.data = data
def __add__(self, value):
return MyList([x + value for x in self.data])
def __sub__(self, value):
return MyList([x - value for x in self.data])
def __mul__(self, value):
return MyList([x * value for x in self.data])
def __truediv__(self, value):
return MyList([x / value for x in self.data])
def __len__(self):
return len(self.data)
def display(self):
for item in self.data:
print(item, end=' ')
print()
# 测试列表的内容为(1, 2, 3, 4, 5)
my_list = MyList([1, 2, 3, 4, 5])
# 列表每个元素增加2并显示列表内容
my_list += 2
my_list.display()
# 列表每个元素减少2并显示列表内容
my_list -= 2
my_list.display()
# 列表每个元素乘以4并显示列表内容
my_list *= 4
my_list.display()
# 列表每个元素除以2并显示列表内容
my_list /= 2
my_list.display()
# 输出列表的长度
length = len(my_list)
print(length)
正确答案
class MyList: #定义类MyList
def __init__(self, *args): #构造函数
self.__mylist = [] #初始化私有属性，空列表
for arg in args:
self.__mylist.append(arg)
def __add__(self, n): #重载运算符"+"，每个元素增加n
for i in range(0, len(self.__mylist)):
self.__mylist[i] += n
def __sub__(self, n): #重载运算符"-"，每个元素减少n
for i in range(0, len(self.__mylist)):
self.__mylist[i] -= n
def __mul__(self, n): #重载运算符"*"，每个元素乘以n
for i in range(0, len(self.__mylist)):
self.__mylist[i] *= n
def __truediv__(self, n): #重载运算符"/"，每个元素除以n
for i in range(0, len(self.__mylist)):
self.__mylist[i] /= n
def __len__(self): #对应于内置函数len()，返回列表长度
return(len(self.__mylist))
def __repr__(self): #对应于内置函数str()，显示列表
str1 = ''
for i in range(0, len(self.__mylist)):
str1 += str(self.__mylist[i]) + ' '
return str1#测试代码
m = MyList(1, 2, 3, 4, 5) #创建对象
m + 2; print(repr(m)) #每个元素加2
m - 1; print(repr(m)) #每个元素减1
m * 4; print(repr(m)) #每个元素乘4
m / 2; print(repr(m)) #每个元素除2print(len(m)) #列表长度
Python的运算符实际上是通过调用对象的特殊方法实现的。在Python类体中，通过重写各运算符所对应的特殊方法，即可以实现运算符的重载。
+ 0.0 分
45 . 编程题 中等 2分
Fibonacci数列
回答错误
编写程序，定义一个名为Fib的类，实现数值在1000以内的Fibonacci数列。要求Fib对象作为可迭代对象，也是迭代器，并定义__iter__方法和__next()__。
class Fib:
def __init__(self):
self.a = 0
self.b = 1
def __iter__(self):
return self
def __next__(self):
fib_num = self.a
if fib_num > 1000:
raise StopIteration
self.a, self.b = self.b, self.a + self.b
return fib_num
# 创建 Fib 对象并进行迭代
fib_sequence = Fib()
for num in fib_sequence:
print(num, end=' ')
正确答案
class Fib:
def __init__(self):
self.a,self.b = 0,1 #前两项值
def __next__(self):
self.a,self.b = self.b,self.a+self.b
return self.a #f(n)=f(n-1)+f(n-2)
def __iter__(self):
return self#测试代码
fibs = Fib()for f in fibs:
if f < 1000: print(f, end=' ')
else: break
声明一个类，定义__iter__方法和__next()__。创建该类的对象，即是可迭代对象，也是迭代器。。
+ 2.0 分
46 . 编程题 中等 2分
Fibonacci数列
回答正确
编写程序，利用生成器函数创建数值在1000以内的Fibonacci数列。
def fibonacci():
a, b = 1, 1
while a <= 1000:
yield a
a, b = b, a + b
fib_seq = fibonacci()
for num in fib_seq:
print(num, end=",")
正确答案
def fib():
a,b = 0,1 #前两项值
while 1:
a,b = b,a+b
yield a #f(n)=f(n-1)+f(n-2)#测试代码if __name__ == '__main__':
fibs = fib()
for f in fibs:
if f < 1000: print(f, end=',')
else: break
生成器函数使用yield语句返回一个值，然后保存当前函数整个执行状态，等待下一次调用。生成器函数是一个迭代器，是可迭代对象，支持迭代。
+ 2.0 分
47 . 编程题 中等 2分
生成器函数
回答正确
编写程序，利用生成器函数创建m到n之间素数的生成器。使用m=5000000000、n=5000000090进行测试。
def is_prime(n):
if n <= 1:
return False
for i in range(2, int(n ** 0.5) + 1):
if n % i == 0:
return False
return True
def primes(m, n):
for i in range(m, n + 1):
if is_prime(i):
yield i
m = 5000000000
n = 5000000090
prime_seq = primes(m, n)
for num in prime_seq:
print(num, end=",")
正确答案
import mathdef is_prime(n):
if n < 2: return False
if n == 2: return True
if n % 2 == 0: return False
sqrt_n = int(math.floor(math.sqrt(n)))
for i in range(3, sqrt_n + 1, 2):
if n % i == 0:
return False
return Truedef primes(m, n):
"""返回[m, n]之间所有素数的生成器"""
for i in range(m, n+1):
if is_prime(i):
yield i#测试代码if __name__ == '__main__':
pimes1 = primes(5000000000, 5000000090)
for p in pimes1:
print(p, end=',')
生成器函数使用yield语句返回一个值，然后保存当前函数整个执行状态，等待下一次调用。生成器函数是一个迭代器，是可迭代对象，支持迭代。
+ 2.0 分
48 . 编程题 中等 2分
计算圆的周长、面积和球的表面积和体积
回答正确
编写程序，创建类MyMath，计算圆的周长、面积和球的表面积和体积，并编写测试代码，提示用户输入圆的半径，输出计算结果。结果均保留一位小数。
import math
class MyMath:
def __init__(self, radius):
self.radius = radius
def circle_circumference(self):
return round(2 * math.pi * self.radius, 1)
def circle_area(self):
return round(math.pi * self.radius ** 2, 1)
def sphere_surface_area(self):
return round(4 * math.pi * self.radius ** 2, 1)
def sphere_volume(self):
return round((4/3) * math.pi * self.radius ** 3, 1)
radius = float(input("请输入半径： "))
my_math = MyMath(radius)
circle_circumference = my_math.circle_circumference()
circle_area = my_math.circle_area()
sphere_surface_area = my_math.sphere_surface_area()
sphere_volume = my_math.sphere_volume()
print(circle_circumference, circle_area, sphere_surface_area, sphere_volume)
正确答案
from math import *class MyMath:
global PI
PI = 3.1415926
def Perimeter(r):
return (2 * PI * r)
def Area(r):
return (PI * r * r)
def Surface(r):
return (4*PI * r * r)
def Volume(r):
return( 4 * PI * pow(r, 3) / 3)
r = float(input("请输入半径： "))print(str.format("{0:2.1f} {1:2.1f} {2:2.1f} {3:2.1f}",MyMath.Perimeter(r),MyMath.Area(r), MyMath.Surface(r),MyMath.Volume(r)))
无。
+ 2.0 分
49 . 编程题 中等 2分
温度转换
回答正确
编写程序，创建类Temperature，包含成员变量degree（表示温度）以及实例方法ToFahrenheit()（将摄氏温度转换为华氏温度），并编写测试代码，提示用户输入摄氏温度，输出华氏温度。结果保留一位小数。
class Temperature:
def __init__(self, degree):
self.degree = degree
def ToFahrenheit(self):
fahrenheit = round(self.degree * 9/5 + 32, 1)
return fahrenheit
degree_celsius = float(input("请输入摄氏温度： "))
temperature = Temperature(degree_celsius)
fahrenheit = temperature.ToFahrenheit()
print(fahrenheit)
正确答案
class TemperatureCelsius:
def __init__(self, d):
self.degree = d
def ToFahrenheit(self):
return (self.degree * 9 / 5) + 32
d = float(input("请输入摄氏温度： "))
celsius = TemperatureCelsius(d)print(str.format("{0:2.1f}",celsius.ToFahrenheit()))
+ 2.0 分
50 . 编程题 中等 2分
温度转换
回答正确
编写程序，创建类Temperature，包含成员变量degree（表示温度）以及实例方法ToCelsius()（将华氏温度转换为摄氏温度），并编写测试代码，提示输入华氏温度，输出摄氏温度。结果保留一位小数。
class Temperature:
def __init__(self, degree):
self.degree = degree
def ToCelsius(self):
celsius = round((self.degree - 32) * 5/9, 1)
return celsius
degree_fahrenheit = float(input("请输入华氏温度： "))
temperature = Temperature(degree_fahrenheit)
celsius = temperature.ToCelsius()
print(celsius)
正确答案
class Temperature:
def __init__(self, d):
self.degree = d
def ToCelsius(self):
return (self.degree - 32) * 5 / 9
d1 = float(input("请输入华氏温度： "))
fahrenheit = Temperature(d1)print(str.format("{0:2.1f}",fahrenheit.ToCelsius()))
第7章-图形界面设计-平时作业
总分：100分
得分：65.5分
+ 1.0 分
1 . 简答题 困难 3分
设计一个程序，用两个文本框输入数值数据，用列表框存放“＋、－、×、÷、幂次方、余数”。用户先输入两个操作数，再从列表框中选择一种运算，即可在标签中显示出计算结果。 实现简单加减乘除程序。使用两个单行文本框输入数字，使用列表框选择运算。
回答正确
import tkinter as tk
def calculate():
operand1 = float(entry1.get())
operand2 = float(entry2.get())
operator = listbox.get(listbox.curselection())
if operator == '加':
result = operand1 + operand2
elif operator == '减':
result = operand1 - operand2
elif operator == '乘':
result = operand1 * operand2
elif operator == '除':
result = operand1 / operand2
label.config(text="计算结果：{}".format(result))
# 创建窗口
window = tk.Tk()
window.title("简单计算器")
# 创建文本框和标签
entry1 = tk.Entry(window)
entry1.pack()
entry2 = tk.Entry(window)
entry2.pack()
label = tk.Label(window, text="计算结果：")
label.pack()
# 创建列表框
listbox = tk.Listbox(window)
listbox.insert(0, '加')
listbox.insert(1, '减")
listbox.insert(2, '乘')
listbox.insert(3, '除')
listbox.pack()
# 创建计算按钮
button = tk.Button(window, text="计算", command=calculate)
button.pack()
# 运行窗口主循环
window.mainloop()
正确答案
from tkinter import *
import tkinter as tk
root = Tk()
m = StringVar()
def callbutton2():
a=float(num1.get())
b=float(num2.get())
if k=='加':
print(a+b)
result["text"]=str(a+b)
#result.config(text=str(a+b))
if k=='减':
print(a-b)
result["text"]=str(a-b)
if k=='乘':
print(a*b)
result["text"]=str(a*b)
if k=='除':
print(a*b)
result["text"]=str(a/b)
root.title("使用Listbox组件的例子") #设置窗口标题
lab1=Label(root,text = '请输入第1个数',width=20)
lab1.pack()
num1 = tk.Entry(root) #Entry组件
num1.pack()
lab2=Label(root,text = '请输入第2个数',width=20)
lab2.pack()
num2 = tk.Entry(root) #Entry组件
num2.pack()
lb = Listbox(root, listvariable =m) #将一字符串与Listbox的值绑定
lb.insert(END,'加')
lb.insert(END,'减')
lb.insert(END,'乘')
lb.insert(END,'除')
lb.pack()
b2 = Button (root,text = '计算', command=callbutton2, width=20)#创建Button组件
b2.pack()#显示Button组件
result=Label(root,text = '结果',width=6)
result.pack()
root.mainloop()
+ 1.0 分
2 . 简答题 困难 3分
编写选课程序。左侧列表框显示学生可以选择的课程名，右侧列表框显示学生已经选择的课程名，通过4个按钮在两个列表框中移动数据项。通过“〉”、“〈”按钮移动一门课程，通过“》”、“《”按钮移动全部课程。程序运行界面见图7-42所示。
回答正确
mport tkinter as tk
def move_right():
selected = listbox1.curselection()
for index in selected:
value = listbox1.get(index)
listbox2.insert(tk.END, value)
for index in reversed(selected):
listbox1.delete(index)
def move_left():
selected = listbox2.curselection()
for index in selected:
value = listbox2.get(index)
listbox1.insert(tk.END, value)
for index in reversed(selected):
listbox2.delete(index)
def move_all_right():
items = listbox1.get(0, tk.END)
for item in items:
listbox2.insert(tk.END, item)
listbox1.delete(0, tk.END)
def move_all_left():
items = listbox2.get(0, tk.END)
for item in items:
listbox1.insert(tk.END, item)
listbox2.delete(0, tk.END)
# 创建窗口
window = tk.Tk()
window.title("选课系统")
# 创建左侧列表框
listbox1 = tk.Listbox(window, selectmode=tk.MULTIPLE)
listbox1.pack(side=tk.LEFT)
# 添加课程名到左侧列表框
courses = ["Flash动画设计", "数据库原理", "大数据应用", "Java程序设计", "c#程序设计"，"网站开发","计算机导论","数据结构"]
for course in courses:
listbox1.insert(tk.END, course)
# 创建按钮框架
button_frame = tk.Frame(window)
button_frame.pack(side=tk.LEFT, padx=10)
# 创建右移按钮
button_right = tk.Button(button_frame, text="〉", command=move_right)
button_right.pack(pady=10)
# 创建左移按钮
button_left = tk.Button(button_frame, text="〈", command=move_left)
button_left.pack(pady=10)
# 创建右移全部按钮
button_all_right = tk.Button(button_frame, text="》", command=move_all_right)
button_all_right.pack(pady=10)
# 创建左移全部按钮
button_all_left = tk.Button(button_frame, text="《", command=move_all_left)
button_all_left.pack(pady=10)
# 创建右侧列表框
listbox2 = tk.Listbox(window, selectmode=tk.MULTIPLE)
listbox2.pack(side=tk.LEFT)
# 运行窗口主循环
window.mainloop()
正确答案
from tkinter import *
root = Tk()
def callbutton1(): #>选中一门
for i in listb.curselection():
listb2.insert(0,listb.get(i))
listb.delete(i)
def callbutton2(): #<取消一门
for i in listb2.curselection():
listb.insert(0,listb2.get(i))
listb2.delete(i)
def callbutton3(): #>>全部选中
for i in range(0,listb.size()):
listb2.insert(0,listb.get(i))
for i in range(listb.size()-1,-1,-1):
listb.delete(i)
def callbutton4(): #>>全部取消
for i in range(0,listb2.size()):
listb.insert(0,listb2.get(i))
for i in range(listb2.size()-1,-1,-1):
listb2.delete(i)
li = ['Flash动画设计','数据库原理','大数据应用','Java程序设计','C#程序设计','网站开发','计算机导论','数据结构']
listb = Listbox(root) #左边列表框
listb2 = Listbox(root) #右边列表框
for item in li:
listb.insert(0,item)
listb.grid(row=0,column=0,rowspan=4)
b1 = Button (root,text = '>', command=callbutton1, width=20)
b2 = Button (root,text = '>>', command=callbutton3, width=20)
b3 = Button (root,text = '<', command=callbutton2, width=20)
b4 = Button (root,text = '<<', command=callbutton4, width=20)
b1.grid(row=0,column=1)
b2.grid(row=1,column=1)
b3.grid(row=2,column=1)
b4.grid(row=3,column=1)
listb2.grid(row=0,column=2,rowspan=4)
root.mainloop()
+ 1.0 分
3 . 简答题 中等 3分
设计一个电子标题板。 要求：（1）实现字幕从右向左循环滚动。（2）单击“开始”按钮，字幕开始滚动，单击“暂停”按钮，字幕停止滚动。
回答正确
from tkinter import *
from tkinter.messagebox import showinfo
# 创建电子标题板窗口
root = Tk()
root.title("电子标题板")
# 初始化标题列表和当前标题索引
titles = ["欢迎来到电子标题板", "这是一个示例程序", "希望你喜欢"]
current_title_index = 0
# 创建标题滚动标签
title_label = Label(root, text="", font=("Arial", 18, "bold"), width=30)
title_label.pack()
# 标题滚动函数
def scroll_title():
global current_title_index
# 更新标题标签文本
title_label.config(text=titles[current_title_index])
# 循环更新标题索引
current_title_index = (current_title_index + 1) % len(titles)
# 1秒后继续滚动标题
root.after(1000, scroll_title)
# 创建开始和暂停按钮
start_button = Button(root, text="开始", command=scroll_title)
start_button.pack(side=LEFT, padx=10, pady=10)
pause_button = Button(root, text="暂停", command=root.after_cancel)
pause_button.pack(side=LEFT, padx=10, pady=10)
root.mainloop()
正确答案
略
+ 1.0 分
4 . 简答题 中等 3分
设计一个倒计时程序，应用程序界面自己设计。
回答正确
from tkinter import *
from tkinter.messagebox import showinfo
# 创建倒计时窗口
root = Tk()
root.title("倒计时程序")
# 初始化倒计时时间
time_remaining = 0
def start_countdown():
global time_remaining
# 获取用户输入的倒计时时间
try:
time_remaining = int(entry.get())
if time_remaining <= 0:
raise ValueError
except ValueError:
showinfo("错误", "请输入一个正整数作为倒计时时间！")
return
# 禁用输入框和开始按钮
entry.config(state=DISABLED)
start_button.config(state=DISABLED)
# 开始倒计时
countdown()
def countdown():
global time_remaining
# 更新倒计时显示
label.config(text=f"剩余时间: {time_remaining} 秒")
if time_remaining > 0:
# 倒计时减1
time_remaining -= 1
# 1秒后继续倒计时
root.after(1000, countdown)
else:
# 倒计时结束，弹出提示对话框
showinfo("倒计时结束", "时间到！")
# 重置倒计时时间和界面状态
time_remaining = 0
label.config(text="剩余时间: 0 秒")
entry.config(state=NORMAL)
start_button.config(state=NORMAL)
# 创建界面元素
label = Label(root, text="请输入倒计时时间（秒）：")
label.pack()
entry = Entry(root)
entry.pack()
start_button = Button(root, text="开始倒计时", command=start_countdown)
start_button.pack()
root.mainloop()
正确答案
略
+ 1.0 分
5 . 简答题 中等 3分
设计一个程序，用两个文本框输入数值数据，用列表框存放“＋、－、×、÷、幂次方、余数”。用户先输入两个操作数，再从列表框中选择一种运算，即可在标签中显示出计算结果。 实现简单加减乘除程序。使用两个单行文本框输入数字，使用列表框选择运算。
回答正确
import tkinter as tk
def calculate():
operand1 = float(entry1.get())
operand2 = float(entry2.get())
operator = listbox.get(listbox.curselection())
if operator == '加':
result = operand1 + operand2
elif operator == '减':
result = operand1 - operand2
elif operator == '乘':
result = operand1 * operand2
elif operator == '除':
result = operand1 / operand2
label.config(text="计算结果：{}".format(result))
# 创建窗口
window = tk.Tk()
window.title("简单计算器")
# 创建文本框和标签
entry1 = tk.Entry(window)
entry1.pack()
entry2 = tk.Entry(window)
entry2.pack()
label = tk.Label(window, text="计算结果：")
label.pack()
# 创建列表框
listbox = tk.Listbox(window)
listbox.insert(0, '加')
listbox.insert(1, '减")
listbox.insert(2, '乘')
listbox.insert(3, '除')
listbox.pack()
# 创建计算按钮
button = tk.Button(window, text="计算", command=calculate)
button.pack()
# 运行窗口主循环
window.mainloop()
正确答案
from tkinter import * import tkinter as tk root = Tk() m = StringVar() def callbutton2(): a=float(num1.get()) b=float(num2.get()) if k=='加': print(a+b) result["text"]=str(a+b) #result.config(text=str(a+b)) if k=='减': print(a-b) result["text"]=str(a-b) if k=='乘': print(a*b) result["text"]=str(a*b) if k=='除': print(a*b) result["text"]=str(a/b) root.title("使用Listbox组件的例子") #设置窗口标题 lab1=Label(root,text = '请输入第1个数',width=20) lab1.pack() num1 = tk.Entry(root)#Entry组件 num1.pack() lab2=Label(root,text = '请输入第2个数',width=20) lab2.pack() num2 = tk.Entry(root)#Entry组件 num2.pack() lb = Listbox(root, listvariable =m) #将一字符串与Listbox的值绑定 lb.insert(END,'加') lb.insert(END,'减') lb.insert(END,'乘') lb.insert(END,'除') lb.pack() b2 = Button (root,text = '计算', command=callbutton2, width=20)#创建Button组件 b2.pack()#显示Button组件 result=Label(root,text = '结果',width=6) result.pack() root.mainloop()
+ 1.0 分
6 . 简答题 中等 3分
编写选课程序。左侧列表框显示学生可以选择的课程名，右侧列表框显示学生已经选择的课程名，通过4个按钮在两个列表框中移动数据项。通过“〉”、“〈”按钮移动一门课程，通过“》”、“《”按钮移动全部课程。程序运行界面见图7-42所示。
回答正确
import tkinter as tk
def move_right():
selected = listbox1.curselection()
for index in selected:
value = listbox1.get(index)
listbox2.insert(tk.END, value)
for index in reversed(selected):
listbox1.delete(index)
def move_left():
selected = listbox2.curselection()
for index in selected:
value = listbox2.get(index)
listbox1.insert(tk.END, value)
for index in reversed(selected):
listbox2.delete(index)
def move_all_right():
items = listbox1.get(0, tk.END)
for item in items:
listbox2.insert(tk.END, item)
listbox1.delete(0, tk.END)
def move_all_left():
items = listbox2.get(0, tk.END)
for item in items:
listbox1.insert(tk.END, item)
listbox2.delete(0, tk.END)
# 创建窗口
window = tk.Tk()
window.title("选课系统")
# 创建左侧列表框
listbox1 = tk.Listbox(window, selectmode=tk.MULTIPLE)
listbox1.pack(side=tk.LEFT)
# 添加课程名到左侧列表框
courses = ["Flash动画设计", "数据库原理", "大数据应用", "Java程序设计", "c#程序设计"，"网站开发","计算机导论","数据结构"]
for course in courses:
listbox1.insert(tk.END, course)
# 创建按钮框架
button_frame = tk.Frame(window)
button_frame.pack(side=tk.LEFT, padx=10)
# 创建右移按钮
button_right = tk.Button(button_frame, text="〉", command=move_right)
button_right.pack(pady=10)
# 创建左移按钮
button_left = tk.Button(button_frame, text="〈", command=move_left)
button_left.pack(pady=10)
# 创建右移全部按钮
button_all_right = tk.Button(button_frame, text="》", command=move_all_right)
button_all_right.pack(pady=10)
# 创建左移全部按钮
button_all_left = tk.Button(button_frame, text="《", command=move_all_left)
button_all_left.pack(pady=10)
# 创建右侧列表框
listbox2 = tk.Listbox(window, selectmode=tk.MULTIPLE)
listbox2.pack(side=tk.LEFT)
# 运行窗口主循环
window.mainloop()
正确答案
from tkinter import * root = Tk() def callbutton1(): #>选中一门 for i in listb.curselection(): listb2.insert(0,listb.get(i)) listb.delete(i) def callbutton2(): #<取消一门 for i in listb2.curselection(): listb.insert(0,listb2.get(i)) listb2.delete(i) def callbutton3(): #>>全部选中 for i in range(0,listb.size()): listb2.insert(0,listb.get(i)) for i in range(listb.size()-1,-1,-1): listb.delete(i) def callbutton4(): #>>全部取消 for i in range(0,listb2.size()): listb.insert(0,listb2.get(i)) for i in range(listb2.size()-1,-1,-1): listb2.delete(i) li = ['Flash动画设计','数据库原理','大数据应用','Java程序设计','C#程序设计','网站开发','计算机导论','数据结构'] listb = Listbox(root) #左边列表框 listb2 = Listbox(root) #右边列表框 for item in li: listb.insert(0,item) listb.grid(row=0,column=0,rowspan=4) b1 = Button (root,text = '>', command=callbutton1, width=20) b2 = Button (root,text = '>>', command=callbutton3, width=20) b3 = Button (root,text = '<', command=callbutton2, width=20) b4 = Button (root,text = '<<', command=callbutton4, width=20) b1.grid(row=0,column=1) b2.grid(row=1,column=1) b3.grid(row=2,column=1) b4.grid(row=3,column=1) listb2.grid(row=0,column=2,rowspan=4) root.mainloop()
+ 1.0 分
7 . 简答题 中等 3分
设计井字棋游戏程序。游戏是一个有 3*3 方格的棋盘。双方各执一种颜色棋子，在规定的方格内轮流布棋。如果一方横竖斜方向连接成3子则胜利。
回答正确
from tkinter import *
from tkinter.messagebox import showinfo
# 创建游戏窗口
root = Tk()
root.title("井字棋游戏")
# 初始化游戏状态和当前玩家
board = [['' for _ in range(3)] for _ in range(3)]
current_player = 'X'
def play(row, col):
global current_player
# 检查该位置是否已经被占据
if board[row][col] != '':
showinfo("提示", "该位置已经被占据，请选择其他位置！")
return
# 在该位置放置当前玩家的棋子
board[row][col] = current_player
button = buttons[row][col]
button.config(text=current_player)
# 检查游戏是否结束
if check_winner():
showinfo("游戏结束", f"恭喜 {current_player} 获胜！")
reset_game()
elif check_draw():
showinfo("游戏结束", "平局！")
reset_game()
else:
# 切换玩家
current_player = 'O' if current_player == 'X' else 'X'
label.config(text=f"当前玩家: {current_player}")
def check_winner():
# 检查横向、纵向和对角线是否有连成3子的情况
for i in range(3):
if board[i][0] == board[i][1] == board[i][2] != '':
return True
if board[0][i] == board[1][i] == board[2][i] != '':
return True
if board[0][0] == board[1][1] == board[2][2] != '':
return True
if board[0][2] == board[1][1] == board[2][0] != '':
return True
return False
def check_draw():
# 检查是否达到平局
for row in board:
for cell in row:
if cell == '':
return False
return True
def reset_game():
# 重置游戏状态和按钮文本
global current_player, board
board = [['' for _ in range(3)] for _ in range(3)]
current_player = 'X'
label.config(text=f"当前玩家: {current_player}")
for i in range(3):
for j in range(3):
buttons[i][j].config(text='')
# 创建游戏界面
buttons = []
for i in range(3):
button_row = []
for j in range(3):
button = Button(root, text='', width=10, height=5,
command=lambda row=i, col=j: play(row, col))
button.grid(row=i, column=j)
button_row.append(button)
buttons.append(button_row)
label = Label(root, text=f"当前玩家: {current_player}", font=("Arial", 12, "bold"))
label.grid(row=3, column=0, columnspan=3)
reset_button = Button(root, text="重新开始", command=reset_game)
reset_button.grid(row=4, column=0, columnspan=3)
root.mainloop()
正确答案
略
+ 1.0 分
8 . 简答题 中等 3分
设计一个单选题考试程序。
回答正确
from tkinter import *
from tkinter.messagebox import showinfo
# 定义题目和答案
questions = [
{
"question": "1. 以下哪个是Python的标准GUI库？",
"choices": ["A. Tkinter", "B. PyQt", "C. wxPython", "D. Kivy"],
"answer": "A"
},
{
"question": "2. 在Python中，如何定义一个函数？",
"choices": ["A. def", "B. function", "C. define", "D. fun"],
"answer": "A"
},
{
"question": "3. Python中的列表可以包含不同类型的元素吗？",
"choices": ["A. 是", "B. 否"],
"answer": "A"
}
]
def submit():
# 计算得分
score = 0
for i, question in enumerate(questions):
answer = question["answer"]
user_answer = var_list[i].get()
if user_answer == answer:
score += 1
# 显示得分信息
message = f"你的得分是：{score}/{len(questions)}"
showinfo("考试结果", message)
root = Tk()
# 创建题目和选项
labels = []
var_list = []
for question in questions:
label = Label(root, text=question["question"])
label.pack(anchor=W)
labels.append(label)
var = StringVar()
for choice in question["choices"]:
radio_button = Radiobutton(root, text=choice, variable=var, value=choice.split(".")[0])
radio_button.pack(anchor=W)
var_list.append(var)
# 创建提交按钮
submit_button = Button(root, text="提交", command=submit)
submit_button.pack()
root.mainloop()
正确答案
略
+ 0.0 分
9 . 填空题 简单 3分
Python的标准GUI库tkinter由若干的模块组成：_________、__________和_________等。（注意：英文区分大小写）
回答错误
tkinter、tkinter.ttk、tkinter.messagebox
正确答案
_tkinter、tkinter、tkinter.constants
tkinter由若干的模块组成：_tkinter、tkinter和tkinter.constants等。
+ 0.0 分
10 . 填空题 简单 3分
Python图形用户界面程序一般包含一个顶层窗口，也称_________或_________。
回答错误
主窗口、根窗口
正确答案
根窗口、主窗口
应用程序主窗口也称根窗口、顶层窗口。
+ 3.0 分
11 . 填空题 简单 3分
tkinter提供了三种不同的几何布局管理类：_________、_________和_________，用于组织和管理在父组件中子配件的布局方式。（注意：英文区分大小写）
回答正确
Pack、Grid、Place
正确答案
pack、grid、place
tkinter提供了三种不同的几何布局管理类：pack、grid和place。
+ 3.0 分
12 . 填空题 简单 3分
通过组件的_________和_________选项，可以设置组件的宽度和高度。（注意：英文区分大小写）
回答正确
width、height
正确答案
width、height
无。
+ 3.0 分
13 . 填空题 简单 3分
通过组件的______________选项，可以设置其显示的文本的字体。（注意：英文区分大小写）
回答正确
font
正确答案
font
无。
+ 3.0 分
14 . 填空题 简单 3分
通过组件的______________选项，可以设置内容停靠位置。（注意：英文区分大小写）
回答正确
anchor
正确答案
anchor
pack方法提供的anchor选项设置停靠对齐方式，对应于东南西北中以及四个角。
+ 3.0 分
15 . 填空题 简单 3分
通过组件的______________选项，可以设置鼠标经过组件时的光标形状。（注意：英文区分大小写）
回答正确
cursor
正确答案
cursor
无。
+ 3.0 分
16 . 填空题 简单 3分
通过组件的_________选项，可以设置其显示的内容。通过_________选项，可指定多少单位后开始换行，即显示多行；通过_________选项，可指定多行的对齐方式。（注意：英文区分大小写）
回答正确
text、wraplength、justify
正确答案
text、wraplength、justify
无。
+ 3.0 分
17 . 填空题 简单 3分
通过组件的_________选项，可以设置其显示的位图。自定义位图为_________格式的文件。（注意：英文区分大小写）
回答正确
bitmap、.xbm
正确答案
bitmap、.xbm
无。
+ 3.0 分
18 . 填空题 简单 3分
通过组件的______________选项，可以设置其显示的图像。（注意：英文区分大小写）
回答正确
image
正确答案
image
无。
+ 3.0 分
19 . 填空题 简单 3分
通过组件的______________选项，可以设置其同时显示文本和位图/图像。（注意：英文区分大小写）
回答正确
compound
正确答案
compound
无。
+ 1.5 分
20 . 填空题 简单 3分
通过组件的_________选项，可以设置其3D显示样式。通过_________选项，可以设置其鼠标经过时的3D显示样式。（注意：英文区分大小写）
回答正确
relief、active relief
正确答案
relief、overrelief
无。
+ 0.0 分
21 . 填空题 简单 3分
通过组件的_________或_________选项，可以设置其边框宽度。（注意：英文区分大小写）
回答错误
borderwidth或bd
正确答案
bd
无。
+ 3.0 分
22 . 填空题 简单 3分
通过组件的_________和_________选项，可以设置其显示内容与边框之间的填充宽度和高度。（注意：英文区分大小写）
回答正确
padx、pady
正确答案
padx、pady
无。
+ 3.0 分
23 . 填空题 简单 3分
通过组件的______________选项，可以设置其启用或禁用状态。（注意：英文区分大小写）
回答正确
state
正确答案
state
无。
+ 0.0 分
24 . 填空题 简单 3分
通过组件的______________选项，可以设置组件显示文本第几个字符加下划线。（注意：英文区分大小写）
回答错误
show
正确答案
underline
无。
+ 0.0 分
25 . 填空题 简单 3分
通过组件的______________选项，可以绑定StringVar对象到组件。（注意：英文区分大小写）
回答错误
variable
正确答案
textvariable
无。
+ 3.0 分
26 . 填空题 简单 3分
______________控件用于选择同一组单选按钮中的一个单选按钮（不能同时选定多个），可显示文本，也可显示图像。（注意：英文区分大小写）
回答正确
Radiobutton
正确答案
Radiobutton [或者]单选按钮
Radiobutton（单选按钮）控件用于选择同一组单选按钮中的一个单选按钮（不能同时选定多个）。Radiobutton可以显示文本，也可以显示图像。
+ 3.0 分
27 . 填空题 简单 3分
______________控件用于选择一项或多项选项（可以同时选定多个），可显示文本，也可显示图像。（注意：英文区分大小写）
回答正确
Checkbutton
正确答案
Checkbutton [或者]复选框
Checkbutton（复选框）控件用于选择一项或多项选项（可以同时选定多个）。Checkbutton可显示文本，也可显示图像。
+ 3.0 分
28 . 填空题 简单 3分
______________用于显示对象列表，并且允许用户选择一个或多个项。（注意：英文区分大小写）
回答正确
Listbox
正确答案
Listbox [或者]列表框
Listbox（列表框）用于显示对象列表，并且允许用户选择一个或多个项。
+ 3.0 分
29 . 填空题 简单 3分
______________允许用户选择一个项的列表框（在用户请求时显示）。用户单击下拉按钮可显示列表框，选择的内容会显示在顶部文本框中。（注意：英文区分大小写）
回答正确
OptionMenu
正确答案
OptionMenu [或者]选择项
OptionMenu（选择项）允许用户选择一个项的列表框（在用户请求时显示）。用户单击下拉按钮可以显示列表框，选择的内容会显示在顶部文本框中。
+ 3.0 分
30 . 填空题 简单 3分
______________控件用于在有界区间内，通过移动滑块来选择值。（注意：英文区分大小写）
回答正确
Scale
正确答案
Scale [或者]移动滑块
Scale（移动滑块）控件用于在有界区间内，通过移动滑块来选择值。
+ 0.0 分
31 . 填空题 简单 2分
tkinter模块中的子模块_________、_________、_________和_________，包括通用的预定义对话框；用户也可以通过继承TopLevel创建自定义对话框。（注意：英文区分大小写）
回答错误
simpledialog、messagebox、dialog、Toplevel
正确答案
messagebox、filedialog、colorchooser、simpledialog
tkinter模块中的子模块messagebox、filedialog、colorchooser、simpledialog，包括一些通用的预定义对话框；用户也可以通过继承TopLevel创建自定义对话框。
+ 2.0 分
32 . 填空题 简单 2分
tkinter模块中的子模块______________用于实现通用消息对话框的功能。（注意：英文区分大小写）
回答正确
messagebox
正确答案
messagebox
模块tkinter的子模块messagebox包含若干用于打开消息对话框的函数。
+ 2.0 分
33 . 填空题 简单 2分
tkinter模块中的子模块______________用于实现文件对话框的功能。（注意：英文区分大小写）
回答正确
filedialog
正确答案
filedialog
模块tkinter的子模块filedialog包含若干用于打开文件对话框的函数。
+ 2.0 分
34 . 填空题 简单 2分
tkinter模块中的子模块______________用于实现颜色选择对话框的功能。（注意：英文区分大小写）
回答正确
colorchooser
正确答案
colorchooser
模块tkinter的子模块colorchooser包含用于打开颜色选择对话框的函数。
+ 2.0 分
35 . 填空题 简单 2分
tkinter模块中的子模块______________用于实现输入对话框的功能。（注意：英文区分大小写）
回答正确
simpledialog
正确答案
simpledialog
模块tkinter的子模块simpledialog中包含若干用于打开输入对话框的函数。
第8章平时作业
总分：100分
得分：62.0分
+ 9.0 分
1 . 单选题 简单 9分
在DBMS中，如果一个国家只能有一个总统，而一个总统只能在一个国家任职，则国家和总统为（ ）的联系。
A.一对一
B.一对多
C.多对多
D.多对一
回答正确
A
正确答案
A
+ 9.0 分
2 . 单选题 简单 9分
在DBMS中，如果一个部门有多名员工，而一名员工只能在一个部门工作，则部门和员工为（ ）的联系。
A.一对一
B.一对多
C.多对多
D.多对一
回答正确
B
正确答案
B
+ 9.0 分
3 . 单选题 简单 9分
在DBMS中，如果一名学生可以选修多门课程，而一门课程可以有多名选修的学生，则学生和课程是（ ）的联系。
A.一对一
B.一对多
C.多对多
D.多对一
回答正确
C
正确答案
C
+ 9.0 分
4 . 单选题 简单 9分
在DBMS中，假设有表示学生选课的三张表，其中学生S（学号，姓名，性别，年龄，身份证号），课程C（课号，课名），选课SC（学号，课号，成绩），则选课表SC的关键字（键或码）为（ ）。
A.学号，课号
B.学号，成绩
C.课号，成绩
D.学号，姓名，成绩
回答正确
A
正确答案
A
+ 8.0 分
5 . 单选题 简单 8分
在DBMS中，假设有表示公司和职员及工作的三张表，职员可在多家公司兼职。其中公司C（公司号，公司名，地址，注册资本，法人代表，员工数），职员S（职员号，姓名，性别，年龄，学历），工作W（公司号，职员号，工资），则工作表W的关键字（键或码）为（ ）。
A.公司号，职员号，工资
B.职员号
C.职员号，工资
D.公司号，职员号
回答正确
D
正确答案
D
+ 0.0 分
6 . 填空题 简单 8分
数据库管理系统的主要功能包括___________、___________和___________。
回答错误
数据的存储和管理、数据的检索和更新、数据的备份和恢复
正确答案
数据定义功能、数据操作功能、数据库的管理和维护
+ 0.0 分
7 . 填空题 简单 8分
现实世界的数据可以抽象为___________，也称为___________。
回答错误
实体、关系模型或关系表
正确答案
概念模型（Conceptual Model）[或者]概念模型[或者]Conceptual Model、信息模型
+ 8.0 分
8 . 填空题 简单 8分
实体是指现实世界中具有一定特征或属性并与其它实体有联系的对象，在关系模型中实体通常是以________的形式来表现。
回答正确
表
正确答案
表[或者]数据表
+ 8.0 分
9 . 填空题 简单 8分
SQLite是遵守________的关系数据库管理系统。
回答正确
ACID
正确答案
ACID [或者]原子性Atomicity、一致性Consistency、隔离性Isolation、持久性Durability[或者]原子性、一致性、隔离性、持久性[或者] Atomicity、Consistency、Isolation、Durability
+ 0.0 分
10 . 填空题 简单 8分
在E-R图中用来表示实体联系的图形是________。
回答错误
菱形
正确答案
矩形框
+ 1.0 分
11 . 简答题 困难 8分
题目：创建一个数据库stuinfo，并在其中创建数据库表student，表中包含stuid(学号)、stuname（姓名）、birthday（出生日期）、sex（性别）、address（家庭地址）、rxrq（入学日期）6列，其中stuid设为主键，并添加5条记录。 将所有记录的rxrq属性更新为2017-9-1。 查询性别为“女”的所有学生的stuname和address字段值。
回答正确
import sqlite3
# 连接到数据库（如果不存在，则创建）
conn = sqlite3.connect('stuinfo.db')
# 创建一个游标对象
cursor = conn.cursor()
# 创建表
cursor.execute('''
CREATE TABLE IF NOT EXISTS student (
stuid INTEGER PRIMARY KEY,
stuname TEXT,
birthday TEXT,
sex TEXT,
address TEXT,
rxrq TEXT
)
''')
# 添加5条记录
data = [
(1, '张三', '1998-05-15', '男', '北京', '2015-09-01'),
(2, '李四', '1999-02-28', '女', '上海', '2016-09-01'),
(3, '王五', '1997-11-20', '男', '广州', '2017-09-01'),
(4, '赵六', '2000-08-12', '女', '深圳', '2018-09-01'),
(5, '钱七', '1996-04-30', '男', '成都', '2019-09-01')
]
cursor.executemany('INSERT INTO student (stuid, stuname, birthday, sex, address, rxrq) VALUES (?, ?, ?, ?, ?, ?)', data)
# 更新所有记录的rxrq属性为2017-9-1
cursor.execute('UPDATE student SET rxrq="2017-09-01"')
# 查询性别为“女”的所有学生的stuname和address字段值
cursor.execute('SELECT stuname, address FROM student WHERE sex="女"')
female_students = cursor.fetchall()
print(female_students)
# 提交更改
conn.commit()
# 关闭连接
conn.close()
正确答案
import sqlite3
con=sqlite3.connect("sales.db")
cur=con.cursor()
cur.execute("DROP table book")#第一次运行时这句删掉，之后再运行加上。
con.execute("create table book(stuid primary key,stuname varchar(20),birthday integer(20),sex varchar(20),address varchar(20),rxrq integer(20))")
cur.execute("insert into book(stuid,stuname,birthday,sex,address,rxrq) values (1,'张一',19980301,'男','黄河路1号',20160901)")
cur.execute("insert into book(stuid,stuname,birthday,sex,address,rxrq) values (2,'张二',19980302,'女','黄河路2号',20160902)")
cur.execute("insert into book(stuid,stuname,birthday,sex,address,rxrq) values (3,'张三',19980303,'男','黄河路3号',20160903)")
cur.execute("insert into book(stuid,stuname,birthday,sex,address,rxrq) values (4,'张四',19980304,'男','黄河路4号',20160904)")
cur.execute("insert into book(stuid,stuname,birthday,sex,address,rxrq) values (5,'张五',19980305,'女','黄河路5号',20160905)")
print('记录计入完成')
cur.execute('select * from book')
values = cur.fetchall()
for row in values:
print(row)
print('记录更新完成')
cur.execute("Update book set rxrq=20170901")
cur.execute('select * from book')
values = cur.fetchall()
for row in values:
print(row)
print('性别为女的名字和地址信息为：')
cur.execute('select stuname,sex,address from book')
values = cur.fetchall()
for row in values:
if row[1]=='女':
print(row[0],row[2])
cur.close()
con.commit()
con.close()
+ 1.0 分
12 . 简答题 中等 8分
创建一个数据库stuinfo，并在其中创建数据库表student，表中包含stuid(学号)、stuname（姓名）、birthday（出生日期）、sex（性别）、address（家庭地址）、rxrq（入学日期）6列，其中stuid设为主键，并添加5条记录。 将所有记录的rxrq属性更新为2017-9-1。 查询性别为“女”的所有学生的stuname和address字段值。
回答正确
import sqlite3
# 连接到数据库（如果不存在，则创建）
conn = sqlite3.connect('stuinfo.db')
# 创建一个游标对象
cursor = conn.cursor()
# 创建表
cursor.execute('''
CREATE TABLE IF NOT EXISTS student (
stuid INTEGER PRIMARY KEY,
stuname TEXT,
birthday TEXT,
sex TEXT,
address TEXT,
rxrq TEXT
)
''')
# 添加5条记录
records = [
(1, '张三', '1998-05-15', '男', '北京', '2015-09-01'),
(2, '李四', '1999-02-28', '女', '上海', '2016-09-01'),
(3, '王五', '1997-11-20', '男', '广州', '2017-09-01'),
(4, '赵六', '2000-08-12', '女', '深圳', '2018-09-01'),
(5, '钱七', '1996-04-30', '男', '成都', '2019-09-01')
]
cursor.executemany('INSERT INTO student (stuid, stuname, birthday, sex, address, rxrq) VALUES (?, ?, ?, ?, ?, ?)', records)
# 更新所有记录的rxrq属性为2017-9-1
cursor.execute('UPDATE student SET rxrq="2017-09-01"')
# 查询性别为“女”的所有学生的stuname和address字段值
cursor.execute('SELECT stuname, address FROM student WHERE sex="女"')
female_students = cursor.fetchall()
print(female_students)
# 提交更改
conn.commit()
# 关闭连接
conn.close()
正确答案
代码： import sqlite3 con=sqlite3.connect("sales.db") cur=con.cursor() cur.execute("DROP table book")#第一次运行时这句删掉，之后再运行加上。 con.execute("create table book(stuid primary key,stuname varchar(20),birthday integer(20),sex varchar(20),address varchar(20),rxrq integer(20))") cur.execute("insert into book(stuid,stuname,birthday,sex,address,rxrq) values (1,'张一',19980301,'男','黄河路1号',20160901)") cur.execute("insert into book(stuid,stuname,birthday,sex,address,rxrq) values (2,'张二',19980302,'女','黄河路2号',20160902)") cur.execute("insert into book(stuid,stuname,birthday,sex,address,rxrq) values (3,'张三',19980303,'男','黄河路3号',20160903)") cur.execute("insert into book(stuid,stuname,birthday,sex,address,rxrq) values (4,'张四',19980304,'男','黄河路4号',20160904)") cur.execute("insert into book(stuid,stuname,birthday,sex,address,rxrq) values (5,'张五',19980305,'女','黄河路5号',20160905)") print('记录计入完成') cur.execute('select * from book') values = cur.fetchall() for row in values: print(row) print('记录更新完成') cur.execute("Update book set rxrq=20170901") cur.execute('select * from book') values = cur.fetchall() for row in values: print(row) print('性别为女的名字和地址信息为：') cur.execute('select stuname,sex,address from book') values = cur.fetchall() for row in values: if row[1]=='女': print(row[0],row[2]) cur.close() con.commit() con.clo
第9章平时作业
总分：100分
得分：55.0分
+ 1.0 分
1 . 简答题 中等 4分
TCP协议和UDP协议的主要区别是什么？
回答正确
连接的建立：
TCP 是面向连接的协议，这意味着在数据传输开始之前，它需要在发送方和接收方之间建立一个连接。这个过程通常涉及一个被称为“三次握手”的步骤。
UDP 是无连接的协议，它不需要预先建立连接，因此可以直接发送数据包。
可靠性：
TCP 提供了可靠的数据传输服务，确保数据包按顺序、完整无误地到达接收方。如果发生数据丢失或错误，TCP 会进行重传。
UDP 不提供可靠性保证，数据包可能会丢失或乱序到达，且UDP不提供重传机制。
数据流控制：
TCP 使用流量控制和拥塞控制机制来调整数据传输速率，以避免网络拥塞。
UDP 不进行流量控制或拥塞控制，发送方可以以任何速率发送数据。
传输速度和效率：
TCP 由于其可靠性和控制机制，通常比UDP慢，尤其是在网络条件不理想的情况下。
UDP 由于缺乏复杂的控制机制，具有较低的延迟，适用于对实时性要求高的应用，如视频会议、在线游戏等。
报文结构：
TCP 报文头部较大，至少20字节，包含多种参数和状态信息，用于确保数据的可靠传输。
UDP 报文头部较小，只有8字节，包括源端口、目的端口、长度和校验和字段。
使用场景：
TCP 通常用于需要高可靠性的应用，如网页浏览、文件传输、电子邮件等。
UDP 通常用于对实时性要求较高、可以容忍一定丢包的应用，如流媒体、VoIP（语音通信）、在线游戏等。
正确答案
TCP协议建立在IP协议之上，负责在两台计算机之间建立可靠连接，保证数据包按顺序到达。TCP协议会通过握手建立连接，然后，对每个IP包编号，确保对方按顺序收到。如果包丢掉了，就自动重发。 UDP协议也建立在IP协议之上，但是UDP协议是面向无连接的通信协议，不保证数据包的顺利到达，不可靠传输。所以效率比TCP要高。 使用UDP协议时，不需要建立连接，只需要知道对方的IP地址和端口号，就可以直接发数据包。但是，能不能到达就不知道了。虽然用UDP传输数据不可靠，但它的优点是和TCP相比，速度快，对于不要求可靠到达的数据，就可以使用UDP协议。
+ 1.0 分
2 . 简答题 中等 4分
Socket有什么用途？
回答正确
数据交换：Socket 提供了一种机制，允许两个程序（无论是在同一台计算机上还是分布在网络上的不同计算机上）通过网络进行数据交换。
建立通信连接：在基于 TCP 的通信中，Socket 可以用来建立两个程序之间的连接，并保持这个连接直到双方完成通信。
监听网络请求：服务器端的 Socket 可以被设置为监听模式，等待并接受客户端的连接请求。
网络服务实现：Socket 是实现各种网络服务（如 HTTP 服务器、FTP 服务器、邮件服务器等）的基础，它们依赖于 Socket 来处理客户端和服务器之间的通信。
多种协议支持：虽然 Socket 最常与 TCP/IP 协议栈一起使用，但它也可以支持其他多种网络协议，为不同类型的网络通信提供灵活性。
异步通信：通过非阻塞式 Socket 或者使用特定的编程技术（如异步 I/O、事件驱动编程），可以实现异步通信，从而提高程序的性能和响应能力。
多播和广播：特定类型的 Socket 支持发送多播（组播）或广播消息，允许一个数据包被发送到多个接收者。
平台独立性：Socket API 在不同的操作系统平台上都有相应的实现，这使得基于 Socket 的网络程序可以更容易地移植到不同平台。
安全通信：结合加密技术（如 SSL/TLS），Socket 可以用来建立安全的连接，确保数据传输的安全性和隐私性。
网络调试工具：Socket 编程可以用来创建各种网络测试和调试工具，比如网络扫描器、协议分析器等。
正确答案
socket 用来写网络通讯程序的，简单来说在远程机器（服务器）和本地机器各建一个socket，然后即可进行连接通讯。 Socket非常类似于电话插座。以一个国家级电话网为例，电话的通话双方相当于相互通信的2个进程，区号是它的网络地址;分配给每个用户的电话号码相当于Socket号。任何用户在通话之前，首先要占有一部电话机，相当于申请一个Socket;同时要知道对方的号码，相当于对方有一个固定的Socket。然后向对方拨号呼叫，相当于发出连接请求(假如对方不在同一区内，还要拨对方区号，相当于给出网络地址)。假如对方在场并空闲(相当于通信的另一主机开机且可以接受连接请求)，拿起电话话筒，双方就可以正式通话，相当于连接成功。双方通话的过程，是一方向电话机发出信号和对方从电话机接收信号的过程，相当于向Socket发送数据和从socket接收数据。通话结束后，一方挂起电话机相当于关闭Socket，撤消连接。
+ 1.0 分
3 . 简答题 困难 4分
简单描述开发UDP程序的过程。
回答正确
创建 Socket：
首先，需要使用 socket 函数创建一个 UDP Socket。在这个过程中，你需要指定使用的协议族（例如，AF_INET 表示 IPv4），以及指定 Socket 类型为 SOCK_DGRAM 来表示这是一个 UDP Socket。
绑定地址和端口（对于服务器端）：
如果你正在编写一个服务器程序，你需要将创建的 Socket 绑定到一个地址和端口上，这样客户端就能知道如何连接到这个服务器。这可以通过 bind 函数来实现。
发送和接收数据：
对于 UDP 通信，你可以使用 sendto 和 recvfrom 函数来发送和接收数据。sendto 函数用于向指定的目标地址和端口发送数据，而 recvfrom 函数则用于从任意源接收数据，并且能够获取发送方的地址信息。
在客户端，通常会首先使用 sendto 发送数据到服务器，然后使用 recvfrom 等待服务器的响应。
在服务器端，通常会使用 recvfrom 等待接收客户端的消息，然后使用 sendto 向客户端发送响应。
关闭 Socket：
数据传输完成后，应该使用 close 函数来关闭 Socket，以释放系统资源。
正确答案
python udp是无连接，没有TCP的三次握手，错误重传机制，发的只管发，收的只管收，效率比TCP高，运用于对数据帧不高的地方，如视频，音频的传输。 一、实现过程: 服务器端过程如下: 1.建立UDP的SOCKET 2.绑定一个接口，让客户端连接 3.接受数据 客户端过程如下: 1.创建一个socket 2.收发数据报 二、代码实现 1.服务器端： import socket from time import ctime def udpServer(): buffer=2048 address=('127.0.0.1',8080) udpsock=socket.socket(socket.AF_INET,socket.SOCK_DGRAM) udpsock.bind(address) while True: #不断循环 print ('wait for message...') data,addr=udpsock.recvfrom(buffer) #接受数据 str='[%s]%s' %(ctime(),data.decode('utf-8')) udpsock.sendto(str.encode('utf-8'),addr) #发送数据 print ('...received from and retuned to:',addr) udpsock.close() if __name__=='__main__': udpServer() 2.客户端: import socket def udpClient(): address=('localhost',8080) udpClientSocket=socket.socket(socket.AF_INET,socket.SOCK_DGRAM) #创建socket while True: #不断循环 data= input('>') if not data: break udpClientSocket.sendto(data.encode('utf-8'),address) #发送数据 data,addr=udpClientSocket.recvfrom(2048) print (data.decode('utf-8')) udpClientSocket.close() if __name__=='__main__': udpClient() 运行结果： 服务器端： wait for message... ...received from and retuned to: ('127.0.0.1', 61957) wait for message... ...received from and retuned to: ('127.0.0.1', 61957) wait for message... 客户端: >中国 [Sat Mar 24 10:35:19 2018]中国 >hello [Sat Mar 24 10:35:29 2018]hello >
+ 2.0 分
4 . 简答题 困难 4分
编写获取本机IP的程序。
回答正确
import socket
# 获取本机计算机名称
hostname = socket.gethostname()
# 获取本机ip
ip_address = socket.gethostbyname(hostname)
print(f"Hostname: {hostname}")
print(f"IP Address: {ip_address}")
这个程序首先获取本机的主机名，然后通过 gethostbyname() 函数查询这个主机名对应的 IP 地址。
请注意，gethostbyname() 函数可能返回回环地址（127.0.0.1），特别是当你的计算机没有连接到任何网络时。如果你想要获取与外界通信的接口的 IP 地址，你可以通过建立一个临时的 Socket 连接到一个外部地址，然后获取这个 Socket 的本地端地址：
import socket
def get_ip():
try:
# 创建一个 UDP Socket
with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as s:
# 不需要发送数据，因此目标地址可以是任意的
s.connect(("8.8.8.8", 80))
# 获取本地 IP 地址
ip = s.getsockname()[0]
except Exception:
ip = "127.0.0.1" # 默认回环地址
return ip
print(f"IP Address: {get_ip()}")
正确答案
import socket
myname = socket.getfqdn(socket.gethostname( ))#获取本机电脑名
myaddr = socket.gethostbyname(myname)#获取本机ip
print(myname,myaddr)
import uuid
#python 获得本机MAC地址：
def get_mac_address():
mac=uuid.UUID(int = uuid.getnode()).hex[-12:]
return ":".join([mac[e:e+2] for e in range(0,11,2)])
print("本机MAC地址:",get_mac_address())
#方法二：
#利用 UDP 协议来实现的，生成一个UDP包，
#把自己的 IP 放如到 UDP 协议头中，然后从UDP包中获取本机的IP。
#封装成函数，方便 Python 的程序调用
import socket
def get_host_ip():
try:
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.connect(('8.8.8.8', 80)) #
ip = s.getsockname()[0]
finally:
s.close()
return ip
print( get_host_ip()) #'192.168.1.105'
+ 0.0 分
5 . 填空题 简单 4分
TCP/IP协议模型把TCP/IP协议族分成四个层次：_________、_________、_________和_________。
回答错误
应用层、传输层、网络互联层、网络接口层
正确答案
网络接口层、Internet层、传输层、应用层
TCP/IP协议，即传输控制协议/互连网协议，是一种网际互联通信协议，其目的在于通过它实现网际间各种异构网络和异种计算机的互联通信。
+ 4.0 分
6 . 填空题 简单 4分
Internet采用一种全局通用的地址格式，为网络中的每一台主机都分配一个唯一的地址，称为____________。
回答正确
IP地址
正确答案
IP地址
+ 4.0 分
7 . 填空题 简单 4分
Internet使用____________来管理计算机域名与IP地址的对应关系。（注意：英文区分大小写）
回答正确
DNS
正确答案
域名系统 [或者]Domain Name System [或者]DNS
+ 4.0 分
8 . 填空题 简单 4分
IP地址用来标识Internet上的主机，而位于Internet主机上的资源（如各种文档、图像等）则通过____________来标识。（注意：英文区分大小写）
回答正确
URL
正确答案
统一资源定位器 [或者]Uniform Resource Locator [或者]URL
URL（Uniform Resource Locator，统一资源定位器）是专为标识Internet网上资源位置而设的一种编址方式。。
+ 4.0 分
9 . 填空题 简单 4分
TCP/IP协议的传输层包含两个传输协议：面向连接的_________和非面向连接的_________。（注意：英文区分大小写）
回答正确
TCP、UDP
正确答案
TCP、UDP
+ 0.0 分
10 . 填空题 简单 4分
创建服务器端socket对象并绑定到IP地址后，可以使用_________和_________对象方法进行侦听和接收连接。（注意：英文区分大小写）
回答错误
listen()、accept()
正确答案
listen、accept
+ 0.0 分
11 . 填空题 简单 4分
客户机端socket对象通过____________方法尝试建立到服务器端socket对象的连接。（注意：英文区分大小写）
回答错误
connect()
正确答案
connect
+ 4.0 分
12 . 单选题 简单 4分
在Python多线程和并行计算相关的主要模块中，（ ）模块提供基于进程的并行功能。
A.multiprocessing
B.threading
C.concurrent
D.queue
回答正确
A
正确答案
A
+ 0.0 分
13 . 单选题 简单 4分
在Python多线程和并行计算相关的主要模块中，（ ）模块提供底层多线程API功能。
A._thread
B.threading
C.concurrent
D.queue
回答错误
B
正确答案
A
+ 4.0 分
14 . 单选题 简单 4分
在Python网络和进程间通信相关的主要模块中，（ ）模块提供底层网络接口功能。
A.asyncio
B.ssl
C.socket
D.signal
回答正确
C
正确答案
C
+ 4.0 分
15 . 单选题 简单 4分
在Python中运行以下程序产生的输出结果是（ ）。 import time t = time.gmtime() print(time.strftime("%Y-%m-%d %H:%M:%S",t))
A.系统当前的日期与时间
B.系统当前的日期
C.系统当前的时间
D.系统出错
回答正确
A
正确答案
A
+ 0.0 分
16 . 单选题 简单 4分
如果当前时间是2022年5月1日10点10分9秒，则如下Python代码的输出结果是（ ）。 import time print(time.strftime("%Y=%m-%d@%H>%M>%S", time.gmtime()))
A.2022=05-01@10>10>09
B.2022=5-1 10>10>9
C.True@True
D.2022=5-1@10>10>9
回答错误
D
正确答案
A
+ 4.0 分
17 . 单选题 简单 4分
执行如下Python代码后，描述错误的选项是（ ）。 import time print(time.time());time.sleep(5)
A.输出自1970年1月1日00:00:00 AM以来的秒数
B.time模块是Python的标准库
C.可以使用time.ctime()代替time.time()，显示为更具可读性的日期时间格式
D.time.sleep(5)推迟调用线程的运行，单位为毫秒
回答正确
D
正确答案
D
+ 0.0 分
18 . 填空题 简单 4分
使用time模块的____________函数可以获取当前系统的起始点。（注意：英文区分大小写）
回答错误
time.gmtime()
正确答案
getime
+ 0.0 分
19 . 填空题 简单 4分
time模块中的___________函数将字符串为struct_time对象；___________函数将struct_time对象格式化为字符串。（注意：英文区分大小写）
回答错误
time.strptime()、time.strftime()
正确答案
strptime()、strftime()
+ 0.0 分
20 . 填空题 简单 3分
Python中的____________模块包含用于处理时间的函数。（注意：英文区分大小写）
回答错误
datetime
正确答案
time
+ 3.0 分
21 . 单选题 简单 3分
Python语句print(type(lambda:None))的输出结果是（ ）。
A.<class 'NoneType'>
B.<class 'tuple'>
C.<class 'type'>
D.<class 'function'>
回答正确
D
正确答案
D
lambda是一种简便的、在同一行中定义函数的方法。lambda实际上生成一个函数对象，即匿名函数。
+ 3.0 分
22 . 单选题 简单 3分
Python语句序列“f = lambda x,y: x * y; f(12, 34)”的程序运行结果是（ ）。
A.12
B.22
C.56
D.408
回答正确
D
正确答案
D
lambda是一种简便的、在同一行中定义函数的方法。lambda实际上生成一个函数对象，即匿名函数。
+ 3.0 分
23 . 单选题 简单 3分
Python语句序列“f1=lambda x:x*2; f2= lambda x:x**2; print(f1(f2(2)))”的程序运行结果是（ ）。
A.2
B.4
C.6
D.8
回答正确
D
正确答案
D
lambda是一种简便的、在同一行中定义函数的方法。lambda实际上生成一个函数对象，即匿名函数。
+ 0.0 分
24 . 填空题 简单 3分
下列Python语句的输出结果是___________。 d = lambda p: p * 2; t = lambda p: p * 3 x = 2;x = d(x);x = t(x);x = d(x);print(x)
回答错误
12
正确答案
24
lambda是一种简便的、在同一行中定义函数的方法。lambda实际上生成一个函数对象，即匿名函数。
+ 3.0 分
25 . 填空题 简单 3分
下列Python语句的输出结果是___ ______、_________、_________。 i = map(lambda x: x**2, (1, 2, 3)) for t in i: print(t, end=' ')
回答正确
1、4、9
正确答案
1、4、9
lambda是一种简便的、在同一行中定义函数的方法。lambda实际上生成一个函数对象，即匿名函数。
+ 3.0 分
26 . 编程题 中等 3分
return语句求最大值
回答正确
编写程序，利用函数的return语句返回函数值，求若干数中的最大值。测试数据是求1、7、11、2、5中的最大值。
def max_num(*nums):
max_value = nums[0] # 假设第一个数是最大值
for num in nums:
if num > max_value:
max_value = num
return max_value
# 测试数据
nums = [1, 7, 11, 2, 5]
print( max_num(*nums))
正确答案
def my_max(a, b, *c): #求若干数中的最大值
max_value = a #假设第一个数为最大值
if max_value < b: #如果最大值小于b，则b为最大值
max_value = b
for n in c: #循环迭代c中每个元素n，如果最大值小于n，则n为最大值
if max_value < n:
max_value = n
return max_value #利用return语句返回最大值#测试代码print(my_max(1, 7, 11, 2, 5)) #求(1, 7, 11, 2, 5)中的最大值
求若干数中最大值的方法一般如下： （1）将最大值的初值设为一个比较小的数，或者取第一个数为最大值的初值。 （2）利用循环，将每个数与最大值比较，若此数大于最大值，则将此数设置为最大值。
+ 3.0 分
27 . 编程题 中等 3分
素数
回答正确
编写程序，先编制一个判断一个数是否为素数的函数，然后编写测试代码，判断并输出1~99中的素数。
def is_prime(num):
if num < 2:
return False
for i in range(2, int(num**0.5) + 1):
if num % i == 0:
return False
return True
# 测试1~99中的素数
for i in range(1, 100):
if is_prime(i):
print(i, end=" ")
正确答案
def is_prime(n):
if n < 2: return False #如果n小于2，返回False
i = 2
while i*i <= n:
#一旦n能够被2~ 中的任意整数整除，n就不是素数，返回False
if n % i == 0: return False
i += 1
return True#测试代码for i in range(100): #判断并输出1~99中的素数，以空格分隔
if is_prime(i):print(i, end=' ')
所谓素数（或称质数），是指除了1和该数本身，不能被任何整数整除的正整数。判断一个正整数n是否为素数，只要判断n可否被2~ 之中的任何一个整数整除，如果n不能被此范围中任何一个整数整除，n即为素数，否则n为合数。
第11章文本处理
总分：100分
得分：49.7分
+ 6.0 分
1 . 单选题 简单 6分
在Python文本处理相关的主要模块中，（ ）模块主要提供处理正则表达式的对象和函数。
A.re
B.string
C.textwrap
D.stringprep
回答正确
A
正确答案
A
+ 4.0 分
2 . 填空题 简单 6分
Python中文分词组件jieba支持三种分词模式，即_______、______和______。
回答正确
精准模式、全模式、搜索引擎模式
正确答案
精确模式、全模式、搜索引擎模式
+ 0.0 分
3 . 填空题 简单 6分
Python语句re.match('back', 'text.back')的执行结果是___________。
回答错误
一个匹配对象
正确答案
空
+ 6.0 分
4 . 填空题 简单 6分
Python语句re.findall("to", "Tom likes to swim too")的执行结果是___________。（注意：英文区分大小写）
回答正确
['to', 'to']
正确答案
['to', 'to']
+ 6.0 分
5 . 填空题 简单 6分
Python语句re.findall("bo[xy]", "The boy is sitting on the box")的执行结果是___________。（注意：英文区分大小写）
回答正确
['boy', 'box']
正确答案
['boy', 'box']
+ 0.0 分
6 . 填空题 简单 6分
中华人民共和国邮政编码由6位数字组成，使用重复限定符___________，表示数字字母重复6次。
回答错误
{6}
正确答案
\d{6}
+ 0.0 分
7 . 填空题 简单 6分
正则表达式引擎均支持不同的匹配模式，也称之为匹配选项，其中，__________使正则表达式对大小写不敏感，__________开启多行模式。（注意：英文区分大小写）
回答错误
re.I、re.M
正确答案
/i、/m
+ 0.0 分
8 . 填空题 简单 6分
Python语句re.sub('hard', 'easy', 'Python is hard to learn.')的执行结果是___________。（注意：英文区分大小写）
回答错误
Python is easy to learn.正确答案
'Python is easy to learn.'
+ 6.0 分
9 . 填空题 简单 6分
Python语句re.split('\W+', 'go, went, gone')的执行结果是___________。（注意：英文区分大小写）
回答正确
['go', 'went', 'gone']
正确答案
['go', 'went', 'gone']
+ 0.0 分
10 . 填空题 简单 6分
Python语句re.split('\d', 'a1b2c3')的执行结果是___________。（注意：英文区分大小写）
回答错误
['a', 'b', 'c']
正确答案
['a', 'b', 'c', '']
+ 0.0 分
11 . 填空题 简单 5分
下列Python语句的输出结果是_____。 import re; sum = 0; pattern = 'boy' if re.match(pattern, 'boy and girl'): sum += 1 if re.match(pattern, 'girl and boy'): sum += 2 if re.search(pattern, 'boy and girl'): sum += 3 if re.search(pattern, 'girl and boy'): sum += 4 print(sum)
回答错误
6
正确答案
8
注意，match函数从字符串头部开始匹配，而search函数在字符串任何位置匹配。
+ 1.7 分
12 . 填空题 简单 5分
下列Python语句的输出结果是__________、__________、__________。（注意：英文区分大小写） import re re.match("to", "Tom likes to swim too") re.search("to", "Tom likes to swim too"); re.findall("to", "Tom likes to swim too")
回答正确
None、<re.Match object; span=(8, 10), match='to'>、['to', 'to', 'too']
正确答案
None、<re.Match object; span=(10, 12), match='to'>、['to', 'to']
+ 0.0 分
13 . 填空题 简单 5分
下列Python语句的输出结果是_____。（注意：英文区分大小写） import re; m = re.search("to", "Tom likes to swim too") print(m.group(),m.span())
回答错误
to (8, 10)
正确答案
to (10, 12)
+ 0.0 分
14 . 填空题 简单 5分
以十三届全国人大四次会议报告中一句话“依靠创新推动实体经济高质量发展，培育壮大新动能。”作为字符串变量s，完善以下Python程序，分别使用Python内置函数及jieba库中已有函数统计字符串s的中文字符个数及中文词语个数。注意，中文字符包含中文标点符号。 import jieba s = "依靠创新推动实体经济高质量发展，培育壮大新动能。" n = ___________ m = ___________ print("中文字符数为{}，中文词语数为{}".format(n, m))
回答错误
len([c for c in s if '\u4e00' <= c <= '\u9fff'])、len([word for word in seg_list if '\u4e00' <= word <= '\u9fff'])
正确答案
len(s)、len(jieba.lcut(s))
+ 5.0 分
15 . 编程题 中等 5分
电子邮件格式
回答正确
编写程序，验证一个字符串是否为有效的电子邮件格式。
import re
def is_valid_email(email):
if not email:
return False
pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
return re.match(pattern, email.strip()) is not None
# 测试
email = input("请输入电子邮箱：")print(is_valid_email(email))
正确答案
import os, redef check_email(strEmail):
regex_email = re.compile(r'^[\w\.\-]+@([\w\-]+\.)+[\w\-]+$')
result = True if regex_email.match(strEmail) else False
return result#测试代码if __name__=='__main__':
str1 = input("请输入电子邮箱：")
print( check_email(str1))
通过正则表达式re模块的匹配和搜索，或者正则表达式对象的匹配和搜索，可以验证一个字符串是否与指定模式匹配，即实现字符串包含验证。
+ 5.0 分
16 . 单选题 简单 5分
下列数据类型中，Python不支持的是（ ）。
A.char
B.int
C.float
D.list
回答正确
A
正确答案
A
无。
+ 5.0 分
17 . 单选题 简单 5分
关于Python字符串，下列说法错误的是（ ）。
A.字符即长度为1的字符串
B.字符串以\0标志字符串的结束
C.用户既可以用单引号，也可以用双引号创建字符串
D.在三引号字符串中可以包含换行回车等特殊字符
回答正确
B
正确答案
B
Python字符串字面量可以使用以下单引号、双引号、三单引号、三双引号四种方式定义。Python中没有独立的字符数据类型，字符即长度为1的字符串
+ 5.0 分
18 . 简答题 简单 5分
下列Python语句的输出结果是______。 print("数量{0}，单价{1}".format(100, 285.6)) print(str.format("数量{0}，单价{1:3.2f}", 100, 285.6)) print("数量%4d，单价%3.3f" % (100, 285.6))
回答正确
数量100，单价285.6
数量100，单价285.60
数量 100，单价285.600
正确答案
数量100，单价285.6、数量100，单价285.60、数量 100，单价285.600
【例6-6】公有方法、私有方法、静态方法的定义和调用。
class Fruit:
price=0
def __init__(self):
self.__color='Red' #定义和设置私有属性color
self.__city='Kunming' #定义和设置私有属性city
def __outputColor(self): #定义私有方法outputColor
print(self.__color) #访问私有属性color
def __outputCity(self): #定义私有方法outputCity
print(self.__city) #访问私有属性city
def output(self): #定义公有方法output
self.__outputColor( ) #调用私有方法outputColor
self.__outputCity( ) #调用私有方法outputCity
@ staticmethod
def getPrice(): #定义静态方法getPrice
return Fruit.price
@ staticmethod
def setPrice(p): #定义静态方法setPrice
Fruit.price=p
#主程序
apple=Fruit()
apple.output()
print(Fruit.getPrice( ))
Fruit.setPrice(9)
print(Fruit.getPrice( ))
例子6-7
class Parent: # 定义父类
parentAttr = 100
def __init__(self):
print ("调用父类构造函数")
def parentMethod(self):
print("调用父类方法")
def setAttr(self, attr):
Parent.parentAttr = attr
def getAttr(self):
print( "父类属性 :", Parent.parentAttr)
class Child(Parent): # 定义子类
def __init__(self):
print( "调用子类构造函数")
def childMethod(self):
print("调用子类方法 child method")
#主程序
c = Child() # 实例化子类
c.childMethod() # 调用子类的方法
c.parentMethod() # 调用父类方法
c.setAttr(200) # 再次调用父类的方法
c.getAttr() # 再次调用父类的方法
例子6-8
#定义基类：Person类
import types
class Person(object): #基类必须继承于object，否则在派生类中将无法使用super()函数
def __init__(self, name = '', age = 20, sex = 'man'):
self.setName(name)
self.setAge(age)
self.setSex(sex)
def setName(self, name):
if type(name) != str: #内置函数type( )返回被测对象的数据类型
print ('姓名必须是字符串.')
return
self.__name = name
def setAge(self, age):
if type(age) != int:
print ('年龄必须是整型.')
return
self.__age = age
def setSex(self, sex):
if sex != '男' and sex != '女':
print ('性别输入错误')
return
self.__sex = sex
def show(self):
print ('姓名：', self.__name, '年龄：', self.__age ,'性别：', self.__sex)
#定义子类（Student类），其中增加一个入学年份私有属性（数据成员）。
class Student (Person):
def __init__(self, name='', age = 20, sex = 'man', schoolyear = 2016):
#调用基类构造方法初始化基类的私有数据成员
super(Student, self).__init__(name, age, sex)
#Person.__init__(self, name, age, sex) #也可以这样初始化基类私有数据成员
self.setSchoolyear(schoolyear) #初始化派生类的数据成员
def setSchoolyear(self, schoolyear):
self.__schoolyear = schoolyear
def show(self):
Person.show(self) #调用基类show()方法
#super(Student, self).show() #也可以这样调用基类show()方法
print ('入学年份：', self.__schoolyear)
#主程序
if __name__ =='__main__':
zhangsan = Person('张三', 19, '男')
zhangsan.show()
lisi = Student ('李四', 18, '男', 2015)
lisi.show()
lisi.setAge(20) #调用继承的方法修改年龄
lisi.show()
例子6-9
class Animal: # 定义父类
def run(self):
print ('调用父类方法')
class Cat (Animal): # 定义子类
def run (self):
print ('调用子类方法')
class Dog (Animal): # 定义子类
def run (self):
print ('调用子类方法')
c = Dog() # 子类实例
c. run () # 子类调用重写方法
例子7-5
from tkinter import *
root = Tk()
root.title("登录")
root['width']=200;root['height']=80
Label(root,text = '用户名',width=6).place(x=1,y=1) #绝对坐标（1，1）
Entry(root,width=20).place(x=45,y=1) #绝对坐标（45，20）
Label(root,text = '密码',width=6).place(x=1,y=20) #绝对坐标（1，20）
Entry(root,width=20, show='*').place(x=45,y=20) #绝对坐标（45，20）
Button(root,text = '登录',width=8).place(x=40,y=40) #绝对坐标（40，40）
Button(root,text = '取消',width=8).place(x=110,y=40) #绝对坐标（110，40）
Rout.mainloop()
例子7-8
import tkinter as tk
def btnHelloClicked(): #事件函数
cd = float(entryCd.get()) #获取文本框内输入的内容转换成浮点数
labelHello.config(text = "%.2f C = %.2f F" %(cd, cd*1.8+32))
root = tk.Tk()
root.title("Entry Test")
labelHello = tk.Label(root, text = "转换°C to °F...", height = 5, width = 20, fg = "blue")
labelHello.pack()
entryCd = tk.Entry(root) #Entry组件
entryCd.pack()
btnCal = tk.Button(root, text = "转换温度", command = btnHelloClicked) #按钮
btnCal.pack()
root.mainloop()
【例7-9】Tkinter创建一个获取Listbox组件内容的程序。运行效果如图7-9所示。
from tkinter import *
root = Tk()
#将一字符串与Listbox的值绑定
m = StringVar()
def callbutton1():
print(m.get())
def callbutton2():
for i in lb.curselection():
print(lb.get(i))
root.title("使用Listbox组件的例子") #设置窗口标题
lb = Listbox(root, listvariable =m)
for item in ['北京','天津','上海']:
lb.insert(END,item)
lb.pack()
b1 = Button (root,text = '获取Listbox的所有内容', command=callbutton1, width=20)#创建Button组件
b1.pack()#显示Button组件
b2 = Button (root,text = '获取Listbox的选中内容', command=callbutton2, width=20)#创建Button组件
b2.pack()#显示Button组件
root.mainloop()
92
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
