2020-08-15 18:49 北华航天工业学院 Java

关注

《Python 程序设计》复习题

填空题

填空题答案变为白色，想要查看请长按复制复制查看，或鼠标向后扫描查看答案
例如：

一、基础知识

1、查看变量类型的 Python 内置函数是________________。（type()）
2、Python 运算符中用来计算整商的是_________。（//）
3、____命令既可以删除列表中的一个元素，也可以删除整个列表。（del）
4、表达式 int(‘123’) 的值为____________。（123）
5、已知 x = 3，那么执行语句 x += 6 之后，x 的值为_______________。（9）
6、表达式 3 ** 2 的值为_________。（9）
7、表达式 3 * 2 的值为___________。（6）
8、已知 x = 3，那么执行语句 x *= 6 之后，x 的值为________________。（18）
9、已知 x=3 和 y=5，执行语句 x, y = y, x 后 x 的值是____。（5）
10、表达式 1234%1000//100 的值为___________。（2）
11、表达式 3 // 5 的值为_______________。（0）
12、表达式 15 // 4 的值为__________________。（3）
13、Python 中用于表示逻辑与关键字是_________（and）
14、Python 中用于表示逻辑或的关键字是_________（or）
15、Python 中用于表示逻辑非运算的关键字是_________。（not）
16、293、表达式 ‘Hello world’.upper() 的值为___________。（‘HELLO WORLD’）
17、表达式 ‘Hello world’.lower() 的值为_____________。（‘hello world’）
18、已知字符串 x = ‘hello world’，那么执行语句 x.replace(‘hello’, ‘hi’) 之后，x 的值为____________。（‘hello world’）
注意：光会理论填空是不够的,在此送大家一套2020最新Python全栈实战视频教程，点击此处免费获取一起进步哦！

19、表达式 len(‘SDIBT’) 的值为__________。（5）

二、序列

1、列表、元组、字符串是 Python 的_________(有序？无序)序列。（有序）
2、Python 内置函数_________可以返回列表、元组、字典、集合、字符串以及 range 对象中
元素个数。（len()）
3、Python 内置函数____________用来返回序列中的最大元素。（max()）
4、Python 内置函数____________用来返回序列中的最小元素。（min()）
5、表达式[1, 2, 3]*3 的执行结果为______________________。（[1, 2, 3, 1, 2, 3, 1, 2, 3]）
6、假设列表对象 aList 的值为[3, 4, 5, 6, 7, 9, 11, 13, 15, 17]，那么切片aList[3:7]得到的值是______________________。（[6, 7, 9, 11]）
7、任意长度的 Python 列表、元组和字符串中最后一个元素的下标为________。（-1）
8、Python 语句 list(range(1,10,3))执行结果为___________________。（[1, 4, 7]）
9、表达式 list(range(5)) 的值为________________。（[0, 1, 2, 3, 4]）
10、切片操作 list(range(6))[::2]执行结果为________________。（[0, 2, 4]）
11、字典中多个元素之间使用____________分隔开，每个元素的“键”与“值”之间使用________分隔开。（逗号、冒号）
12. 字典对象的___________方法可以获取指定“键”对应的“值”，并且可以指定“键”不存在的时候返回指定值，如果不指定则返回 None。（get()）
13. 字典对象的_____________方法返回字典中的“键-值对”列表（items()）
14. 字典对象的____________方法返回字典的“键”列表。（keys()）
15. 字典对象的______________方法返回字典的“值”列表。（values()）
16. 已知 x = {1:2}，那么执行语句 x[2] = 3 之后，x 的值为________________。（{1: 2, 2: 3}）
17. 已知 x = [1, 2, 3, 2, 3]，执行语句 x.pop() 之后，x 的值为_____________。（[1, 2, 3, 2]）
18. 已知 x = list(range(10))，则表达式 x[-4:] 的值为__________。（[6, 7, 8, 9]）
19. 已知列表 x = [1, 2, 3, 4]，那么执行语句 del x[1] 之后 x 的值为____________。（[1, 3, 4]）
20. 表达式 len(range(1, 10)) 的值为___________。（9）
21. 已知 x = {1:1, 2:2}，那么执行语句 x[2] = 4 之后，len(x)的值为____________。（2）
22. 已知列表 x = [1.0, 2.0, 3.0]，那么表达式 sum(x)/len(x) 的值为___________。（2.0）

三、选择结构与循环结构和函数及面向对象、文件

