Python精选480题带解析

精选480道选择题

基础共81题带答案和解析

1.以下关于Python缩进的描述中，错误的是**（** A ）

A Python用严格的缩进表示程序的格式框架，所有代码都需要在行前至少加一个空格

B 缩进是可以嵌套的，从而形成多层缩进

C 缩进表达了所属关系和代码块的所属范围

D 判断、循环、函数等都能够通过缩进包含一批代码

答案：选 a

Python语言采用严格的缩进来表示程序逻辑。

**缩进：**指每行语句开始前的空白区域，用来表示Python程序间的包含和层次关系。

一般代码不需要缩进，顶行编写且不留空白。

当表示分支、循环、函数、类等程序含义时，在if、while、for、def、class等保留字所在完整语句后通过英文冒号（:）结尾并在之后进行缩进，表明后续代码与紧邻无缩进语句的所属关系。

怎么可能所有代码都需要在行前至少加一个空格，需要时才加

2.以下代码的输出结果是__5____。

x = 'A\0B\0C'

print(len(x))

答案： 5

len(x)返回字符串x的长度

一个中文字符和一个西文字符的长度都记为1。

""为转义字符，"\0"表示一个空格，长度记为1，所以字符串长度为5。

3.以下关于Python语言技术特点的描述中，错误的是（B）

A Python比大部分编程语言具有更高的软件开发产量和简洁性

B Python是脚本语言，主要用作系统编程和Web访问的开发语言

C Python语言是解释执行的，因此执行速度比编译型语言慢

D 对于需要更高执行速度的功能，例如数值计算和动画，Python语言可以调用C语言编写的底层代码

答案：选 b

Python语言是一种被广泛使用的高级通用脚本编程语言，具有通用性，可以用于几乎任何与程序设计相关应用的开发，不仅适合训练编程思维，更适合诸如数据分析、机器学习、人工智能、web开发等具体的技术领域。

系统编程主要用C/C++，python太慢了

网络解释：

py是一种解释型高级通用脚本语言，具有通用性，可以用于几乎任何与程序设计相关应用的开发。主要应用于以下几个领域：Web开发，爬虫开发，科学计算，高性能服务器后端，开发界面程序，QT也提供了py的支持，因为py的开源库包含了对C/C++lib库的调用，主要二字太过绝对，因此不对。

4.以下代码的输出结果是___27___。

x = 2 + 9 * ((3* 12) - 8) // 10

print(x)

答案： 27

x//y计算x除以y的商再取int()函数，即不大于x与y之商的最大整数。

x = 2 + 9 * ((3* 12) - 8) // 10 = 2 + 9 * 28 // 10 = 2 + 25 = 27。

5.在Python语言中，可以作为源文件后缀名的是__py____。

答案： py

py可作为源文件后缀名。

python文件的后缀名有:".py"、".py3"、".pyc"、".pyo"、".pyd"、".pyi"、".pyx"、".pyz"、".pywz"、".rpy"、".pyde"、".pyp"、".pyt"

6.以下不属于Python语言保留字的是（A）

A goto

B except

C True

D Pass

答案： goto

Goto是c语言的，不是Python语言保留字。

except是python的保留字

7.以下代码的输出结果是______。

print( 0.1 + 0.2 == 0.3 )

答案： False

双等号==用于判断值是否相等，判断结果是True（真）或False（假），分别对应值相等或值不相等。

左侧运算结果为0.30000000000000004，右侧结果为0.3，值不相等，所以输出False。

Python中print(0.1 + 0.2 == 0.3)的结果是False，

网络解释：

这是因为在计算机中无法精确表示10进制浮点数，而在Python中浮点数默认采用IEEE754标准的双精度浮点数，即64位。

在十进制下，0.1+0.2=0.3，但在二进制下， 0. 1和0 2无法精确表示，因此计算机会近似表示这两个数字。

0.1和0.2在二进制下无限循环，在计算机中的0.1是一个无限循环的小数，而计算机只能用64位来近似表示。

这导致当我们将0.1和0.2相加时，结果并不等于0.3，而是接近于0.30000000000000004所以当我们将0.1 + 0.2与0.3相比较时，结果是False。

8.以下关于Python字符编码的描述中，错误的是（C）

A print (chr (65) )输出A

B chr (x)和ord(x)函数用于在单字符和Unicode编码值之间进行转换

C Python字符编码使用ASCII编码

D print(ord( ' a' ))输出97

答案：选 c

chr( )函数将ASCII码转为相应的字符。字母"A"的ASCII码为65，chr(65)结果是"A"，

属于字符型。

ord( )函数是Python中的库函数，用于获取字符的ASCII值。

字母"a"的ASCII码为97，ord( ' a' )的结果是97

Python字符编码可以使用ASCII编码和Unicode编码。

但是Python3之后用的都是Unicode编码。

9.以下代码的输出结果是__D____。

a = 10.99

print(complex(a))

A 0. 99

B 10.99+j

C 10.99

D (10.99+0j)

答案：选 d

complex(r，i)函数的作用是创建一个复数r+i*1j，a= 10.99,说明实部为10.99 ,虛部为0，其中i可以省略。

10.以下不属于Python语言保留字的是（A）

A do

B pass

C while

D def

答案： do

do不是Python保留字。

11.表达式3*4**2//8%7的计算结果是___6___。

答案： 6

x **y的作用是计算x的y次幂。

x//y的作用是计算x与y的整数商，即不大于x与y之商的最大整数。

x%y的作用是计算x与y之商的余数。

表达式中的运算符中，的运算级最高，所以先计算42，即3*4**2//8%7=3*16//8%7=48//8%7=6%7=6。

12.以下关于Python字符串的描述中，错误的是__D____。

A 空字符串可以表示为" "或' '

B 在Python字符串中，可以混合使用正整数和负整数进行索引和切片

C 字符串'my\text.dat'中第一个\表示转义符

D Python字符串采用[N:M]格式进行切片，获取字符串从索引N到M的子字符串

（包含N和M）

答案：选 d

对字符串的某个子串进行切片：[N:M]，前闭后开区间

切片获取字符串从N到M（不包含M）的子字符串。

N和M为字符串的索引序号，可以混合使用正向递增序号和反向递减序号。

13.Python语言提供三种基本的数字类型，它们是（A）

A 整数类型、浮点数类型、复数类型

B 整数类型、二进制类型、浮点数类型

C 复数类型、二进制类型、浮点数类型

D 整数类型、二进制类型、复数类型

答案：选 a

Python语言提供3种数字类型：整数类型、浮点数类型和复数类型。

14.以下关于语言类型的描述中，错误的是（D）

A 解释是将源代码逐条转换成目标代码同时逐条运行目标代码的过程

B C语言是静态编译语言，Python语言是脚本语言

C 编译是将源代码转换成目标代码的过程

D 静态语言采用解释方式执行，脚本语言采用编译方式执行

答案：选 d

高级语言根据计算机执行机制的不同可分成两类：静态语言和脚本语言

静态语言采用编译方式执行，脚本语言采用解释方式执行。

15.在Python语言中，IPO模式不包括（B）

A Input (输入)

B Program (程序)

C Process (处理)

D Output (输出)

答案：选 B

IPO模式包括输入（input）、输出（output）和处理（process）。

16.拟在屏幕上打印输出Hello World，使用的Python语句是___A___。

A print('Hello World' )

B print(Hello World)

C printf("Hello World")

D printf(' Hello World' )

答案：选 a

Python中使用print()函数进行打印输出。C语言是printf

字符串是字符的序列表示，根据字符串内容多少分为单行字符串和多行字符串。

单行字符串由一对单引号或双引号作为边界表示；

多行字符串由一对三单引号或三双引号作为边界表示。

17.以下关于二进制整数的定义，正确的是（D）

A 0bC3F

B 0b1708

C 0B1019

D 0B1010

答案：选 d

二进制整数以0b引导，由字符0和1组成。

二进制整数只有0和1

18.以下关于Python语言浮点数类型的描述中，错误的是（C）

A Python语言要求所有浮点数必须带有小数部分

B 浮点数类型表示带有小数的类型

C 小数部分不可以为0

D 浮点数类型与数学中实数的概念一致

答案：选 c

Python语言中的浮点数类型必须带有小数部分，小数部分可以是0。

小数部分可以为0，例如5.0。

19.以下变量名中，不符合Python语言变量命名规则的是（C）

A keyword_33

B keyword33_

C 33_ keyword

D _ 33keyword

答案：选 c

Python采用大写字母、小写字母、数字、下划线和汉字等字符及其组合进行命名。

但名字的首字符不能是数字，标识符中间不能出现空格，长度没有限制。

C语言中标识符的首字符必须是字母或下划线，不能是字母。

20.以下关于程序设计语言的描述，错误的选项是（A）

A Python解释器把Python代码一次性翻译成目标代码，然后执行

B 机器语言直接用二进制代码表达指令

C Python是一种通用编程语言

D 汇编语言是直接操作计算机硬件的编程语言

答案：选 a

解释是将源代码逐条转换成目标代码同时逐条运行目标代码的过程。

A错误，不是一次性

执行解释的计算机程序成为解释器。

21.以下关于Python程序语法元素的描述，正确的选项是（B）

A 缩进格式要求程序对齐，增添了编程难度

B 所有的if、while、 def、 class语句后面都要用':'结尾

C Python变量名允许以数字开头

D true是Python的保留字

答案：选 b

一般代码不需要缩进，顶行编写不留空白。

当表示分支、循环、函数、类等程序含义时，在if、while、for、def、class等保留字所在完整语句后，英文冒号结尾后进行缩进，表明后续代码与紧邻无缩进语句的所属关系。

代码编写中，缩进可以用Tab键实现，也可以用多个空格（一般是4个空格）实现。但tab键和空壳两者不混用。

缩进不会增添编程难度

Python采用大写字母、小写字母、数字、下划线和汉字等字符组合进行命名，但首字符不能是数字。

Python保留字是大小写敏感的，True是保留字，true不是。

22.以下选项，不是Python保留字的选项是（）

A None

B from

C finally

D sum

答案：D

sum不是保留字，可以被当做变量使用。

23.字符串tstr=' television'，显示结果为vi的选项是（A）

A print(tstr[-6:6])

B print(tstr [5:7])

C print(tstr [4:7])

D print(tstr [4:-2])

答案：选 a

对字符串的某个子串进行切片：[N:M]

切片获取字符串从N到M（不包含M）的子字符串。

N和M为字符串的索引序号，可以混合使用正向递增序号和反向递减序号。

反向从-1开始，正向从0开始。

tstr[-6:6]表示截取字符串反向第6个字符v到正向第7个字符s（不包括s）之间的字符，即vi。

24.关于表达式id(' 45' )的结果的描述，错误的是（A）

A 是一个字符串

B 可能是4539670688

C 是一个正整数

D 是'45'的内存地址

答案：选 a

id()函数是Python内置函数，作用是获取对象的内存地址，返回对象的内存地址（是一个正整数）。

' 45'是字符串，id(' 45' )的结果是45的内存地址，是个正整数。

25.以下选项不属于Python语言特点的是（C）

A 平台无关

B 第三方库丰富

C 适合编写系统软件

D 语法简洁

答案：选 c

Python语言的三个重要特点：

（1）通用性：Python语言可以用于几乎任何与程序设计相关应用的开发，不仅适合训练编程思维，更适合诸如数据分析、机器学习、人工智能、Web开发等具体的技术区域。

（2）语法简洁。

（3）生态高产：Python解释器提供了几百个内置类和函数库，此外，世界各地程序员通过开源社区贡献了十几万个第三方函数库。

除此之外，还有一些具体特点：

（1）平台无关。

（2）强制可读。

（3）支持中文。

Python可以编写系统软件，但是不是它的特点

26.如果Python程序执行时产生了"TypeError'的错误，其原因是（C）

A 代码中缺少":"符号

B 代码使用了错误的关键字

C 代码中的数据类型不匹配

D 代码里的语句嵌套层次太多

答案：选 c

TypeError表示类型错误。

27.以下选项，不是Python保留字的选项是_（B）

A with

B count

C is

D and

答案：选 b

count不是保留字，可以被当做变量使用。

28.表达式eval(' 500//10' )的结果是_（C）

A 500/10

B 50.0

C 50

D '500/10'

答案：选 c

eval()函数将去掉字符串最外侧的引号，并执行去掉引号后的字符内容。

运算符//表示计算整数商，500//10结果为50。

29.表达式type(type(' 45' ))的结果是_（A）

A <class' type' >

B <class' str' >

C <class' float' >

D None

答案：选 a

type(x)函数对变量x进行类型判断，type('45')输出为<class 'str'>，type(type('45'))输出为<class 'type'>。

30.以下不是Python语言所使用特殊含义符号的是（A）

A $

B **

C &

D +=

答案：选 a

是数值运算操作符，xy表示x的y次幂。

+=是增强赋值操作符，x+=y等价于x=x+y。

&是按位与运算符，参与运算的两个二进制值，如果两个相应位都为1，则该位的结果为1，否则为0。

31.以下不是Python语言保留字的是（D）

A lambda

B pass

C await

D do

答案：选 d

do不是保留字，d开头的保留字只有def和del。

python用lambda函数排序

32.以下保留字不用于循环逻辑的是（A）

A try

B else

C for

D continue

答案：选 a

Python语言使用保留字try和except进行异常处理。

33.s=' 1234567890'，以下表示'1234'的选项是（C）

A s[-10:-5]

B s[0:3]

C s[0:4]

D s[1:5]

答案：选 c

切片是左闭右开，s[-10:-5]是12345，s[0:3]是123，s[0:4]是1234，s[1:5]是2345

34.表达式3+5%6*2//8的值是____4___

答案：4

x%y表示x与y之商的余数，x//y表示x与y之整数商。

