Python Basics: PTA Problems

F。Python 的保留字不能作为变量名，else 是保留字。通过如下方法可以看到所有 Python 的保留字：

1
2
3

>>> import keyword
>>> keyword.kwlist
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']

F。print 是 Python 的内置函数，但是在这里被赋值为 3，因此将被作为一个整数变量看待，而不是函数。

因此会报错 TypeError: 'int' object is not callable。

F。报错 ValueError: invalid literal for int() with base 8: 'a'，因为 'a' 在八进制下是没有意义的。

需要了解 int(value, base) 函数中 value 和 base 的意义（见 Review - int），以及区分 a 和 'a' 的区别。

F。** 优先级高于 -。

F。再次注意，'a' 是一个字符常量，而 a 是一个变量。a 和 'a' 一般没有关联。

F。x=int(input()) 会报错 ValueError: invalid literal for int() with base 10: '10.0'。

注意 int 函数只能将字符串按整数进行解释，如果无法解释，将会报错。

F。id 函数返回对象的内存地址，x=7 与原来的 x=3 不是同一个对象了，内存地址会发生变化。

F。根据 int(value, base) 函数中 value 和 base 的意义（见 Review - int），会把 "92" 试图按照八进制进行解释，但是 '9' 不是八进制的数字，因此会报错 ValueError: invalid literal for int() with base 8: '92'。

F。用到了比较运算符的链接。

1
2
3
4

"34" in "1234"==True
= "34" in "1234" and "1234"==True
= True and False
= False

F。比较作为 int 的 2 和 float 的 2.0 时，2 会先被转换为 float 2.0，然后进行比较，即

1

2 == 2.0 -> 2.0 == 2.0 -> True

关于这种混合数值类型计算时的类型转换规则，可以参照 Review - 数值类型混合运算。

T。Python 是一种动态类型语言，变量的类型是在运行时确定的，不需要事先声明。

C。print 的 sep 参数默认为 " "。

BC。实部和虚部都是 float，虚部后缀可以是 j 或者 J。

ABD。

A，Python 中的标识符是区分大小写的，True 是保留字，但 true 不是保留字，是合法标识符。

B，print 是内置函数名，不是保留字，是合法标识符。

C，标识符不能以数字开头。

D，下划线开头的标识符是合法的。

标识符由字母、数字、下划线组成，但不能以数字开头。

CD。Python 变量名可以由字母、数字、下划线组成，但不能以数字开头。

B。列表越界错误。

1
2
3

1
False
TypeError: 'float' object cannot be interpreted as an integer

对于第二行，空列表转 bool 为 False，非空列表转 bool 为 True。特别地，bool([[]]) 也为 True。

对于第三行，bin, oct, hex都要求输入为 int，详见 Review - int。

先输出 A 和 65。chr 将 ascii 码转化为字符，ord 把字符转化为 ascii 码。

后报错 TypeError: can only concatenate str (not "int") to str。int 和 str 不能直接相加。

特别地，如果 print(x * y)，将会输出 dogdogdogdogdogdog，即字符串乘法的结果。

1
2
3
4

9
6561
32 5
3

1

8 + 8//3 - True + False = 8 + 2 - 1 + 0 = 9

1

3**2**3 = 3**8 = 6561

对于第四行，两个负号相互抵消了效果，所以又回到了原始的 3。

关于运算符优先级和结合性的内容可以去 Review - 运算符优先级与结合性查漏补缺。

1
2
3

21
True
6.0

对于第二行，先计算出大于号左侧为 7.42，然后和 0 比较，返回 True。注意运算顺序上大于号最后计算，最终返回值为 bool 类型。

对于输出的第三行，math 库中的 sqrt 函数的返回值为 float 类型，两个 float 相乘还是 float，因此按照 float 输出为 6.0。

1
2
3
4

True
True
Pythonbeginner
16.0

对于第一行，计算顺序为

1
2
3
4
5

0 and 1 or not 2<True
= 0 and 1 or not False
= 0 and 1 or True
= False or True
= True

对于第二行，计算顺序为

1
2
3
4
5
6

