GESP第五次认证真题解析|Python三级真题回顾

1、⼩杨的⽗母最近刚刚给他买了⼀块华为⼿表 ，他说⼿表上跑的是鸿蒙 ，这个鸿蒙是？ ( )

A.⼩程序

B.计时器

C.操作系统

D.神话⼈物

【答案】C

【解析】本题主要考察对“鸿蒙”这一概念的理解及其在华为产品中的应用。鸿蒙在此处指的是华为开发的自有操作系统，而非其他选项所描述的小程序、计时器或神话人物。

选项A“小程序”通常指的是在微信或其他平台上运行的轻量级应用，与手表的操作系统无关。

选项B“计时器”是手表或其他设备上用于计时的功能，与操作系统是两个不同的概念。

选项C“操作系统”是管理计算机硬件与软件资源的程序，鸿蒙正是华为开发的用于其智能设备的操作系统。

选项D“神话人物”与本题的技术背景完全不符，是一个干扰项。

2、中国计算机学会（CCF）在2024年1⽉27⽇的颁奖典礼上颁布了王选奖，王选先⽣的重⼤贡献是（ ）。

A.制造⾃动驾驶汽车

B.创⽴培训学校

C.发明汉字激光照排系统

D.成⽴⽅正公司

【答案】C

【解析】王选先生是中国计算机界的杰出人物，被誉为“汉字激光照排系统之父”。他的主要贡献在于他发明的汉字激光照排系统，这项技术彻底改造了中国的印刷行业，实现了从铅字排版到计算机排版的飞跃，极大地提高了印刷效率和质量。

选项A“制造自动驾驶汽车”与王选先生的贡献不符，自动驾驶汽车是近年来兴起的技术领域，与王选先生的主要工作方向不一致。

选项B“创立培训学校”虽然可能是王选先生的一项社会贡献，但并非他在计算机领域的主要成就，也不是本题所考察的内容。

选项D“成立方正公司”是王选先生参与创立的一家公司，但公司的成立并非他的主要技术贡献，而是他技术创新成果商业化的一个体现。

3、下列流程图的输出结果是？

A. 25

B. 30

C. 35

D. 55

【答案】B

【解析】 从图片中的流程图我们可以看到，程序的执行逻辑如下：

初始化sum为0，i为0。

进入一个循环，条件是i小于等于10。

在循环中，首先判断i除以2的余数是否等于0。

如果等于0（即YES路径），则sum增加i的值，继续循环。

如果不等于0（即NO路径），则sum不增加i的值，继续循环。

无论上述判断结果如何，i的值都增加1。

当i不再满足循环条件（即i>10）时，循环结束。

输出sum的值。

按照上述逻辑，当i的值从0到10依次增加时，sum会增加所有奇数i的值（因为偶数的余数不为0）。所以sum最终增加的是0+2+4+6+8+10=30。

4、在Python语⾔中，hex 函数可以将⼗进制数转换成⼗六进制数 。执⾏语句  hex(2024) 后 ，显⽰的运⾏结 果是？ (  )

A. 0x7e6

B. 0x7e7

C. 0x7e8

D. 0x7e9

【答案】C

【解析】 在Python中，hex函数用于将一个整数转换为十六进制字符串。转换时，结果会带有'0x' 前缀来表示这是一个十六进制数。

给定hex(2024)，我们需要找出2024的十六进制表示。

首先，我们可以手动转换或使用计算器进行转换：

2024除以 16等于 126余 8。

126除以 16等于 7余14（十六进制中，14用E表示）。

7 除以16 等于0 余7。

所以，2024的十六进制表示为7E8。

当使用hex 函数时，会加上'0x' 前缀，所以最终结果为0x7e8。

5、下列说法错误的是？(   )

A.字典是通过key（键）来进⾏访问的 ，跟列表、元组不同

B. a = {} 是⼀个空字典

C. {(1, 2): "123"} 的数据类型是字典

D.字典⼀旦创建不可以被修改

【答案】D

【解析】A.正确。字典（dictionary）在Python中是一个无序的键值对集合。它使用键（key）来访问对应的值（value），这与列表（list）和元组（tuple）通过索引访问的方式是不同的。

B.正确。在Python中，{}用于创建一个空字典。a = {} 就是将一个空字典赋值给变量a。

