Python编程（1~6级）全部真题・点这里

一、单选题（共25题，每题2分，共50分）

第1题

执行以下代码中，输出的结果是？（ ）

sum=0
for i in range(1,10,3):
    sum=sum+i
print(sum,i)

A：22 10
B：12 7
C：45 9
D：55 10

答案：B

在代码中，首先定义了变量 sum 并初始化为 0。然后使用 for 循环进行迭代，range(1,10,3) 表示从 1 到 10（不包含 10），步长为 3。因此，循环迭代的值为 1、4、7。

在每次循环中，将 i 的值加到 sum 上。循环结束后，sum 的值为 12。

最后，输出 sum 和 i 的值。由于 i 是在 for 循环内部定义的，它的作用范围仅限于循环内部。因此，在循环结束后，i 的值保持为最后一次迭代的值，即 7。

所以，选项 B：12 7 是正确的输出结果。

第2题

已知s=list(“sgdhasdghasdg”)，以下选项中能输出字符“g”出现的次数的是？（ ）
A：print(s.index(g))
B：print(s.index(“g”))
C：print(s.count(“g”))
D：print(s.count(g))

答案：C

给定的代码中，变量 s 被定义为列表 list(“sgdhasdghasdg”)，即 s 等于 [‘s’, ‘g’, ‘d’, ‘h’, ‘a’, ‘s’, ‘d’, ‘g’, ‘h’, ‘a’, ‘s’, ‘d’, ‘g’]。

要输出字符 “g” 出现的次数，可以使用列表的 count() 方法。该方法返回指定元素在列表中出现的次数。

因此，选项 C：print(s.count(“g”)) 将输出字符 “g” 在列表 s 中出现的次数。

第3题

下列代码的执行结果是？（）

s1="abcde"
s2="fgh"
s3=s1+s2
s3[4:7]

A：efg
B：efgh
C：def
D：defg

答案：A

在给定的代码中，首先定义了字符串变量 s1，其值为 “abcde”。然后定义了字符串变量 s2，其值为 “fgh”。通过字符串拼接操作将 s1 和 s2 连接起来，得到新的字符串变量 s3，其值为 “abcdefgh”。

接下来，使用切片操作 s3[4:7]，提取索引从 4 到 7（不包含 7）的子字符串。在字符串 “abcdefgh” 中，索引 4 对应的字符是 “e”，索引 5 对应的字符是 “f”，索引 6 对应的字符是 “g”。切片操作 [4:7] 将提取这些字符并组成一个新的子字符串。

因此，选项 A：efg 是这段代码的输出结果。切片操作 s3[4:7] 的执行结果是 “efg”。

第4题

以下代码的输出结果是？（ ）

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

答案：C

在代码中，首先创建了列表 ls1，其值为 [1, 2, 3, 4, 5]。然后，将 ls1 赋值给变量 ls2，这意味着 ls1 和 ls2 引用同一个列表对象。

接下来，调用 ls2.reverse() 对列表 ls2 进行反转操作。这个操作会修改原始的列表对象。

由于 ls1 和 ls2 引用同一个列表对象，因此在对 ls2 进行反转操作后，ls1 也会受到影响，指向反转后的列表。

最后，使用 print(ls1) 打印输出列表 ls1 的值。由于 ls1 和 ls2 引用同一个反转后的列表对象，输出结果是 [5, 4, 3, 2, 1]。

第5题

运行如下代码，结果是？（ ）

l=["a",1,"b",[1,2]]
print(len(l))

A：3
B：4
C：5
D：6

答案：B

在代码中，定义了列表 l，包含了四个元素：“a”、1、“b” 和 [1, 2]。

然后，使用 len(l) 计算列表 l 的长度，也就是其中元素的个数。

列表 l 中有四个元素，因此 len(l) 返回的结果是 4。

第6题

以下代码的输出结果是？（ ）

lis = list(range(4)) 
print(lis)

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

答案：B

在代码中，使用 range(4) 创建了一个范围对象，它表示从 0 到 4（不包括 4）的整数序列。然后，通过 list() 函数将范围对象转换为列表。

list(range(4)) 的结果是一个包含 0、1、2、3 的列表：[0, 1, 2, 3]。

