Python程序设计任务驱动式教程题库带答案

单元1 程序开发环境构建与数据输入输出

（一）选择题

1．Python是一种优秀并广泛使用的语言，得到行业内众多领域的认可，下列选项属

于Python主要应用领域的是（ ABCD ）。

A．人工智能

B．科学计算和统计

C．大数据处理

D．游戏开发

2．Python相比其他程序设计语言具有的特点是（ ABC ）。

A．交互式

B．解释型

C．面向对象

D．服务端语言

3．计算机中进行信息处理和信息储存使用的是（ A ）。

A．二进制代码

B．十进制代码

C．十六进制代码

D．ASCII代码

4．Python源程序执行的方式是（ B ）。

A．编译执行

B．解析执行

C．直接执行

D．边编译边执行

5．Python代码块的标记是( C )。

A．分号

B．逗号

C．缩进

D．/

6．安装好Python之后，可以有多种方式运行，下列不属于其可行运行方式的是

（ A ）。

A．浏览器中运行

B．交互式解释器

C．命令行脚本

D．PyCharm

7．Python解释器执行'{0},{2},{1}'.format('a','b','c')的结果为（ C ）。

A．'a,b,c'

B．'a,c,c'

C．'a,c,b'

D．'c,c,b'

8．在Python解释器的主提示符或从属提示符后输入中断符（ A ）就会取消当前输

入，回到主提示符，会抛出一个KeyboardInterrupt异常。

A．Ctrl+C

B．Ctrl+Z

1

C．Ctrl+O

D．Alt+C

9．学习Python要先明白什么是编程语言。下列选项正确的是（ ABCD ）。

A．编程语言是程序员与计算机沟通的介质

B．能够被计算机识别的表达方式即是编程语言

C．编程即程序员根据要求把自己的思想流程按照某种编程语言的语法格式编写下来

D．人类编程控制计算机工作

10．下列选项对Unicode作用的描述，正确的是（ AC ）。

A．能够使计算机对跨语言的文本进行转换和处理

B．能够减少存储容量，节约存储成本

C．能够使计算机对跨平台的文本进行转换和处理

D．能够使计算机处理文本速度更快

11．在Python 3中执行以下语句后得到的结果是（ D ）。

>>>word="Python"

>>>print "hello "+ word

A．hello Python

B．"hello" Python

C．hello word

D．语法错误

（二）填空题

1．用编程语言编写的文件通常有固定的扩展名，Python文件的扩展名通常为

{ .py }。

2．Python安装扩展库常用的是{ pip }工具。

3．使用pip工具查看当前已安装的Python扩展库的完整命令是{ pip list }。

4．在IDLE交互模式中浏览上一条语句的快捷键是{ Alt+P }。

5．在Python中，使用内置函数{ print() }可以将结果输出到IDLE或者标准控制台

中。

6．Python的编程方式主要有{ 交互式 }编程、脚本式编程两种。

7．Python编程时关键字都不能作为变量名，在程序中先导入keyword模块，然后调

用{ }即可查看Python包含的所有关键字。

8．在IDLE窗口出现{ >>> }提示符时，表示Python已经准备好了，等待用户输入

Python程序代码。

