目录
第 1 章 Python 概述 13
1.1Python 简介 13
1.2Python 的特点 14
1.3Python 解释器（Python Interpreter） 15
1.4安装 Python 解释器 15
上机实践 1：安装 Python 解释器和配置 Path 环境变量 15
场景 1：安装 Python 解释器（Python Interpreter） 15
场景 2：手工配置 Path 环境变量 18
上机实践 2：交互模式下运行 Python 代码 19
场景 1：通过 cmd 命令窗口启动 Python Shell 19
场景 2：Python Shell 与 Python 解释器的交互 20
场景 3：理解交互模式的特点 20
场景 4：退出 Python Shell（两种方法） 21
上机实践 3：运行 Python 程序（采用直接方式） 21
场景 1：准备工作 21
场景 2：使用记事本程序编写 Python 程序 22
场景 3：采用直接方式运行 Python 程序 22
场景 4：修改 Python 解释器解析 Python 程序的字符编码 23
场景 5：将文本文件中文本的字符编码修改为 UTF-8 24
场景 6：Python 解释器使用 GBK 码解析 UTF-8 编码的程序 25
场景 7：Python 解释器使用 UTF-8 码解析 GBK 编码的程序 25
上机实践 4：运行 Python 程序（采用间接方式） 25
上机实践 5：利用自省功能自学 Python 27
场景 1：查看 Python 会话上定义的所有对象 28
场景 2：查看对象的数据类型（交互模式下） 28
场景 3：查看对象的属性和方法 28
场景 4：查看对象的帮助信息 29
场景 5：查看 builtins 的相关信息 30
第 2 章 标识符和对象名 33
2.1标识符 33
2.1.1标识符的命名规则 33
2.1.2单下划线标识符“_”的妙用 33
2.2Python 内存优化机制 33
2.3对象名的管理 33
2.3.1使用赋值语句为对象命名 34
2.3.2使用 del 语句删除对象名 34
2.4对象和对象名间的关系总结 34
上机实践 1：认识保留字（也叫关键字） 35
场景 1：查看 Python 的保留字 35
场景 2：理解 sys.path 和 import 语句的关系 36
场景 3：修改 sys.path 的值（第 1 种方法） 37
场景 4：修改 sys.path 的值（第 2 种方法） 37
上机实践 2：理解 Python 的内存优化机制 37

场景 1：通过对象的内存地址理解 Python 的内存优化机制 1 37
场景 2：通过对象的内存地址理解 Python 的内存优化机制 2 38
上机实践 3：对象名的管理 39
场景 1：理解赋值语句的执行流程 39
场景 2：其他格式的赋值语句 40
场景 3：使用 del 语句删除对象名 40
第 3 章 初识内置数据类型 42
3.1常用的内置数据类型 42
3.2数字、布尔型数据和 None 42
3.2.1 数字 42
3.2.2布尔型数据（bool） 42
3.2.3None 42
3.3字符串 str 43
3.3.1字符串的特点 43
3.3.2转义字符 43
3.3.3字符串的索引操作 43
3.3.4字符串的切片操作 44
3.3.5格式化字符串 44
3.4元组 tuple 44
3.5列表 list 44
3.6集合 set 44
3.7字典 dict 45
3.8对象的拷贝 45
上机实践 1：认识数字、布尔型数据和 None 45
场景 1：认识整数 int 和浮点数 float 45
场景 2：认识布尔型数据 46
场景 3：None 对象的数据类型是 NoneType 46
上机实践 2：认识字符串 46
场景 1：认识字符串 str 46
场景 2：了解单行注释和多行注释的区别 47
场景 3：认识转义字符 47
场景 4：字符串的索引操作 48
场景 5：字符串的切片操作 48
场景 6：字符串不可变更 51
场景 7：格式化字符串 51
上机实践 3：认识元组 tuple 51
场景 1：普通元组、空元组和单元素元组 51
场景 2：元组的索引和切片 51
场景 3：元组不可变更 52
上机实践 4：认识列表 list 52
场景 1：普通列表、空列表 52
场景 2：列表的索引和切片 53
场景 3：列表可变更 53
上机实践 5：认识集合 set 53