最后，使用 print(lis) 打印输出列表 lis 的值。

因此，选项 B：[0, 1, 2, 3] 是这段代码的输出结果。print(lis) 将打印输出列表 lis 的值，即 [0, 1, 2, 3]。

第7题

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

ls = ["橘子","芒果","草莓","西瓜","水蜜桃"]
for k in ls:
    print(k,end=" ")

A：橘子芒果草莓西瓜水蜜桃
B：橘子 芒果 草莓 西瓜 水蜜桃
C：西瓜
D：”橘子””芒果””草莓””西瓜””水蜜桃”

答案：B

在代码中，定义了列表 ls，其中包含了五个字符串元素：“橘子”、“芒果”、“草莓”、“西瓜”、“水蜜桃”。

然后，使用 for 循环遍历列表 ls 中的每个元素，并使用 print() 函数将元素打印输出。通过设置 end=" "，在每个元素之间添加一个空格作为分隔符。

因此，循环执行后，元素会依次被打印输出，每个元素之间有一个空格作为分隔。输出结果是：橘子 芒果 草莓 西瓜 水蜜桃。

所以，选项 B：橘子 芒果 草莓 西瓜 水蜜桃 是这段代码的输出结果。

第8题

关于Python中的流程控制语句，下列描述错误的是？（ ）
A：在分支结构中，if、elif、else都可以单独使用。
B：分支结构中的条件判断通常用关系表达式或逻辑表达式来进行描述。
C：continue语句和break语句只有在循环结构中才可以使用。
D：while语句和for语句的循环条件后都必须输入冒号，需要循环执行的语句必须有缩进。

答案：A

这个描述是错误的。在分支结构中，if 是必需的，但 elif 和 else 是可选的。if 语句用于执行特定条件下的代码块，而 elif 和 else 语句用于提供多个条件判断的情况下的执行选择。

A的正确描述应该是：在分支结构中，if 是必需的，elif 和 else 是可选的。

所以，选项 A 中的描述是错误的。

第9题

已知有列表a = [1, 2, 3, 4, 5]，以下语句中，不能输出[5, 4, 3, 2, 1]的是？（ ）
A：print(a[:-6:-1])
B：print(a.sort(reverse=True))
C：print(sorted(a, reverse=True))
D：print([5, 4, 3, 2, 1])

答案：B

在给定的选项 B 中，使用 sort() 方法对列表 a 进行降序排序，并且 reverse=True 参数指定降序排序。然而，sort() 方法会直接修改原始列表，并且返回值为 None，所以 print(a.sort(reverse=True)) 的输出结果为 None，而不是期望的 [5, 4, 3, 2, 1]。

其他选项都能够输出 [5, 4, 3, 2, 1]：

A：print(a[:-6:-1]) 使用切片操作从列表 a 中提取索引从 -1 到 -6（不包括 -6）的子列表，即最后五个元素，输出结果为 [5, 4, 3, 2, 1]。

C：print(sorted(a, reverse=True)) 使用 sorted() 函数对列表 a 进行降序排序，并返回一个新的列表，输出结果为 [5, 4, 3, 2, 1]。

D：print([5, 4, 3, 2, 1]) 直接打印输出列表 [5, 4, 3, 2, 1]。

因此，选项 B：print(a.sort(reverse=True)) 是不能输出 [5, 4, 3, 2, 1] 的语句。

第10题

已知列表a=[1,2,3,4,5],执行a.insert(2,6)后结果是什么？（ ）
A：[1,2,3,4,5,2,6]
B：[1,2,3,4,5,6]
C：[1,2,6,3,4,5]
D：[1,2,3,6,4,5]

答案：C

在给定的代码中，insert() 方法用于在指定位置插入元素。参数 2 表示在索引为 2 的位置插入元素 6。插入后，原来在索引 2 及其后面的元素都会向后移动一个位置。

初始列表 a 为 [1, 2, 3, 4, 5]，执行 a.insert(2, 6) 后，元素 6 被插入到索引为 2 的位置，结果为 [1, 2, 6, 3, 4, 5]。

因此，选项 C：[1, 2, 6, 3, 4, 5] 是执行 a.insert(2, 6) 后的结果。

第11题

