全国计算机等级考试二级Python易错真题详解-数值类型

数值类型（单选题）

说明：

• 本文中的题目，全都来自全国计算机等级考试二级Python语言程序设计考试的真题，且都为易错题。题干最后如有编号，则是 python123 平台上的题号，以方便学生查找和索引。

• 在满分为 100 分的二级Python考试中，单选题总共占 40 分。本文 为Python语言中数值类型相关的解析，这部分一般占 3 - 4分 左右。

• 面向对象：Python 学习爱好者、Python 二级备考的大学生

之前相关文章在这儿：

• 2024全国计算机等级考试二级Python易错真题详解-Python语言基础-单选题
  

• Python中为什么“四舍五入”函数round(1.5)等于2，而round(2.5)也等于2？！round()函数详解
  

以下关于二进制整数的定义，正确的是(      )。(#168604)

A. 0bC3F

B. 0b1708

C. 0B1019

D. 0B1010

参考答案：0B1010

解析：

所谓“十进制”是指“逢十进一”，十进制数只能由 0、1、2、3、4、5、6、7、8、9 这10个字符构成；9再往上到10的话，就是9上进位，变成前面是1后面是0，即10；而所谓的“二进制”是指“逢二进一”，那么相应的，构成二进制数的符号，最多只有两个：0和1。

选项中符合这一标准的只有 0B1010。Python中， 0B 或 0b 是二进制数开头必须要有的标记。

下面属于整数类 int 的实例是(      )。(#168650)

A. 919E+3

B. 0.919

C. -919

D. 919D-2

参考答案：-919

解析：

Python中的整数就是常见的：0、-3、123 这些形式；

包含大写 E 或小写 e 的数值，是用科学计数法表示的，记住：它们都是浮点数，属于浮点类型（float），如本例中的 919E+3，实际上是浮点数 919000.0；

选项 919D-2 是错误的，Python中目前尚没有这种计数方式。

以下代码的执行结果是(      )。(#169695)

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.71828182459 is not int.

C. 2.72 is int.

D. 2.72 is not int.

参考答案：2.72 is not int.

解析：

2.71828182459 是一个小数（浮点数），赋值给变量 a 之后，再用 isinstance(a, int) 函数去判断a是否是整数类型中的一个实例，当然这儿应该返回 False（假）；同时，round(a,2) 是对浮点数 a 取保留小数点后两位，那就是 2.72 。

x=2.6，表达式 round(x) 的结果是(      )。(#168572)

A. 2.6

B. 2

C. 3

D. 2.0

参考答案：3

解析：

Python的 round() 内置函数，对于二级考试来说，一般只要记住 “四舍六入” 就够了。这题中，round(2.6)只有一个参数，没有精度，就是默认的取整数，小数点后保留 0 位。因为小数点后是 "6"，则按照“四舍六入”的原则进一位，就有了：2+1 的结果为 3 。对于 “五” 的情况下，到底是应该“入”，还是“舍”，相对复杂，之前 有一篇长文详细解读 了，感兴趣的可以去看下。

链接：https://www.toutiao.com/item/7391499540970357282/ https://mp.weixin.qq.com/s/v15Hp-X4MtW9p3S53pJ4Dw

以下关于 Python 语言浮点数类型的描述中，错误的是(      )。(#170637)

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

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

C. 小数部分不可以为 0

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

参考答案：小数部分不可以为 0

解析：

Python中浮点数的小数部分可以为0，如：10.0。其它选项都对。“Python 语言要求所有浮点数必须带有小数部分” 中的 “小数部分” 指的是必须要有小数点，如 10. 就是一个浮点数，而非整数 10 。

以下代码的输出结果是(      )。(#168795)

print(0.1 + 0.2 == 0.3)

A. True

B. False

C. -1

D. 0

参考答案：False

解析：

这题，是要判断 0.1 与 0.2 的和是否等于 0.3，如果是，则输出True（真），否则的话输出False（假）。具体执行步骤可以看下面的动图，先算(0.1+0.2)，再跟 0.3 做是否相等的比较。

计算机中，十进制浮点数并非每一个都能被无损地转换到一个二进制浮点数，这在之前的文章中也解释过；因此对于有的小数（浮点数）来说，它们在计算机中存在尾数误差。

计算机中的数据，都是采用 二进制 的方式进行存储和运算的；而程序中看到的 0.1、0.2和0.3，则是写给人看的，是 十进制 的。

每一个十进制的整数，都可以表示成一个有限的二进制数。如十进制的 13 ，可以表示成二进制的 1101 ；但并非每一个十进制的小数，都能转换成一个有限的二进制小数；只有当十进制小数能够表示为 2的负幂次之和 时，它才能被表示为有限的二进制小数。否则，它将是一个无限循环的二进制小数。十进制的0.1在二进制中表示为0.0 0011 0011 0011 0011…（其中 “0011” 这个序列无限循环），而十进制的0.2在二进制中表示为0.0110 0110 0110 0110…（其中 “0110” 这个序列无限循环）。

因为没有一个有限的二进制数能够精确地表示成十进制的 0.1 和 0.2 ，而目前的计算机都是有精度限制的（32位、64位之类），因此，这些数字在计算机中存储的就不是刚刚好，而是一个 近似值 ，或者比实际的十进制数略小一点，或者略大一点。

因此，0.1+0.2 在数学上虽然等于 0.3，但在计算机中却非 0.3，而是一个近似的值（略大一点）：

n = 0.1+0.2print(n)#实际输出：0.30000000000000004，不等于0.3

因此，计算机中 0.1+0.2 是略大于 0.3 而不等于 0.3，所以 (0.1 + 0.2 == 0.3) 这个表达式的值为 False。

再进一步：

如果就要比较 0.1+0.2 和 0.3 的大小，且结果为相等，应该怎么办呢？可以有多种方法，此处暂介绍两种常用的：

方法1：

可以通过判断两个数值的差的绝对值是否小于一个很小的数来近似判断，如：abs((0.1+0.2)-0.3) < 0.00000001，如果满足条件，就可以视作（近似）相等；

方法2：

用其它的精确计数的库/方法。如利用Python自带的 ** 0.1+0.2 是略大于 0.3 而** 库，把小数用字符串形式表示，后面就可以无损地进行精确的计算，代码如下：

from decimal import Decimal
# 使用Decimal来表示数值，默认精度足够a = Decimal('0.1')b = Decimal('0.2')c = Decimal('0.3')
# 判断result = a + b == cprint(result)  # 输出 True

以下代码的执行结果是(      )。(#168862)

x = 4+3jy = -4-3jprint(x + y)

A. 0j

B. 0

C. <class 'complex'>

D. 无输出

参考答案：0j

解析：

复数运算之后的结果仍然是一个复数，哪怕是0，也是复数形式的：0j，而非整数形式的0。

在 Python 语言中，使用 for..in.. 方式的循环，不能遍历的类型是(      )。(#169594)

A. 字典

B. 列表

C. 浮点数

D. 字符串

参考答案：浮点数

解析：

for 单个元素 in 可迭代对象 形式的循环，in 后面需要的是可迭代类型的对象。在Python中，可迭代类型（Iterable）指的是那些可以一次返回(取出)一个元素的对象，元祖、列表、字符串、集合、字典、文件等都是可迭代对象，从中可以抽取出单个元素；而浮点数不行，所以for循环中浮点数不能用来遍历。

进阶学习：

可迭代对象的定义

一个对象如果实现了一个名为 __iter__() 的特殊方法，该方法就能返回一个迭代器，这个对象就是一个可迭代对象。迭代器是一个带有 __next__() 方法的对象，每次调用 __next__() 都会返回序列中的下一个元素。

常见的可迭代类型

• 列表（List）：Python中最常用的可迭代类型之一，可以通过索引来访问每个元素。
• 元组（Tuple）：元组与列表类似，但是它是不可变的。
• 字符串（String）：字符串也是可迭代的，每次迭代返回一个字符。
• 字典（Dictionary）：字典是可迭代的，默认情况下迭代的是键，但也可以迭代值或者键值对。
• 集合（Set）：集合是可迭代的，但迭代顺序是不确定的，因为集合是无序的。
• 文件对象（File Object）：文件对象是可迭代的，每次迭代返回一行。
• 生成器（Generator）：生成器是使用yield语句创建的函数，它们也是可迭代的。
• 自定义类的实例：如果在自定义的类中实现了__iter__()方法，那么这个类的实例也是可迭代的。

如何判断一个对象是可迭代的？

有好多种方法，这儿仅介绍几种常见的。

1. 可迭代对象通常都有一个 __iter__ 方法，可以使用内置函数 hasattr() 函数检查是否对象有 __iter__ 方法：

hasattr(obj, '__iter__')

2. 使用内置函数 isinstance，判断对象是否是 Iterable 的一个实例。collections.abc.Iterable是一个抽象基类，可以用于检查对象是否是可迭代的。

from collections.abc import Iterable
isinstance(obj, Iterable)

表达式 eval('500//10') 的结果是(      )。(#169889)

A. 500/10

B. 50.0

C. 50

D. '500/10'

参考答案：50

解析：

eval() 函数的作用是：将字符串参数两边的引号去除，剩下的部分作为一个Python表达式来执行，运算符//表示计算整数商，故 500//10 执行的结果为整数 50 ，非浮点数 50.0 。

表达式 eval("print(1+2)") 的结果是(      )。(#169579)

A. "print(1+2)"

B. print(1+2)

C. 1+2

D. 3

参考答案：3

解析：

同上例，先去除 eval() 字符串参数最外侧的引号后，然后把里面的部分当成一个 Python表达式 来执行，即执行 print(1+2)，结果就是：输出整数3。

在Python语言中，整数999的二进制、八进制、十六进制表达形式分别是(      )。(#169585)

A. 0b1111100111, 0o1747, 0x3e7

B. 1111100111, 1747, 3e7

C. b1111100111, o1747, x3e7

D. B1111100111, O1747, X3e7

参考答案：0b1111100111, 0o1747, 0x3e7

解析：

这题根本不需要计算。先看一眼答案，结果的数都一样，就是形式不同而已。二进制整数以 0b 或 0B 打头，八进制整数以 0o 或 0O 打头，十六进制以 0x 或 0X 打头；这样只有第一个选项满足。

表达式 int('100/3') 的执行结果是(      )。(#168669)

A. '100/3'

B. 33.3

C. 33

D. ValueError

参考答案：ValueError

解析：

跟下题相同

关于类型转换的描述，错误的选项是(      )。(#169694)

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

B. str(1+2j) 能将复数 1+2j 转换为字符串类型

C. int(1.23) 能将浮点数 1.23 转换为整数

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

参考答案：int('1.23') 能将字符串转换为整数

解析：

其它的都对，注意理解和记忆。内置函数 int() 的参数为字符串时，必须是10进制整数字符串，如 '-12'、'345' 等，否则会报错：ValueError: invalid literal for int() with base 10: '1.23'

表达式 divmod(40,3) 的结果是(      )。(#169871)

A. 1

B. 13,1

C. 13

D. (13,1)

参考答案：(13,1)

解析：

这题要注意的是，divmod() 函数返回的是一个元组，而元组规范的表示是用圆括号括起来的，所以答案是 (13, 1) 而非 13,1。

divmod(a, b)以两个（非复数）数字为参数，在作整数除法时，返回商和余数。若操作数为混合类型，则适用 二进制算术运算符的规则。对于整数而言，结果与 (a // b, a % b) 相同。

表达式 3+5%6*2//8 的值是(      )。(#168585)

A. 4

B. 5

C. 6

D. 7

参考答案：4

解析：

按照优先级，加上括号，其实是这样的运算优先级（顺序）：3+( ( (5%6)*2 )//8 )

表达式 3*4**2//8%7 的计算结果是(      )。(#170617)

A. 3

B. 6

C. 4

D. 5

参考答案：6

解析：

这题也是涉及 Python 中的优先级，如下，以表格形式从高到低，列出了各种符号的优先级；同一层中各个符号的优先级是相同的，代码运行时，优先级相同的，一般是按照从左到右的顺序来执行的，唯一一个例外是。

本题中，乘方 ** 的优先级最高， * 和 // 和 % 都是相同的优先级（就按从左到右来计算），所以 4**2 先计算得到 16 ，然后计算 3*16 得 48 ，再计算 48//8 得到 6，最后 6%7 得到 6 。

可以在Thonny中调试一下，看下如下动画展现的顺序：

好啦，整理了几天，终于又整理出一篇，效率太低了😭。如有疑问，欢迎留言！粉丝免费指导😄