场景 1：集合内的元素不可重复、无先后顺序 54
场景 2：空集合对象的创建 54
场景 3：集合内的元素不可变更 54
场景 4：集合的长度可变更 54
上机实践 6：认识字典 dict 54
场景 1：字典内元素的“键”不可重复 54
场景 2：字典内元素的“键”不可变更 54
场景 3：空字典对象的创建 54
场景 4：字典是可变更的 55
上机实践 7：对象的拷贝 55
场景 1：使用赋值语句“=”拷贝对象 55
场景 2：浅拷贝（借助切片实现） 56
场景 3：浅拷贝（借助 copy 模块的 copy 函数实现） 58
场景 4：深拷贝 58
上机实践 8：理解“Python 中一切皆对象” 59
第 4 章 运算符和数据类型转换 61
4.1运算符 61
4.1.1算术运算符 61
4.1.2比较运算符 61
4.1.3赋值运算符 61
4.1.4逻辑运算符 62
4.1.5成员运算符 62
4.1.6对象比较运算符 is 62
4.1.7条件运算符 62
4.2类型转换的必要性 62
4.3理解 True 和“真”、False 和“假” 63
4.4精简代码的技巧 63
上机实践 1：运算符 63
场景 1：算术运算符 63
场景 2：比较运算符 64
场景 3：成员运算符 64
场景 4：对象比较运算符 is 65
场景 5：条件运算符 65
场景 6：算术运算符的其它用途 65
上机实践 2：显式类型转换的必要性 66
场景 1：避免“TypeError”异常 66
场景 2：input 内置函数的使用 66
场景 3：实现一个简易版的整数加法器 67
上机实践 3：常用的类型转换函数 67
场景 1：将字符串'10.0'转换为整数 10 67
场景 2：将字符串、列表、集合、字典转换为元组 67
场景 3：将字符串、元组、集合、字典转换为列表 67
场景 4：将字符串、元组、列表、字典转换为集合 67
场景 5：将元组、列表转换为字典 67

场景 6：任意对象都可以转换为布尔型数据 68
场景 7：eval 函数的用法 68
场景 8：Python 表达式和 Python 语句的区别 68
上机实践 4：逻辑运算符 69
场景 1：逻辑运算符作用于 True 和 False 69
场景 2：逻辑运算符作用于普通对象 69
第 5 章 自定义函数 70
5.1代码块 70
5.2自定义函数的语法格式 71
5.3函数的生命周期 71
5.4命名空间（namespace） 71
5.4.1命名空间概述 72
5.4.2内部函数 72
5.4.3命名空间的 LEGB 规则 72
5.6形式参数 parameter 和实际参数 argument 73
5.7return 语句 73
5.8lambda 表达式 74
5.9组包和解包 74
5.10参数是可变更对象时的注意事项 74
上机实践 1：理解函数的生命周期 74
场景 1：准备工作 74
场景 2：函数的定义 74
场景 3：创建函数对象 74
场景 4：查看函数对象的信息 75
场景 5：调用函数对象 76
场景 6：删除函数对象 77
上机实践 2：理解命名空间 77
场景 1：理解内置命名空间与全局命名空间之间的关系 77
场景 2：理解全局命名空间与局部命名空间之间的关系 79
场景 4：理解内部函数以及命名空间的 LEGB 规则 80
场景 5：理解 global 关键字 81
场景 6：理解 nonlocal 关键字 81
场景 7：函数内对象名的生命周期 82
上机实践 3：理解形式参数 parameter 和实际参数 argument 82
场景 1：通过位置参数为形参赋值 82
场景 2：通过关键字参数为形参赋值 83
场景 3：通过默认值参数为形参赋值 83
上机实践 4：理解 return 语句 84
场景 1：结束函数的执行 84
场景 2：将函数的执行结果返回给调用者 84
上机实践 5：使用 lambda 表达式创建匿名函数对象 85
上机实践 6：理解组包和解包 85
场景 1：使用“*”解包元组或字典 85
场景 2：使用“*”组包 86