在循环语句中，__________语句的作用是提前结束本层循环。（break）
在循环语句中，_______语句的作用是提前进入下一次循环。（continue）
Python 中定义函数的关键字是_________________。（def）
在函数内部可以通过关键字________________来定义全局变量。（global）
如果函数中没有 return 语句或者 return 语句不带任何返回值，那么该函数的返回值为___。（None）
表达式 sum(range(10)) 的值为________________。（45）
表达式 sum(range(1, 10, 2)) 的值为____________。（25）
已知 g = lambda x, y=3, z=5: xyz，则语句 print(g(1)) 的输出结果为_______。（15）
已知 f = lambda x: x+5，那么表达式 f(3) 的值为________。（8）
已知 g = lambda x, y=3, z=5: x+y+z，那么表达式 g(2) 的值为________。（10）
已知函数定义 def func(*p):return sum§，那么表达式 func(1,2,3) 的值为______。（6）
已知函数定义 def func(*p):return sum§，那么表达式 func(1,2,3, 4) 的值为______。（10）
已知函数定义 def func(**p):return sum(p.values())，那么表达式 func(x=1, y=2, z=3) 的值为________。（6）
Python 使用_________________关键字来定义类。（class）
Python 内置函数_____________用来打开或创建文件并返回文件对象。（open()）
表达式 ‘abc’ in ‘abdcefg’ 的值为_____________。（False）
表达式[3] in [1, 2, 3, 4]的值为________________。（False）
表达式 3< 5 >2 的值为_______________。（True）
表达式 3 not in [1, 2, 3]的值为__________。（False）

选择题

一、Python 基础语法

2.以下选项中，不是 Python 语言保留字的是（C）

A while
B pass
C do
D except

关于 Python 程序格式框架，以下选项中描述错误的是(A)

A Python 语言不采用严格的“缩进”来表明程序的格式框架
B Python 单层缩进代码属于之前最邻近的一行非缩进代码，多层缩进代码根据缩进关系决定所属范围
C Python 语言的缩进可以采用 Tab 键实现
D 判断、循环、函数等语法形式能够通过缩进包含一批 Python 代码，进而表达对应的语义

下列选项中不符合 Python 语言变量命名规则的是©

A TempStr
B I
C 3_1
D _AI

以下选项中，关于 Python 字符串的描述错误的是（D）

A Python 语言中，字符串是用一对双引号""或者一对单引号 ‘’ 括起来的零个或者多个字符
B 字符串包括两种序号体系：正向递增和反向递减
C 字符串是字符的序列，可以按照单个字符或者字符片段进行索引
D Python 字符串提供区间访问方式，采用[N:M]格式，表示字符串中从 N 到 M 的索引子字符串（包含 N 和 M）

给出如下代码
TempStr =“Hello World” 可以输出“World”子串的是(B)

A print(TempStr[–5:0])
B print(TempStr[–5:])
C print(TempStr[–5: –1])
D print(TempStr[–4: –1])

关于赋值语句，以下选项中描述错误的是(B)

A a,b = b,a 可以实现 a 和 b 值的互换
B a,b,c = b,c,a 是不合法的
C 在 Python 语言中，“=”表示赋值，即将“=”右侧的计算结果赋值给左侧变量，包含“=”的语句称为赋值语句
D 赋值与二元操作符可以组合，例如&=

关于 Python 语言的注释，以下选项中描述错误的是（D）

A Python 语言有两种注释方式：单行注释和多行注释
B Python 语言的单行注释以#开头
C Python 语言的多行注释以’’’（三个单引号）开头和结尾
D Python 语言的单行注释以单引号 ’ 开头

关于 Python 语言的特点，以下选项中描述错误的是(B)

A Python 语言是脚本语言
B Python 语言是非开源语言
C Python 语言是跨平台语言
D Python 语言是多模型语言

关于 import 引用，以下选项中描述错误的是(A)

A 可以使用 from turtle import setup 引入 turtle 库
B 使用 import turtle as t 引入 turtle 库，取别名为 t
C 使用 import turtle 引入 turtle 库
D import 保留字用于导入模块或者模块中的对象

下面代码的输出结果是（C）

print（0.1+0.2==0.3）

A false
B True
C False
D true

在一行上写多条 Python 语句使用的符号是( C )

A 点号
B 冒号
C 分号
D 逗号

给出如下代码

s = 'Python is beautiful!'

可以输出“python”的是(A)

A print(s[0:6].lower())
B print(s[:–14])
C print(s[0:6])
D print(s[–21: –14].lower)

给出如下代码

s = 'Python is Open Source!' print(s[0:].upper())

上述代码的输出结果是（D）

A PYTHON
B PYTHON IS OPEN SOURCE
C Python is Open Source!
D PYTHON IS OPEN SOURCE!

以下选项中，符合 Python 语言变量命名规则的是(A)

A Templist
B ！1
C (VR)
D 5_1

下列选项中可以获取 Python 整数类型帮助的是（C）

A >>> help(float)
B >>> dir(str)
C >>> help(int)
D >>> dir(int)

下列 Python 保留字中，用于异常处理结构中用来捕获特定类型异常的是(B)

A def
B except
C while
D pass

关于 Python 注释，以下选项中描述错误的是（A）

A Python 注释语句不被解释器过滤掉，也不被执行
B 注释可用于标明作者和版权信息
C 注释可以辅助程序调试
D 注释用于解释代码原理或者用途

以下选项中，不是 Python 数据类型的是A

A 实数
B 列表
C 整数
D 字符串

下列 Python 保留字中，不用于表示分支结构的是(B)

A elif
B in
C if
D else

以下选项中，对程序的描述错误的是(A)