下列选项中，不属于Python流程控制语句的是？（ ）
A：if-elif-else语句
B：while语句
C：do-while语句
D：for语句

答案：C

在 Python 中，没有内置的 “do-while” 语句。 “do-while” 语句是一种先执行循环体，然后再检查条件的循环结构。Python 中的循环结构主要包括 for 循环和 while 循环。

A：if-elif-else 语句用于根据条件执行不同的代码块。

B：while 语句用于在满足条件的情况下重复执行一段代码块。

D：for 语句用于遍历可迭代对象（如列表、元组等）中的元素。

因此，选项 C：do-while 语句不属于 Python 的流程控制语句。

第12题

关于Python元组类型，以下选项中描述错误的是？（ ）
A：元组不可以被修改
B：Python中元组使用圆括号和逗号表示
C：元组中的元素要求是相同类型
D：一个元组可以作为另一个元组的元素，可以采用多级索引获取信息

答案：C

这个描述是错误的。在 Python 中，元组可以包含不同类型的元素。元组是一种有序的、不可变的数据结构，可以包含任意类型的元素，包括不同的数据类型。

其他选项中的描述是正确的：

A：元组不可以被修改。元组是不可变的，一旦创建后，其元素和结构不可更改。

B：Python 中元组使用圆括号和逗号表示。例如，(1, 2, 3) 表示一个包含三个元素的元组。

D：一个元组可以作为另一个元组的元素，可以采用多级索引获取信息。例如，如果有一个嵌套的元组 t = ((1, 2), (3, 4))，可以使用多级索引 t[0][1] 获取内部元组 (1, 2) 的第二个元素 2。

因此，选项 C：元组中的元素要求是相同类型 是描述错误的。

第13题

设有元组tup=(1,2,3,‘1’,‘2’,‘3’)，执行语句print(tup[0::2])，得到的结果是？（ ）
A：(1,2)
B：(1,3)
C：(1,3,‘2’)
D：(1,‘1’,‘3’)

答案：C

切片操作 tup[0::2] 从索引 0 开始，以步长 2 进行切片。这意味着选取从索引 0 开始的元素，并每隔一个元素选择一个。

给定元组 tup=(1, 2, 3, ‘1’, ‘2’, ‘3’)，切片操作 tup[0::2] 选择了索引为 0、2、4 的元素，即第一个元素、第三个元素和第五个元素，结果为 (1, 3, ‘2’)。

因此，选项 C：(1, 3, ‘2’) 是执行 print(tup[0::2]) 得到的结果。

第14题

执行下列代码，输出的结果是？（ ）

dic = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
dic.pop('b')
del dic['d']
dic['d'] = 4
print(dic)

A：{‘a’: 1, ‘b’: 2, ‘c’: 3,‘d’:4}
B：{‘a’: 1, ‘c’: 3, ‘d’: 4}
C：{‘a’: 1, ‘c’: 3}
D：{‘d’: 4}

答案：B

执行上述代码后，输出的结果是字典 dic 的最新状态。

首先，dic.pop(‘b’) 会从字典 dic 中移除键为 ‘b’ 的项，字典变为 {‘a’: 1, ‘c’: 3, ‘d’: 4}。

接着，del dic[‘d’] 会删除字典 dic 中键为 ‘d’ 的项，字典变为 {‘a’: 1, ‘c’: 3}。

最后，dic[‘d’] = 4 会向字典 dic 中添加一个新的键值对，字典变为 {‘a’: 1, ‘c’: 3, ‘d’: 4}。

因此，选项 B：{‘a’: 1, ‘c’: 3, ‘d’: 4} 是执行代码后的输出结果。

第15题

已知列表a=[1, 2, ‘3’]，执行语句print(a*2)后，输出的结果是？（ ）
A：[1, 2, ‘3’, 1, 2, ‘3’]
B：[1, 2, ‘3’]
C：[2, 4, ‘6’]
D：[1, 2, ‘3’,2]

答案：A

执行语句 print(a*2) 后，输出的结果是：

A：[1, 2, ‘3’, 1, 2, ‘3’]

乘法运算符 * 在列表中表示重复操作，会将列表的元素重复指定的次数。

给定列表 a = [1, 2, ‘3’]，执行 print(a*2) 将列表 a 重复两次，结果为 [1, 2, ‘3’, 1, 2, ‘3’]。