not d or a>=0 and a+c>b+3
= not True or 3>=0 and 3+6>5+3
= not True or True and True
= False or True and True
= False or True
= True

对于第三行，字符串拼接可以直接写在一起，不需要额外的 +；由于是拼接而不是作为两个参数输入 print，中间就没有空格。

对于第四行，20//4 的结果是 int 5，但是 43.5//2 的结果是 float 21.0，所以最后结果为 float 类型。

1
2
3

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: int() argument must be a string, a bytes-like object or a number, not 'list'

1

35

对于第二段程序，input().split() 返回的是字符串列表 ['3', '5']，所以 m+n 是字符串拼接，结果为 35。

1
2
3

<class 'str'>
<class 'int'>
ValueError: invalid literal for int() with base 10: '12.3'

对于第二段程序，int(input())->int('123')->123 返回 int 123，所以 type(a) 是 <class 'int'>。

对于第三段程序，int(input())=int('12.3') 会报错，因为 int 函数不能直接作用于字符串 '12.3'。

1
2
3

00003.14
NameError: name 'pi' is not defined
NameError: name 'math' is not defined

对于第二段程序，pi 没有被定义，会报错 NameError: name 'pi' is not defined。对于这种方式，需要 from math import pi。

对于第三段程序，尽管 from math import * 导入了 math 库中的所有函数和常量，但没有导入 math 这一名字，因此使用 math.pi 会无法识别 math。

1
2
3

<class 'complex'>
<class 'int'>
<class 'float'>

对于第二行，1//2 是两个 int 进行整除，所以还是返回 int。注意只要除数与被除数有一者是 float，结果就会变为 float。

对于第三行，121 + 1.21 是 int 加 float，返回 float。只要有 float 参与运算，结果就会变为 float。

a#c#e#g#。

每隔两个字符输出一个字符，并且由于 print 的 end 从默认的 '\n' 改为了 '#'，每个字符后面都会跟着一个 #。

1
2
3
4

True
True
False
True

1

True or False and False = True or False = True

对于第二行，有

1
2
3
4
5
6

16-25>78/2 or "XYZ"!="xyz"and not (10-6>18/2)
= -9>39 or "XYZ"!="xyz" and not 4>9
= False or True and not False
= False or True and True
= Flase or True
= True

对于第三行，有

1
2
3
4
5

((2>=2) or (2<2)) and 1<2>5
= ((2>=2) or (2<2)) and (1<2 and 2>5)
= (True or False) and (True and False)
= True and False
= False

对于第四行，有

1
2
3
4
5

False and 1 or not 2<False
= False and 1 or not False
= False and 1 or True
= False or True
= True

1
2

0x10 0b1010
32 5

对于第二行，按十六进制和二进制解释输入字符串，输出对应的十进制 int。

可以参考 Review - int。

F。可以通过下标访问，但是不能修改，因为字符串是不可变的。

F。

s1 的每个数字后面都有一个空格，s2 仅在各数字之间存在空格，因此 s1 在末尾比 s2 多了一个空格，输出为 no。

关于 join 可以回顾 Review - join: split 的逆操作。

F。[12, 12, 12] 是整数列表，输入给 join 会发生报错，无法得到正常输出。

关于 join 可以回顾 Review - join: split 的逆操作。

B。\ 是转义字符，如果要输出 \ 本身，需要使用 \\，所以 A 错 B 对。

C 是转义输出 " 的方法，会输出 I"love"Python.txt。

D 是错误的写法，会报错 SyntaxError: unexpected character after line continuation character。

B。通过转义 \ 使得 ' 失去代码中划定字符串的功能，成为字符串的一部分被输出。

A，三个 '，使得字符串字面量范围无法被清楚地划定，会报错。

C，raw string 可以免于大部分特殊字符的转义 \，但在此处 ' 是关键的划定字符串字面量范围的字符，因此在这里无法仅用 raw string 解决问题。

D，会输出 I"m python，不符合要求。但是如果用 print("I'm python") 可以实现功能。

关于 raw string 乃至字符串字面量的更多内容详见官方文档：String and Bytes literals - Python 3.12.3 documentaion

B。字符串以 \0 标志字符串的结束是 C 语言的特性，Python 中字符串以长度标志字符串的结束。

