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

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

第1题

关于Python中的列表，下列描述错误的是?（ ）
A：列表是Python中内置可变序列，是若干元素的有序集合；
B：列表中的每一个数据称为“元素”；
C：在Python中，一个列表中的数据类型可以各不相同；
D：可以使用s[1]来获取列表s的第一个元素。

答案：D

选项 D 描述是错误的。在 Python 中，列表的索引是从 0 开始的，因此要获取列表中的第一个元素，应该使用 s[0] 而不是 s[1]。

第2题

已知列表a=[1,3,5,7],下列语句无法将a变成a=[1,3,5,7,9]的是?（ ）
A：a.append(9)
B：a=[1,3,5,7,9]
C：a.insert(4,9)
D：a[4]=9

答案：D

在选项 D 中，尝试通过赋值操作来修改列表 a 的第五个元素，但是由于列表 a 只有四个元素，索引为 4 的位置并不存在。所以选项 D 是错误的。

第3题

关于以下代码段的说法错误的是?（ ）

a = [1, 2, 5, 4, 3]
a.sort(reverse=True)
print(a)

A：a.sort(reverse=True)语句中的reverse默认值为False。
B：省略a.sort(reverse=True)语句中的reverse=True，代码运行结果不变。
C：将以上代码的a.sort(reverse=True)改为a=sorted(a,reverse=True)，代码运行结果和原题的结果一样。
D：以上代码运行结果为：[5, 4, 3, 2, 1]。

答案：B

选项 B 是错误的。省略 a.sort(reverse=True) 语句中的 reverse=True，代码运行结果会发生变化。

在原题中，a.sort(reverse=True) 会对列表 a 进行降序排序，即从大到小排序。所以，代码运行结果为 [5, 4, 3, 2, 1]。

如果省略 reverse=True 参数，即使用默认值 reverse=False，则 a.sort() 会对列表 a 进行升序排序，即从小到大排序。这样，代码运行结果就会变成 [1, 2, 3, 4, 5]。

第4题

下面程序的运行结果是?（ ）

a=80
b=70
if a>b:
    a,b=b,a
    print(a,b)

A：70 70
B：80 70
C：70 80
D：80 80

答案：C

在这段程序中，首先定义了变量 a 的值为 80，变量 b 的值为 70。然后使用条件语句 if a > b 判断 a 是否大于 b。由于条件为真，所以接下来执行 a, b = b, a，这行代码将交换变量 a 和 b 的值。最后，打印输出经过交换后的变量 a 和 b 的值。

因为原始的 a 的值为 80，b 的值为 70，经过交换后，a 的值变为 70，b 的值变为 80。所以运行结果为 “70 80”，对应选项 C。

第5题

以下关于元组的描述正确的是?（ ）
A：元组和列表相似，所有能对列表进行的操作都可以对元组进行
B：创建元组时，若元组中仅包含一个元素，在这个元素后可以不添加逗号
C：元组中的元素不能被修改
D：多个元组不能进行连接

答案：C

以下描述正确的是：

C：元组中的元素不能被修改。

元组是Python中的一种数据类型，类似于列表。然而，元组是不可变的，这意味着一旦创建了元组，就不能修改其中的元素。你无法对元组的元素进行增加、删除或修改操作。

选项 A 是不正确的。尽管元组和列表在某些方面相似，如可以通过索引访问元素，但元组是不可变的，因此无法对元组进行像列表那样的修改操作。

选项 B 是错误的。在创建元组时，如果元组中仅包含一个元素，需要在该元素后面添加逗号，以便将其识别为一个元组。例如，(1,) 表示包含一个元素的元组，而 (1) 仅仅是一个整数。

选项 D 是不正确的。多个元组可以通过连接运算符 + 进行连接。例如，(1, 2) + (3, 4) 可以得到 (1, 2, 3, 4) 的结果。

所以，选项 C 是描述正确的。

第6题

以下程序的输出结果是?（ ）

tuple1 = (1,2,3)
tuple2 = (2)
print(tuple1*tuple2)