场景 3：使用“**”解包字典 86
场景 4：元组变长参数 87
场景 5：字典变长参数 87
场景 6：同时使用元组变长参数和字典变长参数 87
场景 7：调用函数时使用“*”或者“**”解包 88
上机实践 7：参数是可变更对象时的注意事项 88
场景 1：实参是不可变更对象 88
场景 2：实参是可变更对象 89
场景 3：默认值参数是可变更对象 89
第 6 章 控制语句 91
6.1if 语句 91
6.1.1不包含 else 子句的 if 语句 91
6.1.2包含 else 子句的 if 语句 91
6.1.3包含 elif 子句的 if 语句 92
6.2循环语句 92
6.2.1while 循环语句 92
6.2.2for 循环语句 93
6.2.3使用循环语句的建议 93
6.3其他控制语句 93
6.4强行终止程序的执行 94
6.5异常的处理 94
6.5.1常见的内置异常类型 95
6.5.2异常处理程序的完整语法格式 95
6.6控制语句中定义的对象名具有向外穿透性 96
上机实践 1：if 语句 96
场景 1：准备工作 96
场景 2：不包含 else 子句的 if 语句 97
场景 3：包含 else 子句的 if 语句 97
场景 4：包含 elif 子句的 if 语句 98
上机实践 2：不包含 else 子句的 while 循环语句 98
场景 1：使用 while 循环语句计算 1 100 的和 98
场景 2：使用 while 循环语句解决生活中的问题 99
上机实践 3：不包含 else 子句的 for 循环语句 100
场景 1：使用 for 循环语句计算 1 100 的和 100
场景 2：列表推导式 100
场景 3：生成器表达式 101
场景 4：集合推导式 101
场景 5：字典推导式 101
场景 6：使用 for 循环语句解决生活中的问题 102
上机实践 4：其他控制语句的使用 102
场景 1：认识循环控制语句 break 102
场景 2：使用 break 语句解决生活中的问题 103
场景 3：认识循环控制语句 continue 104
场景 4：认识 pass 语句 104

场景 5：循环语句中的 else 子句 104
上机实践 5：强行终止程序的执行 105
场景 1：exit()和 quit()的使用 105
场景 2：sys.exit()的使用 105
场景 3：exit()和 sys.exit()的使用区别 106
场景 4：os._exit()的使用 106
场景 5：os._exit()和 sys.exit()的使用区别 106
场景 6：将 exit()替换成 sys.exit() 107
上机实践 6：异常的处理 107
场景 1：认识 Python 解释器处理异常的默认行为 107
场景 2：手动抛出异常 107
场景 3：没有异常处理的程序是不健壮的 107
场景 4：编写异常处理程序增强程序的健壮性 108
场景 5：异常的处理 1 109
场景 6：异常的处理 2 109
场景 7：捕获异常并打印异常信息 110
场景 8：使用 next 函数和 StopIteration 异常遍历迭代器对象 110
第 7 章 自定义模块和导入语句 112
7.1模块概述 112
7.1.1自定义模块 112
7.1.2Python 包的必要性 112
7.2sys.path 的第 1 个元素的两种取值 113
7.3import 语句的 5 种常见用法 114
7.4模块的主次之分 114
7.4.1模块的 name 属性 114
7.4.2 主模块 114
7.4.3非主模块 114
7.4.4模块名和模块的 name 属性值间的关系 115
7.4.5模块的 name 属性在测试中的作用 115
7.5主程序存放位置的建议 115
7.6 总结 116
7.6.1import 语句总结 116
7.6.2Python 程序与 Python 模块间的关系总结 117
上机实践 1：认识自定义模块 117
场景 1：准备工作 117
场景 2：认识自定义模块 117
上机实践 2： init .py 程序的作用 118
场景 1：Python 包也是模块 118
场景 2：Python 程序的优先级高于命名空间包 119
场景 3：常规包的优先级高于 Python 程序 119
场景 4： init .py 程序的作用（1） 120
场景 5： init .py 程序的作用（2） 121
上机实践 3：import 语句的第 3 种用法 122
场景 1：准备工作 122

