个人名片：
🎓作者简介：嵌入式领域优质创作者
🌐个人主页：妄北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基础知识的实践，做项目是最锻炼能力的一个学习方法，这里我们会学习到一些简单基础的项目开发与应用，而且都是毕业设计级别的哦。🤸🌱🚀
非常期待与您一同在这个广阔的互联网天地里，携手探索知识的海洋，互相学习，共同进步。🌐💫🌱 熠熠星光，照亮我们的成长之路
✨✨ 欢迎订阅本专栏，对专栏内容任何问题都可以随时联系博主，共同书写属于我们的精彩篇章！✨✨
文章介绍：
📚本篇文章将深入剖析Python学习的精髓与奥秘，与您一同分享相关知识！🎉🎉🎉
若您觉得文章尚可入目，期待您能慷慨地送上点赞、收藏与分享的三连支持！您的每一份鼓励，都是我创作路上源源不断的动力。让我们携手并进，共同奔跑，期待在顶峰相见的那一天，共庆辉煌！🚀🚀🚀
🙏衷心感谢大家的点赞👍、收藏⭐和评论✍️，您的支持是我前进的动力！
前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。点击跳转到网站：人工智能教程
目录：
一、选择题：
1. 下列选项中,不属于Python特点的是( )。
(A)可读性好
(B)运行效率高
(C)面向对象
(D)开源
(A) 可读性好：Python的设计哲学强调代码的可读性，它使用缩进来定义代码块，这有助于提高代码的可读性和清晰性。
(C) 面向对象：Python是一种面向对象的编程语言，支持类和对象的概念，允许开发者使用面向对象的方法来编写程序。
(D) 开源：Python是开源的，它的源代码是公开的，任何人都可以查看、使用和修改。(B) 运行效率高：虽然Python是一种非常流行的编程语言，但它的运行效率并不是其主要特点。Python是一种解释型语言，相比于编译型语言（如C或C++），它的运行效率通常较低。Python的运行效率可以通过使用C语言编写的扩展模块来提高，但这并不是Python语言本身的特性。
答案：B
2.下面（）是非法变量名。
(A)_address
(B)complex
(C)my-name
(D)ID
在Python中，变量名必须遵循以下规则：
1. 变量名可以包含字母（A-Z, a-z）、数字（0-9）和下划线（_）。
2. 变量名不能以数字开头。
3. 变量名不能是Python的关键字或保留字。
4. 变量名区分大小写。
5. 变量名中不能包含空格或特殊字符（如@、#、$、%等）。(A)_address：这是一个合法的变量名，因为它只包含字母和下划线，并且以下划线开头。
(B)complex：这也是一个合法的变量名，虽然"complex"是Python的一个内置类型，但在实际使用中，只要不与内置函数或类型冲突，它仍然可以作为变量名。
(D)ID：这是一个合法的变量名，因为它只包含字母，并且不是Python的关键字。(C)my-name：这是一个非法的变量名，因为在Python中，变量名不能包含连字符（-）这样的特殊字符。如果想要表示"my"和"name"之间的连接，应该使用下划线（_），例如"my_name"。
答案：C
3. 换行的转义符为( ）。
(A)\t
(B)\n
(C)\b
(D)\f
在Python中，转义字符用于表示一些特殊的字符或操作。以下是一些常见的转义字符：
(A)\t：表示制表符（Tab）。
(B)\n：表示换行符。
(C)\b：表示退格符（Backspace）。
(D)\f：表示换页符（Form feed）。因此，换行的转义符是\n。
答案：B
4. 5.0//2.0结果为( )。
(A)3
(B)2.5
(C)2
(D)2.0
在Python中，`//` 是整数除法运算符，它执行的是向下取整的除法操作。即使操作数是浮点数，`//` 运算符也会返回一个向下取整的结果。
因此，`5.0 // 2.0` 的结果是 `2.0`，因为 `5.0` 除以 `2.0` 的结果是 `2.5`，向下取整后得到 `2.0`。
答案：D
5. 下面选项中()是Python的可更改数据类型。
(A)列表
(B)元组
(C)字符串
(D)数字
在Python中，数据类型可以分为可更改（mutable）和不可更改（immutable）两种。
(A)列表（List）：是可更改的数据类型。你可以添加、删除或修改列表中的元素。
(B)元组（Tuple）：是不可更改的数据类型。一旦创建，元组中的元素不能被修改。
(C)字符串（String）：是不可更改的数据类型。字符串中的字符不能被修改，但你可以创建一个新的字符串。
(D)数字（Number）：在Python中，数字类型（包括整数、浮点数等）也是不可更改的。你不能改变一个数字对象的值，但可以重新赋值。
因此，列表是Python中的可更改数据类型。
答案：A
6. t1=(12,34,56)
t2=(1,2,3)
t1+t2等于()。
(A)(12,34,56,1,2,3)
(B)(13,36,59)
(C)(12,34,56)
(D)上述答案错误
在Python中，元组的加法操作 `+` 是将两个元组连接起来形成一个新的元组。
给定的元组 `t1` 是 `(12, 34, 56)`，元组 `t2` 是 `(1, 2, 3)`。
当执行 `t1 + t2` 时，结果是将 `t1` 和 `t2` 的元素按顺序连接起来，形成一个新的元组：
`(12, 34, 56, 1, 2, 3)`
答案：A
7. "hello"=="HELLO"的运算结果是()。
(A)False
(B)1
(C)True
(D)0
在Python中，字符串比较是区分大小写的。"hello" 和 "HELLO" 虽然包含相同的字符，但大小写不同。因此，当进行比较时，Python会认为它们不相等。
执行 "hello"=="HELLO" 的比较，结果是 False，因为这两个字符串在大小写上不匹配。
所以，正确答案是 (A)False。
答案：A
8. 下列语句执行后的结果是()。
fruits={'apple': 3,'banana': 4 ,'pear':5}
fruits [' banana']=7
print(sum(fruits. values()))
(A)12
(B)19
(C)7
(D)15
首先，我们有一个字典
fruits，它包含了三种水果及其对应的数量：
- 'apple': 3
- 'banana': 4
- 'pear': 5
然后，我们执行了一个语句
fruits[' banana'] = 7，键是 ' banana'，值是 7。接下来，我们使用
sum(fruits.values())来计算字典中所有值的总和。fruits.values()返回一个包含所有值的视图，sum()函数将这些值相加。字典
fruits现在的内容是：
- 'apple': 3
- 'banana': 7
- 'pear': 5
所有值的总和是：3 + 7 + 5 = 15
因此，
print(sum(fruits.values()))的输出结果是 15。
答案：B
9. ()函数用于将数字转换成字符。
(A)hex()
(B)oct)
(C)ord()
(D)chr()
hex()函数用于将整数转换为十六进制字符串。oct()函数用于将整数转换为八进制字符串。ord()函数返回一个字符的 Unicode 码点，即返回该字符对应的整数值。chr()函数用于将整数（Unicode 码点）转换为对应的字符。因此，将数字转换成字符应该使用
chr()函数。
答案：D
10. 下列程序的输出结果是()。
def f(a,b):
a=4
return a+b
def main():
a=5
b=6
print(f(a,b),a+b)
main()
(A)11 10
(B)11 11
(C)10 10
(D)10 11
在
main()函数中，我们定义了两个变量a和b，它们的值分别为 5 和 6。然后我们调用了函数f(a, b)，并将a和b作为参数传递进去。接着，我们打印了f(a, b)的返回值和a + b的结果。现在，我们来分析程序的执行过程：
- 在
main()函数中，a的值为 5，b的值为 6。- 调用
f(a, b)时，a的值被设置为 4（在函数f内部），然后返回a + b，即4 + 6 = 10。- 在
main()函数中，a + b的结果为5 + 6 = 11。- 打印的结果是
f(a, b)的返回值和a + b的结果，即10和11。因此，程序的输出结果是
10 11。
答案：D
11. 在方法定义中，访问实例属性x的格式是()。
(A)self[x]
(B)self.x
(C)x
(D)self.getx()
(A)
self[x]- 这种方式通常用于访问字典类型的属性，其中x是键，而不是实例属性。(B)
self.x- 这是正确的访问实例属性的方式。(C)
x- 这种方式没有使用self，因此它不会访问实例属性，而是会尝试访问局部变量或全局变量。(D)
self.getx()- 这种方式假设有一个名为getx()的方法来获取属性x的值，而不是直接访问属性。
答案：B
12.在读写文件之前，用于创建文件对象的函数是()。
(A)file
(B)create
(C)open
(D)folder
(A)
file- 这不是Python中的内置函数，尽管在Python 2中有一个名为file()的内置类型，但它已经被open()函数取代。(B)
create- 这不是Python中的内置函数。(C)
open- 这是正确的函数，用于打开文件并创建文件对象。(D)
folder- 这不是Python中的内置函数，它通常指的是文件夹（目录）。
答案：C
13.list(range(1,5)）返回的结果是()。
(A)(1,2,3,4)
(B)[1,2,3,4,5]
(C)[1,2,3,4]
(D)(1,2,3,4,5}
在Python中，
list(range(1, 5))会创建一个列表，其中包含从1到4的整数（不包括5）。range(1, 5)生成的是一个范围对象，它包含1到4的整数，而list()函数将这个范围对象转换为列表。(A)
(1,2,3,4)- 这是一个元组，而不是列表。(B)
[1,2,3,4,5]- 这个列表包含5，但是range(1, 5)不包含5。(C)
[1,2,3,4]- 这是正确的，因为range(1, 5)生成的是1到4的整数。(D)
(1,2,3,4,5}- 这是一个带有错误括号的元组，正确的括号应该是圆括号()，而不是花括号{}。
答案：C
二、填空题：
1. a='Python'，表达式a[ 1]的结果为【1】。
在Python中，字符串的索引是从0开始的。因此，对于字符串 `a = 'Python'`，`a[1]` 表示访问字符串中索引为1的字符，即第二个字符。
字符串 `'Python'` 的第一个字符是 `'P'`，第二个字符是 `'y'`。
所以，表达式 `a[1]` 的结果是 `'y'`。
答案：'y'
2. Python 3.x语句print(1,2,3,sep =",')的输出结果为【1】。
在Python 3.x中，`print()` 函数可以接受多个参数，并且可以通过 `sep` 参数来指定这些参数之间的分隔符。默认情况下，`sep` 的值是空格。
当你执行 `print(1, 2, 3, sep =",")` 时，它会将数字1、2、3打印出来，并且它们之间用逗号作为分隔符。
因此，输出结果为：
1,2,3
答案：1,2,3
3. 已知列表×=[1,2,3]，那么执行语句x.insert(1,4)之后，x的值为【1】。
在Python中，列表的`insert()`方法用于在指定位置插入一个元素。`insert()`方法的语法如下：
list.insert(index, element)其中，`index`是插入位置的索引，`element`是要插入的元素。
对于给定的列表 `x = [1, 2, 3]`，执行语句 `x.insert(1, 4)` 意味着在索引位置1（即第二个元素的位置）插入元素4。
执行该语句后，列表 `x` 将变为：
x = [1, 4, 2, 3]所以，执行 `x.insert(1, 4)` 之后，`x` 的值为 `[1, 4, 2, 3]`。
答案：[1,4,2,3]
4. 循环语句for i in range(-3,21,4)的循环次数为【1】。
`range()` 函数在Python中用于生成一个整数序列，它接受三个参数：起始值、结束值和步长。在这个例子中，`range(-3, 21, 4)` 表示从-3开始，每次增加4，直到但不包括21。
要计算循环次数，我们需要确定从-3开始，每次增加4，直到最接近但不包括21的整数是多少。我们可以通过以下步骤来计算：
1. 确定起始值：-3
2. 确定步长：4
3. 确定结束值：21
4. 计算循环次数：(结束值 - 起始值) / 步长，然后向上取整到最接近的整数。计算过程如下：
(21 - (-3)) / 4 = (21 + 3) / 4 = 24 / 4 = 6
因此，循环次数为6。
答案：6
5. 列表s=[56,78,90,99,21],s.remove(90)后，len(s)=【1】。
在Python中，`remove()` 方法用于移除列表中第一个匹配指定值的元素。对于给定的列表 `s = [56, 78, 90, 99, 21]`，执行 `s.remove(90)` 将移除值为90的元素。
执行 `s.remove(90)` 后，列表 `s` 将变为：
s = [56, 78, 99, 21]要计算列表的长度，我们使用 `len()` 函数。在移除元素后，列表 `s` 包含4个元素。
因此，`len(s)` 的值为 `4`。
答案：4
6. A=(1,2,3),B=('a', 'b')则A+B的值为【1】。
在Python中，`+` 运算符用于连接两个列表。对于给定的列表 `A = (1, 2, 3)` 和 `B = ('a', 'b')`，执行 `A + B` 将连接这两个列表。
请注意，`A` 和 `B` 实际上是元组（tuples），而不是列表（lists）。元组是不可变的序列类型，而列表是可变的序列类型。不过，`+` 运算符同样适用于元组。
执行 `A + B` 后，结果将是一个包含 `A` 和 `B` 所有元素的新元组。
A + B = (1, 2, 3, 'a', 'b')所以，`A + B` 的值为 `(1, 2, 3, 'a', 'b')`。
答案：(1,2,3,'a','b')
7.已知a=3,b=5,c=6,d=True，则表达式not d or a>=0 and a+c>b+3的值为【1】。
首先，我们需要按照Python中的运算符优先级来解析这个表达式。在这个表达式中，
not的优先级最高，其次是and，然后是or。我们还需要注意括号的使用，以确保按照正确的顺序进行计算。表达式
not d or a>=0 and a+c>b+3可以按照以下步骤解析：
- 计算
not d：因为d的值是True，所以not d的值是False。- 计算
a>=0：因为a的值是3，所以a>=0的值是True。- 计算
a+c：a的值是3，c的值是6，所以a+c的值是9。- 计算
b+3：b的值是5，所以b+3的值是8。- 计算
a+c>b+3：因为a+c的值是9，b+3的值是8，所以a+c>b+3的值是True。- 计算
a>=0 and a+c>b+3：因为a>=0的值是True，a+c>b+3的值是True，所以a>=0 and a+c>b+3的值是True。- 最后，计算
not d or a>=0 and a+c>b+3：因为not d的值是False，a>=0 and a+c>b+3的值是True，所以not d or a>=0 and a+c>b+3的值是True。因此，表达式
not d or a>=0 and a+c>b+3的值为True。
答案：True
8.Python语句print(len())的结果是【1】。
在Python中，
print(len())语句是错误的，因为len()函数需要一个参数来计算其长度。如果没有提供参数，Python会抛出一个TypeError，提示缺少了1个必需的位置参数。
答案：0
9. 表达式int(str(34))==34的值为【1】。
str(34)将整数34转换为字符串"34"。int(str(34))将字符串"34"转换回整数34。int(str(34))==34比较转换后的整数34是否等于原始的整数34。因为转换后的整数确实等于原始的整数，所以表达式的值为
True。
答案：True
10. Python内置函数【1】用来返回序列中的最小元素。
Python内置函数
min()用来返回序列中的最小元素。
答案：min()
11. 下列程序的运行结果为【1】。
class Account:
def _init_(self, id):
self.id=id
id=888
acc=Account(100)
print(acc.id)在这个Python程序中，
Account类有一个构造函数__init__（注意，方法名应该是__init__而不是_init_，可能是输入错误），它接受一个参数id并将其赋值给实例变量self.id。然后，它将局部变量id重新赋值为888。当创建
Account类的实例acc并传递100作为id时，构造函数被执行。由于id被重新赋值为888，但这个id是局部变量，它不会影响实例变量self.id。因此，实例变量self.id仍然是100。程序的运行结果将是：
100
答案： 100
12. 已知text='111a22bb3ccc'，并且己导入正则表达式模块re，那么表达式len (re.sub ('[abc]+', ", text))的值为【1】。
原始字符串
text是'111a22bb3ccc'。正则表达式'[abc]+'匹配任何连续的a、b或c字符。re.sub函数将这些匹配的字符替换为逗号。替换后的字符串将是
'111,22,3,'，因为a、b和c分别被替换为逗号。然后，
len函数计算替换后字符串的长度。在这个字符串中，有 7 个字符（包括逗号和数字）。所以，表达式
len(re.sub('[abc]+', ", text))的值为7。
答案：7
13.表达式'abcabcabc'.count ('abc')的值为【1)】。
在这个Python表达式中，
'abcabcabc'.count('abc')使用了字符串的count方法来计算字符串'abcabcabc'中子字符串'abc'出现的次数。字符串
'abcabcabc'由三个连续的'abc'子字符串组成。因此，
'abcabcabc'.count('abc')的值为3，表示子字符串'abc'在原字符串中出现了3次。
答案：3
14. 表达式[ i for i in range(10) if i>8]的值为【1】。
在这个Python表达式中，
[ i for i in range(10) if i>8]是一个列表推导式，它生成一个列表，其中包含range(10)中满足条件i>8的所有元素。
range(10)生成的序列是[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]。条件
i>8筛选出序列中大于8的元素。在这个序列中，只有9满足这个条件。因此，列表推导式
[ i for i in range(10) if i>8]的值为[9]，即一个包含单个元素9的列表。
答案：[9]
15.表达式3 in{1,2,3}的值为【1】。
在这个Python表达式中，
3 in {1,2,3}使用了in关键字来检查元素3是否存在于集合{1,2,3}中。集合
{1,2,3}包含了三个元素：1、2和3。由于
3确实存在于集合中，因此表达式3 in {1,2,3}的值为True。
答案：True
16. 结构化程序设计有三种基本结构:顺序结构、分支结构和【1】。
结构化程序设计的三种基本结构是：
1. 顺序结构：程序按照代码的顺序依次执行。
2. 分支结构：程序根据条件选择执行不同的代码路径，通常使用 `if`、`else` 或 `switch` 语句实现。
3. 循环结构：程序重复执行一段代码，直到满足某个条件才停止，通常使用 `for`、`while` 或 `do-while` 语句实现。
答案：循环结构
17.表达式sorted({'a':3,'b':9,c':78})的值为【1】。
在Python中，
sorted()函数通常用于列表或其他可迭代对象，它会返回一个新的排序后的列表。然而，当你尝试对一个字典使用sorted()时，它会默认对字典的键进行排序。表达式
sorted({'a':3,'b':9,'c':78})会尝试对字典{'a':3,'b':9,'c':78}的键进行排序。排序后的结果是一个包含字典键的列表。因此，这个表达式的值将是
['a', 'b', 'c']。
答案：['a','b','c']
18. r表示以【1】方式打开文件。
在Python中，`r` 表示以只读方式打开文件。这是文件打开模式的一种，用于读取文件内容而不进行写入或修改。如果文件不存在，使用 `r` 模式打开文件会引发一个错误。
因此，`r` 表示以只读方式打开文件。
答案：只读
三、判断题：
1. 不可以在同一台计算机上安装多个Python版本。
实际上，可以在同一台计算机上安装多个Python版本。这通常通过使用Python版本管理工具来实现，例如 `pyenv`、`conda` 或 `virtualenv`。这些工具允许用户在不同的项目或环境中使用不同版本的Python，而不会相互干扰。
例如，使用 `pyenv`，你可以轻松地在同一台机器上安装和管理Python 2.x 和 Python 3.x 版本，并根据需要切换默认版本。这对于需要在不同Python版本下测试代码或在不同项目中使用不同Python版本的用户来说非常有用。
答案：X
2. 在Python中可以使用if作为变量名。
在Python中，
if是关键字，它用于条件语句，因此不能用作变量名。如果你尝试将if用作变量名，Python解释器会抛出一个语法错误。
答案：X
3. 已知x是个列表对象，那么执行语句y=x之后，对y所做的任何操作都会同样作用到x上。
是的，这个说法是正确的。在Python中，当你执行
y = x这样的赋值操作时，实际上是将列表x的引用复制给了y。这意味着y和x现在指向内存中的同一个列表对象。因此，对y所做的任何操作，如添加、删除或修改列表中的元素，都会反映在x上，因为它们引用的是同一个对象。
答案：√
4. 在Python中，关系运算符可以连续使用，例如1<3<5等价于1<3 and 3<5。
是的，这个说法是正确的。在Python中，你可以连续使用关系运算符，例如
1 < 3 < 5。这种写法在语义上等价于1 < 3 and 3 < 5。Python会自动按照从左到右的顺序计算这些关系表达式，并返回一个布尔值。
答案：√
5. 字典的“键”必须是不可变的。
是的，这个说法是正确的。在Python中，字典的键（key）必须是不可变的数据类型。这意味着键可以是数字、字符串或元组等不可变类型，但不能是列表、字典或其他可变类型。这是因为字典的实现依赖于键的哈希值，而可变对象的哈希值可能会随着对象内容的变化而变化，这会导致字典无法正确地存储和检索键值对。
答案：√
6. 如果仅仅是用于控制循环次数，那么使用for i in range(20)和 for iin range(20,40)的作用是等价的。
在Python中，
for i in range(20)和for i in range(20, 40)的作用并不等价。
for i in range(20)会创建一个从0开始到19的整数序列，循环将执行20次，每次迭代时，i的值将从0递增到19。而
for i in range(20, 40)会创建一个从20开始到39的整数序列，循环将执行20次，每次迭代时，i的值将从20递增到39。因此，这两个循环的迭代次数相同，但每次迭代时
i的值是不同的。第一个循环的i值从0开始，而第二个循环的i值从20开始。如果循环内部的代码依赖于i的具体值，那么这两个循环的结果将会有所不同。如果循环内部的代码仅仅依赖于循环的次数而不关心i的具体值，那么这两个循环在功能上可以是等价的，但它们在i的取值范围上是不同的。如果仅仅是用于控制循环次数，作用就是等价的
答案：√
7.函数中必须包含return语句。
在Python中，函数并不必须包含
return语句。如果一个函数没有显式地使用return语句返回任何值，那么该函数将隐式地返回None。
答案：X
8. Python标准库random的函数randint (m，n)用来生成一个[m,n]区间上的随机整数。
是的，这个说法是正确的。在Python中，
random模块的randint(m, n)函数用于生成一个在闭区间 [m, n] 上的随机整数，其中 m 和 n 都是整数，且包括 m 和 n 本身。
答案：√
四、程序填空：
第一题：
# -*- coding:cp936 -*-
'''------------------------------------------------------
【程序填空】
---------------------------------------------------------
以下程序键盘输入任意十个列表元素，升序输出：
------------------------------------------------------------
注意：除要求填空的位置之外，请勿改动程序中的其他内容。
------------------------------------------------------'''
s=[]
for i in range(10):
x=int(input("键盘输入一整数："))
#**********SPACE**********
【?】
print("刚才输入的列表：",s)
for i in range(9):
for j in range(i+1,10):
#**********SPACE**********
if s[i]>s[j]: 【?】
print("升序排列后的列表：",s)
解析：
这段代码是一个简单的Python程序，用于从键盘输入十个整数，并将它们存储在一个列表中。然后，程序使用冒泡排序算法对列表中的元素进行升序排序，并输出排序后的列表。下面是填空部分的代码：
# -*- coding:cp936 -*-
'''------------------------------------------------------
【程序填空】
---------------------------------------------------------
以下程序键盘输入任意十个列表元素，升序输出：
------------------------------------------------------------
注意：除要求填空的位置之外，请勿改动程序中的其他内容。
------------------------------------------------------'''
s=[]
for i in range(10):
x=int(input("键盘输入一整数："))
#**********SPACE**********
s.append(x)
print("刚才输入的列表：",s)
for i in range(9):
for j in range(i+1,10):
#**********SPACE**********
if s[i]>s[j]:
s[i] , s[j] = s[j] , s[i]
print("升序排列后的列表：",s)第一个填空处是使用 `append` 方法将输入的整数添加到列表 `s` 中。
第二个填空处是实现冒泡排序的关键步骤，即比较相邻元素的大小，并在必要时交换它们的位置。
运行效果：
第二题：
# -*- coding:cp936 -*-
'''------------------------------------------------------
【程序填空】
---------------------------------------------------------
输入密文，输入‘q’结束，解密输出明文，无法转换的用‘？’替代。
如果输入abc，输出012
------------------------------------------------------------
注意：除要求填空的位置之外，请勿改动程序中的其他内容。
------------------------------------------------------'''
code=('a','b','c','d','e','A','B','C','D','E')
while True:
d=''
s=input("请输入密文，q退出：\n")
if s=='q':
#**********SPACE**********
【?】
for i in range(len(s)):
if s[i] in code:
p=code.index(s[i])
#**********SPACE**********
d=d+【?】
else:
d=d+'?'
print("明文是：\n",d)
解析：
# -*- coding:cp936 -*-
'''------------------------------------------------------
【程序填空】
---------------------------------------------------------
输入密文，输入‘q’结束，解密输出明文，无法转换的用‘？’替代。
如果输入abc，输出012
------------------------------------------------------------
注意：除要求填空的位置之外，请勿改动程序中的其他内容。
------------------------------------------------------'''
code=('a','b','c','d','e','A','B','C','D','E')
while True:
d=''
s=input("请输入密文，q退出：\n")
if s=='q':
#**********SPACE**********
break
for i in range(len(s)):
if s[i] in code:
p=code.index(s[i])
#**********SPACE**********
d=d+str(p)
else:
d=d+'?'
print("明文是：\n",d)第一个填空处 `break` 是在用户输入 'q' 时跳出循环，结束程序。
第二个填空处 `d=d+str(p)` 是将找到的索引 `p` 转换为字符串并添加到解密后的字符串 `d` 中。如果字符不在 `code` 中，则添加 '?'。
运行效果：
第三题：
# -*- coding:cp936 -*-
'''------------------------------------------------------
【程序填空】
---------------------------------------------------------题目：求输入数字的平方，如果平方运算后小于 50 则退出。
---------------------------------------------------------
注意：除要求填空的位置之外，请勿改动程序中的其他内容。
------------------------------------------------------'''
def power(x):
#**********SPACE**********
if 【?】:
#**********SPACE**********
print('%d的平方为:%d,不小于50，继续'【?】)
else:
#**********SPACE**********
print('{}的平方为:{},小于50，退出'.format(【?】))
quit()
def main():
while True:
x = int(input('输入数字:'))
#**********SPACE**********
power(【?】)if __name__ == '__main__':
main()
解析：
在这段代码中，有三个填空位置需要补充代码。下面是填空部分的代码：
# -*- coding:cp936 -*-
'''------------------------------------------------------
【程序填空】
---------------------------------------------------------
题目：求输入数字的平方，如果平方运算后小于 50 则退出。
---------------------------------------------------------
注意：除要求填空的位置之外，请勿改动程序中的其他内容。
------------------------------------------------------'''
def power(x):
#**********SPACE**********
if x**2 >= 50:
#**********SPACE**********
print('%d的平方为:%d,不小于50，继续' % (x, x**2))
else:
#**********SPACE**********
print('{}的平方为:{},小于50，退出'.format(x, x**2))
quit()
def main():
while True:
x = int(input('输入数字:'))
#**********SPACE**********
power(x)
if __name__ == '__main__':
main()第一个填空处 `if x**2 >= 50:` 是检查平方后的值是否大于或等于 50。
第二个填空处 `print('%d的平方为:%d,不小于50，继续' % (x, x**2))` 是在平方值不小于 50 时打印信息。
第三个填空处 `print('{}的平方为:{},小于50，退出'.format(x, x**2))` 是在平方值小于 50 时打印信息并退出程序。
运行效果：
五、程序改错
第一题：
# -*- 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` 可以得到这个表达式。
```python
# -*- coding:cp936 -*-
'''------------------------------------------------------
【程序改错】
---------------------------------------------------------
题目：一个整数，它加上100后是一个完全平方数，再加上168又
是一个完全平方数，请问该数是多少？
请改正程序中的错误，使它能得出正确的结果。
---------------------------------------------------------
注意：不可以增加或删除程序行，也不可以更改程序的结构。
------------------------------------------------------'''
def main():
t = []
#**********FOUND**********
for m in range(1, 168): # 修正：从1开始，因为0不是有效的完全平方数
for n in range(m):
#**********FOUND**********
if m**2 - n**2 == 168:
#**********FOUND**********
x = n**2 - 100 # 修正：应该是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 -*-
'''------------------------------------------------------
【程序改错】
---------------------------------------------------------题目：编写函数fun计算下列分段函数的值：
x*x+x x<0且x≠-3
f(x)= x*x+5x 0≤x<10且x≠2及x≠3
x*x+x-1 其它
请改正程序中的错误，使它能得出正确的结果。---------------------------------------------------------
注意：不可以增加或删除程序行，也不可以更改程序的结构。
------------------------------------------------------'''
def fun(x):
#**********FOUND**********
if (x<0 and x!=-3.0):
y=x*x+x
#**********FOUND**********
elif(x>=0 and x<10.0 and x!=2.0 or x!=3.0):
y=x*x+5*x
else:
y=x*x+x-1
#**********FOUND**********
return ydef main():
x = int(input("请输入x的值，并按回车继续:"))
f = fun(x)
print("x={},f(x)={}".format(x,f))
if __name__ == '__main__':
main()
解析：
在给定的代码中，有几个地方需要修正以确保程序能够正确计算分段函数的值。以下是需要改正的地方：
1. 条件逻辑错误：在`elif`部分，条件逻辑应使用`and`而不是`or`，以确保正确的分段函数判断。
2. 输入类型问题：`input`获得的输入应该转换为浮点数，以确保分段函数逻辑处理正确。
下面是修正后的代码：
# -*- coding: cp936 -*-
'''------------------------------------------------------
【程序改错】
---------------------------------------------------------
题目：编写函数fun计算下列分段函数的值：
x*x+x x<0且x≠-3
f(x)= x*x+5x 0≤x<10且x≠2及x≠3
x*x+x-1 其它
请改正程序中的错误，使它能得出正确的结果。
---------------------------------------------------------
注意：不可以增加或删除程序行，也不可以更改程序的结构。
------------------------------------------------------'''
def fun(x):
#**********FOUND**********
if (x < 0 and x != -3.0):
y = x * x + x
#**********FOUND**********
elif (x >= 0 and x < 10.0 and x != 2.0 and x != 3.0):
y = x * x + 5 * x
else:
y = x * x + x - 1
#**********FOUND**********
return y
def main():
x = int(input("请输入x的值，并按回车继续:"))
f = fun(x)
print("x={},f(x)={}".format(x, f))
if __name__ == '__main__':
main()
改正内容说明:
1. 条件逻辑：将`elif`分支的条件改为 `x >= 0 and x < 10.0 and x != 2.0 and x != 3.0`。
运行效果：
六、程序设计
第一题：
# -*- coding:cp936 -*-
'''------------------------------------------------------
【程序设计】
---------------------------------------------------------题目：编写函数main找出1000以内的所有完数。
说明：一个数若恰好等于它的真因子（即除了本身以外的约数）
之和，这个数就称为完数。要求：使用列表函数完成
例如：6=1+2+3 6即为完数
---------------------------------------------------------
注意：部分源程序给出如下。请勿改动其它函数中的任何内容，
仅在函数的注释标志之间填入所编写的若干语句。
------------------------------------------------------'''
def main():
for x in range(1, 1001):
#**********Program**********#********** End **********
if x == sum(lists):
print("【完数为：】%d"%x)
print("【它的真因子为：】%s"%lists)if __name__ == '__main__':
main()
解析：
为了找出1000以内的所有完数，我们需要在函数 `main` 中编写代码来计算每个数的真因子，并检查这些真因子的和是否等于该数本身。以下是完整的代码实现：
# -*- coding:cp936 -*-
'''------------------------------------------------------
【程序设计】
---------------------------------------------------------
题目：编写函数main找出1000以内的所有完数。
说明：一个数若恰好等于它的真因子（即除了本身以外的约数）
之和，这个数就称为完数。
要求：使用列表函数完成
例如：6=1+2+3 6即为完数
---------------------------------------------------------
注意：部分源程序给出如下。请勿改动其它函数中的任何内容，
仅在函数的注释标志之间填入所编写的若干语句。
------------------------------------------------------'''
def main():
for x in range(1, 1001):
#**********Program**********
lists = []
for i in range(1, x):
if x % i == 0:
lists.append(i)
#********** End **********
if x == sum(lists):
print("【完数为：】%d" % x)
print("【它的真因子为：】%s" % lists)
if __name__ == '__main__':
main()
1. 外层循环：遍历从1到1000的所有整数。
2. 内层循环：对于每个数 `x`，遍历从1到 `x-1` 的所有整数，找出 `x` 的真因子（即能整除 `x` 的数），并将这些真因子添加到列表 `lists` 中。
3. 检查完数：如果 `x` 等于 `lists` 中所有元素的和，则 `x` 是一个完数，打印出该完数及其真因子。
这样，程序会找出并打印出1000以内的所有完数及其真因子。
运行效果：
第二题：
# -*- coding:cp936 -*-
'''------------------------------------------------------
【程序设计】
---------------------------------------------------------题目：主程序中已有一个排好序的列表，请编写函数insertList，
将从键盘接收的整数按原来从小到大的排序规律插入到该
列表中。要求：使用列表函数完成
---------------------------------------------------------
注意：部分源程序给出如下。请勿改动主函数main和其它函数中的
任何内容，仅在函数的注释标志之间填入所编写的若干语句。
------------------------------------------------------'''
def insertList(L1,x):
#**********Program**********#********** End **********
def main():
print("【请分别三次插入输入的整数到列表中并打印：】")
for n in range(3):
print("【第%d次：】" %(n+1))
L1=[1,4,6,9,13,16,28,40,100]
x=int(input('【请输入一个要插入的整数：】'))
insertList(L1,x)
print(L1)
if __name__ == '__main__':
main()
解析：
为了实现将一个整数插入到已排序列表中的功能，我们需要编写 insertList 函数。该函数应该找到正确的插入位置，并将整数插入到列表中，同时保持列表的有序性。以下是完整的代码实现：
# -*- coding:cp936 -*-
'''------------------------------------------------------
【程序设计】
---------------------------------------------------------
题目：主程序中已有一个排好序的列表，请编写函数insertList，
将从键盘接收的整数按原来从小到大的排序规律插入到该
列表中。
要求：使用列表函数完成
---------------------------------------------------------
注意：部分源程序给出如下。请勿改动主函数main和其它函数中的
任何内容，仅在函数的注释标志之间填入所编写的若干语句。
------------------------------------------------------'''
def insertList(L1, x):
#**********Program**********
L1.append(x)
L1.sort()
#********** End **********
def main():
print("【请分别三次插入输入的整数到列表中并打印：】")
for n in range(3):
print("【第%d次：】" % (n+1))
L1 = [1, 4, 6, 9, 13, 16, 28, 40, 100]
x = int(input('【请输入一个要插入的整数：】'))
insertList(L1, x)
print(L1)
if __name__ == '__main__':
main()
解析：
这个程序会在主函数中循环三次，每次都会创建一个新的排序列表，然后从用户输入中接收一个整数，调用 insertList 函数将该整数插入到列表中，并保持列表的排序。最后，打印更新后的列表。
运行效果：
第三题：
# -*- coding:cp936 -*-
'''------------------------------------------------------
【程序设计】
---------------------------------------------------------题目：用户输入若干个分数，求所有分数的平均分。每输入一个
分数后询问是否继续输入下一个分数，回答“y”、“n”
之外的字符就提示只能输入y或n并继续询问是否继续输入
下一个分数，回答“y”就继续输入下一个分数，回答“n”
就停止输入，结束程序例如：
【请输入成绩：】90
【继续输入成绩吗？（y/n）】y
【请输入成绩：】91
【继续输入成绩吗？（y/n）】y
【请输入成绩：】92
【继续输入成绩吗？（y/n）】y
【请输入成绩：】93
【继续输入成绩吗？（y/n）】y
【请输入成绩：】94
【继续输入成绩吗？（y/n）】y
【请输入成绩：】95
【继续输入成绩吗？（y/n）】t
【只能输入y或n】
【继续输入成绩吗？（y/n）】n
【输入的所有分数的平均分为】92.50
---------------------------------------------------------
注意：部分源程序给出如下。请勿改动主函数main和其它函数中的
任何内容，仅在函数的注释标志之间填入所编写的若干语句。
------------------------------------------------------'''
def main():
number=0
total=0
while True:
chenji=float(input("【请输入成绩：】"))
#**********Program**********
number += 1
total += chenji
while True:
#********** End **********
flag = input('【继续输入成绩吗？（y/n）】')
if flag not in ('y', 'n'):
print('【只能输入y或n】')
else:
break
if flag=='n':
break
print('【输入的所有分数的平均分为】%.2f'%(total/number))
if __name__ == '__main__':
main()
解析：
# -*- coding:cp936 -*-
'''------------------------------------------------------
【程序设计】
---------------------------------------------------------
题目：用户输入若干个分数，求所有分数的平均分。每输入一个
分数后询问是否继续输入下一个分数，回答“y”、“n”
之外的字符就提示只能输入y或n并继续询问是否继续输入
下一个分数，回答“y”就继续输入下一个分数，回答“n”
就停止输入，结束程序
例如：
【请输入成绩：】90
【继续输入成绩吗？（y/n）】y
【请输入成绩：】91
【继续输入成绩吗？（y/n）】y
【请输入成绩：】92
【继续输入成绩吗？（y/n）】y
【请输入成绩：】93
【继续输入成绩吗？（y/n）】y
【请输入成绩：】94
【继续输入成绩吗？（y/n）】y
【请输入成绩：】95
【继续输入成绩吗？（y/n）】t
【只能输入y或n】
【继续输入成绩吗？（y/n）】n
【输入的所有分数的平均分为】92.50
---------------------------------------------------------
注意：部分源程序给出如下。请勿改动主函数main和其它函数中的
任何内容，仅在函数的注释标志之间填入所编写的若干语句。
------------------------------------------------------'''
def main():
number = 0
total = 0
while True:
chenji = float(input("【请输入成绩：】"))
#**********Program**********
number += 1
total += chenji
while True:
#********** End **********
flag = input('【继续输入成绩吗？（y/n）】')
if flag not in ('y', 'n'):
print('【只能输入y或n】')
else:
break
if flag == 'n':
break
if number > 0:
print('【输入的所有分数的平均分为】%.2f' % (total / number))
else:
print('【没有输入任何分数】')
if __name__ == '__main__':
main()
解释：
- 累加分数和计数：
total: 用于累加所有输入的分数。number: 用于记录输入分数的次数。
- 输入分数：
- 每次输入分数后，更新
total和number。
- 每次输入分数后，更新
- 询问是否继续：
- 使用一个循环不断询问用户是否继续输入分数。只有当用户输入
'y'或'n'时才会跳出这个循环。 - 如果用户输入
'y'，继续输入下一个分数。 - 如果用户输入
'n'，跳出主循环并结束输入。
- 使用一个循环不断询问用户是否继续输入分数。只有当用户输入
- 计算并打印平均分：
- 在输入结束后，检查是否有输入分数。如果有，计算平均分并打印。如果没有，提示没有输入任何分数。
这样，程序能够根据用户输入的分数正确计算并输出平均分，同时处理用户输入的有效性。
答案：
第四题：
# -*- coding:cp936 -*-
'''------------------------------------------------------
【程序设计】
---------------------------------------------------------题目：绘制红色red正方形
描述：用户输入一个正整数作为边长，利用turtle库绘制一个正方形。
要求：
输入格式：输入一个正整数，作为正方形的边长
输出格式：如示例
使用forward函数、left函数、pencolor函数、使用for语句
输入示例 输出示例示例1 200 如样张
---------------------------------------------------------
注意：仅在注释标志之间填入所编写语句。
------------------------------------------------------'''#**********Program**********
#********** End **********
解析：
为了完成这个任务，我们需要使用Python的turtle库来绘制一个红色的正方形。用户将输入一个正整数作为正方形的边长。我们将使用turtle库中的forward、left、pencolor等函数来实现绘制。
以下是完整的代码：
# -*- coding:cp936 -*-
'''------------------------------------------------------
【程序设计】
---------------------------------------------------------
题目：绘制红色red正方形
描述：用户输入一个正整数作为边长，利用turtle库绘制一个正方形。
要求：
输入格式：输入一个正整数，作为正方形的边长
输出格式：如示例
使用forward函数、left函数、pencolor函数、使用for语句
输入示例 输出示例
示例1 200 如样张
---------------------------------------------------------
注意：仅在注释标志之间填入所编写语句。
------------------------------------------------------'''
#**********Program**********
# 导入turtle库，用于绘图
import turtle
# 设置画笔颜色为红色
turtle.pencolor("red")
# 获取用户输入的正整数作为正方形的边长
l = int(input())
# 使用for循环绘制正方形，循环4次，每次绘制一条边
for _ in range(4):
# 向前移动指定长度
turtle.forward(l)
# 左转90度，准备绘制下一条边
turtle.left(90)
# 隐藏turtle图标
turtle.hideturtle()
# 保持绘图窗口打开，直到用户关闭
turtle.done()
#********** End **********
- 导入turtle库：
import turtle用于导入绘图库。 - 设置画笔颜色：
turtle.pencolor("red")将画笔颜色设置为红色。 - 获取用户输入：
l = int(input())获取用户输入的正整数作为正方形的边长。 - 绘制正方形：
for _ in range(4):使用for循环4次，每次绘制正方形的一条边。turtle.forward(l)向前移动指定长度，即正方形的边长。turtle.left(90)左转90度，准备绘制下一条边。
- 隐藏turtle图标：
turtle.hideturtle()隐藏turtle图标，使绘图更清晰。 - 保持绘图窗口打开：
turtle.done()保持绘图窗口打开，直到用户手动关闭。
这样，程序将根据用户输入的边长绘制一个红色的正方形。
最终结果：
📝大佬觉得本文有所裨益，不妨轻点一下👍给予鼓励吧！
❤️❤️❤️本人虽努力，但能力尚浅，若有不足之处，恳请各位大佬不吝赐教，您的批评指正将是我进步的动力！😊😊😊
💖💖💖若您认为此篇文章对您有所帮助，烦请点赞👍并收藏🌟，您的支持是我前行的最大动力！
🚀🚀🚀任务在默默中完成，价值在悄然间提升。让我们携手共进，一起加油，迎接更美好的未来！🌈🌈🌈
929
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