因此，选项 A：[1, 2, ‘3’, 1, 2, ‘3’] 是执行 print(a*2) 后的输出结果。

第16题

下列代码的运行结果是？（ ）

a={'xm':'zhangsan'} 
b={'sg':175,'tz':'55kg'} 
b.update(a)
len(b)

A：2
B：3
C：4
D：6

答案：B

首先，将字典 a 定义为 {‘xm’: ‘zhangsan’}，字典 b 定义为 {‘sg’: 175, ‘tz’: ‘55kg’}。

然后，使用 b.update(a) 将字典 a 的键值对更新到字典 b 中。更新后的字典 b 变为 {‘sg’: 175, ‘tz’: ‘55kg’, ‘xm’: ‘zhangsan’}。

最后，使用 len(b) 获取字典 b 的键值对数量，结果为 3。

因此，选项 B：3 是给定代码的运行结果。

第17题

下面Python循环体执行的次数与其他不同的是？（ ）
A：

i = 0
while (i<=10):
    print(i)
    i = i+1

B：

i = 10
while (i>0):
    print(i)
    i = i-1

C：

for i in range(10):
    print(i)

D：

for i in range(10,0,-1):
    print(i)

答案：A

在选项B的循环中，使用 while 循环和递增操作符，从初始值 0 开始，每次迭代增加 1，直到 i 的值增至 11，循环结束。因此，循环体执行的次数为 11 次。

与其他选项不同的是，其他选项的循环体执行次数为 10 次

第18题

下列属于列表的是？（ ）
A：str=“python”
B：list = [‘1’, ‘2’, ‘3’]
C：tup= (‘1’, ‘2’, ‘3’)
D：dict = {‘a’: 1, ‘b’: 2, ‘b’: ‘3’}

答案：B

列表是一种有序的可变数据类型，用于存储多个元素的集合。在选项 B 中，list 被赋值为 [‘1’, ‘2’, ‘3’]，符合列表的定义。

其他选项不属于列表：

A：str=“python” 是一个字符串变量的定义，不是列表。

C：tup= (‘1’, ‘2’, ‘3’) 是一个元组的定义，不是列表。元组与列表相似，但是元组是不可变的，无法修改元素。

D：dict = {‘a’: 1, ‘b’: 2, ‘b’: ‘3’} 是一个字典的定义，不是列表。字典是由键值对组成的集合，而不是仅有元素的集合。

因此，选项 B：list = [‘1’, ‘2’, ‘3’] 是属于列表的。

第19题

已知t=(1,2,3,4,5,6),下面哪条元组操作是非法的？（ ）
A：len(t)
B：max(t)
C：min(t)
D：t[1]=8

答案：D

元组是不可变（immutable）的数据类型，意味着一旦创建，元组的元素就不能被修改。因此，试图使用赋值操作来修改元组的元素是非法的。

在选项 D 中，t[1]=8 是试图将元组 t 的第一个元素修改为 8，这是非法操作。

其他选项是合法的元组操作：

A：len(t) 返回元组 t 的长度，结果为 6。

B：max(t) 返回元组 t 中的最大值，结果为 6。

C：min(t) 返回元组 t 中的最小值，结果为 1。

因此，选项 D：t[1]=8 是非法的元组操作。

第20题

已知字符串中的某个字符，要找到这个字符的位置，最简便的方法是？（ ）
A：切片
B：连接
C：分割
D：索引

答案：D

最简便的方法是使用索引来找到字符串中某个字符的位置。

因此，选项 D：索引 是最简便的方法。

使用索引，可以通过指定字符在字符串中的位置来获取该字符。索引从0开始，可以使用正向索引或反向索引来访问字符串的特定位置。

例如，对于字符串 “Hello”，使用索引可以找到字符 “o” 的位置：

s = "Hello"
index = s.index("o")
print(index)  # 输出: 4

在上述示例中，使用 s.index(“o”) 找到字符 “o” 在字符串 “Hello” 中的位置，并将结果打印出来。结果为 4，表示 “o” 在字符串中的索引位置为 4。

因此，选项 D：索引 是找到字符串中某个字符位置的最简便方法。

第21题

