SDUT：Python实验——Python基础填空题（参考答案）

1.Python 表达式 10 + 5//3 –True+False的值为（10）

解答：在Python中，表达式 `10 + 5//3 - True + False` 的计算需要考虑Python的运算符优先级和类型转换。

首先，`5//3` 会进行整数除法，结果是 `1`。

接着，`True` 和 `False` 在算术运算中会被转换为整数，其中 `True` 转换为 `1`，`False` 转换为 `0`。

因此，表达式可以重写为：10 + 1 - 1 + 0

现在，我们按照从左到右的顺序计算加法和减法：

最终结果是 `10`。

所以，Python 表达式 `10 + 5//3 - True + False` 的值为 `10`。

2.Python 表达式 3**2**3 的值为（6561）

解答：在Python中，指数运算符 ** 是右结合的，这意味着当你连续使用它时，它会从右向左计算。所以，表达式 3**2**3 的计算过程如下：
首先计算 2**3，得到 8。
然后，计算 3**8，得到 6561。
因此，3**2**3 的值为 6561。

3.Python 表达式 round(17.0/3**2,2) 的值为（1.89）

解答：在Python中，表达式 round(17.0/3**2, 2) 的计算过程如下：
首先计算 3**2，得到 9。
然后计算 17.0 / 9，得到约等于 1.8888888888888888（这是一个近似值，但由于浮点数的精度问题，实际结果可能略有不同）。
最后，round 函数将这个近似值四舍五入到小数点后两位，得到 1.89。
因此，round(17.0/3**2, 2) 的值为 1.89。

4.Python 语句 print(pow(-3, 2), round(18.67, 1), round(18.67, -1))的输出结果是（9  18.7  20）

解答：

在Python中，pow 函数用于计算一个数的幂，而 round 函数用于四舍五入一个浮点数到指定的小数位数或指定精度。
首先，我们分析各个部分的计算结果：

pow(-3, 2)：计算 -3 的平方，结果是 9。
round(18.67, 1)：将 18.67 四舍五入到小数点后一位，结果是 18.7。
round(18.67, -1)：将 18.67 四舍五入到最近的十位，结果是 20。

然后，print 函数会按照顺序输出这些结果，默认用空格分隔。
因此，print(pow(-3, 2), round(18.67, 1), round(18.67, -1)) 的输出结果是：9 18.7 20
注意，具体的输出格式可能会受到你使用的Python环境或IDE的影响，但结果的值应该是相同的。

5.Python 语句 print(int("20", 16), int("101",2))的输出结果是（32 5）

解答：

在Python中，int() 函数用于将一个字符串或数字转换为整数。这个函数可以接受两个参数：要转换的值和转换的基数（或进制）。
对于语句 print(int("20", 16), int("101", 2))：

int("20", 16)：这部分将字符串 "20" 从十六进制转换为十进制。在十六进制中，"20" 等于十进制的 32。
int("101", 2)：这部分将字符串 "101" 从二进制转换为十进制。在二进制中，"101" 等于十进制的 5。

因此，print(int("20", 16), int("101", 2)) 的输出结果是：32 5
这两个整数值会依次打印出来，中间可能有一个空格或其他分隔符，具体取决于你的输出环境和设置。

6.已知 a=3; b=5; c=6; d=True, 则表达式 not d or a>=0 and a+c>b+3的值是（True）

解答：首先，我们已知 a=3, b=5, c=6, d=True。
接下来，我们按照Python的逻辑运算符优先级来解析表达式 not d or a>=0 and a+c>b+3：

not d：由于d是True，not d的结果为False。
a>=0：由于a是3，所以a>=0的结果为True。
a+c>b+3：计算得a+c=9，b+3=8，所以a+c>b+3的结果为True。

现在，我们根据逻辑运算符的优先级（not > and > or）来组合这些结果：

a>=0 and a+c>b+3：由于a>=0和a+c>b+3都是True，所以整个表达式的结果也是True。
not d or (a>=0 and a+c>b+3)：由于not d是False，而a>=0 and a+c>b+3是True，or运算符只要有一个操作数为True，结果就为True。

所以，整个表达式 not d or a>=0 and a+c>b+3 的值为True。

7.Python 语句 x=True; y=False; z=False; print(x or y and z) 的程序运行结果是（True）

解答：在Python中，逻辑运算符 and 和 or 的优先级是：and 的优先级高于 or。同时，逻辑表达式会遵循短路求值（short-circuit evaluation）原则，即如果某个子表达式的结果已经能够决定整个表达式的结果，那么就不会继续计算其他的子表达式。
对于表达式 x or y and z，首先会计算 y and z，因为 and 的优先级更高。由于 y 是 False，y and z 的结果直接就是 False，不论 z 的值是什么（因为 False and anything 都是 False）。
然后，由于 or 运算符的一个操作数 x 是 True，True or anything 的结果都是 True，因此整个表达式 x or y and z 的结果就是 True。
所以，Python 语句 x=True; y=False; z=False; print(x or y and z) 的程序运行结果是：True

