个人名片：
🎓作者简介：嵌入式领域优质创作者
🌐个人主页：妄北y📞个人QQ：2061314755
💌个人邮箱：[mailto:2061314755@qq.com]
📱个人微信：Vir2025WBY🖥️个人公众号：科技妄北
🖋️本文为妄北y原创佳作，独家首发于CSDN🎊🎊🎊
💡座右铭：改造世界固然伟大，但改造自我更为可贵。
专栏导航：
妄北y系列专栏导航:
物联网嵌入式开发项目：大学期间的毕业设计，课程设计，大创项目，各种竞赛项目，全面覆盖了需求分析、方案设计、实施与调试、成果展示以及总结反思等关键环节。📚💼💡
QT基础入门学习：对QT的基础图形化页面设计进行了一个简单的学习与认识，利用QT的基础知识进行了翻金币小游戏的制作。🛠️🔧💭
Linux基础编程：初步认识什么是Linux，为什么学Linux，安装环境，进行基础命令的学习，入门级的shell编程。🍻🎉🖥️
深耕Linux应用开发：分享Linux的基本概念、命令行操作、文件系统、用户和权限管理等，网络编程相关知识，TCP/IP 协议、套接字（Socket）编程等，可以实现网络通信功能。常见开源库的二次开发，如libcurl、OpenSSL、json-c、freetype等💐📝💡
Linux驱动开发：Linux驱动开发是Linux系统不可或缺的组成部分，它专注于编写特殊的程序——驱动程序。这些程序承载着硬件设备的详细信息，并扮演着操作系统与硬件间沟通的桥梁角色。驱动开发的核心使命在于确保硬件设备在Linux系统上顺畅运作，同时实现与操作系统的无缝集成，为用户带来流畅稳定的体验。🚀🔧💻
Linux项目开发：Linux基础知识的实践，做项目是最锻炼能力的一个学习方法，这里我们会学习到一些简单基础的项目开发与应用，而且都是毕业设计级别的哦。🤸🌱🚀
非常期待与您一同在这个广阔的互联网天地里，携手探索知识的海洋，互相学习，共同进步。🌐💫🌱 熠熠星光，照亮我们的成长之路
✨✨ 欢迎订阅本专栏，对专栏内容任何问题都可以随时联系博主，共同书写属于我们的精彩篇章！✨✨
文章介绍：
📚本篇文章将深入剖析xxxx学习的精髓与奥秘，与您一同分享相关知识！🎉🎉🎉
若您觉得文章尚可入目，期待您能慷慨地送上点赞、收藏与分享的三连支持！您的每一份鼓励，都是我创作路上源源不断的动力。让我们携手并进，共同奔跑，期待在顶峰相见的那一天，共庆辉煌！🚀🚀🚀
🙏衷心感谢大家的点赞👍、收藏⭐和评论✍️，您的支持是我前进的动力！
前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。点击跳转到网站：人工智能教程
目录：
一、选择题
1. 下列选项中,不属于Python特点的是(）。
(A)开源
(B)运行效率高
(C)可读性好
(D)面向对象
答案：B
(A) 开源：Python是一种开源编程语言，这意味着它的源代码是公开的，任何人都可以查看、使用和修改它。
(B) 运行效率高：虽然Python是一种功能强大的语言，但它的运行效率通常不如编译型语言如C或C++高。Python是一种解释型语言，这意味着它在运行时逐行解释代码，这通常会导致比编译型语言更慢的执行速度。
(C) 可读性好：Python的设计哲学强调代码的可读性，它使用缩进来定义代码块，而不是使用大括号或其他符号。这使得Python代码通常比其他语言的代码更易于阅读和理解。
(D) 面向对象：Python是一种面向对象的编程语言，支持类和对象的概念，允许开发者使用面向对象的方法来设计和实现程序。
因此，选项 (B) 运行效率高 不是Python的特点。
2. 下列选项中合法的标识符是（)。
(A)7ab
(B)break
(C)_a$b
(D)_7a_b
答案：D
在大多数编程语言中，合法的标识符（identifier）需要遵循以下规则：
1. 标识符不能以数字开头。
2. 标识符只能包含字母、数字和下划线（_）。
3. 标识符不能是保留字或关键字。根据这些规则，我们来分析给出的选项：
(A) 7ab - 不合法，因为它以数字开头。
(B) break - 不合法，因为`break`是大多数编程语言中的关键字。
(C) _a$b - 不合法，因为它包含非法字符`$`。
(D) _7a_b - 合法，因为它以下划线开头，只包含字母、数字和下划线，并且不是关键字。因此，合法的标识符是 (D) _7a_b。
3. len('a\nb\\c')打印在屏幕上为（） 。
(A)7
(B)3
(C)5
(D)4
答案：C
在Python中，`len()`函数用于返回字符串、列表、元组等序列类型中元素的数量。在这个例子中，`len('a\nb\\c')`计算的是字符串`'a\nb\\c'`中字符的数量。
字符串`'a\nb\\c'`包含以下字符：
1. 'a' - 一个普通字符
2. '\n' - 一个换行符（转义字符）
3. 'b' - 一个普通字符
4. '\\' - 一个反斜杠（转义字符）
5. 'c' - 一个普通字符因此，`len('a\nb\\c')`的结果是5。
4. 下面运算符优先级最低的是（） 。
(A)==
(B)+
(C)*=
(D)and
答案：D
在Python中，不同的运算符有不同的优先级。运算符的优先级决定了表达式中各部分的计算顺序。以下是几个给出的运算符的优先级，从高到低排列：
1. `*=` ：这是乘法赋值运算符，属于赋值运算符。
2. `+` ：这是加法运算符，属于算术运算符。
3. `==` ：这是等于运算符，属于比较运算符。
4. `and` ：这是逻辑与运算符，属于布尔运算符。根据优先级的排列：
乘法赋值运算符 (`*=`) 有较高的优先级。
加法运算符 (`+`) 次之。
比较运算符 (`==`) 再次之。
逻辑与运算符 (`and`) 优先级最低。因此，选项中优先级最低的是 (D) `and`。
5. 若alist=[1,2],则执行alist.insert(-1,5)后, alist的值是()。
(A)[5,2,1]
(B)[1,5,2]
(C)[5,1,2]
(D)[1,2,5]
答案：B
在Python中，`list.insert(index, element)`方法用于在列表的指定位置插入一个元素。如果`index`是一个负数，那么它表示从列表的末尾开始计数的位置。例如，`-1`表示列表的最后一个元素，`-2`表示倒数第二个元素，以此类推。
在这个例子中，`alist.insert(-1, 5)`意味着在列表`alist`的倒数第二个位置插入元素`5`。由于`alist`原本只有两个元素`[1, 2]`，倒数第二个位置实际上就是第二个元素`2`之前的位置。
执行`alist.insert(-1, 5)`后，`alist`将变为`[1, 5, 2]`。
6. t=(1,2,3,4,5,6,7,8,9),t[6]指的是()。
(A)8
(B)6
(C)7
(D)5
答案：C
在Python中，元组（tuple）是一种有序的数据类型，可以通过索引来访问其元素。索引是从0开始的，表示元组中的第一个元素。
在这个例子中，元组`t`是`(1, 2, 3, 4, 5, 6, 7, 8, 9)`。要访问索引为6的元素，我们需要从元组的开始计数，第7个元素（因为索引是从0开始的）。
因此，`t[6]`指的是元组中的第7个元素，即`7`。
7. 下面if语句统计满足“性别(gender)为男、职称(rank)为教授、年龄(age)小于40岁”的条件人数，正确的语句为()。
(A)if(gender=='男' or age<40 or rank=='教授'):n+=1
(B)if(gender=='男' and age<40 and rank=='教授'):n+=1
(C)ifgender=='男' and age<40 or rank=='教授'):n+=1
(D)if(gender=='男' or age<40 and rank=='教授'):n+=1
答案：B
在这个问题中，我们需要统计满足以下三个条件的人数：
1. 性别(gender)为男
2. 职称(rank)为教授
3. 年龄(age)小于40岁这三个条件必须同时满足，因此我们需要使用逻辑与（and）运算符来连接这些条件。
选项 (A) 使用了逻辑或（or）运算符，这意味着只要满足其中一个条件，计数器就会增加，这不符合题目要求。
选项 (B) 正确地使用了逻辑与（and）运算符来确保所有三个条件都必须满足。
选项 (C) 的语法不正确，因为它没有在if语句的条件周围加上括号。
选项 (D) 使用了逻辑或（or）运算符，这意味着只要性别为男或者年龄小于40岁，计数器就会增加，这不符合题目要求。
8. 对于字典D={'A':10,'B':20,C':30,'D':40} , sum(list(D.values()))的值是()。
(A)200
(B)100
(C)40
(D)10
答案：B
在这个问题中，我们需要计算字典`D`中所有值的总和。字典`D`的键值对是`{'A':10,'B':20,'C':30,'D':40}`。
首先，我们使用`D.values()`来获取字典中所有的值，这将返回一个包含所有值的视图对象。然后，我们使用`list()`将这个视图对象转换为一个列表。最后，我们使用`sum()`函数来计算列表中所有元素的总和。
执行`sum(list(D.values()))`的操作如下：
1. `D.values()`返回`[10, 20, 30, 40]`。
2. `list(D.values())`转换为列表`[10, 20, 30, 40]`。
3. `sum([10, 20, 30, 40])`计算总和，结果是`100`。因此，`sum(list(D.values()))`的值是`100`。
9. 可以终止循环体语句执行的语句是()。
(A)quit
(B)exit
(C)break
(D)continue
答案：C
在循环体中，`break`语句用于立即终止循环的执行，并跳出循环。当`break`语句被执行时，循环会立即停止，程序控制权会转移到循环后的下一条语句。
选项 (A) `quit` 和 (B) `exit` 通常用于退出整个程序，而不是仅仅终止循环。
选项 (C) `break` 是正确答案，因为它专门用于终止循环。
选项 (D) `continue` 用于跳过当前循环中的剩余语句，并立即开始下一次循环迭代，而不是终止循环。
10. 函数调用时所提供的参数可以是() 。
(A)以上都可以
(B)变量
(C)函数
(D)常量
答案：A
函数调用时所提供的参数可以是多种形式，包括但不限于：
(B) 变量：函数可以接受变量作为参数，这些变量可以是局部变量、全局变量或其他函数的返回值。
(D) 常量：函数也可以直接接受常量作为参数，例如数字、字符串等。
(C) 函数：在某些编程语言中，函数可以作为参数传递给其他函数，这种特性称为高阶函数。
因此，选项 (A) "以上都可以" 是正确的，因为函数调用时所提供的参数可以是变量、常量或函数。
11. 在方法定义中，访问实例属性x的格式是()。
(A)self.getx()
(B)self.x
(C)self[x]
(D)x
答案：B
在面向对象编程中，当我们在类的实例方法中访问实例属性时，通常需要使用特殊的引用`self`来表示当前实例本身。访问实例属性的标准格式是使用`self`加上属性名。
选项 (B) `self.x` 是正确的格式，它表示访问当前实例的属性`x`。
选项 (A) `self.getx()` 假设存在一个名为`getx`的方法，这通常用于封装属性，通过方法来访问或修改属性。
选项 (C) `self[x]` 通常用于访问字典类型的属性，而不是普通的实例属性。
选项 (D) `x` 没有使用`self`，这意味着它不会访问当前实例的属性，而是可能访问局部变量或全局变量。
因此，正确答案是 (B) `self.x`。
12. 在读写文件之前，用于创建文件对象的函数是()。
(A)folder
(B)create
(C)file
(D)open
答案：D
在大多数编程语言中，用于创建文件对象的函数或方法通常是`open`。这个函数或方法允许你打开一个文件，并返回一个文件对象，你可以通过这个对象进行读取或写入操作。
选项 (A) `folder` 通常不是用于创建文件对象的函数，而是与文件夹（目录）操作相关。
选项 (B) `create` 不是一个标准的文件操作函数，尽管它听起来像是用于创建文件的。
选项 (C) `file` 也不是一个标准的用于创建文件对象的函数。
选项 (D) `open` 是正确的，因为它是用于打开文件并创建文件对象的标准函数。
13. 下列关于元组的说法,错误的是()。
(A)用sort()方法可对元组中的元素排序
(B)元组没有append()或extend()方法
(C)元组在定义时所有元素放在一对圆括号"0"中
(D)元组中的元素不能改变和删除
答案： A
元组（Tuple）是许多编程语言中的一种数据结构，它类似于列表（List），但具有不可变性，即一旦创建，其元素不能被修改、添加或删除。
选项 (A) `用sort()方法可对元组中的元素排序` 是错误的。元组是不可变的，因此不能使用`sort()`方法对其元素进行排序。`sort()`方法通常用于列表，而不是元组。
选项 (B) `元组没有append()或extend()方法` 是正确的。由于元组是不可变的，它们不支持`append()`或`extend()`这样的方法来添加元素。
选项 (C) `元组在定义时所有元素放在一对圆括号"0"中` 是正确的。在大多数编程语言中，元组是通过将元素放在圆括号内来定义的。
选项 (D) `元组中的元素不能改变和删除` 是正确的。元组的不可变性意味着一旦创建，其元素就不能被修改或删除。
二、填空题：
1. 整型变量x中存放了一个两位数，要求出这个两位数的十位数字，例如31得到3,正确的Python表达式是【1】。
答案： x//10
要获取一个两位数的十位数字，可以使用整数除法。在Python中，整数除法使用`//`运算符。对于一个两位数，将其除以10，得到的商就是十位数字。
例如，如果`x`是31，那么`x // 10`将得到3。
因此，正确的Python表达式是：`x // 10`
2. Python 3.x语句for i in range(3): print(i,end=',')的输出结果为【1】。
答案： `0,1,2,`
在Python 3.x中，`for i in range(3)`会遍历从0到2的整数（因为`range(3)`生成的是0, 1, 2）。`print(i, end=';,')`会打印出当前的`i`值，并且使用`,`作为结尾，而不是默认的换行符。
因此，执行这段代码的输出结果将是：`0,1,2,`
3. 已知列表x=[1,2,3]，那么执行语句x.insert(0,4)之后，x的值为【1】。
答案：[4, 1, 2, 3]
在Python中，`insert()`方法用于在列表的指定位置插入一个元素。`x.insert(0, 4)`的意思是在列表`x`的索引位置0（即列表的开头）插入元素4。
执行这个操作后，列表`x`的内容将变为：`[4, 1, 2, 3]`
4.len[x for x in range(10)if x%5==0]的值是【1】。
答案：2
这个表达式使用了列表推导式，它生成一个列表，其中包含`range(10)`中所有满足条件`x % 5 == 0`的元素。这个条件意味着只有当`x`是5的倍数时，元素才会被包含在列表中。
`range(10)`生成的是从0到9的整数序列，其中只有0和5是5的倍数。因此，列表推导式生成的列表是`[0, 5]`。
`len()`函数用于计算列表的长度，即列表中元素的数量。在这个例子中，列表`[0, 5]`的长度是2。
所以，`len[x for x in range(10) if x%5==0]`的值是：`2`
5. 列表list=[1，2，3，4，5]，list[3]=【1】。
答案：4
在Python中，列表的索引是从0开始的。因此，列表`list = [1, 2, 3, 4, 5]`中，索引3对应的元素是4。
所以，`list[3]`的值是：`4`
6. 元组t=(2,23,41,3,7,1,10,48,5)max(t)的值是【1】。
答案：48
在Python中，`max()`函数用于返回给定序列中的最大值。对于元组`t = (2, 23, 41, 3, 7, 1, 10, 48, 5)`，`max(t)`将返回元组中的最大值。
在这个元组中，最大值是48。
所以，`max(t)`的值是：`48`
7. 表达式3 in[1,2,3,4]的值为【1】。
答案：True
在Python中，`in`关键字用于检查一个值是否存在于一个序列（如列表、元组、字符串等）中。对于表达式`3 in [1, 2, 3, 4]`，它检查数字3是否存在于列表`[1, 2, 3, 4]`中。
在这个列表中，数字3确实存在。
因此，表达式`3 in [1, 2, 3, 4]`的值是：`True`
8. 已知x={1:1}，那么执行语句x[2]=4之后，len(x)值为【1】。
答案：2
在Python中，字典（dictionary）是一种可变的数据类型，它存储键值对（key-value pairs）。当你创建一个字典`x = {1: 1}`时，它包含一个键值对，其中键是1，值也是1。
当你执行语句`x[2] = 4`时，你向字典`x`中添加了一个新的键值对，其中键是2，值是4。
因此，字典`x`现在包含两个键值对：`{1: 1, 2: 4}`。
`len(x)`函数用于返回字典中键值对的数量。在这个例子中，字典`x`有两个键值对。
所以，`len(x)`的值是：`2`
9. 语句int('2')+3执行后的输出结果是【1】。
答案：5
在Python中，`int()`函数用于将一个字符串或数字转换为整数。在这个例子中，`int('2')`将字符串`'2'`转换为整数2。
然后，这个整数2与整数3相加，得到结果5。
因此，语句`int('2') + 3`执行后的输出结果是：`5`
10. Python内置函数【1】可以返回列表、元组、字典、集合、字符串以及range对象中元素个数。
答案：len()
在Python中，内置函数`len()`可以返回列表、元组、字典、集合、字符串以及range对象中元素的个数。
因此，正确答案是：`len()`
11. Python使用【1】关键字来定义类。
答案：class
在Python中，使用关键字`class`来定义类。
因此，正确答案是：`class`
12. 已知x='a234b123c'，并且re模块已导入，则表达式re.split ('\d+'，x)的值为【1】。
答案：['a','b','c']
在Python中，使用`re.split()`函数可以根据正则表达式分割字符串。在这个例子中，正则表达式`'\d+'`匹配一个或多个连续的数字。
给定的字符串`x='a234b123c'`，使用`re.split('\d+', x)`将按照数字序列分割字符串。
执行`re.split('\d+', x)`后，结果将是：['a', 'b', 'c']
13. 表达式‘Hello world! '.count ("I")的值为【1】。
答案：3
在Python中，字符串的`.count()`方法用于计算指定子字符串在原字符串中出现的次数。
给定的字符串是`'Hello world!'`，而我们要查找的子字符串是`"I"`。
执行`'Hello world!'.count("I")`后，结果将是：3
字符串`'Hello world!'`中包含字母`"I"`为3个。
14. 表达式[1，2,3]*3的值为【1】。
答案：[1,2,3,1,2,3,1,2,3]
这个表达式 `[1,2,3]*3` 的值实际上是 `[1,2,3,1,2,3,1,2,3]`，而不是 `[1]`。这是一个列表重复三次的操作，其中列表 `[1,2,3]` 被重复了三次，生成了一个新的列表。
所以，正确的答案应该是 `[1,2,3,1,2,3,1,2,3]`。
15.表达式{1,2,3,4}-{3,4,5,6}的值为【1】。
答案：{1,2}
表达式 `{1,2,3,4} - {3,4,5,6}` 使用的是集合的差集操作，它将返回在第一个集合 `{1,2,3,4}` 中而不在第二个集合 `{3,4,5,6}` 中的元素。
执行这个操作后，结果集合将包含 `{1,2}`，因为只有 `1` 和 `2` 是第一个集合中的元素，而不在第二个集合中。
所以，正确的答案应该是 `{1,2}`，而不是 `{1}`。
16. 执行下面程序段后，k值是【1)】。
k=1
n=263
while(n):
k*=n%10
n//=10答案： 36
这段代码是一个Python程序段，它计算了一个数字 `n` 的各位数字的乘积，并将结果存储在变量 `k` 中。让我们逐步解释这段代码：
1. `k = 1`：初始化变量 `k` 为 1。
2. `n = 263`：给变量 `n` 赋值为 263。
3. `while(n):`：开始一个循环，只要 `n` 不为零，循环就会继续。
4. `k *= n % 10`：在每次循环中，将 `k` 乘以 `n` 的个位数（`n % 10` 得到 `n` 的个位数）。
5. `n //= 10`：将 `n` 整除以 10，这样 `n` 的个位数就会被移除，准备下一次循环。现在，我们来执行这个程序段：
第一次循环：`n` 是 263，`n % 10` 是 3，所以 `k` 变成 1 * 3 = 3。然后 `n` 变成 263 // 10 = 26。
第二次循环：`n` 是 26，`n % 10` 是 6，所以 `k` 变成 3 * 6 = 18。然后 `n` 变成 26 // 10 = 2。
第三次循环：`n` 是 2，`n % 10` 是 2，所以 `k` 变成 18 * 2 = 36。然后 `n` 变成 2 // 10 = 0。当 `n` 变成 0 时，循环结束。此时 `k` 的值是 36。
所以，执行这段程序后，`k` 的值是 36，而不是 1。
17. 表达式sorted({'a': 3, 'b': 9, 'c': 78}.values())的值为【1】。
答案： [3,9,78]
具体的步骤如下：
1. 获取字典 `{'a': 3, 'b': 9, 'c': 78}` 的所有值：[3, 9, 78]。
2. 对这些值进行排序：[3, 9, 78]。因此，表达式 `sorted({'a': 3, 'b': 9, 'c': 78}.values())` 的值是 `[3, 9, 78]`。
所以，正确答案应该是 `[3, 9, 78]`。
18. Python可以使用【1】函数打开文件。
答案：open()
在Python中，可以使用 `open()` 函数来打开文件。这个函数是Python内置的，用于打开一个文件，并返回一个文件对象，之后可以对这个文件对象进行读取、写入或其他操作。
`open()` 函数的基本语法如下：
file = open(filename, mode)其中：
filename` 是文件的路径和名称。
mode` 是打开文件的模式，例如 `'r'` 表示只读，`'w'` 表示写入（会先清空文件），`'a'` 表示追加，`'b'` 表示以二进制模式打开，等等。例如，要打开一个名为 `example.txt` 的文件进行读取，可以使用以下代码：
file = open('example.txt', 'r')因此，正确答案是 `open()`。
三、判断题：
1. Python 3.x完全兼容Python 2.x。
答案：X
不，Python 3.x 不完全兼容 Python 2.x。Python 3.x 是对 Python 2.x 的一个重大更新，它引入了许多不向后兼容的改变。这些改变包括但不限于：
print 函数：在 Python 2.x 中，
print "Hello, World"，而在 Python 3.x 中，print("Hello, World")。整数除法：在 Python 2.x 中，两个整数相除会得到一个整数，如
5 / 2结果为2。而在 Python 3.x 中，5 / 2会得到2.5，除非使用整数除法运算符//。Unicode 字符串：在 Python 2.x 中，字符串默认是 ASCII 编码，而在 Python 3.x 中，字符串默认是 Unicode 编码。
异常处理：在 Python 3.x 中，异常处理语法有所改变，例如
except Exception, e变为except Exception as e。xrange 函数：在 Python 2.x 中，
xrange函数用于创建一个迭代器，而在 Python 3.x 中，range函数的行为类似于 Python 2.x 中的xrange。字典的
keys(),values(),items()方法：在 Python 3.x 中，这些方法返回视图，而不是列表。新的语法和库：Python 3.x 引入了新的语法和库，这些在 Python 2.x 中不存在。
由于这些不兼容的改变，直接将 Python 2.x 的代码迁移到 Python 3.x 可能需要进行一些修改。为了帮助开发者迁移，有一些工具如
2to3可以自动转换代码，但某些情况下可能需要手动调整。
2.Python变量名必须以字母或下划线开头，并且区分字母大小写。
答案：√
对的，在Python中，变量名的命名规则如下：
必须以字母或下划线开头：变量名的第一个字符必须是字母（a-z, A-Z）或下划线（_）。
后面可以跟字母、数字或下划线：在第一个字符之后，变量名可以包含字母、数字或下划线。
区分大小写：在Python中，变量名是区分大小写的。例如，
myVariable和myvariable是两个不同的变量。不能使用Python的关键字：变量名不能使用Python的保留字或关键字，如
if、else、while、for等。
3. 假设x为列表对象，那么x.pop()和x.pop(-1)的作用是一样的。
答案：√
是的，
x.pop()和x.pop(-1)在大多数情况下作用是一样的。
x.pop()方法默认删除并返回列表中的最后一个元素。在Python中，列表的索引是从0开始的，因此最后一个元素的索引是-1。
x.pop(-1)方法明确指定要删除的元素的索引为-1，也就是列表的最后一个元素。因此，无论是使用
x.pop()还是x.pop(-1)，它们都会删除并返回列表x的最后一个元素。
4. 在Python中，选择结构和循环结构必须带有else子句。
答案：X
不，。在Python中，选择结构（如
if语句）和循环结构（如for和while循环）并不必须带有else子句。else子句是可选的，它们可以根据需要被包含或省略。
5. 列表、元组、宇符串支持双向索引，-1表示最后一个元的下标。
答案：√
是的，在Python中，列表、元组和字符串都支持双向索引，这意味着它们不仅可以通过正数索引从前往后访问元素，还可以通过负数索引从后往前访问元素。
具体来说：
正数索引：从0开始，表示从序列的第一个元素开始计数。例如，
my_list[0]访问列表的第一个元素。负数索引：从-1开始，表示从序列的最后一个元素开始计数。例如，
my_list[-1]访问列表的最后一个元素，my_list[-2]访问列表的倒数第二个元素，依此类推。
6. 如果仅仅是用于控制循环次数，那么使用for iin range(20)和for i in range(20,40)的作用是等价的。
答案：√
对，
for i in range(20)和for i in range(20, 40)的作用并不等价。
for i in range(20)会生成一个从0到19的整数序列，因此循环会执行20次。如果仅仅是用于控制循环次数这关回答就是对的
7. 在调用函数时，可以通过关键参数的形式进行传值，从而避免必须记住函数形参顺序的麻烦。
答案： √
是的，。在Python中，调用函数时可以使用关键参数（keyword arguments）来指定参数的值，这样可以不必严格遵守参数的顺序。使用关键参数的好处是，它使得代码更加清晰易读，因为参数的名称和对应的值直接关联起来，减少了因参数顺序错误而导致的潜在问题。
8. 如果只需要math模块中的sin()函数，建议使用from math import sin来导入，而不要使用import math导入整个模块。
答案：√
是的，在Python中，如果你只需要使用模块中的某个特定函数或变量，使用
from module import item的语法可以减少命名空间的冲突，并使代码更加清晰和简洁。这种方式只导入你需要的部分，而不是整个模块，这样可以减少内存的使用，并且避免在代码中使用长前缀（如math.sin）。
四、程序填空
第一题：
# -*- coding:cp936 -*-
'''------------------------------------------------------
【程序填空】
---------------------------------------------------------
以下程序将下列列表中偶数变成其平方，其他不变,列表长度不固定
------------------------------------------------------------
注意：除要求填空的位置之外，请勿改动程序中的其他内容。
------------------------------------------------------'''
s=[2,3,56,23,89,90,12,33,67,59]
#**********SPACE**********
for i in range (【?】):
#**********SPACE**********
【?】s[i]=s[i]*s[i]
print(s)
解析：
在这个程序中，我们需要填空的两个地方是：
1. 第一个空格处应该指定循环的范围，即列表 `s` 的长度。
2. 第二个空格处应该检查列表中的每个元素是否为偶数，并将其替换为其平方。
下面是填空后的完整程序：
# -*- coding:cp936 -*-
'''------------------------------------------------------
【程序填空】
---------------------------------------------------------
以下程序将下列列表中偶数变成其平方，其他不变,列表长度不固定
------------------------------------------------------------
注意：除要求填空的位置之外，请勿改动程序中的其他内容。
------------------------------------------------------'''
s=[2,3,56,23,89,90,12,33,67,59]
#**********SPACE**********
for i in range(len(s)):
#**********SPACE**********
if s[i] % 2 == 0:
s[i] = s[i] * s[i]
print(s)这个程序会遍历列表 `s` 中的每个元素，检查它是否为偶数。如果是偶数，就将其替换为其平方。最后，程序打印出修改后的列表。
运行效果：
第二题：（6分拿4分）
# -*- coding:cp936 -*-
'''------------------------------------------------------
【程序填空】
---------------------------------------------------------题目：用选择法进行排序。
---------------------------------------------------------
注意：除要求填空的位置之外，请勿改动程序中的其他内容。
------------------------------------------------------'''
def main():
print('请分别输入10个数字:')
a=[]
#**********SPACE**********
for n in range(【?】):
a.append(int(input("请输入一个整型数值，并按回车继续:")))
#**********SPACE**********
for i in range(【?】):
min=i
#**********SPACE**********
for j in range(【?】,10):
if a[min]>a[j]:
min=j
if min!=i:
t=a[min]
a[min]=a[i]
a[i]=t
print(a)
if __name__ == '__main__':
main()
解析：
在这个程序中，我们需要填空的三个地方是：
1. 第一个空格处应该指定循环的范围，即10次，用于接收用户输入的10个数字。
2. 第二个空格处应该指定循环的范围，即10次，用于对列表 `a` 进行选择排序。
3. 第三个空格处应该指定内部循环的范围，用于比较并找到列表中的最小值。
下面是填空后的完整程序：
# -*- coding:cp936 -*-
'''------------------------------------------------------
【程序填空】
---------------------------------------------------------
题目：用选择法进行排序。
---------------------------------------------------------
注意：除要求填空的位置之外，请勿改动程序中的其他内容。
------------------------------------------------------'''
def main():
print('请分别输入10个数字:')
a=[]
#**********SPACE**********
for n in range(10):
a.append(int(input("请输入一个整型数值，并按回车继续:")))
#**********SPACE**********
for i in range(10):
min=i
#**********SPACE**********
for j in range(i + 1, 10):
if a[min]>a[j]:
min=j
if min!=i:
t=a[min]
a[min]=a[i]
a[i]=t
print(a)
if __name__ == '__main__':
main()这个程序会接收用户输入的10个数字，并使用选择排序算法对这些数字进行排序。选择排序的基本思想是每次从待排序的元素中选出最小（或最大）的一个元素，放到序列的起始位置，直到全部待排序的数据元素排完。在这个程序中，我们通过两层循环来实现这一过程：外层循环控制排序的轮数，内层循环用于在未排序的部分中找到最小元素。
运行效果：
第三题：（6分拿4分）
# -*- coding:cp936 -*-
'''------------------------------------------------------
【程序填空】
---------------------------------------------------------题目：输入3个数a,b,c，按从小到大的顺序输出。
说明：采用冒泡排序法
---------------------------------------------------------
注意：除要求填空的位置之外，请勿改动程序中的其他内容。
------------------------------------------------------'''
def Sort(list):
n = len(list)
#**********SPACE**********
for i in range(【?】, n):
#**********SPACE**********
for j in range(1, 【?】):
if list[j - 1] > list[j]:
#**********SPACE**********
list[j - 1], list[j] 【?】 list[j], list[j - 1]
print(list)def inputData():
list_first = []
a = input("请输入整数a:".strip())
list_first.append(int(a))
b = input("请输入整数b:".strip())
list_first.append(int(b))
c = input("请输入整数c:".strip())
list_first.append(int(c))
return list_first
def main():
lt = inputData()
print("输入列表为：")
print(lt)
print("从小到大的顺序为：")
Sort(lt)
if __name__ == '__main__':
main()
解析：
在这个程序中，我们需要填空的三个地方是：
1. 第一个空格处应该指定外层循环的范围，即从0到列表长度减1。
2. 第二个空格处应该指定内层循环的范围，即从1到列表长度减当前外层循环的索引。
3. 第三个空格处应该实现元素的交换。
下面是填空后的完整程序：
# -*- coding:cp936 -*-
'''------------------------------------------------------
【程序填空】
---------------------------------------------------------
题目：输入3个数a,b,c，按从小到大的顺序输出。
说明：采用冒泡排序法
---------------------------------------------------------
注意：除要求填空的位置之外，请勿改动程序中的其他内容。
------------------------------------------------------'''
def Sort(list):
n = len(list)
#**********SPACE**********
for i in range(1, n):
#**********SPACE**********
for j in range(1, n - i + 1):
if list[j - 1] > list[j]:
#**********SPACE**********
list[j - 1], list[j] = list[j], list[j - 1]
print(list)
def inputData():
list_first = []
a = input("请输入整数a:".strip())
list_first.append(int(a))
b = input("请输入整数b:".strip())
list_first.append(int(b))
c = input("请输入整数c:".strip())
list_first.append(int(c))
return list_first
def main():
lt = inputData()
print("输入列表为：")
print(lt)
print("从小到大的顺序为：")
Sort(lt)
if __name__ == '__main__':
main()这个程序会接收用户输入的3个数字，并使用冒泡排序算法对这些数字进行排序。冒泡排序的基本思想是通过重复地遍历要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。遍历数列的工作是重复进行直到没有再需要交换，也就是说该数列已经排序完成。在这个程序中，我们通过两层循环来实现这一过程：外层循环控制排序的轮数，内层循环用于比较相邻元素并进行交换。
运行效果：
五、程序改错
第一题：
# -*- coding:cp936 -*-
'''------------------------------------------------------
【程序改错】
---------------------------------------------------------题目：一个整数，它加上100后是一个完全平方数，再加上168又
是一个完全平方数，请问该数是多少？
请改正程序中的错误，使它能得出正确的结果。---------------------------------------------------------
注意：不可以增加或删除程序行，也不可以更改程序的结构。
------------------------------------------------------'''
def main():
t = []
#**********FOUND**********
for m in range(168)
for n in range(m):
#**********FOUND**********
if m**2 - n**2 = 168
#**********FOUND**********
x = n*2 - 100
t.append(x)
print('符合条件的整数有：',t )
if __name__ == '__main__':
main()
解析：
在这个程序中，有三个错误需要修正。
1. 第一个错误是在 `for m in range(168)` 语句中缺少了冒号 `:`，这是Python语法要求的。
2. 第二个错误是在 `if m**2 - n**2 = 168` 语句中使用了单个等号 `=`，这在Python中是赋值操作符，而这里需要使用双等号 `==` 来进行比较，并且缺少冒号：。
3. 第三个错误标记实际上是正确的，但可能需要解释。这里计算 `x = n*2 - 100` 是因为题目要求找到一个数，它加上100后是一个完全平方数，再加上168又是一个完全平方数。通过解方程 `(n+100)^2 - n^2 = 168` 可以得到这个表达式。
# -*- coding:cp936 -*-
'''------------------------------------------------------
【程序改错】
---------------------------------------------------------
题目：一个整数，它加上100后是一个完全平方数，再加上168又
是一个完全平方数，请问该数是多少？
请改正程序中的错误，使它能得出正确的结果。
---------------------------------------------------------
注意：不可以增加或删除程序行，也不可以更改程序的结构。
------------------------------------------------------'''
def main():
t = []
#**********FOUND**********
for m in range(168): # 错误：缺少冒号
for n in range(m):
#**********FOUND**********
if m**2 - n**2 == 168: # 错误：使用单个等号进行赋值，应使用双等号进行比较，并且缺少冒号
#**********FOUND**********
x = n*2 - 100 # 这里没有错误，但可能需要解释
t.append(x)
print('符合条件的整数有：',t )
if __name__ == '__main__':
main()运行效果：
第二题：
# -*- coding:cp936 -*-
'''------------------------------------------------------
【程序改错】
---------------------------------------------------------题目：读取7个数(（1-50）的整数值)，每读取一个值，程序打印
出该值个数个＊。如输入3，输出***
请改正程序中的错误，使它能得出正确的结果。---------------------------------------------------------
注意：不可以增加或删除程序行，也不可以更改程序的结构。
------------------------------------------------------'''
def main():
n = 1
#**********FOUND**********
while n < 7
a = int(input('请输入一个整数值，并按回车继续:'))
#**********FOUND**********
while a <= 1 or a >= 50
a = int(input('范围是1-50，请重新输入:'))
#**********FOUND**********
print(a , '*')
n += 1
if __name__ == '__main__':
main()
解析：
在这个程序中，有三个错误需要修正。下面是修正后的代码：
1. 第一个错误是在 `while n < 7` 语句中缺少了冒号 `:`，这是Python语法要求的。并且读取7个数应该是while n <= 7
2. 第二个错误是在 `while a <= 1 or a >= 50` 语句后缺少了冒号 `:`
3. 第三个错误是在 `print(a , '*')` 语句中，应该使用 `'*' * a` 来打印a个星号，而不是仅仅打印a和星号，应该是`print(a * '*')。
# -*- coding:cp936 -*-
'''------------------------------------------------------
【程序改错】
---------------------------------------------------------
题目：读取7个数(（1-50）的整数值)，每读取一个值，程序打印
出该值个数个＊。如输入3，输出***
请改正程序中的错误，使它能得出正确的结果。
---------------------------------------------------------
注意：不可以增加或删除程序行，也不可以更改程序的结构。
------------------------------------------------------'''
def main():
n = 1
#**********FOUND**********
while n <= 7:
a = int(input('请输入一个整数值，并按回车继续:'))
#**********FOUND**********
while a < 1 or a > 50:
a = int(input('范围是1-50，请重新输入:'))
#**********FOUND**********
print(a * '*')
n += 1
if __name__ == '__main__':
main()
修正后的程序将正确地读取7个1到50之间的整数，并打印出相应数量的星号。
运行效果：
第三题：
# -*- coding:cp936 -*-
'''------------------------------------------------------
【程序改错】
---------------------------------------------------------题目：find_max()的功能是在列表中找到年龄最大的人，并输出。
---------------------------------------------------------
注意：不可以增加或删除程序行，也不可以更改程序的结构。
------------------------------------------------------'''
def find_max(dict):
max_age = 0
#**********FOUND**********
for value in dict.items():
#**********FOUND**********
if value >= max_age:
max_age = value
#**********FOUND**********
name == key
print(name)
print(max_age)
def main():
person = {"li":18,"wang":50,"zhang":20,"sun":22}
find_max(person)if __name__ == '__main__':
main()
解析：
在这个程序中，有三个错误需要修正。下面是修正后的代码：
1. 第一个错误是在 `for value in dict.items():` 语句中，应该使用 `for key, value in dict.items():` 来同时获取键和值。
2. 第二个错误是在 `if value >= max_age:` 语句中，应该使用 `if value > max_age:` 来确保找到的是最大的年龄，而不是等于当前最大年龄的值。
3. 第三个错误是在 `name == key` 语句中，应该使用 `name = key` 来进行赋值。
# -*- coding:cp936 -*-
'''------------------------------------------------------
【程序改错】
---------------------------------------------------------
题目：find_max()的功能是在列表中找到年龄最大的人，并输出。
---------------------------------------------------------
注意：不可以增加或删除程序行，也不可以更改程序的结构。
------------------------------------------------------'''
def find_max(dict):
max_age = 0
#**********FOUND**********
for key, value in dict.items(): # 错误：需要同时获取键和值
#**********FOUND**********
if value > max_age: # 错误：应该使用大于号来比较，而不是大于等于号
max_age = value
#**********FOUND**********
name = key # 错误：使用双等号进行赋值，而不是单等号
print(name)
print(max_age)
def main():
person = {"li":18,"wang":50,"zhang":20,"sun":22}
find_max(person)
if __name__ == '__main__':
main()修正后的程序将正确地在字典中找到年龄最大的人，并输出其姓名和年龄。
运行效果：
六、程序设计
第一题：
# -*- coding:cp936 -*-
'''------------------------------------------------------
【程序设计】
---------------------------------------------------------题目：统计不同字符个数。用户从键盘输入一行字符，编写一个程序，统计并输出其中
英文字符、数字、空格和其他字符的个数。输入输出结果实例：
【请输入一行字符：】sfdfg gg 54 7657 $%^&&**
数字有6个
字母有7个
空格有4个
其他字符有7个
------------------------------------------------------'''
def main():letter=0
space=0
digit=0
others=0
s = input("【请输入一行字符：】")#**********Program**********
#********** End **********
print("数字有{}个".format(digit))
print("字母有{}个".format(letter))
print("空格有{}个".format(space))
print("其他字符有{}个".format(others))if __name__ == '__main__':
main()
解析：
# -*- coding:cp936 -*-
'''------------------------------------------------------
【程序设计】
---------------------------------------------------------
题目：统计不同字符个数。用户从键盘输入一行字符，编写一个程序，统计并输出其中
英文字符、数字、空格和其他字符的个数。
输入输出结果实例：
【请输入一行字符：】sfdfg gg 54 7657 $%^&&**
数字有6个
字母有7个
空格有4个
其他字符有7个
------------------------------------------------------'''
def main():
letter = 0
space = 0
digit = 0
others = 0
s = input("【请输入一行字符：】")
#**********Program**********
for char in s:
if char.isalpha(): # 检查字符是否为英文字母
letter += 1
elif char.isdigit(): # 检查字符是否为数字
digit += 1
elif char.isspace(): # 检查字符是否为空格
space += 1
else: # 其他字符
others += 1
#********** End **********
print("数字有{}个".format(digit))
print("字母有{}个".format(letter))
print("空格有{}个".format(space))
print("其他字符有{}个".format(others))
if __name__ == '__main__':
main()在这个程序中，我们使用了一个循环来遍历输入的字符串中的每个字符。我们使用Python的内置字符串方法 `isalpha()`, `isdigit()`, 和 `isspace()` 来检查每个字符的类型，并相应地增加计数器。如果字符不属于上述任何一类，我们就将其归类为“其他字符”。最后，我们打印出每种类型的字符数量。
运行结果：
第二题：
# -*- coding:cp936 -*-
'''------------------------------------------------------
【程序设计】
---------------------------------------------------------题目：从键盘输入某一年，请编写fun函数，其功能为判断该年是
否为闰年。说明：闰年的条件是：
（1）能被4整除但不能被100整除。
（2）能被400整除。符合任何一个条件就是闰年。
（3）输入年份为整型。例如：括号内是说明
输入：
2000 (year=2000)
输出：
2000是闰年---------------------------------------------------------
注意：部分源程序给出如下。请勿改动主函数main和其它函数中的
任何内容，仅在函数的注释标志之间填入所编写的若干语句。
------------------------------------------------------'''
def fun(year):
#**********Program**********#********** End **********
def main():
print("【请连续四次判断输入的某一年是否为闰年：】")
for n in range(4):
print("【第%d次：】" %(n+1))
year = int(input("【请输入一个年份：】"))
if fun(year):
print("{0}是【闰年】".format(year))
else:
print("{0}不是【闰年】".format(year))if __name__ == '__main__':
main()
解析：
# -*- coding:cp936 -*-
'''------------------------------------------------------
【程序设计】
---------------------------------------------------------
题目：从键盘输入某一年，请编写fun函数，其功能为判断该年是
否为闰年。
说明：闰年的条件是：
（1）能被4整除但不能被100整除。
（2）能被400整除。符合任何一个条件就是闰年。
（3）输入年份为整型。
例如：括号内是说明
输入：
2000 (year=2000)
输出：
2000是闰年
---------------------------------------------------------
注意：部分源程序给出如下。请勿改动主函数main和其它函数中的
任何内容，仅在函数的注释标志之间填入所编写的若干语句。
------------------------------------------------------'''
def fun(year):
#**********Program**********
if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
return True
else:
return False
#********** End **********
def main():
print("【请连续四次判断输入的某一年是否为闰年：】")
for n in range(4):
print("【第%d次：】" %(n+1))
year = int(input("【请输入一个年份：】"))
if fun(year):
print("{0}是【闰年】".format(year))
else:
print("{0}不是【闰年】".format(year))
if __name__ == '__main__':
main()在这个程序中，我们定义了一个名为 `fun` 的函数，它接受一个年份作为参数。函数内部使用闰年的定义来检查输入的年份是否为闰年。如果年份满足闰年的条件，函数返回 `True`，否则返回 `False`。主函数 `main` 使用一个循环来连续四次接收用户输入的年份，并调用 `fun` 函数来判断这些年份是否为闰年，然后输出相应的结果。
运行结果：
第三题：
# -*- coding:cp936 -*-
'''------------------------------------------------------
【程序设计】
---------------------------------------------------------题目：用户输入若干个分数，求所有分数的平均分。每输入一个
分数后询问是否继续输入下一个分数，回答“yes”、“no”
之外的字符就提示只能输入yes或no并继续询问是否继续输入
下一个分数，回答“yes”就继续输入下一个分数，回答“no”
就停止输入，结束程序例如：
【请输入成绩：】90
【继续输入成绩吗？（yes/no）】yes
【请输入成绩：】91
【继续输入成绩吗？（yes/no）】yes
【请输入成绩：】92
【继续输入成绩吗？（yes/no）】n
只能输入yes或no
【继续输入成绩吗？（yes/no）】no
【所有分数的平均分为】91.00---------------------------------------------------------
注意：部分源程序给出如下。请勿改动主函数main和其它函数中的
任何内容，仅在函数的注释标志之间填入所编写的若干语句。
------------------------------------------------------'''
def main():
number=0
total=0
while True:
chenji=float(input("【请输入成绩：】"))
number+=1
total+=chenji
while True:
flag = input('【继续输入成绩吗？（yes/no）】')
#********** Program **********
#********** End **********
print('【所有分数的平均分为】%.2f'%(total/number))
if __name__ == '__main__':
main()
解析：
# -*- coding:cp936 -*-
'''------------------------------------------------------
【程序设计】
---------------------------------------------------------
题目：用户输入若干个分数，求所有分数的平均分。每输入一个
分数后询问是否继续输入下一个分数，回答“yes”、“no”
之外的字符就提示只能输入yes或no并继续询问是否继续输入
下一个分数，回答“yes”就继续输入下一个分数，回答“no”
就停止输入，结束程序
例如：
【请输入成绩：】90
【继续输入成绩吗？（yes/no）】yes
【请输入成绩：】91
【继续输入成绩吗？（yes/no）】yes
【请输入成绩：】92
【继续输入成绩吗？（yes/no）】n
只能输入yes或no
【继续输入成绩吗？（yes/no）】no
【所有分数的平均分为】91.00
---------------------------------------------------------
注意：部分源程序给出如下。请勿改动主函数main和其它函数中的
任何内容，仅在函数的注释标志之间填入所编写的若干语句。
------------------------------------------------------'''
def main():
number = 0
total = 0
while True:
chenji = float(input("【请输入成绩：】"))
number += 1
total += chenji
while True:
flag = input('【继续输入成绩吗？（yes/no）】')
#********** Program **********
if flag == 'yes':
break
elif flag == 'no':
break
else:
print("只能输入yes或no")
continue
break
if flag == 'no':
break
#********** End **********
print('【所有分数的平均分为】%.2f' % (total / number))
if __name__ == '__main__':
main()
在这个程序中，我们使用了一个外层循环来处理每个输入的成绩，并在内层循环中询问用户是否继续输入下一个成绩。如果用户输入的是 "yes"，我们跳出内层循环继续输入下一个成绩；如果用户输入的是 "no"，我们跳出内层循环并结束外层循环，然后计算平均分。如果用户输入的不是 "yes" 或 "no"，我们提示用户只能输入 "yes" 或 "no" 并继续询问。在输入 "no" 时，我们需要将计数器 `number` 减1，因为此时我们不计算这个成绩，但在之前的循环中已经加1了。最后，我们计算并输出所有分数的平均分。
运行结果：
第四题：
# -*- coding:cp936 -*-
'''------------------------------------------------------
【程序设计】
---------------------------------------------------------题目：画绿色green等边三角形
描述：用户输入一个正整数作为边长，利用turtle库left函数和fd函数pencolor函数画一个等边三角形。
要求：
输入格式：输入一个正整数
输出格式：一个等边三角形输入示例 输出示例
示例1 120 如样张
示例2
---------------------------------------------------------
注意：仅在注释标志之间填入所编写语句。
------------------------------------------------------'''#**********Program**********
#********** End **********
解析：
# -*- coding:cp936 -*-
'''------------------------------------------------------
【程序设计】
---------------------------------------------------------
题目：画绿色green等边三角形
描述：用户输入一个正整数作为边长，利用turtle库left函数和fd函数pencolor函数画一个等边三角形。
要求：
输入格式：输入一个正整数
输出格式：一个等边三角形
输入示例 输出示例
示例1 120 如样张
示例2
---------------------------------------------------------
注意：仅在注释标志之间填入所编写语句。
------------------------------------------------------'''
#**********Program**********
import turtle
# 设置画笔颜色为绿色
turtle.pencolor("green")
# 获取用户输入的边长
side_length = int(input())
#**********Program**********
# 使用循环绘制等边三角形
for _ in range(3): # 绘制三角形的三条边
turtle.forward(side_length) # 向前移动指定的边长
turtle.left(120) # 向左转120度
#********** End **********
# 隐藏画笔并完成绘制
turtle.hideturtle()
turtle.done()
#********** End **********
在这个程序中，我们首先导入turtle库，并设置画笔颜色为绿色。然后，我们获取用户输入的边长，并使用一个循环来绘制等边三角形。在循环中，我们使用forward函数向前移动指定的边长，并使用left函数向左转120度，这是等边三角形每个内角的角度。最后，我们调用turtle.done()来结束绘制并保持窗口打开，以便用户可以看到绘制的结果。
运行结果：
📝大佬觉得本文有所裨益，不妨轻点一下👍给予鼓励吧！
❤️❤️❤️本人虽努力，但能力尚浅，若有不足之处，恳请各位大佬不吝赐教，您的批评指正将是我进步的动力！😊😊😊
💖💖💖若您认为此篇文章对您有所帮助，烦请点赞👍并收藏🌟，您的支持是我前行的最大动力！
🚀🚀🚀任务在默默中完成，价值在悄然间提升。让我们携手共进，一起加油，迎接更美好的未来！🌈🌈🌈
扫一扫
959
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