C.正确。在Python中，字典的键（key）可以是任何不可变类型，如整数、浮点数、字符串、元组等。因此，{(1, 2): "123"} 是一个有效的字典，其中键是一个元组(1, 2)，对应的值是字符串"123"。

D.错误。字典在Python中是可以被修改的。通过赋值操作来修改字典中的值，或者通过del语句来删除键值对。同时，也可以通过键来添加新的键值对到字典中。例如：

d = {'a': 1, 'b': 2}

d['a'] = 3  # 修改键'a'对应的值

d['c'] = 4  # 添加新的键值对

del d['b']   # 删除键'b'及其对应的值

6、使⽤ tuple 函数创建元组错误的是？()

A. a = tuple("1234")

B. a = tuple([10, 20, 30, 40])

C. a = tuple(20, 30)

D. a = tuple({10, 20, 30, 40})

【答案】C.

【解析】A. 正确。tuple("1234")会将字符串"1234" 转换为一个包含字符的元组，即('1', '2', '3', '4')。

B.正确。tuple([10, 20, 30, 40]) 会将列表[10, 20, 30, 40] 转换为一个包含整数的元组，即(10, 20, 30, 40)。

C.错误。tuple函数只接受一个参数，即要转换为元组的对象。如果想创建一个包含两个元素的元组，应该传入一个包含这两个元素的序列（如列表、元组、字符串等），或者显式地使用逗号来创建一个元组，例如a = (20, 30)。直接传入两个参数给tuple 函数会导致语法错误。

D.正确。tuple({10, 20, 30, 40}) 会将集合{10, 20, 30, 40}转换为一个包含整数的元组。注意，由于集合是无序的，所以转换后的元组中元素的顺序可能与集合中的顺序不同，但是元组本身是有序的。

因此，选项C 是错误的，因为它尝试将两个单独的参数传递给tuple 函数，而tuple函数只接受一个参数。正确的做法应该是传入一个包含两个元素的序列，或者直接使用括号和逗号来创建元组。

7、Python代码print(list(range(1, 10))[1::2]) ，输出结果是 ()  ?

A. 上述代码执⾏报错

B. [1, 3, 5, 7, 9]

C. [2, 4, 6, 8, 10]

D. [2, 4, 6, 8]

【答案】D

【解析】首先，range(1, 10) 生成一个从1开始到9结束的整数序列（不包含10），即1, 2, 3, 4, 5, 6, 7, 8, 9。

然后，list(range(1, 10)) 将这个整数序列转换成一个列表，得到[1, 2, 3, 4, 5, 6, 7, 8, 9]。

接着，[1::2]是一个切片操作，表示从索引1开始（即列表中的第二个元素2），每隔2个元素取一个元素，直到列表的末尾。

具体切片操作[start:stop:step] 的含义是：

start：开始索引，默认为0。

stop：结束索引（不包含），默认为列表长度。

step：步长，默认为1。

因此，[1::2]表示从索引1开始，步长为2，一直取到列表末尾。所以取出的元素是[2, 4, 6, 8]。

8、下列Python赋值语句错误的是(   )  ?

A. a = {10, 20, 30} * 3

B. a = (10, 20, 30) * 3

C. a = "123" * 3

D. a = [10, 20, 30] * 3

【答案】A

【解析】A. 错误。在Python中，集合（set）是不可变序列，不支持使用*运算符。B的tuple也是不可变序列，但支持*3，用不可变序列，理由不成立。另外，set是可变序列。

B.正确。元组（tuple）是不可变序列，在Python中允许使用* 运算符来重复元组。这个表达式会创建一个新的元组，其内容为原始元组的内容重复三次，即(10, 20, 30, 10, 20, 30, 10, 20, 30)。

C.正确。字符串（string）是序列类型，支持使用* 运算符进行乘法操作。这个表达式会创建一个新的字符串，其内容为原始字符串的内容重复三次，即"123123123"。

D.正确。列表（list）是可变序列，也支持使用* 运算符进行乘法操作。这个表达式会创建一个新的列表，其内容为原始列表的内容重复三次，即[10, 20, 30, 10, 20, 30, 10, 20, 30]。

9、执⾏下列Python代码 ，输出结果是  ()  ?

A. (1, 3, 3, 6, 8, 9)

B. (9, 8, 6, 3, 3, 1)