A：(1,2,3)
B：(1,2,3,1,2,3)
C：(2,4,6)
D：报错

答案：B

在给定的代码中，tuple1是一个元组(1, 2, 3)，而tuple2是一个整数2。

在print(tuple1*tuple2)中，tuple1被重复了tuple2次。由于tuple2的值是2，因此tuple1将被重复两次。

所以，print(tuple1*tuple2)的输出结果为(1, 2, 3, 1, 2, 3)，即元组元素重复的结果。

第7题

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

ls = []
for m in '想念':
   for n in '家人':
          ls.append(m+n)
print(ls)

A：[“想念”,“家人”]
B：[“想想”,“念念”,“家人”]
C：[“想家想”,“人念家”,“念人”]
D：[“想家”, “想人”, “念家”, “念人”]

答案：D

给定的代码中，定义了一个空列表ls。然后，使用两个嵌套的循环对字符串进行迭代。

外部循环for m in '想念’遍历字符串’想念’中的每个字符，内部循环for n in '家人’遍历字符串’家人’中的每个字符。在每次迭代中，将m+n的结果添加到列表ls中。

因此，循环的执行过程如下：

第一次迭代：m为’想’，内部循环迭代一次，n为’家’，将’想’+‘家’的结果’想家’添加到ls中。
第二次迭代：m为’想’，内部循环迭代两次，n分别为’人’和’家’，将’想’+‘人’和’想’+‘家’的结果’想人’和’想家’添加到ls中。
第三次迭代：m为’念’，内部循环迭代一次，n为’家’，将’念’+‘家’的结果’念家’添加到ls中。
第四次迭代：m为’念’，内部循环迭代两次，n分别为’人’和’家’，将’念’+‘人’和’念’+‘家’的结果’念人’和’念家’添加到ls中。
最终，ls中包含了四个字符串元素，分别是’想家’、‘想人’、‘念家’和’念人’。

因此，代码的输出结果是：[“想家”, “想人”, “念家”, “念人”]，对应选项D。

第8题

以下程序的输出结果是?（ ）

lt = ['绿茶','乌龙茶','红茶','白茶','黑茶']
ls = lt
ls.clear()
print(lt)

A：[]
B：变量未定义的错误
C：[‘绿茶’,‘乌龙茶’,‘红茶’,‘白茶’,‘黑茶’]
D：‘绿茶’,‘乌龙茶’,‘红茶’,‘白茶’,‘黑茶’

答案：A

给定的代码中，定义了一个列表lt，其中包含了五个字符串元素。然后，将列表lt赋值给另一个变量ls。

接下来，使用ls.clear()方法清空了列表ls中的所有元素。由于lt和ls指向同一个列表对象，因此清空ls也会影响到lt。

最后，使用print(lt)输出列表lt的内容。由于ls.clear()已经清空了列表，所以lt也变为空列表。

因此，代码的输出结果是：[]，对应选项A。

第9题

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

list1 = [1,2,3]
list2 = [4,5,6]
print(list1+list2)

A：[4,5,6]
B：[1, 2, 3, 4, 5, 6]
C：[1,2,3]
D：[5,7,9]

答案：B

给定的代码中，list1是一个包含了三个整数的列表[1, 2, 3]，list2是一个包含了三个整数的列表[4, 5, 6]。

在print(list1+list2)中，使用加法运算符+将两个列表进行连接操作。这将会生成一个新的列表，其中包含了list1和list2中的所有元素。

所以，print(list1+list2)的输出结果为[1, 2, 3, 4, 5, 6]，即将list1和list2中的元素进行连接形成的新列表。

因此，代码的输出结果是：[1, 2, 3, 4, 5, 6]，对应选项B。

第10题

字符串str="maixnm"包含"min"和"max"两个单词，下面哪个操作不能将"min"从中找出来?（ ）
A：str1=str[0]+str[2]+str[4]
B：str1=str[0:-1 :2]
C：str1=str[::2]
D：str1=str[0:4:2]