8.Python 语句 x=0; y= True; print(x>=y and‘A'<'B') 的程序运行结果是（False）

解答：

在Python中，比较运算符 <、<=、>、>=、== 和 != 用于比较两个值的大小或是否相等。当比较一个整数和一个布尔值时，Python会将布尔值 True 视为 1，False 视为 0。
对于语句 x=0; y=True; print(x>=y and 'A'<'B')：

首先，x 被赋值为 0，y 被赋值为 True。
然后，表达式 x>=y 被计算。由于 x 是 0，y 被视为 1，因此 0 >= 1 是 False。
接下来，表达式 'A'<'B' 被计算。显然，'A' 小于 'B'，因此这个表达式的结果是 True。
最后，整个表达式变为 False and True。在逻辑与操作中，只要有一个操作数为 False，整个表达式的结果就是 False。

因此，print(x>=y and 'A'<'B') 的输出结果是：False

9.Python 表达式 16-25>78/2 or "XYZ"!="xyz" and not (10-6>18/2) 的值是（True）

解答：

在Python中，这个表达式包含多个比较和逻辑运算符。我们按照运算符的优先级（括号 > not > and > or）来逐步解析这个表达式。
首先，处理括号内的表达式：

18/2 等于 9。
10-6 等于 4。
4 > 9 是 False。

接下来，处理 not 运算符：

not (4 > 9) 变成 not False，结果是 True。

然后，处理 and 运算符：

"XYZ"!="xyz" 是 True，因为字符串 "XYZ" 和 "xyz" 不相等。
"XYZ"!="xyz" and True 仍然是 True，因为 and 运算符的两个操作数都是 True。

最后，处理 or 运算符：

16-25 等于 -9。
-9 > 78/2 是 False，因为 78/2 等于 39，而 -9 显然不大于 39。
False or True 是 True，因为 or 运算符只要有一个操作数为 True，结果就是 True。

因此，整个表达式 16-25>78/2 or "XYZ"!="xyz" and not (10-6>18/2) 的值是 True。

10.表达式 ((2>=2) or (2<2)) and 2 的值为（2）

解答：

在Python中，表达式 ((2>=2) or (2<2)) and 2 的值可以通过以下步骤计算：

首先计算括号内的表达式：

2>=2 是 True，因为2确实大于或等于2。
2<2 是 False，因为2并不小于2。

然后使用 or 运算符组合这两个结果：

True or False 的结果是 True，因为 or 运算符只要有一个操作数为 True，结果就是 True。

最后，使用 and 运算符将上一步的结果与 2 组合：

True and 2 的结果并不是简单地 True 或 2。在Python中，and 运算符会返回其第一个为 False 的操作数（如果存在），否则返回最后一个操作数。因为 True 不是 False，所以结果是 2。

因此，表达式 ((2>=2) or (2<2)) and 2 的值为 2。

11.表达式 3 and 0 and 5的结果是（0）

解答：

在Python中，使用and运算符连接多个值时，and运算符的行为稍有特殊。当使用and来连接数值时，它会返回其操作数中的最后一个为True的值（在布尔上下文中）。如果所有值在布尔上下文中都为False，则and会返回最后一个操作数。
对于表达式3 and 0 and 5：

3在布尔上下文中是True。
0在布尔上下文中是False。

由于and运算符是短路的，当遇到第一个False值（在这里是0）时，它就不会继续评估后面的值。因此，and运算符会返回导致其结果为False的第一个操作数，即0。
所以，表达式3 and 0 and 5的结果是0。

12.表达式 --3 的结果是（3）

解答：在Python中，--3 的操作实际上是先对 3 进行一次负号操作，得到 -3，然后再对 -3 进行一次负号操作。负负得正，所以 --3 的结果是 3。
这个操作等同于 -(-3)，也就是 3。

13.表达式 32.2//6-24//6 的值是（1）

解答：

在Python中，// 是整数除法运算符，它返回商的整数部分，忽略小数部分。对于表达式 32.2//6-24//6，我们首先分别计算两个整数除法，然后再进行减法运算。
32.2//6：尽管 32.2 是一个浮点数，但 // 运算符会将其当作整数来处理。因为 32 除以 6 的整数部分是 5，所以 32.2//6 的结果是 5。
24//6：24 除以 6 的整数部分也是 4，所以 24//6 的结果是 4。
然后，我们进行减法运算：5 - 4 = 1。
因此，表达式 32.2//6-24//6 的值是 1。

14.Python 表达式 0 and 1 or not 2<True 的值为（True）

解答：

在Python中，表达式 0 and 1 or not 2<True 的值可以通过以下步骤计算：
2<True：在Python中，True和False在布尔上下文中分别等同于1和0。因此，2<True 实际上等同于 2<1，其结果为 False。
not 2<True：由于 2<True 是 False，not False 的结果是 True。
0 and 1：由于 and 运算符的短路行为，当第一个操作数（0）为 False 时，整个表达式的结果就已经确定为 False，因此不会计算第二个操作数（1）。
0 and 1 or True：由于 0 and 1 的结果是 False，or 运算符会返回其第二个操作数，即 True。
因此，Python表达式 0 and 1 or not 2<True 的值为 True。