C. [9, 8, 6, 3, 3, 1]

D. [1, 3, 3, 6, 8, 9]

【答案】C

【解析】给定的Python代码首先定义了一个元组 a，包含整数 1, 9, 3, 6, 3, 8。

接下来，sorted(a, reverse=True) 函数被用来对元组 a 中的元素进行排序。reverse=True 表示排序应该是降序的，即从大到小。

sorted 函数返回的是一个新的排序后的列表，而不是修改原始元组。这是因为元组在Python中是不可变的，不能被修改。

最后，print(a) 语句打印出排序后的列表。虽然变量 a 最初被赋值为一个元组，但在 sorted 函数调用后，它被重新赋值为一个列表。

因此，输出结果为降序排列的列表 [9, 8, 6, 3, 3, 1]。

10、对于字典 data = { 'apple ': 3.5, 'banana ': 4.0, 'orange ': 6.0} ，删除 'banana ': 4.0 键值对 的正确操作是  ()  ?

A. del data[ 'banana ']

B. del data[ 'banana ': 4.0]

C. del data

D. data.remove( 'banana ')

【答案】A

【解析】A. del data['banana']：这是正确的。del关键字用于删除字典中的键值对。这里，我们传递了键'banana' 给del，所以它会从字典data 中删除'banana': 4.0 这一键值对。

B. del data['banana': 4.0]：这是错误的。在Python中，不能这样使用del 来删除字典中的键值对。需要传递键而不是键值对给del。

C. del data：会删除整个字典data，而不仅仅是'banana': 4.0 这一键值对。

D. data.remove('banana')：这是错误的。remove方法是列表（list）对象的一个方法，而不是字典（dict）对象的方法。

11、在三位数的⾃然数中 ，找出⾄少有⼀位数字是5的所有整数 ，应在横线填⼊代码是 （） 。

A. l st.extend(i)

B. l st.append(i)

C. l st.add(i)

D. l st += i

【答案】B

【解析】题目要求找出三位数中至少有一位数字是5的所有整数，并将这些整数添加到一个列表lst中。

在给出的代码段中，已经通过循环遍历了所有的三位数，并通过取余和整除操作得到了每个数的个位、十位和百位数字，分别赋值给变量a、b和c。

接下来，通过if语句判断个位、十位或百位上是否有数字5。如果有，则需要将这个数添加到列表lst中。

A lst.extend(i)：extend方法用于将一个列表的所有元素添加到另一个列表中。但在这里，i是一个整数，不是列表，所以使用extend会报错。

B.lst.append(i)：append方法用于将一个元素添加到列表的末尾。在这里，我们需要将满足条件的三位数i添加到列表lst中，所以应该使用append方法。

C lst.add(i)：add方法不是列表的方法，而是集合（set）的方法。因此，在这里使用add会报错。

D lst += i：这个表达式实际上是将整数i与列表lst相加，这在Python中是不合法的，因为整数和列表不能进行这样的操作。

12、以下哪个选项可以创建⼀个列表 ，包含 1 到10 的奇数？(    )

A. (x for x in range(1, 11) if x % 2 != 0)