以下关于字典特性的描述正确的是？（ ）
A：字典支持位置索引
B：字典是一种有序的对象集合
C：字典中的数据可以进行切片
D：字典里面的值（不是键）可以包含列表和其他数据类型

答案：D

字典是一种无序的键值对集合，其中的值可以是任意的数据类型，包括列表、元组、字符串、整数等。字典的值可以是可变的对象，如列表，也可以是不可变的对象，如字符串。

其他选项的描述是不正确的：

A：字典不支持位置索引。字典中的元素是通过键而不是位置进行访问的。

B：字典是一种无序的对象集合，不是有序的。字典中的键值对没有固定的顺序。

C：字典中的数据不能进行切片操作。切片操作适用于序列类型（如列表、字符串、元组等），而不适用于字典。

因此，选项 D：字典里面的值（不是键）可以包含列表和其他数据类型 是对字典特性的正确描述。

第22题

在某学校，张三、李四、王五三名同学对应的学号分别是100、101、102。现将他们学号与姓名对应的关系存入字典id_name中，关于以下代码段的描述，错误的是？（ ）

id_name = {101: '张三', 102: '李四', 103: '王五'}
name_id = {}
name_id[id_name[101]] = 101
name_id[id_name[102]] = 102
name_id[id_name[103]] = 103
print(id_name == name_id)

A：在字典id_name中，只能通过学号查找对应的姓名，不能通过姓名查找对应的学号。
B：上述代码是将id_name中姓名作为键、学号作为值构建了一个新的字典name_id。
C：上述代码执行后，字典name_id为：{‘张三’: 101, ‘李四’: 102, ‘王五’: 103}。
D：上述代码输出的结果为：True。

答案：D

在给定的代码段中，首先定义了字典 id_name，用于将学号与姓名进行对应关系。然后创建了一个空字典 name_id。接下来，通过索引 id_name 字典来构建 name_id 字典，将学生姓名作为键，学号作为值。

这两个字典是不相等的，最后执行 print(id_name == name_id) 会输出 False，所以答案选D

第23题

执行下面代码，结果是？（ ）

for key in "lanxi":
    if key=="x":
        break
    print(key)

A：lanxi
B：lan
C：

l
a
n

D：

l
a
n
i

答案：C

在给定的代码中，使用 for 循环遍历字符串 “lanxi” 中的每个字符。当遍历到字符 “x” 时，满足条件 key==“x”，因此执行 break 语句跳出循环。

在循环的每次迭代中，如果字符不是 “x”，则打印该字符。因此，执行结果为打印字符 “l”、“a”、“n”。

第24题

关于break语句与continue语句的说法中，以下选项中错误的是？（ ）
A：continue语句类似于break语句，也必须在for、while循环中使用。
B：break语句结束循环，继续执行循环语句的后续语句。
C：当多个循环语句嵌套时，break语句只适用于当前嵌套层的语句。
D：continue语句结束循环，继续执行循环语句的后续语句。

答案：D

正确的答案是：

D：continue语句结束循环，继续执行循环语句的后续语句。

这个说法是错误的。continue 语句用于结束当前循环的当前迭代，并继续执行下一次迭代。它会跳过循环体中 continue 语句之后的代码，直接进入下一次迭代。也就是说，它不会执行循环语句的后续语句，而是直接开始下一次循环迭代。

正确的描述是：

A：continue语句类似于break语句，也必须在for、while循环中使用。这是正确的描述，continue 语句通常用于循环结构中，可以在循环体内部的某个条件满足时跳过当前迭代。

B：break语句结束循环，继续执行循环语句的后续语句。这是 break 语句的作用，它会终止当前循环的执行，并继续执行循环语句之后的代码。

C：当多个循环语句嵌套时，break语句只适用于当前嵌套层的语句。break 语句只会跳出当前所在的内层循环，而不会跳出外层循环。如果需要跳出多层循环，可以使用嵌套的 break 语句或其他控制结构。

因此，选项 D：continue语句结束循环，继续执行循环语句的后续语句 是错误的描述。

第25题

对s=“www.baidu.com"执行s.split(”.")后的结果是什么？（ ）
A：www.baidu.com
B：[‘www’,‘baidu’,‘com’]
C：“www.baidu.com”
D：wwwbaiducom