A 程序是由一系列函数组成的
B 通过封装可以实现代码复用
C 可以利用函数对程序进行模块化设计
D 程序是由一系列代码组成的

以下选项中可用作 Python 标识符的是（C）

A 3B9909
B class
C ____
D it’s
[解析]：标识符开头不能使用数字，所以 A 选项错误；C 选项中 class 是保留字，不可以作为标识符；D选项中有特殊字符，也是不可以作为标识符的，所以也不能选择。只有B选项是符合标识符的命名规则，所以 B 选项是正确的选项。

关于 Python 程序中与“缩进”有关的说法中，以下选项中正确的是C

A 缩进统一为 4 个空格
B 缩进可以用在任何语句之后，表示语句间的包含关系
C 缩进在程序中长度统一且强制使用
D 缩进是非强制性的，仅为了提高代码可读性

以下选项中可访问字符串 s 从右侧向左第三个字符的是C

A s[3]
B s[：-3]
C s[-3]
D s[0：-3]

以下选项中，不是 Python 语言合法命名的是A

A 5MyGod
B MyGod5
C _MyGod_
D MyGod
【解析】：变量名可以包括字母、数字、下划线，但是数字不能做为开头。例如：name1是合法变量名，而1name就不可以。

在 Python 函数中，用于获取用户输入的是A

A input()
B print()
C Eval()
D get()

给标识符关联名字的过程是B

A 赋值语句
B 命名
C 表达
D 生成语句

以下选项中，不是 Python 打开方式的是A

A Office
B Windows 系统的命令行工具
C 带图形界面的 Python Shell-IDLE
D 命令行版本的 Python Shell-Python 3.x

二、基本数据类型

关于 Python 的数字类型，以下选项中描述错误的是C

A 复数类型虚部为 0 时，表示为 1+0j
B 1.0 是浮点数，不是整数
C 浮点数也有十进制、二进制、八进制和十六进制等表示方式
D 整数类型的数值一定不会出现小数点

下面代码的输出结果是A

x = 12.34
print(type(x))

==A <class ‘float’> ==
B <class ‘complex’>
C <class ‘bool’>
D <class ‘int’>

下面代码的输出结果是C

z = 12.12 + 34j
print(z.real)

A 34
B 34.0
C 12.12
D 12

10.下面代码的输出结果是B

z = 12.34 + 34j
print(z.imag)

A 12.12
B 34.0
C 12
D 34

11.下面代码的输出结果是A

x=10
y=–1+2j
print(x+y)

A （9+2j）
B 11
C 2j
D 9

12.下面代码的输出结果是A

x=10
y=3
print(x%y,x**y)

A 1 1000
B 3 30
C 3 1000
D 1 30

13.下面代码的输出结果是C

