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

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

第1题

有如下Python程序段：

x,y=12,5
if x % y==0:
    z=x/y
    print(x,"/",y,"=",z)
else:
    z=y*x
    print(x,"*",y,"=",z)

程序段执行后，输出的结果为？（ ）
A：x/y=2.4
B：x*y=60
C：12/5=2.4
D：12*5=60

答案：D

根据给定的Python程序段，我们可以分析代码的执行流程：

首先，将变量x赋值为12，变量y赋值为5。
然后，判断x对y取余是否等于0。由于12对5取余不等于0，所以执行else代码块中的内容。
在else代码块中，将z赋值为y乘以x，即z=5*12=60。
最后，打印输出结果，即打印"12 * 5 = 60"。
因此，程序段执行后的输出结果为选项D：12*5=60。

第2题

下列创建元组的方法中不正确的是？（ ）
A：t=(1,2,‘信息’）
B：t=(1)
C：t=(‘信息’,)
D：t=‘音乐’,‘体育’,‘美术’

答案：B

选项B中的代码尝试创建一个元组，但是元组只有一个元素时需要在元素后面添加一个逗号来区分它是一个元组而不是一个普通的括号包裹的表达式。因此，正确的写法应该是使用逗号来创建只有一个元素的元组，例如：t=(1,)。

所以，选项B中的代码应该修改为：t=(1,)，即在元素1后面添加逗号，才能正确创建一个只有一个元素的元组。

第3题

s='语文、数学、英语、信息技术'
l=s.split('、')
print(l)

以上代码的运行结果为？（ ）
A：[‘语文’, ‘数学’, ‘英语’, ‘信息技术’]
B：[‘语文、数学、英语、信息技术’]
C：(‘语文’, ‘数学’, ‘英语’, ‘信息技术’)
D：(‘语文、数学、英语、信息技术’)

答案：A

根据给定的代码，我们可以分析其执行过程：

首先，将字符串s赋值为’语文、数学、英语、信息技术’。
然后，使用split方法对字符串s进行分割，指定分隔符为’、'，将字符串分割成多个子字符串，并返回一个列表。
将得到的列表赋值给变量l。
最后，打印输出变量l。
根据代码的执行过程，我们可以得出结论：

代码会将字符串s按照’、‘进行分割，得到一个包含分割后的子字符串的列表。每个子字符串都是以’、'为分隔符划分的。所以，程序段执行后的输出结果为选项A：[‘语文’, ‘数学’, ‘英语’, ‘信息技术’]。

第4题

已知存在字典a中有多个键值对，以下指令可以清空字典并保留变量的是？（ ）
A：a.remove()
B：a.pop()
C：a.clear()
D：del a

答案：C

选项A和B都是错误的：

• a.remove() 是一个无效的字典方法，因为字典没有 remove() 方法。

• a.pop() 会删除字典中指定的键，并返回相应的值，但是它不会清空整个字典。

选项D：del a 是删除变量 a 的操作，而不是清空字典。

正确的选项是C：a.clear()，它会清空字典中的所有键值对，但是保留字典的存在，因此变量 a 仍然存在，只是字典为空。

第5题

以下程序的运行结果是？（ ）

list1=[1,2,3]
list1[2]=4 
print(list1)

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

答案：A

代码会将列表list1中索引为2的元素的值修改为4，然后打印输出整个列表list1。因此，程序段执行后的输出结果为选项A：[1, 2, 4]。

第6题

执行下列代码后，运行结果是？（ ）

l1 = [11, 22, 33]
l2 = [66, 44, 22]
for i in l1:
    for j in l2:
        if i == j:
            print(i)

A：True
B：0
C：2
D：22

答案：D

代码会遍历列表l1中的元素和列表l2中的元素，当元素值相等时，即i等于j时，会打印该元素的值。

根据给定的列表l1和l2，可以看出22是l1和l2共有的元素，因此程序段执行后会打印出22。

因此，程序段执行后的输出结果为选项D：22。

第7题

执行以下语句后的输出结果是？（ ）

>>> str1='My name is BeiJing'
>>> print(len(str1)) 

A：20
B：18
C：15
D：16

答案：B

字符串’My name is BeiJing’的长度是18个字符，包括空格。所以，程序输出结果为18。

因此，选项B是正确答案。

第8题

列表a=[1,2,3,4,5,6,7,8,9],对列表进行切片操作，要想得到[3,5,7]，以下切片正确的是？（ ）
A：a[-7:-2:-2]
B：a[2:7:2]
C：a[3:7:2]
D：a[2:7:-2]

答案：B

列表a的索引从0开始，我们可以使用切片操作来获取指定范围的元素。
a[2:7:2] 表示从索引2开始（包含），到索引7结束（不包含），步长为2。
这意味着切片会取到索引2、4和6对应的元素，即 [3, 5, 7]。

第9题

执行以下语句，将输出？（ ）

>>>list1=['b','c',1,2,3,4,5] 
>>>list1.append('a') 
>>>list1.append('a') 
>>>list1

A：[‘b’,‘c’,1,2,3,4,5]
B：[‘b’,‘c’,1,2,3,4,5,‘a’]
C：[‘b’,‘c’,1,2,3,4,5,‘a’,‘a’]
D：无输出

答案：C

首先，定义了一个列表list1，包含元素[‘b’, ‘c’, 1, 2, 3, 4, 5]。
使用列表的append()方法两次，在列表末尾分别添加了两个元素 ‘a’。
最后，使用print语句打印输出列表list1。
因此，程序的输出结果为选项C：[‘b’, ‘c’, 1, 2, 3, 4, 5, ‘a’, ‘a’]。

第10题

不能用作if语句条件表达式的是？（ ）
A：x in range(6)
B：3=a
C：a>3 and b<10
D：x-6>5

答案：B

在条件表达式中，if语句需要一个布尔值（True或False）来确定执行哪个分支。
选项A：x in range(6)是一个合法的条件表达式，它会检查x是否在range(6)范围内。
选项C：a>3 and b<10是一个合法的条件表达式，它会检查a是否大于3并且b是否小于10。
选项D：x-6>5是一个合法的条件表达式，它会检查x减去6的结果是否大于5。
然而，选项B：3=a 是一个不合法的条件表达式。在Python中，赋值操作符是=，而相等比较操作符是==。

第11题

执行以下语句后，输出的结果是？（ ）

>>>list2 = ['a',1, 2, 3, 4, 5 ]
>>>print(list2[5]) 

A：5
B：4
C：3
D：提示错误

答案：A

在Python中，列表的索引从0开始，因此 list2[5] 表示获取 list2 中索引为5的元素。根据给定的列表，索引为5的元素是5。

因此，程序的输出结果为选项A：5。

第12题

alist=[‘cat’,‘bat’,‘cat’,‘hat’,‘cat’]， 执行下列代码，输出的结果是？（ ）

alist.remove('cat')
print(alist)

A：[‘cat’,‘bat’,‘cat’,‘hat’,‘cat’]
B：[‘bat’,‘cat’,‘hat’,‘cat’]
C：[‘bat’,‘hat’]
D：[‘cat’,‘bat’,‘cat’,‘hat’]

答案：B

根据给定的列表 alist=[‘cat’,‘bat’,‘cat’,‘hat’,‘cat’]，执行 alist.remove(‘cat’) 后，会移除第一个出现的 ‘cat’ 元素。因此，列表 alist 变为 [‘bat’, ‘cat’, ‘hat’, ‘cat’]。

因此，程序的输出结果为选项B：[‘bat’, ‘cat’, ‘hat’, ‘cat’]。

第13题

以下创建字典的方法，正确的是？（ ）
A、d={学号,001,姓名,张三,成绩,98}
B、d={‘学号’:‘001’,‘姓名’:‘张三’,‘成绩’:98}
C、d={‘学号’,‘001’,‘姓名’,‘张三’,‘成绩’,98}
D、d={‘学号’:‘001’;‘姓名’:‘张三’;‘成绩’:98}

答案：B

字典是由键值对组成的数据结构，在Python中用花括号 {} 表示。
键值对由键和对应的值组成，使用冒号 : 分隔键和值。
选项A中的语法是错误的，应该使用键值对的形式，即 ‘学号’: ‘001’, ‘姓名’: ‘张三’, ‘成绩’: 98。
选项C中的语法也是错误的，应该使用冒号 : 分隔键和值。
选项D中使用了分号 ;，而不是逗号 , 来分隔键值对。
因此，选项B：d={‘学号’:‘001’,‘姓名’:‘张三’,‘成绩’:98} 是正确的创建字典的方法。

第14题

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

for i in "Python":       
      if i == "t" or i == "o":
            continue
      print(i,end="")

A：Pyhn
B：Python
C：Pyt
D：Pytho

答案：A

根据给定的字符串 “Python”，循环遍历每个字符，当字符为 “t” 或 “o” 时，执行 continue 跳过剩余部分。因此，字符 “t” 和 “o” 不会被打印。

因此，程序的输出结果为选项A：Pyhn。

第15题

对于字典dic={1:2,‘3’:‘d’,‘sex’:1,4:{‘No’:1,‘name’:‘Mike’}},len(dic)的值是？（ ）
A：3
B：4
C：5
D：6

答案：B

len(dic) 是一个内置函数 len() 用于返回字典中键值对的数量。
给定的字典 dic 包含以下键值对：1: 2，‘3’: ‘d’，‘sex’: 1 和 4: {‘No’: 1, ‘name’: ‘Mike’}。
字典中共有4个键值对。
因此，len(dic) 的值为4

第16题

对于元组tup=(1,2,3,4,5)执行的操作非法的是？（ ）
A：len(tup)
B：max(tup)
C：min(tup)
D：tup[1] = 6

答案：D

元组是不可变的序列，一旦创建就不能修改其元素。
选项A：len(tup) 是一个合法的操作，它返回元组 tup 的长度。
选项B：max(tup) 是一个合法的操作，它返回元组 tup 中的最大值。
选项C：min(tup) 是一个合法的操作，它返回元组 tup 中的最小值。
选项D：tup[1] = 6 是一个非法的操作，因为它试图修改元组 tup 中索引为1的元素的值，而元组是不可变的，不能修改其中的元素。
因此，选项D：tup[1] = 6 是非法的操作。

第17题

水果店促销每斤苹果5元，如果购买六斤及六斤以上还可以打八折，小红去买苹果，下面的哪一个的Python程序语句可以帮小红算一下她买苹果得花多少钱（具体购买斤数由小红输入）？（ ）
A：

x=input("请输入斤数：")
if x<6:
       y=5*x
else:
       y=5*x*0.8
print(y)

B：

x=eval(input("请输入斤数："))
if x<6:
    y=5*x
else:
    y=5*x*0.8
print(y)

C：

x=eval(input("请输入斤数："))
if x<6:
    y=5*x*0.8
else:
    y=5*x
print(y)

D：

x=input("请输入斤数：")
if x<6:
       y=5*x*0.8
else:
       y=5*x
print(y)

答案：B

选项B的程序语句是正确的，并且可以实现小红购买苹果的计算。
首先，使用 input 函数获取小红输入的购买斤数，并使用 eval 函数将输入转换为数值。
然后，使用条件判断语句 if-else 来判断购买斤数是否小于6。
如果购买斤数小于6，即不满足打折条件，计算花费为 y = 5 * x。
如果购买斤数大于等于6，满足打折条件，计算花费为 y = 5 * x * 0.8。
最后，使用 print 函数输出计算得到的花费 y。
因此，选项B的程序语句可以帮助小红计算购买苹果的花费。

第18题

执行下列代码后，运行结果是？（ ）

s="垃圾分类"
i=len(s)
while i>=0:
    print(s[i-1])
    i=i-1

A：

类
分
圾
垃

B：

垃
圾
分
类

C：

垃
圾
分
类
垃

D：

类
分
圾
垃
类

答案：D

给定的代码使用 while 循环来逆序输出字符串 s 中的每个字符。
首先，通过 len(s) 获取字符串 s 的长度，赋值给变量 i。
进入循环，当 i 大于等于0时，执行循环体内的代码。
在循环体内，使用 print(s[i-1]) 打印输出字符串 s 中索引为 i-1 的字符。
然后，将 i 的值减1，继续下一次循环。
根据给定的字符串 “垃圾分类”，执行循环后，将会按逆序输出每个字符。循环的次数与字符串的长度相同。

因此，程序的运行结果为选项D：类 分 圾 垃 类。

第19题

在列表a中存放1-100之间所有的奇数，可以有多种方法，以下哪种方法是错误的？（ ）
A：a=list(range(1,100,2))
B：a=range(1,101,2)
C：

a=[]
i=1
while i<100:
    a.append(i)
    i+=2

D：

a=[]
for i in range(1,100,2):
    a.append(i)

答案：B

选项A：a=list(range(1,100,2)) 是正确的方法，使用 range 函数生成从1到100之间的奇数序列，然后通过 list 函数将其转换为列表。
选项C和选项D都是正确的方法，使用循环来生成从1到100之间的奇数，并将其添加到列表中。
选项B：a=range(1,101,2) 是错误的方法，因为它实际上创建了一个 range 对象，而不是一个列表。虽然 range 对象可以用于迭代和生成奇数序列，但在此情况下，题目要求的是存储奇数的列表。
因此，选项B：a=range(1,101,2) 是错误的方法。

第20题

若li=list(range(1,10,2))，则print(li)的结果是？（ ）
A：[0,2,4,6,8,10]
B：[1,3,5,7,9]
C：[1,2,3,4,5,6,7,8,9,10]
D：[0,2,4,6,8]

答案：B

给定的代码 li=list(range(1,10,2)) 使用 range 函数生成从1到10之间步长为2的序列，并将其转换为列表。
range(1,10,2) 生成的序列包括1、3、5、7和9，这些是从1开始，每次增加2的奇数。
因此，赋值给变量 li 的结果是包含这些奇数的列表：[1,3,5,7,9]。

第21题

已知a=[‘a’,‘b’]，b=[7,8,9]，如果c=a*2+b，那么列表c是？（ ）
A：[‘a’,‘b’,‘a’,‘b’,7,8,9]
B：[‘a’,‘b’,2,7,8,9]
C：[‘a’,‘b’,7,8,9,‘a’,‘b’]
D：[‘a’,‘b’,‘a’,‘b’,7,8,9,7,8,9]

答案：A

根据给定的代码，a 是包含两个元素 ‘a’ 和 ‘b’ 的列表，b 是包含三个元素 7、8 和 9 的列表。
运算符 * 用于重复列表，a*2 表示将列表 a 重复两次，得到 [‘a’, ‘b’, ‘a’, ‘b’]。
运算符 + 用于连接列表，a*2 + b 表示将两个列表连接起来，得到 [‘a’, ‘b’, ‘a’, ‘b’, 7, 8, 9]。
因此，列表 c 的结果是选项A：[‘a’, ‘b’, ‘a’, ‘b’, 7, 8, 9]。

第22题

已知a=[1,2,3,4,5,6,7]，则a[0:-2]的的值是？（ ）
A：[1,2,3,4,5,6]
B：[2,3,4,5,6]
C：[1,2,3,4,5]
D：[2,3,4,5]

答案：C

列表切片可以通过指定起始索引和结束索引来获取列表中的部分元素。
在给定的代码中，a 是包含元素 1 到 7 的列表。
a[0:-2] 表示从索引 0 开始，到倒数第二个元素（索引 -2）之前的元素。
因此，a[0:-2] 返回的结果是包含索引 0 到索引 -3 的部分列表，即 [1,2,3,4,5]。

第23题

以下语句不正确的是？（ ）
A：dict={1:‘a’}
B：a={‘name’:‘bob’}
C：e={[1]:‘篮球’}
D：c={‘school’:‘精英小学’}

答案：C

选项A：dict={1:‘a’} 是正确的语句，用于创建一个字典，其中键为整数1，值为字符串 ‘a’。
选项B：a={‘name’:‘bob’} 是正确的语句，用于创建一个字典，其中键为字符串 ‘name’，值为字符串 ‘bob’。
选项D：c={‘school’:‘精英小学’} 是正确的语句，用于创建一个字典，其中键为字符串 ‘school’，值为字符串 ‘精英小学’。
选项C的语句 e={[1]:‘篮球’} 是不正确的。字典的键必须是不可变类型，而列表是可变类型。在这种情况下，将列表作为字典的键会引发错误。

第24题

关于 break的作用，以下说法正确的是？（ ）
A：按照缩进跳出当前层语句块
B：暂停该语句后面的循环内容，跳转到循环开始位置开始下一轮循环
C：跳出当前层for/while循环
D：跳出所有for/while循环

答案：C

break 语句用于提前终止循环，当某个条件满足时，可以使用 break 语句跳出循环。
选项A的说法是不正确的，break 语句并不是按照缩进来跳出当前层语句块，而是跳出最内层的循环块。
选项B的说法也是不正确的，break 语句只会终止当前循环的执行，并跳出循环体，不会返回循环的开始位置开始下一轮循环。
选项D的说法也是不正确的，break 语句只会跳出当前层的循环，而不是跳出所有的 for/while 循环。
因此，选项C：跳出当前层的 for/while 循环 是正确答案。

第25题

若s=(1,‘a’,[1,2])，则len(s)的值为？（ ）
A：错误
B：2
C：3
D：4

答案：C

len() 是一个内置函数，用于返回一个对象的长度或元素的个数。
在给定的代码中，s 是一个元组，包含三个元素：整数1、字符串 ‘a’ 和列表 [1,2]。
len(s) 返回的结果是元组 s 的元素个数，即3。

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

第26题

while循环和for-in循环一样，都明确了循环的次数。（ ）

答案：错误

while 循环和 for-in 循环在循环的方式和使用上有一些区别。
for-in 循环用于遍历可迭代对象（如列表、元组或字符串）中的元素，它会在每一次迭代中自动取出下一个元素，因此在使用 for-in 循环时无需明确指定循环的次数。
while 循环则是根据一个条件表达式的真假来判断是否继续循环，它会在每一次迭代前先判断条件是否满足，只有条件为真时才会执行循环体，因此 while 循环的次数可以根据条件的变化而不同，不需要明确指定循环的次数。

第27题

可以使用“+”和“-”来连接与删除字符串。（ ）

答案：错误

在Python中，不能使用加号（“+”）和减号（“-”）来直接连接和删除字符串。
使用加号（“+”）可以用于连接两个字符串，例如使用 + 运算符可以将两个字符串连接成一个新的字符串。
使用减号（“-”）并不能直接用于删除字符串中的内容。字符串是不可变对象，无法通过减号运算符来删除指定的子字符串。要删除字符串中的内容，可以使用其他方法，如切片、替换等。

第28题

不同类型的元素可以存储在同一个列表中。（ ）

答案：正确

在Python中，列表是一种容器类型，可以存储不同类型的元素。
列表可以同时包含整数、浮点数、字符串、布尔值等不同类型的元素。
由于列表是一种可变序列，它具有灵活性，允许存储和操作不同类型的数据。

第29题

循环结构中的continue语句的功能是中断当前循环的执行，进入下一轮循环条件是否满足的判断。（ ）

答案：正确

ontinue 语句用于中断当前循环的执行，并跳过循环中剩余的代码，直接进入下一轮循环的条件判断。
当 continue 语句被执行时，循环的控制流会立即跳到循环的开头，忽略循环体中 continue 语句后面的代码，进行下一轮循环的判断。
continue 语句通常与条件语句结合使用，用于在特定条件下跳过当前循环的执行。

第30题

ESC可以用于Python跳出循环。（ ）

答案：错误

在Python中，使用 ESC 键无法直接用于跳出循环。
在Python中，使用 break 语句可以跳出循环，而不是使用 ESC 键。
当 break 语句执行时，它会立即终止当前的循环执行，并跳出循环体，继续执行循环后面的代码。

第31题

按照顺序执行下面的代码，以下命令都是合法的。（ ）

list1=[1,2,3] list1[2]=4
tuple1=(1,2,3)
tuple1[0]=0

答案：错误

在给定的代码中，首先定义了一个列表 list1，并将其赋值为 [1,2,3]。
然后，定义了一个元组 tuple1，并将其赋值为 (1,2,3)。
在代码的第一行，list1[2]=4 是合法的操作，它将列表 list1 中索引为 2 的元素修改为 4。因为列表是可变的，可以通过索引来修改其中的元素。
然而，在代码的第三行，tuple1[0]=0 是不合法的操作。元组是不可变的，一旦创建后，其中的元素不可修改。因此，试图通过索引来修改元组中的元素会引发错误。

第32题

Python列表、元组、字典都属于有序序列，都可以用索引进行访问。（ ）

答案：错误

列表和元组是有序序列，可以使用索引来访问其中的元素。索引从0开始，可以使用正整数和负整数来访问列表和元组中的元素。
字典是无序的，它是一种映射类型，使用键值对存储数据。字典中的元素没有固定的顺序，因此不能使用索引来访问字典中的值。
字典中的元素是通过键来访问的，通过指定键来获取对应的值。

第33题

message1=‘Hello’，则message1.append(‘world’)的值为’Hello world’。（ ）

答案：错误

在Python中，字符串是不可变的，意味着不能直接对字符串进行修改。
当尝试使用 append() 方法来修改字符串时，会引发 AttributeError 错误，因为字符串类型没有 append() 方法。
append() 方法通常用于向可变的序列类型（如列表）中添加元素，而不是字符串类型。

第34题

元组一旦创建，其中的元素就不能再被修改了。（ ）

答案：正确

在Python中，元组是不可变的序列类型，一旦创建后，其中的元素不能被修改。
元组的不可变性意味着无法通过索引或其他方式直接修改元组中的元素。
如果需要修改元组中的元素，只能通过创建新的元组来实现，或者使用其他可变的数据结构（如列表）来替代元组。

第35题

运行以下程序，结果是一条由9行单个的#组成的图案。（ ）

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

答案：错误

给定的程序使用了一个 while 循环来打印出一条由多个 # 符号组成的图案。
循环的条件是 i<10，即 i 的值小于 10。
在循环体中，首先将 i 的值加1，然后使用 print(‘#’) 语句打印出一个 # 符号。
循环体执行了10次，每次循环都会打印一个 # 符号，最终输出的结果是10行单个的 # 符号。

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

第36题

日期转换
编写一个程序，实现用户输入一个日期，格式为"月/日/年"，如输入’05/21/2021’，程序输出日期为’May 21,2021’。
1至12月的英文名称如下：
January，February，March，April，May，June，July，August，September，October，November，December。

以下是一个Python程序，用于将用户输入的日期格式从"月/日/年"转换为"Month day, year"的格式：

# 获取用户输入的日期
date_input = input("请输入日期（格式为月/日/年）：")

# 拆分月、日、年
month, day, year = date_input.split('/')

# 创建月份名称列表
months = ['January', 'February', 'March', 'April', 'May', 'June',
          'July', 'August', 'September', 'October', 'November', 'December']

# 获取月份名称
month_name = months[int(month) - 1]

# 输出转换后的日期
formatted_date = f"{month_name} {day},{year}"
print(f"转换后的日期为：{formatted_date}")

运行程序后，用户将被提示输入日期，例如：‘05/21/2021’。程序将会将该日期转换为’May 21, 2021’的格式，并输出结果。

请注意，此程序假设用户输入的日期格式为"月/日/年"，并且输入的月份和日期是有效的。对于输入的日期格式错误或无效的情况，需要进行适当的错误处理和验证。

第37题

图形的循环美
设计一个海龟绘图程序，程序效果如下图（要求：海龟从里往外绘制图形，线条初始长度为20，相邻两条边相差4（每一个线条均比前一个线条长4），线条颜色为红色，总共边数至少80条以上（为了便于程序调试，建议不超过120条）。

以下是一个使用Python的turtle库编写的海龟绘图程序，实现了从里往外绘制图形的效果：

import turtle

# 创建海龟对象
turtle_obj = turtle.Turtle()

# 设置初始线条长度
line_length = 20
# 设置线条颜色
turtle_obj.pencolor("red")

# 循环绘制图形
for i in range(80):
    # 绘制一条边
    turtle_obj.forward(line_length)
    turtle_obj.right(90)

    # 更新线条长度
    line_length += 4

# 隐藏海龟
turtle_obj.hideturtle()

# 等待用户关闭窗口
turtle.done()

运行这段代码，将会弹出一个窗口，海龟将从里往外绘制图形。每条边的长度逐渐增加4，线条的颜色为红色。如要调整边数，可以根据需要修改循环的次数。