答案：D

选项 D 中的操作 str[0:4:2] 是取字符串的切片，从索引 0 开始，到索引 4 之前，步长为 2。这样取得的结果是 “mi”。

因此，选项 D 不能将 “min” 从字符串中找出来。

第11题

cat=[‘fat’,‘black’,‘cloud’]，则cat.index(‘black’)的值为?（ ）
A：1
B：2
C：3
D：0

答案：A

给定列表 cat = [‘fat’, ‘black’, ‘cloud’]，我们需要找出字符串 ‘black’ 在列表中的索引。

使用列表的 index() 方法可以找到指定元素的索引。在这种情况下，cat.index(‘black’) 的值为 1，因为 ‘black’ 在列表中的索引位置是 1。

第12题

3年级2班的学生花名册被存储在一个列表name中，如何快速得到该班级学生的总人数?（ ）
A：print(sum(name))
B：print(len(name))
C：print(min(name))
D：print(max(name))

答案：B

给定学生花名册存储在列表 name 中，使用 len(name) 可以获取列表的长度，即学生的总人数。

第13题

小张的爸爸每个月都有绩效工资，绩效工资根据业绩被分为1200、1400和1600三个等级，小张把爸爸每个月的绩效工资都记录在了一个money的列表中，如何能快速得到小张爸爸得到1600元绩效的次数?（ ）
A：money.index(1600)
B：money.count(1600)
C：money.remove(1600)
D：money.insert(0,1600)

答案：B

给定小张爸爸每个月绩效工资记录在列表 money 中，使用 count(1600) 方法可以统计列表中元素出现的次数。在这种情况下，使用 money.count(1600) 可以得到小张爸爸得到 1600 元绩效的次数。

第14题

name=(‘Jerry’,)，则name的数据类型是?（ ）
A：字符串
B：元组
C：列表
D：其他类型

答案：B

给定变量 name = (‘Jerry’,)，它的数据类型是元组。

第15题

以下代码的运行结果为?（ ）

d1={'学科':'语文','班级':'2班','最高分':99}
d2={'学科':'数学','班级':'2班','最高分':100}
d1.update(d2)
print(d1)

A：{‘学科’:‘语文’,‘班级’:‘2班’,‘最高分’:99}
B：{‘学科’:‘语文’,‘班级’:‘2班’,‘最高分’:100}
C：{‘学科’:‘数学’,‘班级’:‘2班’,‘最高分’:100}
D：{‘学科’:‘数学’,‘班级’:‘2班’,‘最高分’:99}

答案：C

给定的代码中，首先创建了两个字典 d1 和 d2。d1 包含了键值对 ‘学科’:‘语文’、‘班级’:‘2班’、‘最高分’:99，而 d2 包含了键值对 ‘学科’:‘数学’、‘班级’:‘2班’、‘最高分’:100。

然后，使用字典的 update() 方法将 d2 合并到 d1 中。update() 方法会将 d2 中的键值对更新或添加到 d1 中。

最后，使用 print(d1) 输出合并后的 d1 字典。因为 d2 中的键 ‘学科’、‘班级’ 和 ‘最高分’ 的值分别是 ‘数学’、‘2班’ 和 100，所以合并后的结果是 {‘学科’:‘数学’,‘班级’:‘2班’,‘最高分’:100}。

第16题

小明用一个字典d={‘语文’:88,‘数学’:92,‘英语’:‘96’}来储存他的期末考试成绩。则小明的总分是?（ ）
A：

s=0
for i in d.values():
    s=s+int(i)
print(s)

B：