三引号字符串是一种特殊的字符串，会保留其中字符串的格式，也就是会包含其中的换行、回车等特殊字符。

1
2

676767
00011111

对于第二行，

• bin(31) 是将 int 类型的 31 转换为其二进制表示的字符串 '0b11111'
• [2:] 去掉了前缀 0b，得到字符串切片 '11111'
• 然后 {:>08s} 控制格式为靠右对齐，总长度为 8，不足的地方用 0 填充（即在左侧填充），所以输出的字符串为 '00011111'

1 2 3（1、2、3 前面都有 1 个空格）。经历 a, b, c = c, a, b 后，a=3, b=1, c=2；

"{1:2d}{2:2d}{0:2d}".format(a, b, c) 表示输出的顺序为 b, c, a，且各自占 2 个字符的宽度，不足宽度的部分（默认）在左侧填充空格。

1

 a c d e 

a = input().split() 后，有 a = ['', 'c', 'd', 'e', 'a']。

a.sort() 排序后，有 a = ['', 'a', 'c', 'd', 'e']。因此最后会得到这样的输出。

1
2
3
4
5
6

5
4
True
Aabcab
aabcab
2

对于第二行，找到第 2 个 "r" 的位置，即下标为 4。

对于第三行，判断 "aABC" 是否每个字符都是英文字母，所以为 True。

对于第四行和第五行输出，s.title() 是返回一个 s 中首字母变成大写之后的字符串，但并不改变 s 本身（字符串不可变）。

对于第六行输出，统计 s 中子串 'ab' 的数量，那就是 2。

1

4:12:10

0, 2, 1 对应的分别为 len(a), a[0], a[-1]，因此最后结果为 4:12:10。

1
2
3

TTTTTTT666666TTTTTTTT
TTTTTTTTTTTTTTT666666
666666TTTTTTTTTTTTTTT

1
2
3

print("{0:{1}^{2}}".format(666666, "T", 20))
print("{0:{1}>{2}}".format(666666, "T", 20))
print("{0:{1}<{2}}".format(666666, "T", 20))

每行输出的总宽度都是 20，三行格式分别为居中、右对齐、左对齐，输出内容是 666666，用 "T" 字符填充空缺部分。

dd。

len(my_str) - 1 = 2，所以只会进行 index_int 为 0 和 1 的两次循环。

index_int = 0 时，my_str[0] > my_str[1]，所以 result_str 乘 2，变为 dd。

DHB。

• 可以看出 mdict 是一个字典，所以应该用 mdict = {} 来初始化
• for e in mlist: 遍历字符串中的每个字符，需要有 e，否则循环中的 e 没有意义了
• mdict.items() 可以遍历字典中的键值对，不能只有键或只有值

T。Python 的赋值语句是没有返回值的，不允许这种写法，在编译时直接会被认为是非法语句。

而 x=y=z+1 是合法的，这是因为 Python 特别规定了这种连等的赋值语句，将会首先计算最右侧的表达式，将其计算结果赋值给左边的每一个对象。

关于赋值语句的更多内容可以参考 Review - 赋值语句。

F。else 子句只有在循环正常结束时才会执行，如果是因为 break 语句退出的，else 子句不会执行。

F。

在遍历列表时，不要对列表进行增删操作，容易会导致遍历出错。这里发生的事情大概为：

• 前一轮循环，取出 lst 中的前 3 个元素，不是 0，继续。
• 第四轮循环，取出 lst 中的第 4 个元素 0（下标为 3），删除这个元素，lst 变为 [34, 6, 7, 0, 0, 9]。
• 第五轮循环，取出 lst 中的第 5 个元素 0（下标为 4），删除这个元素，lst 变为 [34, 6, 7, 0, 9]。
• 此时发现 lst 的长度已经是 5 了，没有第 6 个元素，因此不再继续。

所以最后 n 的值就是 2。

F。i = x[i] = 3 是一个连等赋值语句，先将 3 赋值给 i，再将 3 赋值给 x[i]，因此输出应当为

1

[1, 2, 3, 3, 5]

具体细节可以参照 Review - 赋值语句。