场景 2：import 语句的第 3 种用法 122
场景 3：import ... as ... 的使用 123
场景 4：import 语句第 3 种用法的注意事项 124
上机实践 4：import 语句的第 4 种和第 5 种用法 124
场景 1：import 语句的第 4 种用法 124
场景 2：import 语句的第 5 种用法 125
上机实践 5：Python 程序存在主模块和非主模块两种身份 125
场景 1：准备工作 125
场景 2：Python 程序存在主模块和非主模块两种身份 126
场景 3：理解 sys.path 的第 1 个元素的两种取值 127
上机实践 6：模块的 name 属性在测试中的作用 127
场景 1：准备工作 127
场景 2：在 Python Shell 上调用自定义函数 128
场景 3：在被测程序中调用自定义函数 128
场景 4：将测试代码写在另一个程序中（1） 129
场景 5：将测试代码写在另一个程序中（2） 129
场景 6：重温带 from 的 import 语句 130
上机实践 7：主程序建议存放在项目根目录下 130
第 8 章 项目实战：学生管理系统的实现（列表和字典篇） 133
8.1元组对象 133
8.2集合对象 133
8.3列表对象 133
8.4字典对象 134
上机实践 1：元组的应用 134
上机实践 2：集合的应用 134
场景 1：集合与集合之间的运算（原集合不变） 134
场景 2：以元素为单位更新集合 135
场景 3：以集合为单位更新集合 135
上机实践 3：列表的应用 136
场景 1：列表对象的常用方法 136
场景 2：采用 MVC 分层思想设计学生管理系统 137
场景 3：使用列表实现学生管理系统 137
上机实践 4：字典的应用 141
场景 1：字典的 dict()构造方法 141
场景 2：字典常用的方法 141
场景 3：使用字典实现学生管理系统 142
第 9 章 项目实战：字符串的处理与格式化 146
9.1字符串的处理 146
9.2字符串的格式化 147
上机实践 1：准备工作 147
上机实践 2：字符串的处理 148
上机实践 3：字符串的格式化 149
场景 1：%字符串格式化 149
场景 2：str.format()方法 149

场景 3：str.format_map(mapping)方法 150
场景 4：格式化字符串（f-string） 150
上机实践 4：字符串的处理（综合） 151
场景 1：统计段落数 151
场景 2：筛选反义词 151
场景 3：统计词频 151
场景 4：绘制词云 152
场景 5：数据清洗 153
第 10 章 为什么面向对象编程 154
10.1从认知现实世界的角度理解面向对象编程 154
10.1.1人类认知现实世界的过程 154
10.1.2计算机管理现实世界的过程 154
10.2从避免代码冗余的角度理解面向对象编程 155
10.2.1结构化编程 155
10.2.2面向对象编程 156
10.2.3理解类和对象之间的关系 157
10.3理解需求的重要性 158
10.4知识汇总 158
10.4.1现实世界 VS 计算机世界知识汇总 158
10.4.2结构化编程 VS 面向对象编程知识汇总 158
第 11 章 面向对象编程基础知识 161
11.1定义类的语法格式 161
11.2类的定义、模板对象和实例化对象间的关系 161
11.2.1类的定义、模板对象和实例化对象间的关系 161
11.2.2函数和方法的关系 162
11.2.3查看模板对象和实例化对象的内部结构 162
11.2.4访问模板对象和实例化对象的内部结构 162
11.3构造方法的构成 163
11.3.1 new 方法的语法格式 163
11.3.2 init 方法的语法格式 163
11.4对象的属性和方法 163
11.4.1实例属性和实例方法 163
11.4.2类方法和静态方法 163
11.4.3 类属性 164
11.5方法的链式调用 164
11.6 小结 164
上机实践 1：类的定义、模板对象和实例化对象间的关系 166
场景 1：准备工作 166
场景 2：类的定义用于创建模板对象 167
场景 3：模板对象用于创建实例化对象 167
场景 4：查看模板对象和实例化对象的内部结构 168
场景 5：类的定义不能决定模板对象的内部结构 170
场景 6：模板对象不能决定实例化对象的内部结构 171
场景 7：属性的命名空间 171