s=0
s=sum((d.values())
print（s）

C：

s=0
while i
    s=s+int(d.values())
print（s）

D：

s=0
for i in d():
        s=s+int(i.values())
    print（s）

答案：A

给定的字典 d 包含了小明的期末考试成绩。为了计算总分，我们可以使用循环遍历字典的值，并将其转换为整数，然后将每个成绩累加到变量 s 上。

所以，选项 A 中的代码可以计算小明的总分，并将结果打印出来。

第17题

如果要计算123456789则下列程序代码正确的是?（ ）
A：

s=0
for i in range(1,10):
    s=s*i
print(s)

B：

s=0
for i in range(1,9):
    s=s*i
print(s)

C：

s=1
for i in range(1,10):
    s=s*i
print(s)

D：

s=1
for i in range(1,9):
    s=s*i
print(s)

答案：C

给定的计算可以通过循环遍历从 1 到 9 的数字，并将每个数字乘以变量 s 的累积结果。初始值为 1，因为乘法的单位元素是 1。

所以，选项 C 中的代码是正确的，它可以计算 1 * 2 * 3 * 4 * 5 * 6 * 7 * 8 * 9 的结果，并将其打印出来。

第18题

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

d={'1':1,'2':2,'3':3,'4':4}
b=d
b['2']=5
print(d['2']+b['2'])

A：4
B：5
C：7
D：10

答案：D

给定的代码创建了一个字典 d，其中包含了键值对 ‘1’:1、‘2’:2、‘3’:3、‘4’:4。然后，将字典 d 赋值给变量 b，这意味着 b 和 d 引用同一个字典对象。

接下来，通过修改 b 的键 ‘2’ 的值为 5（b[‘2’]=5），同时也会修改 d 中 ‘2’ 的值为 5。

最后，打印语句 print(d[‘2’]+b[‘2’]) 计算并输出了键 ‘2’ 对应的值 5 在 d 和 b 中的和。

因此，代码的输出结果是：10，对应选项 D。

第19题

若dic_color={‘red’:‘红色’,‘green’:‘绿色’,‘gold’:‘金色’,‘brown’:‘棕色’,‘purple’:‘紫色’}，以下选项中能够输出’金色’的是?（ ）
A：print(dic_color[‘gold’])
B：print(dic_color[‘金色’])
C：print(dic_color[2])
D：print(dic_color.values[2])

答案：A

给定的字典 dic_color 包含了颜色和对应的中文名称。要输出’金色’，可以使用字典的键 ‘gold’，并通过索引操作获取对应的值。

所以，选项 A 中的代码 print(dic_color[‘gold’]) 可以打印出’金色’。

第20题

以下程序执行的结果是?（ ）

a=0
b=5
Sum=0
for i in range(3):
    if a>0:
        Sum+=a
        a+=1
    elif b>1:
        Sum+=b
    a+=1
    b+=1
print(Sum)

A：7
B：9
C：11
D：12

答案：B

第21题

想得到的输出为"My name is Kevin and I am 10 years old."以下选项正确的是?（ ）
A：print(‘My name is %s and I am %d years old.’,%(‘Kevin’,10))
B：print(‘My name is %s and I am %d years old.’%(‘Kevin’,10))
C：print(‘My name is %c and I am %d years old.’%(‘Kevin’,10))
D：print(‘My name is %s and I am %d years old.’%‘,Kevin’,%10))

答案：B

要格式化字符串中的变量，可以使用 % 运算符结合格式化字符串的占位符。在选项 B 中，使用 %s 表示字符串占位符，%d 表示整数占位符。通过在字符串末尾使用 % 运算符，将要填充的变量值以元组形式传递给字符串。

因此，选项 B 中的代码 print(‘My name is %s and I am %d years old.’ % (‘Kevin’, 10)) 可以打印出期望的输出：“My name is Kevin and I am 10 years old.”

其他选项中的语法都存在错误或不符合格式化字符串的要求。

第22题

编写一段猜密码程序，只允许猜三次，当猜中密码时，提示“密码正确”，程序退出。当输入密码错误时，提示“密码错误”，并提示剩余次数。程序空白处应填写的条件是?（ ）

pwl="999"
abc=3
while ______:
  input1 = input("请输入密码：")
  if(input1==pwl):
    print("密码正确！")
    break
  else:
    abc=abc-1
    print("密码错误！","剩余次数：",abc)

A. abc>0
B. abc>=0
C. abc==0
D. abc!=3