B. (x for x in range(1, 11) if x % 2 != 0

C. [x for x in range(1, 11) if x % 2 != 0]

D. [x for x in range(1, 11)] if x % 2 != 0

【答案】C

【解析】 A选项：(x for x in range(1, 11) if x % 2 != 0) 创建的是一个生成器表达式，而不是列表。生成器表达式使用圆括号() 而不是方括号[]。虽然它确实会生成1 到10 的奇数，但题目要求的是创建一个列表。

B选项：(x for x in range(1, 11) if x % 2 != 0 这个选项是不完整的，因为它缺少了闭合的圆括号)。即使我们加上闭合的圆括号，它仍然是一个生成器表达式，而不是列表。

C选项：[x for x in range(1, 11) if x % 2 != 0] 这是一个列表推导式，它会创建一个包含1 到10 的所有奇数的列表。range(1, 11) 生成一个从1 到10 的整数序列，if x % 2 != 0 是一个条件表达式，用于过滤出其中的奇数。这个选项满足题目的要求。

D选项：[x for x in range(1, 11)] if x % 2 != 0 这个选项的语法是错误的。列表推导式的条件应该放在for循环后面，而不是整个列表推导式后面。此外，它使用了方括号[]，这表示它试图创建一个列表，但由于语法错误，它实际上不会执行任何操作。

13、有⼀组数据 [20, 0, 7, 0, 31] 存放在nums 中 ，希望将列表中的所有零移动到列表尾 ，应在横线填⼊ 代码是 （） 。

A. [0] * (len(nums) - i)

B. [0] * (len(nums) - j)

C. [0] * i

D. [0] * j

【答案】B

【解析】题目要求将列表nums中的所有零移动到列表的末尾。通过给定的代码片段，我们可以看到它使用了双指针的方法来实现这个需求。其中，i指针用于遍历整个列表，而j 指针用于指向非零元素的存放位置。

当nums[i] 不为零时，我们将它放到nums[j] 的位置，并将j指针向前移动一位。这样，当遍历完整个列表后，所有非零元素都被放到了列表的前面，而j 的位置则指向了第一个需要被替换为零的位置。

接下来，我们需要用零来填充从j开始到列表末尾的所有位置。因此，我们需要创建一个包含若干个零的列表，其长度应该是len(nums) - j。这样，当我们使用切片操作nums[j:] = ... 时，就可以将j 及其之后的所有位置替换为零。

14、执⾏下列Python程序 ，最后的输出是  ()   ?

A. 14

B. 16

C. 18

D. 20

【答案】C

【解析】首先，我们分析给出的Python程序。

程序定义了一个列表lst，然后初始化result 和d 为3。接着，程序通过一个for循环遍历lst中的元素（从索引1开始，即第二个元素开始），并在每次迭代中检查当前元素与前一个元素的差是否大于d。

如果当前元素与前一个元素的差大于d，则result 增加d 的值；否则，result增加这两个元素之间的差值。

现在，我们逐步分析lst 中的元素，并计算result 的值：

初始时，result和d 都是3。

遍历到lst[1]（值为2），lst[1] - lst[0] = 2 - 1 = 1，这不大于d，所以result += 1，此时result 变为4。

遍历到lst[2]（值为7），lst[2] - lst[1] = 7 - 2 = 5，这大于d，所以result += d（即加3），此时result 变为7。

遍历到lst[3]（值为10），lst[3] - lst[2] = 10 - 7 = 3，这不大于d，所以result += 3，此时result 变为10。

遍历到lst[4]（值为15），lst[4] - lst[3] = 15 - 10 = 5，这大于d，所以result += d（即加3），此时result 变为13。

遍历到lst[5]（值为17），lst[5] - lst[4] = 17 - 15 = 2，这不大于d，所以result += 2，此时result 变为15。

遍历到lst[6]（值为22），lst[6] - lst[5] = 22 - 17 = 5，这大于d，所以result += d（即加3），此时result 变为18。

因此，最后的输出是18。

15、执⾏下列Python程序 ，最后的输出是  ()   ?

olleh dlrow

hello world

world hello

dlrow olleh

【答案】A

【解析】首先，我们来分析这段Python程序：

s='hello world'：定义了一个字符串s，内容为hello world。

words=s.split()：使用split()方法将字符串s按空格分割成一个列表words。分割后，words的内容为['hello', 'world']。

words=[x[::-1] for x in words]：使用列表推导式对words中的每个元素进行反转操作。x[::-1]是Python中反转字符串或列表的常用方法。所以，words的内容变为['olleh', 'dlrow']。

print(" ".join(words))：使用join()方法将反转后的words列表中的元素用空格连接起来，并打印出来。

因此，最后的输出是：olleh dlrow。

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

1、任何⼀个for循环都可以转化为等价的while循环。

【答案】正确

【解析】在编程中，for循环和while循环是两种常用的循环结构，它们的功能在某种程度上是等价的，也就是说，任何for循环都可以转化为一个等价的while循环。这是因为for循环在内部实现上通常也是基于某种形式的while循环或其他循环结构。

例如，考虑一个常见的for循环遍历数组或列表的情况：

for i in range(10):  

print(i)

这个for循环可以转化为一个等价的while循环：

i = 0  

while i < 10:  

print(i)

i += 1

在这个while循环中，维护了循环变量i，并在每次循环的末尾增加它的值，这与for循环自动处理这些操作是类似的。

虽然任何for循环都可以转化为while循环，但这并不意味着总是应该这样做。for循环通常用于遍历序列（如列表、元组、字符串等），而while循环则用于基于某个条件进行循环。在某些情况下，使用for循环会使代码更简洁、更易于理解。

2、⼩杨今年春节回奶奶家了，奶奶家的数字电视要设置ip地址并接⼊到WIFI盒⼦才能收看节⽬，那这个WIFI盒⼦具有路由器的功能。

【答案】正确

【解析】本题考察的是对WIFI盒子功能的理解。题目中提到小杨在奶奶家需要将数字电视设置ip地址并接入到WIFI盒子才能收看节目，询问这个WIFI盒子是否具有路由器的功能。

首先，我们需要明确什么是路由器。路由器的主要功能包括连接不同的网络，选择信息传送的线路，以及实现网络互联。在家用环境中，路由器通常用于连接互联网，并通过无线或有线方式将网络信号分发给家中的各种设备，如电脑、手机、电视等。

其次，题目中提到的WIFI盒子，如果它能够让数字电视通过设置ip地址并接入来收看节目，那么它至少具备了以下功能：1）为数字电视分配IP地址，这意味着它可能具有DHCP服务器的功能，DHCP服务器是路由器常见的功能之一；2）接入WIFI，这通常意味着WIFI盒子具有无线接入点的功能，这也是路由器的一个关键功能。

3、若s = ["Hello world", "I love GESP", [2024, 100]] ，则len(s)的值为4。

【答案】错误

【解析】在这个判断题中，我们有一个列表s，这个列表包含了三个元素：两个字符串"Hello world" 和"I love GESP"，以及一个列表[2024, 100]。题目要求判断len(s)的值是否为4。

首先，我们需要理解len()函数在Python中的作用。len()函数用于返回对象（如列表、元组、字符串等）的长度或项目数。对于列表，它返回列表中元素的个数。

然后，我们来看列表s的结构。列表s包含了三个元素，不论这些元素是什么类型（字符串或另一个列表），它们在计算len(s)时都只被计为一个元素。因此，列表s的长度是3，而不是4。

最后，我们来比较题目中的判断与实际的len(s)值。题目中说len(s)的值为4，但实际上len(s)的值为3。

4、执⾏Python代码print(set([x % 2 for x in range(10)])) ，输出的结果是{0, 1} 。

【答案】正确

【解析】首先，我们来解析这段代码：

range(10)生成一个包含从0到9的整数序列。

x % 2 for x in range(10) 是一个列表推导式，它遍历range(10)中的每个数x，并计算x除以2的余数。由于我们只关心余数，所以会得到一个由0和1组成的序列。

set([...])将列表推导式生成的列表转换为集合。集合是一个无序且不包含重复元素的集合，因此任何重复的0或1都将被合并为一个。

现在，我们来手动计算这段代码的结果：

0 % 2 = 0

1 % 2 = 1

2 % 2 = 0

3 % 2 = 1

4 % 2 = 0

5 % 2 = 1

6 % 2 = 0

7 % 2 = 1

8 % 2 = 0

9 % 2 = 1

将上述结果放入集合中，我们得到{0, 1}。

因此，执行代码print(set([x % 2 for x in range(10)])) 的输出确实是{0, 1}。

5、Python表达式 5^6的值是15。

【答案】错误

【解析】在Python中，^运算符不是表示乘方（即幂运算），而是表示按位异或操作。这意味着它会对两个数的二进制表示进行异或运算，而不是一个数对另一个数进行幂运算。

因此，Python表达式5^6实际上执行的是5和6的按位异或操作，而不是5的6次幂。在二进制中：

5是0101

6是0110

对这两个数进行按位异或操作后得到的结果是：

0101

0110

0011

这对应的十进制数是3，而不是15。

另外，Python中进行幂运算的正确运算符是**，所以5的6次幂应该表示为5**6，其结果为15625。

6、执⾏Python代码print( 'gesp.ccf.org.cn '.split( '. ')) ，输出的结果是 [ 'gesp ', 'ccf ', 'org ',   'cn '] 。

【答案】正确

【解析】 这段代码执行的是字符串 'gesp.ccf.org.cn'的split()方法，并且使用了点号'.'作为分隔符split()方法的作用是将字符串按照指定的分隔符分割成一个列表，其中分隔符不会被包含在列表的元素中。

'gesp.ccf.org.cn'字符串按照点号'.'分割后，会得到以下列表：

['gesp', 'ccf', 'org', 'cn']

这个列表包含了字符串'gesp.ccf.org.cn'中由点号分隔的各个部分。

因此，执行print('gesp.ccf.org.cn'.split('.'))这段代码，会输出['gesp', 'ccf', 'org', 'cn']。

7、执⾏下列Python代码 ，输出的结果是  None { 'Name ': '小杨', 'Age ': 12, 'Sex ': 'female '} 。

【答案】错误

【解析】首先，我们来分析给出的Python代码。

dict1={"Name":"小杨","Age":13} 这行代码将初始化字典dict1，包含键'Name'和'Age'，其值分别为'小杨'和13。

dict2={"Sex":"female","Age":12} 这行代码将初始化字典dict2，包含键'Sex'和'Age'，其值分别为'female'和12

dict1.update(dict2)  这行代码将使用dict1.update(dict2)更新dict1。update方法会遍历dict2的键值对，并将这些键值对添加到dict1中。如果dict1中已经存在相同的键，那么该键对应的值会被dict2中的值覆盖。在这个例子中，'Age'键的值会从13变为12，同时'Sex'键及其值'female'会被添加到dict1中。

a=dict1.setdefault("Height",165) 使用dict1.setdefault("Height",165)设置dict1中'Height'键的值。如果'Height'键已经存在于dict1中，则setdefault方法不会改变其值，并返回该键对应的值；如果'Height'键不存在，则setdefault方法会在dict1中添加该键，并设置其值为165，然后返回该值。因为在这个例子中，'Height'键原本不存在于dict1中，所以setdefault方法会添加这个键并设置其值为165，然后返回165。

现在，我们来看输出结果。题目中给出的输出结果是None {'Name': '小杨', 'Age': 12, 'Sex': 'female'}，这实际上是不正确的。None部分应该是a的值，但由于a被赋值为dict1.setdefault("Height",165)的返回值，即165，所以输出中None是不正确的。{'Name': '小杨', 'Age': 12, 'Sex': 'female'} 是dict1更新后的内容，这部分是正确的。

8、执⾏下列Python代码print((tuple(range(1, 4)) * 3).index(2)) ，输出的结果是 2。

【答案】错误

【解析】首先，我们来分析这段Python代码：

print((tuple(range(1, 4)) * 3).index(2))

range(1, 4) 生成一个从1到3（不包含4）的整数序列，即[1, 2, 3]。

tuple(range(1, 4)) 将这个整数序列转换成一个元组，即(1, 2, 3)。

(tuple(range(1, 4)) * 3) 将这个元组重复三次，结果是(1, 2, 3, 1, 2, 3, 1, 2, 3)。

.index(2)查找数字2在这个元组中的位置，并返回其索引。

在元组(1, 2, 3, 1, 2, 3, 1, 2, 3) 中，数字2第一次出现的位置是索引1（注意Python的索引是从0开始的）。

因此，.index(2)返回的应该是1，而不是2。

9、执⾏下列Python代码 ，输出的结果是  ["banana", "apple", "orange"] 。

【答案】错误

【解析】首先，我们需要分析给出的Python代码，理解其执行过程，并确定最终打印出的列表内容是否与题目中给出的结果相符。

代码如下：

lis=list('banana')

lis.append('apple')

lis.extend('orange')

print(lis)

lis=list('banana')：这行代码将字符串'banana'转换成一个列表，其中每个字符都是列表的一个元素。因此，lis的初始值为['b', 'a', 'n', 'a', 'n', 'a']。

lis.append('apple')：这行代码在列表lis的末尾添加一个字符串'apple'，而不是将其字符分开添加。因此，列表变为['b', 'a', 'n', 'a', 'n', 'a', 'apple']。

lis.extend('orange')：这行代码将字符串'orange'中的每个字符作为单独的元素添加到列表lis的末尾。所以，列表将变为['b', 'a', 'n', 'a', 'n', 'a', 'apple', 'o', 'r', 'a', 'n', 'g', 'e']。

print(lis)：这行代码将打印列表lis的当前内容。

根据以上分析，最终的输出结果应为['b', 'a', 'n', 'a', 'n', 'a', 'apple', 'o', 'r', 'a', 'n', 'g', 'e']，而不是题目中给出的["banana", "apple", "orange"]。

10、执⾏Python代码print(list("CCFGESP").reverse())与print(list("CCFGESP")[::-1])，其输出的结果相同。

【答案】错误

【解析】首先，我们来分析这两段Python代码的执行过程和输出结果。

print(list("CCFGESP").reverse())

这段代码首先将字符串"CCFGESP"转换为一个列表，然后调用reverse()方法来反转这个列表。然而，reverse()方法是一个原地操作，它直接修改列表本身，而不返回任何值（返回值为None）。因此，当你尝试打印list("CCFGESP").reverse()的结果时，实际上你打印的是None。

print(list("CCFGESP")[::-1])

这段代码首先将字符串"CCFGESP"转换为一个列表，然后使用切片操作[::-1]来反转这个列表。切片操作会返回一个新的列表，这个新列表是原列表的反转。因此，当你打印list("CCFGESP")[::-1]的结果时，你会得到反转后的列表['P', 'S', 'G', 'F', 'C', 'C']。

三、编程题（每题25分，共50分）

1、字母求和

题面描述

小杨同学发明了一种新型密码，对于每一个小写英文字母，该小写字母代表了一个正整数，即该字母在字母顺序中的位置，例如字母a代表了正整数1，字母b代表了正整数2;对于每一个大写英文字母，该大写字母代表了一个负整数，即该字母的ASCI码的相反数，例如字母A代表了正整数-65。小杨同学利用这种方式对一个整数进行了加密并得到了一个由大写字母和小写字母组成的字符串，该字符串中每个字母所代表数字的总和即为加密前的整数，例如aAc对应的加密前的整数为1+(-65)+3=-61。

对于给定的字符串，请你计算出它对应的加密前的整数是多少。

输入格式

第一行一个正整数n，表示字符串中字母的个数。

第二行一个由大写字母和小写字母的字符串T，代表加密后得到的字符串。

输出格式

输出一行一个整数，代表加密前的整数。

样例1

对于全部数据，保证有1≤n≤10⁵。

【解题思路】

这个题目主要考查的是对ASCII码和字母顺序的理解，以及对字符串的遍历和数学运算的掌握。以下是解题思路：

理解加密规则：

小写字母代表其在字母表中的位置，从'a'开始，'a'代表1，'b'代表2，以此类推，直到'z'代表26。

大写字母代表其ASCII码的相反数。ASCII码是计算机中用于表示字符的编码，例如大写字母'A'的ASCII码是65，所以'A'代表-65。

读取输入：

第一行读取一个正整数n，它表示接下来字符串中的字母个数。

第二行读取一个由大写字母和小写字母组成的字符串s。

遍历字符串并计算总和：

初始化一个变量sum为0，用于记录加密前的整数。

遍历字符串s中的每个字符：

如果字符是小写字母，将其转换为对应的正整数（字符的ASCII码值减去'a'的ASCII码值加1）。

如果字符是大写字母，将其转换为对应的负整数（字符的ASCII码值的相反数）。

将得到的整数加到sum中。

输出结果：输出sum作为加密前的整数。

【参考程序】

2、完全平方数

问题描述

小杨同学有一个包含n个非负整数的序列A，他想要知道其中有多少对下标组合< i,j > (1 ≤i,j≤n,i < j)，使得A_i+ A_j是完全平方数。

如果x是完全平方数，则存在非负整数y使得y×y= x 。

输入格式

第一行一个非负整数n，表示非负整数个数。

第二行包含n个非负整数A₁,A₂,...,A_n”，表示序列A包含的非负整数。

输出格式

输出一个非负整数，表示和是完全平方数的非负整数对数。

样例1

对于全部数据，保证有1≤n≤1000,0≤A_i≤10⁵。

【解题思路】

首先，我们需要理解题目的要求。题目给出了一个非负整数序列，我们需要找出这个序列中所有和是完全平方数的数对数量。首先，我们需要明确什么是完全平方数。完全平方数是指一个整数可以表示成某个整数的平方，例如1、4、9、16等都是完全平方数。

要解决这个问题，我们可以采用两层循环遍历序列中的每一个元素，并检查它们的和是否为完全平方数。为了判断一个数是否为完全平方数，我们可以尝试找到一个整数，其平方等于该数。如果找到了这样的整数，那么该数就是完全平方数

【参考程序】