C。由于 int 类型的 x 被强制处理为 bool，仅当 x 为 0 的时候会被认为是 True，非零即为 False。因此，if x 和 if x != 0 是等价的。

A，if x=0 应该为 if x==0。

B，if x!=0 后面漏了一个冒号。D 同样也是漏了冒号。

C。对于列表推导式，应将其展开解读。

B 首先应该排除，这是不合法的列表推导式写法，应当将列表中元素的形式放在最前面。

A 应当解读为：

1
2
3
4
5
6
7

lst = []
for i in range(2, 7):
    if i%2==1:
        lst.append(i-1/i)
    else:
        lst.append(1-i/i)
sum(lst)

C 应当解读为：

1
2
3
4
5
6
7

lst = []
for i in range(2, 7):
    if i%2:
        lst.append((i-1)/i)
    else:
        lst.append((1-i)/i)
sum(lst)

D 的解读与 C 类似，只是 range 的起点不同，第一项会计算 (1-0)/0，发生除零错误。

A。步长默认为正步长 1，初始就有 10<0，于是没能进入循环。

B 是正确的，range(1, 11) 会生成 1 到 10 的整数序列。

C 是正确的，range(10, 0, -1) 会生成 10 到 1 的整数序列。

D 是正确的，for i in (10,9,8,7,6,5,4,3,2,1) 会遍历元组中的元素。

B。当输入 1 时，a 的初始值为 0，不会进入 while 循环，直接输出 是素数。

1。由于 a 大于 0，所以第一个条件满足，执行完毕后直接跳出，不会执行 elif 语句。

Grade D。

由于 score 为 82，满足第一个条件，因此 grade 直接被赋值为 D，不会再执行后面的 elif。

Python。遇到 s == "N" 时，执行 break 语句，直接跳出循环。

PythonNCRE。

当 s 为 "N" 时，会进入 while 循环，然后 break 表示离开最近的一层循环（也就是 while 循环），然后继续 print，继续执行 for 循环。

当 s 不是 "N" 时，不进入 while 循环。因此实际上就是打印了整个 "PythonNCRE"。

1
2
3
4

0 
0 1 
0 1 2 
0 1 2 3 

对于第二行，i=2，j=0，j<i，输出 0 1。

对于第三行，i=3，j=0，j<i，输出 0 1 2。

对于第四行，i=4，j=0，j<i，输出 0 1 2 3。

45。对于列表中的每个元素，如果是列表，则将列表中的元素相加，否则直接加到 s 上。

该程序仅针对最多嵌套一层的列表进行求和，而且假定各基础元素都是数值类型可以互相相加。

15 次。外层循环 5 次，内层循环 3 次，总共 5*3=15 次。

150。可以按如下计算

2。

对于第二行代码，首先算出等号右侧的 2 和 t+1=2。随后按顺序赋值，先将 2 赋值给 t，再将算好的 t+1 的值，也就是 2 赋值给 a。

关于赋值语句的计算顺序，可以参考 Review - 赋值语句。

6。

尽管我们说，“对于列表的遍历，不要在遍历的过程中对列表进行增删操作，会导致遍历出错”，但是这里的 lst[:] 是复制了一份原列表，被遍历的是复制的列表、被删除的是原列表，因此不会出错。

在遍历的过程中，删除了所有模 3 不为 1 的 6 个元素。

AHI。

其思想是，一开始的 t=x%2 是二进制最低位，反向后是二进制最高位。逐渐将 x//2，可以得到原来的数中更高维的二进制数位，然后反向后的数位逐渐变低。累加，使用 *2+t 的方法，对应二进制相邻数位之间的关系。

BGE。

• value 会逐渐变化，所以不能直接使用原来的 decimal，因为在最后还需要输出 decimal
• 模仿前面的，其实就是 single 对应的字符
• value 逐渐除以 16，获得十六进制的下一位

F。其结果为 [4, 5, 4, 5, 4, 5]，每个元素的内存都是独立的。

而 [[4,5]]*3 的结果是 [[4, 5], [4, 5], [4, 5]]，但是这个二维列表（矩阵）中的每个一维列表共享内存，即该矩阵的每一行都是同一行。例如会有：