答案：A

根据题目要求，程序只允许猜三次密码。因此，我们需要使用一个变量 abc 来追踪猜测的次数。

在程序中，使用 while 循环来迭代用户的猜测操作。循环的条件应该是猜测次数大于 0，即 abc > 0。当猜测次数达到 0 次时，程序将退出循环。

在每次循环中，需要判断用户输入的密码是否正确。如果密码正确，程序将打印 “密码正确” 并退出循环。如果密码错误，程序将打印 “密码错误” 并提示剩余次数。

因此，选项 A 中的条件 abc > 0 是正确的选择。

第23题

已知a=list(range(10)),执行以下指令后，a的值会变成?（ ）

a[:2]=[5]
a.pop(5)
a.remove(5)

A：[2, 3, 4, 5, 7, 8, 9]
B：[2, 3, 4, 7, 8, 9]
C：[2, 3, 4, 6, 7, 8, 9]
D：[5, 2, 3, 4, 5, 7, 8, 9]

答案：A

执行指令后，列表 a 的值会变成 [2, 3, 4, 5, 7, 8, 9]，选项 A 是正确的答案。

指令 a[:2] = [5] 将列表 a 的前两个元素替换为 [5]，指令 a.pop(5) 移除索引为 5 的元素，即第六个元素，指令 a.remove(5) 移除列表 a 中的第一个值为 5 的元素。

第24题

以下选项中，不能用于表示分支结构的python函数是?（ ）
A：if
B：else
C：in
D：elif

答案：C

在给定的选项中，A：if、B：else 和 D：elif 都是用于表示分支结构的关键字或函数。

if 是用于条件判断的关键字，根据条件的真假执行相应的代码块。
else 是用于 if 语句中的可选部分，表示在条件不满足时执行的代码块。
elif 是 else if 的缩写，用于在多个条件判断中添加额外的条件分支。
然而，选项 C：in 不是用于表示分支结构的函数。它是用于检查一个元素是否存在于一个容器对象中的运算符，通常与条件判断语句配合使用。

因此，选项 C：in 是不能用于表示分支结构的 Python 函数。

第25题

执行以下程序的运行结果为?（ ）

a=range(1,10)
for i in a:
    if i%2 == 0:
        print(i)

A：1 3 5 7 9
B：1 4 7
C：2 4 6 8
D：2 5 7 9

答案：C

给定的程序使用 for 循环遍历了范围对象 a 中的每个元素。

范围对象 a 的取值为 1 到 9（不包括 10），因此循环将迭代以下元素：1, 2, 3, 4, 5, 6, 7, 8, 9。

在循环中，使用条件判断 if i % 2 == 0 来判断当前迭代的元素是否为偶数。如果是偶数，则打印该元素。

根据给定的程序，只有偶数会被打印出来。因此，循环将打印出 2, 4, 6, 8 这四个偶数。

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

第26题

已知Money=8.6675,print(“工资{0:.2f}”.format(Money)),结果是：“工资8.67”。（ ）

答案：正确

给定的代码使用了格式化字符串的方式来输出变量 Money 的值。在格式化字符串中，使用 {0:.2f} 来指定输出的格式，其中 .2f 表示保留两位小数的浮点数。

根据给定的代码，变量 Money 的值为 8.6675。在格式化字符串中，使用 {0:.2f} 来代表变量的位置和格式。其中，0 表示第一个参数，即 Money 的位置，而 :.2f 表示浮点数格式，保留两位小数。

因此，运行代码后，输出的结果是 “工资8.67”，即保留了两位小数的工资金额。

第27题

在使用format()函数对字符串进行格式化时，参数索引从1开始。（ ）

答案：错误

在使用 format() 函数对字符串进行格式化时，参数索引从 0 开始，而不是从 1 开始。

例如，使用 {} 占位符来指示格式化的位置，第一个参数可以通过索引 {0} 来引用，第二个参数可以通过索引 {1} 来引用，依此类推。