先计算3+(((5%6)*2)//8)中的(((5%6)*2)//8)=5*2//8=10//8=1，再计算3+1=4。

35.以下不是Python语言所使用特殊含义符号的是（D）

A &=

B **

C ^

D ?

答案：选 d

**是数值运算操作符。幂

&是按位与运算符，&=则是对应的二元操作符。

^是按位异或运算符。

36.以下不是Python语言保留字的是（A）

A false

B as

C def

D from

答案：选 a

保留字大小写敏感，False是保留字，false不是保留字。

37.以下保留字不用于异常处理逻辑的是（B）

A else

B if

C try

D finally

答案：选 b

if不用于异常处理逻辑，用于分支结构。

try except异常处理

try...except...else...异常捕获

try...except...finally...异常捕获

38.以下不是Python语言特点的是（A）

A 执行速度快

B 语法简洁

C 支持中文

D 生态丰富

答案：选 a

Python语言的三个重要特点：

（2）语法简洁。

（3）生态高产：Python解释器提供了几百个内置类和函数库，此外，世界各地程序员通过开源社区贡献了十几万个第三方函数库。

除此之外，还有一些具体特点：

（1）平台无关。

（2）强制可读。

（3）支持中文。

Python执行速度快，但是不是它的特点，对比c和c++还不够快。

39.以下符合Python语言变量命名规则的是（C）

A 5_2

B ！i

C turtle

D (ABC)

选择：选 c

A不符合，数字不能做首项；

符号只有下划线可以，感叹号、括号不行B、D不对

Python采用大写字母、小写字母、数字、下划线和汉字等字符组合命名，但首字符不能是数字。

Python的turtle库是Python内置函数库，属于标准库，用于图形绘制。

turtle库绘制图形，可以理解为一只小海龟在画布中心开始爬行，起点位置坐标为（0,0），其前进、后退、旋转的轨迹就构成了绘制图形，比较直观、有趣、易理解，深受用户喜爱。

使用时首先导入turtle标注库，即可使用turtle标注库的函数。

import turtle

40.以下选项不属于Python语言特点的是（B）

A 优异的扩展性

B 网络编程语言

C 跨平台

D 开源理念

答案：选 b

Python语言的三个重要特点：

（2）语法简洁。

（3）生态高产：Python解释器提供了几百个内置类和函数库，此外，世界各地程序员通过开源社区贡献了十几万个第三方函数库。

除此之外，还有一些具体特点：

（1）平台无关。

（2）强制可读。

（3）支持中文。

Python提供了许多网络编程库和模块,使其成为一种优秀的网络编程语言。

但是网络编程语言不是python的特点。

41.如果Python程序执行时产生了"SyntaxError' 的错误，其原因是（D）

A 代码中的输出格式错误

B 代码里的变量名未定义

C 代码使用了错误的关键字

D 代码中出现了无法解释执行的符号

答案：选 d

Python中出现SyntaxError一般表示语法错误，如在 if , elif , else , for , while , class ,def 声明末尾未添加":"，导致该语句无法解释执行。

知识点总结：Python常见报错：

1、缩进错误（IndentationError）

2、Tab 和空格混用（TabError）

3、语法错误（SyntaxError）

语法错误的原因包含下列三种：

①无效语法（invalid syntax）

标点符号遗漏，中英文符号混用，拼写错误，变量名或者函数名使用了关键字。

②标识符中有无效字符（invalid character in identifier）

代码中出现了无法识别的字符，检查一下是否有多余字符或者中文字符。

③检查到不完整的字符串（EOL while scanning string litera）

很多情况下是由于字符串两边的引号不统一。

4、变量名错误（NameErro）

出现变量名错误，可以查看变量是否赋值，是否存在大小写不统一或者变量名写错了

5、索引错误（IndexError）

6、键错误（KeyError）

在读取字典中的key和value时，如果key不存在，就会触发KeyError错误。

7、类型错误（TypeError）

在程序中使用不正确的对象类型时，会引发该错误。

8、属性错误（AttributeError）

特性引用和赋值失败时会引发属性错误。

42.以下选项不是Python保留字的是_（D）

A False

B from

C try

D For

答案：选 d

Python中区分大小写，小写的for是保留字。

43.表达式int('100/3')的执行结果是（D）

A '100/3'

B 33.3

C 33

D ValueError

答案：选 d

int()函数用于将一个字符串或数字转换为整型，字符串'100/3'中有"/"，该文本不能转化成数值，参数无效，会报ValueError的错误。

int(100/3)结果是33，不带引号是数字型，100/3=33.3，浮点数强制转换为整型，结果33

int('100/3')的执行结果ValueError，带引号的是字符型，是浮点数不是整型，报错

100/3

'100/3'

1+2j

123

'123'

1.5

'1.5'

Python int() 使用总结：

int()的基本语法格式是int(x,[base=10])，其中base可以省略

int()的作用是把不同进制的数字或数字字符串转为十进制整数。

1、不带任何参数返回0,即int()

2、取整是简单截断，不是四舍五入，如int(1.5) = 1

3、参数可以是整数，浮点数，或算术表达式如100/3，但不能是复数，如1+2j ，会报错TypeError

4、数字字符串可以是整数字符串如'123'，

但不能是算术表达式字符串如'100/3'或字符形式的浮点数如'1.5'，会报错 ValueError

5、base缺省值是10，表示十进制，如果包括base参数，则前面的x必须是符合当前进制的数字字符串

此时int的作用是把base进制代表的数字字符串x，转换为10进制数

44.以下语句的执行结果是_（D）

import random

print (type (random.random()))

A <class 'int' >

B <class 'str' >

C None

D <class 'float' >

答案：选 d

type(x)函数对变量x进行类型判断。

random.random()表示取随机数，数值的类型是float型，所以执行结果为<class 'float'>。

random 库主要函数总结：

函数名说明用法

random() 生成一个0~1之间的随机浮点数,范围 0 <= n < 1.0 random.random()

uniform(a,b) 返回a, b之间的随机浮点数，范围[a, b]或[a, b), 取决于四舍五入,a不一定要比b小 random.uniform(1,5)

randint(a, b) 返回a, b之间的整数，范围[a, b]，注意：传入参数必须是整数，a一定要比b小 random.randint(0, 100)

randrange([start], stop[, step]) 类似range函数，返回区间内的整数，可以设置step。 random.randrange(1, 10, 2)

choice(seq) 从序列seq中随机读取一个元素 random.choice([1,2,3,4,5])

choices(seq,k) 从序列seq中随机读取k个元素，k默认为1 random.choices([1,2,3,4,5], k=3)

shuffle(x) 将列表中的元素打乱，俗称为洗牌。会修改原有序列。 random.shuffle([1,2,3,4,5])

sample(seq, k) 从指定序列中随机获取k个元素作为一个片段返回，sample函数不会修改原有序列 random.sample([1,2,3,4,5], 2)

45.关于Python语言的描述，错误的选项是（C）

A 支持面向对象

B 支持面向过程

C 是一种机器语言

D 是一种解释类型的语言

答案：选 c

Python语言是广泛使用的高级通用脚本编程语言，并不是机器语言。

Python既支持面向对象，又支持面向过程。

静态cj编译，脚本py解释。

46.执行下列选项，输出了'Hello World' 的选项是（C）

A print(' "Hello World"')

B print('"Hello World")

C print(" 'Hello World' ")

D print( 'Hello World")

答案：选 c

print()函数输出字符串时，需要在字符串两端加上双引号，所以print(" 'Hello World' ")能输出'Hello World'。

47.以下选项，不是Python保留字的选项是_（B）

A True

B true

C pass

D None

答案：选 b

True是Python保留字，Python语言中区分大小写，true不是保留字。

48.表达式34%6的结果是___4___。

答案：4

%表示取余，34%6的结果为4。

49.下面语句的执行结果，不可能的选项是（B）

import random

print (random.uniform(1, 3))

A 2. 764076933688729

B 3. 993002365820678

C 2. 5670577649215085

D 1. 807117374321477

答案：选 b

uniform(a,b)：生成一个[a,b]之间的随机小数，3.993002365820678超出了范围。

50.在Python语言中，不能作为变量名的是_（C）

A p

B Temp

C 3p

D _fg

答案：选 c

Python采用大写字母、小写字母、数字、下划线和汉字等字符及其组合进行命名，但名字的首字符不能是数字，标识符中间不能出现空格，长度没有限制。

51.以下不是Python语言特点的是（C）

(A) 支持面向过程和面向对象编程

(B) 生态庞大

(D) 语法简洁

答案：选 c

运行速度快不是Python语言特点

52.可以部署Python环境、运行Python脚本的系统是（B）

(A) Mac 0S

(B) 各操作系统平台

(D) Linux

答案：选 b

因为python平台无关，可以在所有操作系统上运行。

53.关于Python语言的描述，错误的选项是（D）

(A) Python支持中文等多语言字符

(B) Python具有庞大的计算生态

(D) Python是一种编译型语言，可在各类计算机上直接运行

答案：选 d

Python是一种解释型语言，先编译，后翻译。

C语言和c++是编译型语言

54.关于Python代码编写原则的描述，错误的选项是（D）

(A)保持代码的可读性、减少嵌套

(B)变量的定义和引用范围要清晰

(D) 尽量使用函数和类封装代码

答案：选 d

不一定什么都要尽量用函数，就计算1+1=2很简单的程序，没必要用函数。

55.关于Python缩进的描述，错误的选项是

(A) Python使用缩进表示代码块，缩进必须固定采用4个空格

(B) Python缩进在单个结构体语句(比如某个循环体)中必须一致

(D) Python的分支、循环、函数可以通过缩进包含多行代码

答案：选 a

缩进采用的空格数量必须固定，不一定非要是4个，2个4个6个都行

56.以下可以替代#用来当作Python语言注释的语法元素是

(A) input()函数

(B) eval ()函数

(D) 字符串类型

答案：选 d

函数肯定不能代替#，所以肯定是字符串类型

57.以下选项不是Python合法变量名的是

(A) 2nd table

(B) Eval

(D) VAL

答案：选 a

数字不能做变量名开头

58.关于变量名的定义，不合法的选项是

(A) y-1

(B) Temp00

(D) str_x

答案：选 a

变量名没有减号，只有下划线。

59.函数名称定义错误的选项是

(A) fun*1()

(B) _func()

(D) max()

答案：选 a

函数名也是一种变量名，符号也是只能带下划线，不能带星号

60.以下不是Python保留字的是

(A) in

(B) none

(D) except

答案：选 b

None的首字n要大写

61.以下代码的输出结果是

x=2+9*((3*12)-8)//10

print(x)

(A) 28.2

(B) 27

(D) 26

答案：选 b

2+928//10=2+252//10=2+25=27

62.Python的运算符中**的作用是

(A)非法符号

(B)操作数取平方

(C)乘法运算

(D)幂运算

答案：选 d

**是幂运算。

63.表达式eval( 'print(1+2)')的结果是

(A)'print(1+2)'

(B)3

(D) 1+2

答案：选 b

eval去掉两边的引号

64.以下代码的执行结果是

a='100'

print(eval (a+"1+2")) .

(A)103

(B) 1003

(C)执行出错

(D) 100+1+2

答案：选 b

'100'+"1+2"，这里的加好表示字符串直接拼接

即"100"+"3"，结果为1003

65.将下列表达数作为eval()函数的参数，执行结果错误的选项是

(A) "print()"

(B) "input()"

(C)"1+2"

(D) 1+2

答案：选 d

eval()函数是去掉两边的引号，如果没有引号可以去，会报错。

66.以下语句的执行结果是

ls = [x2 for x in range(5)]

print(ls)

(A) [2，4，6，8，10]

(B) [1，4，9，16，25]

(D) [0，1，4，9, 16]

答案：选 d

range(5)即x=0、1、2、3、4

x2即x的平方

67.表达式str(10/2) 的结果是

(A) ValueError

(B)'5.0'

(C)'5'

(D)'10/2'

答案：选 b

Python的除法结果肯定是带小数的，即肯定是浮点数，要保证一定精度。

str( )函能将int类型、float类型的数据转换成字符串类型。

68.可用于判断变量a的数据类型的选项是

(A) eval(a)

(B) int(a)

(D) type(a)

答案：选 d

type()函数用来判断变量的数据类型。

69.关于类型转换的描述，错误的选项是

(A) int(1+2j)不能将复数1+2j转换为整数类型，执行出错

(B) int('1.23')能将字符串转换为整数

(D) int(1. 23)能将浮点数1.23转换为整数

答案：选 b

int(100/3)结果是33，不带引号是数字型，100/3=33.3，浮点数强制转换为整型，结果33

int('100/3')结果ValueError，带引号的是字符型，是浮点数不是整型，报错

复数1+2j不能用int()强制转换

70.如果Python程序执行时产生了"unexpected indent" 错误，其原因可能是

(A)代码缩进不正确

(B)代码变量未赋初值

(C)代码进入了死循环状态

(D)代码使用了错误的保留字

答案：选 a

Indent就是缩进的意思。

71.关于Python赋值语句的描述，错误的选项是

(A)使用符号"="表达赋值关系

(B) 赋值语句要求赋值两侧的数据类型一致

(D) a, b = b，a可以交换a和b的值

答案：选 b

Python语言很牛逼，不需要赋值语句的两侧数据类型一致

72.关于变量名称的定义，错误的选项是

A、false

B、And

C、pass

D、a123

答案 : C

pass是关键字，不能做变量名

73.关于input()函数的描述，错误的选项是

A、用户可以输入多行信息，并将被当作一个字符串处理

B、input()参数用于提示用户，不影响用户输入的内容

C、input()参数只能是字符串类型

D、用户输入的信息全部被当作一个字符串处理

答案 : A

input()函数获取用户输入的信息，并将信息组成一个字符串处理，input()函数含有参数，用于提示用户输入，当用户输入信息时，使用回车也就是想换一行时，会停止输入结束input()函数。

74.关于字符串类型转换的描述，错误的选项是

A、str(123)的结果是'123'

B、str(1+2j)的结果是' (1+2j)'

C、str(1. 23)的结果是'1.23'

D、str(1+2)对表达式1+2进行字符串转换，结果是'1+2'

答案 : D

str()函数是将参数转化为字符串，当参数是表达式的时候会先计算出结果，再进行转换, str(1+2)结果是'3'

75、关于Python语言特点的描述，错误的选项是

A、同一个Pthon程序可以在不同的操作系统上执行

B、Python语言在大数据和人工智能领域的应用很广泛

C、Python是一种脚本语言，经过编译后可多次执行

D、Python的计算生态非常丰富

答案 : C

Python是脚本，经过解释；

C和c++是静态，经过编译

76、关于Python语言注释的描述，错误的选项是

A、注释语句不能够被执行

B、Python可以用井号#注释一行语句

C、Python可以使用缩进来表示注释

D、Python可以用一对三引号'注释多行语句

答案 : C

Python语言中可以使用井号(#) 或者三引号('''或""") 来注释语句，其中井号常用于单行，三引号常用于多行。注释语句是对代码进行的解释说明，不被解释器解释执行。

缩进是表示结果和所属关系的。

77、以下赋值语句，错误的选项是

A、b+= 1

B、s=s. replace(':，")

C、a,b=b，C

D、x==0

答案 : D

两个等于号不是赋值语句，是用于判断的

等于运算符是比较运算符的一种，用于判断左右两边的表达式是否相等的

78、表达式'980'>'1000'的结果是

A、0

B、1

C、True

D、False

答案 : C

字符串比较大小是按照对应索引位置上的字符比较大小，

对于字符来说'0'<. ... <'9'<A<...<'Z'<'a'...<'z'

题中索引为0位置的字符'9'>'1'。

79. 表达式 trype(45) 的结果是

A、<class 'int'>

B、<class, str'>

C、<class "float'>

D、None

答案 : A

45是int型

80.关于Python语言发展的描述，最次要的因素是

A、各领域应用广泛，通用性强

B、语法简洁、精炼，语言设计质量高

C、语言开源开放，能够整合C语言代码

D、解释器采用Unicode编码，支持中文处理

答案 : D

支持中文肯定不能算是python发展的重要因素啊

81.不是Python保留字的选项是

A、finally

B、define

C、break

D、await

答案 : B

define不是保留字，def是保留字

保留字，也称关键字，是指被编程语言内部定义并保留使用的标识符。

Python 3.x版本中有35个保留字，分别为: and、as、assert、async、await、break、class、continue、def、del、elif、else、except、False、finally、for、from、global、if、import、in、is、lambda、None、nonlocal、not、or、pass、raise、return、True、try、while、with、yield

控制共79题带答案和解析

1.以下保留字不属于分支或循环逻辑的是

A elif

B in

C for

D while

答案：选 b

属于分支逻辑的保留字有if、else、elif；

属于循环逻辑的保留字有break、continue、for、while。

2.在Python语言中，使用for...in...方式形成的循环不能遍历的类型是

A字典

B列表

C浮点数

D字符串

答案：选 c

列表、字典和字符串类型的元素是有限的，浮点数的个数是无限的。

3.以下关于Python语言中try语句的描述中，错误是

A一个try代码块可以对应多个处理异常的except代码块

B当执行try代码块触发异常后，会执行except后面的语句

C try用来捕捉执行代码发生的异常，处理异常后能够回到异常处继续执行

D try代码块不触发异常时，不会执行except后面的语句

答案：选 c

基本的语法格式如下：

try:

<语句块1>

except:

<语句块2>

语句块1是正常执行的程序内容，当执行这个语句块发生异常时，则执行except保留字后面的语句块2。并不是回到异常处继续执行

网络解释：

try--except语句：用于捕获程序在执行时遇到的异常、报错的情况。

4.Python语言中用来表示代码块所属关系的语法是

A缩进

B括号

C花括号

D冒号

答案：选 a

缩进是指每行语句开始前的空白区域，用来表示Python程序间的包含和层次关系。一般代码不需要缩进，顶行编写且不留空白。当表示分支、循环、函数、类等程序含义时，在if、while、for、def、class等保留字所在完整语句后通过英文冒号（:）结尾并在之后进行缩进，表明后续代码与紧邻无缩进语句的所属关系。

5.以下描述错误的是

A编程语言中的异常和错误是完全相同的概念

B当Python脚本程以下关于Python语言中try语句的描述中，错误是序发生了异常，如果不处理，运行结果不可预测

C try-except可以在函数、循环体中使用

D Python通过try、except等保留字提供异常处理功能

答案：选 a

异常和错误是不同的概念，异常仅指程序运行层面的错误，而错误范围更广泛，还包括程序的逻辑错误等。

6.以下关于Python循环结构的描述中，错误的是

A continue只结束本次循环

B遍历循环中的遍历结构可以是字符串、文件、组合数据类型和range( )函数等

C Python通过for、while等保留字构建循环结构

D break用来结束当前当次语句，但不跳出当前的循环体

答案：选 d

break用来跳出最内层for或while循环，脱离该循环后程序从循环后的代码继续执行。

continue只结束本次循环；

break用来跳出当前的循环体。

7.以下构成Python循环结构的方法中，正确的是

A if

B loop

C while

D do... for

答案：选 c

Python语言的循环结构包括两种：遍历循环和无限循环。遍历循环使用保留字for，无限循环使用保留字while。

Loop语句就是循环语句的意思

8.以下代码绘制的图形是

inmport turtle as t

for i in range(1, 5)：

t. fd(50)

t.1eft (90)

A五边形

B正方形

C三角形

D五角星

答案：选 b

t.fd(50)表示沿着当前方向前进指定距离，t.left(90)表示向左旋转90度。range(start, stop[, step])表示计数从start开始，到stop结束，但不包括stop，步长默认为1，则i的取值为1、2、3、4，所以绘制的图形是正方形。

旋转90度，旋转4次，不就是正方形嘛

9.以下关于Python语言的描述中，正确的是

A条件11<=22<33是合法的，输出True .

B条件11<=22<33是合法的，输出False

C条件11<=22<33是不合法的

D条件11<=22<33是不合法的，抛出异常

答案：选 a

分支结构中的判断条件可以使用任何能够产生True或False的语句或函数。形成判断条件最常见的方式是采用关系操作符。11<=22<33是合法的条件，输出为True。

10.以下代码的输出结果是

for i in range(1, 6):

if i % 4 == 0：

break

else：

print( i,end =",")

A 1,2,3, 5,

B 1,2,3, 4,

C 1,2, 3,

D 1,2,3,5, 6

答案：选 c

range(start, stop[, step])表示计数从start开始，到stop结束，但不包括stop，步长默认为1，则i的取值为1、2、3、4、5。根据程序可知，当i不能被4整除时，执行输出语句；当i能被4整除时，跳出for循环，则输出结果为"1,2,3,"。

break是直接结束当前循环了，4符合if条件，整个循环直接break了

如果是continue的话应该选A，4跳过了，结束本次循环，继续到5。

11.以下关于Python分支的描述中，错误的是

A Python分支结构使用保留字if、elif和else来实现，每个if后面必须有elif或else

B if-else结构是可以嵌套的

C if语句会判断if后面的逻辑表达式，当表达式为真时，执行if后续的语句块

D 缩进是Python分支语句的语法部分，缩进不正确会影响分支功能

答案：选 a

Python的单分支结构使用if保留字对条件进行判断；二分支结构使用if-else保留字对条件进行判断；多分支结构使用if-elif-else保留字对多个相关条件进行判断，并根据不同条件的结果按照顺序选择执行路径。其中，else子句是可选的。

12.列表变量ls共包含10个元素，ls索引的取值范围是

A -1到-9(含)的整数

B 0到10(含) 的整数

C 1到10(含)的整数

D 0到9(含)的整数

答案：选 d

列表的索引采用正向递增序号或反向递减序号。

正向递增序号从0开始，即ls索引的取值范围是0到9(含)的整数；

反向递减符号从-1开始，即ls索引的取值范围是-1到-10(含)的整数。

ls索引是ls[9]，即0到9，共10个元素。类似c语言的数组。

列表的索引与切片总结：

列表的索引与字符串的索引类似，都分为正向与反向索引，如图所示。

列表中每个元素都对应两个下标，例如索引列表中元素5，通过两种方式指定：

list1[4]

list1[-4 ]

列表的切片与字符串的切片类似，列表的切片可以从列表中取得多个元素并组成新列表。

演示列表的切片，切片左闭右开：

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

print(list1[2: 6])

print(list1[2:6:2] )

print(list1[:6])

print(listl [2:])

print(list1[-6:-2])

print(list1[-6:-2:2])

print(list1[: :-2])

13.键盘输入数字5，以下代码的输出结果是______。

n = eval(input("请输入一个整数: "))

s = 0

if n>=5:

n -= 1

s = 4

if n<5:

n -= 1

s = 3

print(s)

答案： 3

键盘输入数字5，则n的值为5，s的值为0。

此时n>=5条件成立，n减1为4，s被赋值为4。

此时n<5条件成立，n减1为3，s被赋值为3。

程序结束，输出s的值为3。

这是两个if语句，是按顺序执行的，两个if都要执行的，不是if else语句，看清楚！

14.关于Python循环结构的描述中，错误的是_

A while循环使用break保留字能够跳出所在层循环体

B while循环可以使用保留字break和continue

C while循环也叫遍历循环，用来遍历序列类型中元素，默认提取每个元素并执行一次循环体

D while循环使用pass语句，则什么事也不做，只是空的占位语句

答案：选 c

Python语言的循环结构包括两种：遍历循环和无限循环。

while循环是无限循环，for循环是遍历循环

break、continue、pass语句总结：

break语句可以跳出for和while的循环体。

continue语句用来跳过当前循环的剩余语句，然后继续进行下一轮循环。

pass语句在语句中用作占位符，不做任何事情，是一个空操作。假设你有一个函数，还没有编写代码，Python认为是一个错误。添加使用pass语句，忽略并继续执行，而不会给出任何错误。

15.键盘输入数字5，以下代码的输出结果是______。

try:

n = input("请输入一个整数: ")

def pow2(n):

return nn

except:

print("程序执行错误")

A程序没有任何输出

B 25

C出程序执行错误.

D 5

答案：选 c

input()函数从控制台获得用户的一行输入，无论用户输入什么内容，input()函数都以字符串类型返回结果。

所以变量n是字符串类型，计算n的平方时产生异常，执行except后的语句块，输出"程序执行错误"。

def pow2(n):

return nn

这一段代码根本没有执行到，只是定义了个函数，函数里面根本没有print，下面直接print

16.以下的描述中，不属于Python语言控制结构的是

A循环结构

B程序异常

C跳转结构

D顺序结构

答案：选 c

顺序结构、分支结构和循环结构是Python语言中3种最基本的控制结构。

异常处理以程序异常为判断条件，根据代码执行的正确性进行程序逻辑选择，是分支结构的一种扩展。跳转结构（如 goto 语句）不属于Python语言控制结构。

17.以下关于分支结构的描述中，错误的是

A 二分支结构有一种紧凑形式，使用保留字if和elif实现

B if语句中条件部分可以使用任何能够产生True和False的语句和函数

C if语句中语句块执行与否依赖于条件判断

D 多分支结构用于设置多个判断条件以及对应的多条执行路径

答案：选 a

二分支结构使用if-else保留字对条件进行判断，二分支结构没有elif。

多分支结构使用if-elif-else保留字对多个相关条件进行判断。

18.以下代码的输出结果是______。

while True:

guess =eval(input())

if guess == 0x452//2:

break

print(guess)

A "0x452//2"

B break

C 0x452

D 553

答案：选 d

运算符//表示计算整数商。

当guess == 0x452//2条件成立时，跳出while循环，输出guess的值。

0x452是16进制数，转换成十进制为41616+516+21=1106，则0x452//2的值为553

19.以下代码的输出结果是______。

for s in "testatest":

if s=="a" or s=='e':

continue

print(s, end=' ')

A tsttst

B testatest

C testtest

D tstatst

答案：选 a

continue用来结束当前当次循环，即跳出循环体中下面尚未执行的语句，但不跳出当前循环。

由代码可知，当s=="a"或s=='e'条件成立时，跳出当前当次循环，不输出s的值，则最后的输出结果为tsttst。

20.以下关于分支和循环结构的描述中，错误的是

A 所有的for分支都可以用while循环改写

B While循环只能用来实现无限循环

C 可以终止一个循环的保留字是break

D continue 可以停止后续代码的执行，从循环的开头重新执行

答案：选 b

while循环也可以用来实现遍历循环。

21.表达式divmod(40,3)的结果是______。

答案： (13,1)

divmod(x,y)函数同时返回两个值，分别是x和y的整数商和除法余数，输出为二元组形式（也称为元组类型）。

22.以下关于字符串类型的操作的描述，正确的是

A想获取字符串str的长度，用字符串处理函数len(str)

B设x='aaa'，则执行x/3的结果是'a'

C想把一个字符串str所有的字符都大写，用upper (str)

D str. isnumeric( )方法把字符串str中数字字符变成数字

答案：选 a

x='aaa'，x/3的结果是'a'，不对，这会直接报错，因为字符串不支持除法运算。

x='a' ，x3的结果是'aaa'

len(x)：返回字符串x的长度，也可返回其他组合数据类型的元素个数。

Isnumeric()函数：判断对象是否为数字，返回布尔值。

upper()函数：将字符串中的小写字母转为大写字母。

str.upper()返回值被转换为大写字母的字符串，不是upper (str)

23.设str1='*@python@*'，语句print(str1[2:].strip('@'))的执行结果是______。

A @python@

B python*

C python@*

D python

答案：选 c

str1[2:]表示截取字符串正向第3个字符p到字符串末尾之间的字符，即'python@*'。

str.strip(chars)表示从字符串str中去掉在其左侧和右侧chars中列出的字符。

因为得到的子字符串'python@* '最左和最右都没有字符@，所以最后的结果依然为'python@*'。

24.执行以下程序，输出结果是______。

y='中文'

x='中文字'

print(x>y)

A False

B True

C False or False

D None

答案：选 b

字符串按位比较，x>y是成立的，所以输出True。

25.以下关于"for <循环变量> in <循环结构>"的描述，错误的是______。

A 这个循环体语句中不能有break语句，会影响循环次数

B <循环结构>采用[1,2,3]和['1','2' ,'3' ]的时候，循环的次数是一样的

C 使用range(a, b)函数指定for循环的循环变量取值是从a到b-1

D for i in range(1, 10, 2)表示循环5次，i的值是从1到9的奇数

答案：选 a

break是辅助循环控制的保留字，用来跳出最内层for或while循环，脱离该循环后程序从循环后的代码继续执行。

for语句的循环执行次数是根据<循环结构>中元素的个数确定的，[1,2,3]和['1','2',3]均有三个元素，因此循环次数是一样的.

循环体中的break语句的确能影响到循环次数，但是不代表循环体中不能有break语句.

26.x=2.6，表达式round(x)的结果是______。

答案： 3

round(x)：返回对x四舍五入的整数值。

27.变量tstr='kip520'，表达式eval(tstr[3:-1])的结果是______。

A 52

B 520

C p520

D p52

答案：选 a

tstr[3:-1]表示截取字符串正向第4个字符5到字符串末尾（不包括末尾字符）之间的字符，即'52'。

28.设str1='python'，语句print(str1.center(10, *))的执行结果是______。

A python***

B python

C **python

D SyntaxError

答案：选 d

str.center(width,fillchar)：返回长度为width的字符串

str位于新字符串中心位置，两侧新增字符采用fillchar填充。（fillchar填充字符）

正确的语句是print(str1.center(10,''))，运行后的结果为python。

题面语句运行会出错

*星号要带引号。

29.执行以下程序，输出结果是______。

y=['',' ']

print(all(y),any(y))

A False True

B True False

C False False

D True True

答案：选 a

all(x)：组合类型变量x中所有元素都为真时返回True，否则返回False；

若x为空，返回True。

any(x)：组合类型变量x中任一元素都为真时返回True，否则返回False；

若x为空，返回True。

y中第一个元素为一个空格，第二个元素为空，即null，所以第一个元素为真，第二个元素为假，all(y)输出False，any(y)输出True。

网络解释：

any(x)，只要x中有一个不为空，0，false就返回True，否则返回False。

all函数：判断tuple或者list是否全不为空，0，False。如果全不为空，则返回True；否则返回False。

空tuple和空list的返回值是True

布尔值里引号中没有带空格为False，有空格为True

30.ls=['1','2','3']，以下关于循环结构的描述，错误的是______。

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

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

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

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

答案：选 c

for i in range(len(ls))中，i的值是数字类型，for i in ls中i是列表中的元素，是字符串类型。这两个i的值不同。

31.以下不是函数作用的选项是

A 提高代码执行速度

B 增强代码可读性

C 复用相同功能代码

D 降低编程复杂度

答案：选 a

使用函数主要有两个目的：降低编程难度和增加代码复用。代码复用降低了代码行数和代码维护难度，增强代码可读性

32.关于Python全局变量和局部变量，以下选项描述错误的是

A 函数内部使用各种全局变量，都要用globle语句声明

B 程序中的变量包含两类：全局变量和局部变量

C 全局变量在源文件顶层，一般没有缩进

D 不是在程序最开头定义的全局变量，不是全过程均有效

答案：选 a

全局变量在函数内部使用时，需要提前使用保留字global声明

只是使用不用声明，声明可以提前声明，声明一次就好了。

33.关于函数定义,以下形式错误的是__________。

A def foo(a,b)

B def foo(a,b=10)

C def foo(a,*b)

D def foo(*a,b)

答案：选 d

如果一个函数需要以多种形式来接收实参，定义时一般把位置参数放在最前面，然后是默认参数，接下来是一个星号的可变长度参数，最后是两个星号的可变长度参数。

例：def foo(x,*args,**kwargs):

a指的是可变长度参数，意思就是说可以有无数个变量传进来，所以a要放后面

34.字典d={'Python':123,'C':123,'C++':123},len(d)的结果是______。

答案： 3

len(d)：字典d的元素个数（长度）。字典中每一个元素是一个键值对，共有3个键值对，所以结果为3。

35.以下不是Python组合数据类型的是

A 字符串类型

B 数组类型

C 元组类型

D 列表类型

答案：选 b

常见的组合数据类型有：集合类型、序列类型和映射类型。

序列类型的典型代表是字符串类型和列表类型，

映射类型的典型代表是字典类型。

集合类型是一个元素集合，元素之间无序，相同元素在集合中唯一存在。

36.Python为源文件指定的默认字符编码是

A UTF-8

B GB2312

C GBK

D ASCII

答案：选 a

文件包括文本文件和二进制文件两种类型。文本文件一般由单一特定编码的字符组成，如UTF-8编码，内容容易统一展示和阅读。二进制文件直接由比特0和比特1组成，没有统一的字符编码。

《信息交换用汉字编码字符集》GB2312编码适用于汉字处理、汉字通信等系统之间的信息交换，通行于中国大陆；

《汉字编码扩展规范》（GBK）包括全部中、日、韩（CJK）汉字，共计20902字

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

x=3.1415926

print(round(x,2),round(x))

A 2,2

B 3,3. 14

C 3.14,3

D 6.283

答案：选 c

round(x,d)：对x四舍五入，保留d位小数，无参数d则返回四舍五入的整数值。

38.函数chr (x)的作用是

A 返回数字x作为Unicode编码对应的字符

B 返回字符x对应的Unicode值

C 返回数字x的十六进制字符串形式

D 返回字符串x中每个字符对应的Unicode编码值

答案：选 a

chr(x)：返回Unicode编码x对应的单字符。

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

A无限循环可以与break、continue和else一起使用无限循环

B无限循环通过while保留字构建

C无限循环在判断条件满足时一直执行循环操作

D需要提前确定循环次数

答案：选 d

Python通过保留字while实现无限循环，不需要提前确定循环次数。

循环结构有两个辅助循环控制的保留字：break和continue。

无限循环也有一种使用保留字else的扩展模式，使用方式如下：

while <条件>：

<语句块1>

else：

<语句块2>

40.以下不是Python组合数据类型的是

A复数类型

B字符串类型

C集合类型

D字典类型

答案：选 a

常见的组合数据类型有集合类型、序列类型和映射类型。

序列类型的典型代表是字符串类型和列表类型，映射类型的典型代表是字典类型。

集合类型是一个元素集合，元素之间无序，相同元素在集合中唯一存在。

41.表达式max({2:10,8:4,5:9})的结果是______。

答案： 8

字典由键值对组成，max（D）输出的是最大的键。

max用于字典只则判断键的大小，输出的是最大的键。

42.以下语句的执行结果是______。

tstr = '12345678'

print(tstr[1👎2])

A 24

B 1357

C 246

D 2468

答案：选 c

列表切片：<列表或列表变量>[N:M:K]

切片获取列表类型从N到M（不包含M）的以K为步长所对应的元素组成的列表。

题中N=1，M=-1，K=2，而列表下标由0开始，表示从列表的第2个元素开始，到最后一个元素为止（不包括最后一个元素），步长为2，取出对应的元素，这里取出的是246。

43.以下语句的执行结果是______。

str1='||北京大学||'

print(str1.strip('|').replace('北京','南京'))

A南京大学||

B南京大学

C |南京大学||

D |南京大学

答案：选 b

str.strip(chars)表示从字符串str中去掉在其左侧和右侧chars中列出的字符。

str.replace(old,new)：返回字符串中的old（旧字符串）替换成new（新字符串）后生成的字符串。

43.（改）以下语句的执行结果是______。

str1='||北京大学|| '#最后一个竖线后面有一个空格

print(str1.strip('|').replace('北京','南京'))

A南京大学||

B南京大学

C |南京大学||

D |南京大学

答案：选 a

最后的两个竖线去不掉了，因为最右边的是空格

44.以下语句的执行结果是______。

y1='' ，y2=' 'print(y1.isspace(),y2.isspace())

A True True

B False True

C False False .

D True False

答案：选 b

isspace()方法检测字符串是否只由空格组成。

如果字符串中只包含空格，则返回 True，否则返回False。

y1是空字符串，不包含空格，返回False；y2只包含一个空格，返回True。

45.以下关于控制结构的描述，错误的是

A Python的单分支结构里，包含else语句

B Python的多分支结构，指的是既包含else语句块，也包含elif语句块

C使用range(1, 10)函数，指定语句块的循环次数是9次

D Python的for循环结构是对遍历结构各元素进行处理

答案：选 a

Python的单分支结构使用if保留字对条件进行判断；

二分支结构使用if-else保留字对条件进行判断；

多分支结构使用if-elif-else保留字对多个相关条件进行判断。

46.表达式min([3,5,1,7,9])的结果是______。

答案： 1

min()用来求出列表中的最小值，这里的最小值为1。

47.下面语句的执行结果是______。

tstr = 'Baidu Translation is an online translation service'

print(len(tstr.split('a')))

答案： 7

split()通过指定分隔符对字符串进行切片，返回一个列表。

字符串中共有6个a，则该字符串被切割成7部分，所以列表元素个数为7，使用len()求出列表长度为7。

48.变量sstr ='天使的翅膀带着我在尘世飞翔' ，执行下列选项，不能输出'翅膀'的是

A print (sstr[3::2])

B print (sstr[3:-8])

C print (sstr [3:5])

D print(sstr[-10:-8])

答案：选 a

列表切片：<列表或列表变量>[N:M:K]

切片获取列表类型从N到M（不包含M）的以K为步长所对应的元素组成的列表。索引序列使用正向递增序号或反向递减序号。正向从0开始，代表第1个元素，反向从-1开始，代表最后一个元素。

sstr[3::2]中N=3，M省略，K=2，表示从正向第4个字符开始，以步长为2获取字符，最后得到"翅带我尘飞"。

sstr[3:-8]中K省略，表示获取从正向第4个字符到反向第8个字符（不包括第8个），得到"翅膀"。

依次类推，sstr[3:5]和sstr[-10:-8]也能输出"翅膀"。

49.若使以下程序执行结果是144，空格处该填写的代码是______。

x = 'bee'

y = ''

for i in x:

y+=str(______)

print(y)

A ord(i) - ord('a')

B i-' a'

C chr(i)-chr('a' )

D ord(x)-ord(' a' )

答案：选 a

chr(x)返回Unicode编码x对应的单字符；

ord(x)返回单字符x表示的Unicode编码。

空字符的ASCII码值为0，字符a的ASCII码值为97。

第1次循环，i为'b'，ord(i) - ord('a')的值为1，str()进行类型转换，输出字符'1'；

第2次循环和第3次循环都输出字符'4'，所以最后的执行结果为144。

50.以下关于循环结构的描述，错误的是_

A当try中有循环结构时，循环结构中出错，会跳出循环并进入except

B for或者while与else搭配使用的时候，循环非正常结束时会执行else

C break语句执行时，会跳出break所在的第一层循环

D continue语句执行时，会跳回continue所在的循环开头

答案：选 b

B选项中，循环正常结束时会执行else。

51.在Python语言中，整数999的二进制、八进制、十六进制表达形式分别是

(A) b1111100111，o1747，x3e7

(B) B1111100111, 01747，X3e7

(D) 0b1111100111, 0o1747，0x3e7

答案：选 d

二进制0b、八进制0o、十六进制0x

52.Python使用 for和in的组合表达遍历循环，不能被遍历的数据类型是

(A)字符串类型

(B)字典类型

(C)复数类型

(D)元组类型

答案：选 c

复数类型是数据类型，不好被遍历

在Python中，遍历循环中的数据为多元素类型，如字符串、列表、元组、字典、集合等。

53.以下关于控制结构的描述，错误的是

(A) 在for结构中使用continue，会开始遍历下一个元素

(B) break也可用于跳出try-except控制块

(D) Python的多分支结构里，可以包含多个elif语句

答案：选 b

break、continue只适用于循环结构，try-except控制块是异常处理

54.关于Python字符串的描述，错误的选项是

(A)字符串可以赋值给变量，也可以作为单独一行语句

(B)可以通过索引方式访问字符串中的某个字符

(C)可以使用lenstr ()获得字符串的长度

(D)可以通过在引号前增加转义符\输出带有引号的字符串

答案：选 c

使用len (str)获得字符串的长度

54.关于Python二分支精简结构的表示，正确的选项是

(A)表达式1 if条件else表达式2

(B)表达式1 if条件:表达式2 else

(C)表达式1 if表达式2 else条件

(D)条件if表达式1 else表达式2

答案：选 a

二分支精简结构：表达式1 if条件else表达式2

55.关于加、减、乘、除、乘方五种数字运算的描述，错误的选项是

(A)整数运算的结果可能是浮点数

(B)整数运算的结果可能是复数

(C)复数类型运算的结果可能是整数

(D)浮点数运算的结果仍然是浮点数

答案：选 c

复数类型运算不可能算出是整数，2+0j也还是复数型

整数运算的结果可能是复数，-1的开根号等于1j

56.关于Python分支结构的描述，错误的选项是

(A)单分支结构可以用if语句表示

(B)多分支结构可以用switch语句表示

(C)多分支结构可以用if elif else语句表示

(D)二分支结构可以用if else语句表示

答案：选 b

多分支结构可以用if elif else语句表示。

在Python中，没有内置的Switch语句，可以使用不同去方法模拟Switch语句的功能

57.关于Python字符串的描述，错误的选项是

(A) 字符串属于序列类型，可以通过字符串切片的方式访问部分字符串

(B)可以通过下标索引方式访问字符串中的单个字符

(C)字符串不可以转换为整数类型

(D)可以通过字符串的sp1it()方法生成列表

答案：选 c

字符串可以转换为整数类型，eval('1')，就是把字符串转换为整数

58. 以下程序执行结果是

import time

type(time. ctime())

(A) True

(B) <class.'str' >

(D) <class 'float'>

答案：选 b

时间输出时间的类型，肯定是字符串

59.表达式'Python编程是方向'[2:-2]的结果是

(A) 'ython编程是'

(B) 'thon编程是'

(C)'thon编程是方'

(D)'ython编程是方'

答案：选 b

2是't'包括，-2是'是'，不包括

60.表达式min( {3:7, 10:5, 1:6} )的结果是

(A) {1:6}

(B) 5

(D)1

答案：选 d

Min判断字典，键最小的是1

61.以下语句执行结果是:

s ='HelloWorld'

print(s[5::-2])

(A) loo

(B) Wle

(D) olH

答案：选 b

5::-2\]，从5开始，步长是负数，从右向左， 62.以下语句执行结果是 s='北京,上海,广州,深圳,' print(s.strip(',').replace(',',':')) (A)北京:上海:广州:深圳 (B)北京:上海:广州:深圳: (C)北京 上海 广州 深圳 (D)北京:上海:广州:深圳， **答案：选** **a** s.strip(',')先去掉左右两边的逗号，replace(',',':')再把所以逗号换成冒号 63.以下程序的输出结果是 import string y1='a' y2 ='asdf' print(y1 in string. printable,y2 in string. printable) (A) False False (B) True True (C) False True (D) True False **答案：选** **d** 做这个题要理解这个 string.printable 是一个包含所有可打印ASCII字符的字符串 这个的意思就是 这些字符的ASCII码值在32到126的范围内。 64.以下代码的执行结果是 a = 3.141593 b="" print(" {0: (2)\> (1),}\\n {0: (2)\^{1},}\\n {0: (2)\<{1},}".format(a, 20, b)) (A) 3.141593 3. 141593 3.141593 (B) 3. 14159 3.141593 3.14159\* (C) 3. 14153\*\*\*\*\*\*\*\*\*\*\* \*\*\*\*\*\*\*3. 141593 3.141593 (D) 3. 141593 3.15 3.14159 **答案：选** **a** {0: (2)\>(1),}靠右 {0: (2)\^{1},}居中 {0: (2)\<{1},}靠左 65.以下代码的执行结果是 a=75 if a\> 60: print("Should Work Hard! ") elif a\>70: print("Good") else: print("Excellent") (A)执行出错 (B)Good (C)Excellent (D)Should Work Hard! **答案：选** **d** If语句按顺序判断，第一个符合就直接输出了，后面的平行语句就不判断 if分支语句，自上而下执行，只要有一个条件成立便执行对应语句块，后续分支无需继续判断。 66.以下代码的执行结果是 a =2.71828182459 if isinstance(a, int): print("{} is int. ". format (round(a, 2))) else: print("{} is not int. ". format (round(a, 2))) (A)执行错误 (B) 2.72 is int. (C) 2.72 is not int. (D) 2.71828182459 is not int. **答案：选** **c** 判断a是不是int，a明显不是，round(a, 2)四舍五入两位小数 67.以下代码的执行结果是 a=eval("12+3") if type(a) == type(123): print("整数类型") elif type(a) == type("123"): print("字符串类型") else: print("其他类型") (A) 整数类型 (B) 代码执行错误提示 (C) 字符串类型 (D) 其他类型 **答案：选** **a** eval("12+3")去掉引号，12+3=15,15是整数类型 type(a)结果是整数，type(123) 结果也是整数 68.表达式min(\[3,2,1\])的结果是 A、3 B、\[1

C、[3,2,1]

D、1

答案 : D

min()函数是返回参数中的最小值，列表[3,2, 1]的最小值是1，所以选择D选项。

69.以下代码的执行结果是( )

x=4+3j

y=-4-3j

print(x + y)

A、0j

B、0

C、<class 'complex'>

D、无输出

答案 : A

在Python中复数的加法运算与数学上的加法一致，实部与实部相加，虚部与虚部相加，最后得到0j,

注意当虚部为0时，j依然不能省略。本题选择A选项。

70.x=2.6+4j,表达式x.real+x.imag的结果是()

A、2.6

B、6.6

C、4.0

D、TypeError

答案 : B

复数的rea和imag两种属性，其中real可以得到复数的实数部分，imag可以得到复数的虚数部分。两种得到的均为浮点数，所以得到的结果为6.6。

71.量s= 'shehuizhili,表达式s[-5:-1]的结果是( )

A、zhil

B、zhili

C、izhi

D、izhil

答案 : A

s[-5:-1]左闭右开zhil

72.执行结果为[23, 56]的选项是()

A、print(eval[23,56])

B、print(type(eva([23,56]))

C、print(23,56)

D、print(list([23,56]))

答案 : D

在多个选项中，分别使用了print()函数、eval()函数、 type()函数和list函数。其中print()函数是输出函数，各选项中使用均正确;

eval()函数参数必须是字符串类型，所以A选项错误;

type()函数返回的数据是参数的数据类型，并不是eval()函数处理过后的[23, 56]

list()函数转化字符串的时候，会将每一个字符都化为列表的一个元素,得到的数据为[['2', '3', '5', '6', ]]

这里的 list([23,56]) 实际上创建了一个包含两个元素的列表，因此输出为 [23, 56]

73.关于Python分支结构的描述，正确的选项是( )

A、

if条件:

语句块

B、

if条件

语句块

C、

if条件

语句块

else条件

if条件:

语句块

else

答案 : A

分支结构完整形式如下：

if条件:

语句块

elif条件:

语句块

else:

语句块

if和elif的后面都要跟条件，if、elif、else后面都要跟冒号。

B选项中i条件后无冒号，格式错误:

C选项中i条件后无冒号且else有条件，格式错误:

D选项中else后无冒号，格式错误。

所以本题选择A选项。

74.以下代码的执行结果是()

a = '3000'

if a < 2000:

print("少")

elif a < 4000:

print("不多")

else:

print("还行")

A.还行

B.不多

C.少

D.执行出错

答案 : D

但是实际上a值为字符串，不能和数字比较大小，所以程序执行会出现异常。

75.字符串s = "中华人民共和国国庆日是10月1日',使用表达式提取s中的日期'10月1日"，正确的选项是()。

A、s[12:]

B、s[-5:-1]

C、S[-5:] .

D、S[-4:]

答案 : C

此题考查的是字符串的切片C选项，切片得到的结果为'10月1日

76.关于数宇运算符的描述，错误的选项是()

A、运算符%实现取余操作，参与运算的可以是浮点数，结果可能是浮点数

B、运算符/实现除法操作，如果参与运算的都是整数，结果只能是整数

C、运算符实现乘法操作，参与运算的可以是任意数字类型

D、运算符实现幂运算操作，幂数可以是整数

答案 : B

%是取余运算符，当参与运算的数字存在浮点数的时候，结果是浮点数，A选项正确;

/是除法运算符,结果只能是浮点数或者复数，B选项错误;

*是乘法运算符，只要是数字均可参与乘法运算，C选项正确;

**是幂运算，代表数字的多少次方，D选项正确。

77.关于操作字符串变量s的使用方式，错误的选项是()

A、s.len()

B、s.format()

C、s.spli()

D、s.join()

答案 : A

字符串没有len()方法，可以利用len()函数计算字符串的长度; format方法是用来对字符串进行格式化操作; split()方法是用来对字符串进行切割的; join方法是利用字符串拼接其他多元素数据类型。

78.不用于Python循环结构保留字的选项是( )

A、else

B、continue

C、break

D、lambda

答案 : D

Python循环结构中涉及到的保留字有for, while, 还有控制循环的continue, break, 以及循环的扩招模式else。

79.以下代码的执行结果是( )。

a= "123"

if a > "Python":

print("再学Python")

else:

print("初学Python")

A、初学Python

B、再学Python

C、没有输出

D、执行出错

答案 : A

判断字符串'123'>'Python'的布尔值，然后根据布尔值执行对应的分支。字符串比较大小是按照对应索引位置比较，从索引0开始，只要有一索引分出了大小，便得到布尔值，字符串比较大小按照以下规则0'<'9'<'A'<'Z'<'a'<'z'.所以123>'Python'得到False, 执行else分支。本题选择A选项。

函数共95题带答案和解析

1.以下关于函数优点的描述中，错误的是

A函数便于阅读

B函数可以使程序更加模块化

C函数可以减少代码重复

D函数可以表现程序的复杂度

答案：选 d

使用函数主要有两个目的：降低编程难度和增加代码复用。表现程序的复杂度不属于函数的优点。

2.Python中定义函数的关键字是

A def

B define

C function

D defun

答案：选 a

Python语言通过保留字def定义函数。

3.以下关于Python函数的描述中，错误的是

A可以定义函数接受可变数量的参数

B定义函数时，某些参数可以赋予默认值

C函数必须要有返回值

D函数可以同时返回多个结果

答案：选 c

函数可以没有return，此时函数并不返回返回值。

当函数使用return返回多个值时，可以使用一个变量或多个变量来保存结果。

4.以下关于Python函数的描述中，错误的是_

A Python程序需要包含一个主函数且只能包含一个主函数

B如果Python程序包含一个函数main(),这个函数与其它函数地位相同

C Python程序可以不包含main函数

D Python程序的main函数可以改变为其他名称

答案：选 a

Python程序可以不包含main函数。

6.以下代码的输出结果是______。

for s in "PythonNCRE":

if s=="N":

continue

print(s,end="")

A N

B PythonCRE

C Python

D PythonNCRE

答案：选 b

continue用来结束当前当次循环，即跳出循环体中下面尚未执行的语句，但不跳出当前循环。由代码可知，当s=="N"条件成立时，跳出当前当次循环，不输出s的值，则最后的输出结果为PythonCRE。

6.当用户输入5时，下面代码的输出结果是______。

try:

n = input("请输入一个整数:")

def pow2(n):

return n**2

pow2(n)

except:

print("程序执行错误")

答案：程序执行错误

input()函数从控制台获得用户的一行输入，无论用户输入什么内容，input()函数都以字符串类型返回结果。所以变量n是字符串类型，计算n的平方时产生异常，执行except后的语句块，输出"程序执行错误"。

7.以下关于Python语言return语句的描述中，正确的是

A return只能返回一个值

B函数必须有return语句

C函数可以没有return语句

D函数中最多只有一个return语句

答案：选 c

函数中可以有多个return语句。

函数可以没有return，此时函数不返回值。

当函数使用return返回多个值时，可以使用一个变量或多个变量保存结果。

8.以下关于Python全局变量和局部变量的描述中，错误的是_

A局部变量在函数内部创建和使用，函数退出后变量被释放

B全局变量一般指定义在函数之外的变量

C使用g1oba1保留字声明后，变量可以作为全局变量使用.

D当函数退出时，局部变量依然存在，下次函数调用可以继续使用

答案：选 d

局部变量指在函数内部定义的变量，仅在函数内部有效，当函数退出时变量将不再存在。

9.以下代码的输出结果是______。

CList = list(range(5))

print(2 in CList)

答案：选 c

range(start, stop[, step])表示计数从start开始，到stop结束，不包括stop，步长默认为1。

start默认从0开始，range(5)等价于range(0,5)，则CList中的元素取值为0、1、2、3、4。

x in S方法的作用是如果x是S的元素，返回True，否则返回False。

2是CList中的元素，所以输出True。

10.关于以下代码的描述中，错误的是______。

def fact(n):

s = 1

for i in range(1,n+1):

s *= i

return s

A 代码中n是可选参数

B fact (n)函数功能为求n的阶乘

C s是局部变量

D range()函数是Python内置函数

答案：选 a

代码中的n是非可选参数。函数的n没有给默认值所以必须得有

可选参数一般放在非可选参数的后面，即定义函数时，先给出所有非可选参数，然后再分别列出每个可选参数即对应的默认值。

11.以下代码的输出结果是______。

def func(a,b):

a *= b

return a

s = func(5,2)

print(s)

答案： 10

语句a = b，即a=ab，a的值为10，func(5,2)返回值为10，即s的值为10。

12.以下代码的输出结果是______。

ls = ["car","truck"]

def funC(A):

ls.append(A)

return

funC("bus")

print(ls)

答案： ["car","truck", "bus"]

ls.append(x)的作用是在列表ls最后增加一个元素x。输出["car","truck", "bus"]。

13.以下代码的输出结果是______。

t=10.5

def above_zero(t):

return t>0

A没有输出

B True

C 10.5

D False

答案：选 A

代码中只定义了函数above_zero()，未向函数中传递参数，函数不执行，没有输出。

14.以下关于Python语言的描述中，错误的是

A函数中return语句只能放在函数定义的最后面

B定义函数需要使用保留字def

C使用函数最主要的作用之一是复用代码

D Python函数可以定义在分支或循环语句的内部

答案：选 a

return语句用来结束函数并将程序返回到函数被调用的位置继续执行。return语句可以出现在函数中的任何部分，同时将0个、1个或多个函数运算的结果返回给函数被调用处的变量。

15.以下代码的输出结果是______。

def young(age):

if 12 <= age <= 17:

print( "作为一个大学生，你很年轻")

elif age <12:

print( "作为一个大学生，你太年轻了")

elif age <= 28:

print( "作为一个大学生，你要努力学习")

else:

print( "作为一个大学生，你很有毅力")

young(18)

答案：作为一个大学生，你要努力学习

age取值为18时，if 12 <= age <= 17条件不成立，不执行输出语句；elif age <12条件不成立，不执行输出语句；elif age <= 28条件成立，执行输出语句，最后输出：作为一个大学生，你要努力学习。

16.以下代码的输出结果是______。

def fibRate(n):

if n <= 0:

return -1

elif n == 1:

return -1

elif n == 2:

return 1

else:

L = [1, 1]

for i in range(2,n):

L.append(L[-1]+L[-2])

return L[-2]/L[-1]

print(fibRate(5))

答案： 0.6

n=5时，执行else后的语句，i的取值范围为range(2,5)，即2、3、4。

ls.append(x)的作用是在列表ls最后增加一个元素x。

初始状态时，L=[1,1]。

第一次循环，n=2，L[-1]+L[-2]=2，L=[1,1,2]；

第二次循环，n=3，L[-1]+L[-2]=3，L=[1,1,2,3]；

第三次循环，n=4，L[-1]+L[-2]=5，L=[1,1,2,3,5]。

循环结束，返回值L[-2]/L[-1]，即3/5=0.6。

17.以下关于函数返回值的描述中，正确的是_

A Python函数的返回值使用很灵活，可以没有返回值，可以有一个或多个返回值

B函数定义中最多含有一个return语句

C在函数定义中使用return语句时，至少给一个返回值

D函数只能通过print语句和return语句给出运行结果

答案：选 a

函数定义中可以含有多个return语句，可以返回0个、1个或多个函数运算的结果。函数可以没有return，此时函数不返回值。

当函数使用return返回多个值时，这些值形成了一个元组数据类型，由小括号和逗号分隔，如(a,b,c)，可以使用一个变量或多个变量保存结果。

18.以下代码的输出结果是______。

def Hello(famlyName,age):

if age > 50:

print("您好！"+famlyName+"大爷")

elif age > 40:

print("您好！"+famlyName+"叔叔")

elif age > 30:

print("您好！"+famlyName+"大哥")

else:

print("您好！"+"小"+famlyName)

Hello(age=60, famlyName="王")

O函数调用出错

O您好!王叔叔

O您好!王大哥

O您好!王大爷

答案：选 d

Python的多分支结构使用if-elif-else保留字对多个相关条件进行判断，并根据不同条件的结果按照顺序选择执行路径。

题目中代码为变量age赋值60，条件if age > 50成立，输出：您好！王大爷。

19.以下关于Python函数的描述中，错误的是_

A函数是一段可重用的语句组

B每次使用函数需要提供相同的参数作为输入

C函数通过函数名进行调用

D函数是一段具有特定功能的语句组

答案：选 b

每次使用函数可以提供不同参数作为输入，以实现对不同数据的处理。

20.函数中定义了2个参数，且两个参数都指定了默认值，调用函数参数个数最少是_____

答案： 0

函数的参数在定义时可以指定默认值，当函数被调用时，如果没有传入对应的参数值，则使用函数定义时的默认值替代，则调用函数时，参数个数最少是0。

21.以下关于Python函数的描述中，正确的是_

A一个函数中只允许有一条return语句

B Python中，def和return是函数必须使用的保留字

C Python函数定义中没有对参数指定类型，这说明参数在函数中可以当作任意类型使用

D函数eval ()可以用于数值表达式求值，例如eval(" 2*3+1")

答案：选 d

函数eval()的作用是去掉字符串最外侧的引号，并按照Python语句方式执行去掉引号后的字符内容。

22.关于以下代码的描述中，错误的是______。

def func(a,b):

c=a2+b

b=a

return c

a=10

b=100

c=func(a,b)+a

A该函数名称为func

B执行该函数后，变量c的值为200

C执行该函数后，变量b的值为100

D执行该函数后，变量a的值为10

答案：选 b

c = func(a,b)+a = func(10,100)+10 = 102+100+10 = 210

代码后，变量c的值为210，不是200。

23.以下关于Python全局变量和局部变量的描述中，错误的是_

A全局变量在程序执行的全过程有效

B全局变量一般没有缩进

C全局变量不能和局部变量重名

D一个程序中的变量包含两类：全局变量和局部变量

答案：选 c

全局变量和局部变量可以重名。

24.以下的函数定义中，错误的是

A def vfunc(a, b=2):

B def vfunc(a, b):

C def vfunc(a, *b):

D def vfunc(*a, b):

答案：选 d

可选参数一般都放置在非可选参数的后面。

即定义函数时，先给出所有非可选参数，然后再分别列出每个可选参数及对应的默认值。

"def vfunc(a,b):"函数定义错误，参数位置出错。

就是带的要放在后面

25.执行以下程序，输入"fish520"，输出结果是______。

w = input()

for x in w:

if '0'<= x <= '9':

continue

else:

w.replace(x,'')

print(w)

答案： fish520

x in s：如果x是s的子串，返回True，否则返回False。

continue：用来结束当前本次循环，跳出循环体中下面尚未执行的语句，但不跳出当前循环。

str.replace(old,new)：返回字符串str的副本，所有old子串被替换为new。

根据题目，改变的是字符串副本，字符串w本身的内容没有改变，所以最后还是输出fish520。

就是正常replace的用法是，print(str.replace('a','b'))或者str2= str.replace('a','b')

就是replace会返回一个新的字符串，这个字符串不会改变原来str字符串的。

26.执行以下程序，导致输出"输入有误"的输入选项是______。

try:

ls= eval(input())*2

print(ls)

except:

print('输入有误')

A aa

B '12'

C 'aa'

D 12

答案：选 a

eval()函数将去掉字符串最外侧的引号，并按照Python语句方式执行去掉引号后的字符内容，使用方式如下：

<变量> = eval(<字符串>)

变量用来保存对字符串内容进行Python运算的结果。

输入aa时，Python语句将其解释为一个变量，由于之前没有定义过变量aa，因此解释器报错。

输入数字，包括小数和复数，input()解析为字符串，经由eval()去掉字符串引号，将被直接解析为数字保存到变量中。

27.以下关于组合类型的描述，正确的是

O字典的items()函数返回一个键值对，并用元组表述空字典

O可以用set创建集合，用中括号和赋值语句增加新元素

O字典数据类型里可以用列表做键

O可以用大括号来创建

答案：选 d

创建集合直接用{}。

set(x)函数将其他的组合数据类型变成集合类型，返回结果是一个无重复且排序任意的集合。

使用大括号可以创建字典，特殊地，可以创建一个空字典。

d.items()返回字典中的所有键值对信息，返回结果是Python的一种内部数据类型dict_items。

是所有键值对，不是一个键值对。

赋值语句不能增加新元素，用add()增加

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

s = 0

def fun(s,n):

for i in range(n):

s += i

print(fun(s,5))

A None

B 10

C 0

D UnboundLocalError

答案：选 a

s += i即s=s+i

n=5，range（0,5）即i=0、1、2、3、4

i=0，s=s+i=0+0=0

i=1，s=s+i=0+1=1

i=2，s=s+i=1+2=3

i=3，s=s+i=3+3=6

i=4，s=s+i=6+4=10

但是题目有坑，函数fun()无返回值，所以最后输出None。

本题中函数体内没有retum语句，即无返回值，所以默认返回None.

29.以下关于函数的描述，正确的是

A函数一定要有输入参数和返回结果

B使用函数可以增加代码复用，还可以降低维护难度

C在一个程序中，函数的定义可以放在函数调用代码之后

D自己定义的函数名不能与Python内置函数同名

答案：选 b

使用函数主要有两个目的：降低编程难度和增加代码复用。

函数可以在一个程序中多个位置使用，也可以用于多个程序，当需要修改代码时，只需要在函数中修改一次，所有调用位置的功能都更新了，这种代码复用降低了代码行数和代码维护难度。

A选项，函数可以没有返回结果

C选项，python函数的应用一般需要：先定义、后调用。如果函数定义在调用之后，执行将报错

自己定义的函数可以与内置函数同名，当调用此函数时会先调用自己定义的函数；

函数可以没有输入参数和返回结果；

Python 程序是自上而下执行的，函数的定义应放在函数调用之前，否则会报错。

网络解释：

自己定义与Python内置函数重名的函数，优先使用自己的

先定义同名函数，再进行调用，Python调用的是自己定义的，可以理解为函数的作用域重合时的优先级问题。

也可以理解为重名函数以最后定义的为准。

30.以下程序的输出结果是______。

def loc_glo( b = 2, a = 4):

global z

z += 3 * a +5 * b

return z

z = 10

print(z, loc_glo (4,2))

答案： 10 36

loc_glo (4,2)，b=4，a=2

z=z+3a+5b=10+32+54=36，函数返回值36

z为全局变量，所以值不变，最后输出仍为10。

31.以下关于随机运算函数库的描述，错误的是_

A random(a, b)产生一个a到b之间的随机小数

B random. seed()函数初始化随机数种子，默认值是当前系统时间.

C random库的随机数是计算机按一定算法产生的，并非完全随机

D Python内置的random库主要用于产生各种伪随机数序列

答案：选 a

ramdom()：生成一个[0.0,1.0)之间的随机小数。

uniform(a,b)：生成一个[a,b]之间的随机小数。

random. seed()函数初始化随机数种子，默认值是当前系统时间。

random库的随机数是计算机按一定算法产生的，并非完全随机，产生的是伪随机数序列。

random.seed() 函数：用来生成随机数

1.参数可以是任何数字，如果使用相同的x值，则每次生成的随即数序列都相同；

2.如果不设置x值，系统将根据时间自动选择x值，此时生成的随机数序列因时间差异而不同；

3.对于同一x值，若多次执行random.seed(x)，将按照固定的序列顺序从头开始生成随机数。

32.以下代码的输出结果是______。

print('{:@>10.6}'.format('Fog'))

A Fog@@@@

B @@@@Fog

C Fog @@@@@@@

D @@@@@@@Fog

答案：选 d

format()方法的格式控制的语法格式如下：

{<参数序号>:<格式控制标记>}

格式控制标记包括：<填充><对齐><宽度><,><.精度><类型>等六个字段，这些字段都是可选的，可以组合使用。

填充常跟对齐一起使用，^、<、>分别是居中、左对齐、右对齐。

后面带宽度，引导符号':'后面带填充的字符，只能是一个字符，不指定默认是用空格填充。

所以填充字符为@，宽度为10，精度为6，也就是字符串最大输出长度为6。

Fog长度为3，可以正常输出。

表示右对齐，所以输出结果为@@@@@@@Fog。

{:@>10.6} format('Fog')表示输出时宽度为10，右对齐且填充@;若字符串长度大于6，只保留前6个字符，小于等于6则全部输出。输出结果为@@@@@@@Fog

33.执行以下程序，输ab，然后回车，结果是______。

k = 10

while True:

s = input('请输入q退出：')

if s == 'a':

k += 1

continue

else:

k += 2

break

print(k)

答案： 12

break用来跳出最内层循环，脱离该循环后程序从循环后的代码继续执行。

continue用来结束当前当次循环，即跳出循环体中下面尚未执行的语句，但不跳出当前循环。

首先s == 'a'成立，k的值加1，变成11，结束当前当次循环，进入下个循环。

函数内部的k不是全局变量，不改变外部全局变量的值，所以进入第二次循环时，k的值依然为10。

此时s的值为b，s == 'a'成立不成立，k的值加2，变成12，跳出循环，执行输出语句，输出结果为12。

34.以下程序的输出结果是______。

s = 10

def run(n):

global s

for i in range(n):

s += i

return s

print(s,run(5))

A 10 20

B 20 20

C 10 10

D UnboundLocalError

答案：选 a

n=5，range(5)，i=0、1、2、3、4

range(n)函数：代表从0到n（不含）产生的一个序列。

n=5，所以函数的返回值为10+0+1+2+3+4=20，全局变量s的值依然为10。

35.以下关于Python的函数的描述，正确的是

A函数内部改变了外部定义的组合类型变量的值，外部该变量的值不随之改变

B函数内部改变了已经声明为全局变量的外部的简单类型，外部该变量的值也随之改变

C函数内部定义了跟外部的全局变量同名的组合类型的变量，则函数内部引用的该名字的变量时不确定是外部的还是内部的

D函数内部使用外部定义的一个简单类型变量，需要显式声明其为全局变量

答案：选 d

全局变量指在函数之外定义的变量，在程序执行全过程有效。

全局变量在函数内部使用时，需要提前使用保留字global声明。

函数内部如果未使用global声明，即使名称相同，也不是全局变量，不会改变外部全局变量的值。

函数内部改变了外部定义的组合类型变量的值，外部该变量的值会随之改变。

1.若该变量为简单类型变量，对于在函数外部定义的全局变量，在函数内部使用时需要提前使用保留字global声明其为全局变量。

2.函数内部改变了已经声明为全局变量的外部的简单类型，外部该变量的值不变。

3.若该变量为组合类型变量，在函数内部定义和该变量同名的变量，在函数内部引用时该变量是内部的，和外部的值无关。

4.函数内部改变了外部定义的组合类型变量的值，外部该变量的值会随之改变。

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

ls = [10]

def run(n):

ls.append(n)

run(5)

print(ls)

A [10]

B UnboundLoca1Error

C [10, 5]

D None

答案：选 c

ls.append(x)：在列表ls最后增加一个元素。

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

A s[i:j:k]

B s[i, j, k]

C s[i;j;k]

D s(i, j, k)

答案：选 a

s[i:j:k]：步骤切片，返回包含序列s第i到j个元素以k为步数的子序列。

切片，里面是冒号！

38.对于序列s，以下选项对min(s)描述正确的是

A 一定能够返回序列s中的最小元素

B可以返回序列s中的最小元素，但要求s中元素可比较

C可以返回序列s中的最小元素，如果存在多个相同的最小元素，则返回一个元组类型

D可以返回序列s中的最小元素，如果存在多个相同的最小元素，则返回一个列表类型

答案：选 b

min(s)：序列s中的最小元素。

使用前提是序列中各元素类型可以进行比较，如果元素间不能比较，则函数会报错。

min()函数返回给定参数的最小值，但是要求给定参数是可以比较的。若给定的参数不能比较，则会报错;若给定参数存在多个最小元素，min()只会返回序列中最小的一个元素。

39.以下程序的输出结果是______。

x = 10

y = 0

if (x > 5) or (x/y > 5):

print('Right')

else:

print('Wrong')

A报错: ZeroDivisionError

B Wrong

C Right

D不报错，但不输出任何结果

答案：选 c

保留字or表示多个条件之间的"或"关系。

or的条件只要满足一个即可，x>5满足，执行下一语句，输出Right，or右侧条件语句不运行。

40.以下程序的输出结果是______。

for c in 'Python NCRE':

if c == 'N':

break

print(C)

答案：

A无输出

B Python

C Pytho

D PythonCRE

答案：选 a

break用来跳出最内层循环，脱离该循环后程序从循环后的代码继续执行。

本题中满足条件时，直接退出循环，不执行print语句，所以无输出。

卧槽，真贱啊，把print放循环里面，一定要注意看缩进

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

s=2

for i in range(1, 10):

s += i

print(s)

答案： 47

2+1+2+3+4+5+6+7+8+9

range(start, stop[, step])表示计数从start开始，到stop结束，但不包括stop，步长默认为1。i的取值范围是1、2、3、4、5、6、7、8、9。所以s=2+1+2+3+4+5+6+7+8+9=47。

42.以下程序被调用后，能够正确执行的是______。

def f(x,y=1,z=2):

pass

A f(1, x=2, z=3)

B f(x=1,2)

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

D f(1, y=2, z=3)

答案：选 c

函数调用时，默认采用按照位置顺序方式传递给函数，同时支持按照参数名称方式传递参数。

就是说，你要不就按照位置使用位参，要不就按照参数名称等于实际值，不要混着用

43.以下程序被调用后，运行错误的是______。

def f(x,y=1,z=2):

pass

A f(1,3)

B f(1, 2)

C f(1,2, 3)

D f(1)

答案：选 a

函数调用时，默认采用按照位置顺序的方式传递给函数，同时支持按照参数名称方式传递参数。f(1, , 3)应该修改为f(x=1,z=3)。

B选项，f(1, 2)就是默认按照位置，那个2按照位置就是传给y

44.以下不能用于生成空字典的选项是_

A dict(())

B dict()

C {}

D {[]}

答案：选 d

使用大括号可以创建字典，特殊地，可以创建一个空字典。

dict()：生成一个空字典，作用和{}相同。

dict(())等同于dict()。

45.对于字典d，以下选项对d. values（）的描述正确的是

A返回一个集合类型，其中包括字典d的所有值

B返回一个列表类型，其中包括字典d的所有值

C返回一个元组类型，其中包括字典d的所有值

D返回一个dict__Values类型，其中包括字典a的所有值

答案：选 d

d.values()返回字典中给的所有值信息，返回结果是Python的一种内部数据类型dict_values。

46.以下程序的输出结果是______。

ls=[1,2,3]

lt=[4,5,6]

print(ls+lt)

A [5,7, 9]

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

C [4,5, 6]

D [1,2,3, 4, 5, 6]

答案：选 d

ls + lt将两个列表的所有元素合并为一个列表。

47.以下程序的输出结果是______。

a = [3, 2, 1]

for i in a[::-1]:

print(i, end=' ')

A 1 2 3

B 3 2 1

C 1,2,3

D 3,2,1

答案：选 a

列表切片：<列表或列表变量>[N:M:K]

切片获取列表类型从N到M（不包含M）的以K为步长所对应的元素组成的列表。

题中k为-1，N和M省略，表示获取列表从后往前的所有元素，即1 2 3。

48.以下程序的输出结果是______。

a=[3,2,1]

b=a[:]

print(b)

A [3,2,1]

B []

C [1,2,3]

D 0xA1F8

答案：选 a

列表切片：<列表或列表变量>[N:M:K]

切片获取列表类型从N到M（不包含M）的以K为步长所对应的元素组成的列表。

题中三个参数均省略，表示获取整个列表，即[3, 2, 1]。XQ

49.以下关于随机运算函数库的描述，正确的是

A random库产生的随机数是完全随机的

B Python的random库是内置库，随Python一起发布

C random(a, b)产生一个(a, b)之间的随机小数

D random. seed()函数初始化随机数种子，是为了可以重复再现随机数序列

答案：选 d

ramdom()：生成一个[0.0,1.0)之间的随机小数。

uniform(a,b)：生成一个[a,b]之间的随机小数。

但是计算机是不可能产生随机值，真正的随机数也是在特定条件下产生的确定值。

random库是使用随机数的Python标准库，使用时需要使用import来调用，而内置库是可以直接使用的，不需要import来调用。

random.seed()函数初始化随机数种子，默认值是当前系统时间，种子相同，产生的随机数也相同，方便程序复现。

50.以下语句的执行结果是______。

lss = 'ab'

print('{:->4}'.join(lss))

A ab--

B --ab

C a{:->4} b

D ab

答案：选 c

join()方法用于将序列中的元素以指定的字符连接生成一个新的字符串。

语法：'sep'.join(seq)

sep：分隔符。可以为空

seq：要连接的元素序列、字符串、元组、字典

上面的语法即：以sep作为分隔符，将seq所有的元素合并成一个新的字符串。

把'{:->4}'这个东西join到(lss)里面，lss是ab，那就是a{:->4} b

这里的join()函数要和format()函数区分开，非常得迷惑人！

51.执行以下程序，根据提示输入3.2，回车后，输出结果是______。

flag = 0

try:

b = int(input('请输入字符串总长度：'))

print(type(B))

except:

flag = 1

print("请输入一个正整数：")

print(flag)

A请输入一个正整数.

B <class 'float'>

C <class' int' >

D <class'int' >

答案：选 a

python中的try...except语句中，如果try语句块执行成功，就会执行try语句块，否则执行except异常语句。

b = int(input('请输入字符串总长度：'))，要求输入一个整数，而题目输入的是3.2，try语句执行不成功，执行except中的语句。

52.以下程序的输出结果是______。

img1 = [12,34,56]

img2 = [1,2,3,4]

def displ(img):

print(img)

img1 = img2

img1.append([5,6])

disp1(img2)

A [12, 34, 56]

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

C [1,2,3, 4]

D [1,2,3, 4, [5, 6]]

答案：选 d

img1 = img2的作用：img1和img2都对[1,2,3,4]对象的引用，img2会随着img1的改变而改变。

ls.append(x)的作用是在列表ls最后增加一个元素x。[5,6]是作为一个元素被添加进去的，所以最后结果为[1,2,3,4,[5,6]]。

列表的复制，通过img1=img2，使得两个变量绑定同一个地址，那么当其中一个只要是未进行赋值的变化时另一个也会随之发生变化，当img1使用append()方法添加了[5,6]，img1=[1, 2, 3, 4, [5, 61],此时img2也就随之变化。所以调用函数显示的是[1, 2, 3, 4, [5, 6]]

53.以下关于Python的函数的描述，错误的是

A python支持用名称传递参数，调用的时候，带名称的参数可以改变在参数序列中的位置

B用def定义了函数之后，就等同于运行函数的代码

C python支持可选参数传递，定义的时候设置参数的默认值

D python函数可以没有return语句，不返回值

答案：选 b

用def定义了函数之后，函数被调用后才等同于运行函数的代码。

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

def calu(x = 3,y = 2)

return(xy)

a = 'abc'

b = 2

print(calu(a,b),end = ',')

A abcabc,

B abcabc

C 6,

D abcabc, 6

答案：选 a

输出calu(a,b)的结果，以","结束。calu(a,b)的返回值是ab，所以输出"abcabc,"。

55.以下关于随机运算函数库的描述，错误的是_

A用random(a, b)产生一个[0.0, 1.0)之间的随机小数

B random choice([1, 2, 3])函数返回的值有可能是3

C Python的random库采用梅森旋转算法生成伪随机数序列

D random sample(pop, k)返回从pop类型中随机选取的k个元素构成的列表

答案：选 a

ramdom()：生成一个[0.0,1.0)之间的随机小数。

56.以下代码的执行结果是______。

x,y,z = 3,4,5

print('x = {1},y ={0},z={0}'.format(x,y,z))

A x =4,y=3,z=3

B x =3,y=4,z=5

C x=4,y=4,z=3

D x=4,y=5,z=3

答案：选 a

print('x = {1},y ={0},z={0}'.format(x,y,z))表示格式化输出。

x = {1}的意思是将x,y,z中序号为1的元素输出，即第二个元素y的值4。

y ={0}的意思是将序号为0的元素输出，即第一个元素x的值3。

以此类推，最后结果为x = 4,y =3,z=3。

57.执行以下程序，输入60，输出的结果是______。

s = eval(input())

k ='合格'if s >= 60 else '不合格'

print(s,k)

A不合格

B 60

C 60合格

D合格

答案：选 c

函数eval()的作用是去掉字符串最外侧的引号，并按照Python语句执行去掉引号后的字符内容。

输入60，满足条件，k被赋值为'合格'，输出s和k，即为60合格。

58.以下程序的输出结果是______。

k = 'fadfa'

def send(n):

s = ''

for i in range(-1,-len(n),-1):

s += k[i]

return s

print(k,',',send(k))

A fadfa, afdaf

B afdaf

C fadfa, afda

D fadfa

答案：选 c

n=k，len（n）=len（k）=5

range(-1,-len(n),-1)就是range(-1,-5,-1)

i=-1、-3不包括-5

s += k[i]就是s=s+k[i]

s初值为空，i=-1，s=k[-1]='a'

i=-3，s=s+k[-3]='a'+='a'

range(start, stop[, step])表示计数从start开始，到stop结束，但不包括stop。

序号可以使用正向递增序号或者反向递减序号，正向从0开始，反向从-1开始。

输入k，字符串的长度为5，所以range(-1,-len(n),-1)等价于range(-1,-5,-1)，则i的取值范围为-1、-2、-3、-4。

i=-1时，k[-1]=a，字符串s中添加字符a，依次类推，s的最终结果为afda，循环结束，输出fadfa,afda。

59.使用Python的函数，需要的步骤不包括_

A函数定义

B函数测试

C函数调用

D函数执行

答案：选 b

使用函数的步骤中不包括函数测试。

60.以下程序的输出结果，可能的选项是______。

import random

def test():

x = random.randint(0,10)

y = random.randint(10,20)

return([x,y])

print(test())

A (6, 20)

B [11, 13]

C [6, 20]

D (1, 11)

答案：选 c

randint(a,b)：生成一个[a,b]之间的整数。

x的取值范围是[0,10]，y的取值范围为[10,20]。

A、D选项中不包括临界值，与题面不符，错误。

B选项中x的取值超出范围，错误。

61.以下不属于Python的内置函数的选项是______。

A abs()

B sum()

C input(

D get()

答案：选 d

get()方法是字典的方法，并不属于Python的内置函数; input()基本的输入函数，abs()绝对值函数，sum()计算和的函数。

get()不属于Python内置函数。

这题可以考技巧猜的，知道input肯定是的，而且abs和sum又都是同一个类型的，都是计算的，所以选d

62.以下不能判断变量x在字符串变量s中的方法是

(A)x ins

(B) len(s. split(x))

(D) s. count(x)

答案：选 c

s.strip(x)只能判断字符串头尾的东西，别的判断不出来

63.关于Python中for循环的描述，正确的选项是

(A) for循环能够实现列表的遍历，不能实现字典的遍历

(B) for循环内语句块的执行次数一定大于1

(D)能用for循环实现字符串里每个字符的遍历

答案：选 d

for循环可以实现字典的遍历

for循环语句块可以就执行1次

64.不是Python内置函数的选项是

(A) type()

(B) ord()

(D) compare()

答案：选 d

compare()不是Python内置函数

65.关于异常处理的描述，错误的选项是

(A) except后面可以增加异常类型，进而区分不同异常进行处理

(B)异常处理中try是必须的，except并不必须

(D) try、except、 else、 finally都可以用于异常处理

答案：选 b

异常处理中try是必须的，except也是必须的

66.以下代码的输出结果是

ls = [2018, 2019, 2020]

print(", ". join(ls))

(A) TypeError错误

(B) 2018, 2019, 2020

(D) 201820192020

答案：选 a

join()函数必须处理的是字符串类型的变量，逗号不是，类型错误

67.以下代码的输出结果是

ls='ab'

print('{{}} {:+^ 4}'. format(ls))

(A) +ab+

(B) {{}]+ab+ ,

(D) {}+ab+

答案：选 d

'{{}} {:+^ 4}'. format(ls)，用{}进行填充，+表示填充，^表示ls居中，宽度为4，即输出+ab+

{第一个花括号} {第二个花括号}第一个花括号输出{}，第二个花括号表示填充格式。

使用format输出花括号本身。两个左花括号输出左花括号本身，两个右花括号输出右花括号本身。

容易搞混的题型，第50题，join(lss)

68.执行以下程序，输3.2，然后回车，结果是

flag =0

try:

b=eval (input('请输入计算次数：'))

print(type(b))

except:

flag=1

print("请输入整数")

print(flag)

(A) <class 'int'>

(B) <class 'float'>

(D)请输入整数

答案：选 b

eval去掉引号，剩下3.2是float型，flag=0

当输入3.2时，b等于eval("3.2"), 也就是3.2, 然后打印输出3 2的数据类型，此两句代码不会出现异常，即except模块的语句不会执行，最后打印输出flag即可。

69.以下程序的执行结果是

a = [12,34, 56]

b = [1,2,3, 4]

def displ(a):

print('res:', [a])

b=a

a. append([5, 6])

displ (b)

(A) res: [[12, 34, 56, [5, 6]]]

(B) res: [[12, 34,56, 5, 6]]

(D) res: [[1, 2, 3, 4, [5, 6]]]

答案：选 a

b=a只是b加一个索引，指向a

a. append([5, 6])，在[12,34, 56]增加一个元素[5, 6]，a变成[12, 34, 56, [5, 6]]

a\]是在方括号里再加列表，即\[\[12, 34, 56, \[5, 6\]\]

70.以下程序的输出结果是

def func(x =[], y=[6,7]):

x. append(8)

y. append(8)

return(x+y)

a, b= [1,2], [3,4]

t=func(x=a)

t=func(y=b)

print(func() , end=';' )

(A) [8,6,7,8,8];

(B) [8,6,7,8,8]

(D) [8,8,6,7,8,8];

答案：选 d

t=func(x=a)执行，x=[1,2,8],y=[6,7,8]

t=func(y=b)执行，x=[8],y=[6,7,8]

只要函数参数的默认地址里的值被修改过，后期再次调用时也是使用被修改过的值。

由于列表类型的参数是可变对象，此处func函数中的x，y参数每被调用一次，参数值就会改变一次。

本题考核的是列表的可变性，当列表在使用apeend()等操作时，数据变化，地址不变。

题目中程序执行第一次函数func(x=a), x使用参数a的地址，结束时x为[1,2,8]， y使用默认参数[6,7]的地址，结束时y为[6,7,8];

71.当用户输入apple, banana, bear时，以下代码的执行结果是

a = input(""). split("，")

x=0

while x < len(a):

print(a[x], end="&")

x=x+1

(A) apple, banana, bear

(B) apple&banana&bear&

(D)执行出错

答案：选 b

apple&banana&bear&

72.以下代码的执行结果是

def maxcount():

a,b=1000,99

for i in range(10) :

a*=b+1

b*=a-1

return a<b

maxcount ()

(A) False

(B) True

(D) 执行错误

答案：选 c

没有print语句，无输出

73.以下代码的执行结果是

a =1000

while (a>123):

for i in range(10) :

a = a-a//123

if a <200:

break

print(a)

(A)执行错误

(B) 123

(D) 199

答案：选 b

这个break就算是跳出循环，也只是跳出for循环，while循环只有当a<=123的时候，才能输出a，选项里只有123符合要求。

74.以下代码的执行结果是

start = 2

n= 0

while start <= 10:

start=start+2.

n=n+ 1

print(n)

(A)5

(B)6

(D)0

答案：选 a

S=2，n=0

S=4，n=1

S=6，n=2

S=8，n=3

S=10，n=4

75.以下代码的执行结果是

def func(n):

n=n+2

return n

a=10

func(a)

print(a)

(A) 11

(B) 10

(D) 0

答案：选 b

这里的func(a)，return a=12，但是并没有改变a的值，a的值还是等于10，

函数内执行形参n的自增长，并且将n作为返回值，但是当调用函数的时候并没有变量接收返回值，且最后输出语句输出的是全局变量a，所以输出的值为10。

76.以下关于组合类型的描述，正确的是( )

A、空字典可以用大括号来创建

B、可以用set创建集合，用中括号和赋值语句增加新元素

C、字典数据类型里可以用列表做键

D、字典的items ()函数返回一个键值对，并用元组表述

答案 : A

集合中可以使用add()方法增加新元素，不能使用中括号来添加，B项错误;

字典数据类型必须用不可变的元素做键，而列表是可变的，不能做键，C项错误;

字典的items () 函数返回的是所有的键值对，D项错误。

77.关于random库的描述错误的是( )

A、使用random库可以用import random方式引入

B、random.seed)可用于初始化随机数种子，用于随机数序列再现

C、random.randint()将产性-个随机整数

D、random()库产生在0到1之间真正的随机数

答案 : C

导入random库的三种方式①import random,②impot random as t,③from random import *;

seed()函数设置随机数种子，可以选择不同的序列进行展示，用于随机数序列再现;

randint()函数用于产生一个随机整数;

random()库是采用梅森旋转算法生成的伪随机数序列，并不是现实意义上的随机数。

78.以下关于Python函数的说法，错误的是()

A、每个Python函数至少包含一个returm语句，如果没有返回参数，直接用retum

B、通过给部分函数参数赋默认值，可以实现可选参数传递

C、调用函数时，可以通过向参数名称赋值而不考虑参数顺序

D、Python函数可以同时返回多个值

答案 : A

Python中函数可以没有return语句，也可以通过returm语句返回一个或多个值;

在创建函数的时候可以设置参数默认值，之后在调用函数时，便可以实现可选参数传递;

在调动函数时，可以通过关键字传参的方式(向形参名赋值)，此时不用考虑传参顺序。

79.关于数据维度，以下选项中描述错误的是( )

A、列表类型可以表示二维数据

B、集合类型可以表示一维数据

C、字典类型可以表示一二维数据

D、字典可以表示高维数据

答案 : C

在Python语言中，列表可以表示一二维数据，集合可以表示一维数据，字典一般表示高维数据。

80.以下关于随机运算函数库的描述，正确的是()

A、Python的random库通过pip进行安装库

B、使用random.random()生成随机数前，必须先用random. seed函数初始化随机数种子

C、random.randint(a,b)产生一个[a,b]之间的随机整数

D、random.random(a,b)产生一个a,b)之间的随机小数

答案 : C

random库是Python的标准库，无需安装;

使用random库内函数时，seed()函数可以省略，此时将自动以当前时间作为随机数种子;

randint(a,b)函数可以产生一个[a,b]之间的随机整数;

random()函数没有参数，且只能产生在[0,1)范围内的随机浮点数。

81.下面关于Python中的变量描述错误的是( )

A、全局变量和局部变量两者的本质区别就是在于作用域

B、全局变量在函数内部和函数外部都可以访问使用

C、局部变量也可以在函数外部使用

D、在函数内部要对全局变量进行修改，需要加上global声明

答案 : C

局部变量是指在函数内部使用的变量，仅在函数内部有效，当函数使用过后，量从内存中释放。

82.关于Python函数的描述错误的是()

A、函数内部使用的全局变量必须用global声明

B、Python支持可选参数传递，但没有默认值的参数必须定义在有默认值参数的左侧

C、Python函数可以没有retum语句，此时返回值为None

D、Python函数支持用名称传递参数

答案 : A

函数内部使用全局变量无需声明，只有当需要改变全局变量时才需要声明;

83.关于Python程异常处理的描述，错误的选项是( )

A、try. except等保留字提供异常处理功能

B、程序发生异常后经过妥善处理可以继续执行

C、异常语句可以与else和finally保留字配合使用

D、Python的异常和错误是完全相同的概念

答案 : D

在Python语言中，利用try、 except、 finally和else保留字提供异常处理功能，当发生异常时，可以通过except捕获异常，而不是直接退出程序，异常和错误是不同的概念。

84.以下代码的执行结果是( )

m = 'BeetHoven MoonLight'

a=0

b=0

fori in m:

if'A'<=i<= 'Z:

a+= 1

elif'a'<=i<= 'z':

b+= 1

else:

break

print(a, b)

A、2 14

B、4 14

C、2 7

D、4 7

答案：选 c

在循环中对m中的每一个字符进行判断，在A到Z之间的字符，变量a值加一;在a到z之间的字符，变量b值加一;两个条件均不满足直接退出循环。观察m变量当遇到空格时，会退出循环，所以计算空格前的所有字符数量，其中大写字母2个，小写字母7个，输出结果为2 7

85.关于以下程序执行结果的描述，正确的选项是( )

try:

f= open('data.txt", 'W')

ts = f.write()

print("写文件正确")

except:

print(文件操作错误")

A、输出"写文件正确"

B、无论data.txt文件是否存在，都输出"文件操作错误"

C、如果data.txt文件不存在，不输出"文件操作错误"

D、如果data .txt文件存在,不输出"文件操作错误"

答案 : B

代码使用了异常捕获语句，在语句结构中，首先用写的方式打开文件data.txt,然后使用write()方法，因为没有参数，所以此处会直接产生异常，即会被except捕获异常并输出文件操作错误。

write()方法的括号里写入文件需要写入的内容，file1.write("Hello World\n")

86.关于循环结构的描述，错误的选项是( )

A、for in range(4,n)中循环变量i的初值是4

B、循环条件中的空列表或空字符串等价于False

C、for in 'Hello world'的循环次数是11次

D、while循环结构的循环次数必须是确定的

答案 : D

在循环结构中，遍历循环通常遍历多元素数据类型及range()函数，其中多元素数据类型的遍历次数与元素个数有关，range()函数有三个参数分别是开始位置，结束位置和步长，所以选项A、C正确;

无限循环中根据条件决定是否执行，当条件为一个数据的时候，会自动利用bool()函数计算此数据的布尔值，针对列表、字符串等多元素数据类型，空数据布尔值即为False，所以B选项正确、D选项错误。本题选择D选项。

87.以下代码的执行结果是()

k=5

def test(n):

global k

for i in range(n):

k+= i

return k

print(k,test(5))

A.程序运行错误

B、5 15

C、5 10

D、15 15

答案 : B

观察题目中代码，首先定义了变量，然后创建了test()函数，此时函数尚末运行。在print()函数内运行了test()函数，此时传入参数5。在函数内使用globa修饰k变量，使得k值在函数内修改也能同步到全局变量，经过循环此时k值应为k=5+1+2+3+4=15最后retum将值返回到调用函数的位置。但是在输出的时候需要考虑到print()函数中，k在调用函数之前，所以是先确定K值再运行函数，那么即使global修饰了K，在调用函数之前的k值也不会变化，所以输出结果为5 15。

88.关于Python函数的描述，正确的选项是( )

A、函数外部定义的列表变量，不可以在函数内部引用其值

B、函数内部定义的数字变量，可以在函数之外引用其值

C、函数有默认参数的时候,调用函数可以不给该参数赋值

D、函数内部定义的列表变量，可以在函数之外引用其值

答案 : C

在Python语言中，函数外部定义的列表，在函数内部可以直接引用或者使用部分方法，所以A选项错误;函数内部定义的变量属于局部变量，不可以在函数外部使用，选项B、D错误。本题选择C选项。

89.以下代码的执行结果是( )

Is= ['try']

def mtry(lt):

Itappend(Is)

return It

print(mtry(mtry('try']))

A. ['try, ['try']. ['try']]

B、['try', 'try', 'try']

C、try try try

D、[['try']. ['try'], ['try']]

答案 : A

根据函数中代码可以知道，函数中是Is添加到参数([try]中，append()方法添加列表，会将列表整体均作为元素添加到['try']中

90.以下代码的执行结果是( )

x= 99

a = list(range(100))

while X < len(a):

a= a[:x]

x-=1

if len(a) == 5:

break

print(a)

A、[0, 1......98, 99]

B、[0,1,2,3, 4]

C、[4,3,2, 1,0]

D、执行出错

答案 : B

观察题目中代码，给x变量赋值为99,给a变量赋值it()函数转换range()函数生成的数据，range()函数生成从0到99共100个数字的数据，list()函数转换过后得到0到99的列表。进入循环中，不停的将x的长度减1，此时a每次切片赋值索引少1的数据，直到a的长度等于5时，此时因为每次切片是将最后一个元素删除，所以剩下的a是前5个元素，也就是[0,1,2,3,4]。

91.关于程异常处理的描述,错误的选项是()

A、在进行关键计算时使用异常处理,如除0运算

B、在获得用户输入时使用异常处理,避免输入格式异常

C、在读取文件时使用异常处理，避免文件读取异常

D、在所有运算中都应该使用异常处理，避免程序任何可能的错误

答案 : D

Python中的异常处理机制是防止程序因某些非编程原因的错误导致程序终止，或者在可能出现异常的代码处增加处理机制。一般来说程序段无需增加异常处理机制。

92.关于while循环的描述，正确的选项是()

A、while循环可以实现无限循环

B、while循环不能实现计数循环

C、while循环与遍历循环等效

D、while循环不能用于函数内部

答案： A

for循环被称作遍历循环，while循环被称作无限循环，所有的for循环都可以用while循环改写，循环语句可以在Python程序的程序段中使用。

93.关于函数的描述，正确的选项是( )

A、每个递归函数都只能有一个基例

B、一个函数中只允许有一条retum语句

C、定义函数和调用该函数的代码可以写在不同的Python程序里

D、每个函数都必须有returm语句

答案 : C

递归函数可以有多个基例，A选项错误;

函数内可以存在0条、1条或多条return语句，B、D选项错误;

调用函数的代码可以在另一个Python程序中，只要导入定义函数的模块即可，C选项正确。本题选择C选项。

94.以下代码的执行结果是()

def func(m, n):

m= 2

s=m*n

return s

m= 5

n=2

print(func(5, 2))

A、10

B、4

C、25

D、5

答案 : B

创建函数传递两个参数，然后设置局部变量m为2，计算出s的值并作为返回值，后续程序创建全局变量m和n,然后调用函数输出返回值。传递m和n进入函数内，因为函数内将m的值赋值为2，n的值使用的是形参2，所以计算得s为4，所以执行结果为4。

95.以下代码不可能的执行结果是()

import random

def func(n):

if n==1 or n ==2:

return 1

else:

return random.randint(1,n-1)

print(func(10))

A、3

B、2

C、1

D、10

答案 : D

先导入random库，然后创建函数，在函数内编写分支语句，判断n的值，当n为1或者2的时候返回1,否则就返回1到n-1之间的随机整数，因为调用函数传入了10，所以不满足条件，返回1到9之间的随机整数，则10不可能是执行结果。本题选择D选项。

组合共97题带答案和解析

1.以下关于Python列表的描述中，错误的是_

A列表的长度和内容都可以改变，但元素类型必须相同

B可以对列表进行成员关系操作、长度计算和分片

C列表可以同时使用正向递增序号和反向递减序号进行索引

D可以使用比较操作符(如>或<等)对列表进行比较

答案：选 a

列表没有长度限制，元素类型可以不同，不需要预定义长度。

2.以下关于Python字典的描述中，错误的是

A在定义字典对象时，键和值用冒号连接

B在Python中，用字典来实现映射，通过整数索引来查找其中的元素

C字典中的键值对之间没有顺序并且不能重复

D字典中引用与特定键对应的值，用字典名称和中括号中包含键名的格式

答案：选 b

python语言中通过字典类型实现映射。

由于字典元素"键值对"中键是值的索引。

因此，可以直接利用键值对关系索引元素。

字典是存储可变数量键值对的数据结构，键和值可以是任意数据类型，通过键索引值，并可以通过键修改值。

3.以下用来处理Python列表的方法中，错误的是_

A interleave

B append

C insert

D replace

答案：选 a

append(x)：在列表最后增加一个元素x。

insert(i,x)：在列表第i位置增加元素x。

interleave()是Dataset的类方法，所以interleave是作用在一个Dataset上的，不是作用在列表上的。

4.以下代码的输出结果是______。

ls = ['book',23,[2010,'studl'],20]

print(ls[2][1][-1])

A s

B studl

C 1

D结果错误

答案：选 c

索引是列表的基本操作，用于获得列表中的一个元素。该操作沿用序列类型的索引方式，即正向递增序号和反向递减序号，使用中括号作为索引操作符，索引序号不能超过列表的元素范围，否则会出现IndexError错误。正向递增序号从0开始，反向递减序号从-1开始。

ls[2][1][-1]的执行过程：[2010,'stud1']-> stud1->1，即最后的结果是"1"。

5.以下代码的输出结果是______。

d = {'food':{'cake':1,'egg':5}}

print(d.get('cake','no this food'))

A egg

B 1

C food

D no this food

答案：选 d

d.get(key,default)根据键信息查找并返回值信息。

如果key存在则返回相应值，否则返回默认值。

代码d.get('cake','no this food')运行时找不到键"cake"，因为这个元祖d里面就只有一个food键，所以输出结果：no this food；

但是如果将代码d.get('cake','no this food')修改为d['food']['cake']，运行后输出结果：1。

26.以下代码的输出结果是______。

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

s = 0

for c in a:

for j in range(3):

s += c[j]

print(s)

答案：选 d

Python通过保留字for实现遍历循环，使用方法如下：

for <循环变量> in <遍历结构>

<语句块>

遍历循环可以理解为从遍历结构中逐一提取元素，放在循环变量中，对于每个所提取的元素执行一次语句块。for语句的执行次数是根据遍历结构中元素个数确定的。

使用range()函数，可以指定语句块的循环次数。

题目中的代码循环过程如下：

c=[1,2,3]，j=0，c[0]=1，s=1；

c=[1,2,3]，j=1，c[1]=2，s=3；

c=[1,2,3]，j=2，c[2]=3，s=6；

c=[4,5,6]，j=0，c[0]=4，s=10；

c=[4,5,6]，j=1，c[1]=5，s=15；

c=[4,5,6]，j=2，c[2]=6，s=21；

c=[7,8,9]，j=0，c[0]=7，s=28；

c=[7,8,9]，j=1，c[1]=8，s=36；

c=[7,8,9]，j=2，c[2]=9，s=45。

7.在Python语言中，不属于组合数据类型的是_。

O列表类型

O字符串类型

O复数类型

O字典类型

答案：选 c

Python语言中的组合数据类型包括集合类型、序列类型（列表类型）和映射类型（字典类型），而复数类型属于基本数据类型中的数字类型。

8.以下代码的输出结果是______。

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]

答案：选 d

range(a,b,s)的作用是从a到b以s为步长产生一个序列。

list(x)的作用是创建或将变量x转换成一个列表类型。

代码执行后的输出结果是[0, 1, 2, 3, 4]。

9.以下关于列表变量ls操作的描述中，错误的是__

A ls. reverse():反转列表ls中所有元素

B ls. append(x):在ls最后增加一个元素

C ls. copy0): 生成一-个新列表，复制ls的所有元素

D ls.clear(): 删除ls的最后一个元素

答案：选 d

ls.clear()：删除ls中所有元素。

总结：python中关于删除list中的某个元素，一般有三种方法：remove、pop、del：

1、remove: 删除单个元素，删除首个符合条件的元素，按值删除

2.、pop: 删除单个或多个元素，按位删除(根据索引删除)

3、del：它是根据索引(元素所在位置)来删除

10.以下关于Python字典变量的定义中，错误的是__

A d = {1:[1,2]， 3:[3, 4]}

B d = {[1,2]:1， [3, 4]:3}

C d ={(1,2):1， (3, 4):3}

D d = {'张三':1, '李四':2}

答案：选 b

Python语言中的字典使用大括号{}建立，每个元素是一个键值对，使用方式如下：

{<键1>:<值1>,<键2>:<值2>......<键n>:<值n>}

其中，键和值通过冒号连接，不同键值对通过逗号隔开。

字典中的键不可变，因此可以使用字符串、数字、元组等，但不能使用列表作为键。

A是数字，B是列表不可以，C是元组，D是字符串

11.列表listV = list (range(10))，以下能够输出列表listV中最大元素的是_

A print (listV. reverse(i) [0])

B print(listV. max()

C print (max(listV0))

D print (max (listV))

答案：选 d

max(ls)是列表的常用操作函数，表示列表ls中的最大值。

12.以下代码的输出结果是______。

ls = []

for m in 'AB':

for n in 'CD':

ls.append(m+n)

print(ls)

A ABCD

B AABBCCDD

C ACADBCBD

D ['AC'，'AD'， 'BC'，'BD']

答案：选 d

Python通过保留字for实现遍历循环，使用方法如下：

for <循环变量> in <遍历结构>

<语句块>

遍历循环可以理解为从遍历结构中逐一提取元素，放在循环变量中，对于每个所提取的元素执行一次语句块。for语句的循环执行次数是根据遍历结构中元素个数确定的。

ls.append(x)方法是列表的常用操作方法，作用是在列表最后增加一个元素x。

题目中的代码循环过程如下：

m = A，n = C，m+n = AC；

m = A，n = D，m+n = AD；

m = B，n = C，m+n = BC；

m = B，n = D，m+n = BD。

代码执行后的输出结果是['AC', 'AD', 'BC', 'BD']。

13.以下描述中，错误的是

A Python语言通过索引来访问列表中元素，索引可以是负整数.

B列表用方括号来定义，继承了序列类型的所有属性和方法

C Python列表是各种类型数据的集合，列表中的元素不能够被修改

D Python语言的列表类型能够包含其它的组合数据类型

答案：选 c

列表是包含0个或多个元组的有序序列，属于序列类型。列表可以进行元素增加、删除、替换、查找等操作。

14.以下描述中，错误的是

A如果s是一个序列，s =[1,"ksate", True]， s[3]返回True

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

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

D如果s是一个序列，s =[1, "kate", True]， s[-1]返回True

答案：选 a

如果序列长度为L，正向递增需要以最左侧序列符号为0，向右依次递增，最右侧序列符号为L-1；反向递减序号以最右侧序列符号为-1，向左依次递减，最左侧序列符号为-L。

选项"如果s是一个序列，s = [1,"kate",True]，s[3]返回True"中的索引序号"3"超过列表的元素范围，出现IndexError错误，返回的结果不是True。

15.以下代码的输出结果是______。

S = 'Pame'

for i in range(len(S)):

print(S[-i],end="")

A ameP

B emaP

C Pema

D Pame

答案：选 c

Python通过保留字for实现遍历循环，使用方法如下：

for <循环变量> in <遍历结构>

<语句块>

len(S)：字符串S的长度，这里为4。i的取值范围为range(4)，即0、1、2、3。

题目中的代码循环过程如下：

i = 0，S[-i]=P；

i = 1，S[-i]=e；

i = 2，S[-i]=m；

i = 3，S[-i]=a。

代码执行后的输出结果是Pema。

16.以下代码的输出结果是______。

for s in "HelloWorld":

if s=="W":

continue

print(s,end="")

A Helloorld

B Hello

C World

D HelloWorld

答案：选 a

Python通过保留字for实现遍历循环，使用方法如下：

for <循环变量> in <遍历结构>

<语句块>

Python的单分支结构使用if保留字对条件进行判断，使用方法如下：

if <条件>：

<语句块>

其中，if、：和<语句块>前的缩进都是语法的一部分。<条件>是一个产生True或False结果的语句，当结果为True时，执行<语句块>，否则跳过<语句块>。

continue用来结束当前当次循环，即跳出循环体中下面尚未执行的语句，但不跳出当前循环。

题目中的代码循环过程如下：

s = H，输出结果H；

s = e，输出结果e；

s = l，输出结果l；

s = o，输出结果o；

s = W，跳出当前当次循环，继续下一次循环；

s = o，输出结果o；

s = r，输出结果r；

s = d，输出结果d。

代码执行后的输出结果是Helloorld。

17.下面的d是一个字典变量，能够输出数字5的语句是______。

d = {'food':{'cake':1,'egg':5},'cake':2,'egg':3}

O print(d[' egg'])

O print(d[' food' ][' egg'])

O print(d[' food' ][-1])

O print(d[' cake' ] [1])

答案：选 b

索引是按照一定顺序检索内容的体系。由于字典元素"键值对"中键是值的索引，因此，可以直接利用键值对关系索引元素。

字典中键值对的索引模式如下（采用中括号格式）：

<值> = <字典变量>[<键>]

d['food'][-1]和d['cake'][1]中括号里的内容不是键，与字典类型中的索引模式不一样；d['egg']执行后的值是3，不是5。

18.以下代码的输出结果是______。

s =[4,2,9,1]

s.insert(2,3)

print(s)

A [4,2,9,2,1]

B [4,3,2,9,1]

C [4,2,3,9,1]

D [4,2,9,1,2,3]

答案：选 c

s.insert(i,x)：在列表第i位置增加元素x。

列表中的索引值从0开始，s.insert(2,3)表示在列表的第三个位置增加元素3，则题目中的代码执行后输出结果为[4,2,3,9,1]。

19.以下代码的输出结果是______。

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

print(len(ls))

答案： 3

len(ls)：列表ls中的元素个数（长度）。

代码执行后的输出结果是3，即ls=[[1,2,3],[[4,5],6],[7,8]]的长度为3。

20.以下代码的输出结果是______。

ls = ["2020", "20.20", "Python"]

ls.append(2020)

ls.append([2020, "2020"])

print(ls)

A [' 2020'，'20.20'，'Python'， 2020]

B [' 2020'，'20. 20'，' Python'，2020， [2020， '2020' ]]

C [' 2020'，20.20'，' Python'，2020， 2020， ' 2020' ]

D [' 2020'，'20.20'，'Python'，2020，[' 2020' ]]

答案：选 b

ls.append(x)：在列表ls最后增加一个元素x。

代码执行后的输出结果为['2020', '20.20', 'Python', 2020, [2020, '2020']]。

21.以下代码的输出结果是______。

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

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

A黑色黑色

B黑色灰色

C黑色黄色

D黑色蓝色

答案：选 a

d.get(key,default)：键存在则返回相应值，否则返回默认值default。

代码执行后的输出结果：黑色黑色。

22.以下选项，错误的是

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

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

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

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

答案：选 d

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

23.以下代码的输出结果是______。

d = {}

for i in range(26):

d[chr(i+ord("a"))] = chr((i+13) % 26 + ord("a"))

for c in "Python":

print(d.get(c,c), end="")

A Pabugl

B Plguba

C Cabugl

D Python

答案：选 b

Python通过保留字for实现遍历循环，使用方法如下：

for <循环变量> in <遍历结构>

<语句块>

chr(x)返回Unicode编码x对应的单字符

ord(x)返回单字符x表示的Unicode编码。

代码一开始生成一个空字典，第一个for循环用于向其中添加字典元素。range(26)表示i的取值范围是0至25之间的整数（包括0与25）。"a"对应的Unicode编码为97。

i=0时，chr(ord("a"))='a'，chr((13) % 26 + ord("a"))=chr(13+97)= 'n'，则第三行赋值语句简化为d['a']='n',此时字典d为{'a': 'n'}。

i=1时，chr(1+ord("a"))= 'b'，chr((1+13) % 26 + ord("a"))=chr(14+97)= 'o'，则第三行赋值语句简化为d['b']='o'，此时字典d为{'a': 'n', 'b': 'o'}。

依次类推，最后得出字典d为{'a': 'n', 'b': 'o', 'c': 'p', 'd': 'q', 'e': 'r', 'f': 's', 'g': 't', 'h': 'u', 'i': 'v', 'j': 'w', 'k': 'x', 'l': 'y', 'm': 'z', 'n': 'a', 'o': 'b', 'p': 'c', 'q': 'd', 'r': 'e', 's': 'f', 't': 'g', 'u': 'h', 'v': 'i', 'w': 'j', 'x': 'k', 'y': 'l', 'z': 'm'}，简而言之，每个字母键对应的是Unicode编码比自己大13的字母值。

d.get(key, default)表示若键存在则返回相应值，否则返回默认值default。所以第二个for循环最后的输出结果为Plguba。

24.以下关于Python二维数据的描述中，错误的是_

A从CSV文件获得数据内容后，可以用replace ()来去掉每行最后的换行符

B CSV文件的每一行是一维数据，可以用列表、元组和字典表示

C若一个列表变量里的元素都是字符串类型，则可以用join()合成字符串

D列表中保存的二维数据，可以通过循环用write()写入CSV文件

答案：选 b

高维数据由键值对类型的数据构成，采用对象方式组织，可以多层嵌套。

高维数据相比一维和二维数据能表达更加灵活和复杂的数据关系，可以用字典类型表示。

一维数据不用字典类型来表示。

逗号分隔型取值格式（Comma Separated Values，简称CSV），是一种纯文本格式，用来存储数据。

在CSV中，数据的字段由逗号分开，程序通过读取文件重新创建正确的字段，方法是每次遇到逗号时开始新一段数据。

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

ll=['aa',[2,3,3.0]]

print(ll.index(2))

A 2

B 3.0

C 3

D ValueError

答案：选 d

索引序号从0开始，不能超过列表的元素范围。l1列表中只有两个元素，l1.index(2)表示取列表中第三个元素，会出错。

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

for i in "Nation":

for k in range(2):

if i == 'n':

break

print(i, end="")

A aattiioo

B NNaattiioo

C Nattiioon

D aattiioonn

答案：选 b

range(start, stop[, step])表示计数从start开始，到stop结束，但不包括stop，步长默认为1。start默认从0开始，range(2)等价于range(0,2)，则k的取值范围为0、1。

break用来跳出最内层循环，脱离该循环后程序从循环后的代码继续执行。

第1次循环，i=N，k=0，if判断条件不成立，输出i的值为N。

第2次循环，i=N，k=1，if判断条件不成立，输出i的值为N。

第3次循环，i=a，k=0，if判断条件不成立，输出i的值为a。

第4次循环，i=a，k=1，if判断条件不成立，输出i的值为a。

......

第11次循环，i=n，k=0，if判断条件成立，跳出内层循环。

第12次循环，i=n，k=1，if判断条件成立，跳出内层循环。

最后输出为NNaattiioo。

27.以下程序的输出结果是______。

x = [90,87,93]

y = ("Aele", "Bob","lala")

z = {}

for i in range(len(x)):

z[i] = list(zip(x,y))

print(z)

A.{0:[(90,'Aele'),(87,'Bob'),(93,'lala')],1:[(90,'Aele'),(87,'Bob'),(93,'lala')],2:[(90,'Aele'),(87,'Bob'),(93,'lala')]}

B.{0:(90,'Aele'),1:(87,'Bob'),2:(93,'lala')}

C.{0:[90,'Aele'],1:[87,'Bob'],2:[93,'lala']}

D.{0:([90,87,93],('Aele','Bob','lala')),1:([90,87,93],('Aele','Bob','lala')),2:([90,87,93],('Aele','Bob','lala'))}

答案：选 a

len(ls)：列表ls的元素个数（长度）。

range(start, stop[, step])表示计数从start开始，到stop结束，但不包括stop，步长默认1。

start默认从0开始，range(len(x))等价于range(0,3)，则i的取值范围为0、1、2。

z = {}，z是一个空的元组类型，利用zip往里面添加元素。

zip()：将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。

list(zip(x,y))，把x和y打包成一个list，添加到元组z当中。

由题面可知，每个键值对的值都是一样的。

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

ss = set("htslbht")

sorted(ss)

for i in ss:

print(i,end = '')

O tsblth

O htslbht

O hlbst

O hhlstt

答案：选 c

set(x)函数将其他的组合数据类型变成集合类型，返回结果是一个无重复且排序任意的集合。4个选项中只有hlbst符合无重复的要求。

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

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

ls2=ls1

ls2.reverse()

print(ls1)

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

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

C 5,4,3,2, 1

D 1,2,3, 4, 5

答案：选 a

ls.reverse()：将列表ls中的元素进行逆序反转。

对于列表类型，使用等号无法实现真正的赋值，不能产生新列表。

ls2 = ls1语句并不是拷贝ls1中的元素给变量ls2，而是新关联了一个引用。

即增加一个别名，ls1和ls2所指向的是同一套内容，所以修改了ls2的内容，ls1也是随之改变的。

#列表对象的赋值和拷贝函数操作的差别。

赋值：是指两个对象共享一块内存；

拷贝：是给第二个对象复制了一份新的变量；

因此，赋值的情况下，如果修改了ls2的内容，则ls1也就改变了

30.为以下程序填空，使得输出结果是{40:'yuwen',20:'yingyu',30:'shuxue'}的选项是___。

tb = {'yingyu':20, 'shuxue':30, 'yuwen':40}

stb = {}

for it in tb.items():

print(it)

print(stb)

A stb[it[1]]=tb[it[0]]

B stb[it[1]]=stb[it[0]]

C stb[it[1]]=tb[it[1]]

D stb[it[1]]=it[0]

答案：选 d

{}用于生成一个空字典，d.items()返回所有的键值对。

在本题中，变量it中每一次循环存储一对键值对。

题面要求将每一对键值对的键和值交换位置，使用语句stb[it[1]] = it[0]。

题意是将字典中的键值互换。tb.items()以列表形式(并非直接的列表，若要返回列表值还需调用list函数)返回可遍历的(键，值)元组数组。因此，for循环中it每次遍历得到的是一个元组，依次为(yingyu',20)、('shuxue' ,30)、('yuwen' ,40)，然后将元组中序号为0的元素和序号为1的元素互换位置，实现字典中键值的互换，应填入stb[t[1]] = it[0]。

31.以下程序的输出结果是______。

def hub(ss, x = 2.0,y = 4.0):

ss+= x * y

ss = 10

print(ss, hub(ss, 3))

A 22 None

B 10 None

C 10. 0 22.0

D 22. 0 None

答案：选 b

全局变量指在函数之外定义的变量，在程序执行全过程有效。

ss是全局变量，最后输出为10，hub()函数没有返回值，最后输出为None。

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

ls = [12,44,23,46]

for i in ls:

if i == '44':

print('found it! i = ',i)

break

else:

print('not found it ...')

A notfoundit...

B foundit!i=44

C foundit!i=44 .

notfoundit...

D foundit!i=' 44'

notfoundit. . .

答案：选 a

列表ls中的元素是数字类型，判断条件中的'44'是字符串类型，所以判断条件不符合，最后输出not found it ...。

啊卧槽，这种题目老坑人了！

33.以下程序的输出结果是______。

x = 4

ca = '123456'

if str(x) in ca:

print(ca.replace(ca[x],str(x-2)))

A 5

B 123456

C 123426

D 2

答案：选 c

ca.replace(ca[4],str(2))即ca.replace(5, str(2))

replace(old,new)方法将字符串中的old（旧字符串）替换成new（新字符串），old和new的长度可以不同。

x=4，if判断条件成立，将字符串ca中索引序号为4的元素（即第5个元素），换成字符'2'，则输出123426。

34.给以下程序填空，能输出{0:[90,'Aele'],1:[87,'Bob'],2:[93,'lala']}结果的选项是______。

x = [90,87,93]

y = ("Aele", "Bob","lala")

z = {}

for i in range(len(x)):

print(z)

A z[i]=[x[i],y[i]]

B z[i]=x[i],y[i]

C z[i]=list(zip(x, y))

D z[i]=x, y

答案：选 a

zip()函数将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。

zip是将所有元素都打包成元组，再返回元组对应的字符串

x[0]=90，y[0]= "Aele"，依此类推，能输出题面要求键值对的语句是z[i] = [x[i],y[i]]。

i=0的时候，x[0]=90，y[0]= "Aele"，是一一对应的。

使用zip函数，是将所有元素都打包成元组，再返回元组对应的字符串

z[i]=list(zip(x, y))

结果是这样的：{0:[(90,'Aele'),(87,'Bob'),(93,'lala')],1:[(90,'Aele'),(87,'Bob'),(93,'lala')],2:[(90,'Aele'),(87,'Bob'),(93,'lala')]}

35.以下程序的输出结果是______。

L1=[1,2,3,4]

L2=L1.copy()

L2.reverse()

print(L1)

#列表对象的赋值和拷贝函数操作的差别，

拷贝函数是给第二个对象复制了一份新的变量；

因此修改了ls2的内容，则ls1并没有改变

A 1,2,3,4.

B [4,3,2, 1]

C 4,3,2, 1

D [1,2,3, 4]

答案：选 d

ls.copy()：复制ls中所有元素生成一个新列表。

题目中列表L1使用.copy()方法复制后赋值给变量L2，L2中元素的改变不会影响L1，所以最后输出L1的内容为[1, 2, 3, 4]。

列表赋值共享同一地址，所以会互相影响，一个改变另一个随之改变

36.以下程序的输出结果不可能的选项是______。

import random

ls=[2,3,4,6]

s=10

k=random.randint(0,2)

s+=ls[k]

print(s)

A 12

B 14

C 13

D 16

答案：选 d

randint(a,b)：生成一个[a,b]之间的整数。

根据题意，k的取值范围为[0,2]，列表的索引序号从0开始，所以可能会取出列表ls的前三个元素，不可能取到第4个元素，即运算结果不可能是16。

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

ls=['绿茶','乌龙茶','红茶','白茶','黑茶']

x='乌龙茶'

print(ls.index(x,0))

答案： 1

s.index(x)：序列s中第一次出现元素x的位置。

索引序号从0开始，所以第一次出现'乌龙茶'的位置是1。

总结：index()函数

str.index(sub [, start [, end]])

其中，str 表示要进行查找的原始字符串；

sub 代表要查找的子字符串；

start 和 end 分别表示字符串查找的起始和结束位置。

如果省略 start ，则默认从字符串开头查找；

如果省略 end ，则默认查找到字符串结尾。

38.关于字典的描述，错误的是_。

A字典的元素以键为索引进行访问

B字典的一个键可以对应多个值

C字典长度是可变的

D字典是键值对的结合，键值对之间没有顺序

答案：选 b

字典类型具有和集合类似的性质，即键值对之间没有顺序且不能重复。

字典元素"键值对"中键是值的索引，可以直接利用键值对关系索引元素，一个键对应一个值。

字典是存储可变数量键值对的数据结构，长度可变。

39.以下不是Python文件读写方法的是_

A read

B readline

C writeline

D write

答案：选 c

文件读取方法：read、readline、readlines、seek

文件写入方法：write、writelines

40.关于Python文件打开模式，表示错误的是

A ab

B rt

C nb

D wt

答案：选 c

总结：文件打开方式

文件的打开方式有：'r'、'w'、'x'、'a'、'b'、't'、'+'。

其中'r'、'w'、'x'、'a'可以和'b'、't'、'+'组合使用。

41.表格类型数据的组织维度最可能是

A二维数据.

B 一维数据

C多维数据

D高维数据

答案：选 a

二维数据，也称表格数据，由关联关系数据构成，采用二维表格方式组织，对应于数学中的矩阵，常见的表格都属于二维数据。

42.二维列表ls=[[9, 8], [7, 6], [5, 4], [3, 2], [1, 0]]，能够获得数字4的选项是_

A ls[-2, 0]

B ls[3, 2]

C ls[2, 2]

D ls[-3,-1]

答案：选 d

索引序列使用正向递增序号或反向递减序号。正向从0开始，代表第1个元素，反向从-1开始，代表最后一个元素。

获取数字4首先需要取到[5, 4]，序号为2或者-3。然后在[5, 4]中取4，序号为1或者-1，所以选择s[-3, -1]。

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

x=dict()

type(x)

A <class' set'>

B <class' list'>

C <class' dict'>

D <class' tuple' >

答案：选 c

x=dict()：生成一个空字典，所以x为字典类型。

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

lt=['绿茶','乌龙茶','红茶','白茶','黑茶']

ls=lt

ls.clear()

print(lt)

A变量未定义的错误

B []

C [绿茶','乌龙茶'，红茶'，'白茶'，黑茶']

D'绿茶','乌龙茶'，红茶,'白茶'，'黑茶'

答案：选 b

ls.clear()：删除ls中所有元素。

对于列表类型，使用等号无法实现真正的赋值，不能产生新列表。ls = lt语句并不是拷贝lt中的元素给变量ls，而是新关联了一个引用，即增加一个别名，ls和lt所指向的是同一套内容，所以删除ls中的元素，lt也随之变成空列表。

45.以下不是Python文件操作方法的是_

A load

B seek

C read

D write

答案：选 a

文件读取方法：read、readline、readlines、seek

文件写入方法：write、writelines

46.文件的追加写入模式是__。

A x

B r

C a

D +

答案：选 c

r：只读模式，如果文件不存在，返回异常。

x：创建写模式，文件不存在则创建，存在则返回异常。

a：追加写模式，文件不存在则创建，存在则在原文件最后追加内容。

+：与r/w/x/a一同使用，在原功能基础上增加同时读写功能。

47.表达键值对的字典类型最可能属于的数据组织维度是_

A一维数据

B高维数据

C二维数据

D多维数据

答案：选 b

高维数据由键值对类型的数据构成，采用对象方式组织，可以多层嵌套。

48.以下对CSV格式描述正确的是

A CSV文件以英文逗号分割元素

B CSV文件以英文空格分割元素

C CSV文件以英文分号分割元素

D CSV文件以英文特殊符号分割元素

答案：选 a

逗号分隔的存储格式叫做CSV格式，是一种通用的、相对简单的文件格式。

49.以下程序的输出结果是______。

def mysort(ss,flag):

if flag:

return(sorted(ss,reverse = True))

else:

return(sorted(ss,reverse = False))

ss = [9,4,6,21]

print(mysort(ss,2))

A [4,6,9,21]

B [9, 4]

C [21,9,6,4]

D [9,4,6,21]

答案：选 c

mysort(ss,flag)函数中，如果flag不为0，则返回元素从大到小排序后的列表；

如果flag为0，则返回元素从小到大排序后的列表。

50.执行以下程序后，要输出ab44cd46结果，该执行的选项是______。

ls = ['ab','44','cd','46']

ls.reverse()

A print(''. join(ls[-1::]))

B print(''. join(ls))

C print(''. join(ls[1:]))

D print(''. join(ls[-1::-1]))

答案：选 d

列表切片：<列表或列表变量>[N:M:K]

切片获取列表类型从N到M（不包含M）的以K为步长所对应的元素组成的列表。

ls[-1::-1]中，N为-1，K为-1，表示获取列表从后往前的所有元素，即46cd44ab，再执行ls.reverse()，将列表中的元素逆序输出，得到ab44cd46。

(改) 执行以下程序后，要输出46cd44ab结果，该执行的选项是______。

ls = ['ab','44','cd','46']

ls.reverse()

A print(''. join(ls[-1::]))

B print(''. join(ls))

C print(''. join(ls[1:]))

D print(''. join(ls[-1::-1]))

答案：选 b

Join时不用逆序输出，reverse时逆序即可。

51.以下程序的输出结果是______。

ss = [2,3,6,9,7,1]

for i in ss:

print(max(ss),end = ',')

ss.remove(max(ss))

A 9,7,6

B 9,7,6,

C 9,7,6,3,2, 1,

D 9, 7,6,3,2, 1

答案：选 b

for循环的作用是求出列表aa中的最大值并输出，以逗号结尾，将这个最大值移出ss列表。

第1次循环，i的取值为ss中的第1个元素，即2，此时最大值为9，输出最大值和逗号后，ss变为[2,3,6,7,1]；

第2次循环，i的取值为ss中的第2个元素，即3，此时最大值为7，输出最大值和逗号后，ss变为[2,3,6,1]；

第3次循环，i的取值为ss中的第3个元素，即3，此时最大值为6，输出最大值和逗号后，ss变为[2,3,1]；

ss中此时只有3个元素，i不再取值，循环结束。

因为此时，已经遍历到列表的最后了，已经完成遍历了，所以不再取值了。

52.以下语句的执行结果是______。

dd={'a':90,'b':87,'c':93}

print(max(dd),min(dd))

A c a

B 93 90

C c b

D 93 87

答案：选 a

字典由键值对组成，max(d)输出的是最大值对应的键，min(d)输出的是最小值对应的键。

abc在ascii中，a最小，c最大

字典的操作函数max()和min()，分别返回最大值、最小值的函数都是对字典的键进行比较，所以最大值为'c，最小值为'a',所以选D选项。

53.以下语句的执行结果是______。

dd = {'chinese':200, 'pe':187, 'Gana':930}

print(dd.keys())

A 200,187,930

B 'chinese':'pe':'Gana'

C dict_keys(['chinese','pe','Gana'])

D ['chinese','pe','Gana']

答案：选 c

字典由键值对组成，dd.keys()返回字典中的所有键的信息，返回结果是Python的一种内部数据类型dict_keys。

54.以下程序的输出结果不可能的选项是______。

import random

ls = ['a','b','c','d']

print(random.sample(ls,2))

A ['d','a']

B ['d','c']

C ['a','d','c']

D ['b','d']

答案：选 c

sample(pop,k)：从pop类型中随机选取k个元素，以列表类型返回。

所以最后输出的是2个元素，不可能为3个元素。

55.以下程序的输出结果是______。

def myf(x = 2.0,y = 4.0):

global sp

sp += x * y

return(sp)

sp = 100

print(sp,myf(4,3))

A 112 100

B 100 112

C 100 100

D 112 112

答案：选 b

程序自上向下执行，首先创建函数，此时函数未经过调用，无需执行，然后创建变量sp，并打印变量sp的值及函数的返回值，所以第一个值为100。函数myf参数为4和3。代入函数中，函数中使用了global关键字，诱导考生认为全局变量sp已经被修改，但是在打印过程中sp先打印，此时还未执行函数。经运算函数的返回值为112。

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

ss=['e','h','b','s','l','p']

for i in range(len(ss)):

print(max(ss),end=',')

ss.remove(max(ss))

A s,p,l,h,e,b,

B s,p,l,h,e,b

C s,p,l

D s,p,l,

答案：选 a

len(ss)=6，所以i的取值范围为0、1、2、3、4、5。

字符之间按照ASCII码值比较大小，26个小写字母中，a最小，z最大。

第1次循环，i的取值为0，输出列表ss中的最大值，即s，以及','，将最大值移出列表，此时列表为['e','h','b','l','p']；

第2次循环，i的取值为1，输出列表ss中的最大值，即p，以及','，将最大值移出列表，此时列表为['e','h','b','l']；

依次类推，最后输出"s,p,l,h,e,b,"。

56.（改）如果改一下题目，把range(len(ss))改成ss。

ss=['e','h','b','s','l','p']

for i in ss:

print(max(ss),end=',')

ss.remove(max(ss))

A s,p,l,h,e,b,

B s,p,l,h,e,b

C s,p,l

D s,p,l,

答案：选 d

i=e,输出's,' ss=['e','h','b','l','p']

i=h,输出'p,',ss=['e','h','b','l']

i=b,输出'l,', ss=['e','h','b',]。此时i遍历到头了，输出结束

输出s,p,l,

57.以下程序的输出结果是______。

print(len(list('i love python')))

A 13

B 1

C 11

D 3

答案：选 a

计算字符串长度时，空格也算作一个字符长度，所以长度为13。

58.以下程序的执行结果是______。

x = [90,87,93]

y = ("Aele","Bob","lala")

z={}

for i in range(len(x)):

z[x[i]]=y[i]

print(z)

A {'Aele':90,'Bob':87,'lala':93}

B {'90':'Aele','87':'Bob','93':'lala'}

C {'Aele':'90','Bob':'87','lala':'93'}

D {90:'Aele',87:'Bob',93:'lala'}

答案：选 d

z是字典变量，由键值对组成，由z[x[i]]=y[i]可知，x[i]是键，y[i]是值，x列表中的元素为数字，y列表中的元素为字符，所以执行结果为{90:'Aele',87:'Bob',93:'lala'}。

59.以下语句的执行结果是______。

dic = {90:'Aele',87:'Bob',93:'lala'}

print(dic.pop(90,-1),len(dic))

A Aele 3

B-13

C Aele 2

D-12

答案：选 c

pop(key[,default])方法删除字典给定键key及对应的值，返回值为被删除的值。key值必须给出，否则返回default值。

题中删除键90及其对应的值，返回值为Aele，此时字典中元素为2，则长度为2。

60.以下语句的执行结果是______。

ls = [120,'120',int('120'),12*10]

print(ls.index(120),ls.count(120))

A 0 3

B 0 2

C 2 4

D 1 3

答案：选 a

s.index(x)：序列s中第一次出现元素x的位置。

列表第一个元素为120，列表序号从0开始，则ls.index(120)返回值为0。

ls.count(120)用来求出列表中值为120的元素个数，除'120'是字符外，其余值均为120，个数为3。

61.不能返回列表数据类型的选项是

A range()

B s. split()

C dict. items ()

D s.lcut()

答案：选 c

dict.items()返回字典中的所有键值对信息，返回结果是Python的一种内部数据类型dict_items。

62.关于Python组合数据类型的描述，错误的选项是

(A) 字符串、元组和列表都属于序列类型

(B)列表创建后，其内容可以被修改

(C)组合数据类型根据数据之间的关系分为三类:序列类型、集合类型和映射类型

(D) 集合类型的元素之间存在先后关系，能通过序号访问

答案：选 d

集合内部元素之间随机排列，没有顺序之分。

组合数据类型根据数据的关系分为序列类型、集合类型和映射类型，其中序列类型又包含字符串、元组和列表。集合类型和映射类型都是没有顺序的数据类型，不能通过序号访问。本题选择A选项。

63.有一组获奖学生名单，从第1名到第6名的学生姓名为:张良，韩梅梅，李亮，王红，张晓晓,李梅。要求名单一旦创建，数据不能修改，不能打乱先后次序。适合存储该组数据的数据类型是

(A)集合类型

(B)列表类型

(C)元组类型

(D)字典类型

答案：选 c

因为要存储多个学生姓名，有顺序的限制，所以集合不适合作为存储类型，且题目要求-但创建数据不能修改，不能打乱先后次序，那么列表和字典也不适合作为存储类型，只能选择元组类型。因为元组是不可改变且有顺序的组合数据类型。

64.以下程序的输出结果是______。

def mysort(ss,flag):

if flag:

return(sorted(ss,reverse = True))

else:

return(sorted(ss,reverse = False))

ss = [1,2,4,3]

print(mysort(ss,2))

(A) [1, 2，4, 3]

(B) [4，3, 2, 1]

(D)[3，4，2，1]

答案：选 b

但凡flag≠0，那么if flag就是True，sorted()函数进行排序，参数reverse = True，就是翻转。默认是从小到大，翻转就是从大到小。

65.（和50题对比）执行以下程序后，要输出46cd44ab结果，该执行的选项是______。

ls = ['ab','44','cd','46']

ls.reverse()

A print(''. join(ls[-1::]))

B print(''. join(ls))

C print(''. join(ls[1:]))

D print(''. join(ls[-1::-1]))

答案：选 b

就是直接join一个字符串，下面已经有reverse函数了，join用空''进行分隔输出

66.(和51题对比，一个max一个min).以下程序的输出结果是______。

ss = [2,3,6,9,7,1]

for i in ss:

ss.remove(min(ss))

print(min(ss),end = ',')

(A) 1,2,3,6,7, 9,

(B) 9,7,6,3,2, 1,

(D) 2,3,6

答案：选 d

先remove最小值1，然后print新ss的最小值2，只有d选项是2开头的，选d

遍历列表ss，当循环执行时，每次删除一个最小的数字，同时打印剩下最小的数字，此时列表的元素数量会发生变化，for循环又是控制循环次数的，所以当执行三次后，元素只剩三个，再想遍历第四个元素，列表已经不能满足了，所以三次的值分别为2,3,6。且print()函数含有参数end那么在每个输出后都得加上","，所以答案为"2,3,6,",选C选项。

67.以下程序的输出结果不可能的选项是

import random

ls = ['a','b','c','d']

print(ls[int (random.random()*3)])

(A) 'a'

(B) 'd'

(D) 'a', 'b','c','d'都有可能

答案：选 b

random.random()生成一个0~1之间的随机浮点数

int取整是直接舍的，所以int (random.random()*3的可能取值是0、1、2

所以不可能取第三位d

题目中Is索引通过random库的random()函数生成，因为random()函数生成在[0,1) (包含0不包含1)的随机浮点数，所以乘三之后范围在[0,3) (包含0不包含3)，所以通过int()函数取整之后也不可能等于3,即索引小于3不可能通过索引取得字符串"d"。

68.关于Python列表类型的描述，错误的选项是

(A)列表创建后可以修改其中元素，但每个元素类型不能修改

(B)二维数据可以用列表类型表示

(C)列表类型的元素可以是列表

(D)列表类型的元素可以是字典

答案：选 a

列表中的元素可以修改类型

69.以下代码的执行结果是

ls =[中国'，['北京'，'上海'，'广州']，['河北省'，'浙江省'，'广东省']，300, 400, 500]

print(ls[-4][1][:2])

(A)河北

(B)浙江

(C)浙江省

(D)北京

答案：选 b

(ls[-4][1][:2])

-4\]是\['河北省'，'浙江省'，'广东省'

1\]是浙江省 \[:2\]即\[0:2\]，不包括2，浙江 70.以下代码的执行结果是 \[' well',' good' ,'best' ,'how'，do'，you','do','?'

str 1 = s[3]+' ' + s[4]+' '+ s[5]+' '+ s[6]

print (str1)

(A) how do you do

(B) do you do?

(D) 执行错误

答案：选 a

中间用空格空开

71.关于Python列表操作的描述，错误的选项是

(A) ls是一个列表，ls. insert(x, j)可以在列表ls第j个位置插入一个元素x

(B) ls是一个列表，ls. remove (x)将列表ls中出现的第1个元素x删除

(D) ls是一个列表，ls. append(x)可以在列表ls第1个位置插入一个元素x

答案：选 d和a

insert(i，x)：在列表第i位置增加元素x。a选项也是错的题目有问题

ls.append(x)的作用是在列表ls最后增加一个元素x。

72.以下代码的执行结果是

s=[1，''Alice"，True]

print(s[1] and s[-1])

(A) True

(B) A1ice

(D) 1

答案：选 a

s[1] and s[-1]即''Alice" and True = True

73.为了使以下代码的执行结果是:中国，韩国，日本，巴基斯坦，蒙古

country = [' 中国'，'韩国'，'日本'，" 巴基斯坦'，'蒙古']

n=1

for c in country:

if n < len(country):

print(______)

else:

print(C)

n=n+1

在横线处要补充的代码是

(A) c, sep=","

(B) c，"，"

(D) c, end=",''

答案：选 d

print(c, end=",'')

74.以下语句的执行结果是

dd = {'chinese' :200，'pe':187,' Gana':930}

print (dd. keys())

(A) [' chinese' ,'pe'，'Gana' ]

(B) dict_keys(['chinese','pe','Gana' ])

(D)'chinese','pe','Gana'

答案：选 b

字典输出键keys的类型dict_keys

75.以下语句的执行结果是

d = {1:10, 2:2, 3:100}

print (d. get(3,99))

(A) 2

(B) 99

(D) 10

答案：选 c

d. get(3,99)，键3在不在，在即返回3，不在即返回默认值99

本题主要考核字典的get()方法，get)方法从字典中寻找对应参数的键，找到即返回对应的值，找不到即返回自身的第二个参数。题目中寻找3对应的键，可以发现字典中有3这个键，所以返回3对应的值，即为100。

76.以下程序的输出结果是

dd = {'a':90,'b' :87,'c' :93}

print([[dd[x]，x] for x in sorted(dd)])

(A) [[87, 'b']，[90, 'a']，[93, 'c']]

(B) [[93, 'c']，[90，'a']，[87， 'b']]

(D) [[90,'a'],[87,'b']，[93,'c']]

答案：选 d

sorted(dd)默认是按照键的升序，键a，再返回键名'a'

字典dd输出语句print()输出的是一个列表，列表由列表生成式产生，列表中含有多个[dd[x], x]元素，其中x从soted(dd)中遍历得到，sorted(dd)的值为['a','b','c'], 代入[dd[x], x]依次计算得到90, 'a], [87, 'b'],[93, 'c']，所以选择B选项。

77.以下是某班5名同学的一组个人信息

学号、姓名、性别、年龄、身高、体重

xs001、张红、女、18、168、 55

xs002、王丽丽、女、19、165、 60

xs003、李华、男、18、178、66

xs004、赵亮、男、19、175、 65

xs005、张玲玲、女、18、160、 50

采用变量a存储以上信息用于统计分析，最适合的数据类型是

(A)字符串

(B)列表

(C)集合

(D)字典

答案：选 b

列表可操作性大，可以修改

78.关于Python的循环控制，以下描述错误的是

(A) break将退出所有层次的循环

(B) continue将结束当次循环

(D) break和continue可以用于遍历循环和无限循环

答案：选 a

break只是退出最内层的循环

79.以下对Python语言定位的表述正确的是( )

A、数据分析专用语言

B、编译型语言

C、解释型脚本语言

D、机器语言

答案 : C

Python是高级脚本语言，采用解释型方式执行，且自身属于通用语言可以完成各种不同的工作。

80.在time库中，可以进行程序计时的函数是( )

A. perf_ counter()

B、sleep()

C、strtime()

D、strptime()

答案 : A

time库中perf_counter()函数用于计时; sleep()函数用于暂停程序执行; strftime()和trptime()都是用于显示时间。

81.使用pip指令安装第三方库wordcloud的命令是( )

A、install pip wordcloud

B、pip install wordcloud

C、pip wordcloud

D、install wordcloud pip

答案 : B

使用pip安装模块的命令是pip install模块名。所以选择B选项。

82.执行以下程序,井输入"0"时，输出结果是( )

try:

b = eval(input(请输入一个正整数: '))

print(100/b)

except ZeroDivisionError:

print("错误1")

except:

print("错误2")

A、错误2

B、错误1

C、100

D、2.03333333333335

答案 : B

当输入0时，eval()函数将字符串"0"转化为数字0，然后执行print()语句内部的100/0， 0不能作为除数，所以会产生异常ZeroDivisionError，所以执行print("错误1")。

83.以下代码的执行结果是()

L1 = ['月亮','河','宽宽','的','河']

print(L1.index('河'))

A. 1

B. 3

C、2

D、4

答案 : A

首先创建了L1例表，然后输出列表index(方法得到的结果。index()方法可以查询列表元素并返回对应索引值，仅返回查询到的第一个元表。题目中询字符串河"，所以返回的索引值应为1。

84.以下程序的输出结果是( )

def mysort(s,flag):

if flag:

return(sorted(ss,reverse = True))

else:

return(sorted(ss,reverse = False))

ss=[1,2, 4, 3]

print(mysort(ss, -1)

A. [1,2,4,3]

B、[3,4.2,1]

C、[1,2,3, 4]

D、[4,3,2, 1]

答案 : D

本题创建了函数，函数体内利用sorted()函数对形参ss进行排序，排序的方式根据形参1ag来确认。程序主体创建列表S，调用函数mysort(),传入实参ss及-1,根据-1可知，分支语句执行的是if分支，则排序方式按照从大到小进行排序。

以下代码的执行结果是()

Is= []

for i in range(11):

ls.append(i**2)

ls.reverse()

print(Is)

A、[100, 64, 36, 16, 4,0,1,9,25, 49, 81]

B、[0, 1,4, 9, 16, 25, 36, 49, 64, 81, 100]

C、[121, 100, 81, 64, 49, 36, 25, 16, 9,4, 1]

D、[1,4,9, 16, 25, 36, 49, 64, 81, 100,121]

答案 : A

观察题目中代码，每次循环都将列表添加一个i的平方，并且将列表逆序，根据分析，列表中数据依次为[0]、[1,0]、 [4,0,1]、 [9,1,0,4]、 [16,4,0,1,9]、 [25,9,1,0.4,16]、[36,16,4,0,1,9,25]、 [49,25,9,1,0,4,16,36]、[64,36,16,4,0,1,9,25.,49]、[81,49,25,9,1,0.4,16,36,64]和[100,64,36,16,4,0,1,9,25,49,81]。

以下代码的执行结果是( )

Is= ["abc", ["abcdef", "123", "xyz"], ["abc", "xyz", "123"], "abc"]

print(len(Is[1][-3]))

A、1

B、6

C、3

D、出错

答案 : B

通过索引嵌套取值，首先取ls的第2个元素为["abcdef", "123", "xyz"]，然后所以取此元素的倒数第三个为"abcdef"，最后len()函数求得此元素的长度为6。

87.以下语句的输出结果是()

dd = {'chinese':200,'pe':187,'Gana':930}

print(sorted(dd.keys()))

A. dict_ key("Gana', 'chinese', 'pe'])

B、'Gana', 'chinese', 'pe'

C、['Gana', 'chinese', 'pe]

D、报错

答案 : C

观察题目可以知道sorted()函数排序的数据是dd字典通过keys()方法返回的全部的键，所以从小到大比较三个字符串得到列表[Gana', 'chinese', 'pe]。

第1题:以下代码的执行结果是( )

dt={'a': 10, 'b' :20}

print(type(dt['a']))

A、<class 'tuple'>

B、<class 'str'>

C、<class 'int'>

D、<class 'dict'>

答案 : C

首先创建了dt字典，然后利用type()函数得到的d通过a键取出值的数据类型，最后输出。当dt通过'a'键取值得到的数据为10, type(10)的返回值为<class 'int'>。

89.关于全局变量和局部变量的描述，错误的选项是()

A、全局变量在Python文件最外层声明时，语句前没有缩进

B、局部变量标识符不能与任何全局变量的标识符相同，即严格不能重名

C、在函数内部引用数字类型全局变量时，必须使用global保留字声明

D、在函数内部引用组合类型全局变量时，可以不通过global保留字声明

答案 : B

在Python语言中局部变量可以是任意标志符，因为局部变量在函数结束时，并相当于被销毁，所以即使与全局变量同名，也可以正常运行。

关于函数参数的描述，错误的选项是( )

A、采用参数名称传递参数，可以增加程序的可读性

B、函数调用时，默认按照位置顺序传递参数

C、采用参数名称传递参数，可以不按照参数的默认顺序

D、函数的可选参数可以放在非可选参数的前面

答案 : D

函数的参数顺序必须是可选参数放在非可选参数后面。

91.以下代码的执行结果是( )

x= [3,4,5],[10,11],[12,13],14]]

print(len(x))

A、4

B、2

C、3

D、5

答案 : B

先创建了x列表，然后用len()函数计算x列表的长度并输出。列表的长度就是列表中元素的数量，x列表有两个元素，分别是[3,4,5]和[10,11]、[12,13],14]，所以长度为2。

92.以下代码的执行结果是( )

L1=[1,2,3,4]

st="

for i in L1:

st+= i

print(st)

A、'1234'

B、10

C、1234

D、程序执行错误

答案 : D

首先创建了L1列表和st空字符串，然后循环遍历列表，每次循环将遍历的元素拼接给st字符串。因为L1中的元素为数字类型不能和字符串拼接，所以会出现异常。

93.在以下程序后执行选项中代码,报错的是( )

d = [{'作者': 'Jone','密码'：*****,'收藏':[]}"作品:['日出','平凡人生']}]

A. print(d[0]['作者'])

B、print(d[01["作者'][4])

C、print([1][作品][0])

D、print(d[1][作品][1])

答案 : B

A选项中d[0][作者]得到的结果为"jone'正确;

B选项在"jone'的基础上取索引的值错误;

C选项d[1][作品][0]得到的结果为'日出'正确;

D选项d[1][作品][1]得到的结果为'平凡人生'正确。

94.关于函数全局变量和局部变量的描述，错误的选项是()

A、在函数内部引用局部变量时可以不用nonlocal保留字声明

B、在函数内部引用全局变量时一定要用global声明

C、全局变量指在函数外部创建的变量

D、在函数内部创建的局部变量，在函数外部不能引用

答案 : B

在函数内部引用全局变量可以不使用globaI声明，如果是更改全局变量的话，一般是需要声明的。

95.关于Python组合数据类型的描述，正确的选项是( )

A、列表类型的元素访问需要索引，有正向递增和反向递减两种方式

B、集合类型的元素访问需要索引，有正向递增和反向递减两种方式

C、元组类型和列表类型都属于集合类型

D、字典类型是"键-值"数据项的组合，各键值对元素之间有先后关系

答案 : A

列表类型访问元素可以通过索引取值的方式，有正向递增索引和反向递减索引两种方式，A选项正确;

集合类型是无序的，所以没有索引，B选项错误;

元组类型和列表类型和集合类型无关，C选项错误;

字典类型是键值数据项的组合，但是字典没有顺序，所以D选项错误。

96.关于组合数据类型的描述，错误的选项是( )

A、s是一个集合类型变量，则语句"x not in s"表示如果x不是s的元素，返回True, 否则返回False

B、赋值语句animal = "cat", "dog", "tiger", "rabit", 产生一个元组类型变量

C、s是一个集合类型变量,若s={235,10,50,10}，则执行print(s)的结果可能是{10,235,50}

D、s是一个列表类型变量，则语句"x is in s"示如果x是s的元素，返回True,否则返回False

答案 : D

not in表达式判断是否存在，如果不存在返回True,存在返回False，A选项正确;

直接将多个元素通过逗号赋值给一个变量，会自动将数据加上括号形成元组进行赋值，B选项正确;

集合是无序不可重复的数据类型，所以会自动去重，顺序也可能是任意形式，C选项正确;

判断是否存在是使用in关键字，不存在is in表示，D选项错误。本题选择D选项。

97.关于列表类型的描述，正确的选项是( )

A. list(x)可以将一个整数x转换为列表[x]

B、列表Is=[1,2,3,4,5], s=ls[3:4]结果是4, 结果是整数类型

C、列表ls=[1,2,3,4,5], s=Is[3:4]结果是[4], 结果是列表类型

D、list({"a":1,"b":2})结果为["a", 1, "b", 2]

答案 : C

list()函数的参数需要是多元素数据类型，比如元组，字符串，字典等，当直接转换字典的时候，是对字典的键进行操作，等于舍弃字典的值，所以A选项错误，D选项错误;

切片[3.4]选取第4位元素到第5位元素，包含第4位不包含第5位，所以取到4，且返回值为列表类型，B选项错误，C选项正确。本题选择C选项。

文件共80题带答案和解析

1.在Python语言中，写文件的操作是_

A write

B writeall

C seek

D writetext

答案：选 a

Python语言中写文件的操作方法：

f.write(s)：向文件写入一个字符串或字节流。

f.writelines(lines)：将一个元素为字符串的列表整体写入文件。

2.以下对Python文件处理的描述中，错误的是_

A Python通过解释器内置的open()函数打开一个文件

B Python能够以文本和二进制两种方式处理文件

C当文件以文本方式打开时，读写按照字节流方式

D文件使用结束后可以用close()方法关闭，释放文件的使用授权

答案：选 c

当文件以文本方式打开时，读写按照字符串方式；

当文件以二进制方式打开时，读写按照字节流方式。

3.以下关于Python二维数据的描述中，错误的是_

A一种通用的二维数据存储形式是CSV格式

B二维数据由多条一维数据构成，可以看作一维数据的组合形式

C表格数据属于二维数据，由整数索引的数据构成

D CSV格式每行表示一个一维数据，用英文半角逗号分隔

答案：选 c

二维数据，也称表格数据，由关联关系数据构成，采用二维表格方式组织，对应于数学中的矩阵，常见的表格属于二维数据。

4.在Python语言中，读入CSV文件保存的二维数据，按特定分隔符抽取信息，最可能用到的函数是

A format()

B join()

C replace()

D split()

答案：选 d

split()通过指定分隔符对字符串进行切片。

join()方法用于将序列中的元素以指定的字符连接生成一个新的字符串。

replace()方法把字符串中的old（旧字符串）替换成new(新字符串)。

format()方法用于解决字符串和变量同时输出的格式安排问题。

csv全称"Comma-Separated Values"，是一种逗号分隔值格式的文件，是一种用来存储数据的纯文本格式文件。

5.以下代码执行后，book.txt文件的内容是______。

fo = open("book.txt","w")

ls = ['book','23','201009','20']

fo.write(str(ls))

fo.close()

A book, 23, 201009, 20

B ['book' ,' 23'，'201009'，'20' ]

C [book, 23, 201009, 20]

D book2320100920

答案：选 b

str(x)：将x转换为等值的字符串类型。str(ls)先把列表ls转换成一个字符串

fo.write(s)：向文件写入一个字符串或字节流。字符串进行写入的时候又变回一个列表。

代码执行后的输出结果为列表['book','23','201009','20']。

6.以下关于Python文件打开模式的描述中，错误的是_

A只读模式r

B覆盖写模式w

C追加写模式a

D创建写模式n

答案：选 d

创建写模式x，文件不存在则创建，存在则返回异常FileExistsError。

7.以下关于CSV文件的描述中，错误的是_

A CSV文件可以保存一维数据或二维数据

B CSV文件的每一行是一维数据，可以使用Python的列表类型表示

C CSV格式是一种通用的文件格式，主要用于不同程序之间的数据交换

D CSV文件只能采用Unicode编码表示字符

答案：选 d

逗号分隔的存储格式叫作CSV格式（逗号分隔值），

CSV是一种通用的、相对简单的文件格式，用途广泛，主要用于不同程序之间的数据交换；

CSV文件不需要特定的字符编码；

CSV文件的每一行是一维数据，整个CSV文件是一个二维数据；

一维数据和二维数据都可以使用CSV格式保存成CSV文件。

8.给定列表ls = [1, 2, 3,"1"，"2"，"3"]，其元素包含2种数据类型，列表ls的数据组织维度是

A二维数据

B 一维数据.

C多维数据

D高维数据

答案：选 b

一维数据由对等关系的有序或无序数据构成，采用线性方式组织，对应于数学中数组的概念。一维数据十分常见，任何表现为序列或集合的内容都可以看作是一维数据。

9.在Python语言中，使用open()打开一个Windows操作系统D盘下文件，路径名错误的是

A D: \PythonTest\a. txt

B D: \\PythonTest \\a. txt

C D:/PythonTest/a. txt

D D:// PythonTest//a. txt

答案：选 a

打开并关闭文件的操作，需要文件的路径名，

由于""是字符串中的转义符，所以表示路径时，使用"\"或"/"代替""。

\a反斜杠后面带东西，会被识别为转义字符

10.在Python语言中，将二维数据写入CSV文件，最可能使用的函数是_

A exists()

B split()

C strip()

D join()

答案：选 d

join()方法用于将序列中的元素以指定的字符连接生成一个新的字符串。

CSV文件是用逗号分割的，用join加到字符之间很方便

二维数据存储为CSV格式，需要将二维列表对象写入CSV格式文件以及将CSV格式读入成二维列表对象。

二维列表对象输出为CSV格式文件方法采用遍历循环和字符串的join()方法相结合。

实例如下：

#ls代表二维列表，此处省略

f = open("cpi.csv","w")

for row in ls:

f.write(",".join(row)+"\n")

f.close()

11.以下关于文件的描述中，错误的是

A使用read()可以从文件中读入全部文本

B可以使用open()打开文件，用close()关闭文件

C文件是存储在磁盘上的数据，也是序列的集合

D使用readline()可以从文件中读入一行文本

答案：选 c

文件是存储在辅助存储器上的一组数据序列，可以包含任何数据内容。

概念上，文件是数据的集合和抽象。

12.以下关于文件的描述中，错误的是

A文件打开后，可以用seek ()控制对文件内容的读写位置

B采用readlines()可以读入文件中的全部文本，返回一个列表

C使用open()打开文件时，必须要用r或w指定打开方式，不能省略

D如果没有采用close()关闭文件，Python程序退出时文件将被自动关闭

答案：选 c

open()函数总结：

Python通过open()函数打开一个文件，并返回一个操作这个文件的变量，函数语法：

<变量名> = open(<文件路径及文件名>,<打开模式>)

open()函数有两个参数：文件名和打开模式。

打开模式用于控制使用何种方式打开文件，open()函数提供7中基本的打开模式：

r：只读模式，如果文件不存在，返回异常FileNotFoundError，默认值

w：覆盖写模式，文件不存在则创建，存在则完全覆盖原文件

x：创建写模式，文件不存在则创建，存在则返回异常FileExistsError

a：追加写模式，文件不存在则创建，存在则在原文件最后追加内容

b：二进制文件模式

t：文本文件模式，默认值

+：与r/w/x/a一同使用，在原功能基础上增加读写功能

13.以下不属于Python文件操作方法的是

A split

B write

C writelines

D readline

答案：选 a

split()方法是常用的字符串处理方法，不是文件操作方法。

Python文件操作方法总结：

f.read(size)：从文件中读入整个文件内容。参数可选，如果给出，读入前size长度的字符串或字节流。

f.readline(size)：从文件中读入一行内容。参数可选，如果给出，读入该行前size长度的字符串或字节流。

f.readlines(hint)：从文件中读入所有行，以每行为元素形成一个列表。参数可选，如果给出，读入hint行。

f.seek(offset)：改变当前文件操作指针的位置，offset的值：0为文件开头；1为当前位置；2为文件结尾。

f.write(s)：向文件写入一个字符串或字节流。

f.writelines(lines)：将一个元素为字符串的列表整体写入文件。

14.以下关于数据组织的描述中，错误的是_

A更高维数据组织由键值对类型的数据构成，可以用Python字典类型表示

B 一维数据采用线性方式组织，可以用Python集合或列表类型表示

C二维数据采用表格方式组织，可以用Python列表类型表示

D字典类型仅用于表示一维和二维数据

答案：选 d

一维、二维数据和高维数据总结：

1、一维数据由对等关系的有序或无序数据构成，采用线性方式组织，对应于数学中数组的概念。

2、二维数据，也称表格数据，由关联关系数据构成，采用二维表格方式组织，对应于数学中的矩阵，常见的表格都属于二维数据。

3、高维数据由键值对类型的数据构成，采用对象方式组织，可以多层嵌套。高维数据相比一维和二维数据能表达更加灵活和复杂的数据关系，可以用字典类型表示。

15.文件exam.txt与以下代码在同一目录下，其内容是一段文本：bigBen，以下代码的输出结果是______。

f = open("exam.txt")

print(f)

f.close()

A bigBen

B exam txt

C <_ io. TextIOWrapper ...>

D exam

答案：选 c

open()方法的作用是打开一个文件，整个代码未对文件exam.txt进行读写操作，就直接关闭了。所以f就是打开文件的一个操作，运行后代码输出的结果是：

<_io.TextIOWrapper name='book.txt' mode='r' encoding='cp936'>。

16.不属于Python文件读操作的是_

A readtext

B readline

C readall

D read

答案：选 a

Python文件读操作的方法：

f.read(size)：从文件中读入整个文件内容。参数可选，如果给出，读入前size长度的字符串或字节流。

f.readline(size)：从文件中读入一行内容。参数可选，如果给出，读入该行前size长度的字符串或字节流。

f.readlines(hint)：从文件中读入所有行，以每行为元素形成一个列表。参数可选，如果给出，读入hint行。

f.seek(offset)：改变当前文件操作指针的位置，offset的值：0为文件开头；1为当前位置；2为文件结尾。

17.文件book.txt在当前代码所在目录内，其内容是一段文本：book，以下代码的输出结果是______。

txt = open("book.txt", "r")

print(txt)

txt.close()

A非其他答案

B book. txt

C txt

D book

答案：选 a

open()方法的作用是打开一个文件，而所给的代码未对文件book.txt进行读写操作，直接关闭，运行后输出<_io.TextIOWrapper name='book.txt' mode='r' encoding='cp936'>。

txt是打开操作

18.假设city.csv文件内容如下______。

巴哈马,巴林,孟加拉国,巴巴多斯

白俄罗斯,比利时,伯利兹

以下代码的输出结果是：

f = open("city.csv", "r")

ls = f.read().split(",")

f.close()

print(ls)

A [巴哈马，巴林，孟加拉国，巴巴多斯，白俄罗斯，比利时，伯利兹']

B ['巴哈马'，'巴林'，'孟加拉国'，'巴巴多斯'，'白俄罗斯'，'比利时'，'伯利兹']

C ['巴哈马'，'巴林'，'孟加拉国'，'巴巴多斯\n白俄罗斯'，'比利时'，'伯利兹']

D ['巴哈马'，'巴林'，'孟加拉国'，'巴巴多斯'，'\n'， '白俄罗斯'，'比利时'，'伯利兹']

答案：选 c

f.read(size)：从文件中读入整个文件内容。参数可选，如果给出，读入前size长度的字符串或字节流。

split(str,num)通过指定分隔符对字符串进行切片，如果参数num有指定值，则仅分隔num个子字符串。

f.read().split(",")：从文件中读入整个文件内容，并以逗号分隔。原文的第一行后有一个换行符"\n"，所以读入文件内容时，这里的字符串应为"巴巴多斯\n白俄罗斯"。

运行代码后的输出结果是['巴哈马', '巴林', '孟加拉国', '巴巴多斯\n白俄罗斯', '比利时', '伯利兹']。

巴巴多斯和白俄罗斯之间，没有逗号，不能用逗号分开，而是有一个换行符。

19.(和第5题对比)以下代码的输出结果是______。

fo = open("book.txt","w")

ls = ['book','23','201009','20']

fo.writelines(ls)

fo.close()

A [book, 23, 201009, 20]

B book, 23, 201009, 20

C book2320100920

D ['book' ,' 23'，'201009'，'20' ]

答案：选 c

fo.writelines(lines)方法的含义是将一个元素为字符串的列表整体写入文件。

代码运行后的输出结果是book2320100920。

20.在读写文件之前，需要打开文件使用的函数是

A open

B fopen

C file

D CFi1e

答案：选 a

Python通过open()函数打开一个文件，并返回一个操作这个文件的变量，语法形式如下：

<变量名>=open(<文件路径及文件名>,<打开模式>)

21.以下关于文件的描述，错误的是_

A当文件以二进制方式打开的时候，是按字节流方式读写.

B open()打开文件后，返回一个文件对象，用于后续的文件读写操作

C open()打开一个文件，同时把文件内容载入内存

D write (x)函数要求x必须是字符串类型，不能是int类型

答案：选 c

采用二进制方式打开文件，文件被解析成为字节流。

Python通过open()函数打开一个文件，并返回一个操作这个文件的变量。

f.write(s)：向文件写入一个字符串或字节流。

Python通过解释器内置的open()函数打开一个文件，并实现该文件与一个变量的关联。

语法格式：<变量名> = open(<文件名/文件路径>[,<打开模式>[,encoding=None]])

使用open函数打开文件后会返回一个文件对象，即<变量名>，利用该变量名可以完成后续文件的读写等操作。

网络解释：

open属于低级IO，返回一个文件描述符，open无缓冲。

fopen是高级IO，返回一个文件指针。fopen有缓冲。

22.给以下程序填空，使得输出到文件a.txt里的内容是'90','87','93'的选项是______。

y = ['90', '87', '93']

l = ''

with open("a.txt",'w') as fo:

for z in y:

fo.write(l.strip(','))

A l+="'{}'".format(z)

B l+="'{}'".format(z)+','

C l='，'.join(y)

D l+='{}'.format(z)+','

答案：选 b

格式化方法.format()用于解决字符串和变量同时输出时的格式安排问题，使用方式如下：

<模板字符串>.format(<逗号分隔的参数>)

其中，模板字符串是一个由字符串和槽组成的字符串，用来控制子串和变量的显示结果。

槽用大括号（{}）表示，对应format()方法中逗号分隔的参数。

程序中使用strip()方法去掉数据尾部的逗号，所以程序填空处应该重新加上逗号。

所以选项A错误，没加上逗号。

选项C中使用了中文状态下的引号（若将引号修改为英文状态，输出到文件的内容也与题意不符），所以选项C错误。

使用选项D中的代码输出到文件中的内容与题意不符，所以选项D错误。

B选项"'{}'"、d选项'{}'、d选项的format输出是不带引号的，选项D错误

'90'因为90输出的时候，是要带引号的。

23.以下程序的输出结果是______。

img1 = [12,34,56,78]

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

def modi():

img1 = img2

print(img1)

modi()

print(img1)

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

12, 34, 56, 78

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

1,2,3, 4, 5

C [12, 34, 56, 78]

12, 34, 56, 78

D [12, 34, 56, 78]

1,2,3, 4, 5

答案：选 a

对于列表类型，使用等号无法实现真正的赋值，不能产生新列表。

img1 = img2语句并不是拷贝img2中的元素给变量img1，而是新关联了一个引用，即增加一个别名，img1和img2所指向的是同一套内容，所以调用函数modi()后，输出的img1，指向的是img2的内容，即[1,2,3,4,5]。

在函数外部，img1内容不变，所以输出的是[12,34,56,78]。

调用函数modi()，函数体内进行赋值操作，列表对象的赋值就是简单的对象引用。

函数体内，img1和img2是一样的，他们指向同一片内存，img1不过是img2的别名。因此，函数调用执行后输出[1,2,3,4,5]。然后执行print(img1)，此处的img1是外部变量，与函数体内img1不是同一个变量，仍输出[12,34,56,78]。

24.以下关于数据维度的描述，错误的是

A二维数据可以看成是多条一维数据的组合形式

B JSON格式可以表示比二维数据还复杂的高维数据

C列表的索引值是大于0小于列表长度的整数

D csv文件既能保存一维数据，也能保存二维数据

答案：选 c

列表的索引值由0开始，可以等于0的

JSON格式可以表示比二维数据还复杂的高维数据

25.以下不属于Python的pip工具命令的选项是

A install

B -V

C show

D download

答案：选 b

pip常用的子命令有：

install、download、uninstall、freeze、list、show、search、wheel、hash、completion、help。

26.以下关于文件的描述，错误的是

A open()打开文件之后，文件的内容就被加载到内存中了

B open()函数的参数处理模式'b'表示以二进制数据处理文件

C open函数的参数处理模式'+' 表示可以对文件进行读和写操作

D fo. readlines()函数是将文件的所有行读入一个列表

答案：选 a

'b'：二进制文件模式。

'+'：与r/w/x/a一同使用，在原功能基础上增加同时读写功能。

f.readlines(hint=-1)：从文件中读入所有行以每行为元素形成一个列表。参数可选，如果给出，读入hint行。

文件读写后要调用close ()函数，才能将文件被保存在磁盘中。

27.以下程序输出到文件text.csv里的结果是______。

fo=open("a.txt",'w')

x=['春眠','处处','夜来']

fo.writelines(x)

fo.close()

A '春眠'处处'夜来'

B春眠

处处

夜来

C春眠处处夜来

D '春眠'

'处处'

'夜来'

答案：选 c

f.writelines(lines)：直接将列表类型的各元素连接起来写入文件f。

28.以下方法能返回列表数据类型的选项是

A s.split()

B s.strip()

C s.replace()

D s.center()

答案：选 a

str.split(sep=None)：返回一个列表，由str根据sep被分割的部分构成，省略sep默认以空格分割。

str.strip(chars)：从字符串str中去掉在其左侧和右侧chars中列出的字符。

str.replace(old,new)：返回字符串str的副本，所有old子串被替换为new。

str.center(width,fillchar)：字符串居中函数，fillchar参数可选。

29.以下关于数据维度的描述，正确的是

A一维数据可以用列表表示，也可以用字典表示

B JSON格式可以表示具有复杂关系的高维数据

C 一维的列表a里的某个元素是一个一维的列表b，这个列表是二维数据

D采用列表表示一维数据，各个元素的类型必须是相同的

答案：选 b

高维数据在Web系统中十分常用，作为当今Internet组织内容的主要方式，高维数据衍生出HTML、XML、JSON等具体数据组织的语法结构。

字典属于高维数据，A项错误；

采用列表表示一维数据时，元素的数据类型可以不同，D项错误；

C项说法片面，列表a还可能是高维的。故答案选B项。

30.以下不属于Python的pip工具命令的选项是

A get

B install

C show

D dowmload

答案：选 a

pip常用的子命令有：

install、download、uninstall、freeze、list、show、search、wheel、hash、completion、help。

31.在进行CSV文件读写时，最不可能使用的字符串处理方法是

A join()

B index()

C strip()

D split()

答案：选 b

str.split(sep=None)：返回一个列表，由str根据sep被分割的部分构成，省略sep默认以空格分割。

str.strip(chars)：从字符串str中去掉在其左侧和右侧chars中列出的字符。

str.join(iter)：将iter变量的每一个元素后增加一个str字符串。

这三个方法用来增加字符串中的分隔字符或者去掉指定字符，是在进行CSV文件读写时，可能会使用的处理方法。

32.f=open()可以打开一个文件，关于f的描述错误的是_

A f是一种特殊的Python变量，执行print (f)时会报错

B f是文件对象引用，在程序中表示文件

C f. read()可以一次性读入文件全部信息

D执行m=f后，m和f同时表示所打开文件

答案：选 a

Python通过open()函数打开一个文件，并返回一个操作这个文件的变量，语法形式如下：

<变量名> = open(<文件路径及文件名>,<打开模式>)

f就是等号左边的变量名。

f=open()，执行print (f)时不会报错

输出的是一种读写的方法：<_io.TextIOWrapper name='book.txt' mode='r' encoding='cp936'>

f=open ()，f是文件对象的引用，在程序中f代表打开的文件，执行print (f)不会报错。

33.下列函数中，不是Python内置函数的是_

A abs()

B all()

C perf_counter ()

D format()

答案：选 c

perf_counter()不是Python内置函数。

time.perf_counter()函数

perf_counter()是第三方库time的函数，返回当前的计算机系统时间。

连续两次执行计算差值，可以得到计算程序运行时间。

34.安装一个第三方库的命名格式是

A pip install<第三方库名>

B pip uninstall<第三方库名>

C pip download<第三方库名>

D pip search<第三方库名>

答案：选 a

install：安装

uninstall：卸载

download：下载

search：查找

35.生成一个[1, 99]之间随机整数的函数是

A random randint(1, 100)

B random randint(0, 99)

C random. randint(1, 99)

D random. uniform(1, 99)

答案：选 c

随机数生成函数总结：

randint(a,b)：生成一个[a,b]之间的整数。

uniform(a,b)：生成一个[a,b]之间的随机小数。

ramdom()：生成一个[0.0,1.0)之间的随机小数。

36.time库的time. time ()函数作用是

A以数字形式返回当前系统时间

B以字符串形式返回当前系统时间

C以struct_time形式返回当前系统时间

D根据format格式定义返回当前系统时间

答案：选 a

使用time.time()获取当前时间戳，返回值为数字形式。

37.以下属于turtle库颜色控制函数的是

A seth()

B pensize()

C pencolor(

D right()

答案：选 c

pencolor()：设置画笔的颜色

pensize()：设置画笔宽度

seth()：改变画笔绘制方向

right(angle)：向右旋转angle角度

38.下列函数中，不是Python内置函数的是

A close()

B sum()

C exec()

D eval()

答案：选 a

close()不是Python内置函数。

exec执行储存在字符串或文件中的 Python 语句，相比于 eval，exec可以执行更复杂的 Python代码。

sum()是Python内置函数，对序列进行求和计算。

sum(iterable[, start])

iterable 可迭代对象，如：列表、元组、集合。

start 指定相加的参数，如果没有设置这个值，默认为0。

39.下载但不安装一个第三方库的命名格式是

A pip search<第三方库名>

B pip uninstall<第三方库名>

C pip install<第三方库名>

D pip download<第三方库名>

答案：选 d

install：安装

uninstall：卸载

download：下载

search：查找

40.生成一个k比特长度随机整数的函数是

A random. shuffle(k)

B random. choice(k)

C random getrandbits(k)

D random sample(k)

答案：选 c

choice(seq)：从序列类型（例如列表）中随机返回一个元素。

shuffle(seq)：将序列类型中元素随机排列，返回打乱后的序列。

getrandbits(k)：生成一个k比特长度的随机整数。

sample(pop,k)：从pop类型中随机选取k个元素，以列表类型返回。

41.以下关于文件的描述，错误的是

A打开文件既要读也要写，应该使用的打开模式参数是'rw+'

B fo.seek ()函数是设置当前文件操作指针的位置

C open()函数的打开模式b'表示以二进制数据处理文件

D open函数的打开模式'a'表示可以对文件进行追加操作

答案：选 a

r：只读

w：只写

r+：可读可写，若文件不存在，报错

w+：可读可写，若文件不存在，创建

42.执行以下语句后，文件txt里的内容是______。

fo = open("txt",'w')

x=['大学',' ','道德经',' ','易经']

fo.write(''.join(x))

fo.close()

A大学道德经易经

B大学道德经易经

C '大学'，

'道德经'

'易经'

D'大学','道德经','易经'

答案：选 a

join()方法用于将序列中的元素以指定的字符连接生成一个新的字符串。

空格也是列表x中的元素，所以文件里的内容为"大学道德经易经"。

用空格来分割

43.以下方法不是python文件操作的选项是

A write()

B open()

C copy()

D seek()

答案：选 c

copy()函数用于复制，与文件操作无关。

Python文件操作方法：

f.open()：打开文件。

f.write(s)：向文件写入一个字符串或字节流。

f.seek(offset)：改变当前文件操作指针的位置，offset的值：0为文件开头；1为当前位置；2为文件结尾。

44.关于数据组织的维度，以下选项中描述错误的是

A CSV文件可以用来存储二维数据

B字典类型可以表示具有复杂关系的高维数据

C列表可以表示一维数据，也可以表示多维数据

D字典和JSON格式都能够表达一维数据

答案：这题四个选项都是对的，题目有问题

高维数据用字典表示，仅利用最基本的二元关系展示数据之间的复杂结构。

JSON格式可以表示高维数据也可以表示一维数据；

Python中的字典形式类似于JSON格式；

列表类型可以表示一维数据，也可以通过多层列表表示二维数据；

CSV文件可以用来存储一维数据或二维数据。

45.用pyinstaller工具能够对Python源文件所做的操作不包括的选项是

A把数据和源代码一起打包

B对源文件打包，并删除生成的临时文件

C生成带有动态链接库的可执行文件

D生成独立的可执行文件

答案：选 a

Pyinstaller命令的常用参数：

--clean：清理打包过程中的临时文件

-F，--onefile：在dist文件夹中只生成独立的打包文件

通过PyInstaller模块可以将源程序打包成为可执行文件，并且会自动将依赖的库一并打包，可以通过设置参数删除生成的临时文件，但是如果程序中对外部数据如图片之类的有调用，就必须自行导入到相应的目录。

46.以下关于文件的描述，错误的是

A以文本方式读打开一个文件，读入后能对文件进行写操作

B以文本方式打开一个空文件，追加方式写入文件，参数用'a+'

C以文本方式写打开一个文件，不能对文件进行读操作

D打开文件的参数'+'，表示在原打开模式基础上，可以对文件进行读写

答案：选 a

以文本方式读打开一个文件，该文件是只读状态，不能进行写操作。

47.以下语句的执行结果是______。

with open('A．txt','w+') as fo:

fo.write('hello')

print(fo.read())

A出现读写异常

B读文件的函数没有从文件里读到字符串

C写到文件a. txt里一个'hello'字符串，显示在屏幕上一个'hello'字符串

D写到文件a. txt里一个'hello'字符串

答案：选 d

with open('a.txt','w+') as fo:将文件以读写方式打开，并且读写完会自动关闭，不需要用close语句来关闭。

as fo打开文件并命名为fo，fo就等价于是这个文件

fo.write('hello')语句的作用是写到文件a.txt里一个'hello'字符串。

print(fo.read())输出时，文件指标已经指向最末尾了，所以屏幕上没有输出。

48.以下关于数据维度的描述，不正确的是

A二维数据处理等同于二维列表的操作

B要处理二维数据的每个元素，需要用循环结构处理

C二维数据用CSV文件格式存储，得用二重循环嵌套实现

D CSV文件里是用英文半角逗号来分隔数据元素

答案：选 c

逗号分隔的存储格式叫作CSV格式（逗号分隔值），是一种通用的、相对简单的文件格式，用途广泛，主要用于不同程序之间的数据交换；

CSV文件不需要特定的字符编码；

CSV文件的每一行是一维数据，整个CSV文件是一个二维数据；

一维数据和二维数据都可以使用CSV格式保存成CSV文件。

二维数据并不是一定要用二重循环嵌套格式存储，说法太绝对。

49.以下选项不属于Python的pip工具的功能是

A打包python源代码

B安装第三方python库

C卸载已经安装了的第三方库

D对第三方库进行基本的维护

答案：选 a

Pip工具可以安装第三方python库；

卸载已经安装了的第三方库；

对第三方库进行基本的维护。

打包使用Pyinstaller工具。

50.以下关于文件的描述，错误的是

(A) open函数的打开模式'a' 表示可以对文件进行追加操作

(B) fo. seek ()函数是设置当前文件操作指针的位置

(C)打开文件时，编码方式是可选参数

(D) open() 函数的打开模式't'表示以二进制打开文件

答案：选 d

打开模式'b'表示以二进制打开文件

t是文本文件

51.以下程序的输出结果是( )

def maxmin(a=10, b=5, c=2):

return max(a, b, c) + min(a, b, c)

print(maxmin(1, b=10))

A、7

B、6

C、11

D、12

答案 : C

题目中定义函数maxmin),使用3个含有默认值的形参，函数返回值为三个值中的最大值加上最小值。调用函数，传入两个实参，一个位置参数传递给a,一个关键字参数传递给b，运行函数比较大小，得到最大值10加上最小值1，所以答案为11。

52.以下程序的输出结果是()

d={"A":10, "B":2, "C":100, "D":9, "E":-10}

s=0

for i in d:

if d[i]> 2:

continue

s += d[i]

print(s)

A、111

B、119

C、121

D、-8

答案 : D

程序遍历字典d,变量i依次是"A"、"B"、 "C"、 "D"、 "E"，内部分支语句对字典d的值进行判断，如果键i对应的值大于2，则不执行后面语句，直接遍历下一个元素，最后循环结束，s=-8。

53.变量Is=[1,2,3,4,5,6,7,8,9],以下执行结果是123456789的选项是( )

A. print("join(str(,strspt"(")"split("," "))

B、print(" join(str(s)))

C、print("".join(s))

D、print(". joinis(s),split(：)))

答案 : A

先将列表Is通过str)函数转化为字符串形式"[1,2,3,4,5,6,7,8,9]"，然后用strip()方法去除首尾的中括号，得到"1,2,3,4,5,6,7,8,9", 接下来通过split()方法以逗号切割成列表[1;2;3,4;5,6;7";8';9]，最后使用join()方法拼接。

54.以下程序的输出结果是()

s =["seashell","gold","pink" ,"brown","purple","tomato"]

print(len(s),min(s),max(s))

A、5 pink brown

B、6 seashell gold

C、6 brown tomato

D、5 purple tomato

答案 : C

len()函数返回数据的长度 ; min()函数返回数据的最小值;

max()函数返回数据的最大值。观察数据可以知道len()函数返回的是6，min()函数返回的是"brown", max()函数返回的是"tomato"。

55.补充以下程序,输出随机列表元素的最大值的选项是()

import random as r

listV= 0

r.seed(100)

for i in range(10):

i= r.randint(100,999)

listV.append(i)

A. print(max(listV))

B、print(listV.max()

C、print(listV.pop())

D、print(listV .reverse())

答案 : A

考核列表的操作方法及操作函数，max()函数返回数据的最大值; max()方法不存在; pop()方法随机删除一个元素，并返回; reverse()方法将列表逆序，所以选择A选项。

56.以下关于文件的描述，错误的是( )

A、open() 函数的打开模式t表示以二进制打开文件

B、打开文件时,编码方式是可选参数

C、fo.seek()函数是设置当前文件操作指针的位置

D、open函数的打开模式'a'表示可以对文件进行追加操作

答案 : A

open()函数打开模式有多种，'b代表以二进制形式打开文件，t代表以文本文件形式打开文件，'a'代表可以对文件进行追加操作，打开文件时还可以用encoding参数设置编码，在对文件进行操作的时候，指针可以由seek()方法进行控制。

57.执行以下程序后，文件a.txt中的内容是( )

fo = open("a.t",'W')

x= [大学",',中学',' ,小学]

fo.write('n'join(x))

fo.close()

A、大学\n中学\n小学

B、大学中学小学

C、'大学','\n';'中学','\n','小学'

D、大学

中学

小学

答案 : D

题目中程序将列表x通过join()方法以换行符作连接符拼接，所以得到的字符串为大学In \n中学\n \n小学，写入文件后展示时，会将换行符自动变为换行。

58.以下方法不是python文件操作的选项是()

A. seek()

B、socket()

C、close()

D、readlines()

答案 : B

seek()方法是控制文件操作的指针; socket()方法是用来创建套接字不属于文件操作; close()方法是关闭文件; readlines()方法是用来读取文件内容。

59.以下关于数据组织的维度，以下选项中描述错误的是()

A. JSON格式能够表达一维数据

B、字典类型可以表示具有复杂关系的高维数据

C、列表只能表示一维数据

D、CSV文件可以用来存储二维数据

答案 : C

JSON格式可以表示高维数据也可以表示一维数据;

Python中的字典形式类似于JSON格式;

列表类型可以表示一维数据，也可以通过多层列表表示二维数据;

CSV文件可以用来存储一维数据或二维数据。

60.turtle库的控制顺时针转的函数是()

A. penup()

B、set()

C、right()

D、pencolor()

答案 : C

penup()函数提起画笔，之后移动画笔不会绘制轨迹;

turtle中没有set()函数;

right()函数使画笔的指向沿着顺时针方向旋转一定的角度;

pencolor()函数设置画笔绘制轨迹的颜色。

61.关于以下代码执行结果的描述，正确的选项是()

chinesetime = {'夜半:子时;鸡鸣':'丑时"，'平旦:寅时",

'日出':'卯时','食时':'辰时','隅中':'巳时',

'日中':'午时','日跌':'未时','哺时':'申时',

'日入':'酋时','黄昏':'戌时';'人定':'亥时'}

time = chinesetime.pop('黄昏';'失败')

print(chinesetime)

A、程序输出一个字典，其中，键为"黄昏"的值被修改为"失败"

B、程序输出一个字典，其中，键为"黄昏"的键值对被删除

C、程序执行后，time变量的值是{"黄昏":"戌时"了

D、程序执行后，time变量的值是{"黄昏":"失败"了

答案 : B

字典的pop()方法是寻找字典中是否存在与第一个参数相同的键，存在即删除该键值对，并返回对应的值;不存在就返回第二个参数。题目字典中存在字符串黄昏这个键，所以删除对应键值对，并返回字符串戌时赋值给time.本题选择B选项。

62.关于列表操作函数的描述，正确的选项是( )

A、Is1=Is2将列表Is2的元素追加到列表Is1

B、ls.insert(x)将x插入到列表ls的娓

C、min(Is)返回列表ls的最大元素

D、','.join(Is)将列表ls的元索用逗号连成一个字符串

答案 : D

A选项错误，采用等号是直接将Is2的数据赋值给ls1。

B选项错误，列表的insert()方法必须要有两个参数，第一个参数是插入的位置，第二个参数是插入的元素。

C选项错误，min()函数返回的是最小值。

D选项正确，join()方法是利用调用自身方法的字符拼接括号内参数的各个元素，最后返回拼接过后的字符串。本题选择D选项。

63.以下代码的执行结果是()

Is= [12, 34, 56, 78]

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

def func():

Is=It

print(Is)

func()

print(Is)

A、

1,2,3, 4,5

12, 34, 56, 78

B、

1,2,3,4, 5

1,2,3,4, 5

C、

12, 34, 56, 78

12, 34, 56, 78

D、

12, 34, 56, 78

1,2,3,4,5

答案 : A

观察本题程序，在打印输出Is前调用了函数，函数内程序先将lt赋值给Is,然后输出s，所以函数内部的输出数据应该是[1,2,3,4,5]。所以排除C、D两个选项。因为在函数内部采用了赋值符号，所以函数内部的Is相当于是局部变量，那么外界全局变量的ls便不会被局部变量所影响，最后输出[12,34,56,78]。

64.关于Python列表及数据维度的描述，错误的选项是()

A、列表索值的范围是大于0小于列表长度的整数

B、列表能表示多维数据

C、二维数据可以看成是多个一维数据的组合

D、CSV格式文件既能保存一维数据，也能保存二维数据

答案 : A

列表可以正向索引，也可以逆向索引。

65.用于设置画布大小的turtle库函数是( )

A、turtlesize()

B、shape()

C、getscreen()

D、setup()

答案 : D

在Python语言中，turtle库没有turtlesize()函数。 shape()函数用于设置绘图箭头的形状。getscreen()函数返回一个TurtleScreen类的绘图对象，开启绘画。setup()函数打开一个自定义大小和位置的画布。

66.以下代码可能的执行结果是()

list1 = [河南', '四川，河北,辽宁]

list2 = [郑州,'成都"，'石家庄，"长春'，'济南']

d={}

for i in range(len(list1)):

d[ist1[i]] = list2[i]

print(d)

A、['河南'，'四川'，'河北'，'辽宁']

B、[('河南','郑州')，('四川', '成都')，('河北'，'石家庄')，('辽宁','长春')]

C、(['河南', "四川','河北'，'辽宁'])

D、{'河北':'石家庄','河南': '郑州','辽宁': '长春'，'四川': '成都'}

答案 : D

观察题目中代码，首先创建了两个列表，然后在循环中向字典中添加数据，以列表list1中的元素作为键，列表list2中的元素为值，且因为是以列表lit1的长度作为循环次数，所以只能生成四个元素的字典，最后得到字典为{河北: '石家庄，河南:郑州"，辽宁:'长春，四川:'成都"}。

67.执行后返回列表类型的方法是()

A、strip()

B、split()

C、replace()

D、lower()

答案 : B

strip()方法作用是去除首尾两端字符，返回值是去除后的字符串;

spit()方法作用是根据一个子串切割字符串，返回值是切割后剩下的元素组成列表;

replace()方法作用是替换字符串的字符，返回值是替换后的字符串;

lower()方法作用是将字符串所有的大写字母转化为小写字母，返回值是转化后的字符串。

68.执行以下代码后，a.txt文件里的内容是()

fo=open("a.txt",'w')

x=[天";地";人]

fo.writelines(','.join(x))

fo.close()

A、天,地,人

B、'天','地','人'

C、天,地,人,

D、'天','地','人',

答案 : A

观察题目中程序，首先打开文件，然后使用文件的writelines()方法写入数据，数据是列表x通过逗号连接内部所有元素，所以写入文件的字符串为"天，地，人"，因为写入文件不会含有引号，所以文件的内容为：天，地，人。

70.设置图形绘制速度的turtle库函数是()

A、goto()

B、speed()

C、speedup()

D、getturtle()

答案 : B

goto()是移动画笔位置的函数;

speed()是设置画笔移动速度的函数;

在turtle模块中没有speedup()函数和geturtle()函数。本题选择B选项。

71.关于文件的描述，错误的选项是()

A、readline()函数从文件中读入一行

B、Python程序退出后,拼文件自动关闭，不定需要close()函数

C、open()函数的参数'r'示对文件进行读操作

D、open()函数的参数'a'示只读文件

答案 : D

Python语言open()函数中"a"模式是写模式，文件不存在则创建，存在则在原文件最后追加内容。追加写模式

72.关于数据维度的描述，错误的选项是()

A、列表只能用来表示一维数据

B、二维数据可以看作多个一维数据的组合形式

C、字典可以示高维数据

D、CSV格式可以存储二维数据,每行使用英文半角逗号分隔各数据

答案 : A

Python语言中，列表类型可以表示一维、二维和多维数据。

73.不能返回列表类型的选项是()

A、s.split()

B、jeba.lcut()

C、jieba.cut()

D、list()

答案 : C

split()方法可以根据参数切割字符串并返回列表;

lcut()函数可以根据jieba库的内置词典将参数进行分词并返回列表;

cut()函数会生成一个可迭代的数据类型，在迭代的时候再进行分词;

list()函数将参数转变为列表数据类型。

74.正确的选项是( )

d = [(-0.71,0.6,1.0), (0.0,0.06,4.0), (0.71,0.6,8.0)]

for n in d:

print(_________)

填写空格,输出下述内容

-0.71 0.0 0.71

A、'{}.format(n[0]), end=' '

B、'{}'.format(n[0])

C、'{}/n'.format(n[0])

D、'{}\n'.format(n[0])

答案 : A

输出的三个数据均为d列表中单个元素的首位，且因为三个参数中间是以空格分隔，那么print()函数就需要设置end参数等于空格，即end=' '。所以本题选择A选项。

75.turtle库中，绘制圆弧的函数是( )

A、seth()

B、eclipse()

C、forword()

D、circle()

答案 : D

seth()函数是用来调整画笔指向的角度;

tuetle库中无eclipse()函数;

forword()函数是用来移动画笔;

circle()函数是用来绘制圆或者绘制圆弧的。

76.补充完整横线处代码，正确的选项是( )

以下代码将打印输出所有女生的名字:

d= {"张良":"男", "李明明":"女", "李华":"女", "张丽":"女"}

for key in d:

if_________== "女":

print(key)

A、d[key]

B、d.values(key)

C、get(key).value

D、d.value

答案 : A

输出所有女生的姓名。因为直接遍历字典相当于遍历字典的键，所以key是姓名，分支语

句中判断性别，所以可以通过字典[键]这种形式取到值，也就是d[key]。

77.关于执行结果的描述，正确的选项是( )

文件data.csv里的内容如下:

zhang,17,5

wang,10,2

li,19,3

执行以下代码

f= open('data.csv', 'r')

print(f.readlines())

f.close()

A、输出三行字符串

B、输出三行列表，每行列表里面有一个字符串元素

C、输出一行字符串，里面包括三个字符串

D、输出一行列表，里面包括三个字符串元素

答案 : D

打开文件并输出文件通过readlines()方法读取的数据，readlines()方法读取文件全部行内容，每一行内容形成一个字符串，所有字符串组成一个列表。

78.文件a.txt的内容如

1,2, 3, 4

以下代码的执行结果是( )。

f= open('a.txt,'r')

print(f.read().split(','))

f.close()

A. '1','2','3', '4'

B、[1,2,3,4]

C、['[1', '2', '3','4]']

D、1,2,3, 4

答案 : C

打开文件并将read()方法读取的内容通过split()方法以逗号切割，然后将切割的数据输出。

文件内容是"[1, 2, 3, 4]',通过逗号切割得到的数据为[[1', '2', '3','4]所以输出为['[1', '2', '3', '4]']。

79.关于数据维度的描述，错误的选项是( )

A、一维数据由对等关系的有序或无序数据构成

B、列表只能存储二维数据

C、二维数据可以看成是多个一维数据的组合形式

D、.txt格式文件可以存储一维数据和二维数据

答案 : B

列表可以存储一维数据，也可以嵌套列表存储二维数据。

80.turtle库中设置画笔宽度的函数是( )

A、turtlesize()

B、pen()

C、write()

D、width()

答案 : D

在turte库中turtlesize()函数返回当或设置笔的属性x或y-stretchfactors和轮廓;

pen()函数用于通过一些键/值对在"pen-dictionary"中返回或设置笔的属性;

write()函数在屏幕上绘制文本;

width()函数设置画笔的宽度。

生态共48题

1.在Python语言中，包含矩阵运算的第三方库是

A wxPython

B PyQt5

C wordcloud

D nunpy

答案：选 d

numpy是Python的一种开源数值计算扩展第三方库，用于处理数据类型相同的多维数组，简称"数组"。

这个库可用来存储和处理大型矩阵，比Python语言提供的列表结构要高效得多。

numpy提供了许多高级的数值编程工具，如矩阵计算、矢量处理、N维数据变换等。

2.在Python语言中，能够处理图像的第三方库是

A PIL

B pyserial

C requests

D pyinstaller

答案：选 a

PIL库是Python语言在图像处理方面的重要第三方库，支持图像存储、处理和显示，它能够处理几乎所有的图片格式，可以完成对图形的缩放、剪裁、叠加以及向图像添加线条、图形和文字等。

PIL库可以完成图像归档和图形处理两方面功能需求。

3.在Python语言中，不属于Web开发框架第三方库的是_

A Django

B Flask

C Mayavi

D Pyramid

答案：选 c

Python语言中Web开发框架第三方库有：Flask、Django、Pyramid。

而mayavi是python语言中数据可视化方向的第三方库。

4.在Python语言中，属于网络爬虫领域的第三方库是

A PyQt5

B numpy

C openpyxl

D scrapy

答案：选 d

Python网络爬虫领域的第三方库：scrapy和request。

numpy是Python语言中数据分析方向的第三方库，

openpyxl是python语言中文本处理方向的第三方库，

PyQt5是Python语言中用户图形界面方向的第三方库。

5.在Python语言中，用于数据分析的第三方库是

A PIL

B pandas

C Django

D flask

答案：选 b

Python语言中数据分析方向的第三方库：numpy、scipy、pandas，

而PIL第三方库可以完成图像归档和图形处理两方面功能需求。

6.在Python语言中，不属于机器学习领域第三方库的是

A MXNet

B Tensorflow

C PyTorch

D Arcade

答案：选 d

Aracde是python语言中的图形库。

7.以下不属于Python数据分析领域第三方库的是

A scrapy

B numpy

C pandas

D matplotlib

答案：选 a

scrapy是Python语言中网络爬虫方向的第三方库，

而numpy、scipy、pandas是Python语言中数据分析方向的第三方库，

matplotlib是数据可视化方向的第三方库，也属于数据分析领域。

8.在Python语言中，用来安装第三方库的工具是

A PyQt5

B pygame

C pip

D pyinstaller

答案：选 c

Python语言中第三方库有三种安装方式：pip工具安装、自定义安装、文件安装。

而pygame、PyQt5、pyinstaller是python语言中的第三方库。

9.以下属于Python机器学习领域第三方库的是_

A Scikit-learn

B numpy

C pygame

D pandas

答案：选 a

Python语言中机器学习方向的第三方库有Tensorflow、Theano、scikit-learn，

而numpy、pandas是数据分析方向的第三方库，

pygame是游戏开发方向的第三方库。

10.不属于Python开发用户界面第三方库的是

A WXpython

B PyQt5

C turtle

D pygtk

答案：选 c

Python语言中开发用户界面方向的第三方库：PyQt5、wxPython、PyGTK，

而turtle库是python的标准库之一。

11.不属于Python数据分析及可视化处理第三方库的是

A mxnet

B pandas

C mayavi2

D Numpy

答案：选 a

Python语言中数据分析方向的第三方库：numpy、scipy、pandas。

Python语言中数据可视化分析方向的第三方库：matplotliB、TVTK、mayavi。

mxnet是Python语言中深度学习方向的第三方库。

12.不属于Python用于Web开发第三方库的是

A flask

B django

C scrapy

D pyramid

答案：选 c

Python语言中Web开发框架第三方库有Flask、Django、Pyramid，

而scrapy是python网络爬虫方向的第三方库。

13.用Pyinstaller工具打包Python源文件时-F参数的含义是

A指定所需要的第三方库路径

B在dist文件夹中只生成独立的打包文件

C指定生成打包文件的目录

D删除生成的临时文件

答案：选 b

Pyinstaller命令的常用参数：

-h，--help：查看帮助

--clean：清理打包过程中的临时文件

-D，--onedir：默认值，生成dist目录

-F，--onefile：在dist文件夹中只生成独立的打包文件

-i<图标文件名.ico>：指定打包程序使用的图标（icon）文件

14.第三方库Beautifulsoup4的功能是_

A解析和处理HTML和XIL

B支持web应用程序框架

C支持webservices框架

D处理http请求

答案：选 a

Beautifulsoup4库，也称为Beautiful Soup库或bs4库，用于解析和处理HTML和XML。

15.以下关于turtle库的描述，错误的是_

A seth(x)是setheading (x)函数的别名，让画笔旋转x角度

B home()函数设置当前画笔位置到原点，方向朝上

C可以用importturtle来导入turtle库函数

D在import turtle之后，可以用turtle. circle()语句画一个圆圈

答案：选 b

home()设置当前画笔位置为原点，朝向东。

16.用Pyinstaller工具把Python源文件打包成一个独立的可执行文件，使用的参数是

A -D

B -F

C -L

D -i

答案：选 b

Pyinstaller命令的常用参数：

-h，--help：查看帮助

--clean：清理打包过程中的临时文件

-D，--onedir：默认值，生成dist目录

-F，--onefile：在dist文件夹中只生成独立的打包文件

-i<图标文件名.ico>：指定打包程序使用的图标（icon）文件

17.random库采用更多随机数生成算法是_

A线性同余法

B蒙特卡洛方法

C梅森旋转算法

D平方取中法

答案：选 c

random库采用梅森旋转算法（Mersenne twister）生成伪随机数序列，可用于除随机性要求更高的加解密算法外的大多数工程应用。

18.turtle画图结束后，让画面停顿，不立即关掉窗口的方法是_

A turtle. clear ()

B turtle. setup()

C turtle. penup ()

D turtle. done ()

答案：选 d

turtle.setup()：设置主窗体的大小和位置

turtle.penup()：提起画笔

turtle.clear()：清空当前窗口，但不改变当前画笔的位置

9.以下用于计算机视觉领域的Python第三方库是_

A OpenCV-Python

B Matplotlib

C Flask

D PylMongo

答案：选 a

OpenCV是一个强大的图像和视频工作库。它提供了多种程序接口，支持跨平台（包括移动端）应用。

OpenCV除了对图像进行基本处理外，还支持图像数据建模，并预制了多种图像识别引擎，如人脸识别。

20.以下不属于数据分析领域的Python第三方库是_

A Nunpy

B Pandas

C PyQt5

D Seaborn

答案：选 c

PyQt5库是Python语言当前最好的GUI（用户图形界面）第三方库，它可以在Windows、Linux和MacOS X等操作系统上跨平台使用。

21.以下不属于人工智能领域的Python第三方库是

A PyOCR

B PyTorch

C MXNet

D Keras

答案：选 a

PyOCR是图像字符识别方向的第三方库

22.以下用于数据存储领域的Python第三方库是

A Luminoth

B Django

C NLTK

D redis-py

答案：选 d

Django：Web开发方向

NLTK：自然语言处理工具包

Luminoth：计算机视觉工具包

23.以下不属于网络爬虫领域的Python第三方库是_

A Scrapy

B SnowNLP

C Requests

D PySpider

答案：选 b

网络爬虫领域：Scrapy、Requests、PySpider。

SnowNLP用于处理中文文本内容。

24.以下不属于Web开发框架的Python第三方库是

A Django

B Tornado

C Pyramid

D Beautiful Soup

答案：选 d

Web开发方向：Tornado、Pyramid、Django。

25.turtle库的控制颜色的函数是

A goto()

B pendown()

C right()

D pencolor()

答案：选 d

pencolor()：设置画笔的颜色。

26.Python数据分析方向的第三方库是

A mayavi

B time

C tensorflow

D Numpy

答案：选 d

numpy、pandas是数据分析方向的第三方库。

Tensorflow是机器学习方向的第三方库

27.Python Web开发方向的第三方库是_

A PyQt5

B Tkinter

C Pygame

D Django

答案：选 d

Python语言中Web开发框架第三方库有Flask、Django、Pyramid。

28.关于beautiful soup4的描述，正确的选项是

A用于处理三维可视化

B用于绘制图形

C这个库能遍历处理HTML网页上的语法元素

D用于解析和处理HTML和XML

答案：选 d

Beautifulsoup4库，也称为Beautiful Soup库或bs4库，用于解析和处理HTML和XML。

29.关于pandas的描述，不正确的选项是

A不能用于金融数据分析

B是用于数据分析的第三方库

C是基于numpy扩展而来的第三方库

D能够高效的进行时间序列分析

答案：选 a

pandas是数据分析的一个核心框架，集成了数据结构化和数据清洗以及分析的一些方法。pandas在numpy的基础上新增了三个数据类型，Series、DataFrame、Panel。可以进行高效的时间序列分析以及金融数据分析。

30.以下不是Python深度学习方向的第三方库是

(A) MXNet

(B) Keras

(C)requests

(D) PyTorch

答案：选 c

Requests用于爬虫

31.以下不是Python web开发方向第三方库的是

(A) Pyramid

(B) PyQt5

(D) Django

答案：选 b

PyQt5做桌面软件的

32.以下不是Python数据可视化方向第三方库是

(A) vispy

(B) matplotlib

(D) ggplot

答案：选 c

TimeSide肯定和时间有关

33.Python机器学习方向的第三方库是

(A) tensorflow

(B) openpyxl

(D) PIL

答案：选 a

tensorflow是机器学习方向的第三方库

openpyxl是python语言中文本处理方向的第三方库，

Web开发框架第三方库有Flask

PIL库是在图像处理方面的第三方库

34.属于Python图像处理方向的第三方库是

(A) wxpython

(B) matplotlib

(D) opencv-python

答案：选 d

opencv-python是Python图像处理方向的第三方库

35.属于Python网络爬虫方向的第三方库是

(A)requests

(B) pillow

(D) NLTK

答案：选 a

requests是Python网络爬虫方向的第三方库。

NLTK是Python自然语言处理的第三方库。

pytorch是Python机器学习方向的第三方库。

pillow是Python图像处理的第三方库。

36.关于Pyinstaller工具，下列说法正确的是

(A)生成单独的可执行文件时，图片等文件资源不能一并打包到可执行文件中

(B)只能处理UTF -8编码形式的Python源文件

(C)不能为生成的可执行文件指定图标

(D)不能生成带有动态链接库的可执行文件

答案：选 b

Pyinstaller只能处理UTF -8编码形式的Python源文件

37.Python网络爬虫开发方向的第三方是()

A. Django

B、Theano

C、scrapy

D、Tkinter

答案 : C

Django是Web开发方向的第三方库；

Theano是机器学习方向的第三方库;

scrapy是网络爬虫方向的第三方库；

Tkinter是用户图形界面方向的第三方库。

38.关于以下代码的执行结果的描述，正确的选项是()

import random

a = random.randint(1, 100)

while (a < 50): .

a = random.randint(1, 100)

print(a)

A、执行错误

B、每次执行结果不完全相同

C、执行结果总是50

D、执行结果总是51

答案 : B

使用random库内的randint函数生成范围在1到100的随机整数，只要数字大于等于50，就输出出来，并结束程序，如果小于50，便一直通过循环获取新的随机数，直至数字大于等于50。因为本题未设置随机数种子，所以每次程序运行总会以运行的时间默认作为随机数种子，种子不同，产生的结果不同，并且只要a是大于50的数字都可以退出程序。

39.关于以下代码执行结果的描述，正确的选项是()

import random

a = random.randint(1, 100)

while not a:

if a<=50 and a>=40:

a = random.random()

break

print(a)

A、0.0到1.0之间的浮点数

B、1到100之间的整数或浮点数

C、1到100之间的整数

D、40到50之间的整数或浮点数

答案 : C

randint(1, 100)创建了一个在[1,100]的随机整数，循环条件设立为not a，因为数字a不可能为0，所以布尔值永远为True, 那么not a的布尔值就为False，即条件不成立，循环内语句不执行，直接执行后续输出语句，输出结果为1到100之间的整数。

40.属于Python数据分析方向的第三方库是()

A、pandas

B、Django

C、moviepy .

D、pefile

答案 : A

pandas是Python用于数据分析方向的第三方库;

Django是Python用于web开发方向的第三方库;

moviepy是Python用于视频编辑的第三方库;

pefile是Python用来专门解析PE文件的第三方库。

41.属于Python机器学习方向的第三方库是()

A、scikit-learn

B、SQLAlchemy

C、Click

D、requests

答案 : A

scikit-learn是Python用于机器学习方向的第三方库;

SQLAlchemy是Python用于操作数据库的第三方库;

Click是Python用于命令行操作的第三方库;

requests是Python用于网络爬虫方向的第三方库。

42.关于Python语言time标准库的描述，错误的选项是()

A、localtime()返回系统当前时间对应的struct_time形式

B、localtime(返回系统当前时间对应的时间戳

C、strftime()按照指定的格式返回易读字符串形式的时间

D、mktime()将struct_time对象转换成时间戳

答案 : B

在time库中，localtime()函数返回的是系统当前时间对应的struct_time形式。

43.下面属于Python文本处理方向的第三方库的是( )

A、PlL

B、mayavi

C、TVTK

D、pdfminer

答案 : D

mayavi和TVTK是数据可视化方向的第三方库，

PIL 是图像处理方面的第三方库。

44.属于Python文本处理方向的第三方库是()

A、beautifulsoup4

B、matplotlib

C、vispy

D、wxpython

答案 : A

beautifulsoup4库是用于文本处理方向的第三方库，用于处理网页信息;

matplotlib是用于数据可视化方向的第三方库;

vispy也是用于数据可视化方向的第三方库;

wxpython是用于图形界面方向的第三方库

45.属于Python网络爬虫方向的第三方库是()

A、myqr

B、numpy

C、scrapy

D、pillow

答案 : C

myqr是用于二维码制作的第三方库;

numpy是用于数据分析方向的第三方库;

scrapy是用于网络爬虫方向的第三方库;

pillow是用于图像处理的第三方库。

46.显示pip命令帮助信息的命令格式是()

A、pip-h

B、pip search <拟查询关键字>

C、pip install <拟安装库名>

D、pip download <拟下载库名>

答案 : A

pip -h是用于查询帮助信息的;

pip search是用于查询关键字的;

pip install是用于安装库的;

pip download是用于下载库的。

47.属于Python任务调度方向第3三方库的选项是( )

A、scrapy

B、doit

C、pandas

D、NLTK

答案 : B

scrapy是网络爬虫方向的第三方库;

doit是任务管理和自动化的第三方库;

pandas是数据分析的第三方库;

NLTK是自然语言处理的第三方库。

48.属于Python网络爬虫方向第三方库的选项是()

A、Click

B、scikit-learn

C、scrapy

D、pytorch

答案 : C

Click是用于快速创建命令行的第方库;

scikit-learn是用于机器学习的第三方库

scrapy是网络爬虫方向的第三方库

pytorch是用于深度学习的第三方库。

Python精选480题带解析

精选480道选择题

基础 共81题 带答案和解析

控制 共79题 带答案和解析

函数 共95题 带答案和解析

组合 共97题 带答案和解析

文件 共80题 带答案和解析

生态 共48题

基础共81题带答案和解析

控制共79题带答案和解析

函数共95题带答案和解析

组合共97题带答案和解析

文件共80题带答案和解析

生态共48题