场景 8：函数和方法的关系 173
上机实践 2：构造方法、实例属性和实例方法 173
场景 1： init 方法用于定义实例属性 173
场景 2：def 语句用于定义实例方法 174
场景 3：理解 new 方法的工作流程 176
上机实践 3：类方法和静态方法 177
场景 1：使用“@classmethod”装饰器定义类方法 177
场景 2：使用“@staticmethod”装饰器定义静态方法 179
上机实践 4：类属性的应用 181
场景 1：类属性的应用 181
场景 2：重温“属性的命名空间” 182
上机实践 5：方法的链式调用 182
第 12 章 文件管理和路径管理 184
12.1文件、目录和路径 184
12.1.1文件管理概述 184
12.1.2文件的分类 184
12.1.3文本文件的分类 184
12.1.4目录和路径 184
12.1.5绝对路径和相对路径 185
12.1.6路径管理概述 186
12.2文件管理 186
12.2.1理解打开文件 186
12.2.2理解读文件和写文件 187
12.2.3理解刷新文件 188
12.2.4理解关闭文件 188
12.3文件管理知识汇总 188
12.4使用 pathlib 管理文件路径 189
上机实践 1：文件管理和路径管理基础知识 189
场景 1：准备工作 189
场景 2：查看 Python Shell 的当前工作目录 189
场景 3：修改 Python Shell 的当前工作目录 190
场景 4：查看 Windows 的首选字符编码 190
上机实践 2：以“写”模式打开文本文件 190
场景 1：创建文件和打开文件的二合一操作 190
场景 2：查看文件句柄的状态信息 191
场景 3：写文件和 flush 操作 192
场景 4：写文件和 close 操作 193
场景 5：查看文件句柄的数据类型 194
场景 6：制作一个 Unicode 字符生成器 194
上机实践 3：以“读”模式打开文本文件 195
场景 1：通过迭代文件句柄的方法读文件 195
场景 2：readline 方法只读取一行 196
场景 3：使用 read 方法读文件 197
场景 4：readlines 方法以“行”为单位读取全部内容 197

上机实践 4：追加模式和排他写模式 198
场景 1：以追加模式打开文本文件 198
场景 2：以排他写模式打开文本文件 198
上机实践 5：关闭文件的正确方法 198
场景 1：错误的代码片段 198
场景 2：不规范的代码片段 199
场景 3：改进后的代码仍然不规范 199
场景 4：较为规范的代码片段 199
场景 5：最为规范的代码片段 199
场景 6：with 上下文管理的综合练习 200
上机实践 6：pathlib 模块的 Path 类的使用 201
场景 1：认识 pathlib 模块 201
场景 2：创建 Path 路径对象和拼接 Path 路径对象 201
场景 3：Path 路径对象的属性和方法 202
场景 4：查看计算机上真实存在的文件路径 203
场景 5：遍历路径 204
场景 6：查看文件（目录）的基本信息 204
场景 7：创建目录 205
场景 8：移动文件（或目录）和重命名文件（或目录） 205
场景 9：删除文件和目录 206
场景 10：创建文件、打开文件、读写文件 206
第 13 章 项目实战：学生管理系统的实现（JSON、CSV 和 pickle 篇） 208
13.1序列化和持久化 208
13.2json 模块的使用 208
13.2.1JSON 内置的数据类型 209
13.2.2json 模块的序列化和持久化方法 209
13.2.3内存中的对象和 JSON 文本数据相互转换 210
13.3csv 模块的使用 210
13.3.1列表对象 CSV 文本文件 211
13.3.2字典对象 CSV 文本文件 212
13.4pickle 模块的使用 213
13.5 总结 213
上机实践 1：json 模块的使用 213
场景 1：准备工作 213
场景 2：认识 json 模块 213
场景 3：JSON 字符串反序列化为内存中的对象 214
场景 4：内存中的对象序列化为 JSON 字符串 215
场景 5：内存中的对象持久化到 JSON 文本文件 215
场景 6：JSON 文本文件反持久化为 Python 对象 216
场景 7：使用 JSON 文本文件和列表实现学生管理系统 217
场景 8：使用 JSON 文本文件和字典实现学生管理系统 220
上机实践 2：csv 模块的使用 223
场景 1：认识 csv 模块 223
场景 2：使用 csv.writer 持久化列表对象到 CSV 文本文件 225