1
2
3
4

a = [[4,5]]*3
# a = [[4, 5], [4, 5], [4, 5]]
a[1][1] = 2
# a = [[4, 2], [4, 2], [4, 2]]

可以参考 Review - 列表。

F。其结果为 [1, 2, [3], 4, 5]，两个列表直接相加，会将第二个列表整体加到第一个列表的末尾。

T。列表越界错误。

T。参考 Review - 数据类型。

F。find() 是字符串的方法，用于查找子串的位置，列表没有这个方法。

T。参考 Review - 可变类型与不可变类型。

C。舍去最后一个元素后的列表，注意是 list1[:-1] 而不是 list1[::-1]。

D。报错在第 4 行：TypeError: unsupported operand type(s) for +=: 'int' and 'list'。

这是一个循环引用的例子，b[2] 指向了 b 这个列表，是一种特殊的用法，这种用法本身并不会报错。

实际执行中，row 取 1 和 2 不会发生问题；接下来 row 取 b[2] 也就是 b，也不会发生问题。

接下来由于 b 是 list 类型，就会执行 for elem in b。elem 取 1 和 2 也不会发生问题，但是接下来 elem 还是会取到 b，此时的 s 是 int 类型，但是 b 是 list 类型，会试图将 s 与 b 相加，于是会报错。

1
2
3

True
False
False

对于第二行输出，copy 会将整个一维列表进行拷贝，内存空间会不一样。

对于第三行输出，切片操作会进行类似 copy 的操作，而不是引用赋值。

可以参考 Review - 列表。

1
2
3
4

[[0, 0, 0, 0], 0, 0]
[[0, 0, 0, 0], [0, 0, 0, 0], 0]
[[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]
[[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 7, 0]]

首先把 a 构造为 [0, 0, 0]，每个 0 都是一行的占位符。随后循环为 a 补上每一行，每行都是长度为 m 的全零列表。利用了一维列表的乘法。由此前三行输出就很自然了。

对于最后一行输出，修改 a[2][2] 为 7 并不会影响其他元素，因为 a 的每一行都是单独构造 [0] * m 后赋值的，没有共享内存空间。

7。

data 中的每一行都是同一个 row，所以修改 data[0][2] 实际上是在修改 row[2]，于是 data 的每一行都改变了。（每一行都是同一行）

7。

用这种方式构造出来的 data 矩阵的每一行也都是同一行。一维列表的乘法是拷贝值后拼接，二维列表的乘法就是拷贝引用后拼接了。

0。

这种方式构造的 data 矩阵的每一行都是独立构造的 [0]*3，因此修改 data[2][2] 不会影响其他元素。

1
2
3
4
5
6
7

[-21, 3, 49, 0, 35, -26, -10, -22, -5, 12]
[12, -22, -26, 0, 3]
[12, -5, -22, -10, -26, 35, 0, 49, 3, -21]
[-10, 35, 49]
[-5, -10, 35, 49, -21]
[12, -5, -22, -10, -26, 35, 0, 49, 3, -21]
IndexError: list index out of range

列表切片 [start:stop:step] 的意义是从 start 开始，到 stop 结束，每隔步长 step 取一个元素，与 range 是类似的。

step 默认为 1，start 默认为 0，stop 默认为列表的长度。值得注意的是，stop 可以取大于列表的长度，会被自动截断。

22

列表直接赋值给另一个变量是引用赋值，因此list1 和 list2 都指向同一个列表，修改 list1 的元素也会影响 list2。

7

发生了列表的拷贝，d1 和 d2 是两个不同的列表，d1[0]=6 不会影响 d2，因此输出是 6+1=7。

F。这个二分查找是有问题的，while 的条件应该改为 left <= right。对于 36 这一输入，最后会进入 left == right，然后直接退出循环（本应先令 found = mid 的），使 found 保持 -1。

11。

mat 是一个 5 行 3 列的矩阵，即

1
2
3
4
5

[[1, 2, 3],
 [4, 5, 6],
 [7, 8, 9],
 [10, 11, 12],
 [13, 14, 15]]

构造 mat 的语句可以展开解读为