四万字解析python二级(看完一遍过）

最新推荐文章于 2024-05-03 18:30:51 发布

森夏下士

最新推荐文章于 2024-05-03 18:30:51 发布

阅读量1.7k

点赞数 33

文章标签： python 算法开发语言

本文链接：https://blog.csdn.net/qq_72908017/article/details/136870975

版权

一、计算机二级Python考试分析及学习策略

分值分布与考试结构
- 计算机二级Python考试中，编程类科目包含40道选择题，占总分中的至少20分，这部分对于考试通过至关重要，若选择题得分不足20分，则即便编程题获得满分也无法通过考试。
- 编程题共60分，包括：
  - 基础操作部分：共计15分，每题5分，题目相对简单，已给出大部分代码，只需补充少量代码即可。
  - 简单应用部分：共25分，含一道10分的绘图题和一道15分的题目，此部分代码量稍多，难度略增，但仍属初级编程范畴。
  - 综合应用部分：难度较高，需要编写较多代码（约4-6行或更多），考察全面的编程能力。
时间分配建议
- 选择题部分：建议用时40分钟，平均1分钟/题。
- 操作题部分（基础操作和简单应用）：总共控制在40分钟内。
- 综合应用题：确保至少有40分钟，如有余力或对题目较为熟悉，可以适当延长时间至50分钟。
考试小技巧
- 开始考试后，可以先快速浏览编程题，若有较熟悉的题目或综合应用题思路清晰，可以选择先做编程题而非按顺序从选择题开始，灵活调整答题顺序。
学习策略
- 录播课与直播课结合学习：
  - 录播课为基础理论教学，类似数学中的公式推导和知识点梳理。
  - 直播课则是实战演练，基于录播课所学知识解决具体编程问题，两者相辅相成，缺一不可。
  - 学习时序上，应在观看直播课前确保已经预习完对应的录播课程内容。

二、Python编程入门：程序设计语言简介与Python语言特性

程序设计语言的发展历程

程序设计语言经历了机器语言、汇编语言到高级语言的发展阶段。
机器语言是计算机硬件可以直接识别和执行的二进制指令，对应于电路中的“通电”、“不通电”状态，即高低电位变化。
高级语言如Python、Java等更为人性化，便于程序员理解和编写。

编译型与解释型语言

编译型语言（例如C、Java）需要经过编译器将源代码转换为可执行文件，如同制作一台能够自动做特定菜肴的机器，一旦设计制造完成便不易改动。
解释型语言（如Python、JavaScript、PHP）则逐行解释执行源代码，如同按照菜谱一步一步做菜，灵活性更高，能够实时修改和测试代码。

Python语言特点

Python是由Guido van Rossum在20世纪90年代初创建，近年来随着数据分析、人工智能等领域的发展而越来越流行。
Python目前主要有3.x版本，其中3.x版本是主流且官方推荐使用的版本，旧版2.x不再被支持。
安装Python时务必勾选将Python添加到环境变量，以便于在命令行中直接运行Python程序。
推荐安装最新稳定版本的Python（例如3.8或更新版本），以获取最新特性和兼容性。
使用IDLE作为Python的主要集成开发环境（IDE），用于编写和运行Python代码。

Python编程的基本逻辑

编程的基本逻辑遵循“输入 -> 处理 -> 输出”的流程。
Python语言以其简洁易学、跨平台支持、丰富的生态系统（众多可用库）和良好的可读性而受到广大开发者喜爱。

IDLE使用简介

在IDLE中可以进行交互式编程，即时查看代码执行结果。
可以创建.py文件进行批量代码编写，通过F5或Run > Run Module运行整个程序文件。
Ctrl+N新建文件，Ctrl+S保存文件，Alt+3添加注释（井号#）忽略当前行代码执行

三、Python语言中的基本语法元素

在本节课中，我们将概览Python语言中的一些基本语法元素。虽然部分概念可能较为新颖，但不用担心，后续章节会有更为详尽的解释。现在只需要对这些概念有一个大致的认识即可。

1. 缩进

在Python中，通过缩进来表示程序各部分之间的逻辑关系和层级结构。通常推荐使用四个空格或一个制表符（Tab键）进行缩进，并保持统一，以确保代码的清晰性和正确性。

例如：

Python

if 1 + 1 > 2:
    print("What?")

上述代码中，print("What?") 与 if 语句通过缩进表示了从属关系。

2. 冒号

在Python中，特定的关键语句如条件判断、循环、函数定义等后面都需要加上冒号 (:) 表示语句的开始。

例如：

1if condition:
2    # ...
3for i in range(10):
4    # ...
5def my_function():
6    # ...

3. 错误处理

在编写代码过程中，难免会出现错误。Python的错误提示通常非常详细，比如语法错误（SyntaxError），可以通过错误信息找出问题所在并进行修复。例如，若出现“IndentationError: unexpected indent”，即表示缩进错误。

4. 注释

在Python中，使用井号 (#) 开头表示注释，无论是单行注释还是多行注释（连续使用多个井号）都不会被执行，仅用于程序员阅读和理解代码。

例如：

1# 这是一个单行注释
2'''
3这是
4一个多行
5注释
6'''

5. 续行符

为了使长行代码便于阅读，可以在一行末尾添加反斜杠 (\) 后回车，实现换行而不终止语句。

例如：

1print(123 \
2      + 456)

6. 标识符、变量与常量

标识符：用于命名变量、函数等，可包含字母、数字和下划线，但不能以数字开头，且不能与Python的保留字（关键字）相同。
变量：存储数据的容器，其值可以改变，遵循标识符的命名规则。
常量：在Python中没有严格意义上的常量，通常用变量表示不变的数据，只是约定俗成不修改其值。

7. 关键字与保留字

Python中有特定的关键字，这些词不能作为变量名使用。

序号	Python结构/关键词	描述
1	`None`	特殊常量，表示无值或空值，类型为`NoneType`
2	逻辑运算符	- `and`：两边表达式均为True时结果为True<br>- `or`：两边表达式任一为True时结果为True<br>- `not`：对表达式求反
3	条件语句	- `if`：满足条件时执行相应代码块<br>- `elif`：在if之后，用于多个条件判断<br>- `else`：当所有条件都不满足时执行
4	循环语句	- `for`：遍历序列或可迭代对象<br>- `while`：满足条件时重复执行
5	布尔值	- `True`：真<br>- `False`：假
6	循环控制	- `break`：退出当前循环<br>- `continue`：跳过本次循环剩余语句，进入下一轮
7	占位符	`pass`：不做任何操作，仅作占位或满足语法需求
8	异常处理	- `try`：尝试执行代码块，可能引发异常<br>- `except`：捕获并处理异常<br>- `finally`：无论是否出现异常都会执行的代码块<br>- `raise`：主动抛出异常<br>- `assert`：断言条件为真，否则触发异常
9	模块导入	- `import module_name`：导入整个模块<br>- `from module import *`：导入模块所有内容<br>- `from module import item as alias`：导入模块中的特定项并重命名
10	自定义函数	- `def function_name(...):`：定义函数<br>- `return`：函数内用于返回结果
11	类	`class ClassName:`：定义类
12	匿名函数	`lambda arguments: expression`：创建简短、一次性使用的函数
13	删除	`del variable`：删除变量、数据结构或其他对象
14	变量作用域声明	- `global`：声明全局变量<br>- `nonlocal`：声明外部嵌套作用域中的变量
15	条件测试	- `in`：检查值是否在序列中<br>- `is`：比较两个对象是否为同一对象（引用相同）
16	异步编程	- `async def`：定义异步函数<br>- `await expression`：在异步函数内部暂停执行，等待表达式的完成
17	上下文管理	`with context_manager:`：简化资源获取与释放，自动处理异常
18	生成器	- `yield`：在函数内部产生值，并保留状态，用于后续迭代

8. 数据类型

Python支持多种数据类型，如数字、字符串等。不同类型的数据适用于不同的应用场景，将在后续章节详细介绍。

9. 表达式与运算符

表达式是由数值、变量、运算符等组成的合法语句片段，能够计算出一个值。例如，"1+1" 就是一个简单的表达式。

10. 引用与导入模块

通过 import 语句可以引用外部模块或库，引入其中的功能到当前程序中使用，例如 import math 导入Python内置的数学模块。

11. 分支语句与循环语句

分支语句：如 if、elif 和 else 用于根据条件执行不同代码块。
循环语句：如 for 和 while 用于重复执行某段代码直至满足某种条件。

12. 输入与输出

input() 函数用于接收用户的输入。
eval() 函数可以将字符串当作Python表达式执行，但实际开发中较少使用，因其存在安全隐患。
print() 函数用于输出内容到控制台，可以输出字符串、数字等多种类型的数据，通过逗号 , 可以连接多个输出项并在它们之间添加空格。还可以通过设置 end 参数控制输出后是否换行，如 print("A", end="") 输出后不换行。

四、Python编程中的基本数据类型

（一）Python编程中的变量及其基本用法

在编程中，变量是一个至关重要的概念，它就像一个标签或容器，用于存储和引用各种数据。下面通过生活中的例子来帮助理解变量：

假设你是一位班级的学习委员，老师会给你每位同学每次考试的成绩单。为了方便管理和记录，你可以将每位同学的成绩存入一个“信封”（变量），并在信封上标注同学的名字。这样一来，当你需要查找或更新某个同学的成绩时，只需找到对应的信封（变量），取出或替换其中的成绩即可。即使成绩不断变化，只要更改相应的变量值，整个数据管理流程仍然有效。

变量的基本概念与赋值语句： 在Python中，变量是用来储存数据的一个名字，赋值语句则是将一个值绑定到变量上的过程。例如，x = 3 或者 lilei_score = 98，这里的等号不是数学意义上的相等，而是一个赋值动作，即将右边的值赋给左边的变量。因此，= 被称为赋值运算符。

赋值的过程： 赋值时，程序会先计算右边的表达式，然后将结果赋给左边的变量。例如，在 x = x + 10 中，首先获取变量 x 当前的值（假设为 1），然后计算 1 + 10 的结果，最终将结果 11 赋予 x，此时 x 的值变为 11。值得注意的是，此处的 x 在左右两边并不相同，左边的 x 是目标变量，右边的 x 是参与计算的原始值。

💡

变量命名规则：

变量名可以由字母（包括大小写）、数字和下划线组成，但不能以数字开头。

不要使用Python的保留字（关键字）作为变量名，可通过 help('keywords') 查看所有关键字。

变量名中不应包含空格，可用下划线 _ 替代空格以提高可读性。

避免使用Python内置函数名作为变量名。

进阶赋值方式： 可以同时给多个变量赋相同的值，例如 a, b, c = 100, 100, 100；也可以给多个变量分别赋不同的值，如 a, b, c = 1, 2, 3。

（二）Python基础数据类型介绍

在Python编程中，基础数据类型是构建程序的基础要素。以下是Python中最常见的七种基础数据类型：

整型 (int)：整数类型，用于表示没有小数部分的数值，如 a = 1。通过 type(a) 可以查看变量 a 的类型，输出为 <class 'int'>。
浮点型 (float)：浮点数类型，用于表示带有小数部分的数值，如 b = 2.0。类型输出为 <class 'float'>。
复数类型（未在原文提及，补充说明）：Python中还支持复数类型，如 c = 3+4j，类型输出为 <class 'complex'>。
字符串 (str)：由一系列字符组成的不可变序列，用单引号 ' ' 或双引号 " 括起来，如 s = "Hello World"。类型输出为 <class 'str'>。
列表 (list)：有序且可变的数据结构，用方括号 [ ] 包围，可以存放任意类型的数据，如 lst = [1, "two", 3.0]。类型输出为 <class 'list'>。
元组 (tuple)：有序且不可变的数据结构，用圆括号 ( ) 包围，同样可以存放任意类型的数据，如 tup = (1, "two", 3.0)。一旦创建，元组内的元素无法修改。
字典 (dict)：无序的键值对集合，用花括号 { } 包围，键必须是唯一的且不可变类型（如字符串、数字或元组），值可以是任意类型，如 dict = {"name": "Alice", "age": 25}。类型输出为 <class 'dict'>。
集合 (set)：无序且不重复元素的集合，用大括号 { } 创建，如 set_example = {1, 2, 2, 3, 3, 4}，输出结果自动去重为 {1, 2, 3, 4}。类型输出为 <class 'set'>。
布尔型 (bool)：表示真或假两种状态，只有 True 和 False 两种值，首字母大写，如 is_student = True。类型输出为 <class 'bool'>。

注意：在Python中并没有名为“数组”的基础数据类型，而是通过列表(list)来实现数组的功能。在其他一些编程语言中，数组通常要求所有元素具有相同的数据类型，而在Python列表中则可以包含任意类型的元素。

（三）Python中的数字类型及其运算

在Python编程中，数字类型主要包括整数类型（int）和浮点数类型（float）。除此之外，还包括复数类型（complex），不过在此主要讲解整数和浮点数。

整数类型（int）

表示方式：整数可以以十进制、二进制（前缀0b）、八进制（前缀0o）和十六进制（前缀0x）表示。
取值范围：理论上整数在Python中的取值范围是无穷大。

浮点数类型（float）

表示方式：通常用小数或科学计数法（如1.1, 1e-1）表示。
注意事项：浮点数的运算并非完全精确，因为计算机内部是以二进制表示浮点数，可能导致细微的误差。因此，直接比较两个浮点数是否相等时需谨慎，可采用四舍五入或检查两者之差的绝对值是否小于一个极小的阈值来判断。

数值运算操作符

基本运算：加（+）、减（-）、乘（*）、除（/）、整除（//）、取模（%）。
增强操作符：+=、-=、*=、/= 等，简化了更新变量值的操作。
特殊运算：
- abs(x)：返回 x 的绝对值。
- divmod(a, b)：返回 (a // b, a % b) 元组，即 (商, 余数)。
- pow(base, exponent[, modulo])：返回 base 的 exponent 次幂，可选参数 modulo 表示取模。
- round(number[, ndigits])：返回 number 四舍五入后的值，可指定保留的小数位数。
- max(*args) 和 min(*args)：返回一组数值中的最大值和最小值。

其他注意事项

数字类型混合运算：整数与浮点数混合运算时，结果通常是浮点数类型。
对于判断浮点数是否相等，应避免直接使用 == 进行比较，而可以采取四舍五入后比较或比较二者之差的绝对值是否小于一个很小的阈值。

（四）Python列表(List)的基本概念与操作详解

列表定义与特点

在Python中，列表（List）是一种复合数据结构，它可以容纳多个不同类型的元素，并且每个元素都有其对应的位置索引。列表是由一对方括号 [] 包围，各元素之间用英文半角逗号 , 分隔。

例如：

students_info = ["李雷", 95, "北京市", 16]

列表允许存储多种数据类型，比如字符串、数字等，并且可以对其进行修改。

访问与修改列表元素

访问列表元素：通过索引（indexing），索引从0开始计数（从前往后从0开始；从后往前从-1开始），如 students_info[0] 表示访问第一个元素。
修改列表元素：同样通过索引赋值，例如，若要更改“李雷”的名字为“马冬梅”，可写作 students_info[0] = "马冬梅"。

列表的属性和函数

长度获取

使用 len() 函数获取列表长度，如同字符串操作一样，例如：len(students_info)。

最小值与最大值

使用 min(list_name) 和 max(list_name) 获取列表中的最小和最大值。

类型转换

将其他数据类型转换为列表，例如将字符串 "Python" 转换为包含每个字符的列表：list("Python")。

列表操作方法

添加元素

使用 append() 方法向列表末尾添加一个元素，例如：L.append(5)。

合并列表

两个列表可以通过 + 运算符合并为一个新列表，例如：L3 = L1 + L2。

插入元素

使用 insert(index, value) 方法在指定位置插入元素，例如：L3.insert(3, 'a') 在索引为3的位置插入元素'a'。

清空列表

使用 clear() 方法清空列表内的所有元素：L1.clear()。

删除元素

pop() 方法用于移除并返回列表中指定位置（默认为最后一个）的元素，如无参数则删除并返回最后一个元素：a = L3.pop() 或 a = L3.pop(0)。
remove() 方法用于删除列表中首次出现的指定元素：L3.remove('a') 或 L3.remove(2)。
直接使用 del 语句删除列表中指定索引位置的元素：del L3[0]。

删除特定值的所有实例

注意，remove() 只删除第一次出现的指定值，如果要删除所有匹配的元素，则需要重复调用该方法或者使用其他方法实现。

反转列表

使用 reverse() 方法将列表元素顺序反转：L3.reverse()。

复制列表

使用 copy() 方法创建原列表的一个副本：L4 = L3.copy()。

列表的扩展操作

列表之间可以使用 + 进行连接，类似于加法操作。
利用乘法操作符 * 对列表进行重复拼接，如：[1, 2] * 3 得到 [1, 2, 1, 2, 1, 2]。

总结来说，Python列表提供了丰富的操作功能，使得它能够高效地处理一组相关数据。

（五）列表（List）基础教学与操作

列表的基本概念

定义：列表是一种组合型数据结构，在Python中用中括号[]包裹，可以存储多个不同类型的元素，如字符串、数字等，各元素间通过英文半角逗号,分隔。

# 示例列表
example_list = ["李雷", 95, "北京市", 18]

列表元素的访问与修改

索引：列表元素的位置从0开始计数，可以通过索引访问和修改元素。例如，访问列表中第一个元素：example_list[0]；修改第一个元素：example_list[0] = "马冬梅"。

列表操作函数与方法

获取长度：使用len()函数获取列表的长度，例如：len(example_list)返回列表中元素的个数。
查找最大值/最小值：可直接将列表传入max()或min()函数获得最大值或最小值。
类型转换：可以使用list()函数将其他可迭代对象（如字符串）转换为列表。

s = "Python"
list_s = list(s)  # 将字符串转换为列表
print(list_s)  # 输出：['P', 'y', 't', 'h', 'o', 'n']

列表方法：

添加元素：使用append()方法向列表末尾添加元素，例如：example_list.append("新元素")。
合并列表：可通过加号+连接两个列表以合并它们，如：L3 = L1 + L2，合并后L3包含L1和L2的所有元素。
插入元素：使用insert()方法在指定位置插入元素，例如：example_list.insert(3, "新插入的元素")。
清空列表：使用clear()方法清空列表内所有元素，如：example_list.clear()。
弹出元素：
- pop()方法默认删除并返回列表的最后一个元素，如：last_element = example_list.pop()。
- 指定索引位置删除元素：element = example_list.pop(0)会删除并返回指定位置的元素。
删除元素：
- remove()方法用于删除列表中首次出现的指定元素，如：example_list.remove("特定元素")。
- 使用del关键字直接删除指定索引的元素：del example_list[0]。
反转列表：使用reverse()方法翻转列表中元素的顺序，如：example_list.reverse()。
复制列表：使用copy()方法创建原列表的浅复制副本，如：L4 = L3.copy()。
列表运算：
- 列表相加合并列表。
- 列表与整数相乘，将会重复列表内容相应次数形成新列表，如：new_list = [1, 2] * 3会产生[1, 2, 1, 2, 1, 2]。

以上涵盖了列表的基础操作和特性，进一步的学习会涉及到更多高级操作，比如切片、排序等。

（六）字典数据类型详解

在Python中，字典是一种非常重要的组合型数据结构，它与列表相似，都可以存储多个数据项，但它们的主要区别在于组织和访问数据的方式。列表是有序的元素集合，而字典则是以键-值对形式存储的无序集合。

例如，在创建电话簿时，如果我们使用列表，查找某个人的电话号码需要通过索引或姓名在列表中的位置来间接获取。而在字典中，可以通过唯一的“键”（key）直接找到对应的“值”（value），使得查找过程更为直观且高效。字典的键就像是电话簿中的人名，值则代表电话号码。

在Python中，字典使用花括号 {} 包围，并通过逗号分隔各键值对，键和值之间用冒号 : 分隔。例如：

{
    "李雷": 1234,
    "韩梅梅": 3456,
    "马冬梅": 0123
}

字典的特性强调键的唯一性，类似于现实生活中身份证号对于每个人的身份识别作用，即每个键在字典中只能对应一个值，不能出现重复键。若试图用相同的键存储第二个值，则原有的键值对会被新的值替换。

另外，字典中的键必须是不可变类型的数据，如字符串、整数或其他不可变类型，而不能是可变类型如列表，因为可变类型的对象其内部状态可变，不符合哈希表（Hash Table）的内在要求，字典正是基于哈希表实现的，确保键能够快速定位到对应的值。

字典的基本操作包括：

访问：通过键查询值，例如great["李雷"]即可获取李雷对应的值。
添加/修改：直接对某个键赋值，若该键已存在，则原值会被新值覆盖；若不存在，则新增键值对。
删除：使用del关键字删除指定键值对，或者调用pop(key)方法移除并返回指定键对应的值；popitem()方法随机移除并返回一对键值。
判断存在性：使用in关键字判断某个键是否存在于字典中，如"小明" in great将返回True或False。
获取键、值或键值对集合：
- keys()方法返回包含所有键的视图；
- values()方法返回包含所有值的视图；
- items()方法返回包含所有键值对的视图，每个元素为一个元组。
get()方法：不仅用于查询值，还能设置默认值，如great.get("小明", "default_value")，若"小明"不存在，则返回默认值。
长度：通过len()函数获取字典中键值对的数量。
清除：调用clear()方法清空字典内所有数据，或使用del关键字删除整个字典变量。

此外，字典支持多种其他操作，比如转换键值对集合为列表、通过键获取值时提供默认值等。通过这些灵活的操作方式，字典成为处理关联数据、实现映射关系的理想选择。

（七）数字与字符串进阶知识点

数字类型：复数

复数是一种特殊的数字类型，在实际编程中虽然不常用，但仍需了解其基本概念和使用方法。复数由实部和虚部组成，虚部通常用 J 或者 I 表示，且 J（或 I）相当于数学中的根号负一。例如，复数 1+3J 和 2+4J 可以直接进行加减乘除运算。其中，加法运算是实部加实部，虚部加虚部；乘法运算则需要展开计算，如 (1+3J) * (2+4J) 的结果可以通过计算得出。

获取复数的实部和虚部，可通过.real和.imag属性，如：

z = 1 + 2J
z.real  # 输出: 1.0
z.imag  # 输出: 2.0

并且要注意，实部和虚部单独提取时，其数据类型均为浮点数。

字符串：切片操作

字符串切片类似于从一根“火腿肠”中选取一段。基本的切片语法是通过中括号包含起始和结束位置，并用冒号分隔，如s[3:6]表示从索引3开始（包含3），到索引6结束（不包含6），取出字符串s中的子串。

切片操作的几个要点：

省略起始位置默认为0，省略结束位置默认为字符串长度。
步长（步长默认为1，即连续取字符）可通过在冒号后添加第三个参数表示，如s[3:6:2]表示从索引3开始，每隔一个字符取一个，直到索引6前。
步长可以为负数，表示逆向取值，如s[::-1]将返回字符串s的反转。

字符串的不可变性：在Python中，字符串一旦创建就不能被修改。尝试直接修改字符串中的某个字符将会抛出错误。若要改变字符串内容，可以创建一个新的字符串，基于原字符串进行修改，例如：

1s = "Hello Python"
2s1 = "Hacker" + s[6:]  # 创建新字符串s1，将s的第一个字符替换并保留其余部分

在这个过程中，原字符串s不会发生任何变化，体现了字符串的不可变性。

（八）列表与字典的进阶知识点

列表切片及赋值

列表切片：列表的切片操作与字符串切片规则相同，通过中括号内的起始和结束位置以及可选的步长来选取列表中的子序列。例如，list[2:5]会取出索引为2到4（不包括5）的元素子列表。
- 正向切片：list[2:5]、list[1::2]（隔一个取一个）
- 反向切片：list[6:1:-1]（从第6个元素开始反向取到第1个）
列表切片赋值：列表允许通过切片进行赋值，从而实现部分元素的替换或插入删除操作。例如：

1L = [1, 2, 3, 4, 5, 6]
2L[2:] = ['A', 'B', 'C']  # 将索引2及以后的元素替换为['A', 'B', 'C']
3L[1:1] = [234]  # 在索引1处插入列表[234]
4L[:] = []  # 清空整个列表

字典创建与嵌套

字典创建：除了传统的键值对形式创建，也可以通过列表的元组形式一次性创建多个键值对。例如：

data = [('A', 12), ('B', 2)]
d = dict(data)

或者直接使用关键字参数创建：

li_lei = 98
han_meimei = 99
d = {'li_lei': 98, 'han_meimei': 99}

字典嵌套：字典和列表可以相互嵌套，形成复杂的结构，如班级信息可以用列表存储多个学生的字典，每个学生字典中可以包含多个信息项（如课程列表）。

class_info = [{'name': 'student1', 'courses': ['math', 'english']},
             {'name': 'student2', 'courses': ['science', 'history']}]

这样可以方便地通过键名访问嵌套字典中的值，例如获取student1的课程列表。

引用与复制

引用与赋值：在Python中，当我们将一个列表赋值给另一个变量时，实际上是创建了一个指向原列表的引用，而非新建一个列表。例如：

L1 = [1, 2, 3, 4]
L2 = L1
L2[0] = 5

在上述情况下，L1和L2都指向同一个列表，因此修改L2会影响到L1。

复制列表：为了避免引用带来的副作用，需要显式地复制列表以创建独立的新列表。可以使用copy()方法进行浅复制：

L2 = L1.copy()
L2[0] = 5

修改L2后，L1不再受影响。

注意：在Python中，浅复制仅针对列表本身的元素进行复制，如果列表中包含其他可变类型的元素（如子列表或字典），则子元素仍会被引用，而非复制。涉及深层次的复制时，需要使用深复制，这将在后续课程中讲解。

（九）元组与集合的基本概念

元组 (Tuple)

定义与特点

元组是另一种有序且不可变的数据结构，其使用圆括号 ( ) 包裹元素。
跟列表相似，但不同之处在于元组创建后无法修改其内容，类似于字符串。
元组可以通过切片和索引进行读取，但不能进行增加、删除或修改元素的操作。

应用场景

元组可以作为字典的键，因为它不可变，符合映射关系的要求。

特殊情况

元组内部如果有可变类型（如列表）的元素，则该元素本身是可以被修改的，即“隔山打牛”现象。例如：

t = (1, 2, [3, 4])
t[2][0] = 5

print(t)  # 输出：(1, 2, [5, 4])

集合 (Set)

定义与特点

集合是由花括号 { } 或 set() 函数创建的无序且唯一元素的数据结构。
集合中的元素不允许重复，即使在创建时传入了重复的元素，集合会自动去除重复项。

创建集合的方法

直接初始化：s = {1, 2, 3, 4, 5}
通过列表转集合：s = set([1, 2, 3, 4, 5, 5, 5]) 会得到一个元素唯一的集合 {1, 2, 3, 4, 5}

常见集合操作

交集 (Intersection)

交集代表两个集合共有的元素集合。
表示方法：set1 & set2 或 set.intersection(set1, set2)
示例：

set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7}
intersection = set1 & set2
print(intersection)  # 输出：{4, 5}

并集 (Union)

并集代表两个集合所有元素合并后的集合，不重复。
表示方法：set1 | set2 或 set.union(set1, set2)
示例：

union = set1 | set2
print(union)  # 输出：{1, 2, 3, 4, 5, 6, 7}

差集 (Difference)

差集代表第一个集合中有而第二个集合中没有的元素集合。
表示方法：set1 - set2
示例：

difference_set1 = set1 - set2
print(difference_set1)  # 输出：{1, 2, 3}

对称差集 (Symmetric Difference)

对称差集代表两个集合中各自独有的元素组成的集合，即不同时属于两个集合的元素集合。
表示方法：set1 ^ set2 或 set.symmetric_difference(set1, set2)
示例：

symmetric_difference = set1 ^ set2
print(symmetric_difference)  # 输出：{1, 2, 3, 6, 7}

实现对称差集的替代方法

可以通过并集和交集的差集计算得到对称差集：（A|B）-（A|B）

1symmetric_difference_alternative = (set1 | set2) - (set1 & set2)
2assert symmetric_difference == symmetric_difference_alternative

总结：本节介绍了元组和集合的基础知识，元组作为不可变容器，适用于需要固定不变数据的情况；集合则是用于处理唯一元素集合的高效工具，并提供了多种集合运算功能。

五、程序的控制结构

（一）布尔表达式与逻辑运算符

布尔表达式是编程中的基本概念，主要用于判断条件是否成立。在Python中，布尔值有两种：True 和 False，分别代表真和假。它们通常用于条件测试和循环控制中。

布尔值与条件判断

在Python中，使用 == 进行相等性判断，而不是单个等号 =，后者是赋值操作。
示例：

dog = '小黄'
dog == '小黄'  # 返回 True，因为dog确实等于'小黄'

数字和字符串都可以进行条件比较，例如：

10 > 4  # 返回 True，因为10大于4
'Hello' in 'Hello world'  # 返回 True，因为在字符串'Hello world'中找到了'Hello'

逻辑运算符

AND (`and`)

当两个条件（或更多）都需要同时满足时，使用 and 连接这些条件。
示例：

1age_lei >= 18 and age_hanmeimei >= 18

如果李雷和韩梅梅的年龄都大于等于18岁，则表达式返回 True；否则返回 False。

OR (`or`)

当至少满足其中一个条件时，使用 or 连接这些条件。
示例：

age_lei >= 18 or age_hanmeimei >= 18

如果李雷或韩梅梅的年龄至少有一个大于等于18岁，则表达式返回 True；若两者都不满足条件，则返回 False。

NOT (`not`)

not 是用来反转一个布尔值的运算符。
示例：

not (10 > 20)  # 返回 True，因为原条件为 False，反转后为 True

示例应用

假设 age_lei = 18 和 age_hanmeimei = 15：
- age_lei >= 18 and age_hanmeimei >= 18 返回 False，因为韩梅梅的年龄未达到18岁。
- age_lei >= 15 and age_hanmeimei >= 15 返回 True，因为两个人的年龄都大于等于15岁。
- age_lei >= 18 or age_hanmeimei >= 18 返回 True，因为李雷的年龄满足条件。

综述

布尔表达式和逻辑运算符在编程中极其重要，不仅用于单一条件的判断，还能处理复杂的逻辑组合。建议同学们通过实践编写代码，熟悉各种逻辑组合的结果，比如尝试写出并运行以下表达式的值：

True and True
True and False
True or False
not True

（二）条件判断与if-else语句

在Python编程中，条件判断和if-else结构是非常基础且重要的概念，用于实现程序的分支逻辑。在深入讲解if-else之前，首先回顾Python代码的缩进规则：

Python代码缩进

在Python中，代码的缩进是用来区分代码块的层次结构。通常使用4个空格或1个制表符作为缩进单位，关键在于保持统一。在同一缩进层级的代码行被视为同一代码块，而在其后缩进的代码行则视为该代码块的内部部分。

China
  Tsinghua University
    Li Lei
    Han Meimei
  Peking University
    Li Lei
    Ma Dongmei

上述例子展示了缩进如何表示代码的层级关系，就如同现实世界中的所属关系一样。

接下来，我们进入条件判断的主题——if-elif-else结构。在实际生活中，我们会根据不同的条件做出相应的决策，同样，在编程中我们也需要类似的逻辑判断机制。

如果(条件A) {
  执行操作A
} 否则如果(条件B) {
  执行操作B
} 否则 {
  执行操作C
}

在Python中，上述逻辑可以用以下语法表示：

if condition_A:
  # 条件A满足时执行的操作
elif condition_B:
  # 条件A不满足且条件B满足时执行的操作
else:
  # 条件A和条件B都不满足时执行的操作

举例说明，考虑一个判断用户输入性别并输出相应信息的程序：

gender = input("请输入您的性别（F/M）：")
if gender == 'F':
  print("你是一个萌妹子")
elif gender == 'M':
   print("你是一个汉子")
else:
  print("抱歉，您输入的内容不正确，请输入F或M")

在这段代码中，我们首先获取用户输入的性别，然后通过if-elif-else结构进行判断。如果输入是"F"，则输出“你是一个萌妹子”，如果输入是"M"，则输出“你是一个汉子”。其他任何输入都将导致输出“抱歉，您输入的内容不正确，请输入F或M”。

需要注意的是，在Python中使用两个等号（==）进行比较判断，而一个等号（=）则是赋值操作。此外，elif 是 else if 的简写形式，在Python中用于连接多个条件判断。

总结：条件判断（if-else）是实现程序分支逻辑的关键手段，通过它可以针对不同条件执行不同操作。在设计程序时，要充分利用缩进来构建清晰的层级结构，并确保每个条件及其对应的操作块正确匹配。鼓励同学们亲自实践编写并调试相关代码，从而更好地理解和掌握条件判断的应用。

（三）while循环的理解与应用

while循环基本概念

while循环是一种重复执行某段代码直到指定条件不再满足的结构。其基本格式如下：

while condition:
    # 这里是循环体内的代码
    ...

while循环的工作原理是首先检查条件（condition），如果条件为真（True），则执行循环体内的代码；循环结束后，再次检查条件，若依然为真，则继续执行循环体，直至条件变为假（False）时跳出循环。

例如：

i = 1
while i < 10:
    print(i)
    i += 1

此代码会输出1至9，因为当i达到10时，条件i < 10不再满足，循环终止。

用户输入验证与while循环

在处理用户输入时，可以利用while循环来确保用户输入的有效性，直到输入符合预期条件为止。例如，要求用户输入"F"或"M"表示性别，可以设置一个标志变量来跟踪用户是否已输入正确，并在循环体内进行修正，直到输入正确为止。

user_answer_correct = False
while not user_answer_correct:
    user_input = input("请输入您的性别（F/M）：")
    # 对user_input进行验证，并在满足条件时设置user_answer_correct为True

循环控制语句：break和continue

break：在循环体内遇到break语句时，不论循环条件是否满足，都会立即跳出整个循环。

示例：

i = 1
while i < 10:
    if i == 5:
        break
    print(i)
    i += 1

此代码在i等于5时停止循环，不会输出5之后的数字。

continue：在循环体内遇到continue语句时，会跳过当前循环迭代中余下的语句，直接开始下一次循环。

示例：

i = 1
while i < 10:
    if i == 5:
        continue
    print(i)
    i += 1

此代码在i等于5时不执行打印操作，而是直接进入下一轮循环，因此不会输出数字5。

while循环的else子句

while循环可以包含一个可选的else子句，当循环因条件不再满足而自然结束（而非break语句跳出）时，会执行else子句中的代码。

i = 1
while i < 10:
    print(i)
    i += 1
else:
    print("正常结束")

上述代码会在循环结束后输出“正常结束”。

总结：while循环是Python中实现重复执行特定任务的重要结构，结合break、continue以及else子句，可以根据不同需求灵活控制循环流程。在实践中务必注意避免造成无限循环（死循环），并在必要时合理运用break和continue语句以优化循环逻辑。

（四）for循环的理解与应用

for循环的基本概念

for循环是一种遍历序列（如列表、元组、字符串或range对象等）并针对其中每个元素执行相应操作的循环结构。其基本格式如下：

for element in sequence:
    # 在这里编写针对element的操作
    ...

例如，对于一个学生列表 student_list = ['李雷', '韩梅梅', '马冬梅']，可以使用for循环遍历并打印出学生名字：

student_list = ['李雷', '韩梅梅', '马冬梅']
for student in student_list:
    print(student)

循环会按照列表中的顺序，依次将'李雷'、'韩梅梅'和'马冬梅'赋值给变量student，并在每次循环迭代中执行print语句。

使用range()函数进行数字循环

range()函数可以生成一系列连续的整数，常用于需要循环遍历数字序列的情况。有两种常见形式：

单参数形式：range(stop)，生成从0开始到stop-1的整数序列。

for i in range(10):
    print(i)

此代码将输出0到9之间的数字。

三参数形式：range(start, stop, step)，生成从start开始到stop-1之前（不包括stop），以step为步长的整数序列。

for i in range(0, 10, 2):  # 输出 0, 2, 4, 6, 8
    print(i)

for循环遍历非零起点的数字序列

通过指定range()函数的起始值，可以遍历任意非零起点的整数序列，例如生成某个时间段内的年份：

for year in range(2010, 2021):
    print(year)

此代码将输出2010年至2020年的所有年份。

for循环与else子句

for循环同样支持一个可选的else子句，该子句在循环正常结束（即未遇到break语句）时执行：

for year in range(2010, 2021):
    if year == 2015:
        break
else:
    print("正常结束")

在此示例中，当循环遍历到2015年时，会遇到break语句并提前结束循环，所以else子句不会被执行。如果去掉break语句，则在循环遍历完所有年份后，会输出“正常结束”。

总结：for循环在Python中广泛应用于遍历各种有序数据结构，结合range()函数可以轻松处理数字序列。for循环的else子句提供了在循环正常结束时执行额外逻辑的功能，进一步增强了循环结构的灵活性。通过实践和练习，熟练掌握for循环的各种应用场景有助于提升编程效率。

（五）异常处理在Python程序中的运用

在Python编程中，异常处理是应对程序运行过程中可能出现的错误的关键机制，它允许程序在遭遇问题时不立即终止，而是采取特定的恢复或反馈措施。以下是关于异常处理的基本结构和用法的说明：

基础异常处理：try-except

try-except块用于捕获并处理可能发生的异常。基本语法如下：

try:
    # 尝试执行可能会引发异常的代码
    age = int(input("请输入年龄："))
except ValueError:
    # 如果在try块内引发了ValueError异常（例如，尝试将非数字字符串转换为int）
    print("输入有误，您并未输入有效的数字年龄！")
# 可选部分：except 后可以跟具体的异常类型
except ZeroDivisionError:
    # 如果发生除以零的错误
    print("发生了除零错误！")
# 可选部分：else 子句会在try块内的代码没有引发任何异常时执行
else:
    print("您的输入正确，年龄为：", age)
# finally 子句无论是否发生异常，都会被执行
finally:
    print("感谢您的输入，程序已结束处理。")

当在try块内执行代码时，若无异常发生，则程序将跳过except子句并执行else（如果存在）和finally子句。
若try块内的代码触发了异常，程序会立刻停止try块内剩余代码的执行，并寻找匹配的except子句来处理异常。如果找到匹配的except子句，则执行相应的异常处理代码；否则，异常将沿着调用栈向上抛出，直到被捕获或导致程序终止。
finally子句总是会被执行，不论try块内是否有异常发生。通常用来清理资源或确保某些关键操作（如关闭文件、数据库连接等）总会被执行。

精细的异常捕获

在实际开发中，通常需要针对不同类型的异常进行细化处理。比如上述示例中，我们捕获了ValueError异常，这是因为当尝试将非数字字符串转换为整数时会抛出该异常。而对于其他类型的异常，如除以零产生的ZeroDivisionError，也可以针对性地捕获并给出相应提示：

try:
    result = 1 / 0
except ZeroDivisionError:
    print("发生了除以零的错误。")

总之，异常处理是编程中必不可少的一部分，它增强了程序的健壮性和容错能力，使得程序在面对异常情况时，能更好地给出反馈并保持稳定运行。

六、函数代码复用

（一）函数的定义与使用

在Python编程中，函数是实现代码复用的重要手段，它将一组具有特定功能的语句封装起来，便于多次调用。本文将通过以下几个要点详细阐述函数的定义和使用方法：

函数定义
- 函数定义以关键词def开始，后跟函数名。函数名应遵循标识符命名规则，由字母、数字和下划线组成，且不能以数字开头。
- 函数名后紧跟一对圆括号，括号内为参数列表（可以为空）。参数用于接收传递给函数的数据，无需声明类型。
- 圆括号后的冒号:标志着函数定义的开始，其后的代码需适当缩进，构成函数体。

def sum(a, b):
    result = a + b
    return result

函数调用
- 定义函数并不意味着执行函数，函数的实际执行需要通过调用完成。调用函数时，只需使用函数名后跟一对圆括号，括号内填入传给函数的实际参数值（实参列表）。

print(sum(1, 2))  # 调用函数并打印结果

注意事项
- 在定义函数时，即使函数不需要任何参数，也需要保留一对空的圆括号。
- 函数体内的代码相对于def关键字需要进行缩进。
- 形参（形式参数）在函数定义时不指定类型，其类型由实际调用时传入的实参决定。
- 函数在被调用前，解释器仅执行函数定义，不会执行函数体内的代码。当调用函数时，会根据实参列表将值传递给形参，并执行函数体内的语句。
函数调用过程
- 计算机执行代码时，按照自上而下的顺序执行。当遇到函数调用时，会暂时跳过函数体内的代码，将实参传递给形参，然后执行函数体内的语句。
- 若函数体内的语句包含return语句，则函数执行到此处时会返回指定值并结束函数调用。关于函数返回值的概念将在后续课程中详细介绍。

综上所述，函数的定义和使用是Python编程的基础知识，通过合理地封装和调用函数，可以大大提高代码的可读性和复用性。在后续的学习中，将进一步探讨函数的返回值、默认参数、可变参数以及其他高级特性。

（二）函数参数传递详解

在Python中，函数参数传递主要有四种方式：位置参数、默认值参数、关键字参数和可变长度参数。以下是各参数传递方式的详细说明及示例代码。

位置参数（Positional Arguments）
- 位置参数是指在函数定义和调用时，参数按照顺序传递。在函数定义中，形参按照顺序排列，调用时实参也需要按照同样的顺序进行传递。

def multiply(x, y):
    return x * y
result = multiply(2, 5)  # 正确：2 和 5 分别赋值给 x 和 y
result = multiply(5)      # 错误：缺少一个位置参数
result = multiply(2, 5, 3)  # 错误：多了一个位置参数

默认值参数（Default Arguments）
- 默认值参数是指在函数定义时，为形参提供一个默认值。调用函数时，如果没有为该参数提供实参，将会使用预设的默认值。默认值参数必须出现在位置参数之后。

def add_or_multiply(x, y=10):
    return x + y if y != 0 else x * y
result = add_or_multiply(2, 3)  # 正确：x=2, y=3
result = add_or_multiply(2)      # 正确：x=2, y=10（使用默认值）
result = add_or_multiply(y=3, x=2)  # 正确，但推荐使用位置参数顺序

关键字参数（Keyword Arguments）
- 关键字参数允许调用函数时通过参数名指定实参。这样可以忽略参数的顺序，使得代码更具可读性。

def calculate(value1, value2):
    return value1 * value2
result = calculate(value2=3, value1=2)  # 正确：通过参数名指定实参

可变长度参数（Variable-Length Arguments）
- 可变长度参数分为两种类型：
  - 元组打包参数（*args）：用于接收任意数量的位置参数，并将其收集到一个元组中。

def sum_values(*args):
    total = 0
    for num in args:
        total += num
    return total
result = sum_values(1, 2, 3, 4)  # 返回 10，args=(1, 2, 3, 4)

- - 字典打包参数（kwargs）：用于接收任意数量的关键字参数，并将其收集到一个字典中。

def process_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")
process_info(name="Alice", age=25, job="Engineer")  # 输出：name: Alice, age: 25, job: Engineer

总结：函数参数传递是Python编程中非常重要的概念，熟悉并掌握以上四种参数传递方式有助于提高代码的灵活性和可维护性。在实际编程中，根据需求灵活运用这些参数传递方式，可以使函数接口更加清晰易用。

（三）变量作用域：局部变量与全局变量

在Python编程中，变量的作用域是根据其定义的位置来确定的，主要分为局部变量和全局变量两种类型。

局部变量（Local Variables）
- 局部变量是在函数内部定义的变量，其作用范围仅限于定义它的函数内部。当函数执行完毕，局部变量将不再有效，无法在函数外部访问。

def sum_values(x, y):
    s = x + y  # 局部变量s，仅在函数内部有效
    print(s)
sum_values(1, 2)  # 输出3
print(s)  # 报错：NameError，因为在函数外部无法访问局部变量s

全局变量（Global Variables）
- 全局变量是在函数外部定义的变量，其作用范围涵盖了整个程序文件，包括所有函数内部。函数内部可以直接访问全局变量，但若要在函数内部修改全局变量的值，需要使用global关键字声明。

a = 1  # 全局变量a，可以在函数内外部使用
def modify_a():
    global a  # 使用global关键字声明a为全局变量
    a = 4  # 修改全局变量a的值
modify_a()
print(a)  # 输出4，因为全局变量a已被修改

简而言之，局部变量只能在其定义的函数内部使用，函数执行完毕后失效；而全局变量在整个程序文件范围内均有效，函数内外部均可访问。在函数内部若要修改全局变量的值，必须通过global关键字明确声明该变量为全局变量，否则Python会默认将其视为局部变量。此外，同一程序中可以存在名称相同的局部变量和全局变量，它们互不影响，各自独立。

（四）函数返回值及其使用

在Python编程中，函数返回值是通过return语句实现的，它允许我们将函数内部计算的结果传递到函数外部进行进一步的使用。下面是关于函数返回值的重点内容：

return语句的作用
- return语句用于结束函数的执行，并将函数内部计算得到的值返回到调用该函数的地方。
- 当函数执行过程中遇到return语句时，会立即跳出函数，不再执行后面的代码。

def sum_and_product(a, b):
    s = a + b
    p = a * b
    return s, p  # 返回元组 (s, p)
result = sum_and_product(1, 2)
Pythonprint(result)  # 输出：(3, 2)

return语句的位置
- return语句可以在函数内的任何位置出现，一旦执行到该语句，函数将结束执行并返回相应的值。
返回多个值
- 通过在return语句中用逗号分隔多个表达式，可以一次性返回多个值。这些值将被组合成一个元组返回给调用者。
无返回值的函数
- 函数并非必须有返回值，若不使用return语句或者return语句后不跟任何表达式，函数将被视为无返回值。在这种情况下，调用函数后获取的返回值将是None。

def say_hello():
    print("Hello!")
message = say_hello()  # 执行后，message 的值为 None

返回值的使用
- 可以将函数返回的值赋给一个变量，或者直接在调用函数后进行打印或其他操作。
- 对于返回多个值的函数，可以通过解包或索引等方式访问元组中的各个元素。

returned_tuple = sum_and_product(1, 2)
sum_result = returned_tuple[0]  # 获取第一个返回值，即和
product_result = returned_tuple[1]  # 获取第二个返回值，即积
print(sum_result)  # 输出：3
print(product_result)  # 输出：2

总之，函数的返回值是实现代码模块化和数据交互的重要机制。通过合理地使用return语句，不仅可以控制函数执行流程，还能有效地传递和利用函数内部计算的结果。

（五）代码复用与函数的作用

在编程中，函数扮演着至关重要的角色，其核心价值在于代码复用和提高代码的可读性。下面我们将通过一个实例说明如何利用函数改进代码结构，提升代码复用性。

函数的作用

代码组织与复用：函数可以将具有相同功能的代码封装起来，使其在程序的不同位置被多次调用，避免重复编写相同的代码片段，从而提高代码的简洁性和可维护性。
- 示例：对于一段根据用户输入数字N打印不同形状星号矩阵的代码，原始版本存在大量重复代码。通过提取重复部分创建函数，将变化的部分作为参数传递给函数，即可实现代码的优化。

Python

1# 原始代码
2n = int(input("请输入一个数："))
3if n <= 3:
4    print("*" * 3 for _ in range(3))
5elif 3 < n <= 6:
6    print("*" * 4 for _ in range(4))
7else:
8    print("*" * 5 for _ in range(5))
910# 使用函数优化后的代码
11def print_star_matrix(n):
12    print("*" * n for _ in range(n))
1314n = int(input("请输入一个数："))
15if n <= 3:
16    print_star_matrix(3)
17elif 3 < n <= 6:
18    print_star_matrix(4)
19else:
20    print_star_matrix(5)

提高代码可读性：通过函数抽象，将复杂的逻辑分解为一系列易于理解的函数，使得阅读者更容易把握代码的核心逻辑。

模块化设计

模块化设计：进一步扩展代码复用的概念，将整个程序划分为多个主程序和子程序（或称为模块），每个模块通过函数实现特定的功能，如控制机器人的头部、手部和脚部动作。
耦合度概念：
- 紧耦合：强调单个功能块（函数）内部的代码高度相关，每一行代码都与整体功能紧密相连，不可或缺。
- 松耦合：提倡不同功能块（函数）之间的依赖关系尽量简化，减少相互间的直接影响。即使某个函数出现问题，也不会导致与其松耦合的其他函数无法正常工作。

总结来说，通过合理运用函数以及遵循紧耦合和松耦合原则进行模块化设计，可以极大地提升代码的复用性、可读性和可维护性，使程序更易于理解和修改。

（六）匿名函数（Lambda Function）

匿名函数，又称lambda函数，是一种无需显式定义名称即可快速创建小型、一次性使用的函数的方法，尤其适用于处理较为简单的函数操作，可以有效简化代码并提高可读性。尽管在某些考试大纲中并未明确要求，但在实际试题中可能会出现关于匿名函数的简单应用场景。

匿名函数的定义与语法

匿名函数的表达式一般采用如下形式：

lambda 参数列表: 表达式

lambda：Python 中用于定义匿名函数的关键字。
参数列表：类似于普通函数的形式参数列表，用逗号分隔各个参数名。
冒号 (:)：用于区分参数列表和函数体的表达式部分。
表达式：匿名函数的主体部分，通常是简短的单行表达式，其计算结果即为函数的返回值。

匿名函数实例

假设我们有一个简单的任务——计算两个数的和，可以通过匿名函数实现如下：

# 定义匿名函数
add = lambda x, y: x + y
# 调用匿名函数并传递参数
result = add(2, 3)
# 输出计算结果
print(result)  # 输出：5

在上述代码中，我们首先使用 lambda x, y: x + y 创建了一个匿名函数，该函数接受两个参数 x 和 y 并返回它们的和。接着，我们赋予这个匿名函数一个函数对象名 add，以便后续调用。最后通过 add(2, 3) 调用该匿名函数并将参数 2 和 3 传递给形参 x 和 y，得到结果 5。

需要注意的是，匿名函数由于其简洁特性，更适合于实现简单且临时的函数功能，对于较复杂的函数逻辑，建议使用常规函数定义方式以保证代码的可读性和可维护性。

七、文件和数据的格式化

（一）文件打开方式

1. 文件的概念与分类

文件是存储在辅助存储器（如磁盘、机械硬盘）上的一组数据序列。
文件作为数据集合和抽象，可以包含任意类型的数据内容。
文件主要分为两类：
- 文本文件：由单一特定编码字符组成，例如UTF-8编码，易于展示和阅读。
- 二进制文件：由比特流组成，其内部数据编码格式根据用途不同而变化，常见的如图片、视频文件。

2. 文本文件与二进制文件的区别

文本文件需要统一的字符编码，而二进制文件通常不统一编码。
打开文件时，文本文件读取的结果是字符串，而二进制文件被解析为字节流。

3. 文件的打开与关闭

操作文件遵循三个基本步骤：打开 -> 操作 -> 关闭。
使用Python内置的open()函数实现文件的打开，并通过指定不同的打开模式（如"r"读模式、"w"写模式等）来进行相应操作，最后使用close()方法关闭文件。

# 示例代码：打开并读取文本文件
with open('文件路径及文件名', 'r', encoding='编码格式') as f:
    content = f.read()
    print(content)

open()函数中的参数：
- 第一个参数：文件的路径及文件名。
- 第二个参数：打开模式，如'r'代表读取模式。

👋

r : 读取文件，若文件不存在则会报错

w: 写入文件，若文件不存在则会先创建再写入，会覆盖原文件

a : 写入文件，若文件不存在则会先创建再写入，但不会覆盖原文件，而是追加在文件末尾

rb,wb：分别于r,w类似，但是用于读写二进制文件

r+ : 可读、可写，文件不存在也会报错，写操作时会覆盖

w+ : 可读，可写，文件不存在先创建，会覆盖

a+ ：可读、可写，文件不存在先创建，不会覆盖，追加在末尾

- 可选的第三个参数：当读取文本文件时，指定字符编码，如encoding='utf-8'。

💡

Pyhton中文乱码产生原因及常见问题的解决方法

1.中文乱码产生的原因

中文乱码问题个根本原因就是几种常见中文编码之间存在兼容性，一图胜千言

所谓兼容性可以简单理解为子集，同时存在也不冲突。图中我们可以看出，ASCII被所有编码兼容，而最常见的UTF8与GBK之间除了ASCII部分之外没有交集，这也是平时业务中最常见的导致乱码场景，使用UTF8去读取GBK编码的文字，可能会看到各种乱码。由于在文件存储和网络传输中具体是使用哪种编码并不明确，所以在读取解码时如果使用的解码方式不对应，就会产生乱码。

现将常见的几种情况逐一进行梳理，以供大家学习

2.使用Requests获得网站内容后，发现中文显示乱码。

例如：

import requests

from bs4 import BeautifulSoup

url='w3school 在线教程'

response=requests.get(url)

soup=BeautifulSoup(response.text,'lxml')

xx=soup.find('div',id='d1').h2.text

print(xx)

输出

ÁìÏÈµÄ Web ¼¼Êõ½Ì³Ì - È«²¿Ãâ·Ñ

得到的结果是：ÁìÏÈµÄ Web ¼¼Êõ½Ì³Ì - È«²¿Ãâ·Ñ

这是因为代码中获得的网页的响应体response和网站的编码方式不同，键入response.enconding得到的结果是ISO-8859-1。意思是Requests基于HTTP头部推测的文本编码方式是ISO-8859-1,实际网站真正使用的编码是gb2312。我们只需要声明response的正确编码方式为gb2312就可以了。

response.encoding='gb2312'

（如果还不能解决，有可能是网页数据进行了压缩，可以使用response.content替换response.text。content会自动解码gzip和defate传输编码的响应数据，具体可以再去百度学习）

3.非法字符抛出异常。

当我们将某个字符串从GBK解码为Unicode的时候（也可能是用其他编码方式，比如'UTF-8')，可以采用上面介绍的decode方法，具体如下：

str.decode('GBK')

但实际可能会遇到如下异常

UnicodeDecodeError: 'gbk' codec can't decode bytes in position 7-8: illegal multibyte sequence

出错原因是，字符串内混入了多种编码，于是出现了非法字符，如标点符号全角半角、全角空格的不同编码实现方式存储等，只要出现一个非法字符就会报错。解决方法很简单就是采用ignore忽略，具体可以参照上面对decode函数的详细介绍。

str.decode('GBK','ignore')

4.读写文件的中文乱码

在使用Python3读取和保存文件时一定要注明编码方式。

同时在操作系统中保存的文件也应该明确系统存储时的编码方式，具体可以参照前面对系统编码方式的介绍，如记事本默认的编码方式时ANSI编码（gbk），读取时就应该使用gbk进行decode

另外，jison的保存中，如果希望能在记事本中读取中文文本，可以设置参数ensure_ascii=false

import json

str='中文CH'

with open('ch.json','w',encoding='UTF-8') as f:

json.dump([str],f,ensure_ascii=False)

4. 文件路径

路径分为相对路径和绝对路径：
- 相对路径：相对于当前工作目录的路径。
- 绝对路径：从根目录开始的完整路径，在Python中使用正斜杠("/")分隔各层级目录，且在Windows系统中，需要在路径前添加两个反斜杠("\")或一个正斜杠("/")以避免转义字符问题。例如：

# 绝对路径示例（Windows系统）
file_path = 'C://Users/Desktop//文件夹名称//文件名.txt'

5.文件写入模式详解

在Python中，文件的打开模式主要有以下几种：

读模式 ('r')：用于读取文件内容，如果文件不存在，则会引发错误。读取完成后，文件指针位于文件末尾。
覆盖写模式 ('w')：
- 如果文件不存在，则创建新文件并写入内容。
- 如果文件已存在，则清空文件原有内容并开始写入新的内容。

示例代码：

Python

1with open('B.txt', 'w') as f:
2    # 写入内容
3    f.write("今天天气真好")
4    # 关闭文件（此处由于使用了with语句，无需手动关闭）

创建写模式 ('x')：
- 如果文件不存在，则创建新文件并写入内容。
- 如果文件已存在，则抛出错误，不允许覆盖现有文件。
追加写模式 ('a')：
- 如果文件不存在，则创建新文件并写入内容。
- 如果文件已存在，则在文件末尾追加内容，不覆盖原有内容。

示例代码：

with open('B.txt', 'a') as f:
    f.write("我要去约一场篮球")
f.close()#记得关闭文档

二进制模式 ('b')：可以与上述模式组合使用，如 'wb' 表示以二进制模式打开文件进行写入，'rb' 表示以二进制模式打开文件进行读取。二进制模式下读取的数据将以字节流形式返回，不涉及文本编码。
更新模式 ('+')：可以与 'r', 'w', 'a' 组合使用，如 'r+', 'w+', 'a+'，表示打开文件后既能读也能写。
- 'r+'：文件指针初始位于文件开头，允许读写，但写入会覆盖原有内容。
- 'w+'：文件指针初始位于文件开头，与 'w' 类似，会清空文件内容，之后允许读写。
- 'a+'：文件指针初始位于文件末尾，允许读写，读取时不影响文件指针位置，写入时在末尾追加内容。

总结起来，在实际应用中，根据需求选择合适的打开模式至关重要。考试中常见的是 'w' 模式，但在实际编程中应谨慎使用以免覆盖重要数据。另外，'a' 和 'a+' 模式常用于日志记录等需要在原有内容后追加数据的场景。而对于二进制文件操作，应使用带有 'b' 的模式。

（二）Python文件读写操作详解

在Python中，文件的读写操作主要包括读取全文、逐行读取、移动文件指针位置以及写入文件内容。以下是相关方法的详细介绍：

读取全文 (read() 方法)：
- 使用 open(filename, 'r') 打开文件，并确保在操作结束后调用 close() 方法关闭文件。
- 通过 f.read() 可读取文件中的全部内容作为字符串返回。例如：

with open('./text.txt', 'r', encoding='utf-8') as f:
    content = f.read()
    print(content)

- 若文件包含非ASCII字符（如中文），需指定编码，如 'utf-8'。

逐行读取 (readline() 或 readlines() 方法)：
- readline() 方法读取文件中的一行内容并返回，直至文件末尾。

with open('./text.txt', 'r', encoding='utf-8') as f:
    line = f.readline()
    print(line)

- readlines() 方法读取文件中所有行内容，并以列表形式返回，列表中的每个元素是文件中的一行。

with open('./text.txt', 'r', encoding='utf-8') as f:
    lines = f.readlines()
    for line in lines:
        print(line)

移动文件指针位置 (seek(offset, whence) 方法)：
- seek() 方法用于更改文件对象的当前位置（即文件指针）。
- 参数 offset 是相对于 whence 参数指示的位置的偏移量。
- whence 可以是 0（文件起始处）、1（当前位置）、2（文件结尾处）。
- 示例：

with open('./text.txt', 'r+', encoding='utf-8') as f:
    # 读取整个文件内容
    content = f.read()
    # 将指针重置回文件起始处
    f.seek(0)
    # 再次读取文件内容（将会再次读取到整个文件内容）
    content_again = f.read()

写入文件内容 (write(string) 和 writelines(list_of_strings) 方法)：
- 使用 open(filename, 'w') 以覆盖写模式打开文件。
- write(string) 方法将字符串内容写入文件。

with open('./text.txt', 'w', encoding='utf-8') as f:
    new_content = "学习很难，但我们很快乐"
    f.write(new_content)

- writelines(list_of_strings) 方法将一个字符串列表中的每个字符串依次写入文件，并在每两个字符串间自动添加换行符（若字符串本身不包含换行符）。

names = ["小黑", "小白", "小红", "小绿"]
with open('./text.txt', 'w', encoding='utf-8') as f:
    for name in names:
        f.write(name + '\n')
    # 或者一次性写入所有字符串
    f.writelines([name + '\n' for name in names])

请注意，无论读写操作如何，为了资源的有效管理，强烈推荐使用上下文管理器（如 with 语句）来处理文件操作，这样可以确保文件在完成操作后会被自动关闭，避免资源泄露。同时，针对不同写入模式（覆盖写、追加写等），可以根据需要选择不同的文件打开模式（如 'w'、'a' 等）。

（三）数据组织维度简介与一维数据在CSV文件中的存储与读取

数据组织维度

在计算机处理数据之前，通常需要对数据进行组织。常见的数据组织维度有三种：一维数据、二维数据 和 高维数据。其中，一维数据是最简单的数据组织形式，表现为有序的数据集合，如Python 中的列表。

一维数据的存储方式

一维数据在文件中的存储方式通常包括以下四种：

空格隔开：每个数据项之间以空格进行区分。
逗号分隔（CSV格式）：数据项之间以逗号分隔，广泛应用于数据交换。
换行分隔：每个数据项占据一行，下一个数据项在下一行开始。
特殊字符分隔：使用除逗号之外的其他特殊字符作为分隔符。

CSV文件及其特点

CSV (Comma Separated Values) 文件是一种常见的表格数据文件格式，各列数据由逗号分隔。其通用性强，多数编程语言和软件都能支持CSV文件的读写。Python 中处理CSV文件的主要目的是实现数据的交换和共享。

一维数据写入CSV文件

示例1：字符串写入CSV文件

假设有一组数据：北京、上海、重庆、武汉、广东，可通过以下步骤将其写入CSV文件：

1data_str = "北京,重庆,武汉,广东"
2with open('demo.csv', 'w', newline='') as f:
3    f.write(data_str)

这里需要注意，newline='' 参数是为了防止在不同操作系统间因换行符差异导致的问题。运行后，数据将按照逗号分隔写入CSV文件，并在打开文件时被解析为表格形式。

示例2：列表写入CSV文件

对于列表 [北京, 西藏, 武汉, 上海]，要将其写入CSV文件，应先将其转换为逗号分隔的字符串，再进行写入：

data_list = ["北京", "西藏", "武汉", "上海"]
data_str = ','.join(data_list)
with open('demo.csv', 'w', newline='') as f:
    f.write(data_str)

一维数据从CSV文件读取

假设CSV文件中有一行数据：北京、西藏、武汉、上海、天津，可以通过以下步骤读取并处理数据：

Python

with open('demo.csv', 'r', newline='') as f:
    data = f.read()  # 先读取整个字符串
    data_without_newline = data.replace('\n', '')  # 去掉末尾换行符
    data_list = data_without_newline.split(',')  # 根据逗号分割为列表
# 输出处理后的列表
print(data_list)

在读取CSV文件后，首先去除换行符，然后使用 split(',') 函数将数据分割为列表，最后输出处理后的列表。在实际应用中，Python 提供了 csv 模块专门用于高效处理CSV文件，可以简化此类操作。

（四）二维数据的存储与读取

二维数据的概念与存储方式

二维数据是由多个一维数据构成的，每一行视为一个一维数据。例如，一个包含多个一维数据（即子列表）的大列表，每个子列表内部是以逗号隔开的元素集合。二维数据常以表格的形式展现，而CSV文件正是存储二维数据的理想格式，其中每行对应一个一维数据，各元素间以逗号分隔，行与行之间则是独立的数据记录。

将二维列表写入CSV文件

假设存在一个二维列表，并希望将其写入CSV文件中，步骤如下：

Python

1# 假设我们有一个二维列表data_2d
2data_2d = [['学校', '姓名', '理科人数'], ['A校', '张三', '100'], ['B校', '李四', '200']]
34# 打开CSV文件以写入模式
5with open('demo.csv', 'w', newline='') as f:
6    writer = csv.writer(f)
78    # 遍历二维列表，逐行写入CSV文件
9    for sublist in data_2d:
10        # 将子列表转换为逗号分隔的字符串，并在末尾添加换行符
11        row_string = ','.join(sublist) + '\n'
12        # 写入文件
13        f.write(row_string)
1415# 关闭文件
16# （此处不需要显式调用f.close()，因为在with语句中已自动管理文件关闭）

从CSV文件读取二维列表

读取CSV文件并将内容转换为二维列表的过程如下：

Python

1import csv
23# 打开CSV文件以读取模式
4with open('demo.csv', 'r') as f:
5    reader = csv.reader(f)
67    # 逐行读取CSV文件内容，并存入二维列表
8    data_2d_read = []
9    for row in reader:
10        # 移除行尾换行符（如有），并添加至二维列表
11        row_no_newline = [item.rstrip('\n') for item in row]
12        data_2d_read.append(row_no_newline)
1314# 输出读取到的二维列表
15print(data_2d_read)

双层循环遍历二维列表

在处理二维列表时，通常需要使用双层循环。外层循环遍历每一行（即每个子列表），内层循环遍历该行内的每个元素。例如：

Python

1for row in data_2d:
2    for item in row:
3        # 对item进行所需处理，如打印或计算等
4        print(item)

总结：本节课主要讲述了如何将二维列表写入CSV文件以及如何从CSV文件中读取二维列表，并强调了处理二维列表时双层循环的应用场景。同学们应熟练掌握上述方法，并能灵活运用到实际案例中。

八、Python计算生态与计算思维

（一）计算思维概述

计算思维概念

计算思维是人类在认识世界和改造世界过程中形成的特殊思维方式，主要包括三种思维特征：

实证思维：以实验和验证为核心，以物理学为代表，强调通过实践和证据检验理论。
逻辑思维：以推理和演绎为主要特征，以数学为代表，注重严密的逻辑体系和证明过程。
计算思维：以设计和构造为显著特征，以计算机科学为代表，着重于利用算法和自动化手段解决问题。

计算思维本质

计算思维的本质在于抽象与自动化。抽象是对现实世界的简化模拟和模型构建，自动化则指通过编写程序让计算机执行相应的逻辑以解决实际问题。举例而言，高斯通过逻辑思维发现了计算1到100之和的简便方法——等差数列求和公式。而在计算思维中，即使面对看似简单的逐项累加问题（如1+2+3+...+100），也会将其转化为计算机可执行的指令序列，充分发挥计算机强大的计算能力，从而快速解决问题。

程序设计方法论

在本章中，我们将通过实例讲解程序设计方法论，引导大家学会如何设计和实现解决问题的算法，并通过编写Python代码来体现计算思维在实际应用中的价值。

Python计算生态

在后续章节中，我们将深入探讨Python计算生态，包括但不限于各种库、框架以及工具链等内容，但在本章仅作简要介绍，让大家对其有初步的认识。

复习Python内置函数

为了巩固基础，本章还会带领大家回顾部分Python内置函数的使用，选取具有代表性的几个函数进行实战练习。然而，更为广泛的内置函数学习和实践还需各位自行加强训练。

总结：本节课介绍了计算思维的基本概念及其本质特征，并预告了接下来课程内容的重点，包括程序设计方法论、Python计算生态以及Python内置函数复习。希望大家能够领会计算思维的核心理念，并在后续的学习实践中逐步培养和运用计算思维解决问题的能力。

（二）程序设计方法论：自顶向下设计实例

在本节课中，我们将通过一个模拟游戏购买商品流程的实例，来阐述自顶向下的程序设计方法。这种方法的基本思路是从一个复杂问题出发，逐步将其分解为一系列较小、更易处理的问题，最终通过逐一解决这些小问题，实现整个程序的设计与实现。

实例描述

我们设计的小程序模拟了游戏中购买商品的过程。玩家可以输入商品编号和购买数量，程序将计算总价，并处理支付环节，最终显示购买结果。

自顶向下设计步骤

第一步：打印程序介绍信息
- 创建一个名为intro的函数，负责输出程序的介绍信息。
第二步：获取商品编号和数量
- 定义一个名为get_CID_count的函数，接收用户输入的商品编号（CID）和购买数量(count)，并进行相应处理。
第三步：计算商品总价
- 设计一个名为get_total_price的函数，根据商品编号和数量从商品信息字典中查找单价，并计算总价。
第四步：处理支付
- 编写一个名为handle_payment的函数，接收用户支付金额，并计算找零，完成支付环节。

主程序设计

主函数（main function）
- 作为程序的核心，主函数负责调用上述四个子函数，按照自顶向下的设计思路，依次执行各个步骤，确保整个程序流程顺利完成。

以下是按照自顶向下设计方法编写的主函数示例：

首先，我们将整个程序划分为四个步骤，分别为输出介绍信息、获取商品编号和数量、计算商品总价以及处理支付。接下来，我们将逐步实现每个函数的具体功能。

步骤一：输出介绍信息

1def intro():
2    print("欢迎来到武器商店！")
3    print("请按照以下操作完成交易：")
4    print("--------------------------------")
5    # 输出商品列表信息
6    for key, value in 商品信息.items():
7        print(f"编号：{key}")
8        print(f"名称：{value['name']}")
9        print(f"单价：{value['price']} 元")
10        print("--------------------------------")
11    print("请输入您要购买的商品编号和数量，如：102 3")
1213# 在主函数中调用此函数输出介绍信息

步骤二：获取商品编号和数量

1def get_CID_count(user_input):
2    CID, count = user_input.split()
3    CID = int(CID)
4    count = int(count)
5    return CID, count

步骤三：计算商品总价

1def calculate_total_price(CID, count):
2    product_info = 商品信息[CID]
3    price = int(product_info['price'])
4    total_price = price * count
5    return total_price

步骤四：处理支付

1def handle_payment(total_price):
2    while True:
3        money = float(input(f"请输入您的付款金额（总价为{total_price}元）："))
45        if money >= total_price:
6            change = money - total_price
7            print(f"购买成功，找回：{change:.2f} 元")
8            break
9        else:
10            print("金额不足，请重新输入")
1112# 在主函数中调用以上四个函数，按顺序执行购买流程

在程序执行过程中，自底向上的执行方式体现在函数间的调用关系上。首先，程序从底部的函数开始逐个执行，每当调用一个函数时，该函数体内的代码才会被执行。整个流程遵循了先定义函数，再调用函数的规律，由底层函数逐层调用至顶层主函数，实现了自底向上的执行逻辑。

总结：通过本节内容，我们不仅学会了自顶向下设计程序的方法，还将每个模块抽象为单独的函数，并通过自底向上的执行方式完成了整个程序流程。同时，也强调了在设计中理解和区分“自顶向下设计”与“自底向上执行”的重要性，这对于今后的编程实践有着指导意义。

（三）Python计算生态介绍

开源开放的Python

自诞生以来，Python始终坚持开源开放的原则，得益于此，Python在全球范围内构建起了最大的编程计算生态系统。Python拥有众多强大的库，使得开发者无需从零开始编写所有底层逻辑，只需调用相应的库及其内部函数即可实现复杂功能，例如网络爬虫技术，就依赖于诸如requests、Scrapy等成熟的爬虫相关库。

Python与胶水语言

Python中的库并非全由Python编写，部分库可能是用C语言等其他语言编写的。然而，Python可通过简单封装，提供统一接口供用户调用，这也让Python被誉为“胶水语言”。因其开源开放特性和与其他语言的高度兼容性，Python现已成为全球计算生态最大的编程语言之一。

标准库与第三方库

标准库：标准库是由Python官方提供的库，其包含了一系列广泛应用且高频使用的模块，如random（随机数模块）和turtle（海龟绘图模块）。这些库在Python安装时就已经包含其中，可以直接调用。
第三方库：第三方库是指非官方提供，但针对特定领域或需求开发的库，如用于网络爬虫的requests、用于机器学习和数据分析的各类库等。第三方库通常需要根据实际需求额外下载安装，以保持Python安装包的精简，并确保仅专业人士在其所需领域获取和使用对应的工具库。

总结，Python以其丰富的计算生态，特别是标准库和第三方库的支持，极大地提高了开发效率并促进了跨领域的知识共享和技术进步。下一章节将重点带领大家学习如何使用这两种类型的库。

（四）Python内置函数简介

在Python中，解释器自带了大约68个内置函数，虽然不是每个函数都会在初级考试中涉及，但其中一部分尤为重要。本节将重点介绍几个较为重要和特殊的内置函数，同时也会提及一些相对冷门但在某些场景下仍可能用到的函数。

常用内置函数示例

open()：用于打开文件，返回文件对象。参数包括文件路径、打开模式（读、写等），以及编码方式（在读模式下可能需要指定）。

冷门内置函数解析

`all(iterable)`

函数作用：检查iterable中的所有元素是否均为真（非零、非空、非False），如果所有元素均为真，则返回True，否则返回False。
示例：

1all([1, 3, 4, 5])  # 返回 True，因为所有元素均为非零数值，视为真
2all([1, 0, 4, 5])  # 返回 False，因为存在0，被视为假

`any(iterable)`

函数作用：检查iterable中的任意元素是否为真，只要有一个元素为真，则返回True；若所有元素均为假，则返回False。
示例：

1any([0, 0, 0, 1])  # 返回 True，因为存在1这个真值

`exec(code[, globals[, locals]])`

函数作用：执行一个动态的Python代码字符串，该字符串会被当作单个语句或语句序列执行。exec函数本身没有返回值，但它会改变全局或局部作用域的变量状态。
示例：

a = ""
exec("a = 1 + 2")  # 执行后，a的值变为3，但exec不会返回任何值
print(a)  # 输出：3

`sorted(iterable[, key[, reverse]])`

函数作用：对可迭代对象iterable中的元素进行排序，返回一个新的已排序列表。可选参数key用于指定排序依据，reverse=True表示降序排列。
示例：

numbers = [5, 6, 2, 4, 8, 2]
sorted_numbers = sorted(numbers, reverse=True)
print(sorted_numbers)  # 输出：[8, 6, 5, 4, 2, 2]
# 使用reverse参数直接修改原列表顺序，使用reverse()函数
numbers.reverse()
print(numbers)  # 输出：[2, 2, 4, 5, 6, 8]

`reversed(seq)`

函数作用：返回一个反向迭代器，用于迭代序列seq的倒序版本，而不是直接返回反转后的列表。
示例：

original_list = [1, 2, 3, 4, 5, 6]
reversed_iter = reversed(original_list)
for num in reversed_iter:
    print(num)  # 输出：6, 5, 4, 3, 2, 1

其他内置函数简述

在列举的内置函数中，提到了somedata和mean、max等函数，但实际上Python内置函数中并没有名为somedata的函数，mean和max也不是内置函数，而是NumPy或其他数据处理库中的函数，用于计算平均值和最大值。

请同学们牢记常见内置函数的用途，并尽可能熟悉它们的使用方法。对于不太常见的内置函数，虽不常出现在考试中，但也应有所了解。本节课的内容着重在于加强大家对Python内置函数的认识与掌握。

九、python标准库

（一）Python标准库概览

在Python编程中，标准库是指Python自带的一系列模块，可以直接使用无需额外安装。而在第三方库中，包含了许多专业且功能丰富的模块，需要通过安装才能调用。本章着重介绍Python标准库中的三个关键库：turtle、random 和 time。其中，turtle 和 random 库是考试中的必考内容，而 time 库虽在考试中的重要性相对较低，但在实际编程中却具有重要作用，尤其在处理时间和延迟方面。

turtle库概述

turtle 库是Python的一个基础绘图库，适合初学者学习图形绘制和动画制作。在这个库中，核心概念是一个名为“小乌龟”的虚拟实体，它在一个二维坐标平面上移动。每当小乌龟移动时，会在路径上留下痕迹，形成图形。

turtle库的基本使用方式

第一种导入方式：

1import turtle
2turtle.forward(100)  # 小乌龟向前移动100像素，留下一条线段

第二种导入方式：

1from turtle import *
2forward(100)  # 直接调用forward函数，小乌龟向前移动100像素

第三种导入方式（别名导入）：

1import turtle as t
2t.forward(100)  # 使用别名`t`调用forward函数

窗口设置函数`setup()`

turtle.setup() 函数用于设置绘图窗口的大小和初始位置。它接受四个参数：

宽度（窗口宽度）
高度（窗口高度）
初始X坐标（相对于屏幕左上角的水平偏移量）
初始Y坐标（相对于屏幕左上角的垂直偏移量）

例如：

1import turtle
2turtle.setup(400, 400, 100, 100)  # 设置窗口大小为400x400像素，位于屏幕左上角距离100像素的位置

若仅提供宽度和高度两个参数，则窗口会默认居中显示。

此外，setup() 的参数也可以接受浮点数，表示相对于屏幕尺寸的比例，例如：

1turtle.setup(0.5, 0.6)  # 窗口宽度占屏幕宽度的50%，高度占屏幕高度的60%

（二）Python Turtle库常用状态函数详解

在Python的turtle库中，有一些常用的状态函数用于控制绘图过程中的画笔行为。为了更好地理解并掌握这些函数的用法，我们将逐一解析它们的功能，并通过实例演示如何使用。

基础状态函数

penup() / pendown()
- penup()：模拟画笔抬起，此时即便移动乌龟也不会在画布上留下痕迹。
- pendown()：模拟画笔落下，当乌龟移动时会在画布上留下轨迹。

1from turtle import *  # 第二种导入方式
2pendown()  # 落笔
3forward(100)  # 前进100像素
4penup()  # 提笔

pensize()
- 设置画笔的粗细，单位通常为像素。

1pensize(6)  # 设置画笔粗细为6像素

pencolor()
- 设置画笔的颜色。

1pencolor("blue")  # 设置画笔颜色为蓝色

fillcolor()
- 通过begin_fill()和end_fill()配合使用，设置填充图形的颜色。

1fillcolor("red")  # 设置填充颜色为红色
2begin_fill()  # 开始填充
3# 这里绘制图形...
4end_fill()  # 结束填充

其他相关函数

clear()
- 清除当前窗口的所有绘画内容，但不改变乌龟的位置。

1clear()  # 清空当前窗口

reset()
- 将乌龟重置至原点（中心），并将画布清空。

1reset()  # 重置乌龟位置及清空窗口

write()
- 在当前位置写入文本，可以指定字体样式。

1write("你好", font=("宋体", 12))  # 在当前位置写出“你好”，字体为宋体，字号为12

screensize()
- 设置画布的大小，不同于setup()函数，它只更改画布尺寸而不影响画布位置。

1screensize(400, 300)  # 设置画布尺寸为400x300像素

hideturtle()
- 隐藏画笔的形状（乌龟图标），在绘图过程中使其不可见。

1hideturtle()  # 隐藏画笔形状

showturtle()
- 显示画笔的形状，与hideturtle()相反。

1showturtle()  # 显示画笔形状

isvisible()
- 返回一个布尔值，表示画笔是否可见。如果可见则返回True，否则返回False。

1if isvisible():  # 检查画笔是否可见
2    # 如果可见，则执行相应操作

总结：本节课详细介绍了turtle库中与画笔状态相关的常见函数，包括画笔的升降、粗细、颜色设定、填充颜色、清除屏幕、重置乌龟位置、在画布上写字以及控制画笔形状的可见性等功能。熟练掌握这些函数将有助于使用turtle库完成各种基本绘图任务。下一节课将重点讨论turtle库中的运动函数。

（三）Python Turtle 库常用运动函数详解

基础运动函数

forward() 和 backward()

forward(distance)：向前移动画笔指定的距离（单位：像素）。
backward(distance) 或 back(distance)：向后移动画笔指定的距离。实际上，可以使用负数值调用 forward(-distance) 来达到同样的效果。

setheading(angle)

setheading(angle) 或其缩写形式 seth(angle)：设置画笔指向指定的角度（0° 为向东，顺时针为正角度，逆时针为负角度）。

circle(radius[, extent])

circle(radius, extent=None)：绘制一个圆或者部分圆。其中 radius 表示圆的半径，extent（可选参数）表示要绘制的角度范围，默认为 360° 绘制完整圆。

undo()

undo()：撤销画笔的最后一个动作。

right(angle) 和 left(angle)

right(angle)：向右旋转画笔指定的角度。
left(angle)：向左旋转画笔指定的角度。

goto(x, y)

goto(x, y) 或者 setpos(x, y)：移动画笔到指定的坐标 (x, y) 处，移动过程中保持当前方向不变。

speed(speed_value)

speed(speed_value)：设置画笔的绘制速度，取值范围为0到10，0最快，1最慢，中间数值介于两者之间。

dot(radius[, color])

dot(radius, color="black")：在画笔当前位置绘制一个直径为 radius 的实心圆点，可选参数 color 设置圆点颜色。

home()

home()：将画笔移动回原点（即 (0, 0) 坐标位置）。

总结：在Python的turtle库中，上述运动函数是绘制图形的基础，包括直线移动、转向、绘制圆形以及定位等功能。通过灵活组合和运用这些函数，可以创造出多种多样的几何图形。同时，记得合理利用undo()撤销错误操作，以及通过speed()调整绘制速度，提高绘图效率。另外，理解各个函数之间的联动机制至关重要，例如setheading()设置方向后再进行前进，能够使画笔沿着新的方向移动。最后，借助dot()函数可在特定位置绘制单个点，home()函数则可快速将画笔回归原点。

（四）Python Random 库详解

随机数库 - random

在Python的标准库中，random模块是一个非常实用的工具，用于生成各种类型的随机数。本节课程将详细介绍random库中的几个关键函数及其用法。

1. `random.random()` 函数

这是最基本的随机数生成函数，它会生成一个位于0.0（包含）到1.0（不包含）之间的浮点数。

1import random
2n = random.random()
3print(n)

2. 设置随机种子 - `random.seed()` 函数

random.seed()函数用于初始化随机数生成器的种子，默认情况下使用系统当前时间，确保每次程序运行时都能得到不同的随机数。
如果传递一个特定的数值作为参数，则每次运行程序并使用同一种子时，生成的随机数序列将会一致。

1random.seed(3)

3. 生成指定范围内的整数 - `random.randint(a, b)` 函数

这个函数生成一个介于a（包含）和b（包含）之间的随机整数。

1n = random.randint(1, 6)
2print(n)

4. 获取指定长度的随机整数 - `random.getrandbits(k)` 函数

random.getrandbits(k)生成一个具有k比特长度的随机整数，并将其转换为十进制显示。

1n = random.getrandbits(6)
2bin_n = bin(n)  # 转换为二进制表示
3print(bin_n)

5. 生成指定范围内的随机浮点数 - `random.uniform(a, b)` 函数

此函数生成一个位于a（包含）和b（包含）之间的随机浮点数。

1n = random.uniform(1, 9)
2print(n)

6. 随机选取序列中的元素 - `random.choice(sequence)` 函数

从序列类型（如列表、元组等）中随机选取一个元素并返回

1ls = [1, '我', '你']
2element = random.choice(ls)
3print(element)

7. 打乱序列 - `random.shuffle(sequence)` 函数

将序列类型中的元素随机排列，原地修改序列本身。

1ls = [1, 2, '333', '5', 79]
2random.shuffle(ls)
3print(ls)

8. 抽取序列中的随机样本 - `random.sample(sequence, k)` 函数

从序列类型中随机抽取k个不重复的元素，并以列表形式返回。

1ls = ['寒假', '代表']
2sampled_ls = random.sample(ls, 3)  # 或者根据需要更改k值
3print(sampled_ls)

总结起来，random库提供了丰富的功能，可以帮助我们在编程过程中生成各类随机数据。为了更好地掌握这些函数的用法，请大家多多实践，尝试编写不同的代码片段来熟悉它们的特性。

（五）Python Time 库讲解

Python 标准库之 Time 库

尽管 time 库在某些场合下属于选考内容，但在实际编程中，特别是涉及时间处理、计时、程序暂停等功能时，time 库显得尤为重要。接下来我们将深入探讨 time 库中的关键函数及其用途。

时间处理部分

1. `time.time()` 函数

返回当前时间的时间戳，即从1970年1月1日（UTC）以来的秒数，精度可达到毫秒或微秒级别。

1import time
2timestamp = time.time()
3print(timestamp)  # 输出类似：1592144100.0

2. `time.gmtime()` 函数

返回当前时间的 struct_time 对象，表示 UTC 时间。

1utc_time = time.gmtime()
2print(utc_time)  # 输出类似：time.struct_time(tm_year=2020, tm_mon=6, tm_mday=14, ...)

3. `time.localtime()` 函数

返回当前时间的 struct_time 对象，表示本地时间。

1local_time = time.localtime()
2print(local_time)  # 输出类似：time.struct_time(tm_year=2020, tm_mon=6, tm_mday=14, ...)

4. `time.mktime()` 函数

将 struct_time 对象转换为时间戳。

1t = time.localtime()
2timestamp_local = time.mktime(t)
3print(timestamp_local)

5. `time.strftime()` 函数（格式化主力军，常考）

格式化本地时间，将 struct_time 对象转换为字符串形式。

1formatted_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
2print(formatted_time)  # 输出类似：'2020-06-14 17:15:00'

strftime 中的格式化符号如：

%Y 表示四位年份
%m 表示月份（01-12）
%d 表示日期（01-31）
%H 表示24小时制小时数
%M 表示分钟数
%S 表示秒数

6. `time.strptime()` 函数

反格式化字符串为 struct_time 对象，将符合特定格式的字符串解析为时间。

计时功能

7. `time.sleep(secs)` 函数

暂停程序执行指定秒数。

1for i in range(3):
2    print(i)
3    time.sleep(3)  # 每隔3秒打印一次循环变量i的值

总结

在 time 库中，重点掌握的功能包括获取时间戳、转换UTC和本地时间、格式化与反格式化时间以及进行程序暂停。尤其在考试中，时间格式化的相关操作常常成为考点，通常需要先调用 time.localtime() 获取本地时间对象，再使用 time.strftime() 进行格式化输出。

以上就是 time 库中常用函数的简介，建议大家在实践中不断练习，熟练掌握各个函数的用法。

十、python第三方库

（一）第三方库获取与安装方式

1. PIP 工具安装

PIP 是随 Python 下载时一同提供的包管理工具，可以直接在终端中使用。
常用的安装命令有两种，分别适用于不同操作系统：
- Windows 系统使用 pip install 库名
- 苹果 macOS 系统，若已安装 Python 3，则使用 pip3 install 库名，避免安装到 Python 2.7 版本。
打开终端的方法：
- Windows 用户：按 Windows + R 键打开“运行”对话框，输入 cmd 并回车；或者直接在搜索框中搜索“cmd”并打开命令提示符。
- macOS 用户：直接打开“终端”应用。
安装 pyinstaller 库的例子：

pip3 install pyinstaller

验证安装是否成功：

pip list

2. 加速安装第三方库（国内源）

当通过 PIP 安装速度较慢时，可以使用国内的镜像源加速安装过程，例如豆瓣源：

pip3 install -i https://pypi.doubanio.com/simple/ 库名

举例：快速安装 requests 库

pip3 install -i https://pypi.doubanio.com/simple/ requests

3. 自定义安装和文件安装

自定义安装是指通过指定网站下载 WHL 文件或其他类型的安装包文件，然后进行安装。
文件安装则是指下载好相应的库文件后，在本地进行安装。
文件安装步骤示例：
- 下载库文件（例如 requests 的 WHL 文件）。
- 在终端中通过 cd 命令切换至包含下载好的库文件的目录。
- 使用 pip install 命令安装该文件：

pip install ./path/to/库文件.whl

PIP 工具常用命令

安装：pip install 库名
卸载：pip uninstall 库名
查看已安装库列表：pip list
查看帮助文档：pip help

（二）使用PyInstaller库将Python源文件打包成可执行文件

PyInstaller概述

PyInstaller库是一个跨平台的打包工具，它可以将Python源代码转换为Windows (.exe)、Linux和Mac OS等操作系统下的可执行文件。这意味着即使目标用户的计算机上没有安装Python环境，也能直接运行打包后的程序。

安装PyInstaller

Shell

1pip3 install pyinstaller

注意事项：

安装PyInstaller时，请确保使用对应Python 3版本的pip，如pip3，以免安装到Python 2环境中。
推荐使用的Python版本为3.7或3.5，过高版本可能导致部分旧库无法正常安装。

打包Python程序

假设在桌面上有一个名为yin_yang.py的Python文件，我们需要将其打包为可执行文件。

打开终端：
- Windows用户通过Windows + R快捷键打开运行对话框，输入cmd并回车；
- macOS用户直接打开终端应用。
切换到源文件所在目录：
- 使用cd命令更改工作目录到包含yin_yang.py的文件夹路径。
打包基础版：

Shell

1pyinstaller yin_yang.py

运行此命令后，会在当前目录下生成一个dist文件夹，其中包含打包后的可执行文件。

打包纯净版（只生成单个可执行文件）：

Shell

1pyinstaller --onefile yin_yang.py

替换默认图标：若要更改打包后的应用程序图标，需要准备一个.ico格式的图标文件，并将其与源文件放置在同一目录下，然后使用以下命令打包：

Shell

1pyinstaller --onefile --icon=1.ico yin_yang.py

去除控制台窗口（对于不需要用户交互且无输出的日志型应用）：

Shell

1pyinstaller --onefile --windowed yin_yang.py

其他PyInstaller选项与帮助

若要查看PyInstaller的所有可用选项和指令，可以通过以下命令获得帮助信息：

Shell

1pyinstaller --help

总之，通过PyInstaller库，开发者可以方便地将Python源代码转化为易于分发和部署的独立可执行文件，并根据实际需求定制打包参数，包括但不限于替换默认图标、去除控制台窗口等。尽管这一知识点在某些考试场景下并非重点，但在实际编程工作中却十分实用。

（三）结巴库（Jieba）在中文文本分词中的应用

结巴库是一个强大的第三方中文分词库，能够有效处理中文文本的词语分割问题。例如，对于一段文字，如“一个重要的第三方中文分词函数库”，结巴库能够将其按照词语边界正确分割为“一个”、“重要”、“的”、“第三方”、“中文”、“分词”、“函数库”。

安装结巴库

安装结巴库可通过以下命令完成：

Bash

1pip3 install jieba

为了加速安装过程，建议使用豆瓣源：

Bash

1pip3 install jieba -i https://pypi.doubanio.com/simple/

安装完成后，可以通过pip3 list命令检查是否安装成功。

结巴库的工作原理与功能

结巴库基于预设的中文词语库进行分词操作，当接收到一句文本时，会在词库中查找并匹配出所有可能的词语组合。

结巴库支持三种分词模式：

精确模式：提供最精确的分词结果，适用于对分词结果要求严格的场景。
全模式：尽可能包含所有可能的词语组合，分词速度较快，但可能会产生较多冗余信息。
搜索引擎模式：在精确模式基础上对较长词语进行进一步细分，相比精确模式更为细致，但不及全模式全面。

使用方法

导入结巴库：

Python

1import jieba

精确模式分词示例：

Python

1sentence = "全国计算机等级考试Python科目"
2words_list = jieba.lcut(sentence)
3print(words_list)

运行后将得到一个列表，其中包含了按精确模式分词后的结果。

全模式分词示例：

Python

1words_list = jieba.lcut(sentence, cut_all=True)
2print(words_list)

在全模式下，分词结果会包含更多的可能性，可能会出现单个汉字也被当作词语的情况。

搜索引擎模式分词示例：

Python

1words_list = jieba.lcut_for_search(sentence)
2print(words_list)

搜索引擎模式会在精确模式基础上进一步细分词语。

添加自定义词汇

对于结巴库词典中未包含的新兴词汇或专有名词，可以手动添加至词库：

Python

1jieba.add_word("奥利给")
2sentence = "作为一个年轻人，我们要努力，加油奥利给！"
3words_list = jieba.lcut(sentence)
4print(words_list)

在添加词汇"奥利给"后，该词汇在分词时将不再被误切分。

（四）Workout库：用于生成词云的第三方库及其在Python中的应用

在本节课中，我们将探讨Workout库，这是一个专门用于生成词云的Python第三方库，在某些Python二级考试中作为选考内容出现。通过Workout库，我们可以将文本内容可视化，突出显示文本中高频词汇。

安装Workout库

Bash

1pip3 install wordcloud

为了加快安装速度，可以使用豆瓣源进行安装：

Bash

1pip3 install wordcloud -i https://pypi.doubanio.com/simple/

使用Workout库生成词云

示例1：基于空格分隔的简单词云生成

导入库：

Python

1from wordcloud import WordCloud

创建一个文本字符串：

Python

1text = "Python IM Learning"

使用WordCloud类的generate()方法生成词云：

Python

1wc = WordCloud().generate(text)

将生成的词云保存为图片：

Python

1wc.to_file('test.png')

这样，WordCloud将会根据文本中各个词汇出现的频率，创建一个词云图片，并保存在指定路径下。

示例2：结合结巴分词库生成词云

首先导入所需的库：

Python

1import jieba
2from wordcloud import WordCloud

准备含有换行符的多行文本字符串：

Python

1text_with_newlines = """
2程序设计语言，Python学习，
3计算机编程入门课程。
4"""

使用结巴库进行分词：

Python

1words = jieba.lcut(text_with_newlines)

将分词结果转换为字符串：

Python

1joined_text = ' '.join(words)

设置WordCloud的参数，包括字体路径（解决中文显示问题），以及图片尺寸等：

Python

1font_path = 'C:/Windows/fonts/simhei.ttf'
2wc = WordCloud(font_path=font_path, width=800, height=600).generate(joined_text)

最后，将生成的词云保存为图片：

Python

1wc.to_file('word.png')

通过上述步骤，Workout库可以根据提供的文本生成词云图片，其中词云中的每个词的大小与该词在文本中出现的频率成正比。此外，用户可以根据需要自定义多种参数，如背景颜色、词间距、形状等，以便更好地满足个性化需求。更多参数可参考官方文档进行配置。

（五）Python第三方库概述及重要库详解

在本节课中，我们将概览Python中常见的第三方库并详细介绍部分关键库的应用场景和功能。以下是各类库的简要总结：

1. 网络爬虫方向

requests: 简洁易用的HTTP库，用于模拟人类访问网页的行为，适合简单网页抓取任务。
scrapy: 功能强大的爬虫框架，用于构建复杂爬虫项目，包含数据提取、存储、并发请求等功能。

2. 数据分析方向

numpy: 提供高效的矩阵运算和多维数组处理能力，常用于科学计算和数据分析的基础库。
pandas: 强大的数据处理库，支持DataFrame结构，方便进行数据清洗、合并、筛选等工作。
scipy: 包含大量科学计算功能，如线性代数、傅立叶变换等。
matplotlib: 基础的数据可视化库，用于绘制二维图表。
seaborn: 基于matplotlib的高级统计图形库，提供更加美观和易于使用的可视化功能。

3. 文本处理方向

pdfminer: 处理PDF文档的库，用于提取文本、布局信息等。
openpyxl: 处理Excel文件的库，能读写Excel表格数据。
python-docx: 操作Word文档的库，可用于创建、修改Word文档内容。
beautifulsoup4: HTML和XML解析库，常用于网页信息抽取。

4. 数据可视化方向

matplotlib: 绘制2D图表的库，广泛应用于数据可视化。
mayavi: 开源的三维可视化工具包，用于科学数据的三维可视化。
plotly: 功能强大的交互式可视化库，支持在线和离线环境下的图表制作。

5. 用户图形界面（GUI）方向

PyQt5: 商业级GUI库，可用于开发专业级应用程序。
wxPython: 另一个流行的GUI库，具有丰富的组件和良好的跨平台性能。
Tkinter: Python自带的标准GUI库，虽功能相对简单但易于上手。

6. 机器学习方向

scikit-learn: 用于数据挖掘和数据分析的机器学习库，包含大量的监督和无监督学习算法。
tensorflow: Google开发的深度学习框架，广泛应用于神经网络模型构建。
keras: 构建在tensorflow等框架之上的高级神经网络API，简化深度学习模型开发流程。

7. Web开发方向

Flask: 轻量级Web框架，易于上手，适用于小型至中型项目。
Django: 功能齐全的重量级Web框架，包含完整的MVC模式和丰富的功能模块，适合大型项目开发。
Tornado: 高性能异步Web框架，适用于长连接、实时通信等场景。

8. 游戏开发方向

pygame: 用于开发2D游戏的库，适合初学者入门游戏编程。
Panda3D: 用于开发3D游戏的引擎，支持Python编写游戏逻辑代码。

9. 其他重要库

Pillow (PIL): 图像处理库，支持图像加载、显示、转换、保存等多种操作。
sympy: 符号数学计算库，用于数学表达式的符号运算。
nltk: 自然语言处理库，提供分词、标注、语法分析等功能。
itchat: 微信公众平台开发库，便于开发基于微信的聊天机器人和公众号应用。
qrcode: 二维码生成库，可以创建静态和动态效果的二维码。

学习这些库时，切记每个库都有其特定的应用场景和功能特点，无需全部精通，只需根据实际需求选择合适的库，并学会查阅相关文档解决问题。同时，熟练掌握Python基础知识，是有效利用这些库的前提。在考试中，通常需要考生了解各库的主要用途和应用场景。

森夏下士

关注

33
点赞
踩
56

收藏

觉得还不错? 一键收藏
0
评论
四万字解析python二级(看完一遍过）

在Python编程中，基础数据类型是构建程序的基础要素。
复制链接

扫一扫

四万字解析python二级(看完一遍过）

一、计算机二级Python考试分析及学习策略

二、Python编程入门：程序设计语言简介与Python语言特性

程序设计语言的发展历程

编译型与解释型语言

Python语言特点

Python编程的基本逻辑

IDLE使用简介

三、Python语言中的基本语法元素

1. 缩进

2. 冒号

3. 错误处理

4. 注释

5. 续行符

6. 标识符、变量与常量

7. 关键字与保留字

8. 数据类型

9. 表达式与运算符

10. 引用与导入模块

11. 分支语句与循环语句

12. 输入与输出

四、Python编程中的基本数据类型

（一）Python编程中的变量及其基本用法

（二）Python基础数据类型介绍

（三）Python中的数字类型及其运算

整数类型（int）

浮点数类型（float）

数值运算操作符

其他注意事项

（四）Python列表(List)的基本概念与操作详解

列表定义与特点

访问与修改列表元素

列表的属性和函数

长度获取

最小值与最大值

类型转换

列表操作方法

添加元素

合并列表

插入元素

清空列表

删除元素

删除特定值的所有实例

反转列表

复制列表

列表的扩展操作

（五）列表（List）基础教学与操作

列表的基本概念

列表元素的访问与修改

列表操作函数与方法

列表方法：

（六）字典数据类型详解

（七）数字与字符串进阶知识点

数字类型：复数

字符串：切片操作

（八）列表与字典的进阶知识点

列表切片及赋值

字典创建与嵌套

引用与复制

（九）元组与集合的基本概念

元组 (Tuple)

定义与特点

应用场景

特殊情况

集合 (Set)

定义与特点

创建集合的方法

常见集合操作

交集 (Intersection)

并集 (Union)

差集 (Difference)

对称差集 (Symmetric Difference)

实现对称差集的替代方法

五、程序的控制结构

（一）布尔表达式与逻辑运算符

布尔值与条件判断

逻辑运算符

AND (and)

OR (or)

NOT (not)

AND (`and`)

OR (`or`)

NOT (`not`)