当前位置： 首页 > news >正文

做推广的网站带宽需要多少,长沙软件开发培训机构,wordpress修改模板教程,百度seo查询收录查询目录 第一章 一、高级语言程序的执行方式 二、变量赋值与内存地址 三、字符编码 3.1 Unicode 3.2 ASCII#xff08;American Standard Code for Information Interchange#xff09; 四、编程语言分类按照编程范式分类 4.1 面向过程语言 4.2 面向对象语言 五、原码…目录 第一章 一、高级语言程序的执行方式 二、变量赋值与内存地址 三、字符编码 3.1 Unicode 3.2 ASCIIAmerican Standard Code for Information Interchange 四、编程语言分类按照编程范式分类 4.1 面向过程语言 4.2 面向对象语言 五、原码、反码和补码 5.1 原码 5.2 反码 5.3 补码 六、基本的计算机概念 6.1二进制和数据表示 6.2内存和存储 6.3 变量和常量 6.4运算符和表达式 6.5 控制结构 6.6 函数 6.7 数据结构 6.8 文件处理 6.9 异常处理 6.10 面向对象编程OOP* 6.11.模块和包 6.12  库和框架* 七、进制转换二进制  7.1整数部分的转换 7.2小数部分的转换 第二章

1. 数据类型和转换 1.1进制转化 1.2字符串格式化居中对齐 1.3虚数类型
2. 运算和表达式 2.1取整运算 2.2四舍五入 2.3逻辑运算 2.4布尔值 2.6布尔值与比较运算 2.7布尔值与条件/循环语句  3常见错误类型 结果类型 3 1进制转换错误 3.2类型错误 3.3表达式结果类型 4 math 模块
3. 字符串拼接 5.1直接拼接 5.2使用加号 5.3使用join方法  5.4使用format方法 5.5使用 f-string格式化字符串字面量 5.6 如果需要重复一个字符串可以使用 * 运算符
4. 复数
5. 字符串结束标志
6. 运算注意事项 第三章 一、 判断表达式的输出 二、 列表操作 三、随机数操作 四、列表切片 五、写法规范 六、列表拼接字符串的判断 七、 列表操作之pop函数 八、 字符串处理 九、内存地址和引用 十、运算顺序    python 十一、打印表格内容 第四章题目解析 第五章 集合与字典的基本知识与应用 1.集合基本知识 1.1集合的元素 添加删除 1.2集合的创建 1.3集合的操作 2.字典基本知识 2.1字典的键 2.2访问字典 2.3字典操作键值对反转字典合并 3.数据结构总结 -3.1 创建空数据结构

• 3.2可变与不可变 4 相关题目 4.0正确数据结构选择
• 4.1输出字典中的键
• 4.2删除字典中的键值对
• 4.3输出字典中某个键的平方值
• 4.4计算字符串中单词的长度
• 4.5合并两个字典
• 4.6访问二维列表中的元素
• 4.7列表推导式 第六章 函数题目分析 第七章  文件和异常题目分析 一、判断题 二、单选题 三、填空题 第一章 一、高级语言程序的执行方式 高级语言程序要被机器执行有以下几种常见的执行方式 解释执行通过解释器逐行解释并执行源代码。编译执行通过编译器将源代码编译成机器代码然后由计算机执行。即时编译JIT在运行时将部分或全部代码编译为机器代码提高执行效率。虚拟机执行在虚拟机上运行通过虚拟机将字节码解释或编译为机器代码。 —例题高级语言程序要被机器执行,只有用解释器来解释执行。False 二、变量赋值与内存地址 变量赋值是将一个值存储到一个变量中。内存地址是计算机内存中的一个位置每个变量的值都存储在内存中的某个地址上。当变量被重新赋值时它会引用一个新的内存地址。 —例题已知 x3, 则执行“ x7”后id(x)的返回值与原来没有变化。 False 三、字符编码 3.1 Unicode 特点 设计目的是覆盖世界上所有的书写系统。UTF-8与UTF-16使用可变长度编码可以表示超过100万个字符。 编码形式 UTF-8可变长度1到4个字节向后兼容ASCII节省空间。UTF-16可变长度2或4个字节常用于操作系统和编程语言内部。UTF-32固定长度4个字节直接表示所有字符但占用空间大。 示例 A 的 UTF-8 编码是 0x411字节。你 的 UTF-8 编码是 0xE4 0xBD 0xA03字节。 优势 能够表示几乎所有语言的字符具有广泛的通用性。 3.2 ASCIIAmerican Standard Code for Information Interchange 特点 使用7位二进制表示字符最多可以表示128个即2^7字符。包含基本的英文字母大小写、数字、标点符号以及一些控制字符。 示例 A 的 ASCII 码是 65。a 的 ASCII 码是 97。 局限性 仅能表示英语及一些常见符号不能满足其他语言的需求。 —例题UTF-8码是不等长编码即不同字符占用的字节数不同。True 四、编程语言分类按照编程范式分类 4.1 面向过程语言 特点程序由过程函数构成通过过程调用完成任务。示例C。 4.2 面向对象语言 特点程序由对象构成对象包含数据和方法通过对象的交互完成任务。示例Java、C、Python。 —例题不是面向对象的程序设计语言是C。True 五、原码、反码和补码 在二进制表示中有三种常见的编码方式原码、反码和补码。以下是它们的定义和特点 5.1 原码
• 正数的原码原码与其二进制表示相同符号位是0。- 负数的原码在二进制表示的前面加上一个1作为符号位。 5.2 反码
• 正数的反码反码与其原码相同。- 负数的反码原码除符号位外的所有位取反。 5.3 补码
• 正数的补码补码与其原码相同。- 负数的补码反码加1。 注意正数的原码、反码和补码都是相同的。 —例题十进制106的原码是反码是补码是___ 用八位表示     解析:三个都是01101010 六、基本的计算机概念 6.1二进制和数据表示
• 二进制Binary计算机使用二进制0和1来表示和存储数据。- 字节Byte一个字节等于8位bit。- 数据类型包括整数、浮点数、字符串、布尔值等。不同的数据类型在内存中有不同的表示和存储方式。标识符规范由数字字母下划线组成不能以数字开头区分大小写不能使用关键字标识符不能是 Python 的关键字或保留字例如 if、for、while 等 6.2内存和存储
• RAM随机存取存储器用于临时存储数据断电后数据会丢失。- ROM只读存储器用于存储永久性数据断电后数据不会丢失。- 存储器地址每个存储单元都有一个唯一的地址用于访问存储器中的数据。 6.3 变量和常量
• 变量用于存储可以改变的数据。- 常量用于存储不变的数据。 6.4运算符和表达式
• 算术运算符如 、-、*、/。- 比较运算符如 、!、、。- 逻辑运算符如 and、or、not。 6.5 控制结构
• 条件语句如 if、elif、else。- 循环语句如 for、while。 6.6 函数 -定义和调用函数使用 def 关键字定义函数通过函数名调用函数。- 参数和返回值函数可以接受参数并返回值。 6.7 数据结构
• 列表List有序、可变的集合如 [1, 2, 3]。- 元组Tuple有序、不可变的集合如 (1, 2, 3)。- 字典Dictionary键值对的集合如 {key: value}。- 集合Set无序、唯一元素的集合如 {1, 2, 3}。 6.8 文件处理
• 文件读写使用 open 函数打开文件read 和 write 方法读取和写入文件。- 文件模式如 r读、w写、a追加。 6.9 异常处理
• 捕获和处理异常使用 try、except 块来捕获和处理可能发生的异常。 6.10 面向对象编程OOP*
• 类和对象使用 class 关键字定义类通过类创建对象。- 继承一个类可以继承另一个类的属性和方法。- 封装将数据和方法封装在类中。- 多态同一方法在不同对象中的不同实现。 6.11.模块和包
• 模块一个Python文件就是一个模块可以包含函数、类和变量。- 包包含多个模块的文件夹通过 import 关键字导入模块和包。 6.12  库和框架*
• 标准库Python自带的模块和包如 math、datetime。- 第三方库由社区和开发者创建的库可以通过 pip 安装如 numpy、pandas。 七、进制转换二进制  7.1整数部分的转换 步骤 用2除十进制整数并记录商和余数。再用2除上一步的商继续记录新的商和余数。重复步骤2直到商为0为止。将所有的余数按逆序排列即从最后一次除法得到的余数开始到第一次除法得到的余数这些逆序排列的余数就是整数部分的二进制表示。 示例 将十进制数 45 转换为二进制 步骤操作商余数145 ÷ 2221222 ÷ 2110311 ÷ 25145 ÷ 22152 ÷ 21061 ÷ 201 逆序排列余数得到101101。 所以45 的二进制表示为 101101。 7.2小数部分的转换 步骤 乘以2并记录整数部分。将乘以2后的结果的小数部分继续乘以2记录新的整数部分。重复步骤2直到小数部分为0或达到所需的精度为止。将所有记录的整数部分按顺序排列即从第一次乘法得到的整数部分开始到最后一次乘法得到的整数部分这些顺序排列的整数部分就是小数部分的二进制表示。 示例 将十进制小数 0.625 转换为二进制 步骤操作整数部分小数部分10.625 × 2 1.2510.2520.25 × 2 0.500.530.5 × 2 1.010.0 将记录的整数部分按顺序排列得到101。 所以0.625 的二进制表示为 0.101。 —例题十进制19.625的二进制是___(整数部分用八位二进制表示) 解析 整数部分转换 将整数部分 19 转换为二进制 步骤操作商余数119 ÷ 29129 ÷ 24134 ÷ 22042 ÷ 21051 ÷ 201 将余数逆序排列得到10011。 所以整数部分 19 的二进制表示为 10011。 小数部分转换 将小数部分 0.625 转换为二进制 步骤操作整数部分小数部分10.625 × 2 1.2510.2520.25 × 2 0.500.530.5 × 2 1.010.0 将记录的整数部分按顺序排列得到101。 所以小数部分 0.625 的二进制表示为 0.101。 所以最后答案为 00010011.101 第二章