场景 3：使用 csv.reader 遍历 CSV 文本文件 226
场景 4：使用 csv.DictWriter 持久化字典对象到 CSV 文本文件 226
场景 5：使用 csv.DictReader 遍历 CSV 文本文件 227
场景 6：使用 CSV 文本文件和列表实现学生管理系统 227
场景 7：使用 CSV 文本文件和字典实现学生管理系统 230
上机实践 3：pickle 模块的使用 234
场景 1：认识 pickle 模块 234
场景 2：使用 pickle 实现对象的序列化和反序列化 234
场景 3：使用 pickle 模块实现对象的持久化和反持久化 235
场景 4：使用 pickle 二进制文件和列表实现学生管理系统 236
场景 5：使用 pickle 二进制文件和字典实现学生管理系统 237
第 14 章 项目实战：学生管理系统的实现（Web 篇） 238
14.1Web 开发概述 238
14.2Bottle 概述 238
14.3初识 FORM 表单 239
14.3.1表单标签 239
14.3.2表单控件 239
14.3.3表单按钮 240
上机实践 1：初识 Bottle 和认识 GET 请求 241
场景 1：准备工作 241
场景 2：快速上手 Bottle 241
场景 3：认识 GET 请求 243
场景 4：获取 GET 请求中的请求参数 244
上机实践 2：认识 POST 请求 244
场景 1：发送 GET 请求的 FORM 表单 245
场景 2：发送 POST 请求的 FORM 表单 246
场景 3：获取 POST 请求 FORM 表单中的请求参数 247
上机实践 3：Bottle 内置模板引擎的使用 247
场景 1：初识 SimpleTemplate 模板引擎 247
场景 2：在模板文件中处理 Python 对象 248
场景 3：认识 table 表格标签 250
上机实践 4：学生管理系统的实现（Web 篇） 250
场景 1：准备工作 251
场景 2：student_route.py 程序的实现 251
场景 3：index.txt 首页的实现 253
场景 4：edit.txt 学生编辑页面的实现 254
场景 5：主程序 main.py 的实现 255
场景 6：测试 255
第 15 章 项目实战：学生管理系统的实现（数据库篇） 257
15.1SQLite 概述 257
15.2数据库和数据库表 257
15.3SQLite 数据类型 257
15.4创建数据库表结构 258
15.5表记录的操作 258

上机实践 1：使用 sqlite3 模块操作 SQLite 数据库 259
场景 1：准备工作 259
场景 2：创建并连接数据库 259
场景 3：获取游标对象 260
场景 4：创建数据库表 260
场景 5：提交事务（commit） 261
场景 6：释放资源 261
场景 7：向数据库表添加记录 261
场景 8：回滚事务（rollback） 262
场景 9：表记录的检索（检索所有记录） 263
场景 10：表记录的检索（带有 where 语句） 263
场景 11：修改数据库表的记录 264
场景 12：删除数据库表的记录 264
场景 13：认识 SQL 语句的“？”占位符 264
上机实践 2：基于 Web 学生管理系统的实现（数据库篇） 265
第 16 章 拓展知识 269
16.1认识字符和字符编码 269
16.1.1十进制数和二进制数 269
16.1.2ASCII 编码表和 ASCII 字符集 269
16.1.3十六进制数 270
16.1.4字符编码表 270
16.1.5 字符集 270
16.1.6Unicode 编码表 271
16.1.7实现 Unicode 编码表的字符集 271
16.1.8UTF-8 流行的原因 272
16.1.9Python 字符串弃用 UTF-8 的原因 272
16.1.10理解字符编码和字符解码 273
上机实践 1：通过文本文件认识字符和字符编码 273
上机实践 2：通过 Python 代码认识字符和字符编码 277
16.2使用 IDLE 开发 Python 程序 281
上机实践 3：使用 IDLE 开发 Python 程序 282
16.3可迭代对象和迭代器对象 284
上机实践 4：可迭代对象和迭代器对象 284
16.4生成器函数和生成器对象 288
上机实践 5：生成器函数和生成器对象 289
16.5pip 包管理工具的使用 290
上机实践 6：pip 包管理工具的使用 291
16.6Python 中的标点符号 293
16.7os 模块和 pathlib 模块的对比 295