name = "Alice"
age = 25
message = "My name is {0} and I'm {1} years old.".format(name, age)
print(message)

输出结果为：

My name is Alice and I'm 25 years old.

第28题

while语句只能用于未知次数的循环，for语句只能用于循环次数己知的循环。（ ）

答案：错误

在 Python 中，while 和 for 语句都可以用于已知次数和未知次数的循环。

while 语句用于在条件为真的情况下重复执行代码块，直到条件为假。这种情况下循环次数是未知的，因为循环的结束取决于条件的满足与否。

for 语句用于迭代遍历一个可迭代对象（如列表、元组、字符串等），每次迭代都会执行一次代码块。循环次数是已知的，取决于可迭代对象的长度。

下面是一个使用 while 和 for 循环的示例：

# 使用 while 循环
count = 0
while count < 5:
    print(count)
    count += 1

# 使用 for 循环
numbers = [1, 2, 3, 4, 5]
for num in numbers:
    print(num)

在这个例子中，while 循环在未知次数的情况下重复执行，直到 count 变量的值达到 5。而 for 循环在已知次数的情况下，依次遍历列表 numbers 中的元素。

第29题

t=(1,2,3,4,2)，则print(t.index(2))的运行结果为1。（ ）

答案：正确

在给定的元组 t=(1,2,3,4,2) 中，调用 t.index(2) 将返回元素 2 在元组中的第一个出现的索引位置。在这种情况下，元素 2 第一次出现在索引位置 1，所以 print(t.index(2)) 的运行结果是 1。

第30题

若s=(1,2,3,4,5)，则执行s.remove(5)语句后，s的值是(1,2,3,4)。（ ）

答案：错误

在 Python 中，元组是不可变的数据类型，因此无法直接修改元组的内容。调用 s.remove(5) 方法尝试从元组 s=(1,2,3,4,5) 中删除元素 5 会引发 AttributeError 异常，因为元组对象没有名为 remove 的方法。

如果要删除元组中的元素，需要创建一个新的元组，其中仅包含不需要删除的元素。例如，可以使用切片操作来实现这一点：

s = (1, 2, 3, 4, 5)
s = s[:s.index(5)] + s[s.index(5)+1:]
print(s)

输出结果为：

(1, 2, 3, 4)

第31题

Python语言用缩进来标识语句块，同一级语句块中的语句具有相同的缩进量。（ ）

答案：正确

在 Python 中，使用缩进来标识语句块（代码块），同一级别的语句块需要具有相同的缩进量。这是 Python 的语法规则之一，被称为缩进规则（Indentation Rule）。

例如，当定义一个函数时，函数体内的语句块需要有相同的缩进量：

def my_function():
    statement1
    statement2
    statement3

在这个例子中，statement1、statement2 和 statement3 都具有相同的缩进，表示它们属于函数 my_function 的语句块。

同样，条件语句（如 if、else、elif）和循环语句（如 for、while）也需要使用相同的缩进来标识其中的语句块。

第32题

表达式[3] in [1,2,3]的值为True。（ ）

答案：错误

在 [3] in [1,2,3] 这个表达式中，左侧的 [3] 是一个包含一个元素 3 的列表，右侧的 [1,2,3] 是一个包含三个元素的列表。

当使用 in 运算符来检查一个元素是否存在于一个列表中时，它会逐个比较列表中的元素和目标元素。在这个例子中，目标元素是 [3]，它与列表 [1,2,3] 中的元素进行比较。

由于列表 [1,2,3] 中没有元素与 [3] 完全匹配，所以表达式的值为 False。

第33题

break语句执行后，将跳出程序所有的循环，程序结束。（ ）

答案：错误

在 Python 中，break 语句用于中断当前循环，并跳出该循环的执行，之后的代码会继续执行。break 语句并不会结束整个程序的执行，只是提前退出当前循环。

当 break 语句被执行时，程序会跳出最内层的循环，然后继续执行循环之后的代码。

第34题

字典中的键和值必须用冒号隔开，同一个字典中的所有键都必须是唯一的。（ ）