1. 数据类型和转换 1.1进制转化 a, b input().split(,) b int(b) c int(a, b) # 将 b 进制的 a 转换为十进制 print©

   输入 45, 8 并不会输出 37因为 a 是字符串应该改成 int(a, b) 而不是 int(a, b)bin()#注意括号内是int类型###变成二进制

   oct()#变成八进制 hex()#变成16进制hex()[2:]##加切片可以去除0b 0o 0x的前缀其他类似 例题 a,b input().split(,) bint(b) cint(a,b)   #把b进制的a变成十进制 print© 输入458并会输出37 False 因为#处第一个参数是绝对引用a字母变成字符串了改成intab即可输出37 1.2字符串格式化居中对齐 mint(input()) print({:^5}.format(m)) print({:^m}.format(m)) ###ValueError #输入5第二个print这里不支持{^m}在格式化指令中直接使用变量作为字段宽度或其他限制参数的值print({:^{width}}.format(**m, widthm)) # 正确写法输出一个宽度为 m 的居中字符串其中 m 为输入的值print(这是数字输出格式{:5d}.format(123))  # 输出这是数字输出格式  123前面有两个空格空格表示填充 1.3虚数类型 print(type(1j))  # 输出 class complexJ 或 j 是虚数单位 注意j大小写均可  通常小写