答案：B

当对字符串s执行s.split(“.”)操作时，会将字符串按照.作为分隔符进行分割。这将返回一个列表，其中包含被分割后的子字符串。

在本例中，字符串s是"www.baidu.com"。执行s.split(“.”)后，将使用.作为分隔符进行分割，得到以下结果：

[‘www’, ‘baidu’, ‘com’]

每个元素都是被.分隔开的子字符串。因此，选项B [‘www’, ‘baidu’, ‘com’]是正确的解析结果。

二、判断题（共10题，每题2分，共20分）

第26题

执行以下代码，输入数字99，运行结果是：ok。（ ）

a=input('输入一个数字：') 
if a<100: 
    print('ok')

答案：错误

在Python中，input()函数接受的输入都是字符串类型（str）。即使你输入的是数字，它也会以字符串的形式接收。所以，当你输入数字99时，实际上得到的是一个字符串"99"。

在代码中，条件判断语句if a<100:会比较字符串"a"和数字100。由于字符串和数字是不可比较的类型，会引发TypeError错误。

要解决这个问题，你需要将输入的字符串转换为整数类型，可以使用int()函数来实现，像这样：a = int(input(‘输入一个数字：’))。这样，输入的字符串就会被转换成整数，才能进行数值比较。

第27题

在Python中for item in range(1,10,2)表示的是从1循环到10（包括10）步长是2。（ ）

答案：错误

在Python中，range(start, stop, step)函数用于生成一个整数序列，其中start表示起始值（包含），stop表示结束值（不包含），step表示步长（每次增加的值）。

在给定的代码中，range(1, 10, 2)表示从1开始（包含1），以步长2递增，但不包括10。因此，循环将在1、3、5、7、9这些值上进行，不包括10。

第28题

d=( )，d是一个空列表。（ ）

答案：错误

在Python中，( )表示一个空的元组（tuple），而不是一个空列表（list）。

如果要表示一个空列表，应该使用[ ]，像这样：d = []。

第29题

在使用del语句删除字典中不需要的元素时，必须指定字典名和要删除的键。（ ）

答案：正确

在使用del语句删除字典中的元素时，必须指定要删除的键。语法格式为del 字典名[键]，其中字典名表示要删除元素的字典，[键]表示要删除的键。

例如，如果有一个字典my_dict，要删除其中的键为’key1’的元素，可以使用del my_dict[‘key1’]。

第30题

判断下面的语句是否正确。（ ）

 >>>a="Hello"-"World"
 >>>a
‘Hello World’

答案：错误

在Python中，字符串之间不能使用减法运算符进行减法操作。如果尝试执行"Hello"-"World"这样的语句，会引发TypeError错误。

字符串相减操作没有定义，因此无法执行减法运算。如果想要实现字符串的拼接，可以使用加法运算符+，如"Hello" + " World"。

第31题

在Python中range,表示一个整数序列，对于浮点型和字符串类型是无效的。（ ）

答案：正确

在Python中，range()函数用于生成一个整数序列，对于浮点型和字符串类型是无效的。range()函数的参数必须是整数类型，不能接受浮点型或字符串类型的参数。

如果尝试将浮点型或字符串类型作为range()函数的参数，将引发TypeError错误。

第32题

元组的访问速度比列表要快一些，如果定义了一系列常量值，并且主要用途仅仅是对其进行遍历而不需要进行任何修改，建议使用元组而不使用列表。（ ）

答案：正确

元组的访问速度比列表要快一些。由于元组是不可变的（immutable），一旦创建后就不能进行修改，这使得对元组的访问和遍历操作更加高效。

如果你有一系列常量值，并且主要目的是对其进行遍历而不需要进行修改操作，那么使用元组比使用列表更合适。这是因为元组的不可变性可以提供一些性能上的优势。

另一方面，列表是可变的（mutable），允许进行插入、删除和修改等操作。如果你需要对数据进行修改或者频繁地进行插入和删除操作，那么使用列表会更适合。

第33题

元组是用方括号来表示的，列表是用圆括号来表示的。（ ）

答案：错误

在Python中，元组使用圆括号（parentheses）来表示，而列表使用方括号（brackets）来表示。