9．多行注释使用三引号'''或者3个{ 双引号“"""” }将注释括起来。

10．Python提供了{ input() }内置函数从标准输入中读入文本，默认的标准输入是

键盘。

11．Python 3语句print(1, 2, 3, sep=',')的输出结果为{ 1,2,3 }。

（三）判断题

1．Python是一种跨平台、开源、免费的动态编程语言。（ 对 ）

2．Python 3完全兼容Python 2。（ 错 ）

3．在Windows平台上编写的Python程序无法在UNIX平台运行。（ 错 ）

4．不可以在同一台计算机上安装多个Python版本。（ 错 ）

5．pip命令也支持扩展名为“.whl”的文件直接安装Python扩展库。（ 对 ）

6．Python使用缩进来体现代码之间的逻辑关系。（ 对 ）

7．Python代码的注释只有一种方式，那就是使用#符号。（ 错 ）

2

8．为了让代码更加紧凑，编写Python程序时应尽量避免加入空格和空行。（ 错 ）

9．Python程序只能在安装了Python环境的计算机上以源代码形式运行。（ 错 ）

10．在Python 3中，使用内置函数input()接收用户输入时，不论用户输入什么格式的

内容，一律按字符串进行返回。（ 对 ）

11．安装Python扩展库时只能使用pip工具在线安装，如果安装不成功就没有别的办

法了。（ 错 ）

单元2 基本数据类型与运算符应用

（一）选择题

1．在信息组织和存储中，最基本的单位是（ B ）。

A．字节（Byte）

B．位（bit）

C．字（Word）

D．双字（Double Word）

2．现有代码t=('a')，在Python 3解释器中查看type(t)的结果为（ A ）。

A．

B．

C．(class 'str')

D．(class 'tuple')

3．设任意一个十进制整数D，转换成二进制数为B，根据数制的概念，下列叙述中正

确的是（ C ）。

A．数字B的位数<数字D的位数

B．数字B的位数≤数字D的位数

C．数字B的位数≥数字D的位数

D．数字B的位数>数字D的位数

4．字长为7位的无符号二进制整数能表示的十进制整数范围是（ C ）。

A．0~128

B．0~255

C．0~127

D．1~127

5．下列选项中，八进制数24转换成二进制数正确的是（ B ）。

A．00101100

B．00010100

C．00011100

D．00011101

6．将二进制数10010101转换成十进制数，正确的选项为（ C ）。

A．139

B．141

C．149

D．151

7．下列字符中对应ASCII数值最小的选项是（ A ）。

A．B

B．a

3

C．k

D．M

8．在Python中，数值类型包括（ ABCD ）。

A．int

B．float

C．complex

D．bool

9．以下选项为整数类型的有（ ACD ）。

A．3

B．3.1

C．-3

D．0

10．Python 3解释器执行long(10)的结果为（ C ）。

A．10L

B．10l

C．NameError: name 'long' is not defined

D．1

11．在Python 3中，如果变量x = 3，那么x /= 3的结果为（

A．3

B．0

C．1.0

D．1

12．下列选项中，数值最小的是（ D ）。

A．十进制数 55

B．二进制数110100

C．八进制数 101

D．十六进制数33

13．Python 3解释器执行2的8次方的结果为（ A ）。

A．256

B．256L

C．256l

D．报错

14．下列选项中不是Python合法的标识符的是（ B ）。

A．int32

B．40XL

C．self

D．__name__

15．Python不支持的数据类型是（ A ）。

A．char

B．int

C．float

D．list

16．print(type(1+2*3.14))的结果是（ C ）。

A．

4

C ）。

B．

C．

D．

17．以下不是Python中的关键字的是（ D ）。

A．raise

B．with

C．import

D．final

18．下列语句在Python中为非法的是（ B ）。

A．x = y = z = 1

B．x = (y = z + 1)

C．x, y = y, x

D．x += y

19．关于Python内存管理，下列说法错误的是（ B ）。

A．变量不必事先声明

B．变量无须先创建和赋值而可以直接使用

C．变量无须指定类型

D．可以使用del释放资源

20．关于Python中的复数，下列说法错误的是（ C ）。

A．表示复数的语法是real + imag*j

B．实部和虚部都是浮点数

C．虚部末尾必须加上j，且必须是小写

D．方法conjugate返回复数的共轭复数

21．print(100 - 25 * 3 % 4)输出的结果是（ B ）。

A．1

B．97

C．25

D．0

（二）填空题

1．在Python中{ None }表示空类型。

2．查看变量类型的Python内置函数是{ type() }。

3．以3为实部、4为虚部，Python复数的表达形式为{ 3+4j }或3+4J。

4．Python运算符中用来计算商的整数部分的是{ // }。

5．已知x = 3，那么执行语句x += 6之后，x的值为{ 9 }。

6．已知x = 3，那么执行语句x *= 6之后，x的值为{ 18 }。

7．表达式int(4**0.5)的值为{ 2 }。

8．已知x=3和y=5，执行语句 x, y = y, x 后x的值是{ 5 }。

9．表达式3 ** 2 的值为{ 9 }。

10．表达式3 * 2的值为。{ 6 }

11．表达式3 | 5的值为{ 7 }。

12．表达式3 & 6的值为{ 2 }。

13．表达式3<<2的值为{ 12 }。

14．表达式65 >> 1的值为{ 32 }。

15．表达式isinstance('abc', str)的值为{ True }。

5

16．表达式isinstance('abc', int)的值为{ False }。

17．表达式isinstance(4j, (int, float, complex))的值为{ True }。

18．表达式isinstance('4', (int, float, complex))的值为{ False }。

19．表达式type(3) in (int, float, complex)的值为{ True }。

20．表达式type(3.0) in (int, float, complex)的值为{ True }。

21．表达式type(3+4j) in (int, float, complex)的值为{ True }。

22．表达式type('3') in (int, float, complex)的值为{ False }。

23．表达式type(3) == int的值为{ True }。

24．表达式print(0b10101)的值为{ 21 }。

25．表达式1234%1000//100的值为{ 2 }。

26．表达式3 // 5的值为{ 0 }。

27．表达式15 // 4的值为{ 3 }。

28．已知x为整数变量，那么表达式int(hex(x), 16) == x的值为{ True }。

29．表达式16**0.5的值为{ 4.0 }。

30．表达式isinstance('Hello Python', str)的值为{ True }。

31．已知x = 3+4j和y = 5+6j，那么表达式x+y的值为{ 8+10j }。

32．表达式int('11', 2)的值为{ 3 }。

33．表达式int('11', 8)的值为{ 9 }。

34．表达式int(bin(54321), 2)的值为{ 54321 }。

35．表达式chr(ord('A')+1)的值为{ 'B' }。

36．表达式int(str(34)) == 34的值为{ True }。

37．表达式chr(ord('a')^32^32)的值为{ 'a' }。

38．表达式chr(ord('a')^32)的值为{ 'A' }。

39．表达式chr(ord('b')^32)的值为{ 'B' }。

40．表达式'abc' in 'abdcefg'的值为{ False }。

41．表达式isinstance(3, object)的值为{ True }。

（三）判断题

1．已知x = 3，那么赋值语句x = 'abcedfg'是无法正常执行的。（ 错 ）

2．Python变量使用前必须先声明，并且一旦声明就不能在当前作用域内改变其类

型。（ 错 ）

3．Python采用的是基于值的自动内存管理方式。（ 对 ）

4．在任何时刻相同的值在内存中都只保留一份。（ 错 ）

5．Python不允许使用关键字作为变量名，允许使用内置函数名作为变量名，但这会

改变函数名的含义。（ 对 ）

6．在Python中可以使用if作为变量名。（ 错 ）

7．在Python 3中可以使用中文作为变量名。（ 对 ）

8．Python变量名必须以字母或下划线开头，并且区分字母大小写。（ 对 ）

9．9999**9999这样的命令在Python中无法运行。（ 错 ）

10．3+4j不是合法的Python表达式。（ 错 ）

11．0o12f是合法的八进制数字表示形式。（ 错 ）

12．在Python中0xad是合法的十六进制数字表示形式。（ 对 ）

13．3+4j是合法Python的数值类型。（ 对 ）

14．在Python中0oa1是合法的八进制数字表示形式。（ 错 ）

15．Python运算符%不仅可以用来求余数，还可以用来格式化字符串。（ 对 ）

6

16．已知x = 3，那么执行语句x+=6之后，x的内存地址不变。（ 错 ）

17．一个数字5也是合法的Python表达式。（ 对 ）

18．在Python中可以使用for作为变量名。（ 错 ）

19．在Python中可以使用id作为变量名，尽管不建议这样做。（ 对 ）

20．Python关键字不可以作为变量名。（ 对 ）

21．Python变量名区分大小写，所以student和Student不是同一个变量。（ 对 ）

22．在Python中，变量不直接存储值，而是存储值的引用，也就是值在内存中的地

址。（ 对 ）

23．在条件表达式中不允许使用赋值运算符“=”，会提示语法错误。（ 对 ）

单元3 逻辑运算与流程控制

（一）选择题

1．当知道条件为True，想要程序无限执行直到人为停止的话，需要使用（

句。

A．for

B．break

C．while

D．if

2．下列表达式的值为True的是（ C ）。

A．5+4j > 2-3j

B．3>2>2

C．1==1 and 2!=1

D．not(1==1 and 0!=1)

3．求比10小且大于或等于0的偶数的代码如下，请将代码补充完善。

x = 10

while x:

x = x-1

if x%2!=0:

（ B ）

print (x)

A．break

B．continue

C．yield

D．flag

4．Python 3解释器执行not 1 and 1的结果为（ B ）。

A．True

B．False

C．0

D．1

5．有以下的程序段，其中k取（ A ）值时x =3。

if k<=10 and k>0:

if k>5:

if k>8:

7

C ）语

x=0

else:

x=1

else:

if k>2:

x=3

else:

x=4

A．3 4 5

B．1 2

C．5 6 7

D．5 6

6．以下程序的执行结果是（ B ）。

s = 0

for i in range(1,11):

s += i

if i == 10:

print(s)

break

A．66

B．55

C．45

D．0

7．以下程序的执行结果是（ A ）。

s = 0

for i in range(2,11):

s += i

print(s)

else:

print(1)

A．1

B．2

C．5

D．9

8．假设n为5，那么表达式n&1 == n%2的值为（

A．False

B．True

C．5

D．1

9．执行以下代码，其结果为（ A ）。

x = 5

y = 8

print(x == y)

8

B ）。

A．False

B．True

C．5

D．8

10．执行以下代码，其结果为（ C ）。

n = 10

sum = 0

number = 1

while number <= n:

sum = sum + number

number += 1

print(sum)

A．0

B．45

C．55

D．66

（二）填空题

1．表达式'x41' == 'A'的值为{ True }。

2．表达式not 3的值为{ False }。

3．表达式5 if 5>6 else (6 if 3>2 else 5)的值为{ 6 }。

4．表达式1<2<3的值为{ True }。

5．表达式3 or 5的值为{ 3 }。

6．表达式0 or 5的值为{ 5 }。

7．表达式3 and 5的值为{ 5 }。

8．表达式3 and not 5的值为{ False }。

9．Python中用于表示逻辑与、逻辑或、逻辑非运算的关键字分别是and、or和

{ not }。

10．Python 3语句for i in range(3):print(i, end= ', ')的输出结果为{ 0,1,2, }。

11．对于带有else子句的for循环和while循环，当循环因循环条件不成立而自然结束

时{ 会 }执行else中的代码。

12．在循环语句中，{ break }语句的作用是提前结束本层循环。

13．在循环语句中，{ continue }语句的作用是跳过当前循环中的剩余语句，提前进

入下一次循环。

14．表达式[5 for i in range(3)]的值为{ [ 5, 5, 5 ] }。

15．表达式3<5>2的值为{ True }。

（三）判断题

1．带有else子句的循环如果因为执行了break语句而终止的话，则会执行else子句中

的代码。（ 错 ）

2．对于带有else子句的循环语句，如果是因为循环条件表达式不成立而自然结束循

环，则执行else子句中的代码。（ 对 ）

3．如果仅仅是用于控制循环次数，那么使用for i in range(20)和for i in range(20, 40)的

作用是等价的。（ 对 ）

4．在循环中continue语句的作用是跳出当前循环。（ 错 ）

5．在编写多层循环语句时，为了提高运行效率，应尽量减少内循环中不必要的计算。

9

（ 对 ）

6．带有else子句的异常处理结构，如果不发生异常则执行else子句中的代码。

（ 对 ）

7．当作为条件表达式时，[]与None等价。（ 对 ）

8．表达式[] == None的值为True。（ 错 ）

9．表达式pow(3,2) == 3**2的值为True。（ 对 ）

10．当作为条件表达式时，空值、空字符串、空列表、空元组、空字典、空集合、空

迭代对象以及任意形式的数字0都等价于False。（ 对 ）

11． pass语句仅起到占位符的作用，并不会做任何操作。（ 对 ）

单元4 序列数据与正则表达式操作——列表

（一）选择题

1．Python的join()方法用于将序列中的元素连接生成一个新的字符串，下列描述正确

的是（ BD ）。

A．语句''.join('a','b')是合法的

B．语句''.join(['a','b'])是合法的

C．语句''.join([1,2,3])是合法的

D．语句''.join(['1','2','3'])是合法的

2．Python 3解释器执行for i,v in enumerate([0,1,2],2):print(i,v)和for i,v in

enumerate([0,1,2]):print(i,v)的结果，正确的选项是（ C ）。

A．结果一致

B．第一个报错

C．第一个序号从2开始，第二个序号从0开始

D．两个都报错

3．Python 3解释器执行list=[1,4,3]，(list)后list的值是（ C ）。

A．[1,4,3]

B．[1,4,3,[]]

C．[1, 4, 3, 1, 4, 3]

D．None

4．Python3解释器对列表[1,2,[3,4],5,6]使用reverse()方法执行的结果为（ A ）。

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

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

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

D．报错

5．现有列表list=[1,2,3,4,5,6,7,8,9,0]，那么Python 3解释器执行list[1:3]='abc'后执行

list[2]的结果是（ D ）。

A．4

B．c

C．abc

D．b

6．在Python中，关于reverse()方法的说法中，正确的是（ BD ）。

A．reverse()方法返回新的列表

B．reverse()方法没有返回值

10

C．reverse()方法对列表内的所有元素进行反向排序

D．reverse()方法只对一级元素进行反向排序

7．现有列表list=[1,2,3,4,5,6,7,8,9,0]，那么Python 3解释器执行(2,'a')后执行

list[3]的结果是（ B ）。

A．'a'

B．3

C．2

D．4

8．已知列表x = [1, 3, 2]，那么执行语句a, b, c= sorted(x)之后，b的值为（ C ）。

A．1

B．3

C．2

D．None

9．已知x = [3, 5, 7]，那么执行语句x[1:] = [2]之后，x的值为（ B ）。

A．[3, 5, 7]

B．[3, 2]

C．[3, 5, 2]

D．[3]

10．已知x = [1, 2, 3]，那么连续执行y = x和(4)两条语句之后，x的值为

（ A ）。

A．[1, 2, 3, 4]

B．[1, 2, 3]

C．[4]

D．[]

11．以下选项属于可变对象的是 ( B )。

A．数值类型(int,float)

B．列表

C．元组

D．字符串

12．设list=['a', 'b', 'c', 'd', 'e', 'f', 'g']，则list[::2]的值是（ C ）。

A．['d', 'e']

B．['d', 'e', 'f', 'g']

C．['a', 'c', 'e', 'g']

D．['c', 'd', 'e']

（二）填空题

1．Python 3解释器执行以下代码后，结果是{ [1, 2, ['a', 5]] }。

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

>>>list1[2][0] = 'a'

>>>list2

2．现有列表list=[1,2,3,4,5,6,7,8,9,0]，那么Python 3解释器执行list[1::2]的结果是

{ [2, 4, 6, 8, 0] }。

3．现有列表list=[1,2,3,4,5,6,7,8,9,0]，那么Python 3解释器执行(-2,'b')后执行

list[-2]的结果是{ 9 }。

4．Python 3解释器执行list=[2,4,6]，(list)后的结果是{ [2, 4, 6, 2, 4, 6] }。

11

5．现有列表list=[2,3,['a','b','c'],1]，那么Python 3解释器执行list[2]=2后list的值是

{ [2, 3, 2, 1] }。

6．现有列表list=[2,3,['a','b','c'],1]，那么Python3解释器执行list[2].extend('de')后list的

值是{ [2, 3, ['a', 'b', 'c', 'd', 'e'], 1] }。

7．现有列表list=[1,2,3,4,5,6,7,8,9,0]，那么Python 3解释器执行list[3::-1]的结果是

{ [4, 3, 2, 1] }。

8．已知x = list(range(20))，那么表达式x[-1]的值为{ 19 }。

9．已知x = [3]，那么执行x += [5]之后x的值为{ [3, 5] }。

10．已知x = [3, 3, 4]，那么表达式id(x[0])==id(x[1])的值为{ True }。

11．表达式list(str([3, 4])) == [3, 4]的值为{ False }。

12．已知x = [3, 2, 4, 1]，那么执行语句x = ()之后，x的值为{ None }。

13．表达式list(filter(lambda x: x>5, range(10)))的值为{ [6, 7, 8, 9] }。

14．已知x = list(range(20))，那么语句print(x[100:200])的输出结果为{ [] }。

15．已知x = list(range(20))，那么执行语句x[:18] = []后列表x的值为{ [18, 19] }。

16．已知x = [1, 2, 3]，那么连续执行y = x[:]和(4)两条语句之后，x的值为

{ [1, 2, 3] }。

17．已知x = [1, 2, 3]，那么连续执行y = [1, 2, 3]和(4)两条语句之后，x的值

为{ [1, 2, 3] }。

18．已知x = [[]] * 3，那么执行语句x[0].append(1)之后，x的值为{ [[1], [1],

[1]] }。

19．已知x = [[] for i in range(3)]，那么执行语句x[0].append(1)之后，x的值为{ [[1],

[], []] }。

20．表达式[1, 2] + [3]的值为{ [1, 2, 3] }。

21．已知列表x = list(range(5))，那么执行语句(3)之后，表达式(4)的

值为{ 3 }。

22．已知列表x = [1, 3, 2]，那么执行语句e()之后，x的值为{ [2, 3, 1] }。

23．已知列表x = [1, 3, 2]，那么执行语句x = e()之后，x的值为{ None }。

24．已知x为非空列表，那么表达式e()== list(reversed(x))的值为{ False }。

25．已知x为非空列表，那么表达式()== sorted(x)的值为{ False }。

26．已知列表x = [1, 3, 2]，那么执行语句y = list(reversed(x))之后，x的值为{ [1, 3,

2] }。

27．已知列表x = [1, 3, 2]，那么执行语句y = list(reversed(x))之后，y的值为{ [2, 3,

1] }。

28．已知列表x中包含超过5个以上的元素，那么表达式x == x[:5]+x[5:] 的值为

{ True }。

29．已知列表x = [1, 3, 2]，那么表达式[value for index, value in enumerate(x) if

index==2]的值为{ [2] }。

30．已知列表x = [1, 3, 2]，那么执行语句a, b, c= map(str,sorted(x))之后，c的值为

{ '3' }。

31．已知x = [1, 2, 3, 4, 5]，那么执行语句del x[:3]之后，x的值为{ [4, 5] }。

32．表达式sorted(['abc', 'acd', 'ade'], key=lambda x:(x[0],x[2]))的值为{ ['abc', 'acd',

'ade'] }。

33．表达式[1, 2, 3] == [1, 3, 2]的值为{ False }。

34．已知x = [1, 2, 1]，那么表达式id(x[0]) == id(x[2])的值为{ True }。

12

35．表达式3 not in [1, 2, 3]的值为{ False }。

36．已知x = [1, 2]，那么执行语句x[0:0] = [3, 3]之后，x的值为{ [3, 3, 1, 2] }。

37．已知x = [1, 2]，那么执行语句x[0:1] = [3, 3]之后，x的值为{ [3, 3, 2] }。

38．已知x = [1, 2, 3, 4, 5]，那么执行语句del x[1:3]之后，x的值为{ [1, 4, 5] }。

39．已知x = [[1, 2, 3,], [4, 5, 6]]，那么表达式sum([i*j for i,j in zip(*x)])的值为

{ 32 }。

40．已知列表x = [1, 2, 3]和y = [4, 5, 6]，那么表达式[(i,j) for i, j in zip(x,y) if i==3]的值

为{ [(3, 6)] }。

41．已知列表x = [1.0, 2.0, 3.0]，那么表达式sum(x)/len(x)的值为{ 2.0 }。

42．执行语句x, y, z = sorted([1, 3, 2])之后，变量y的值为{ 2 }。

43．执行语句x, y, z = [1, 2, 3]之后，变量y的值为{ 2 }。

44．已知x = [[1,3,3], [2,3,1]]，那么表达式sorted(x, key=lambda item:(item[1],item[2]))

的值为{ [[2, 3, 1], [1, 3, 3]] }。

45．已知列表x = [1, 2]，那么连续执行语句y = x和(3)之后，x的值为{ [1,

2, 3] }。

46．已知列表x = [1, 2]，那么连续执行语句y =x[:]和(3)之后，x的值为{ [1,

2] }。

47．已知列表x = [1, 2]，执行语句y = x[:]后，表达式id(x) == id(y)的值为

{ False }。

48．已知列表x = [1, 2]，执行语句y = x后，表达式id(x) == id(y)的值为{ True }。

49．已知列表x = [1, 2]，执行语句y = x后，表达式x is y的值为{ True }。

50．已知列表x = [1, 2]，执行语句y = x[:]后，表达式x is not y的值为{ True }。

51．表达式sorted((range(5), 5))的值为{ [0, 1, 2, 3, 4] }。

52．表达式[i for i in range(10) if i>8]的值为{ [9] }。

53．已知有列表x = [[1, 2, 3], [4, 5, 6]]，那么表达式[[row[i] for row in x] for i in

range(len(x[0]))]的值为{ [[1, 4], [2, 5], [3, 6]] }。

54．已知列表x = [1, 2]，那么执行语句([3])之后，x的值为{ [1, 2, 3] }。

55．已知列表x = [1, 2]，那么执行语句([3])之后，x的值为{ [1, 2, [3]] }。

56．假设列表对象x = [1, 1, 1]，那么表达式id(x[0]) == id(x[2])的值为{ True }。

57．已知列表x = list(range(10))，那么执行语句del x[::2]之后，x的值为{ [1, 3, 5, 7,

9] }。

58．已知列表x = [1, 2, 3, 4]，那么执行语句del x[1]之后，x的值为{ [1, 3, 4] }。

59．表达式[1] * 2的值为{ [1, 1] }。

60．表达式[1, 2] * 2的值为{ [1, 2, 1, 2] }。

61．已知列表x = [1, 2, 3]，那么执行语句(1, 4) 之后，x的值为{ [1, 4, 2,

3] }。

62．已知列表x = [1, 2, 3]，那么执行语句(0, 4) 之后，x的值为{ [4, 1, 2,

3] }。

63．已知列表x = [1, 2, 3]，那么执行语句(0)之后，x的值为{ [2, 3] }。

64．已知x = [[1]] * 3，那么执行语句x[0][0] = 5之后，变量x的值为{ [[5], [5],

[5]] }。

65．已知x = [1, 2, 3]，那么执行语句x[len(x)-1:] = [4, 5, 6]之后，变量x的值为{ [1,

2, 4, 5, 6] }。

66．已知x是一个列表对象，那么执行语句y = x[:]之后，表达式id(x) == id(y)的值为

13

{ False }。

67．表达式sorted([13, 1, 237, 89, 100], key=lambda x: len(str(x)))的值为{ [1, 13, 89,

237, 100] }。

68．表达式[str(i) for i in range(3)]的值为{ ['0', '1', '2'] }。

69．表达式list(filter(None, [0,1,2,3,0,0]))的值为{ [1, 2, 3] }。

70．表达式list(range(50, 60, 3))的值为{ [50, 53, 56, 59] }。

71．表达式[1,2,3].count(4)的值为{ 0 }。

72．Python标准库random中的sample(seq, k)方法的作用是从序列中选择{ 不重

复 }的k个元素。

73．表达式[1, 2, 3]*3的执行结果为{ [1, 2, 3, 1, 2, 3, 1, 2, 3] }。

74．list(map(str, [1, 2, 3]))的执行结果为{ ['1', '2', '3'] }。

75．表达式[3] in [1, 2, 3, 4]的值为{ False }。

76．列表对象的sort()方法用于对列表元素进行原地排序，该方法的返回值为

{ None }。

77．假设列表对象aList的值为[3, 4, 5, 6, 7, 9, 11, 13, 15, 17]，那么截取aList[3:7]得到

的值是{ [6, 7, 9, 11] }。

78．Python语句list(range(1,10,3))的执行结果为{ [1, 4, 7] }。

79．表达式list(range(5))的值为{ [0, 1, 2, 3, 4] }。

80．{ del }命令既可以删除列表中的一个元素，也可以删除整个列表。

81．已知a= [1, 2, 3]和b= [1, 2, 4]，那么id(a[1])==id(b[1])的执行结果为{ True }。

82．截取操作list(range(6))[::2]的执行结果为{ [0, 2, 4] }。

83．利用截取操作在列表对象x的开始处增加一个元素3的代码为{ x[0:0] =

[3] }。

84．语句sorted([1, 2, 3], reverse=True) == reversed([1, 2, 3])的执行结果为{ False }。

85．表达式sorted([111, 2, 33], key=lambda x: len(str(x)))的值为{ [2, 33, 111] }。

86．表达式sorted([111, 2, 33], key=lambda x: -len(str(x)))的值为{ [111, 33, 2] }。

87．已知列表对象x = ['11', '2', '3']，则表达式max(x)的值为{ '3' }。

88．表达式min(['11', '2', '3'])的值为{ '11' }。

89．已知列表对象x = ['11', '2', '3']，则表达式max(x, key=len)的值为{ '11' }。

90．关键字{ in }用于测试一个对象是否是一个可迭代对象的元素。

91．使用列表推导式得到100以内所有能被13整除的数的代码可以写作{ [i for i in

range(100) if i%13==0] }。

92．已知x = [3, 5, 7]，那么表达式x[10:]的值为{ [] }。

93．已知x = [3, 5, 7]，那么执行语句x[len(x):] = [1, 2]之后，x的值为{ [3, 5, 7, 1,

2] }。

94．已知x = [3, 7, 5]，那么执行语句(reverse=True)之后，x的值为{ [7, 5,

3] }。

95．已知x = [3, 7, 5]，那么执行语句x = (reverse=True)之后，x的值为

{ None }。

96．已知x = [1, 11, 111]，那么执行语句(key=lambda x: len(str(x)), reverse=True)

之后，x的值为{ [111, 11, 1] }。

97．表达式list(zip([1,2], [3,4]))的值为{ [(1, 3), (2, 4)] }。

98．已知x = [1, 2, 3, 2, 3]，执行语句()之后，x的值为{ [1, 2, 3, 2] }。

99．表达式list(map(list,zip(*[[1, 2, 3], [4, 5, 6]])))的值为{ [[1, 4], [2, 5], [3, 6]] }。

14

100．表达式[x for x in [1,2,3,4,5] if x<3]的值为{ [1, 2] }。

101．表达式[index for index, value in enumerate([3,5,7,3,7]) if value == max([3,5,7,3,7])]

的值为{ [2, 4] }。

102．已知x = [3,5,3,7]，那么表达式[(i) for i in x if i==3]的值为{ [0, 0] }。

103．已知列表x = [1, 2]，那么表达式list(enumerate(x))的值为{ [(0, 1), (1, 2)] }。

104．已知vec= [[1,2], [3,4]]，则表达式[col for row in vec for col in row]的值为{ [1, 2,

3, 4] }。

105．已知vec= [[1,2], [3,4]]，则表达式[[row[i] for row in vec] for i in range(len(vec[0]))]

的值为{ [[1, 3], [2, 4]] }。

106．已知x = list(range(10))，则表达式x[-4:]的值为{ [6, 7, 8, 9] }。

107．已知x = [3, 5, 7]，那么执行语句x[:3] = [2]之后，x的值为{ [ 2] }。

108．已知x为非空列表，那么执行语句y = x[:]之后，id(x[0]) == id(y[0])的值为

{ True }。

109．已知x = [1, 2, 3, 2, 3]，执行语句(2)之后，x的值为{ [1, 3, 2, 3] }。

110．表达式list(str([1,2,3])) == [1,2,3]的值为{ False }。

111．表达式list(map(lambda x: len(x), ['a', 'bb', 'ccc'])) 的值为{ [1, 2, 3] }。

112．表达式list(map(lambda x: x+5, [1, 2, 3, 4, 5])) 的值为{ [6, 7, 8, 9, 10] }。

113．使用列表推导式生成包含10个数字5的列表，语句可以写为{ [5 for i in

range(10)] }。

（三）判断题

1．已知seq为长度大于10的列表，并且已导入random模块，那么

[(seq) for i in range(10)]和(seq,10)等价。（ 错 ）

2．列表对象的pop()方法默认删除并返回最后一个元素，如果列表已空则抛出异常。

（ 对 ）

3．已知列表x = [1, 2, 3, 4]，那么表达式(5)的值应为-1。（ 错 ）

4．列表对象的排序方法sort()只能按元素从小到大排列，不支持别的排序方式。

（ 错 ）

5．已知x = list(range(20))，那么语句del x[::2]可以正常执行。（ 对 ）

6．已知x = list(range(20))，那么语句x[::2] = []可以正常执行。（ 错 ）

7．已知x = list(range(20))，那么语句print(x[100:200])无法正常执行。（ 错 ）

8．已知x是个列表对象，那么执行语句y = x之后，对y所做的任何操作都会同样作

用到x上。（ 对 ）

9．已知x是列表对象，那么执行语句y = x[:]之后，对y所做的任何操作都会同样作

用到x上。（ 错 ）

10．已知x是一个列表，那么x = x[3:] + x[:3]可以实现把列表x中的所有元素循环左

移3位。（ 对 ）

11．对于大量列表的连接，使用extend()方法比使用运算符+具有更高的效率。

（ 对 ）

12．列表对象的extend()方法属于原地操作，调用前后列表对象的地址不变。

（ 对 ）

13．删除列表中重复元素最简单的方法是将其转换为集合后再重新转换为列表。

（ 对 ）

14．已知列表x中包含5个以上的元素，那么语句 x = x[:5]+x[5:] 的作用是将列表x

中的元素循环左移5位。（ 错 ）

15

15．对于生成器对象x = (3 for i in range(5))，连续两次执行list(x)的结果是一样的。

（ 错 ）

16．已知列表x = [1, 2, 3]，那么执行语句x = 3之后，变量x的地址不变。（ 错 ）

17．使用列表对象的remove()方法可以删除列表中首次出现的指定元素，如果列表中

不存在要删除的指定元素则抛出异常。（ 对 ）

18．假设x是含有5个元素的列表，那么截取操作x[10:]是无法执行的，会抛出异

常。（ 错 ）

19．只能通过截取访问列表中的元素，不能通过截取修改列表中的元素。（ 错 ）

20．已知x为非空列表，那么表达式sorted(x, reverse=True) == list(reversed(x))的值一

定是True。（ 错 ）

21．已知x为非空列表，那么(reverse=True)和e()的作用是等价的。

（ 错 ）

22．生成器推导式比列表推导式具有更高的效率，推荐使用。（ 对 ）

23．Python列表中所有元素必须为相同类型的数据。（ 错 ）

24．在Python 3中语句print(*[1,2,3])不能正确执行。（ 错 ）

25．列表对象的append()方法属于原地操作，用于在列表尾部追加一个元素。

（ 对 ）

26．对列表而言，在尾部追加元素比在中间位置插入元素速度更快一些，尤其是对于

包含大量元素的列表。（ 对 ）

27．假设有非空列表x，那么(3)、x = x+[3]与(0,3)在执行时间上基本

没有太大区别。（ 错 ）

28．使用Python列表的方法insert()为列表插入元素会改变列表中插入位置之后的元素

的索引。（ 对 ）

29．假设x为列表对象，那么()和(-1)的作用是一样的。（ 对 ）

30．使用del命令或者列表对象的remove()方法删除列表中的元素会影响列表中部分

元素的索引。（ 对 ）

31．表达式list('[1, 2, 3]')的值是[1, 2, 3]。（ 错 ）

32．同一个列表对象中的元素类型可以各不相同。（ 对 ）

单元4 序列数据与正则表达式操作——元组

（一）选择题

1．现有代码t = (1,2)，在Python 3解释器中执行t * 3 得到的结果为（ B ）。

A．语法错误

B．(1, 2, 1, 2, 1, 2)

C．(2, 4, 2, 4)

D．以上说法都不对

2．以下关于元组的描述，错误的描述是（ B ）。

A．元组的元素可以是整数、字符串、列表等Python支持的任何类型。

B．与列表一样，元组也有append()、insert()函数。

C．元组是不可变序列。

D．元组的访问和处理速度比列表快。

3．在Python中可以创建空元组，以下语句中可以用来创建空元组的是（ C ）。

A．t = tuple()

16

B．t = (0)

C．t = ()

D．t=set()

4．Python中，以下所列方法对于元组可以使用的是（ D ）。

A．append()

B．insert()

C．pop()

D．len()

5．Python中，以下数据序列属于有序序列的是（ C ）。

A．字典

B．集合

C．元组

D．数组

6．Python中，以下所列运算符不能用于元组运算的是（ A ）。

A．-

B．+

C．*

D．in

7．Python中，对于定义的元组tuple = (1, 2, 3, 4, 5, 6, 7 )，不能实现输出元组的全部元

素的是（ D ）。

A．tuple

B．tuple[:]

C．tuple[0:len(tuple)]

D．tuple(0:7)

8．Python中，对于定义的元组tuple1 = (1, 2, 3)，以下连接操作正确的是（ B ）。

A．t=tuple1+'4'

B．t=tuple1+(4,5)

C．t=tuple1+[4,5]

D．t=tuple1+{4 , 5}

9．Python中，对于定义的元组tuple = (1, 2, 3)，以下各项操作能成功执行是

（ D ）。

A．tuple[2]=4

B．tuple[0]=()

C．tuple[0]=None

D．tuple = (4, 5, 6)

10．Python中，对于定义的元组tuple = ('1', '2', '3', '1', '2', '3')，以下各项操作不能成功

执行的是（ C ）。

A．('2')

B．('2')

C．()

D．len(tuple)

（二）填空题

1．表达式sorted({'a':3, 'b':9, 'c':78})的值为{ ['a', 'b', 'c'] }。

2．已知x = ([1], [2])，那么执行语句x[0].append(3)后x的值为{ ([1, 3], [2]) }。

17

3．表达式(1,) + (2,)的值为{ (1, 2) }。

4．表达式(1) + (2)的值为{ 3 }。

5．表达式(1, 2, 3)+(4, 5)的值为{ (1, 2, 3, 4, 5) }。

6．已知x = (3)，那么表达式x * 3的值为{ 9 }。

7．已知x = (3,)，那么表达式x * 3的值为{ (3, 3, 3) }。

8．语句x = (3,)执行后x的值为{ (3,) }。

9．语句x = (3)执行后x的值为{ 3 }。

10．语句x = 3==3, 5执行结束后，变量x的值为{ (True, 5) }。

（三）判断题

1．创建只包含一个元素的元组时，必须在元素后面加一个逗号，例如(3,)。（ 对 ）

2．同一个元组对象中的所有元素必须为相同类型。（ 错 ）

3．已知x为非空列表，那么执行语句x[0] = 3之后，列表对象x的内存地址不变。

（ 对 ）

4．集合可以作为元组的元素。（ 对 ）

5．Python中的元组支持双向索引。（ 对 ）

6．已知x = (1, 2, 3, 4)，那么执行x[0] = 5之后，x的值为(5, 2, 3, 4)。（ 错 ）

7．在Python中元组的值是不可变的，因此，已知x = ([1], [2])，那么语句

x[0].append(3)是无法正常执行的。（ 错 ）

8．元组是不可变的，不支持列表对象的inset()、remove()等方法，也不支持del命令

删除其中的元素，但可以使用del命令删除整个元组对象。（ 对 ）

9．元组的访问速度比列表的要快一些，如果定义了一系列常量值，并且主要用途仅是

对其进行遍历而不需要进行任何修改，建议使用元组而不使用列表。（ 对 ）

10．只能对列表进行截取操作，不能对元组和字符串进行截取操作。（ 错 ）

11．只能通过截取访问元组中的元素，不能通过截取修改元组中的元素。（ 对 ）

单元4 序列数据与正则表达式操作——字典

（一）选择题

1．Python 3解释器执行for x in {'a':'b','c':'d'}:print(x , end=" ")的结果是（ B ）。

A．b c

B．a c

C．b d

D．a b

2．Python 3解释器执行for k,v in {1:'a',2:'b'}:print(k,v)的结果是（ D ）。

A．1 b

B．b 1

C．1 'b'

D．TypeError: cannot unpack non-iterable int object

3．现有d = {}，Python 3解释器执行d[(1,2)] = ({3,(4)})后d的结果是（ A ）。

A．{(1, 2): {3, 4}}

B．{(1, 2): ({3, 4})}

C．报错

D．以上都不对

4．现有代码d={}，在Python 3解释器中执行d[([1,2])] = 'b'得到的结果为（ A ）。

18

A．TypeError: unhashable type: 'list'

B．{([1, 2]): 'b'}

C．{(1): 'b'}

D．以上都不对

5．Python 3解释器执行d = {(1,[2]):'a',(1,2):1}后d的结果是（ B ）。

A．{(1,[2]):'a',(1,2):1}

B．TypeError: unhashable type: 'list'

C．{(1,2):'a',(1,2):1}

D．以上说法都不对

6．现有d = {'a': 'b',1:1,2:2}，Python 3解释器执行()的结果是（ A ）。

A．报错

B．(1,1)

C．('a':'b')

D．以上都不对

7．以下不能创建一个字典的语句是（ C ）。

A．dict1 = {}

B．dict2 = { 3 : 5 }

C．dict3 = dict( [2 , 5] ,[ 3 , 4 ] )

D．dict4 = dict( ( [1,2],[3,4] ) )

8．已知x = {1:2, 2:3, 3:4}，那么表达式sum(x)的值为（ A ）。

A．6

B．9

C．15

D．3

9．已知x = {1:2, 2:3}，那么表达式(3, 4)的值为（ B ）。

A．3

B．4

C．1

D．2

10．已知x = {1:1}，那么执行语句x[2] = 2之后，len(x)的值为（ B ）。

A．1

B．2

C．3

D．4

（二）填空题

1．已知x = range(1,4)和y = range(4,7)，那么表达式sum([i*j for i,j in zip(x,y)])的值为

{ 32 }。

2．现有d = {}，Python 3解释器执行d['a'] = 'b'后d的结果是{ {'a': 'b'} }。

3．现有字典d1 = {'a':1, 'b':2, 'c':3}和d2 = {1:'a', 'b':4, 'd':3}，那么Python 3解释器执行

(d2)后d2的结果是{ {1: 'a', 'b': 4, 'd': 3} }。

4．Python 3解释器执行d = ys(['apple', 'orange'],10)得到的结果是{ {'apple':

10, 'orange': 10} }。

5．已知x = {1:1, 2:2}，那么执行语句({2:3, 3:3})之后，表达式

sorted(())的值为{ [(1, 1), (2, 3), (3, 3)] }。

19

6．已知x = {1:1, 2:2}，那么执行语句x[3] = 3之后，表达式sorted(())的值为

{ [(1, 1), (2, 2), (3, 3)] }。

7．表达式type({}) == dict的值为{ True }。

8．表达式{'x': 1, **{'y': 2}}的值为{ {'x': 1, 'y': 2} }。

9．已知字典x = {i:str(i+3) for i in range(3)}，那么表达式sum(x)的值为{ 3 }。

10．已知字典x = {i:str(i+3) for i in range(3)}，那么表达式''.join(())的值为

{ '345' }。

11．已知字典x = {i:str(i+3) for i in range(3)}，那么表达式sum(item[0] for item in

())的值为{ 3 }。

12．已知字典x = {i:str(i+3) for i in range(3)}，那么表达式''.join([item[1] for item in

()])的值为{ '345' }。

13．表达式dict(zip([1, 2], [3, 4]))的值为{ {1: 3, 2: 4} }。

14．已知x = {1:1, 2:2}，那么执行语句x[2] = 4之后，len(x)的值为{ 2 }。

15．字典中多个元素之间使用{ 逗号 }分隔，每个元素的“键”与“值”之间使用

{ 冒号 }分隔。

16．字典对象的{ get() }方法可以获取指定“键”对应的“值”，并且可以在指定键

不存在的时候返回指定值，如果不指定则返回None。

17．字典对象的{ items() }方法返回字典中的“键值对”列表。

18．字典对象的{ keys() }方法返回字典的“键”列表。

19．字典对象的{ values() }方法返回字典的“值”列表。

20．已知x = {1:2}，那么执行语句x[2] = 3之后，x的值为{ {1: 2, 2: 3} }。

21．假设有列表a= ['name', 'age', 'sex']和b= ['LinMing', 28, 'Male']，请使用一个语句将

这两个列表的内容转换为字典，并且以列表a中的元素为“键”，以列表b中的元素为

“值”，这个语句可以写为{ c= dict(zip(a, b)) }。

22．表达式sorted({'a':3, 'b':9, 'c':78}.values())的值为{ [3, 9, 78] }。

23．已知x = {1:2, 2:3, 3:4}，那么表达式sum(())的值为{ 9 }。

24．已知x = {1:2, 2:3}，那么表达式(2, 4)的值为{ 3 }。

25．已知x = {'a': 'b', 'c': 'd'}，那么表达式'a' in x的值为{ True }。

26．已知x = {'a': 'b', 'c': 'd'}，那么表达式'b' in x的值为{ False }。

27．已知x = {'a': 'b', 'c': 'd'}，那么表达式'b' in ()的值为{ True }。

28．Python 3解释器执行d = {1:1,2:1}后d的结果是{ {1: 1, 2: 1} }。

（三）判断题

1．集合可以作为字典的键。（ 错 ）

2．集合可以作为字典的值。（ 对 ）

3．Python字典支持双向索引。（ 错 ）

4．Python内置的字典dict中的元素是按添加的顺序依次进行存储的。（ 错 ）

5．已知x = {1:1, 2:2}，那么语句x[3] =3无法正常执行。（ 错 ）

6．Python内置的字典是无序的，如果需要一个可以记住元素插入顺序的字典，可以

使用dDict。（ 对 ）

7．当以指定“键”为索引给字典对象赋值时，若该“键”存在则表示修改该“键”对

应的“值”，若不存在则表示为字典对象添加一个新的“键值对”。（ 对 ）

8．Python支持使用字典的“键”作为索引来访问字典中的值。（ 对 ）

9．字典的“键”必须是不可变的。（ 对 ）

10．Python字典中的“键”不允许重复。（ 对 ）

20

11．Python字典中的“值”不允许重复。（ 错 ）

12．Python字典中的“键”可以是列表。（ 错 ）

13．Python字典中的“键”可以是元组。（ 对 ）

14．Python字典和集合属于无序序列。（ 对 ）

单元4 序列数据与正则表达式操作——集合

（一）选择题

1．有集合s = {1,2,3}，Python 3解释器执行del s[2]的结果为（ D ）。

A．3

B．2

C．{1，2}

D．TypeError: 'set' object doesn't support item deletion

2．Python 3解释器执行{1, 2, 'a'} | {2, 3, 4}的结果为（ B ）。

A．{2,3,4}

B．{1, 2, 3, 4, 'a'}

C．{1,2,3,4}

D．{2,3,4,'a'}

3．Python中，对于已定义的集合fruits = {"苹果", "橘子", "梨", "香蕉"}，以下删除集

合元素的方法，不能成功执行的是（ ）。

A．("梨")

B．d ("梨")

C．()

D．("梨")

4．Python中，集合中添加的元素内容不能是（ A ）。

A．列表

B．字符串

C．元组

D．数字

5．Python中，对于已定义的集合fruits = {"苹果", "橘子"}，以下语句无法成功执行的

是（ B ）。

A．("香蕉")

B．("香蕉")

C．({"香蕉"})

D．()

6．Python中，以下关于集合的描述错误的是（ D ）。

A．无法删除集合中指定位置的元素，只能删除特定值的元素。

B．Python集合中的元素不允许重复。

C．Python集合是无序的。

D．Python集合可以包含相同的元素。

7．表达式{1, 2, 3} | {3, 4, 5}的值为（ C ）。

A．{2, 3}

B．{1}

C．{1, 2, 3, 4, 5}

21

D．{}

8．表达式{1, 2, 3} & {2, 3, 4}的值为（ A ）。

A．{2, 3}

B．{1,4}

C．{1, 2, 3, 4, 5}

D．{}

9．表达式{1, 2, 3, 4, 5} ^ {4, 5, 6, 7}的值为（ C ）。

A．{1, 2, 3, 4, 5, 6, 7}

B．{4, 5}

C．{1, 2, 3, 6, 7}

D．{1, 2, 3}

（二）填空题

1．Python 3解释器执行{2, 3, 4}.issubset({2, 3, 4})的结果为{ True }。

2．表达式{1, 2, 3, 4, 5, 6} ^ {5, 6, 7, 8}的值为{ {1, 2, 3, 4, 7, 8} }。

3．表达式type({}) == set的值为{ False }。

4．已知x = [1, 2, 3]，那么表达式not (set(x*100)-set(x))的值为{ True }。

5．已知x = [1, 2, 3]，那么表达式not (set(x*100)&set(x))的值为{ False }。

6．表达式3 in {1, 2, 3}的值为{ True }。

7．表达式set([1,2,3]) == {1, 2, 3}的值为{ True }。

8．表达式set([1,2, 2,3]) == {1, 2, 3}的值为{ True }。

9．表达式{1, 2, 3} | {3, 4, 5}的值为{ {1, 2, 3, 4, 5} }。

10．表达式set([1, 1, 2, 3])的值为{ {1, 2, 3} }。

11．表达式{1, 2, 3} & {3, 4, 5}的值为{ {3} }。

12．表达式{1, 2, 3} & {2, 3, 4}的值为{ {2, 3} }。

13．表达式{1, 2, 3} - {3, 4, 5}的值为{ {1, 2} }。

14．表达式{1, 2, 3} < {3, 4, 5}的值为{ False }。

15．表达式{1, 2, 3} < {1, 2, 4}的值为{ False }。

16．已知x = {1, 2, 3}，那么执行语句(3)之后，x的值为{ {1, 2, 3} }。

17．表达式{1, 2, 3, 4, 5} ^ {4, 5, 6, 7}的值为{ {1, 2, 3, 6, 7} }。

18．Python运算符中用来计算集合并集的是{ | }。

19．表达式type({3})的值为{ }。

（三）判断题

1．运算符“-”可以用于集合的差集运算。（ 对 ）

2．集合可以作为列表的元素。（ 对 ）

3．字典可以作为集合的元素。（ 错 ）

4．可以使用del删除集合中的部分元素。（ 错 ）

5．表达式{1, 2} * 2的值为{1, 2, 1, 2}。（ 错 ）

6．Python集合支持双向索引。（ 错 ）

7．表达式{1, 3, 2}>{1, 2, 3}的值为True。（ 错 ）

8．Python集合不支持使用索引访问其中的元素。（ 对 ）

9．无法删除集合中指定位置的元素，只能删除特定值的元素。（ 对 ）

10．Python字典和集合支持双向索引。（ 错 ）

11．Python集合中的元素不允许重复。（ 对 ）

12．Python集合可以包含相同的元素。（ 错 ）

22

13．Python集合中的元素可以是元组。（ 对 ）

14．Python集合中的元素可以是列表。（ 错 ）

15．已知A和B是两个集合，并且表达式AB的值

一定为True。（ 错 ）

16．列表可以作为集合的元素。（ 错 ）

17．Python内置的集合set中元素顺序是按元素的哈希值进行存储的，并不是按先后

顺序。（ 对 ）

单元4 序列数据与正则表达式操作——字符串

（一）选择题

1．Python解释器执行'123'.isdigit()方法返回的结果是（ A ）。

A．True

B．False

C．'True'

D．因语法错误而报错

2．Python解释器执行'-'.join({'a':'b','c':'d'})的结果为（ A ）。

A．'a-c'

B．'a-b-c-d'

C．'b-d'

D．报错

3．Python中，判断一个字符串是否全由数字组成的方法为ric()，那么在

Python 3中执行print('123'.isnumeric(),u'123'.isnumeric())得到的结果为（ C ）。

A．Ture False

B．False True

C．Ture True

D．True 报错

4．Python 3解释器执行'AB2C3D'.lower().title()的结果是（ B ）。

A．'Ab2c3d'

B．'Ab2C3D'

C．'AB2C3D'

D．语法错误

5．在Python中，字符串s = 'abc'，那么执行表达式s+'d'之后，s的打印结果是

（ A ）。

A．'abc'

B．'abcd'

C．'abc+d'

D．报错

6．关于字符串的replace()方法，正确的选项是（ BC ）。

A．replace()方法如果没有替换成功则报错

B．replace()方法如果没有替换成功则将原字符串返回

C．replace()方法如果替换成功则返回新的字符串

D．replace()方法如果替换成功则返回原字符串

7．Python解释器执行'1234'.find('5')的结果是（ A ）。

A．-1

23

B．None

C．空

D．报错

8．Python解释器执行'abbacabb'.strip('ab')的结果是（ C ）。

A．'aca'

B．'ca'

C．'c'

D．语法错误

9．Python解释器执行'n'.join(('ab','cd','we','xy'))的结果为（ D ）。

A．报错

B．'abcdwexy'

C．'abcdwexy'

D．'abncdnwenxy'

10．下列实例变量a的值为字符串"hello"，变量b的值为"mooc"，以下选项属于正确

字符串运算的是（ ABCD ）。

A．a+b

B．a*2

C．'h' in a

D．print("Learn Python in {}".format(b))

11．Python解释器执行print('金额：{0:f}元'.format(1.5000))的结果为（ C ）。

A．金额：1.5 元

B．金额：1.500 元

C．金额：1.500000元

D．金额：￥1.50000元

12．"ab"+"c"*2的结果是（ C ）。

A．abc2 B．abcabc C．abcc D．ababcc

13．在Python解释器中，执行print('{:.7f}'.format(1.12345678))的结果为（ D ）。

A．1.1234567

B．1.1234578

C．1.12345678

D．1.1234568

14．下列关于字符串下列说法错误的是（ B ）。

A．字符应该视为长度为1的字符串

B．字符串以0标志字符串的结束

C．既可以用单引号，也可以用双引号创建字符串

D．在三引号字符串中可以包含换行符、回车符等特殊字符

15．以下为正确的字符串的是（ BD ）。

A．'abc"ab"

B．'abc"ab'

C．abc"ab"

D．"abc"ab"

16．有如下代码。

str1 = "wow!!!"

str2 = "exam"

24

print((str2, 5))

输出的结果是（ A ）。

A．6

B．7

C．8

D．-1

17．下列对count()、index()、find()方法描述正确的是（ A ）。

A．count()方法用于统计字符串里某个字符出现的次数

B．find()方法检测字符串中是否包含子字符串str，如果包含子字符串返回开始的索引

值，否则会报一个异常

C．index()方法检测字符串中是否包含子字符串str，如果str不存在返回-1

D．以上都错误

18．下列说法错误的是（ A ）。

A．除字典类型外，所有标准对象均可以用于布尔测试

B．空字符串的布尔值是False

C．空列表对象的布尔值是False

D．值为0的任何数字对象的布尔值是False

（二）填空题

1．Python 3解释器执行'new'.center(7,'-')的结果为{ '--new--' }。

2．Python 3解释器执行'abcdd'.endswith('cd')的结果是{ False }。

3．Python 3解释器执行'abc'.isnumeric()的结果是{ False }。

4．已知x = 'aabcccdddd'，那么表达式''.join([v for i,v in enumerate(x[:-1]) if v==x[i+1]])

的值为{ 'accddd' }。

5．假设正则表达式模块re已正确导入，那么表达式''.join(l('d+', 'abcd1234'))的

值为{ '1234 }。

6．假设正则表达式模块re已正确导入，那么表达式l('d+?', 'abcd1234')的值为

{ ['1', '2', '3', '4'] }。

7．假设正则表达式模块re已正确导入，那么表达式('(.s)1+', '1', 'aaaaabb')的值

为{ 'aaaaabb' }。

8．字符串编码格式UTF-8使用{ 3 }个字节表示1个汉字。

9．字符串编码格式GBK使用{ 2 }个字节表示1个汉字。

10．已知字符串编码格式UTF-8使用3个字节表示1个汉字、1个字节表示英语字

母，那么表达式len('abc你好')的值为{ 5 }。

11．已知字符串编码格式UTF-8使用3个字节表示1个汉字、1个字节表示英语字

母，那么表达式len('abc你好'.encode())的值为{ 9 }。

12．已知字符串编码格式GBK使用2个字节表示1个汉字、1个字节表示英语字母，

那么表达式len('abc你好'.encode('gbk'))的值为{ 7 }。

13．已知ord('A')的值为65，并且hex(65)的值为'0x41'，那么表达式'x41b'的值为

{ 'Ab }。

14．已知x = 'Hello Python'，那么表达式('x')和('x')的值都为{ -1 }。

15．表达式':'.join('Hello Python'.split())的值为{ 'Hello:Python' }。

16．已知x = 'Hello Python'，那么表达式e('l', 'g')的值为{ 'Heggo Python' }。

17．假设已成功导入Python标准库string，那么表达式len()的值为

{ 10 }。

25

18．表达式'aaaassddf'.strip('af')的值为{ 'ssdd' }。

19．表达式len('aaaassddf'.strip('afds'))的值为{ 0 }。

20．表达式len('Hello Python' [100:])的值为{ 0 }。

21．已知x = 'abcd'和y = 'abcde'，那么表达式[i==j for i,j in zip(x,y)]的值为{ [True,

True, True, True] }。

22．表达式'ac' in 'abce'的值为{ False }。

23．表达式'Beautiful is better than ugly'.startswith('Be', 5)的值为{ False }。

24．正则表达式模块re的{ compile() }方法用来编译正则表达式对象。

25．正则表达式模块re的{ match() }方法用来在字符串开始处进行指定模式的匹

配。

26．正则表达式模块re的{ search() }方法用来在整个字符串中进行指定模式的匹

配。

27．表达式'abc' in ('abcdefg')的值为{ True }。

28．表达式'abc' in ['abcdefg']的值为{ False }。

29．表达式len('better')的值为{ 6 }。

30．表达式'Hello Python!'.count('l')的值为{ 2 }。

31．已知x ='abcdefg'，则表达式x[3:] + x[:3]的值为{ 'defgabc' }。

32．表达式'aaasdf'.lstrip('as')的值为{ 'df' }。

33．表达式'aaasdf'.lstrip('af')的值为{ 'sdf' }。

34．表达式'aaasdf'.strip('af')的值为{ 'sd' }。

35．表达式'aaasdf'.rstrip('af')的值为{ 'aaasd' }。

36．表达式'The first:{1}, the secondis {0}'.format(65,97)的值为{ 'The first:97, the

secondis 65' }。

37．表达式'{0:#d},{0:#x},{0:#o}'.format(65)的值为{ '65,0x41,0o101' }。

38．表达式isinstance('abcdefg', str)的值为{ True }。

39．表达式isinstance('abcdefg', object)的值为{ True }。

40．表达式'abcabcabc'.rindex('abc')的值为{ 6 }。

41．表达式':'.join('abcdefg'.split('cd'))的值为{ 'ab:efg' }。

42．表达式'I like Python'.rfind('Python')的值为{ 7 }。

43．表达式'abcabcabc'.count('abc')的值为{ 3 }。

44．表达式',banana,pear'.find('p')的值为{ 1 }。

45．表达式',banana,pear'.find('ppp')的值为{ -1 }。

46．表达式'abcdefg'.split('d')的值为{ ['abc', 'efg'] }。

47．表达式':'.join('1,2,3,4,5'.split(','))的值为{ '1:2:3:4:5' }。

48．表达式','.join('abcccnnnddd'.split())的值为{ 'abccc,ddd' }。

49．表达式'Hello Python'.upper()的值为{ 'HELLO PYTHON' }。

50．表达式'Hello Python'.lower()的值为{ 'Hello Python' }。

51．表达式'Hello Python'.lower().upper()的值为{ 'HELLO PYTHON' }。

52．表达式'Hello Python'.swapcase().swapcase()的值为{ 'Hello Python' }。

53．表达式r'c:'.endswith('.exe')的值为{ True }。

54．表达式r'c:'.endswith(('.jpg', '.exe'))的值为{ True }。

55．表达式'C:'.startswith('C:')的值为{ True }。

56．表达式len('Hello Python! '.ljust(20))的值为{ 20 }。

57．表达式len('abcdefg'.ljust(3))的值为{ 7 }。

26

58．表达式'a' + 'b'的值为{ 'ab' }。

59．已知x = '123'和y ='456'，那么表达式x + y的值为{ '123456' }。

60．表达式'a'.join('abc'.partition('a'))的值为{ 'aaabc' }。

61．已知x ='a234b123c'，并且re模块已导入，则表达式('d+', x)的值为{ ['a',

'b', 'c'] }。

62．表达式''.join('asdssfff '.split('sd'))的值为{ 'assfff ' }。

63．表达式''.join(('[sd]', 'asdssfff '))的值为{ 'afff ' }。

64．语句print(('abc', 'defg'))的输出结果为{ None }。

65．表达式'Hello Python!'[-4]的值为{ 'h' }。

66．表达式'Hello Python!'[-4:]的值为{ 'hon!' }。

67．表达式''.endswith(('.py', '.pyw'))的值为{ True }。

68．表达式len('abc'.ljust(20))的值为{ 20 }。

69．代码print(('^[a-zA-Z]+$ ', 'abcDEFG000'))的输出结果为{ None }。

70．当在字符串前加上小写字母{ r}或大写字母{R }表示原始字符串，不对其中的

任何字符进行转义。

71．在设计正则表达式时，字符{ ? }紧随任何其他限定符(*、+、?、{n}、{n,}、

{n,m})之后时，匹配模式是非贪婪匹配的，匹配搜索到的、尽可能短的字符串。

72．假设正则表达式模块re已导入，那么表达式('d+', '1',

'a12345bbbb67c890d0e')的值为{ 'a1bbbb1c1d1e' }。

73．表达式'abcab'.replace('a', 'yy')的值为{ 'yybcyyb' }。

74．已知table =''.maketrans('abcw', 'xyzc')，那么表达式'Hellow world'.translate(table)的

值为{ 'Helloc corld' }。

75．表达式'hello python'.replace('hello', 'hi')的值为{ 'hi python' }。

76．已知字符串x ='Hello Python'，那么执行语句e('hello', 'hi')之后，x的值为

{ 'Hello Python' }。

77．正则表达式元字符{ + }用来表示该符号前面的字符或子模式出现1次或多次。

78．已知x ='abcd'，那么表达式','.join(())的值为{ 'abcd' }。

79．正则表达式元字符{ * }用来表示该符号前面的字符或子模式出现0次或多次。

80．表达式'abcab'.strip('ab')的值为{ 'c' }。

81．表达式''.endswith(('.txt', '.doc', '.jpg'))的值为{ True }。

82．表达式'abc10'.isalnum()的值为{ True }。

83．表达式'abc10'.isalpha()的值为{ False }。

84．表达式'abc10'.isdigit()的值为{ False }。

85．表达式'C:'.endswith('.exe')的值为{ True }。

86．列表、元组、字符串是Python的{ 有序 }序列。

87．任意长度的Python列表、元组和字符串中最后一个元素的索引为{ -1 }。

88．Python语句''.join(list('Hello Python!'))执行的结果是{ 'Hello Python!' }。

89．转义字符'n'的含义是{ 换行 }。

90．表达式'ab' in 'acbed'的值为{ False }。

91．表达式eval('3+5')的值为{ 8 }。

92．表达式eval('[1, 2, 3]')的值为{ [1, 2, 3] }。

93．表达式str([1, 2, 3])的值为{ '[1, 2, 3]' }。

94．已知path = r'c:'，那么表达式path[:-4]+ 'htm'的值为{ 'c:' }。

（三）判断题

27

1．加法运算符可以用来连接字符串并生成新字符串。（ 对 ）

2．正则表达式'^http'只能匹配所有以'http'开头的字符串。（ 对 ）

3．正则表达式'^d{18}|d{15}$'只能检查给定字符串是否为18位或15位数字字符，并

不能保证一定是合法的身份证号。（ 对 ）

4．正则表达式' [^abc] '可以匹配任意一个除'a'、'b'、'c'之外的字符。（ 对 ）

5．正则表达式'Python|perl'或'p(ython|erl) '都可以匹配'Python'或'perl'。（ 对 ）

6．已知x为非空字符串，那么表达式''.join(()) == x的值一定为True。（ 错 ）

7．已知x为非空字符串，那么表达式', '.join((', ')) == x的值一定为True。

（ 对 ）

8．正则表达式对象的match()方法可以在字符串的指定位置开始进行指定模式的匹

配。（ 对 ）

9．使用正则表达式对字符串进行分割时，可以指定多个分隔符，而字符串对象的

split()方法无法做到这一点。（ 对 ）

10．正则表达式元字符“^”一般用来表示从字符串开始处进行匹配，用在一对方括号

中的时候则表示反向匹配，不匹配方括号中的字符。（ 对 ）

11．正则表达式元字符's'用来匹配任意空白字符。（ 对 ）

12．正则表达式元字符'd'用来匹配任意数字字符。（ 对 ）

13．假设re模块已成功导入，并且有pattern = e('^'+'. '.join([r'd{1,3}' for i in

range(4)])+ '$')，那么表达式('192.168.1.103')的值为None。（ 错 ）

14．已知x和y是两个字符串，那么表达式sum((1 for i,j in zip(x,y) if i==j))可以用来计

算两个字符串中对应位置字符相等的个数。（ 对 ）

15．Python字符串方法replace()对字符串进行原地修改。（ 错 ）

16．如果需要连接大量字符串成为一个字符串，那么使用字符串对象的join()方法比使

用运算符“+”具有更高的效率。（ 对 ）

17．正则表达式模块re的match()方法是从字符串的开始处匹配特定模式，而search()

方法是在整个字符串中寻找模式，这两种方法如果匹配成功则返回match对象，匹配失败

则返回空值None。（ 对 ）

18．相同内容的字符串使用不同的编码格式进行编码得到的结果并不完全相同。

（ 对 ）

19．表达式'a'+1的值为'b'。（ 错 ）

20．放在一对三引号之间的任何内容将被认为是注释。（ 错 ）

21．在UTF-8编码中1个汉字需要占用3个字节。（ 对 ）

22．在GBK和CP936编码中1个汉字需要占用2个字节。（ 对 ）

23．字符串属于Python有序序列，和列表、元组一样都支持双向索引。（ 对 ）

24．Python中的列表、元组、字符串都属于有序序列。（ 对 ）

单元5 函数应用与模块化程序设计

（一）选择题

1．Python中“==”运算符用于比较两个对象的值，下列选项中属于is比较对象的因

素的是（ A ）。

A．id()

B．sum()

C．max()

28

D．min()

2．调用以下函数返回的值是（ D ）。

def myfun()

pass

A．0

B．出错不能运行

C．空字符串

D．None

3．函数如下。

def showNumber(numbers):

for n in numbers:

print(n)

下列选项中在调用函数时会报错的是（ C

A．showNumber([2,4,5])

B．showNumber('abcesf ')

C．showNumber(3.4)

D．showNumber((12,4,5))

4．函数如下。

def chanageInt(number2):

number2 = number2+1

print("changeInt:number2=",number2)

number1 = 2

chanageInt(number1)

print("number:",number1)

输出结果正确的是（ B ）。

A．changeInt: number2= 3

number: 3

B．changeInt:number2= 3

number: 2

C．number: 2

changeInt: number2= 2

D．number: 2

changeInt: number2= 3

5．函数如下。

def changeList(list):

(" end")

print("list",list)

#调用

strs =['1','2']

changeList(strs)

print("strs",strs)

下列对strs和list的值输出正确的是( D

A．strs['1','2']

B．list['1','2']

29

）。

)

C．list['1', '2', ' end']

D．strs['1', '2', ' end']

6．导入模块的方式错误的是（ D ）。

A．import test

B．from test import *

C．import test as m

D．import m from test

7．以下关于模块说法错误的是（ C ）。

A．一个文件就是一个模块

B．任何一个普通的文件都可以作为模块导入

C．模块文件的扩展名不一定是.py

D．运行代码时会从指定的文件夹搜索导入的模块，如果没有会报错

8．以下关于函数定义的规则，正确的描述有（ ABCD ）。

A．函数代码块以def关键字开头，后接函数标识符名称和圆括号()

B．任何传入参数和自变量必须放在圆括号中间，可以在圆括号之间定义参数

C．return [表达式]结束函数，选择性地返回一个值给调用方

D．函数内容以冒号起始，并且要缩进

9．下列代码的运行结果是（ A ）。

def total(a, b=3, c=5):

return a+b+c

print(total(a=8, c=2))

A．13

B．16

C．15

D．14

10．下列代码的运行结果是（ A ）。

def total(*p):

return sum(p)

print(total(3, 5, 8))

A．16

B．8

C．20

D．22

11．下列代码的运行结果是（ B ）。

def demo(*p):

return sum(p)

print(demo(1,2,3))

A．15

B．6

C．23

D．8

12．下列代码的运行结果是（ C ）。

def demo(a, b, c=3, d=100):

return sum((a,b,c,d))

30

print(demo(1, 2, d=3))

A．11

B．10

C．9

D．8

13．下列代码的运行结果是（ A ）。

def demo():

x = 5

x = 3

demo()

print(x)

A．3

B．4

C．5

D．6

（二）填空题

1．Python标准库math中用来计算平方根的函数是{ sqrt() }。

2．查看变量内存地址的Python内置函数是{ id() }。

3．已知x = 3，并且id(x)的返回值为496103280，那么执行语句x += 6之后，表达式

id(x) == 496103280 的值为{ False }。

4．表达式int('123', 16)的值为{ 291 }。

5．表达式int('123', 8)的值为{ 83 }。

6．表达式int('123')的值为{ 123 }。

7．表达式int('101',2)的值为{ 5 }。

8．表达式abs(-3)的值为{ 3 }。

9．Python内置函数{ len() }可以返回列表、元组、字典、集合、字符串以及range

对象中元素的个数。

10．Python内置函数{ max() }用来返回序列中的最大元素。

11．Python内置函数{ min() }用来返回序列中的最小元素。

12．Python内置函数{ sum() }用来返回数值型序列中所有元素之和。

13．表达式chr(ord('a')^32)的值为{ 'A' }。

14．表达式abs(3+4j)的值为{ 5.0 }。

15．表达式callable(int)的值为{ True }。

16．表达式sum(range(1, 10, 2))的值为{ 25 }。

17．表达式sum(range(1, 10))的值为{ 45 }。

18．表达式sum(range(10))的值为{ 45 }。

19．表达式range(10)[-1]的值为{ 9 }。

20．表达式range(10,20)[4]的值为{ 14 }。

21．表达式round(3.4)的值为{ 3 }。

22．表达式round(3.7)的值为{ 4 }。

23．Python中定义函数的关键字是{ def }。

24．如果函数中没有return语句或者return语句不带任何返回值，那么该函数的返回

值为{ None }。

25．已知x为非空列表，那么表达式(x) in x的值为{ True }。

31

26．Python标准库random中的{ choice() }方法的作用是从序列中随机选择一个元

素。

27．在Python中定义类时，与运算符“**”对应的特殊方法为 { pow() }。

28．已知f = lambda x: x+5，那么表达式f(3)的值为{ 8 }。

29．已知g = lambda x, y=3, z=5: x+y+z，那么表达式g(2)的值为{ 10 }。

30．假设有Python程序文件，其中只有一条语句print(__name__)，那么直接运

行该程序文件得到的结果为{ __main__ }。

31．已知函数定义

def func(*p):

return sum(p)

那么表达式func(1,2,3)的值为{ 6 }。

32．已知函数定义

def func(*p):

return sum(p)

那么表达式func(1,2,3, 4)的值为{ 10 }。

33．已知函数定义

def func(**p):

return sum(())

那么表达式func(x=1, y=2, z=3)的值为{ 6 }。

34．已知函数定义

def func(**p):

return ''.join(sorted(p))

那么表达式func(x=1, y=2, z=3)的值为{ 'xyz' }。

35．已知f = lambda x: 5，那么表达式f(3)的值为{ 5 }。

36．已知函数定义

def demo(x, y, op):

return eval(str(x)+op+str(y))

那么表达式demo(3, 5, '+')的值为{ 8 }。

37．已知函数定义

def demo(x, y, op):

return eval(str(x)+op+str(y))

那么表达式demo(3, 5, '*')的值为{ 15 }。

38．已知函数定义

def demo(x, y, op):

return eval(str(x)+op+str(y))

那么表达式demo(3, 5, '-')的值为{ -2 }。

39．假设有Python程序文件，代码如下。

def main():

if __name__ == '__main__':

print(1)

else:

print(2)

main()

将该程序文件直接运行时输出的结果为{ 1 }，作为模块导入时得到的结果为

32

{ 2 }。

40．自定义函数时，函数代码块以def关键字开头，后接函数标识符名称和{ 圆括

号 }。

41．random模块中{ shuffle() }方法的作用是将列表中的元素随机乱序。

42．若g = lambda x, y=3, z=5: x*y*z，则语句print(g(1))的输出结果为{ 15 }。

43．假设已从标准库functools导入reduce()函数，那么表达式reduce(lambda x, y: x-y,

[1, 2, 3])的值为{ -4 }。

44．假设已从标准库functools导入reduce()函数，那么表达式reduce(lambda x, y: x+y,

[1, 2, 3])的值为{ 6 }。

45．已知有函数定义def demo(*p):return sum(p)，那么表达式demo(1, 2, 3)的值为

{ 6 }，表达式demo(1, 2, 3, 4)的值为{ 10 }。

46．执行语句x,y,z = map(str, range(3))之后，变量y的值为{ '1' }。

47．表达式len(range(1, 10))的值为{ 9 }。

48．表达式len('北京'.encode('utf-8'))的值为{ 6 }。

49．表达式len('北京'.encode('gbk'))的值为{ 4 }。

50．表达式chr(ord('A')+2)的值为{ 'C' }。

51．假设math标准库已导入，表达式eval('(9)')的值为{ 3.0 }。

52．假设math标准库已导入，表达式eval('(3**2+4**2)')的值为{ 5.0 }。

53．假设math标准库已导入，表达式eval('(4)')的值为{ 2.0 }。

54．表达式len([i for i in range(10)])的值为{ 10 }。

55．表达式len(range(1,10))的值为{ 9 }。

（三）判断题

1．Python扩展库需要导入以后才能使用其中的对象，Python标准库不需要导入即可

使用其中的所有对象和方法。（ 错 ）

2．调用函数时，在实参前面加一个星号“*”表示序列解包。（ 对 ）

3．尽管可以使用import语句一次导入任意多个标准库或扩展库，但是仍建议每次只

导入一个标准库或扩展库。（ 对 ）

4．函数是代码复用的一种方式。（ 对 ）

5．定义函数时，即使该函数不需要接收任何参数，也必须保留一对空的圆括号来表示

这是一个函数。（ 对 ）

6．编写函数时，一般建议先对参数进行合法性检查，然后再编写正常的功能代码。

（ 对 ）

7．一个函数如果带有默认值参数，那么必须所有参数都设置默认值。（ 错 ）

8．定义Python函数时必须指定函数返回值类型。（ 错 ）

9．定义Python函数时，如果函数中没有return语句，则默认返回空值None。

（ 对 ）

10．如果在函数中有语句 return 3，那么该函数一定会返回整数3。（ 错 ）

11．函数中必须包含return语句。（ 错 ）

12．函数中的return语句一定能够得到执行。（ 错 ）

13．在函数内部直接修改形参的值并不影响外部实参的值。（ 对 ）

14．没有任何方法可以在函数内部通过形参影响实参的值。（ 错 ）

15．调用带有默认值参数的函数时，不能为默认值参数传递任何值，必须使用函数定

义时设置的默认值。（ 错 ）

16．形参可以看作函数内部的局部变量，函数运行结束之后形参就不可访问了。

33

（ 对 ）

17．假设已导入random标准库，那么表达式max([t(1, 10) for i in

range(10)]) 的值一定是10。（ 错 ）

18．Python标准库random的方法randint(m,n)用于生成一个[m,n]区间上的随机整数。

（ 对 ）

19．在Python中定义函数时不需要声明函数参数的类型。（ 对 ）

20．在Python中定义函数时不需要声明函数的返回值类型。（ 对 ）

21．在定义函数时，某个参数名字前面带有一个*符号表示可变长度参数，可以接收任

意多个普通实参并存放于一个元组之中。（ 对 ）

22．在定义函数时，某个参数名字前面带有两个*符号表示可变长度参数，可以接收任

意多个关键参数并将其存放于一个字典之中。（ 对 ）

23．在定义函数时，带有默认值的参数必须出现在参数列表的最右端，任何一个带有

默认值的参数右边不允许出现没有默认值的参数。（ 对 ）

24．在调用函数时，可以通过关键字参数的形式进行传值，从而避免必须记住函数形

参顺序的麻烦。（ 对 ）

25．在调用函数时，必须牢记函数形参顺序才能正确传值。（ 错 ）

26．调用函数时传递的实参个数必须与函数形参个数相等才行。（ 错 ）

27．在编写函数时，建议首先对形参进行类型检查和数值范围检查，之后再编写功能

代码，或者使用异常处理结构，尽量避免代码抛出异常而导致程序崩溃。（ 对 ）

28．执行语句from math import sin之后，可以直接使用sin()函数，例如 sin(3)。

（ 对 ）

29．lambda表达式中可以使用任意复杂的表达式，但是必须只编写一个表达式。

（ 对 ）

30．在Python 3中reduce()是内置函数。（ 错 ）

31．使用random模块的函数randint(1, 100)获取随机数时，有可能会得到100。

（ 对 ）

32．如果只需要math模块中的sin()函数，建议使用from math import sin来导入，而

不要使用import math导入整个模块。（ 对 ）

33．内置函数len()返回指定序列的元素个数，适用于列表、元组、字典、集合、字符

串等迭代对象。（ 对 ）

34．包含yield语句的函数一般为生成器函数，可以用来创建生成器对象。（ 对 ）

35．在函数中yield语句的作用和return语句的作用完全一样。（ 错 ）

36．无法使用lambda表达式定义有名字的函数。（ 错 ）

37．假设random模块已导入，那么表达式(range(10), 20)的作用是生成

20个不重复的整数。（ 错 ）

38．假设random模块已导入，那么表达式(range(10), 7)的作用是生成7

个不重复的整数。（ 对 ）

单元6 类定义与使用

（一）选择题

1．以下不属于面向对象的特征的是（ D ）。

A．封装

B．继承

34

C．多态

D．复合

2．定义类如下。

class Test()

pass

下面说法正确的是（ CD ）。

A．该类实例中包含__dir__()方法

B．该类实例中包含__hash__()方法

C．该类实例中只包含__dir__()方法，不包含__hash__()方法

D．该类没有定义任何方法，所以该实例中没有包含任何方法

3．实现以下方法可以让对象像函数一样被调用的是（ C ）。

A．str()

B．iter()

C．call()

D．next()

4．定义类如下。

class Show:

def showInfo(self):

print(self.x)

下面描述正确的是（ BC ）

A．该类不可以实例化

B．该类可以实例化，但不能通过对象正常调用showInfo()

C．在PyCharm中该类实例化运行时会出现语法错误，显示“‘Show’

attribute ‘x’”

D．该类可以实例化，并且能正常通过对象调用showInfo()

5．关于Python类说法错误的是（ B ）。

A．类的实例方法必须创建对象后才可以调用

B．类的实例方法必须在创建对象前才可以调用

C．类的类方法可以使用对象名和类名来调用

D．类的静态属性可以用类名和对象名来调用

6．定义类如下。

class Show:

def __init__(self,name):

=name

def showInfo(self):

print()

下面代码能正常执行的是（ C ）。

A．

h = Show

fo()

B．

h = Show()

fo("张三")

C．

35

object has no

h = Show("张三")

fo()

D．

h = Show('admin ')

showInfo

7．定义类如下：

class A():

def a(self):

print("a")

class B():

def b(self):

print("b")

class C():

def c(self):

print("c")

class D(A, C):

def d(self):

print("d")

d= D()

d.a()

d.c()

d.d()

程序能执行的结果是（ D ）。

A．d

B．a,d

C．d a

D．a c d

8．在类外部访问类内定义的类属性，有效的访问形式有（ BD ）。

A．属性名称

B．类名称.属性名称

C．self.属性名称

D．类实例名称.属性名称

9．以下关于类属性的描述，正确的是（ AB ）。

A．类属性是在类中定义在方法之外的变量

B．类属性是所有实例化对象公用的，可以通过类名称或实例名称访问类属性

C．类属性只能通过实例名称访问，不能通过类名称访问

D．类属性通常在类的__init__()方法内部定义

10．以下关于实例属性的描述，正确的是（ BCD ）。

A．实例属性是所有实例化对象公用的，可以通过类名称或实例名称访问类属性

B．由于实例属性的优先级比类属性的高，相同名称的实例属性将屏蔽掉类属性

C．实例属性只属于类的实例，只能通过实例名称访问

D．实例属性是指定义在方法内部的属性

（二）填空题

1．Python使用{ class }关键字来定义类。

36

2．Python内建异常类的基类是{ BaseException }。

3．在Python中，不论类的名字是什么，构造方法的名字都是{ __init__() }。

4．如果在设计一个类时实现了contains()方法，那么该类的对象会自动支持{ in }运

算符。

5．Python身份运算符{ is }用于判断两个变量的引用对象是否为同一个。

6．在Python类的内部，使用def关键字可以定义属于类的方法，这种方法需要使用

{ @classmethod }来修饰。

7．在Python类的内部，可以定义静态方法，这种静态方法需要使用

{ @staticmethod }来修饰。

8．Python中，类有一个名为{ __init__() }的特殊方法称为构造方法，该方法在类实

例化时会自动调用，不需要显式调用。

9．当内部作用域想修改外部作用域的变量时，需要使用关键字{ global }。

10．Python中，可以通过{ @property }将一个方法转换为只读属性，从而实现专用

于计算的属性。

11．在函数内部可以通过关键字{ global }来定义全局变量。

12．可以使用内置函数{ globals() }查看包含当前作用域内所有全局变量和值的字

典。

13．可以使用内置函数{ locals() }查看包含当前作用域内所有局部变量和值的字

典。

（三）判断题

1．继承自类的子类中不能有普通的成员方法。（ 错 ）

2．Python中一切内容都可以称为对象。（ 对 ）

3．在一个软件的设计与开发过程中，所有类名、函数名、变量名都应该遵循统一的风

格和规范。（ 对 ）

4．定义类时所有实例方法的第一个参数用来表示对象本身，在类的外部通过对象名来

调用实例方法时不需要为该参数传值。（ 对 ）

5．在面向对象程序设计中，函数和方法是完全一样的，都必须为所有参数进行传值。

（ 错 ）

6．Python中没有严格意义上的私有成员。（ 对 ）

7．在Python中定义类时，运算符重载是通过重写特殊方法实现的。例如，在类中实

现了mul()方法即可支持该类对象的**运算符。（ 对 ）

8．对于Python类中的私有成员，可以通过“类实例名称._类名称.私有成员名”的方

式来访问。（ 对 ）

9．如果定义类时没有编写析构方法，Python将提供一个默认的析构方法进行必要的

资源清理工作。（ 对 ）

10．在子类中可以通过“基类名.方法名()”的方式来调用基类中的方法。（ 对 ）

11．Python支持多重继承，如果父类中有相同的方法名，而在子类中调用时没有指定

父类名，则Python解释器将从左向右按顺序进行搜索。（ 对 ）

12．在Python中定义类时实例方法的第一个参数名称必须是self。（ 错 ）

13．在Python中定义类时实例方法的第一个参数名称不管是什么，都表示对象自身。

（ 对 ）

14．定义类时如果实现了contains()方法，该类对象即可支持成员运算符。（ 对 ）

15．定义类时如果实现了len()方法，该类对象即可支持内置函数len()。（ 对 ）

16．定义类时如果实现了eq()方法，该类对象即可支持运算符“==”。（ 对 ）

37

17．定义类时如果实现了pow()方法，该类对象即可支持运算符“**”。（ 对 ）

18．在Python中定义类时，如果某个成员名称前有双下划线则表示是私有成员。

（ 对 ）

19．在类外部没有任何办法可以访问对象的私有成员。（ 错 ）

20．Python类的构造方法是__init__()。（ 对 ）

21．定义类时，在一个方法前面使用@classmethod进行修饰，则该方法属于类方法。

（ 对 ）

22．定义类时，在一个方法前面使用@staticmethod进行修饰，则该方法属于静态方

法。（ 对 ）

23．通过对象不能调用类方法和静态方法。（ 错 ）

24．在Python中可以为自定义类的对象动态增加新成员。（ 对 ）

25．Python类不支持多重继承。（ 错 ）

26．属性可以像数据成员一样进行访问，但赋值时具有方法的优点，可以对新值进行

检查。（ 对 ）

27．只可以动态地为对象增加数据成员，而不能为对象动态地增加成员方法。

（ 错 ）

28．任何包含call()方法的类的对象都是可调用的。（ 对 ）

29．在Python中函数和类都属于可调用对象。（ 对 ）

30．在设计子类时，父类的私有成员默认是不会继承的。（ 对 ）

31．不同作用域中的同名变量之间互相不影响，也就是说，在不同的作用域内可以定

义同名的变量。（ 对 ）

32．全局变量会增加不同函数之间的隐式耦合度，从而降低代码可读性，因此应尽量

避免过多使用全局变量。（ 对 ）

33．函数内部定义的局部变量当函数调用结束后被自动删除。（ 对 ）

34．在函数内部，既可以使用global关键字来声明使用外部全局变量，也可以使用

global关键字直接定义全局变量。（ 对 ）

35．在函数内部没有办法定义全局变量。（ 错 ）

36．在同一个作用域内，局部变量会隐藏同名的全局变量。（ 对 ）

37．在函数内部没有任何声明的情况下直接为某个变量赋值，这个变量一定是函数内

部的局部变量。（ 对 ）

单元7 文件操作与异常处理

（一）选择题

1．Python中，打开文本文件可以有多种方式，以下选项错误的是

（ D ）。

A．""

B．"demo/"

C．r""

D．""

2．打开的文件不存在时，会引发的异常是（ A ）。

A．IOError

B．ImportError

C．IndentationError

38

D．IndexError

3．无法引入模块或包引发的异常是（ B ）。

A．IOError

B．ImportError

C．IndentationError

D．IndexError

4．Python提供了seek()方法将文件指针移动到指定位置，seek(n,1)表示（ B ）。

A．从起始位置即文件首行首字符开始移动n个字符

B．从当前位置往后移动n个字符

C．从文件的结尾位置往前移动n个字符

D．从起始位置即文件首行首字符开始移动n+1个字符

5．Python中，使用open()方法打开一个文件后，可以读取该文件中的内容，读取文件

内容的方式有多种，其中每次只能读取一行的是（ D ）。

A．readlines()

B．read()

C．readall()

D．readline()

6．Python中，os模块提供了创建文件夹的方法，一次创建多级文件夹使用（ B ）

方法。

A．mkdir()

B．makedirs()

C．walk()

D．tell()

7．以下选项不会影响Python程序的正常运行的是（ D ）。

A．拼写错误

B．错误表达式

C．缩进错误

D．手动抛出异常

8．有关异常说法正确的是（ B ）。

A．程序中抛出异常会终止程序

B．程序中抛出异常不一定会终止程序

C．拼写错误会导致程序终止

D．缩进错误会导致程序终止

9．对以下程序描述错误的是（ A ）。

try:

# 语句块1

except IndexError as err:

# 语句块2

A．该程序对异常进行了处理，因此一定不会终止程序

B．该程序对异常进行了处理，不一定不会因异常引发终止

C．语句块1如果抛出IndexError异常，则不会因为异常终止程序

D．语句块2不一定会执行

10．程序如下。

try:

39

number = int(input("请输入数字："))

print("number:",number)

print("=======hello======")

except Exception as err:

# 报错错误日志

print("输出异常详情信息：",err)

else:

print("没有异常")

finally:# 关闭资源

print("finally")

print("end")

该程序运行时，如果在“请输入数字：”后面输入的是1a则结果是（ B ）。

A．

number: 1

输出异常详情信息：invalid literal for int() with base 10:

finally

end

B．

输出异常详情信息：invalid literal for int() with base 10: '1a'

finally

end

C．

=======hello======

输出异常详情信息：invalid literal for int() with base 10:

finally

end

D．以上都正确

（二）填空题

1．当前工作文件夹是指当前运行文件或打开文件所在的文件夹，Python中，通过os

模块提供的{ getcwd() }方法获取当前工作文件夹。

2．对文件进行写入操作之后，{ flush() }方法用于在不关闭文件对象的情况下将缓

冲区内容写入文件。

3．Python内置函数{ open() }用于打开或创建文件并返回文件对象。

4．使用{ with }语句可以自动管理文件对象，不论何种原因结束该语句中的语句

体，都能保证文件被正确关闭。

5．Python os模块中用来列出指定文件夹中的文件和子文件夹列表的方式是

{ listdir() }。

6．Python 模块中用来判断指定文件是否存在的方法是{ exists() }。

7．Python 模块中用来判断指定路径是否为文件的方法是{ isfile() }。

8．Python 模块中用来判断指定路径是否为文件夹的方法是{ isdir() }。

9．Python 模块中用来分离指定路径中的文件扩展名的方法是{ splitext() }。

10．已知当前文件夹中有纯英文文本文件，以下代码的功能为把

文件中的所有内容复制到中，请将其填写完整。

with open('') as src

40

open('' , { 'w' }) as dst:

(src read())

（三）判断题

1． os模块中的方法remove()可以删除带有只读属性的文件。（ 错 ）

2．使用内置函数open()且以“w”模式打开的文件，文件指针默认指向文件尾。

（ 错 ）

3．使用内置函数open()打开文件时，只要文件路径正确就总是可以正确打开文件。

（ 错 ）

4．对文件进行读写操作之后必须显式关闭文件以确保所有内容都得到保存。

（ 对 ）

5．程序中的异常处理结构在大多数情况下是没必要的。（ 错 ）

6．在try…except…else语句中，如果try语句块引发了异常则会执行else语句块中的

代码。（ 错 ）

7．异常处理结构中的finally语句块中的代码仍然有可能出错，从而再次引发异常。

（ 对 ）

8．假设os模块已导入，那么列表推导式[filename for filename in

r( 'C:Windows' ) if th('.exe')]的作用是列出C:Windows文件夹中所有

扩展名为.exe的文件。（ 对 ）

9．二进制文件不能使用记事本程序打开。（ 错 ）

10．使用普通文本编辑器可以正常查看二进制文件的内容。（ 错 ）

11．二进制文件可以使用记事本或其他文本编辑器打开，但是一般来说无法正常查看

其中的内容。（ 对 ）

12．Python os模块中的方法isfile()可以用来测试给定的路径是否为文件。（ 对 ）

13．Python 模块中的方法exists()可以用来测试给定路径的文件是否存在。

（ 对 ）

14．Python 模块中的方法isdir()可以用来测试给定的路径是否为文件夹。

（ 对 ）

15．Python os模块中的方法listdir()返回包含指定路径中所有文件和文件夹名称的列

表。（ 对 ）

16．异常处理结构不是万能的，处理异常的代码也有引发异常的可能。（ 对 ）

17．在异常处理结构中，不论是否发生异常，finally子句中的代码总会执行。

（ 对 ）

18． os模块中的rename()方法可以实现文件移动操作。（ 对 ）

19． os模块中的listdir()方法默认只能列出指定文件夹中当前层级的文件和文件夹列

表，而不能列出其子文件夹中的文件。（ 对 ）

20．文件对象是可以迭代的。（ 对 ）

21．文件对象的tell()方法用来返回文件指针的当前位置。（ 对 ）

22．以写模式打开的文件无法进行读操作。（ 对 ）

23．假设已成功导入os和sys模块，那么表达式e(able)的值为

Python安装文件夹。（ 对 ）

24．以读模式打开文件时，文件指针指向文件开始处。（ 对 ）

25．以追加模式打开文件时，文件指针指向文件尾。（ 对 ）

26．文本文件是可以迭代的，可以使用类似for line in fp的语句遍历文件对象fp中的

每一行。（ 对 ）

41

27．Python的主程序文件属于二进制文件。（ 对 ）

28．已知当前文件夹中有一个文件具有只读属性，假设os模块已正确导

入，那么可以通过语句('' , 0o777)来删除该文件的只读属性。（ 对 ）

29．Python os模块中的方法remove()不能删除具有只读属性的文件。（ 对 ）

30．由于异常处理结构try…except…finally中finally子句的语句块总是被执行的，所

以把关闭文件的代码放到finally语句块里肯定是万无一失的，一定能保证文件被正确关闭

并且不会引发任何异常。（ 错 ）

单元8 数据库访问与使用

（一）选择题

1．如果有这样一段代码：使用connect()方法返回一个连接对象conn，接着使用连接

对象conn的cursor()方法返回一个游标对象cur，那么使用cur对象的（ C ）方法才能

获得结果集中的所有行。

A．fetchmany()

B．fetchone()

C．fetchall()

D．executemany()

2．在Python中创建数据表时，使用sqlite3的（ A ）方法创建连接对象。

A．connect()

B．cursor()

C．execute()

D．close()

3．在Python中创建数据表时，使用连接对象的（ B ）方法获取游标对象。

A．connect()

B．cursor()

C．execute()

D．close()

4．在Python中创建数据表时，使用游标对象的（ C ）方法执行SQL语句。

A．connect()

B．cursor()

C．execute()

D．close()

5．在Python 3中用于连接MySQL服务器的库是（ C ）。

A．MySQLdb

B．MySQL

C．PyMySQL

D．SQLite3

6．在select查询语句中，使用问号“?”作为占位符代替具体的字段值，然后使用一

个（ B ）来替换问号。

A．列表

B．元组

C．字典

D．字符串

42

7．SQL查询语句"select * from teacher where ID>2"与（ C ）语句等价。

A．"select * from teacher where ID>?" , (2)

B．"select * from teacher where ID>%s" , (2,)

C．"select * from teacher where ID>?" , (2,)

D．"select * from teacher where ID>?" , [2]

8．有一个游标对象cursor，使用该游标对象的execute()方法将数据表teacher中ID字

段值为3的姓名更新为“夏丽”，正确的语句是（ A ）。

A．e("update teacher set name=? where ID=?", ('夏丽', 3))

B．e("update teacher set name=? where ID=?", ['夏丽', 3])

C．e("update teacher set name=%s where ID=%s", ('夏丽', 3))

D．e("update teacher set name=* where ID=*", ('夏丽', 3))

9．在Python中查询MySQL数据表时，使用（ A ）方法获取数据表中1条记录数

据。

A．fetchone()

B．fetchall()

C．fetchmany()

D．fetch()

10．Python DB API 2.0的事务提供（ B ）方法用于回滚当前游标的所有操作。

A．commit()

B．rollback()

C．close()

D．back()

（二）填空题

1．Python用来访问和操作内置数据库SQLite的模块是{ sqlite3 }。

2．用于删除数据表test中所有name字段值为'10001 '的记录的SQL语句为{ delete

from test where name= '10001 ' }。

3．Python模块{ sqlite3 }提供了对SQLite数据库的访问接口。

4．在Python中进行数据库连接时，使用{ connect() }方法，返回一个连接对象。

5．有一个游标对象cur，使用游标对象的{ execute() }方法来执行一条SQL语句。

6．向SQLite数据表中新增数据，应使用{ insert into }语句。

7．从SQLite数据表中获取所需的数据后，使用连接对象的{ close() }方法关闭连

接对象。

8．使用select查询语句查询SQLite数据表中的数据时，使用{ ? }作为占位符代替

具体的字段值。

9．在Python中查询MySQL数据表时，使用{ fetchall() }方法获取数据表中多条记

录数据。

10．使用带参数的Insert语句向MySQL数据表student中插入记录时，可以使用

{ %s }作为占位符。

（三）判断题

1．Python只能使用内置数据库SQLite，无法访问SQL Server、Oracle、MySQL等数

据库。（ 错 ）

2．SQLite是一种嵌入式数据库，它的数据库就是一个文件。（ 对 ）

3．Python内置了sqlite3模块，在Python中使用SQLite，不需要额外安装任何模块，

可以直接使用。（ 对 ）

43

4．使用t()方法连接SQLite数据库文件，如果该文件并不存

在，必须先创建好数据库文件。（ 错 ）

5．对于支持事务的数据库，在Python数据库编程时，建立游标就会自动开始一个隐

形的数据库事务。（ 对 ）

6．Python DB API 2.0的事务提供的commit()方法用于执行游标所有的更新操作。

（ 对 ）

7．事务机制的原子性是指事务是一个不可分割的工作单位，事务中包括的各项操作要

么都做，要么都不做。（ 对 ）

8．当有数据处理时的错误发生时触发DatabaseError异常。（ 错 ）。

9．MySQL数据库连接成功后，可以使用execute()方法执行SQL语句创建一个数据

表。（ 对 ）

10．可以使用executemany()方法向MySQL数据表中批量添加多条记录。（ 对 ）

单元9 网络编程与进程控制

（一）选择题

1．假设现在有一个UTF-8编码的文件，需要转码成GBK编码的文件，下列操作流程

正确的是（ D ）。

A．encode('gbk')--->decode('utf-8')

B．encode('utf-8')--->decode('gbk')

C．decode('gbk')--->encode('utf-8')

D．decode('utf-8')--->encode('gbk')

2．计算机通信时，负责在两台计算机之间建立可靠连接，保证数据包按顺序到达的协

议是（ A ）。

A．TCP

B．IP

C．UDP

D．FTP

3．Python中，使用socket模块的（ B ）方法来创建套接字。

A．send()

B．socket()

C．recv()

D．get()

4．不论是客户端还是服务器应用程序都用（ C ）从TCP连接的另一端接收数据。

A．send()

B．socket()

C．recv()

D．get()

5．Socket对象的套接字方法中，用于发送UDP数据，将数据发送到套接字，返回值

是发送的字节数的方法是（ B ）。

A．send()

B．sendto()

C．recv()

D．recvfrom()

44

6．计算机通信时，服务器的套接字方法中用于TCP监听的方法是（ B ）。

A．bind()

B．listen()

C．accept()

D．connect()

7．下列关于创建进程的方式，正确的是（ B ）。

A．使用threading模块的Thread类创建

B．使用multiprocessing模块的Process类创建进程

C．使用threading模块的Process子类创建进程

D．使用threading类的子类创建进程

8．Python中，创建线程的方式有多种，以下不是Python中创建线程的方式的是

（ D ）。

A．使用threading模块的Thread类创建线程

B．使用threading模块的Thread类的子类创建线程

C．调用_thread模块中的start_new_thread()函数产生新线程

D．使用thread模块的Thread类创建线程

9．在threading模块中使用Lock类可以方便地处理锁定，用于获取锁定的方法是

（ B ）。

A．get()

B．acquire()

C．release()

D．getName()

10．Python 3中，字符串和二进制数据是完全区分开的。Python 3新增了（ D ）对

象来表达二进制数据。

A．str

B．int

C．byte

D．bytes

11．以下是字符串转换成字节流的方法的是（ B ）。

A．decode()

B．encode()

C．upper()

D．rstrip()

12．以下会出现错误的是（ B ）。

A．"北京".encode()

B．"北京".decode()

C．"北京".encode().decode()

D．以上都不会错误

（二）填空题

1．Python { socket }模块对Socket进行了二次封装，支持Socket接口的访问，大幅

度简化了网络程序的开发流程。

2．{ socket }模块提供了客户端和服务器套接字的低级访问支持，服务器套接字会

在指定的地址监听客户端的连接，而客户端则直接连接服务器。

3．计算机通信时，负责把数据从一台计算机通过网络发送到另一台计算机的协议是

45

{ IP }。

4．Socket对象的套接字方法中，用于发送TCP数据，将数据发送到连接的套接字，

返回值是要发送的字节数量的方法是{ send() }。

5．Socket对象的套接字方法中，用于返回本地主机的标准主机名的方法是

{ gethostname() }。

6．Socket对象的套接字方法中，用于使用域名或主机名获取IP地址的方法是

{ gethostbyname() }。

7．计算机通信时，被动接受TCP客户端连接，等待连接的到来的服务器的套接字方

法是{ accept() }。

8．计算机通信时，主动初始化TCP服务器连接的客户端的套接字方法是

{ connect() }。

9．一般应用于多点通信和实时的数据业务的协议是{ UDP }。

10．Python中有多个模块可以创建进程，较常见的是使用{ multiprocessing }模块创

建进程。

11．Python 3通过_thread和threading模块提供对线程的支持，推荐使用

{ threading }模块。

12．进程之间不能直接共享数据，只能借助{ Queue }才能实现进程之间的通信。

13．线程对象的{ join() }方法用来阻塞当前线程，指定线程运行结束或超时后继续

运行当前线程。

14．Windows操作系统能同时执行多项任务，每一项任务就是一个{ 进程 }。

15．操作系统能够进行运算调度的最小单位是{ 线程 }。

16．在多线程程序开发中，全局变量是多个线程都共享的数据，为防止数据混乱，通

常使用{ 互斥锁 }。

（三）判断题

1．使用TCP进行通信时，必须首先建立连接，然后进行数据传输，最后再关闭连

接。（ 对 ）

2．TCP是可以提供良好服务质量的传输层协议，所以在任何场合都应该优先考虑使

用。（ 错 ）

3．对字符串信息进行编码以后，必须使用同样的或者兼容的编码格式进行解码才能还

原本来的信息。（ 对 ）

4．Python 3中字符串对象的encode()方法默认使用UTF-8作为编码方式。（ 对 ）

5．已知x = 'Hello Python'.encode()，那么表达式('gbk')的值为Hello Python。

（ 对 ）

6．已知x = 'Python是一种很棒的编程语言'.encode()，那么表达式('utf-8')的值

为“Python是一种很棒的编程语言”。（ 对 ）

7．在多进程中，每个进程都有自己的地址空间、内存、数据栈以及其他记录其运行状

态的辅助数据，进程之间无法直接共享信息。（ 对 ）

8．在编写应用程序时，应合理控制线程数量，线程并不是越多越好。（ 对 ）

9．在多线程编程时，当某子线程的daemon属性为False时，主线程结束时会检测该

子线程是否结束，如果该子线程尚未运行结束，则主线程会等待它完成后再退出。

（ 对 ）

10．多线程编程技术的主要目的是提高计算机硬件的利用率，没有别的作用。

（ 错 ）

11．在多线程程序开发中，局部变量是专属于各自线程的，是非共享的，所以不需要

46

使用互斥锁。（ 对 ）

12．线程是进程的一个实体，是CPU调度和分派的基本单位。（ 对 ）

13．Python threading模块中的Lock、RLock类可以用来实现线程同步。（ 对 ）

单元10 基于GUI框架的图形界面设计与网络爬虫应用

（一）选择题

1．当创建的子类时，子类应该调用其父类的构造器（ A ）。

A．.__int__()

B．._int_()

C．()

D．.__int__

2．在设计图形用户界面时，以下不是rl控件的固有功能的是（ D ）。

A．动态输入单行文本

B．动态输入多行文本

C．输入密码

D．显示提示性的静态文本

3．使用er的（ C ）方法可以将控件加入sizer中。

A．Box()

B．Grid()

C．Add()

D．size()

4．wxPython所提供的sizer中最简单、最灵活的布局方式是（ B ）。

A．GridSizer

B．BoxSizer

C．StaticBoxSizer

D．FlexGridSizer

5．er的Add()方法的flag参数有_CENTER、两个取值，

将这两个取值联合使用的操作符是（ B ）。

A．+

B．|

C．/

D．

6．使用er的Add()方法将控件加入sizer中的代码如下。

hsizerUser = er(NTAL)

(r, proportion=0, flag=, border=5)

其中flag参数的取值为，表示（ C ）。

A．控制上、下、左3个边距

B．控制上、下、右3个边距

C．控制上、下、左、右4个边距

D．控制上、下2个边距

7．er的Add()方法可以将控件加入sizer中，其中flag参数可以与

（ D ）参数结合，设置控件本身的对齐方式。

A．border

47

B．control

C．align

D．proportion

8．在wxPython中有很多以_开头的事件类型，其中_MOTION表示

（ A ）事件。

A．鼠标移动

B．鼠标滚轮滚动

C．鼠标进入控件

D．鼠标离开控件

9．GUI编程时，wxPython中有很多以_开头的事件类型，其中表示鼠标单击

事件的是（ B ）。

A．_MOTION

B．_BUTTON

C．_MOUSEWHEEL

D．_WINDOW

10．GUI编程时，界面中【确定】按钮添加一个单击事件的代码如下。

(_BUTTON, kSubmit)

其中OnclickSubmit表示（ C ）。

A．事件名称

B．类名称

C．方法名称

D．属性名称

11．在PyQt5层次结构中，所有PyQt对象的基类是指（ A ）。

A．QObject类

B．Qapplication类

C．QWidget类

D．QMainWindow类

12．PyQt5常用的控件有多种，其中提供一个命令按钮的是（ A ）。

A．QPushButton控件

B．QRadioButton控件

C．QCheckBox控件

D．QSpinBox控件

（二）填空题

1．{ QWidget }是PyQt5中所有用户界面对象的基类，所有的控件都直接或者间接

继承了该基类对象。

2．PyQt使用统一的坐标系统来定位窗口控件的位置和大小，以屏幕{ 左上角 }为

原点，从左向右为x轴正方向，从上向下为y轴正方向。

3．如果在系统中只有一个窗口，可以直接使用类，这个类提供了一个最基本

的{ OnInit() }初始化方法。

4．以下语句使用创建窗口，由于参数parent的值为None，表示创建的是

{ 顶级窗口 }。

frame = (parent=None, title='显示图书数据')

5．在wxPython中，可以使用{ Text }类实现在图形用户界面中显示一些标

签性或提示性的文本。

48

6．提供了不同类型的按钮，其中非常简单、常用的是{ }类。

7．GUI编程时，利用控件的{ Bind()方法 }可以将事件处理函数绑定到事件上。

8．GUI编程时，wxPython中有很多以_开头的事件类型，其中

_BUTTON表示{ 鼠标单击 }事件。

9．QMainWindow和QWidget的父类是{ QWidget类 }。

10．PyQt5常用的控件有多种，其中提供一个单页面的多行文本编辑器的是

{ QTextEdit控件 }。

（三）判断题

1．wxPython是Python中的一个优秀的GUI库，允许Python程序员很方便地创建完

整的、功能健全的GUI用户界面。（ 对 ）

2．PyQt是Qt库的Python版本，但不支持跨平台。（ 错 ）

3．wxPython是一款开源软件，并且具有非常优秀的跨平台功能。（ 对 ）

4．在wxPython中，是所有框架的父类。（ 对 ）

5．类用于设置文本字体。（ 对 ）

6．Text控件能用于显示动态交互的文本。（ 错 ）

7．er在一条线上布局窗口控件，并且控件的数量是固定的。（ 错 ）

8．GUI编程时，利用控件的Bind()方法可以将事件处理函数绑定到事件上。

（ 对 ）

9．QWidget类是所有用户界面类的基类，它能接收所有的鼠标事件、键盘事件和其他

系统窗口事件。（ 对 ）

10．任何一个使用PyQt开发的图形用户界面应用程序，都存在一个QApplication对

象。（ 对 ）

单元11 基于Flask框架的Web程序设计

（一）选择题

1．创建Flask对象正确的语句是（ A ）。

A．app = Flask(__name__)

B．app = Flask(name)

C．()

D．app = Class(Flask)

2．Flask程序中定义了如下route()装饰器和函数index()。

@('/')

def index():

return "Happy to learn Python"

程序运行时，在浏览器地址栏中应输入的网址是（ B ）。

A．127.0.0.1:8000/index

B．127.0.0.1:5000/

C．127.0.0.1

D．127.0.0.1:5000/index

3．确保服务器只在Flask程序被Python解释器直接执行的时候才会运行，而不是作为

模块导入的时候运行。实现这一功能正确的if语句是（ C ）。

A．if _name_ == '_main_':

B．if name == 'main':

49

C．if __name__ == '__main__':

D．if __name__ == '__main__'

4．Flask程序开启调试模式有多种方法，以下方法不是开启调试模式的正确方法的是

（ D ）。

A．=True

B．( debug=True )

C．将FLASK_DEBUG环境变量的值设置为1

D．Flask内置了调试模式，并且Flask会自动开启调试模式

5．在Flask程序中给指定函数构造URL的函数名为（ B ）。

A．flask

B．url_for

C．route

D．render_template

6．默认情况下，Flask程序的模板文件需要放在（ A ）文件夹下。

A．templates

B．static

C．html

D．app

7．使用Jinja模板时，只需要使用（ B ）方法传入模板文件名和参数名即可。

A．route()

B．render_template()

C．url_for()

D．run()

8．以下Flask模板的基本结构中，用于装载变量的结构是（ C ）。

A．{%…%}

B．{#…#}

C．{{…}}

D．{…}

9．在Flask模板中，如果想让定义的变量只在部分作用域内有效，则需要使用

（ A ）语句定义，其语句定义的变量只能在其语句内部使用，超出范围无效。

A．with

B．set

C．{{ }}

D．run

10．Flask程序中，用于重定向的方法是（ D ）。

A．route()

B．url_for()

C．render_template()

D．redirect()

（二）填空题

1．Flask的两个主要核心应用是路由模块Werkzeug和{ 模板引擎Jinja2 }。

2．Flask程序运行时，在浏览器地址栏中应输入网址127.0.0.1:5000/，程序中

route()装饰器的正确写法是{ @('/') }。

3．在Flask程序中定义路由的最简便的方式之一是使用程序实例提供的

50

{ () }装饰器，把修饰的函数注册为路由。

4．request对象是一个全局对象，利用它的属性和方法，可以方便地获取从页面传递

过来的参数。该对象的{ method }属性会返回HTTP方法的请求方式，例如POST或

GET。

5．在Flask模板内部可以使用{ set }语句定义全局变量，只有定义了这个变量，变

量定义位置之后的代码才可以使用这个变量。

6．Flask程序中，用于返回错误页面的方法是{ abort() }。

7．Flask模板中控制语句都是放在{ {% … %} }中，并且使用语句{% end××

× %}来表示结束。

8．Jinja2模板中for循环的内置常量表示当前迭代的索引从{ 1 }开始。

9．Flask程序中block标签定义的元素可以在衍生模板中修改，获取基模板中的内容

可以使用{ super() }方法。

10．为了渲染模板，Flask使用了一个名为{ Jinja2 }的模板引擎。

（三）判断题

1．Flask相对于Django而言是轻量级的Web框架。（ 对 ）

2．创建Flask的实例时，使用的参数为“__name__”。（ 对 ）

3．如果调用方法run()时需要指定服务器IP为127.0.0.1、端口为5000，则可以添加服

务器IP和端口参数，完整的代码为(host='127.0.0.1'，port=5000)。（ 对 ）

4．run()方法适用于启动本地的服务器，每次修改代码后都会自动重启服务器。

（ 错 ）

5．在Flask程序中需要使用url_for()函数并指定static文件夹名称和文件名称。

（ 对 ）

6．Flask模板的基本结构中用于添加注释的结构是{% ... %}。（ 错 ）

7．使用字典组织多个Flask模板参数时，需要加两个*转换成关键字参数传入。

（ 对 ）

8．在jinja2模板内部可以使用set语句定义全局变量，并且变量可以赋任何类型的

值。（ 对 ）

9．在Flask模板中，可以使用with语句来创建一个内部的作用域，将set语句放在

with语句内部，这样创建的变量也只在with代码块中才有效。（ 对 ）

10．Flask的页面跳转方法redirect()就是response对象的页面跳转的封装。（ 对 ）

单元12 基于Django框架的Web程序设计

（一）选择题

1．在命令行中创建一个名称为test的项目，需要使用（ B ）语句。

A．django-admin help startproject test

B．django-admin startproject test

C．django-admin startapp test

D．manage startproject test

2．在Django项目中创建App应用程序test的正确命令是（ D ）。

A．python startproject test

B．django-admin startapp test

C．manage startapp test

D．python startapp test

51

3．Django项目中借助正则表达式表达URL，可以通过“<>”提取变量作为函数的参

数，使用这种形式必须使用（ A ）方法配置路由表达式。

A．re_path()

B．path()

C．url()

D．settings()

4．Django项目的URL路由设置写在（ C ）文件中。

A．

B．

C．

D．

5．存放Django项目中HTML模板的文件夹是（ A ）。

A．templates

B．Django

C．app

D．static

6．Django项目中自动生成的Python文件中，（ B ）文件是Django项目中的入口

程序，也是实用的命令提示符工具。

A．

B．

C．

D．

7．Django管理工具的URL模式通常在项目生成时在中自动设置好，以下属于

Django项目自动生成自动设置的URL模式的配置代码的是（ A ）。

A．path('admin/', )

B．path('app01/', include(""))

C．path('test/', eDB)

D．path('refer/', ata)

8．在Django项目test中创建名称为app01的App应用程序，自动创建的包文件夹

app01中会创建多个文件，以下不是包文件夹app01中自动创建的文件的是（ A ）。

A．

B．

C．__init__.py

D．

9．Django模板可以用继承的方式来实现复用，子模板继承父模板的关键词是

（ C ）。

A．block

B．include

C．extends

D．render

10．用于接收一个URL参数，让浏览器跳转到指定的URL的Django方法是

（ D ）。

A．HttpResponse()

B．render()

52

C．route()

D．redirect()

（二）填空题

1．启动Django项目内置的开发服务器需要使用文件中的{ runserver }命

令。

2．在Django应用中修改文件中的INSTALLED_APPS列表的

{ }元素，才能在Django应用中访问后台管理系统。

3．在Django项目的文件中开启调试模式的代码为{ DEBUG = True }。

4．App的文件中有以下代码。

from import HttpResponse

def show(request):

return HttpResponse("Happy every day ! ")

视图的函数show()的参数request是{ HttpRequest }对象。

5．Django的URL路由查找，是到文件中对URL逐一匹配{ urlpatterns }列

表的每个元素。

6．Django项目中的静态文件存放在文件夹static中，文件静态文件的路径

设置变量是STATIC_URL，该变量正确的路径配置值是{ '/static/' }。

7．Django指定的模板引擎在文件中定义，该文件中的列表TEMPLATES

中键{ DIRS }用于指定模板文件所在的文件夹。

8．在Django模板文件中使用变量时，变量名称应放入{ {{ }} }。

9．如果Django项目中的配置文件包括“path('index/', )”路径配

置，运行项目app1201，应在浏览器地址栏中输入的访问地址为

{ 127.0.0.1:8000/index/ }。

10．MVT框架中视图与MVC框架模式中控制器的功能类似，负责{ 业务逻辑 }，

并在适当的时候调用模型和模板。

（三）判断题

1．Django项目中每个视图的函数接收来自客户端的请求，并且必须返回一个

HttpResponse对象。 （ 对 ）

2．Django项目默认使用Python自带的SQLite数据库。 （ 对 ）

3．如果Django项目中的配置文件包括“path('index/', )”路径配

置，那么其中“index”表示文件中定义了函数index()。（ 对 ）

4．Django项目中借助正则表达式表达URL，可以通过“<>”提取变量作为函数的参

数，使用这种形式可以使用path()方法配置路由表达式。（ 错 ）

5．Django有一个urls分发器，其作用是将URL的页面请求分发给不同的视图处理，

视图再调用相应的模型和模板。（ 对 ）

6．MVT框架模式中模型负责业务对象和数据库的关系映射，与MVC框架模式中模

型的功能类似。（ 对 ）

7．MVT框架中Template负责把页面展示给用户，与MVC框架模式中视图的功能类

似。（ 对 ）

8．Django的模板标签中没有包含ifequal/ifnotequal标签。（ 错 ）

9．Django模板引擎使用{% %}来描述Python语句。（ 对 ）

10．MVC框架模式是软件工程中的一种软件架构模式，其中“C”表示视图。

（ 错 ）

53

54