2. 运算和表达式 2.1取整运算 print(type(3 // 2))  # 输出 class int整除运算符返回整数 2.2四舍五入 print(round(17.0 / 3**2, 2))  # 输出 1.89round 函数第二个参数表示保留小数点后两位 2.3逻辑运算 print(0 and 1 or not 2 True)  # 输出 True解释如下

   2 True 等同于 False

   not False 等同于 True

   0 and 1 返回 0因为 0 为 False

   0 or True 返回 True

   布尔运算顺序是先比较运算再逻辑运算逻辑运算中如果没有括号优先级默认是notandor
   2.4布尔值 下列被视为False其他所有值都被视为 True。 数值 0空字符串 空列表 []空元组 ()空字典 {}空集合 set()特殊值 None bool(0) # False bool(1) # True bool() # False bool(Hello) # True bool([]) # False bool([1, 2]) # Trueprint(int(True))  # 输出 1 print(bool(FALSE))  # 输出 True因为 FALSE 是非空字符串 print(bool(False))  # 输出 False print(bool([ ]))  # 输出 False因为 [] 是空列表 print(bool(None))  # 输出 False 逻辑运算符返回值 print(3 and 0 and hello)  # 输出 0and 运算符返回第一个 False 的值 print(3 and 0 and 5)  # 输出 0and 运算符返回第一个 False 的值 print(((2 2) or (2 2)) and 2)  # 输出 2

   (2 2) 为 True(2 2) 为 False

   True or False 为 True

   True and 2 返回 2 2.6布尔值与比较运算

   1 1 # True 1 2 # False1 ! 1 # False 1 ! 2 # True2 1 # True 1 2 # False1 2 # True 2 1 # False #与类似的 2.7布尔值与条件/循环语句  布尔值在控制程序流程的条件语句中非常重要例如 if 语句 if True:print(This is true.) else:print(This is false.)布尔值也可以控制循环语句的执行例如 while 循环。在下面的程序中只要条件 count 5 为真循环就会继续执行。 count 0 while count 5:print(count)count 13常见错误类型 结果类型 3 1进制转换错误 try:print(bin(12.5))  # 会报错 TypeError因为 bin() 只接受整数 except TypeError as e:print(e)try:print(int(92, 8))  # 会报错 ValueError因为 92 不是有效的八进制数字 except ValueError as e:print(e) 3.2类型错误 x car y 2 try:print(x y)  # 会报错 TypeError因为不能将字符串与整数连接 except TypeError as e:print(e) 3.3表达式结果类型 print(type(1 2 * 3.14 0))  # 输出 class bool表达式结果为布尔值 4 math 模块 import math print(math.sqrt(4) * math.sqrt(9))  # 输出 6.0 5. 字符串拼接 5.1直接拼接 print(hello world)  # 输出 helloworld字符串直接拼接 print(hello world)  # 输出 hello world print()打印函数里面的逗号相当于一个空格 5.2使用加号 str1 hello str2 world result str1 str2 print(result) # 输出 hello world5.3使用join方法  str_list [hello, world] result .join(str_list) print(result) # 输出 hello world5.4使用format方法 str1 hello str2 world result {} {}.format(str1, str2) print(result) # 输出 hello world5.5使用 f-string格式化字符串字面量 str1 hello str2 world result f{str1} {str2} print(result) # 输出 hello world5.6 如果需要重复一个字符串可以使用 * 运算符 str1 hello result str1 * 3 print(result) # 输出 hellohellohello6. 复数 z 1 2j print(z.real)  # 输出 1.0 print(z.imag)  # 输出 2.0 print(z.conjugate())  # 输出 (1-2j)返回共轭复数 实部real    虚部imag     共轭复数conjugate 7. 字符串结束标志 在 Python 中字符串不以 \0 结束这是在 C 或 C 中的做法 8. 运算注意事项 print(10 / 2)  # 输出 5.0浮点运算的结果为浮点数

   整数运算和浮点运算的结果类型取决于操作数的类型 整数运算 (, -, *, /, %): 如果两个操作数都是整数int那么大多数运算除了 /都会返回整数 浮点数运算 (, -, *, /, %): 如果至少有一个操作数是浮点数float那么运算结果将是 float 类型。 第三章

   一、 判断表达式的输出 print(34 in 1234True)输出什么 -表达式34 in 1234True返回值是 False因为1234 True是 False。 print(输出结果是{:8s}.format(this))输出什么 - 正确输出是 输出结果是this    右侧四个空格。这里格式化字符串 {8s} 表示字符串至少有8个字符文本默认左对齐。 print(输出结果是{:8d}.format(1234))输出什么 - 正确输出是 输出结果是    1234左侧四个空格。这里格式化字符串 {8d} 表示数字至少有8位数据默认右对齐。 print(输出结果是{:08.2f}.format(14.345))输出什么 - 正确输出是 00014.35。格式化字符串 {08.2f} 表示浮点数总长度为8保留两位小数左边补零。 以下哪句打印出smith\exam1\test.txt print(smith\exam1\test.txt) √ 而print(smith\exam1\test.txt)会输出smith\exam1        est.txt print(smith\exam1\test.txt)会smithexam1test.txt print(smith\exam1\test.txt)会SyntaxError: unexpected character after line continuation character list(abcd)的结果  [a, b, c, d] len(3//11//2018.split(/))的结果 5 分析 括号里面相当于 x3//11//2018 xx.split(/)现在x是[3, , 11, , 2018]所以是5 print({1}{0}{2}.format(2, 3, 23))的输出325 print({first}-{second}{0}.format(34-23, first34, second23))的输出34-2311 print({:08s}.format(bin(31)[2:]))的输出00011111 二、 列表操作 - 字符串和列表都是序列类型。 - 字符串对象和元组对象是不可变对象列表对象是可变对象。 - 列表不能使用 find() 函数搜索数据。要不然为什么还会有二分法等查找方法呢 - 列表可以使用 append() 方法添加元素。 例题  判断表达式 1.    12 *3 .join([12, 12, 12]) 返回值是 False。前者是121212后者是12 12 12。 2. [1,2,[3]][4,5]的结果 [1, 2, [3], 4, 5]   3. [4,5]*3的结果 [4, 5, 4, 5, 4, 5]     4. list1 [1, 2, 3, 4, 5, 4, 3, 2, 1] 中 print(list1[:-1]) 的输出 [1, 2, 3, 4, 5, 4, 3, 2]     解左闭右开所以是从索引为0到-2 5. random.randint(0, n) 中 n 的值 - 如果要得到 [0, 100] 范围内的随机数n 应该是 100。 解randint函数包括两个边界值的 6. print(programming.find(r, 2))的输出 4 解 str.find()第一个参数是要搜索的子串第二个参数是开始搜索的位置。这里从索引为2的o处开始找r输出4 7. print(programming.find(x))的输出 -1 解str.find() 方法如果找到了子串就返回子串在字符串中的索引位置如果没有找到则返回 -1 这里没找到故返回-1 8. print(a123.isdigit())的输出 False 解str.isdigit() 是一个字符串方法用于判断字符串中的所有字符是否都是数字 如果字符串中包含任何非数字字符该方法将返回 False 9. print(aABC.isalpha())输出 True 解 str.isalpha() 是一个字符串方法用于判断字符串中的所有字符是否都是字母 如果字符串中包含任何非字母字符该方法将返回 False 三、随机数操作 - shuffle() 不是 random 模块中的函数。 四、列表切片 切片应用 提取子列表 sub_list my_list[2:6] # 输出: [2, 3, 4, 5] 反转列表 reversed_list my_list[::-1] # 输出: [9, 8, 7, 6, 5, 4, 3, 2, 1, 0] 复制列表 copied_list my_list[:] # 输出: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 例子列表 lst[12, -5, -22, -10, -26, 35, 0, 49, 3, -21] 的切片操作 lst[0:100]  # 输出[12, -5, -22, -10, -26, 35, 0, 49, 3, -21]lst[100:]  # 输出[]lst[100]  # 运行错误IndexError: list index out of range 五、写法规范 5.1 for i in a.sort() 是错误的语句应该改为    a.sort()     for i in a:        两行代码 5.2 字符串 lower 方法的调用规范 c Aprint(c.lower()) 错误调用 例如print(c.lower)   lower是一个字符串对象的方法调用的时候要在方法名后面加上一对圆括号 () 六、列表拼接字符串的判断 lst [1, 2, 3, 4, 5]s1 for c in lst:s1 s1 c s2 .join(lst)if s1 s2:print(yes)else:print(no) 输出no。因为 s1 是 1 2 3 4 5 (注意5后面有一个空格) 而 s2 是 1 2 3 4 5。4. 七、 列表操作之pop函数 list(range(2, 12, 2))[:-2].pop()  # 输出6 range(2,12,2)2 4 6 8 10 list[2, 4, 6, 8, 10] [:-2][2, 4, 6] pop()是一个列表方法用于移除列表中的最后一个元素并返回该元素 所以输出6 八、 字符串处理 知识点 - strip()、rstrip() 和 lstrip() 方法用于移除字符串两端的特定字符。 例题□表示空格 1. print(□□□xyz□□.strip(), □□□xyz□□.rstrip(), □□□xyz□□.lstrip())的输出 xyz □□□xyz xyz□□ 九、内存地址和引用 知识点 - 浅拷贝和深拷贝的区别。 例题 1. 内存地址的比较 a [1, 2, 3, 4]b aprint(id(a) id(b))  # Truec a.copy()print(id(a) id©)  # Falsed a[:]print(id(a) id(d))  # False #后面为输出的结果解释如下 ba将a的引用赋值给b此时b和a引用同一个列表对象所以输出是True ca.copy()创建了a的一个浅拷贝赋值给c由于c是a的一个副本它们是两个不同的对象所以输出是False da[:]使用切片操作a[:]创建了a的一个浅拷贝赋值给d。这种切片操作本质上和a.copy()相同都会创建一个新的列表对象。由于d是a的一个副本它们是两个不同的对象所以输出是False。 什么时候id内存地址相同 a hello    a 100   a[1,2,3] b hello    b 100   ba 引用相同对象如上都是hello或者100  或者两个变量被赋予同一个对象的引用的时候内存地址相同 十、运算顺序     python t 1t, a 2, t 1print(a)  # 输出2 a不是3因为先运算等号右边此时t值为1    
   十一、打印表格内容 知识点 - 使用不同方式打印表格内容。 例题 1. 三种不同方式打印表格内容 students [(3180102988, 褚好),(3170102465, 王凯亮),(3160104456, 李永),(3171104169, 陈鑫),(318400429, 徐杭诚)]for row in students:  # 按行存取print(row[0], row[1])print()for id, name in students:  # 按行拆包存取print(id, name)print()for index in range(len(students)):  # 按索引存取print(students[index][0], students[index][1]) 第四章 循环与列表题目解析 –1– 在循环中continue语句的作用是结束本次循环退出循环的当前迭代  √ 带有else子句的循环如果因为执行了break语句而退出的话会执行else子句的代码。× 分析因为break是跳出整个循环所以如果循环体内有else子句且循环是通过break退出的那么else子句中的代码也不会被执行。 当然循环结构可以没有else子句 e.g. for i in range(3):print(i) 下面程序的输出是3。× lst[34,6,7,0,0,0,9]n0for i in lst:if i0:lst.remove(i)n1print(n) 分析第一次移除原索引为3的‘0’  然后原索引为456分别变为345 刚刚查过3这个索引 接下来查4即查原索引为5的‘0’并移除 后面查不到0了所以总共移除了两个0 故输出应该为2而不是3。 思考倘若变成列表里面0不是连着的分布的例如 下面输出是3 lst[0,34,6,0,7,0,9]n0for i in lst:if i0:lst.remove(i)n1print(n) 那么输出3就是对的 关于可变/不变 下面程序输出值是1。× data[[1]*3]*3##①data[0][1]45#②print(data[2][1])#③ ①处  *3是 重复引用同一个列表三次 data [[1, 1, 1],  # 这三个内层列表实际上是同一个对象[1, 1, 1],[1, 1, 1]] ②由于这三个内层列表是相同的对象因此修改会反映在所有引用中 现在data即 data [[1, 45, 1],[1, 45, 1],[1, 45, 1]] 所以③输出45 思考如果外面不是用*3 data [[1] * 3 for i in range(3)]data[0][1] 45print(data)  # 输出 [[1, 45, 1], [1, 1, 1], [1, 1, 1]]print(data[2][1])  # 输出 1 下面程序中 i的循环终值是_______。 for  i  in  range(10):print(i) 是9 但是如果是像while i5这种终值就是5 下面程序中语句print(i*j)共执行了_____________次。 for i in  range(5):for j in range(2,5):print(i*j) 每次循环的具体输出 1. 当 i 0 时内层循环 j 取值为 [2, 3, 4] - 0 * 2 0 - 0 * 3 0 - 0 * 4 0 2. 当 i 1 时内层循环 j 取值为 [2, 3, 4] - 1 * 2 2 - 1 * 3 3 - 1 * 4 4 3. 当 i 2 时内层循环 j 取值为 [2, 3, 4] - 2 * 2 4 - 2 * 3 6 - 2 * 4 8 4. 当 i 3 时内层循环 j 取值为 [2, 3, 4] - 3 * 2 6 - 3 * 3 9 - 3 * 4 12 5. 当 i 4 时内层循环 j 取值为 [2, 3, 4] - 4 * 2 8 - 4 * 3 12 - 4 * 4 16 外层是5次 内层是3次     总共15次 执行下面程序产生的结果是_____________。 x2;y2.0   #分号可把两个语句写在一行if(xy):print(相等)else:print(不相等) 相等 注Python 在比较两个不同类型的数值时会进行类型转换这种转换称为“隐式类型转换”或“类型强制”。在这种情况下Python 会将整数 x 转换为浮点数如果需要的话或者将浮点数 y 转换为整数如果需要的话以便进行比较。由于 2 和 2.0 的数值相同 注意 如果for i in range(10,0)这种步长非负并且参数1比参数2大的range就不产生任何值 下面程序输出什么 for i in range(1,5):j0while ji:print(j,end )j1print() 会输出以下↓ 0 0 1 0 1 2 0 1 2 3 下面程序运行后输出是 a [1, 2, 3, 4, [5, 6], [7, 8, 9]]  #一个列表s 0for row in a:                           #遍历a中的元素if type(row)list:          #检查元素是否为列表for elem in row:        #处理嵌套列表s elemelse:                                       #处理非列表元素srowprint(s) 所以即算列表和 为45 下面程序运行后输出是___。 l3[ij for i in range(1,6) for j in range(1,6)]print(sum(l3)) 嵌套循环 相当于 for i in range(1, 6):for j in range(1, 6):l3.append(i j) 先固定一个i比如说i为1j从1到5生成ij即23456 接下来i是2j从1到5……以此类推 总和就是2加到6 3加到7 4到8 5到9 6到10 即20 25 30 35 40   即150 下面程序运行后输出是___。 l3[[(i,j) for i in range(1,6)] for j in range(1,6)]print(l3[2][1][0]) 分析这个列表生成式创建了一个5x5的二维列表其中每个元素都是一个元组 (i, j)。外层列表生成式遍历 j 从 1 到 5内层列表生成式遍历 i 从 1 到 5。 l3 [ [(1, 1), (2, 1), (3, 1), (4, 1), (5, 1)],  # 当 j 1 [(1, 2), (2, 2), (3, 2), (4, 2), (5, 2)],  # 当 j 2 [(1, 3), (2, 3), (3, 3), (4, 3), (5, 3)],  # 当 j 3 [(1, 4), (2, 4), (3, 4), (4, 4), (5, 4)],  # 当 j 4 [(1, 5), (2, 5), (3, 5), (4, 5), (5, 5)]   # 当 j 5 ] 所以是 2 下面程序运行后最后一行输出是______。 n 3m 4a [0] * n                  #a [0, 0, 0]for i in range(n):a[i] [0] * m         #在每次迭代中将 a[i] 赋值为一个长度为 4 的列表 [0, 0, 0, 0]print(a[0][2]) 分析 前三行 n 被设置为 3表示列表 a 将有3个子列表。 m 被设置为 4表示每个子列表将有4个元素。 a [0] * n 创建一个包含 3 个元素的列表每个元素初始为 0。 迭代分析 第一轮i0     a[0] 赋值为 [0, 0, 0, 0]    所以a [[0, 0, 0, 0], 0, 0]   输出0 第二轮i1     a[1] 赋值为 [0, 0, 0, 0]    所以a [[0, 0, 0, 0], [0, 0, 0, 0], 0]  输出0 第三轮i2    a[2] 赋值为 [0, 0, 0, 0]     所以a [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]] 输出0 最终输出 0 0 0 所以答案为 0 关于列表的引用 下面程序的输出是 row[0]*3                   #创建列表[0, 0, 0]data[row,row,row]    #创建了一个二维列表 data其每一行都引用同一个 row 列表data[2][2]7          # data 的第三行第三列的值设置为 7。由于所有行都引用同一个 row 列表#因此这个操作会影响到所有引用 row 列表的地方print(data[0][2])         初始 row [0, 0, 0]data [row,  # [0, 0, 0]row,  # [0, 0, 0]row   # [0, 0, 0]] data[2][2] 7   相当于   row[2] 7 现在 data [ [0, 0, 7], [0, 0, 7], [0, 0, 7] ] 所以结果是 7 下面程序的输出是 data[[0]*3] *3 #使用的是 [[0] * 3] * 3所以 data 中的3个子列表实际上是同一个列表的引用data[2][2]7    #由于所有行都引用同一个列表这个操作会影响所有引用该列表的地方print(data[0][2]) 分析所以答案是 7 下面程序的输出是 data[]for i in range(3):data.append([0]data[2][2]7print(data[0][2]) 分析使用循环 for i in range(3) 遍历3次每次迭代中向 data 添加一个包含3个元素 [0, 0, 0] 的新列表。这样data 中的每一行都是独立的列表 data[2][2] 7     这个修改只会影响 data[2] 初始 data [[0, 0, 0],  # 第一次迭代添加的列表[0, 0, 0],  # 第二次迭代添加的列表[0, 0, 0]   # 第三次迭代添加的列表] 修改后 data [ [0, 0, 0], [0, 0, 0], [0, 0, 7] ] 所以结果是0 下面程序的输出是 mat[[i*3j1 for j in range(3)] for i in range(5)]mattrans[[row[col] for row in mat] for col in range(3)]print(mattrans[1][3]) 分析①mat [[i*3 j 1 for j in range(3)] for i in range(5)]这一行 外层循环遍历 i 从 0 到 4共 5 次生成 5 行。 内层循环遍历 j 从 0 到 2共 3 次生成 3 列。 每个元素的值为 i * 3 j 1。 具体生成的mat矩阵如下 mat [[1, 2, 3],     # 当 i 0[4, 5, 6],     # 当 i 1[7, 8, 9],     # 当 i 2[10, 11, 12],  # 当 i 3[13, 14, 15]   # 当 i 4] ②mattrans [[row[col] for row in mat] for col in range(3)]这一行 外层循环遍历 col 从 0 到 2生成转置后的3行。 内层循环遍历 mat 中的每一行提取第 col 列的元素形成转置后的列。 mattrans [[1, 4, 7, 10, 13],  # 第0列转成第0行[2, 5, 8, 11, 14],  # 第1列转成第1行[3, 6, 9, 12, 15]   # 第2列转成第2行] 即转置列表     输出是11 第五章 集合与字典的基本知识与应用 1.集合基本知识 Python 的集合set是一个无序的不重复元素序列。它使用大括号 {} 或者 set() 函数创建。由于集合是无序的所以它不支持索引操作也没有切片功能。 集合具有以下基本特性 无序性集合中的元素没有固定的顺序。 确定性集合中的元素是不重复的即集合中不存在重复的元素。 互异性集合中的元素必须是不可变类型例如整数、浮点数和字符串等。 1.1集合的元素 添加删除 - 集合的元素可以是任意数据类型。×   - 错误集合的元素不能是可变的数据类型比如列表和字典。 - 集合的元素去重特性。   - len(set([0,4,5,6,0,7,8])) 的结果是 6。   - 因为集合会去除重复元素即去除两个0中的一个。 -添加与删除元素 添加元素可以用add方法 初始set11234 set1.add(5) print(set1) # 输出: {1, 2, 3, 4, 5}接着删除元素可以使用 remove() 方法。如果元素不存在会引发 KeyError。 set1.remove(3) print(set1) # 输出: {1, 2, 4, 5}删除元素也可以使用 discard() 方法。如果元素不存在不会引发错误。 set1.discard(6) # 不会引发错误1.2集合的创建 - 创建集合   - a {} 创建的是一个空字典而不是集合。   - 创建空集合应使用 a set()。 例如 使用 set() 函数创建一个空集合。 empty_set set() print(empty_set) # 输出: set()注意使用花括号 {} 可以创建一个非空集合。 set1 {1, 2, 3, 4} print(set1) # 输出: {1, 2, 3, 4}1.3集合的操作 - 无序性  - 下面程序的运行结果不一定是 1 2 3 4 set1{1,2,3,4}for i in set1:print(i,end ) - 分析集合是无序的因此元素的打印顺序不是固定的。   - 集合运算   - s1 s2 表示 s1 是 s2 的真子集。   - 不存在的集合操作s.append(1)应使用 s.add(1)。 2.字典基本知识 2.1字典的键 - 字典的键必须是不可变的。   - 列表是可变的因此列表不能作为字典的键。 2.2访问字典

• 访问字典元素   - dic[i] 访问字典元素时键 i 必须存在否则会引发 KeyError 异常。   - dic.get(张军, None) 如果键不存在返回 None不会引发异常。 e.g. dic {赵洁: 15264771766}print(dic[张军])  # 如果键不存在会引发 KeyError 2.3字典操作键值对反转字典合并 - 字典的键值对反转 dic {赵洁 : 15264771766, 张秀华 : 13063767486, 胡桂珍 : 15146046882}reversedic {v:k for k,v in dic.items()}print(reversedic[13063767486])  # 输出 张秀华 - 字典合并   - dic1.update(dic2) 更新 dic1 的内容并返回 None。   - dic3 {**dic1, dic2} 合并 dic1 和 dic2键冲突时 dic2 中的值覆盖 dic1 中的值。   dic1 {赵洁 : 15264771766}dic2 {张秀华 : 13063767486}dic1.update(dic2)print(dic1 {dic1, dic2})  # 输出 True - 合并后重复键覆盖   dic1 {胡桂珍: 15146046882}dic2 {胡桂珍: 13292597821}dic3 {dic1, **dic2}print(dic3[胡桂珍])  # 输出 13292597821 3.数据结构总结 -3.1 创建空数据结构 - 集合Setset()   - 字典Dictionary{}   - 列表List[]   - 元组Tuple() - 3.2可变与不可变 - 可变列表、字典、集合   - 不可变元组 4 相关题目 4.0正确数据结构选择
• 哪一句会得到 {1,2,3} A.list(123) B.tuple(123) C.set(123) D.以上都不是 set(123)  # 输出 {1, 2, 3} 分析list(123) 将字符串 123 转换为一个列表其中每个字符作为一个元素。 结果是 [1, 2, 3]。 而tuple(123) 将字符串 123 转换为一个元组其中每个字符作为一个元素。 结果是 (1, 2, 3) - 4.1输出字典中的键 dic {赵洁: 15264771766}print(张秀华 in dic)  # 输出 False - 4.2删除字典中的键值对 dic {赵洁: 15264771766, 张秀华: 13063767486}del dic[张秀华]print(dic)  # 输出 {赵洁: 15264771766} - 4.3输出字典中某个键的平方值 squares {x: x*x for x in range(20)}print(squares[12])  # 输出 144 - 4.4计算字符串中单词的长度 text four score and 7 yearslenwords {s: len(s) for s in text.split()}print(lenwords[score])  # 输出 5 - 4.5合并两个字典 dic1 {姓名: xiaoming, 年龄: 27}dic2 {性别: male, 年龄: 30}dic3 {k: v for d in [dic1, dic2] for k, v in d.items()}print(dic3[年龄])  # 输出 30 - 4.6访问二维列表中的元素 cells {values: [[100, 90, 80, 90], [95, 85, 75, 95]]}print(cells[values][1][2])  # 输出 75 - 4.7列表推导式 myth [{label: color, value: color} for color in [blue, red, yellow]]print(myth[1][label])  # 输出 red 第六章 函数题目分析 -函数也是对象下面程序可以正常运行吗 def func():              #这里定义了一个名为 func 的函数它         print(11,end )       #在被调用时打印字符串 11并且在末尾不换行。print(id(func),type(func),func)   #获取func的内存地址类型表现形式 通常是内存地址和函数名 分析 会正常运行e.g.输出2352392832160 class function function func at 0x00000223B58A04A0 函数本质上是对象可以存储于数据结构如列表字典当中 函数对象类型为 class function -形参和return语句都是可有可无的√ 分析:在Python中定义函数时不可省略的↓ def 关键字定义函数时必须使用 def 关键字。 函数名称紧跟在 def 关键字之后的是函数的名称这是必须的用于标识函数。 参数列表即使函数不需要参数也必须有一对空括号 ()用于定义参数列表。 函数体至少需要一个冒号 : 和一个缩进的代码块即函数体即使它是空的。 例如一个最简单的函数定义如下 def foo:… 这里…是ellipsis object省略号对象 形参 在编程语言中形参Formal Parameter是函数定义中用于接收传递给函数的值的变量。当函数被调用时形参会被实际的参数Argument所替代这些实际的参数是调用函数时提供的值。 例如考虑以下Python函数定义 def greet(name):print(Hello, name !) 在这个函数中name 就是一个形参。当你调用这个函数并传递一个实际的参数时比如 greet(Alice)name 形参就会被 Alice 这个实际参数所替代并且函数会输出 Hello, Alice!。 -在一个函数中如局部变量和全局变量同名则局部变量屏蔽全局变量√ 例如 x 10 # 全局变量def my_function():x 20 # 局部变量屏蔽全局变量xprint(Inside the function, x , x)my_function() # 调用函数 print(Outside the function, x , x) #会输出↓ #Inside the function, x 20 #Outside the function, x 10 -area是tri模块中的一个函数执行from tri import area 后调用area函数应该使用____ 。 area 分析 当你使用 from tri import area 导入语句时你直接将 area 函数从 tri 模块导入到当前的命名空间中。这意味着你可以直接使用 area() 来调用该函数而不需要模块名称作为前缀。 如果我们用的是  import tri  那么调用area函数要用tri.area()例如 import tri# 调用tri模块中的area函数triangle_area tri.area(base10, height5) -函数可以改变哪种数据类型的实参 int整数 是不可变数据类型 string字符串 是不可变数据类型 float浮点数 是不可变数据类型 -list 列表是可变数据类型函数内部可以改变原始的列表实参 -函数定义如下程序输出是什么 def f1(a,b,c):print(ab)nums(1,2,3)f1(nums) 分析 f1 函数期望接收三个参数 a, b, c但 f1(nums) 只传递了一个参数 nums这里的nums相当于参数a。这会导致函数调用时参数数量不匹配b和c没有的错误 修正 def f1(a, b, c):print(a b)nums (1, 2, 3)f1(*nums) 会输出3 ①函数参数数量匹配函数调用时传递的参数数量必须与函数定义时的参数数量匹配。 ②拆包操作使用 * 操作符可以将一个可迭代对象解包为单独的元素并传递给函数确保参数数量匹配。 -下面程序运行结果是 def fun(x1,x2,x3,x4): print(x1,x2,x3,x4)fun(x11,x222,x3333,x44444) 分析在函数定义中x4 会将所有多余的关键字参数以字典的形式捕获到 x4 中。如果你传递一个与 x4 同名的参数那么它会被视为一个普通参数而不是被捕获到 **x4 中。例如 def fun(x1, x2, x3, **kwargs):print(x1, x2, x3, kwargs)fun(x11, x222, x3333, extra4444) 输出结果是 1 22 333 {extra: 4444} 所以本题将输出 1 22 333 {x4: 4444} 下列程序将输出什么 def scope():n4m5print(m,n,end )n5t8scope()print(n,t) 分析 局部作用域在函数内部定义的变量只在函数内部有效不会影响全局作用域中的变量。 全局作用域在函数外部定义的变量在整个程序中有效除非在函数内部用 global 关键字声明否则函数内部对同名变量的修改不会影响全局变量。 n 5 t 8 在全局作用域中定义了两个变量 n 和 t分别赋值为 5 和 8。 scope() 调用 scope 函数执行函数内部的代码。 在 scope 函数的本地作用域中定义了局部变量 n 和 m分别赋值为 4 和 5。 print(m, n, end ) 输出局部变量 m 和 n 的值即 5 和 4。输出 5 4 . print(n, t) 打印全局作用域中的变量 n 和 t它们的值依然是 5 和 8。输出 5 8。 所以最后输出5 4 5 8 关于输出5 4与5 8要不要换行 print(m, n, end ) 输出 5 4并在末尾添加一个空格光标停在这一行的空格之后紧接着上一步的输出在同一行print(n, t) 输出 5 8。 如果删去 print(m,n,end )中的end 则会换行 输出 5 4 5 8 -下面程序运行结果是什么 def nprintf(message,n):for i in range(n):print(message,end )nprintf(a,3,)nprintf(n5,messagegood) 分析 函数实现功能是输出n个message 所以 nprintf(a,3,) 会输出 a a a (注意每个a后面都有一个空格) nprintf(n5,messagegood) 会输出 good good good good good 每一个good后面也有一个空格 所以原代码输出 a a a good good good good good -下面程序输出是什么 lst[(1,one),(2,two),(3,three),(4,four)]lst.sort(keylambda x:x[1])print(lst[3][1][2]) 分析 lst [(1, one), (2, two), (3, three), (4, four)]      #定义了一个列表lst.sort(keylambda x: x[1])      #排序    sort 方法使用 keylambda x: x[1] 对 lst 进行排序这表示按照每个元组的第二个元素即字符串部分进行排序。 排序后  [(4, four), (1, one), (3, three), (2, two)] print(lst[3][1][2])  [3]访问列表第四个元素即(2, two) [1]访问该元组的第二个元素即two字符串 [2]访问字符串two的第三个元素 即o 所以输出o -下列程序第四行输出什么 def perm(choice,selected[]):if len(choice)1:print(.join(selectedchoice))else:for i in range(len(choice)):tchoice[i]choice.remove(t)selected.append(t)perm(choice,selected)choice.insert(i,t)selected.pop()first[1,2,3]perm(first,selected[]) 分析 重点在于递归函数‘perm’的工作机制 基准 当 choice 列表的长度为 1 时将 selected 列表和 choice 列表连接起来并打印结果。 递归 遍历 choice 列表中的每个元素将其移除并加入到 selected 列表中。 递归调用 perm 函数来处理剩余的 choice 列表。 递归调用结束后将移除的元素重新插入到 choice 列表中的原位置并从 selected 列表中移除 def perm(choice, selected[]):  # 定义一个函数 perm接受两个参数 choice 和 selected默认 selected 是一个空列表if len(choice) 1:  # 如果 choice 的长度为 1print(.join(selected choice))  # 打印 selected 和 choice 的组合将列表转换为字符串else:  # 否则for i in range(len(choice)):  # 遍历 choice 列表的每个索引t choice[i]  # 取出 choice 列表中索引为 i 的元素choice.remove(t)  # 从 choice 列表中移除该元素selected.append(t)  # 将该元素添加到 selected 列表中perm(choice, selected)  # 递归调用 perm 函数传入修改后的 choice 和 selected 列表choice.insert(i, t)  # 在 choice 列表的索引 i 处插入元素 t恢复原样selected.pop()  # 从 selected 列表中移除最后一个元素恢复原样# 例如调用 perm([a, b, c]) 将打印:# abc# acb# bac# bca# cab# cba 具体分析如下 初始调用 first [1, 2, 3] perm(first, selected[]) 第一层递归 选择 1 choice [2, 3] selected [1] perm([2, 3], [1]) 选择 2 choice [1, 3] selected [2] perm([1, 3], [2]) 选择 3 choice [1, 2] selected [3] perm([1, 2], [3]) 第二层递归 选择 1 后 choice [3] selected [1, 2] perm([3], [1, 2]) 输出 123 choice [2] selected [1, 3] perm([2], [1, 3]) 输出 132 选择 2 后 choice [3] selected [2, 1] perm([3], [2, 1]) 输出 213 choice [1] selected [2, 3] perm([1], [2, 3]) 输出 231 选择 3 后 choice [2] selected [3, 1] perm([2], [3, 1]) 输出 312 choice [1] selected [3, 2] perm([1], [3, 2]) 输出 321 总结输出 最终这段代码将会输出所有 [1, 2, 3] 的排列 123 132 213 231 312 321 所以第四行输出231 -在Python中函数是对象可以像其他数据对象一样使用。下面程序的输出是 def func1():print(11,end )def func2():print(22,end )def func3():print(33,end )funclist[func1,func2,func3]for func in funclist:func() 分析 def func1():print(11, end )  # 定义函数 func1打印 11输出后不换行而是输出一个空格def func2():print(22, end )  # 定义函数 func2打印 22输出后不换行而是输出一个空格def func3():print(33, end )  # 定义函数 func3打印 33输出后不换行而是输出一个空格funclist [func1, func2, func3]  # 创建一个函数列表 funclist包含 func1, func2 和 func3for func in funclist:  # 遍历 funclist 列表中的每个函数func()  # 调用当前函数 使用 for 循环遍历 funclist 列表中的每个函数并调用它们。 - 第一次循环时func 是 func1所以调用 func1()输出 11 。 - 第二次循环时func 是 func2所以调用 func2()输出 22 。 - 第三次循环时func 是 func3所以调用 func3()输出 33 。 最终代码的输出结果是 11 22 33 每个函数的输出在一行上连续打印出来因为我们使用了 end 参数来防止打印后的换行。这展示了如何将函数视作一等公民first-class citizens即它们可以被赋值给变量、存储在数据结构中并在需要时调用。 -下面程序的输出是 f lambda p:p5t lambda p:p*3x7xf(x)xt(x)xf(x)print(x) 分析 f lambda p: p 5  # 定义一个 lambda 函数 f它接受一个参数 p并返回 p 5t lambda p: p * 3  # 定义另一个 lambda 函数 t它接受一个参数 p并返回 p * 3x 7  # 定义一个变量 x初始值为 7x f(x)  # 调用函数 f将 x 的值7加 5结果是 12x 变为 12x t(x)  # 调用函数 t将 x 的值12乘以 3结果是 36x 变为 36x f(x)  # 再次调用函数 f将 x 的值36加 5结果是 41x 变为 41print(x)  # 打印 x 的最终值输出 41 总结每一步的变化
• 初始值x 7
• 第一次调用 f(x) 后x 12
• 第二次调用 t(x) 后x 36
• 第三次调用 f(x) 后x 41 最终输出结果是 41 -下面程序的输出是 def factorial(n):match n:case 0 | 1:return 1case _:return n * factorial(n - 1)print(factorial(5)) 分析 def factorial(n):match n:  # 使用 match 语句对 n 进行模式匹配case 0 | 1:  # 如果 n 是 0 或 1return 1  # 返回 1这是阶乘的基例case _:  # 对于所有其他情况return n * factorial(n - 1)  # 返回 n 乘以 factorial(n - 1) 的结果这是阶乘的递归定义print(factorial(5))  # 调用 factorial(5)计算 5 的阶乘并打印结果 这段代码使用 引入的 match 语句来实现一个递归的阶乘函数。 逐步解析最后一行这个调用的执行过程 - factorial(5) 触发 case _返回 5 * factorial(4) - factorial(4) 触发 case _返回 4 * factorial(3) - factorial(3) 触发 case _返回 3 * factorial(2) - factorial(2) 触发 case _返回 2 * factorial(1) - factorial(1) 触发 case 0 | 1返回 1 通过递归调用我们得到 - factorial(2) 2 * 1 2 - factorial(3) 3 * 2 6 - factorial(4) 4 * 6 24 - factorial(5) 5 * 24 120 最终代码的输出结果是 120 -下列程序运行结果是 l[1]def scope1():l.append(6)   print(*l)scope1() 分析 这段代码定义了一个列表 l 和一个函数 scope1()然后调用了这个函数。逐行解析这段代码的作用及其输出结果如下。 l [1]  # 定义一个列表 l初始值为 [1]def scope1():l.append(6)  # 向列表 l 中添加一个元素 6print(*l)  # 使用 * 运算符解包列表 l 的元素并将其传递给 print 函数打印列表中的所有元素中间用空格分隔scope1()  # 调用 scope1 函数执行上述操作 最终输出结果是 16 在这段代码中由于列表 l 是在全局作用域中定义的函数 scope1 可以直接访问和修改全局变量 l。即 Python 中列表作为可变对象的特性 -下面程序运行结果是 a10def func():global aa20print(a,end )func()print(a) 分析 这段代码演示了如何在 Python 中使用 global 关键字来修改全局变量。让我们逐行解析代码的作用及其输出结果。 a 10  # 定义一个全局变量 a初始值为 10def func():global a  # 声明 a 是一个全局变量a 20  # 将全局变量 a 的值修改为 20print(a, end )  # 打印 a 的值20输出后不换行而是输出一个空格func()  # 调用 func 函数打印 20光标停在同一行print(a)  # 打印全局变量 a 的值此时 a 的值为 20 代码的执行过程如下

1. 定义全局变量 a 并赋值为 10。
2. 定义函数 func在函数内部使用 global 关键字声明并修改全局变量 a 的值为 20然后打印 20。
3. 调用函数 func打印出 20。
4. 在函数调用之后再次打印全局变量 a 的值此时 a 的值为 20。 最终输出结果是 20 20 这段代码展示了如何在 Python 中使用 global 关键字来修改和访问全局变量。 -下面程序的运行结果是 b, c2, 4def g_func(d):global aad*cg_func(b)print(a) 分析 b, c 2, 4  # 定义两个全局变量 b 和 c分别赋值为 2 和 4def g_func(d):global a  # 声明 a 是一个全局变量a d * c  # 计算 d 和全局变量 c 的乘积并将结果赋值给全局变量 ag_func(b)  # 调用 g_func 函数传入 b 的值即 2。因此函数内执行 a 2 * 4a 被赋值为 8print(a)  # 打印全局变量 a 的值输出 8 -下面程序的运行结果是 import mathdef factors(x):yint(math.sqrt(x))for i in range(2,y1):if (x%i 0):factors(x//i)breakelse:print(x,end )returnfactors(38) 分析 这是一个找质因数能整除给定正整数的质数的程序 import math  # 导入数学库以便后面可以使用其中的数学函数def factors(x):  # 定义一个名为factors的函数它接受一个参数x表示要找质因数的数y int(math.sqrt(x))  # 计算x的平方根并转换为整数因为质因数不会超过其平方根for i in range(2, y 1):  # 从2开始遍历到y1包括y这个范围内的数都有可能是x的质因数if x % i 0:  # 如果x可以被i整除说明i是x的一个质因数factors(x // i)  # 递归调用factors函数找出x // i的质因数break  # 找到一个质因数就可以停止了使用break退出循环else:  # 如果x不能被当前的i整除说明i不是x的质因数print(x, end )  # 直接打印出xend 是为了让打印出的数横向排列而不是换行return  # 返回结束函数# 调用函数factors传入参数38factors(38)#输出19 -下列程序运行结果是什么 def ins_sort_rec(seq, i):if i 0: returnins_sort_rec(seq, i - 1)j iwhile j 0 and seq[j - 1] seq[j]:seq[j - 1], seq[j] seq[j], seq[j - 1]j - 1seq [3,-6,79,45,8,12,6,8]ins_sort_rec(seq, len(seq)-1)print(seq[5]) 分析这是一段对列表序列排序的代码 def ins_sort_rec(seq, i): # 定义递归插入排序函数参数为待排序序列seq和当前索引iif i 0: return # 基本情况如果索引i为0返回递归结束条件ins_sort_rec(seq, i - 1) # 递归调用自身将当前索引减1j i # 初始化j为当前索引iwhile j 0 and seq[j - 1] seq[j]: # 循环条件j大于0且前一个元素大于当前元素seq[j - 1], seq[j] seq[j], seq[j - 1] # 交换前一个元素和当前元素j - 1 # 将j减1继续向前比较并交换seq [3, -6, 79, 45, 8, 12, 6, 8] # 定义待排序的序列ins_sort_rec(seq, len(seq) - 1) # 调用递归插入排序函数对序列进行排序初始索引为最后一个元素的索引print(seq[5]) # 输出排序后序列的第6个元素#排完序seq[-6, 3, 6, 8, 8, 12, 45, 79]所以第六个是12 -下面程序的运行结果是 def basic_lis(seq):l[1]*len(seq)for cur ,val in enumerate(seq):           #enumerate返回元素的索引和值for pre in range(cur):if seq[pre]val:l[cur]max(l[cur],1l[pre])return max(l)L[49, 64, 17, 100, 86, 66, 78, 68, 87, 96, 19, 99, 35]print(basic_lis(L)) 分析 def basic_lis(seq):l [1] * len(seq) # 初始化一个长度为seq的列表l每个元素初始值为1表示每个元素的最长递增子序列长度至少为1for cur, val in enumerate(seq): # 枚举seq中的元素及其索引for pre in range(cur): # 对当前元素之前的每个元素进行检查if seq[pre] val: # 如果前一个元素小于当前元素l[cur] max(l[cur], 1 l[pre]) # 更新l[cur]为当前最大值表示包括当前元素在内的最长递增子序列长度return max(l) # 返回列表l中的最大值即最长递增子序列的长度L [49, 64, 17, 100, 86, 66, 78, 68, 87, 96, 19, 99, 35] # 定义一个待处理的序列print(basic_lis(L)) # 调用basiclis函数并输出其结果 核心重点在下面这段代码的理解 for cur, val in enumerate(seq):for pre in range(cur):if seq[pre] val:l[cur] max(l[cur], 1 l[pre]) 外层循环枚举 seq 中的每个元素及其索引。内层循环遍历当前元素之前的所有元素检查是否存在递增关系即 seq[pre] val。 如果存在递增关系则更新 l[cur] 的值为 l[cur] 和 1 l[pre] 中的较大值。这意味着如果当前元素 val 能接在前面的递增子序列后面则更新当前元素的最长递增子序列长度。 对于给定的序列 L [49, 64, 17, 100, 86, 66, 78, 68, 87, 96, 19, 99, 35]它的最长递增子序列是 [49, 64, 66, 68, 87, 96, 99]其长度为7。 -下面程序是冒泡排序的实现,请填空(答案中不要有空格) def bubble(List):for j in range(_____,0,-1):for i in range(0,j):if List[i]List[i1]:List[i],List[i1]List[i1],List[i]return Listtestlist [49, 38, 65, 97, 76, 13, 27, 49]print( bubble(testlist)) 分析由于range是左闭右开而索引从0开始所以最后一个元素索引是lenList-1 def bubble(List):for j in range(len(List) - 1, 0, -1): # 外层循环从列表长度减1到1for i in range(0, j): # 内层循环从列表开头到jif List[i] List[i 1]: # 如果当前元素大于下一个元素List[i], List[i 1] List[i 1], List[i] # 交换这两个元素return Listtestlist [49, 38, 65, 97, 76, 13, 27, 49]print(bubble(testlist)) # 输出排序后的列表 -下面程序是选择排序的实现,请填空(答案中不要有空格) def selSort(nums):n len(nums)for bottom in range(n-1):mi bottomfor i in range(_____, n):if nums[i] nums[mi]:mi inums[bottom], nums[mi] nums[mi], nums[bottom]return numsnumbers [49, 38, 65, 97, 76, 13, 27, 49]print(selSort(numbers)) 分析 在选择排序算法中需要在未排序部分寻找最小值并将其与当前循环位置的元素交换。 因此内层循环的起始位置应该是 bottom 1或者bottom。 def selSort(nums):n len(nums) # 计算列表的长度for bottom in range(n - 1): # 外层循环遍历列表的每一个元素除了最后一个mi bottom # 假设当前索引bottom是最小值的索引for i in range(bottom 1, n): # 内层循环从bottom 1或者bottom开始遍历剩余未排序的部分if nums[i] nums[mi]: # 如果找到一个更小的元素mi i # 更新最小值的索引为inums[bottom], nums[mi] nums[mi], nums[bottom] # 交换当前元素和找到的最小元素return nums # 返回排序后的列表numbers [49, 38, 65, 97, 76, 13, 27, 49]print(selSort(numbers)) # 输出排序后的列表 第七章  文件和异常题目分析 一、判断题 1. 以w模式打开的文件无法进行读操作。    - 正确。以 w 模式写入模式打开文件时只允许写操作不能进行读操作。如果尝试读操作会引发错误。 2. Pandas库是用于图像处理的库。    - 错误。Pandas库主要用于数据处理和分析不是用于图像处理的。图像处理通常使用Pillow或OpenCV等库。 3. read函数返回的是列表。    - 错误。read函数读取文件的全部内容并以字符串形式返回而不是列表。 4. readlines函数返回的是列表。    - 正确。readlines函数读取文件的所有行并以列表形式返回每行作为列表中的一个元素。 5. DataFrame是Pandas模块的一种数据类型。    - 正确。DataFrame是Pandas库中用于表示二维数据表的主要数据结构。 6. Json数据格式只能用于Javascript语言。    - 错误。JSONJavaScript Object Notation是一种轻量级的数据交换格式不仅限于JavaScript语言广泛应用于多种编程语言中。 7. close函数用于文件关闭。    - 正确。close函数用于关闭文件对象释放与文件相关的资源。 8. Plotly模块可以画柱状图。    - 正确。Plotly模块功能强大可以用于绘制多种图表包括柱状图。 9. sys.stdin表示标准输入。    - 正确。sys.stdin是Python中表示标准输入流的对象通常用于从控制台读取输入。 10. 第三方模块要先安装才能使用。     - 正确。第三方模块通常不包含在Python的标准库中需要通过pip或其他包管理工具先安装才能使用。 11.  import plotly.graph_objects as gofig go.Figure(data[go.Table(headerdict(values[A Scores, B Scores]),cellsdict(values[[100, 90, 80, 90], [95, 85, 75, 95]]))])     fig.show() 上面程序的输出是下图。 - 正确。这段代码使用Plotly库绘制了一个表格表格头是 A Scores 和 B Scores对应的值是两个列表。输出确实是一个表格。 代码分析 导入模块 import plotly.graph_objects as go: 导入Plotly中的graph_objects模块并命名为go。 创建Figure对象 fig go.Figure(…): 创建一个Figure对象表示一个可视化图表。 添加数据 data[go.Table(…)]: 添加一个Table表格对象到Figure中。headerdict(values[A Scores, B Scores]): 定义表格的头部包含两列列标题分别是 A Scores 和 B Scores。cellsdict(values[[100, 90, 80, 90], [95, 85, 75, 95]]): 定义表格的单元格内容。第一个列表 [100, 90, 80, 90] 是 A Scores 列的分数第二个列表 [95, 85, 75, 95] 是 B Scores 列的分数。 显示图表 fig.show(): 显示创建的图表。 12. 表达式 ³⁄₀ 会引发“ValueError”异常。     - 错误。表达式 ³⁄₀ 会引发 ZeroDivisionError 异常而不是 ValueError。 13. 带有else子句的异常处理结构如果不发生异常则执行else子句中的代码。     - 正确。在异常处理结构中else子句只有在没有发生异常时才会执行。 14. 在异常处理结构中不论是否发生异常finally子句中的代码总是会执行的。     - 正确。finally子句中的代码无论是否发生异常总是会执行常用于清理资源。 二、单选题 1.下面程序的输出是什么 try:xfloat(abc123)print(The conversion is completed) except IOError:print(This code caused an IOError) except ValueError:print(This code caused an ValueError) except:print(An error happened) A.The conversion is completed B.This code caused an IOError C.An error happened D.This code caused an ValueError 代码分析 try: # 开始一个尝试块用于尝试执行可能引发错误的代码xfloat(abc123) # 尝试将字符串 abc123 转换为浮点数这会引发 ValueError因为 abc123 不是一个有效的数字print(The conversion is completed) # 如果转换成功执行该行代码 except IOError: # 开始一个异常处理块用于捕捉 IOError这种错误通常与输入/输出操作有关print(This code caused an IOError) # 如果发生了 IOError执行该行代码 except ValueError: # 开始另一个异常处理块用于捕捉 ValueError这种错误通常发生在某些操作或函数接收到不合适的值print(This code caused an ValueError) # 因为尝试转换一个非数字字符串abc123为浮点数这行代码块将被执行 except: # 这是一个通用异常处理块它会捕捉所有类型的错误print(An error happened) # 如果有任何类型的错误发生这行代码会执行 这段Python代码展示了异常处理的基本结构并且Python中的异常处理是按照从上到下的顺序进行的。 在执行这段代码时因为 abc123 不能被转换为浮点数所以会发生 ValueError因此 except ValueError: 块会被触发执行打印 This code caused an ValueError,即选项D。 2.下面程序输入是1时输出是什么 def func(a):if a0:raise ValueErrorelif a1:raise ZeroDivisionErroriint(input()) try:func(i)print(ok) except Exception as e:print(type(e))A.ok B.class ZeroDivisionError Cclass ValueError D.以上都不是 代码分析这段代码演示了如何使用异常处理机制捕获并处理不同类型的异常。 def func(a): # 定义一个名为 func 的函数参数为 aif a 0: # 判断 a 是否等于 0raise ValueError # 如果 a 等于 0抛出 ValueError 异常elif a 1: # 判断 a 是否等于 1raise ZeroDivisionError # 如果 a 等于 1抛出 ZeroDivisionError 异常i int(input()) # 从标准输入读取一个整数并赋值给变量 i try: # 尝试执行以下代码块func(i) # 调用 func 函数传入参数 iprint(ok) # 如果 func 没有抛出异常打印 ok except Exception as e: # 捕获所有继承自 Exception 的异常并将异常实例赋值给变量 eprint(type(e)) # 打印异常的类型由于输入是1代码运行过程如下 i int(input()) # 输入1i 的值为1try:func(i) # 调用 func(1)进入 func 函数# 进入 func 函数# a 1因此抛出 ZeroDivisionError 异常 except Exception as e:print(type(e)) # 捕获到 ZeroDivisionError打印 class ZeroDivisionError所以输出class ZeroDivisionError即选项B 三、填空题 1.Python内置函数______ 用来打开文件。 open  open函数用法open(file, moder, buffering-1, encodingNone, errorsNone, newlineNone, closefdTrue, openerNone)参数 file要打开的文件的名称或路径。mode文件打开模式如只读 ®、写入 (w)、追加 (a)、二进制模式 (b) 等。buffering、encoding、errors、newline 等参数用于控制文件的读取和写入方式。返回值文件对象可以对其进行读写操作。例如 # 打开一个文件进行读取 with open(example.txt, r) as file:content file.read()print(content)2.Python内置函数open 用__打开文件表示写模式。 w 文件打开模式 r只读模式默认。w写模式。如果文件存在会先清空文件内容。如果文件不存在会创建新文件。a追加模式。如果文件存在写入的数据会追加到文件末尾。b二进制模式。t文本模式默认。x排他性创建模式。如果文件已存在会引发 FileExistsError。读写模式。例如 # 打开一个文件进行写入 with open(example.txt, w) as file:file.write(Hello, World!)3.Pandas模块用_函数打开Excel文件。 read_excel Pandas read_excel 函数 用法pd.read_excel(io, sheet_name0, header0, namesNone, index_colNone, usecolsNone, … )参数 io文件路径、URL、文件类对象等。sheet_name要读取的工作表的名称或索引默认读取第一个工作表。其他参数用于控制读取的数据格式和细节。例如import pandas as pd# 从 Excel 文件中读取数据 df pd.read_excel(example.xlsx, sheet_nameSheet1) print(df.head())4.Pandas模块用函数____把数据写入CSV文件。 to_csv Pandas to_csv 函数 用法DataFrame.to_csv(path_or_bufNone, sep,, na_rep, float_formatNone, … )参数 path_or_buf文件路径或对象。sep字段分隔符默认为逗号。其他参数用于控制输出格式和细节。例如 import pandas as pd# 创建示例 DataFrame df pd.DataFrame({Name: [Alice, Bob, Charlie],Age: [25, 30, 35] })# 将 DataFrame 写入 CSV 文件 df.to_csv(example.csv, indexFalse)5.Plotly用参数____把数据存为HTML文件。 write_html Plotly write_html 参数 用法figure.write_html(file, auto_openFalse, … )参数 file文件路径或对象。auto_open是否在写入后自动打开生成的 HTML 文件。例如 import plotly.express as px# 创建示例图表 fig px.line(x[1, 2, 3], y[1, 4, 9], titleExample Plot)# 将图表保存为 HTML 文件 fig.write_html(example.html)6.下面程序的输出是字符串不要加引号 try:x float(abc123)print(数据类型转换完成) except IOError:print(This code caused an IOError) except ValueError:print(This code caused an ValueError) 与单选第一题是一样的   会输出This code caused an ValueError 即abc123 不是一个有效的浮点数表示所以 float(abc123) 会引发一个 ValueError 异常except ValueError: 块会被执行。 7.下面程序输入是 -3 时输出是__ def area®:assert r0,参数错误,半径小于0s3.14159*r*rreturn srfloat(input()) try:print(area®) except AssertionError as msg:print(msg) 会输出 参数错误,半径小于0 代码分析 def area®:assert r 0, 参数错误,半径小于0 # 断言 r 必须大于等于 0否则引发 AssertionErrors 3.14159 * r * r # 计算圆的面积return sr float(input()) # 从用户输入中读取半径值并转换为浮点数 try:print(area®) # 尝试计算并打印圆的面积 except AssertionError as msg:print(msg) # 如果发生 AssertionError打印错误信息输入-3时代码运行情况如下  r float(input()) 读取输入并将其转换为浮点数 -3.0。调用 print(area®): area(-3.0) 进入函数 area®断言 r 0 失败因为 r 为 -3.0。引发 AssertionError并附带错误消息 参数错误,半径小于0。异常被捕获到 except AssertionError as msg 块中并打印错误信息 msg。 未经允许 不得转载