答案：正确

在 Python 中，字典中的键和值必须使用冒号 : 隔开。字典是由键值对组成的数据结构，每个键值对之间使用逗号 , 分隔。

例如，下面是一个包含键值对的字典的示例：

my_dict = {"key1": value1, "key2": value2, "key3": value3}

在这个例子中，键和值之间使用冒号 : 隔开，每个键值对之间使用逗号 , 分隔。

另外，同一个字典中的所有键必须是唯一的。如果存在重复的键，后面的键值对会覆盖前面的键值对。

第35题

以下程序的运行结果为 5。（ ）

a=6
b=5
if a>b:
    print(a)
else:
    print(b)

答案：错误

根据给定的程序，变量 a 被赋值为 6，变量 b 被赋值为 5。然后，通过 if 条件语句进行比较。

由于 a 的值大于 b 的值，条件 a > b 为真，因此执行 if 语句块中的代码。在 if 语句块中，使用 print(a) 打印变量 a 的值。

因此，程序的运行结果为 6。

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

第36题

实现统计字符串中的单词和单词出现的次数：
要求如下：
（1）统计的语句为：to be or not to be that is a question
（2）要求统计该句中出现的所有单词和其出现次数。
（3）使用字典进行输出，格式如下（注意：排列顺序可以不一致，但是统计的次数要正确）：
{‘to’: 2, ‘be’: 2, ‘or’: 1, ‘not’: 1, ‘is’: 1, ‘a’: 1, ‘question’: 1, ‘that’: 1}

你可以使用 Python 编程语言来实现该统计功能。下面是一个示例代码：

sentence = "to be or not to be that is a question"

# 将句子拆分成单词列表
words = sentence.split()

# 创建一个空字典用于存储单词和出现次数
word_count = {}

# 统计单词出现次数
for word in words:
    if word in word_count:
        word_count[word] += 1
    else:
        word_count[word] = 1

# 输出统计结果
print(word_count)

运行上述代码，将会输出如下结果：

{'to': 2, 'be': 2, 'or': 1, 'not': 1, 'is': 1, 'a': 1, 'question': 1, 'that': 1}

该代码首先将输入的句子通过 split() 方法拆分成单词列表。然后，使用一个循环遍历单词列表，对每个单词进行统计。

在统计过程中，我们使用一个字典 word_count 来记录每个单词出现的次数。如果单词已经在字典中，就将对应的次数加 1；如果单词不在字典中，就将其添加到字典中，并将次数初始化为 1。

最后，输出字典 word_count，即包含单词和对应出现次数的统计结果。

第37题

可以对任何一个自然数进行若干次运算，最终都可以变为1。
运算规则如下：
（1）若该数是偶数，则变为原数的一半；
（2）若该数是奇数，则变为原数的3倍加1；
（3）重复（1）（2），直到该数变为1。
编写程序实现如下功能：输入一个大于1的自然数，计算按照上述方法最终变换为1共经过的变换次数，并输出变换次数。（输出格式为：直接输出次数即可）
示例1：若输入自然数8，则输出结果为：3。
示例2：若输入自然数5，则输出结果为：5。

你可以使用以下 Python 代码来实现该功能：

def transform_to_one(n):
    count = 0
    while n != 1:
        if n % 2 == 0:
            n = n // 2
        else:
            n = (n * 3) + 1
        count += 1
    return count

# 输入一个大于1的自然数
num = int(input("请输入一个大于1的自然数："))

# 调用函数计算变换次数
result = transform_to_one(num)

# 输出变换次数
print(result)

运行以上代码，你可以输入一个大于1的自然数，程序将根据给定规则计算变换为1所需的次数，并输出结果。

该代码使用一个循环来重复进行变换过程，直到数字变为1。在每次循环中，根据给定的规则，如果数字是偶数，则将其除以2；如果数字是奇数，则将其乘以3再加1。同时，使用一个计数器变量 count 来记录变换次数。

最后，将计数器变量 count 的值作为结果进行输出。