x=10
y=4
print(x/y,x//y)

A 2 2.5
B 2.5 2.5
C 2.5 2
D 2 2

19.下面代码的执行结果是B

a = 10.99
print(complex(a))

A 10.99
B (10.99+0j)
C 10.99+0j
D 0.99

20.下面代码的执行结果是C

>>> x = "Happy Birthday to you!" 
>>> x * 3

A 系统报错
B Happy Birthday to you!
C ‘Happy Birthday to you!Happy Birthday to you!Happy Birthday to you!’
D
Happy Birthday to you!
Happy Birthday to you!
Happy Birthday to you!

23.给出如下代码

s= "abcdefghijklmn" 
print(s[1:10:3])

上述代码的输出结果是C

A behk
B adgj
C beh
D adg

31.下面代码的输出结果是A

s1 = "The python language is a scripting language."
s1.replace('scripting','general')
print(s1)

A The python language is a scripting language.
B 系统报错
C [‘The’, ‘python’, ‘language’, ‘is’, ‘a’, ‘scripting’, ‘language.’]
D The python language is a general language.

40.下面代码的输出结果是C

>>> a,b,c,d,e,f = 'Python' 
>>> b

A 1
B 出错
C ‘y’
D 0

41.下面代码的输出结果是D

>>> a = b = c =123
>>> print(a,b,c)

A 0 0 123
B 出错
C 1 1 123
D 123 123 123

44.下面代码的输出结果是B

a = 5/3+5//3
print(a)

A 5.4
B 2.666666666666667
C 3.333333
D 14

47.下面代码的输出结果是C

a = "ac" 
b = "bd" 
c = a + b
print(c)

A dbac
B abcd
C acbd
D bdac

48.下面代码的输出结果是A

str1 = "mysqlsqlserverPostgresQL"
str2 = "sql" 
ncount = str1.count(str2)
print(ncount)

A 2
B 5
C 4
D 3

三、程序的控制结构

关于 Python 的分支结构，以下选项中描述错误的是D

A Python 中 if-elif-else 语句描述多分支结构
B 分支结构使用 if 保留字
C Python 中 if-else 语句用来形成二分支结构
D 分支结构可以向已经执行过的语句部分跳转

关于 Python 循环结构，以下选项中描述错误的是B

A break 用来跳出最内层 for 或者 while 循环，脱离该循环后程序从循环代码后继续执行
B 每个 continue 语句只有能力跳出当前层次的循环
C 遍历循环中的遍历结构可以是字符串、组合数据类型和 range()函数等
D Python 通过 for、while 等保留字提供遍历循环和无限循环结构

关于 Python 循环结构，以下选项中描述错误的是A

A continue 结束整个循环过程，不再判断循环的执行条件
B 遍历循环中的遍历结构可以是字符串、组合数据类型和 range()函数等
C Python 通过 for、while 等保留字构建循环结构
D continue 用来结束当前当次语句，但不跳出当前的循环体

下面代码的输出结果是C

for s in "HelloWorld":
if s=="W":
continue
print(s,end="")

A Hello
B HelloWorld
C Helloorld
D World

下面代码的输出结果是D

for s in "HelloWorld":
if s=="W":
break
print(s,end="")

A HelloWorld
B Helloorld
C World
D Hello

于程序的异常处理，以下选项中描述错误的是A

A 编程语言中的异常和错误是完全相同的概念
B 程序异常发生后经过妥善处理可以继续执行
C 异常语句可以与 else 和 finally 保留字配合使用
D Python 通过 try、except 等保留字提供异常处理功能

关于 Python 遍历循环，以下选项中描述错误的是B

A 遍历循环通过 for 实现
B 无限循环无法实现遍历循环的功能
C 遍历循环可以理解为从遍历结构中逐一提取元素，放在循环变量中，对于所提取的每个
元素只执行一次语句块
D 遍历循环中的遍历结构可以是字符串、文件、组合数据类型和 range()函数等

关于 Python 的无限循环，以下选项中描述错误的是D

A 无限循环一直保持循环操作，直到循环条件不满足才结束
B 无限循环也称为条件循环
C 无限循环通过 while 保留字构建
D 无限循环需要提前确定循环次数

10．给出如下代码：

import random
num = random.randint(1,10)
while True:
guess = input()
i = int(guess)
if i = =  num:
print("你猜对了")
break
elif i < num:
print("小了")
elif i > num:
print("大了")

以下选项中描述错误的是B

A random.randint(1,10)生成[1,10]之间的整数
B “import random”这行代码是可以省略的
C 这段代码实现了简单的猜数字游戏
D “while True:”创建了一个永远执行的 While 循环

11．给出如下代码：

a=3
while a > 0:
a -= 1
print(a,end=" ")

以下选项中描述错误的是：B

A a -= 1 可由 a = a – 1 实现
B 条件 a > 0 如果修改为 a < 0 程序执行会进入死循环
C 使用 while 保留字可创建无限循环
D 这段代码的输出内容为 2 1 0

14．关于 break 语句与 continue 语句的说法中，以下选项中不正确的是D

A continue 语句类似于 break 语句，也必须在 for、while 循环中使用
B break 语句结束循环，继续执行循环语句的后续语句
C 当多个循环语句嵌套时，break 语句只适用于最里层的语句
D continue 语句结束循环，继续执行循环语句的后续语句

16．实现多路分支的最佳控制结构是C

A if
B try
C if-elif-else
D if-else

17．给出下面代码：

age=23
start=2
if age%2!=0:
start=1
for x in range(start,age+2,2):
print(x)

上述程序输出值的个数是：B

A 10
B 12
C 16
D 14

24．于 while 保留字，以下选项中描述正确的是D

A while True: 构成死循环，程序要禁止使用
B 使用 while 必须提供循环次数
C 所有 while 循环功能都可以用 for 循环替代
D 使用 while 能够实现循环计数

27．Python 异常处理中不会用到的关键字是D

A finally
B else
C try
D if

28．下面代码的输出结果是C

for i in range(1,6):
if i%3 = = 0:
break
else:
print(i,end =",")

A 1,2,3,
B 1,2,3,4,5,6
C 1,2,
D 1,2,3,4,5,

32．下面代码的输出结果是C

for i in range(1,10,2):
	print(i,end=",")

A 1,4,
B 1,4,7,
C 1,3,5,7,9,
D 1,3,

39．下面代码的输出结果是A

for a in ["torch","soap","bath"]:
	print(a)

A
torch
soap
bath
B torch,soap,bath
C torch soap bath
D torch,soap,bath,

40．下面代码的输出结果是A

for a in 'mirror':
	print(a, end="")
	if a == 'r':
		break

A mir
B mirror
C mi
D mirror

50．给出下面代码：

a = input("").split(",")
x = 0
while x < len(a):
	print(a[x],end="")
	x += 1

代码执行时，从键盘获得 a,b,c,d，则代码的输出结果是：B

A 执行代码出错
B abcd
C 无输出
D a,b,c,d

四、函数和代码复用

3．以下选项中，不属于函数的作用的是 A

A 提高代码执行速度
B 增强代码可读性
C 降低编程复杂度
D 复用代码

4．假设函数中不包括 global 保留字，对于改变参数值的方法，以下选项中错误的是C

A 参数是列表类型时，改变原参数的值
B 参数是组合类型（可变对象）时，改变原参数的值
C 参数的值是否改变与函数中对变量的操作有关，与参数类型无关
D 参数是整数类型时，不改变原参数的值

6．给出如下代码：

def func(a,b):
	c=a**2+b
	b=a
	return c
a=10
b=100
c=func(a,b)+a

以下选项中描述错误的是C

A 执行该函数后，变量 a 的值为 10
B 执行该函数后，变量 b 的值为 100
C 执行该函数后，变量 c 的值为 200
D 该函数名称为 func

7．在 Python 中，关于全局变量和局部变量，以下选项中描述不正确的是B

A 一个程序中的变量包含两类：全局变量和局部变量
B 全局变量不能和局部变量重名
C 全局变量在程序执行的全过程有效
D 以上都不对

11．关于形参和实参的描述，以下选项中正确的是D

A 参数列表中给出要传入函数内部的参数，这类参数称为形式参数，简称形参
B 程序在调用时，将形参复制给函数的实参
C 函数定义中参数列表里面的参数是实际参数，简称实参
D 程序在调用时，将实参复制给函数的形参

12．关于 lambda 函数，以下选项中描述错误的是A

A lambda 不是 Python 的保留字
B 定义了一种特殊的函数
C lambda 函数也称为匿名函数
D lambda 函数将函数名作为函数结果返回

13 以下选项中，对于函数的定义错误的是B

A def vfunc(a,b=2):
B def vfunc(*a,b):
C def vfunc(a,b):
D def vfunc(a,*b):

14．关于函数的参数，以下选项中描述错误的是C

A 在定义函数时，如果有些参数存在默认值，可以在定义函数时直接为这些参数指定默认
值
B 在定义函数时，可以设计可变数量参数，通过在参数前增加星号（*）实现
C 可选参数可以定义在非可选参数的前面
D 一个元组可以传递给带有星号的可变参数

15．关于 return 语句，以下选项中描述正确的是D

A 函数必须有一个 return 语句
B 函数中最多只有一个 return 语句
C return 只能返回一个值
D 函数可以没有 return 语句

16．关于函数，以下选项中描述错误的是B

A 函数是一段具有特定功能的、可重用的语句组
B Python 使用 del 保留字定义一个函数
C 函数能完成特定的功能，对函数的使用不需要了解函数内部实现原理，只要了解函数的
输入输出方式即可。
D 使用函数的主要目的是降低编程难度和代码重用

17．关于 Python 的全局变量和局部变量，以下选项中描述错误的是D

A 使用 global 保留字声明简单数据类型变量后，该变量作为全局变量使用
B 简单数据类型变量无论是否与全局变量重名，仅在函数内部创建和使用，函数退出后变量被释放
C 全局变量指在函数之外定义的变量，一般没有缩进，在程序执行全过程有效
D 局部变量指在函数内部使用的变量，当函数退出时，变量依然存在，下次函数调用可以继续使用

18．关于 Python 的 lambda 函数，以下选项中描述错误的是A

A f = lambda x,y:x+y 执行后，f 的类型为数字类型
B lambda 用于定义简单的、能够在一行内表示的函数
C 可以使用 lambda 函数定义列表的排序原则
D lambda 函数将函数名作为函数结果返回

21．给出如下代码：

ls = ["car","truck"]
def funC(a):
	ls.append(a)
	return
funC("bus")
print(ls)

以下选项中描述错误的是D

A funC(a)中的 a 为非可选参数
B ls.append(a)代码中的 ls 是全局变量
C ls.append(a)代码中的 ls 是列表类型
D 执行代码输出结果为[‘car’, ‘truck’]

22．给出如下代码：

ls = ["car","truck"]
def funC(a):
	ls =[]
	ls.append(a)
	return
funC("bus")
print(ls)

以下选项中描述错误的是A

A 执行代码输出结果为[‘car’, ‘truck’, ‘bus’]
B 代码函数定义中，ls.append(a)中的 ls 是局部变量
C 执行代码输出结果为[‘car’, ‘truck’]
D ls.append(a)代码中的 ls 是列表类型

27．下面代码的输出结果是D

def func(a,b):
	a *= b
	return a
s = func(5,2)
print(s)

A 20
B 1
C 12
D 10

35．关于函数的返回值，以下选项中描述错误的是B

A 函数可以返回 0 个或多个结果
B 函数必须有返回值
C 函数可以有 return，也可以没有
D return 可以传递 0 个返回值，也可以传递任意多个返回值

37．关于函数，以下选项中描述错误的是A

A 函数使用时需要了解函数内部实现细节
B 函数主要通过接口（interface）与外界通信，传递信息
C 函数：具有特定功能的可重用代码片段，实现解决某个特定问题的算法
D 函数在需要时被调用，其代码被执行

40．关于函数的参数传递（parameter passing），以下选项中描述错误的是B

A 实际参数是函数调用时提供的参数
B 函数调用时，需要将形式参数传递给实际参数
C Python 参数传递时不构造新数据对象，而是让形式参数和实际参数共享同一对象
D 形式参数是函数定义时提供的参数

41．关于函数的关键字参数使用限制，以下选项中描述错误的是B

A 关键字参数顺序无限制
B 关键字参数必须位于位置参数之前
C 关键字参数必须位于位置参数之后
D 不得重复提供实际参数

43．执行下面代码，错误的是A

def f(x, y = 0, z = 0): 
	pass # 空语句，定义空函数体

A f(1, , 3)
B f(1, 2)
C f(1)
D f(1, 2, 3)

44．执行下面代码，错误的是B

def f(x, y = 0, z = 0): 
	pass # 空语句，定义空函数体

A f(1, z = 3)
B f(1, x = 1, z = 3)
C f(1, y = 2, z = 3)
D f(z = 3, x = 1, y = 2)

45．执行下面的代码，以下选项中正确的是D

def f(x, y = 0, z = 0): 
	pass # 空语句，定义空函数体

A f(x = 1, 2)
B f(1, y = 2, t = 3)
C f(1, x = 1, z = 3)
D f(x = 1, y = 2, z = 3)

五、组合数据类型

1.字典 d={‘abc’:123, ‘def’:456, ‘ghi’:789}，len(d)的结果是C

A 9
B 12
C 3
D 6

2.关于 Python 的元组类型，以下选项中描述错误的是A

A 元组中元素不可以是不同类型
B 元组一旦创建就不能被修改
C Python 中元组采用逗号和圆括号（可选）来表示
D 一个元组可以作为另一个元组的元素，可以采用多级索引获取信息

5.以下选项中，不是 Python 序列类型的是C

A 元组类型
B 字符串类型
C 数组类型
D 列表类型

6.对于序列 s，能够返回序列 s 中第 i 到 j 以 k 为步长的元素子序列的表达是D

A s[i, j, k]
B s(i, j, k)
C s[i; j; k]
D s[i:j:k]

14.给定字典 d，以下选项中对 x in d 的描述正确的是D

A 判断 x 是否是在字典 d 中以键或值方式存在
B 判断 x 是否是字典 d 中的值
C x 是一个二元元组，判断 x 是否是字典 d 中的键值对
D 判断 x 是否是字典 d 中的键

18.关于 Python 的列表，以下选项中描述错误的是B

A Python 列表是一个可以修改数据项的序列类型
B Python 列表的长度不可变
C Python 列表用中括号[]表示
D Python 列表是包含 0 个或者多个对象引用的有序序列

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

A 如果 s 是一个序列，s =[1,“kate”,True]，s[3] 返回 True
B 如果 s 是一个序列，x 是 s 的元素，x in s 返回 True
C 如果 s 是一个序列，s =[1,“kate”,True]，s[–1] 返回 True
D 如果 s 是一个序列，x 不是 s 的元素，x not in s 返回 True

20.下面代码的输出结果是C

s =["seashell","gold","pink","brown","purple","tomato"]
print(s[1:4:2])

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

21.下面代码的输出结果是A

s =["seashell","gold","pink","brown","purple","tomato"]
print(s[4:])

A [‘purple’, ‘tomato’]
B [‘seashell’, ‘gold’, ‘pink’, ‘brown’]
C [‘purple’]
D [‘gold’, ‘pink’, ‘brown’, ‘purple’, ‘tomato’]

22.下面代码的输出结果是C

s =["seashell","gold","pink","brown","purple","tomato"]
print(len(s),min(s),max(s))

A 6 seashell gold
B 5 pink brown
C 6 brown tomato
D 5 purple tomato

23.给出如下代码：

s = list("巴老爷有八十八棵芭蕉树，来了八十八个把式要在巴老爷八十八棵芭蕉树下\
住。老爷拔了八十八棵芭蕉树，不让八十八个把式在八十八棵芭蕉树下住。八十八个\
把式烧了八十八棵芭蕉树，巴老爷在八十八棵树边哭。")

以下选项中能输出字符“八”出现次数的是A

A print(s.count(“八”))
B print(s.index(“八”))
C print(s.index(“八”),6,len(s))
D print(s.index(“八”),6)

24.给出如下代码：

s = list("巴老爷有八十八棵芭蕉树，来了八十八个把式要在巴老爷八十八棵芭蕉树下住。老
爷拔了八十八棵芭蕉树，不让八十八个把式在八十八棵芭蕉树下住。八十八个把式烧了八十
八棵芭蕉树，巴老爷在八十八棵树边哭。")

以下选项中能输出字符“八”第一次出现的索引位置的是C

A print(s.index(“八”),6,len(s))
B print(s.count(“八”))
C print(s.index(“八”))
D print(s.index(“八”),6)

25.下面代码的输出结果是A

vlist = list(range(5))
print(vlist)

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

26.下面代码的输出结果是A

vlist = list(range(5))
for e in vlist:
print(e,end=",")

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

27.关于 Python 字典，以下选项中描述错误的是B

A Python 字典是包含 0 个或多个键值对的集合，没有长度限制，可以根据"键"索引"值"的内容
B 如果想保持一个集合中元素的顺序，可以使用字典类型
C Python 通过字典实现映射
D 字典中对某个键值的修改可以通过中括号[]的访问和赋值实现

28.给出如下代码：

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

以下选项中能输出“海贝色”的是A

A print(DictColor[“seashell”])
B print(DictColor.keys())
C print(DictColor.values())
D print(DictColor[“海贝色”])

36.下面代码的输出结果是C

d = {'a':1,'b':2,'c':3};
print(d['c'])

A {‘c’:3}
B 2
C 3
D 1

37.下面代码的输出结果是B

list1 = [1,2,3]
list2 = [4,5,6]
print(list1+list2)

A [4,5,6]
B [1, 2, 3, 4, 5, 6]
C [1,2,3]
D [5,7,9]

47.下面代码的输出结果是B

a = [1, 2, 3]
b = a[:]
print(b)

A []
B [1, 2, 3]
C 0xF0A9
D [3,2,1]

六、面向对象：

关于面向对象的继承，以下选项中描述正确的是B

A
继承是指一组对象所具有的相似性质
B
继承是指类之间共享属性和操作的机制
C
继承是指各对象之间的共同性质
D
继承是指一个对象具有另一个对象的性质
正确答案： B

七、文件

2.以下选项中，不是 Python 对文件的读操作方法的是C

A read
B readline
C readtext
D readlines

3.以下选项中，不是 Python 对文件的打开模式的是D

A ‘w’
B ‘r’
C ‘+’
D 'c‘

判断题

判断题答案变为白色，想要查看请长按复制复制查看，或鼠标向后扫描查看答案
例如：

一、基础知识

1、Python 是一种跨平台、开源、免费的高级动态编程语言。（对）
2、Python 3.x 完全兼容 Python 2.x。（错）
3、Python 3.x 和 Python 2.x 唯一的区别就是：print 在 Python 2.x 中是输出语句，而在 Python3.x 中是输出函数。（错）
4、在 Windows 平台上编写的 Python 程序无法在 Unix 平台运行。（错）
5、不可以在同一台计算机上安装多个 Python 版本。（错）
6、已知 x = 3，那么赋值语句 x = ‘abcedfg’ 是无法正常执行的。（错）
7、Python 变量使用前必须先声明，并且一旦声明就不能再当前作用域内改变其类型。（错）
8、Python 采用的是基于值得自动内存管理方式。（对）
11、在 Python 中可以使用 if 作为变量名。（错）
12、在 Python 3.x 中可以使用中文作为变量名。（对）
13、Python 变量名必须以字母或下划线开头，并且区分字母大小写。（对）
14、加法运算符可以用来连接字符串并生成新字符串。（对）
15、3+4j 不是合法的 Python 表达式。（错）
16、不管输入什么，Python 3.x 中 input()函数的返回值总是字符串。（对）
17、24、Python 使用缩进来体现代码之间的逻辑关系。（对）
18、Python 代码的注释只有一种方式，那就是使用#符号。（错）
19、在 Python 中可以使用 for 作为变量名。（错）
20、Python 关键字不可以作为变量名。（对）
21、不同版本的 Python 不能安装到同一台计算机上。（错）
22、Python 变量名区分大小写，所以 student 和 Student 不是同一个变量。（对）

二、序列

23、Python 支持使用字典的“键”作为下标来访问字典中的值。（对）
24、字典的“键”必须是不可变的。（对）
25、Python 集合中的元素不允许重复。（对）
26、Python 字典中的“键”不允许重复。（对）
27、Python 字典中的“值”不允许重复。（错）
28、Python 集合中的元素可以是元组。（对）
29、Python 列表中所有元素必须为相同类型的数据。（错）
30、Python 列表、元组、字符串都属于有序序列。（对）
31、如果表达式 AB 的值一定为 True。（错）
32、元组是不可变的，不支持列表对象的 inset()、remove()等方法，也不支持 del 命令删除其中的元素，但可以使用 del 命令删除整个元组对象。（对）
33、Python 字典和集合属于无序序列。（对）
34、字符串属于 Python 有序序列，和列表、元组一样都支持双向索引。（对）
35、Python 字典和集合支持双向索引。（错）
36、Python 集合不支持使用下标访问其中的元素。（对）
37、相同内容的字符串使用不同的编码格式进行编码得到的结果并不完全相同。（对）
38、创建只包含一个元素的元组时，必须在元素后面加一个逗号，例如(3,)。（对）
39、同一个列表对象中的元素类型可以各不相同。（对）
40、已知 x 是个列表对象，那么执行语句 y = x 之后，对 y 所做的任何操作都会同样作用到x 上。（对）

三、选择结构与循环结构、函数

1、如果仅仅是用于控制循环次数，那么使用 for i in range(20)和 for i in range(20, 40)的作用是等价的。（对）
2、在循环中 continue 语句的作用是跳出当前循环。（错）
3、在编写多层循环时，为了提高运行效率，应尽量减少内循环中不必要的计算。（对）
4、函数是代码复用的一种方式。（对）
5、定义函数时，即使该函数不需要接收任何参数，也必须保留一对空的圆括号来表示这是一个函数。（对）
6、编写函数时，一般建议先对参数进行合法性检查，然后再编写正常的功能代码。（对）
7、一个函数如果带有默认值参数，那么必须所有参数都设置默认值。（错）
8、定义 Python 函数时必须指定函数返回值类型。（错）
9、定义 Python 函数时，如果函数中没有 return 语句，则默认返回空值 None。（对）
10、如果在函数中有语句 return 3，那么该函数一定会返回整数 3。（错）
11、函数中必须包含 return 语句。（错）
12、函数中的 return 语句一定能够得到执行。（错）
13、不同作用域中的同名变量之间互相不影响，也就是说，在不同的作用域内可以定义同名的变量。（对）
14、函数内部定义的局部变量当函数调用结束后被自动删除。（对）
15、在函数内部，既可以使用 global 来声明使用外部全局变量，也可以使用 global 直接定义全局变量。（对）
16、在函数内部没有办法定义全局变量。（错）
17、在函数内部没有任何方法可以影响实参的值。（错）
18、调用带有默认值参数的函数时，不能为默认值参数传递任何值，必须使用函数定义时设置的默认值。（错）
19、在同一个作用域内，局部变量会隐藏同名的全局变量。（对）
20、形参可以看做是函数内部的局部变量，函数运行结束之后形参就不可访问了。（对）
21、Python 标准库 random 的方法 randint(m,n)用来生成一个[m,n]区间上的随机整数。（对）
22、在函数内部没有任何声明的情况下直接为某个变量赋值，这个变量一定是函数内部的局部变量。（对）
23、在 Python 中定义函数时不需要声明函数参数的类型。（对）
24、在 Python 中定义函数时不需要声明函数的返回值类型。（对）
25、在函数中没有任何办法可以通过形参来影响实参的值。（错）
26、在定义函数时，某个参数名字前面带有一个* 符号表示可变长度参数，可以接收任意多个普通实参并存放于一个元组之中。（对）
27、在定义函数时，某个参数名字前面带有两个*符号表示可变长度参数，可以接收任意多个关键参数并将其存放于一个字典之中。（对）
28、定义函数时，带有默认值的参数必须出现在参数列表的最右端，任何一个带有默认值的参数右边不允许出现没有默认值的参数。（对）
29、在调用函数时，可以通过关键参数的形式进行传值，从而避免必须记住函数形参顺序的麻烦。（对）
30、在调用函数时，必须牢记函数形参顺序才能正确传值。（错）
31、调用函数时传递的实参个数必须与函数形参个数相等才行。（错）
32、语句 pass 仅起到占位符的作用，并不会做任何操作。（对）
33、在类定义的外部没有任何办法可以访问对象的私有成员。（错）
34、Python 中一切内容都可以称为对象。（对）
35、在一个软件的设计与开发中，所有类名、函数名、变量名都应该遵循统一的风格和规范。（对）
36、定义类时所有实例方法的第一个参数用来表示对象本身，在类的外部通过对象名来调用实例方法时不需要为该参数传值。（对）
37、Python 中没有严格意义上的私有成员。（对）
38、Python 支持多继承，如果父类中有相同的方法名，而在子类中调用时没有指定父类名，则 Python 解释器将从左向右按顺序进行搜索。（对）
39、Python 类的构造函数是__init__()。（对）
40、定义类时，在一个方法前面使用@classmethod 进行修饰，则该方法属于类方法。（对）
41、通过对象不能调用类方法和静态方法。（错）
42、在 Python 中可以为自定义类的对象动态增加新成员。（对）
43、Python 类不支持多继承。（错）
44、在设计派生类时，基类的私有成员默认是不会继承的。（对）

四、文件与异常处理

45、使用内置函数 open()且以”w”模式打开的文件，文件指针默认指向文件尾。（错）
46、以读模式打开文件时，文件指针指向文件开始处。（对）
47、以追加模式打开文件时，文件指针指向文件尾。（对）
48、二进制文件也可以使用记事本程序打开，只是无法正确阅读和理解其中的内容。（对）
49、以写模式打开的文件无法进读操作。（对）
50、二进制文件不能使用记事本程序打开。（错）
51、在 try…except…else 结构中，如果 try 块的语句引发了异常则会执行 else 块中的代码。（错）
52、异常处理结构中的 finally 块中代码仍然有可能出错从而再次引发异常。（对）
53、程序中异常处理结构在大多数情况下是没必要的。（错）
54、带有 else 子句的异常处理结构，如果不发生异常则执行 else 子句中的代码。（对）
55、异常处理结构也不是万能的，处理异常的代码也有引发异常的可能。（对）
56、在异常处理结构中，不论是否发生异常，finally 子句中的代码总是会执行的。（对）
57、由于异常处理结构 try…except…finally…中 finally 里的语句块总是被执行的，所以把关闭文件的代码放到 finally 块里肯定是万无一失，一定能保证文件被正确关闭并且不会引发任何异常。（错）