例如，一个元组可以这样表示：(1, 2, 3)，而一个列表可以这样表示：[1, 2, 3]。

第34题

运行如下代码，运行结果为“今天是3月25日，星期三，天气晴好”。（ ）

print('今天是%d月%d日，星期%s，天气%s'%(3,25,'三','晴好'))

答案：正确

给定的代码使用了字符串的格式化操作，通过占位符和相应的值将格式化字符串填充。在代码中，使用了%运算符和占位符来指定要插入的值的位置和类型。

%d表示整数类型的占位符，%s表示字符串类型的占位符。通过在字符串中使用这些占位符，并使用%运算符后跟相应的值，可以将这些值插入到格式化字符串中。

根据给定的代码，运行结果将为：“今天是3月25日，星期三，天气晴好”，其中%d将被替换为整数3，%d将被替换为整数25，%s将被替换为字符串"三"，%s将被替换为字符串"晴好"。

第35题

for循环适合已知循环次数的操作，while循环适合未知循环次数的操作。（ ）

答案：正确

在Python中，for循环适合用于已知循环次数的操作，而while循环适合用于未知循环次数的操作。

for循环通常用于遍历可迭代对象（如列表、元组、字符串等）或者按照指定的范围进行迭代。你可以明确知道要遍历的元素数量或者指定循环的次数。

例如，你可以使用for循环来遍历列表中的每个元素，或者按照指定的范围进行循环迭代。

而while循环则根据条件的真假来决定是否继续循环，适合于未知循环次数的情况。只要条件满足，循环就会继续执行，直到条件不再满足才会退出循环。

三、编程题（共2题，共30分）

第36题

成绩等级
编写一段代码，要求如下：
1、程序开始运行后，需要用户输入学生的成绩（成绩为正整数）
2、一次输入一个学生的成绩，学生成绩是从0到100；
3、根据用户输入的成绩，程序依据等级标准，输出相应的等级。
4、等级标准是成绩小于60为不及格，60（含）到85（不含）之间为良，85（含）以上为优。
5、可以重复输入成绩进行查询。

你可以使用以下代码来实现这个要求：

while True:
    score = input("请输入学生的成绩（0-100）：")
    score = int(score)

    if score < 0 or score > 100:
        print("输入的成绩无效，请重新输入。")
    elif score < 60:
        print("成绩等级：不及格")
    elif score < 85:
        print("成绩等级：良")
    else:
        print("成绩等级：优")

    choice = input("是否继续查询？（是/否）")
    if choice.lower() != "是":
        break

这段代码使用了一个无限循环while True，确保可以重复输入成绩进行查询。首先，程序会要求用户输入学生的成绩，并将输入的成绩转换为整数类型。然后，通过一系列的条件判断，确定成绩所对应的等级，并进行输出。如果输入的成绩不在有效范围内（0-100），会提示输入无效并要求重新输入。最后，询问用户是否继续查询，如果选择不是“是”，则退出循环，结束程序。

你可以根据需要对代码进行修改和扩展，例如添加更多的等级标准或优化用户输入的验证逻辑。

第37题

剔除数字
要求如下：
1、编写一段程序代码，程序运行后，需要用户随意输入一段包含有数字和字母的字符串；
2、程序会自动删除字符串中的数字，然后输出一串没有数字的字符串（纯字母的字符串）或者列表（没有数字）；
3、要求输出的非数字的字符顺序不能变。

你可以使用以下代码来实现这个要求：

import re

input_str = input("请输入包含数字和字母的字符串：")
result = re.findall('[^0-9]+', input_str)
output = ''.join(result)

print("去除数字后的字符串：", output)

这段代码使用了正则表达式的re.findall()函数来匹配字符串中的非数字字符。[^0-9]表示匹配所有非数字字符，+表示匹配至少一个非数字字符。re.findall()返回一个列表，包含所有匹配的非数字字符串片段。

然后，我们使用''.join(result)将列表中的字符串片段连接起来，形成最终的结果。

最后，我们输出去除了数字的字符串。

请注意，这段代码默认假设输入字符串中只包含数字和字母，并将数字全部去除。如果输入字符串中还包含其他特殊字符或空格等，可以根据具体需求进行修改正则表达式的模式匹配。