《Python程序设计与算法基础教程》 - 江红、余青松 - 清华大学出版社 - 香港大書城

	登入帳戶　 \|　訂單查詢　 \|　購物車/收銀台(0)　\|　在線留言板　 \|　付款方式　 \|　運費計算　 \|　聯絡我們　 \|　幫助中心　\|　加入書簽
		會員登入新用戶登記

HOME

新書上架

暢銷書架

好書推介

2023年度TOP

臺灣用戶

品種：超過100萬種各類書籍/音像和精品，正品正價，放心網購，悭钱省心

服務：香港／台灣／澳門／海外

送貨：速遞／郵局／服務站

新書上架：簡體書繁體書
暢銷書架：簡體書繁體書
好書推介：簡體書繁體書

『簡體書』Python程序设计与算法基础教程

書城自編碼： 3006764
分類：簡體書→大陸圖書→教材→研究生/本科/专科教材
作者：江红、余青松
國際書號(ISBN)： 9787302466833
出版社：清华大学出版社
出版日期： 2017-07-01
版次： 1 印次： 1
頁數/字數： 399/648000
書度/開本： 32开釘裝：平装

售價：HK$ 85.6

我要買件

** 我創建的書架 **
未登入.

新書推薦：

《炙野（全2册）》
售價：HK$ 80.3

《女人的胜利》
售價：HK$ 57.4

《数据有道：数据分析+图论与网络+微课+Python编程（鸢尾花数学大系：从加减乘除到机器学习）》
售價：HK$ 273.7

《 500万次倾听：陪伤心的人聊聊》
售價：HK$ 55.2

《英国商业500年（见证大国崛起与企业兴衰，启迪未来商业智慧。）》
售價：HK$ 82.8

《万千心理·儿童心理治疗中的心智化：临床实践指导》
售價：HK$ 89.7

《自我囚禁的人：完美主义的心理成因与自我松绑（破除你对完美主义的迷思，尝试打破自我评价过低与焦虑的恶性循环）》
售價：HK$ 67.9

《周易》
售價：HK$ 45.8

建議一齊購買：

HK$ 187.1
《数据挖掘与分析概念与算法》

HK$ 114.6
《TensorFlow：实战Google深度学习框架》

HK$ 88.5
《Python数据分析实战》

HK$ 171.1
《Python网络数据采集》

HK$ 67.5
《数据结构与算法：Python语言描述》

HK$ 182.9
《机器学习实战【利用Python透析主流机器学习算法，配合日常》

編輯推薦：

內容簡介：

本教程集教材、练习册、上机指导于一体，基于Windows 10和Python 3.5.2构建Python开发平台，阐述Python语言的基础知识，以及使用Python语言的实际开发应用实例，具体内容包括：Python概述、Python语言基础、程序流程控制、常用内置数据类型、系列数据类型、输入和输出、错误和异常处理、函数、类和对象、模块和客户端、算法与数据结构基础、图形用户界面、图形绘制、数值日期和时间处理、字符串和文本处理、文件、数据库访问、网络和Web编程、多线程编程以及系统管理等。
本教程作者结合多年的程序设计、系统开发以及授课经验，由浅入深、循序渐进地介绍Python程序设计语言，让读者能够较为系统全面地掌握程序设计的理论和应用。
本教程可以作为高等学校各专业的计算机程序设计教材，同时也可作为广大程序设计开发者、爱好者的自学参考书。

第1章 Python概述1
1.1 Python语言概述1
1.1.1 Python语言简介1
1.1.2 Python语言的特点1
1.1.3 Python语言的应用范围2
1.2 Python语言版本和开发环境2
1.2.1 Python语言的版本2
1.2.2 Python语言的实现2
1.2.3 Python语言的集成开发环境3
1.3 下载和安装Python3
1.3.1 下载Python3
1.3.2 安装Python4
1.3.3 安装和管理Python扩展包4
1.4 使用Python解释器解释执行Python程序6
1.4.1 运行Python解释器6
1.4.2 运行Python集成开发环境7
1.5 使用文本编辑器和命令行编写和执行Python源文件程序8
1.5.1 编写Hello World程序9
1.5.2 Hello World程序（hello.py）源代码分析10
1.5.3 运行Python源代码程序10
1.5.4 命令行参数11
1.6 使用集成开发环境IDLE编写和执行Python源文件程序12
1.6.1 使用IDLE编写程序12
1.6.2 使用IDLE编辑程序13
1.7 在线帮助和相关资源13
1.7.1 Python交互式帮助系统13
1.7.2 Python文档16
1.7.3 Python官网17
1.7.4 Python扩展库索引（PyPI）17
复习题18
上机实践19
第2章 Python语言基础20
2.1 Python程序概述20
2.1.1 引例20
2.1.2 Python程序构成20
2.2 Python对象和引用21
2.2.1 Python对象概述21
2.2.2 使用字面量创建实例对象21
2.2.3 使用类对象创建实例对象22
2.2.4 数据类型22
2.2.5 变量和对象的引用22
2.2.6 Python是动态类型语言23
2.2.7 Python是强类型语言24
2.2.8 对象内存示意图24
2.2.9 对象的值比较（==）和引用判别（is）25
2.2.10 不可变对象（immutable）和可变对象（mutable）25
2.3 标识符及其命名规则26
2.3.1 标识符26
2.3.2 保留关键字27
2.3.3 Python预定义标识符27
2.3.4 命名规则27
2.4 变量和赋值语句28
2.4.1 变量的声明和赋值28
2.4.2 链式赋值语句28
2.4.3 复合赋值语句29
2.4.4 删除变量29
2.4.5 系列解包赋值29
2.4.6 常量30
2.5 表达式和运算符30
2.5.1 表达式的组成30
2.5.2 表达式的书写规则31
2.5.3 运算符概述31
2.5.4 Python运算符及其优先级31
2.6 语句32
2.6.1 Python语句32
2.6.2 Python语句的书写规则33
2.6.3 复合语句及其缩进书写规则33
2.6.4 注释语句34
2.6.5 空语句pass34
2.7 函数和模块34
2.7.1 函数的创建和调用34
2.7.2 内置函数35
2.7.3 模块函数35
2.7.4 函数API36
2.8 类和对象36
2.8.1 创建类对象36
2.8.2 实例对象的创建和调用37
2.9 模块和包37
复习题37
上机实践39
第3章程序流程控制41
3.1 顺序结构41
3.2 选择结构41
3.2.1 分支结构的形式42
3.2.2 单分支结构42
3.2.3 双分支结构43
3.2.4 多分支结构44
3.2.5 if语句的嵌套45
3.2.6 if语句典型示例代码46
3.2.7 选择结构综合举例47
3.3 循环结构48
3.3.1 可迭代对象48
3.3.2 range对象49
3.3.3 for循环49
3.3.4 while循环50
3.3.5 循环的嵌套51
3.3.6 break语句52
3.3.7 continue语句53
3.3.8 死循环（无限循环）54
3.3.9 else子句55
3.3.10 循环语句典型示例代码55
3.3.11 循环结构综合举例56
复习题57
上机实践60
第4章常用内置数据类型64
4.1 Python内置数据类型概述64
4.1.1 数值数据类型64
4.1.2 序列数据类型64
4.1.3 集合数据类型65
4.1.4 字典数据类型65
4.1.5 NoneType、NotImplementedType和EllipsisType65
4.1.6 其他数据类型65
4.2 int数据类型（任意精度整数）65
4.2.1 整型字面量66
4.2.2 int对象66
4.2.3 int对象的方法66
4.2.4 整数的运算67
4.3 float类型（有限精度浮点数）68
4.3.1 浮点类型字面量68
4.3.2 float对象68
4.3.3 float对象的方法68
4.3.4 浮点数的运算69
4.4 complex类型（复数）70
4.4.1 复数类型字面量70
4.4.2 complex对象70
4.4.3 complex对象属性和方法70
4.4.4 复数的运算70
4.5 bool数据类型（布尔逻辑值）71
4.5.1 布尔值字面量71
4.5.2 bool对象71
4.5.3 逻辑运算符72
4.6 str数据类型（字符串）73
4.6.1 字符串字面量73
4.6.2 字符串编码73
4.6.3 转义字符73
4.6.4 str对象74
4.6.5 str对象属性和方法74
4.6.6 字符串的运算75
4.6.7 对象转换为字符串75
4.6.8 字符串的格式化75
4.7 比较关系运算和条件表达式76
4.7.1 条件表达式76
4.7.2 关系和测试运算符77
4.8 算术运算符和位运算符78
4.8.1 算术运算符78
4.8.2 位运算符78
4.9 混合运算和数值类型转换79
4.9.1 隐式转换79
4.9.2 显式转换（强制转换）79
4.10 内置标准数学函数80
4.10.1 内置数学运算函数80
4.10.2 数制转换函数80
复习题81
上机实践84
第5章系列数据类型89
5.1 Python系列数据概述89
5.1.1 数组89
5.1.2 系列数据类型89
5.2 系列数据的基本操作90
5.2.1 系列的长度、最大值、最小值、求和90
5.2.2 系列的索引访问操作90
5.2.3 系列的切片操作91
5.2.4 系列的连接和重复操作92
5.2.5 系列的成员关系操作92
5.2.6 系列的比较运算操作93
5.2.7 系列的排序操作94
5.2.8 内置函数all和any94
5.2.9 系列拆封94
5.3 元组95
5.3.1 使用元组字面量创建元组实例对象95
5.3.2 使用tuple对象创建元组实例对象96
5.3.3 元组的系列操作96
5.4 列表96
5.4.1 使用列表字面量创建列表实例对象96
5.4.2 使用list对象创建元组实例对象97
5.4.3 列表的系列操作97
5.4.4 list对象的方法97
5.4.5 列表解析表达式98
5.5 字符串98
5.5.1 字符串的系列操作98
5.5.2 字符串编码99
5.5.3 字符串格式化99
5.6 字节系列102
5.6.1 bytes常量102
5.6.2 创建bytes对象102
5.6.3 创建bytearray对象103
5.6.4 bytes和bytearray的系列操作103
5.6.5 字节编码和解码104
复习题104
上机实践106
第6章输入和输出108
6.1 输入和输出概述108
6.2 命令行参数108
6.2.1 sys.argv与命令行参数108
6.2.2 argparse模块和命令行参数解析109
6.3 标准输入和标准输出函数110
6.3.1 输入和输出函数110
6.3.2 交互式用户输入111
6.3.3 运行时提示输入密码112
6.4 文件和文件对象112
6.4.1 文件对象和open函数112
6.4.2 文件的打开、写入、读取和关闭113
6.4.3 with语句和上下文管理协议113
6.5 标准输入、输出和错误流114
6.5.1 标准输入、输出和错误流文件对象114
6.5.2 读取任意长度的输入流115
6.5.3 标准输入、输出和错误流重定向115
6.6 重定向和管道116
6.6.1 重定向标准输出到一个文件117
6.6.2 重定向文件到标准输入117
6.6.3 管道118
6.6.4 过滤器119
复习题121
上机实践121
第7章错误和异常处理123
7.1 程序的错误123
7.1.1 语法错误123
7.1.2 运行时错误123
7.1.3 逻辑错误124
7.2 异常处理125
7.2.1 异常处理概述125
7.2.2 内置的异常类125
7.2.3 引发异常127
7.2.4 捕获处理异常机制概述128
7.2.5 Python虚拟机捕获处理异常128
7.2.6 使用tryexceptelsefinally语句捕获处理异常128
7.2.7 捕获异常的顺序129
7.2.8 finally块和发生异常后的处理130
7.2.9 自定义异常类130
7.3 断言处理131
7.3.1 断言处理概述131
7.3.2 assert语句和AssertionError类131
7.3.3 启用禁用断言132
7.4 程序的基本调试方法132
7.4.1 语法错误的调试133
7.4.2 运行时错误的调试133
7.4.3 逻辑错误的调试134
复习题134
上机实践135
第8章函数137
8.1 函数概述137
8.1.1 函数的基本概念137
8.1.2 函数的功能137
8.1.3 Python函数分类137
8.2 函数的声明和调用138
8.2.1 函数对象的创建138
8.2.2 函数的调用139
8.2.3 作为对象的函数140
8.2.4 Lamda表达式和匿名函数140
8.2.5 函数的副作用141
8.3 参数的传递141
8.3.1 形式参数和实际参数141
8.3.2 形式参数变量和对象引用传递142
8.3.3 传递不可变对象的引用142
8.3.4 传递可变对象的引用143
8.3.5 可选参数143
8.3.6 位置参数和命名参数144
8.3.7 可变参数145
8.3.8 强制命名参数145
8.3.9 参数类型检查146
8.4 函数的返回值146
8.4.1 return语句和函数返回值146
8.4.2 多条return语句147
8.4.3 返回多个值148
8.5 变量的作用域148
8.5.1 全局变量148
8.5.2 局部变量149
8.5.3 全局语句global150
8.5.4 非局部语句nonlocal151
8.5.5 类成员变量151
8.5.6 输出局部变量和全局变量151
8.6 递归函数152
8.6.1 递归函数的定义152
8.6.2 递归函数的原理153
8.6.3 递归函数需要注意的问题154
8.6.4 递归函数的应用：最大公约数154
8.6.5 递归函数的应用：汉诺塔155
8.7 内置函数的使用156
8.7.1 内置函数一览156
8.7.2 eval函数156
8.7.3 exec函数157
8.7.4 compile函数157
复习题157
上机实践159
第9章类和对象161
9.1 面向对象概念161
9.1.1 对象的定义161
9.1.2 封装161
9.1.3 继承161
9.1.4 多态性161
9.2 类对象和实例对象162
9.2.1 类对象162
9.2.2 实例对象162
9.3 属性163
9.3.1 实例属性163
9.3.2 类属性164
9.3.3 私有属性和公有属性164
9.3.4 @property装饰器165
9.3.5 特殊属性167
9.3.6 自定义属性167
9.4 方法168
9.4.1 实例方法168
9.4.2 静态方法169
9.4.3 类方法170
9.4.4 __init__方法（构造函数）和__new__方法171
9.4.5 __del__方法（析构函数）172
9.4.6 私有方法与公有方法173
9.4.7 方法重载173
9.5 继承174
9.5.1 派生类174
9.5.2 查看继承的层次关系175
9.5.3 类成员的继承和重写176
9.6 对象的特殊方法176
9.6.1 对象的特殊方法概述176
9.6.2 运算符重载与对象的特殊方法177
9.6.3 @functools.total_ordering装饰器179
9.6.4 __call__方法和可调用对象179
9.7 对象的引用、浅拷贝和深拷贝180
9.7.1 对象的引用180
9.7.2 对象的浅拷贝180
9.7.3 对象的深拷贝181
复习题181
上机实践183
第10章模块和客户端185
10.1 模块化程序设计的概念185
10.1.1 模块化程序设计185
10.1.2 模块的API185
10.1.3 模块的实现186
10.1.4 模块的客户端187
10.1.5 模块化程序设计的优越性187
10.2 模块的设计和实现188
10.2.1 模块设计的一般原则188
10.2.2 API设计188
10.2.3 创建模块188
10.2.4 模块的私有函数189
10.2.5 模块的测试代码190
10.2.6 编写模块文档字符串191
10.2.7 按字节编译的.pyc文件192
10.3 模块的导入和使用192
10.3.1 导入模块和使用模块192
10.3.2 导入模块中的成员192
10.3.3 重新加载模块193
10.3.4 动态代入模块193
10.4 包194
10.4.1 包的概念194
10.4.2 创建包194
10.4.3 包的导入和使用195
10.5 模块的导入顺序195
10.5.1 导入模块时的搜索顺序195
10.5.2 模块搜索路径sys.path196
10.5.3 dir内置函数197
10.6 命名空间与名称查找顺序198
复习题198
上机实践199
第11章算法与数据结构基础200
11.1 算法及其性能分析200
11.1.1 算法概述200
11.1.2 算法的时间复杂度分析200
11.1.3 增长量级201
11.1.4 算法的空间复杂度分析202
11.2 查找算法202
11.2.1 顺序查找法202
11.2.2 二分查找法204
11.2.3 Python语言提供的查找算法205
11.3 排序算法205
11.3.1 冒泡排序法205
11.3.2 选择排序法206
11.3.3 插入排序法207
11.3.4 归并排序法208
11.3.5 快速排序法210
11.3.6 Python语言提供的排序算法211
11.4 常用数据结构211
11.4.1 数据结构概述211
11.4.2 常用的数据结构概述212
11.4.3 Python的collections模块212
11.5 数组213
11.5.1 列表和数组213
11.5.2 array.array对象和数组213
11.6 栈和队列214
11.6.1 栈的实现：使用列表214
11.6.2deque对象215
11.6.3deque作为栈216
11.6.4deque作为队列216
11.7 集合217
11.7.1 集合的定义217
11.7.2 判断集合元素是否存在217
11.7.3 集合的运算：并集、交集、差集和对称差集218
11.7.4 集合的比较运算：相等、子集和超集218
11.7.5 集合的长度、最大值、最小值、元素和219
11.7.6 可变集合的方法219
11.8 字典（映射）220
11.8.1 对象的哈希值220
11.8.2 字典的定义220
11.8.3 字典的访问操作221
11.8.4 字典的视图对象221
11.8.5 判断字典键是否存在221
11.8.6 字典对象的长度和比较221
11.8.7 字典对象的方法222
11.8.8 defaultdict对象222
11.8.9 OrderedDict对象223
11.8.10 ChainMap对象223
11.8.11 Counter对象224
11.9 collections模块的其他数据结构226
11.9.1 namedtuple对象226
11.9.2 UserDict、UserList和UserString对象227
复习题227
上机实践230
第12章图形用户界面233
12.1 图形用户界面概述233
12.1.1 tkinter233
12.1.2 其他GUI库简介233
12.2 tkinter概述234
12.2.1 tkinter模块234
12.2.2 图形用户界面构成234
12.2.3 框架和GUI应用程序类235
12.2.4 tkinter主窗口236
12.3 几何布局管理器236
12.3.1 pack几何布局管理器237
12.3.2 grid几何布局管理器237
12.3.3 place几何布局管理器239
12.4 事件处理240
12.4.1 事件类型240
12.4.2 事件绑定240
12.4.3 事件处理函数241
12.5 常用组件242
12.5.1 Label242
12.5.2 LabelFrame242
12.5.3 Button243
12.5.4 Message244
12.5.5 Entry245
12.5.6 Text245
12.5.7 Radiobutton247
12.5.8 Checkbutton247
12.5.9 Listbox250
12.5.10 OptionMenu251
12.5.11 Scale253
12.5.12 Toplevel254
12.5.13 ttk子模块控件254
12.6 对话框255
12.6.1 通用消息对话框255
12.6.2 文件对话框256
12.6.3 颜色选择对话框257
12.6.4 通用对话框应用举例258
12.6.5 简单对话框259
12.7 菜单和工具栏260
12.7.1 创建主菜单260
12.7.2 创建上下文菜单262
12.7.3 菜单应用举例263
复习题265
上机实践266
第13章图形绘制268
13.1 Python绘图模块概述268
13.2 基于tkinter的图形绘制269
13.2.1 基于tkinter画布绘图概述269
13.2.2 创建画布对象269
13.2.3 绘制矩形270
13.2.4 绘制椭圆270
13.2.5 绘制圆弧271
13.2.6 绘制线条271
13.2.7 绘制多边形272
13.2.8 绘制字符串273
13.2.9 应用举例：函数图形273
13.3 基于turtle模块的海龟绘图274
13.3.1 海龟绘图概述274
13.3.2 turtle模块概述274
13.3.3 绘制正方形275
13.3.4 绘制多边形275
13.3.5 绘制圆形螺旋276
13.3.6 递归图形277
13.3.7 海龟绘图的应用实例278
13.4 基于Matplotlib模块的绘图279
13.4.1 Matplotlib模块概述279
13.4.2 安装Matplotlib模块279
13.4.3 使用Matplotlib模块绘图概述280
13.4.4 绘制函数曲线280
13.4.5 绘制多个图形281
13.4.6 绘制直方图282
复习题283
上机实践284
第14章数值日期和时间处理286
14.1 相关模块概述286
14.1.1 数值处理的相关模块286
14.1.2 日期和时间处理的相关模块286
14.2 math模块和数学函数286
14.2.1 math模块的API286
14.2.2 math模块应用举例289
14.3 cmath模块和复数数学函数290
14.4 random模块和随机函数291
14.4.1 种子和随机状态291
14.4.2 随机整数292
14.4.3 随机系列293
14.5 数值运算模块NumPy293
14.5.1 数值运算模块的基本使用293
14.5.2 创建数组294
14.5.3 处理数组295
14.5.4 数组应用举例295
14.6 日期和时间处理295
14.6.1 相关术语295
14.6.2 时间对象296
14.6.3 测量程序运行时间296
14.6.4 日期对象297
14.6.5 获取当前日期时间297
14.6.6 日期时间格式化为字符串298
14.6.7 日期时间字符串解析为日期时间对象298
复习题299
上机实践300
第15章字符串和文本处理303
15.1 相关模块概述303
15.1.1 字符串和文本处理的相关模块303
15.1.2 字符串处理概述的常用方法303
15.2 字符串处理的常用操作303
15.2.1 字符串的类型判断303
15.2.2 字符串大小写转换304
15.2.3 字符串的填充、空白和对齐304
15.2.4 字符串的测试、查找和替换305
15.2.5 字符串的拆分和组合305
15.2.6 字符串的翻译和转换306
15.2.7 字符串应用举例306
15.3 正则表达式307
15.3.1 正则表达式语言概述307
15.3.2 正则表达式引擎308
15.3.3 普通字符和转义字符308
15.3.4 字符类和预定义字符类309
15.3.5 边界匹配符309
15.3.6 重复限定符310
15.3.7 匹配算法：贪婪和懒惰310
15.3.8 选择分支311
15.3.9 分组和向后引用311
15.3.10 正则表达式的匹配模式313
15.3.11 常用正则表达式313
15.4 正则表达式模块re313
15.4.1 匹配和搜索函数313
15.4.2 匹配选项314
15.4.3 正则表达式对象314
15.4.4 匹配对象315
15.4.5 匹配和替换316
15.4.6 分割字符串316
15.5 正则表达式应用举例316
15.5.1 字符串包含验证316
15.5.2 字符串查找和拆分317
15.5.3 字符串替换和清除318
15.5.4 字符串查找和截取318
复习题319
上机实践320
第16章文件322
16.1 文件操作相关模块概述322
16.2 文本文件的读取和写入322
16.2.1 文本文件的写入322
16.2.2 文本文件的读取323
16.2.3 文本文件的编码324
16.3 二进制文件的读取和写入325
16.3.1 二进制文件的写入325
16.3.2 二进制文件的读取326
16.4 随机文件访问326
16.5 内存文件的操作328
16.5.1 StringIO和内存文本文件操作328
16.5.2 BytesIO和内存文本文件操作328
16.6 文件的压缩和解压缩329
16.7 CSV文件格式的读取和写入329
16.7.1 csv.reader对象和csv文件的读取330
16.7.2 csv.writer对象和csv文件的写入330
16.7.3 csv.DictReader对象和csv文件的读取331
16.7.4 csv.DictWriter对象和csv文件的写入332
16.7.5 csv文件格式化参数和Dialect对象332
16.8 os模块和文件访问334
16.8.1 文件描述符334
16.8.2 使用os模块提供的函数访问文件334
16.9 输入重定向和管道335
16.9.1 FileInput对象335
16.9.2 fileinput模块的函数336
16.9.3 输入重定向337
16.10 对象系列化338
16.10.1 对象系列化概念338
16.10.2 pickle模块和对象系列化338
复习题339
上机实践340
第17章数据库访问341
17.1 数据库基础341
17.1.1 数据库概念341
17.1.2 关系数据库341
17.2 Python数据库访问模块342
17.2.1 通用数据库访问模块342
17.2.2 专用数据库访问模块343
17.2.3 SQLite数据库和sqlite3模块343
17.3 使用sqlite3模块连接和操作SQLite数据库344
17.3.1 访问数据库的典型步骤344
17.3.2 创建数据库和表346
17.3.3 数据库表的插入、更新和删除操作346
17.3.4 数据库表的查询操作347
复习题347
上机实践348
第18章网络编程和通信349
18.1 网络编程的基本概念349
18.1.1 网络基础知识349
18.1.2 TCPIP简介349
18.1.3 IP地址和域名350
18.1.4 统一资源定位器URL351
18.2 基于socket的网络编程352
18.2.1 socket概述352
18.2.2 创建socket对象353
18.2.3 将服务器端socket绑定到指定地址上353
18.2.4 服务器端socket开始侦听354
18.2.5 连接和接收连接355
18.2.6 发送和接收数据355
18.2.7 简单TCP程序：Echo Server355
18.2.8 简单UDP程序：Echo Server357
18.2.9 UDP程序：Quote Server358
18.3 基于urllib的网络编程359
18.3.1 打开和读取URL网络资源359
18.3.2 创建Request对象359
18.4 基于http的网络编程360
18.5 基于ftplib的网络编程360
18.5.1 创建FTP对象361
18.5.2 创建FTP_TLS对象362
18.6 基于poplib和smtplib的网络编程363
18.6.1 使用poplib接收邮件363
18.6.2 使用smtplib发送邮件363
复习题364
上机实践365
第19章多线程编程367
19.1 线程处理概述367
19.1.1 进程和线程367
19.1.2 线程的优缺点367
19.2 创建和启动多线程368
19.2.1 使用start_new_thread函数创建线程368
19.2.2 使用Thread对象创建线程368
19.2.3 自定义派生于Thread的对象370
19.2.4 线程加入join370
19.2.5 用户线程和daemon线程371
19.3 线程同步373
19.3.1 线程同步处理373
19.3.2 基于原语锁（LockRLock对象）的简单同步373
19.3.3 基于条件变量（Condition对象）的同步和通信375
复习题377
上机实践378

第20章系统管理379
20.1 系统管理相关模块379
20.2 目录、文件和磁盘的基本操作379
20.2.1 创建目录379
20.2.2 临时目录和文件的创建379
20.2.3 切换当前工作目录380
20.2.4 目录内容列表380
20.2.5 文件通配符和glob.glob函数380
20.2.6 遍历目录和os.walk函数381
20.2.7 判断文件目录是否存在381
20.2.8 测试文件类型382
20.2.9 文件的日期及其大小382
20.2.10 文件和目录的删除382
20.2.11 文件和目录复制、重命名和移动383
20.2.12 磁盘的基本操作383
20.3 执行操作系统命令和运行其他程序383
20.3.1 os.system函数383
20.3.2 os.popen函数384
20.3.3 subprocess模块384
20.4 获取终端的大小385
20.5 文件压缩和解压缩386
20.5.1 shutil模块支持的压缩和解压缩格式386
20.5.2 make_archive和文件压缩386
20.5.3 unpack_archive函数和文件解压缩387
20.6 configparser模块和配置文件387
20.6.1 INI文件及INI文件格式387
20.6.2 ConfigParser对象和INI文件操作388
复习题389
上机实践390
附录复习题参考答案391
参考文献400

內容試閱：

程序设计是大专院校计算机、电子信息、工商管理等相关专业的必修课程。Python语言是一种解释型、面向对象的计算机程序设计语言，广泛用于计算机程序设计教学语言、系统管理编程脚本语言、科学计算等，特别适用于快速的应用程序开发。Python编程语言广受开发者的喜爱，并被列入LAMP（Linux、Apache、MySQL以及PythonPerlPHP），已经成为最受欢迎的程序设计语言之一。本教程集教材、练习册、上机指导于一体，基于Windows 10和Python 3.5.2构建Python开发平台，通过大量的实例，由浅入深、循序渐进地阐述Python语言的基础知识，以及使用Python语言的实际开发应用实例。具体内容包括：Python概述、Python语言基础、程序流程控制、常用内置数据类型、系列数据类型、输入和输出、错误和异常处理、函数、类和对象、模块和客户端、算法与数据结构基础、图形用户界面、图形绘制、数值日期和时间处理、字符串和文本处理、文件、数据库访问、网络和Web编程、多线程编程以及系统管理等。本教程各章节涉及的源程序代码和相关素材，以及供教师参考的教学电子文稿均可以通过清华大学出版社网站（www.tup.tsinghua.edu.cn）下载，也可以通过hjiang@cc.ecnu.edu.cn直接与作者联系。本教程由华东师范大学江红和余青松共同编写。由于时间和编者学识有限，书中不足之处在所难免，敬请诸位同行、专家和读者指正。编者 2017年3月

系列数据类型
系列数据类型（bytes、bytearray、list、str和tuple）是Python内置的组合数据类型，可以实现复杂数据的处理。
5.1Python系列数据概述
5.1.1数组
数组是一种数据结构，用于存储和处理大量的数据。将所有的数据存储在一个或多个数组中，然后通过索引下标访问并处理数组的元素，可实现复杂数据处理任务。
Python语言没有提供直接创建数组的功能，但可以使用其内置的系列数据类型（例如列表list），实现数组的功能。
5.1.2系列数据类型
系列数据类型是Python基础的数据结构，是一组有顺序的元素的集合。系列数据可以包含一个或多个元素（对象，元素也可以是其他系列数据），也可以是一个没有任何元素的空系列。
Python内置的系列数据类型包括：元组（tuple）、列表（list）、字符串（str）和字节数据（bytes和bytearray）。
元组也称为定值表，用于存储值固定不变的值表。例如：

s1=1,2,3
s1 #输出：1, 2, 3
s1[2] #输出：3

列表也称为表，用于存储其值可变的表。例如：

s2=[1,2,3]
s2[2]=4
s2 #输出：[1, 2, 4]

字符串是包括若干字符的系列数据，支持系列数据的基本操作。例如：

s3="abc"
s3="Hello, world!"
s3[：5]#字符串前5个字符。输出：''Hello''
字节系列数据是包括若干字节的序列。Python抓取网页时返回的页面，通常为UTF-8编码的字节序列。字节系列和字符串直接可以相互转换。例如：

s1=b"abc"
s1.decode"utf-8" #输出：''abc''
s2="百度"
s2.encode"utf-8" #输出：b''\xe7\x99\xbe\xe5\xba\xa6''
5.2系列数据的基本操作
5.2.1系列的长度、最大值、最小值、求和
通过内置函数len、max、min，可以获取系列的长度、系列中元素最大值、系列中元素最小值。内置函数sum可获取列表或元组中各元素之和；如果有非数值元素，则导致TypeError；对于字符串（str）和字节数据（bytes），也将导致TypeError。
【例5.1】系列数据的求和示例。

t1=1,2,3,4
sumt1#输出：10
t2=1,''a'',2
sumt2#TypeError： unsupported operand types for： ''int'' and ''str''
s=''1234''
sums#TypeError： unsupported operand types for： ''int'' and ''str''

【例5.2】系列的长度、最大值、最小值操作示例。

s=''abcdefg''
lens
7
maxs
''g''
mins
''a''
s2=''''
lens2
0
t=10,2,3
lent
3
maxt
10
mint
2
t2=
lent2
0
lst=[1,2,9,5,4]
lenlst
5
maxlst
9
minlst
1
lst2=[ ]
lenlst2
0
b=b''ABCD''
lenb
4
maxb
68
minb
65
b2=b''''
lenb2
0

5.2.2系列的索引访问操作
系列表示可以通过索引下标访问的可迭代对象。可以通过整数下标访问系列s的元素。

s[i]#访问系列s在索引i处的元素

索引下标从0开始，第1个元素为s[0]，第2个元素为s[1]，依此类推，最后一个元素为s[lens -1]。
如果索引下标越界，则导致IndexError；如果索引下标不是整数，则导致TypeError。例如：

s=''abc''
s[0]#输出：''a''
s[3]#IndexError： string index out of range
s[''a'']#TypeError： string indices must be integers

系列s的索引下标示意图如图5-1所示。

图5-1系列s的索引下标示意图
【例5.3】系列的索引访问示例。

s=''abcdef''
s[0]
''a''
s[2]
''c''
s[-1]
''f''
s[-3]
''d''
t=''a'',''e'',''i'',''o'',''u''
t[0]
''a''
t[1]
''e''
t[-1]
''u''
t[-5]
''a''
lst=[1,2,3,4,5]
lst[0]
1
lst
[1, 2, 3, 4, 5]
lst[2]=''a''
lst[-2]=''b''
lst
[1, 2, ''a'', ''b'', 5]
b=b''ABCDEF''
b[0]
65
b[1]
66
b[-1]
70
b[-2]
69

5.2.3系列的切片操作
通过切片操作，可以截取系列s的一部分。切片操作的基本形式为：

s[i：j] 或者 s[i：j：k]

其中，i为系列开始下标（包含s[i]）；j为系列结束下标（不包含s[j]）；k为步长。如果省略i，则从下标0开始；如果省略j，则直到系列结束为止；如果省略k，则步长为1。
注意，下标也可以为负数。如果截取范围内没有数据，则返回空元组；如果超过下标范围，不报错。
【例5.4】系列的切片操作示例。

s=''abcdef''
s[1：3]
''bc''
s[3：10]
''def''
s[8：2]
''''
s[：]
''abcdef''
s[：2]
''ab''
s[：：2]
''ace''
s[：：-1]
''fedcba''
t=''a'',''e'',''i'',''o'',''u''
t[-2：-1]
''o'',
t[-2：]
''o'', ''u''
t[-99：-5]

t[-99：-3]
''a'', ''e''
t[：：]
''a'', ''e'', ''i'', ''o'', ''u''
t[1：-1]
''e'', ''i'', ''o''
t[1：：2]
''e'', ''o''
lst=[1,2,3,4,5]
lst[：2]
[1, 2]
lst[：1]=[]
lst
[2,3, 4, 5]
lst[：2]
[2, 3]
lst[：2]=''a''
lst[1：]=''b''
lst
[''a'', ''b'']
del lst[：1]
lst
[''b'']
b=b''ABCDEF''
b[2：2]
b''''
b[0：1]
b''A''
b[1：2]
b''B''
b[2：2]
b''''
b[-1：]
b''F''
b[-2：-1]
b''E''
b[0：lenb]
b''ABCDEF''

5.2.4系列的连接和重复操作
通过连接操作符，可以连接两个系列（s1和s2），形成一个新的系列对象；通过重复操作符*，可以重复一个系列n次（n为正整数）。系列连接和重复操作的基本形式为：

s1 s2 或者 s*n或者 n *s

连接操作符和重复操作符*也支持复合赋值运算，即： =和*=。
【例5.5】系列的连接和重复操作示例。

s1=''abc''
s2=''xyz''
s1 s2
''abcxyz''
s1*3
''abcabcabc''
s1= s2
s1
''abcxyz''
s2 *= 2
s2
''xyzxyz''
t1=1,2
t2=''a'',''b''
t1 t2
1, 2, ''a'', ''b''
t1*2
1, 2, 1, 2
t1= t2
t1
1, 2, ''a'', ''b''
t2 *= 2
t2
''a'', ''b'', ''a'', ''b''
lst1=[1,2]
lst2=[''a'',''b'']
lst1 lst2
[1, 2, ''a'', ''b'']
2 *lst2
[''a'', ''b'', ''a'', ''b'']
lst1= lst2
lst1
[1, 2, ''a'', ''b'']
lst2 *=2
lst2
[''a'', ''b'', ''a'', ''b'']
b1=b''ABC''
b2=b''XYZ''
b1 b2
b''ABCXYZ''
b1*3
b''ABCABCABC''
b1 =b2
b1
b''ABCXYZ''
b2*=2
b2
b''XYZXYZ''

5.2.5系列的成员关系操作
可以通过下列方式之一判断一个元素x是否存在于系列s中。

xin s #如果为True，则表示存在
x not in s#如果为True，则表示不存在
s.countx#返回x在s（指定范围[start,end）中出现的次数
s.indexx[, i[, j]]#返回x在s（指定范围[i, j）中第一次出现的下标

其中，指定范围[i,j，从下标i（包括，默认为0）开始，到下标j结束（不包括，默认为lens）。
对于s.indexvalue, [start, [stop]]方法，如果找不到时，则导致ValueError。例如：

''To be or not to be, this is a question''.index''123''#ValueError： substring not found

【例5.6】系列中元素的存在性判断示例。

s=''Good, better, best!''
''o'' in s
True
''g'' not in s
True
s.count''e''
3
s.index''e'', 10
10
t=''r'', ''g'', ''b''
''r'' in t
True
''y'' not in t
True
t.count''r''
1
t.index''g''
1
lst=[1,2,3,2,1]
1 in lst
True
2 not in lst
False
lst.count1
2
lst.index3
2
b=b''Oh, Jesus!''
b''O'' in b
True
b''o'' not in b
True
b.countb''s''
2
b.indexb''s''
6

5.2.6系列的比较运算操作
两个系列支持比较运算符（、、==、!=、=、），字符串比较运算按顺序逐个元素进行比较。
【例5.7】系列的比较运算示例。

s1=''abc''
s2=''abc''
s3=''abcd''
s4=''cba''
s1 s4
False
s2
True
s1 == s2
True
s1 != s3
True
''a'' ''A''
True
''a'' = ''''
True
t1=1,2
t2=1,2
t3=1,2,3
t4=2,1
t1
True
t1
True
t1 == t3
False
t1 != t2
False
t1 = t3
False
t4 t3
True
s1=[''a'',''b'']
s2=[''a'',''b'']
s3=[''a'',''b'',''c'']
s4=[''c'',''b'',''a'']
s1
False
s1
True
s1==s2
True
s1!=s3
True
s1=s3
False
s4s3
True
b1=b''abc''
b2=b''abc''
b3=b''abcd''
b4=b''ABCD''
b1
False
b1
True
b1==b2
True
b1=b3
False
b3!=b4
True
b4b3
False

5.2.7系列的排序操作
通过内置函数sorted，可以返回系列的排序列表。通过类reversed构造函数，可以返回系列的反序的迭代器。内置函数sorted形式如下：

sortediterable, key=None, reverse=False#返回系列的排序列表

其中，key是用于计算比较键值的函数（带一个参数），例如：key=str.lower；如果reverse=True，则反向排序。
【例5.8】系列的排序操作示例。

s1=''axd''
sorteds1
[''a'', ''d'', ''x'']
s2=1,4,2
sorteds2
[1, 2, 4]
sorteds2,reverse=True
[4, 2, 1]
s3=''abAC''
sorteds3, key=str.lower
[''a'', ''A'', ''b'', ''C'']

5.2.8内置函数all和any
通过内置函数all和any，可以判断系列的元素是否全部和部分为True。函数形式如下：

alliterable#如果序列的所有值都为True，返回True；否则，返回False
anyiterable#如果序列的任意值为True，返回True；否则，返回False

例如：

any1, 2, 0
True
all[1, 2, 0]
False

5.2.9系列拆封
1．变量个数和系列长度相等
使用赋值语句，可以将系列值拆封，然后赋值给多个变量：

变量1, 变量2，，变量n= 系列或可迭代对象

变量个数和系列的元素个数不一致时，将导致ValueError。例如：

a, b = 1, 2
a, b #输出：1, 2
a, b, c = 1, 2#ValueError： need more than 2 values to unpack
data = 1001, ''张三'', 80, 79, 92
sid, name, scores = data
scores#输出：80, 79, 92
sid, name, chinese, math, english = data
math#输出：79

2．变量个数和系列长度不等
如果系列长度未知，可使用*元组变量，将多个值作为元组赋值给元组变量。一个赋值语句中，*变量只允许出现一次，否则导致SyntaxError。例如：

first, *middles, last = range10
middles#输出：[1, 2, 3, 4, 5, 6, 7, 8]
first, second, third, *lasts = range10
lasts#输出：[3, 4, 5, 6, 7, 8, 9]
*firsts, last3, last2, last1 = range10
firsts#输出：[0, 1, 2, 3, 4, 5, 6]
first, *middles, last = sorted[70, 85, 89, 88, 86, 95, 89] #去掉最高分和最低分
summiddleslenmiddles#计算去掉最高分和最低分后的平均值。输出：87.4

3．使用临时变量_
如果只需要部分数据，系列其他位置可以使用临时变量_。例如：

_, b, _ = 1, 2, 3
b#输出：2
record = ''Zhangsan'', ''szhang@abc.com'', ''021-62232333'', ''13912349876''
name, _, *phones = record
phones#输出：[''021-62232333'', ''13912349876'']
5.3元组
元组是一组有序系列，包含零个或多个对象引用。元组和列表十分类似，但元组是不可变的对象，即不能修改、添加或删除元组中的项目，但可以访问元组中的项目。
5.3.1使用元组字面量创建元组实例对象
使用元组字面量，可以创建元组实例对象。元组字面量采用圆括号中用逗号分隔的项目定义。圆括号可以省略。其基本形式如下：

x1, [x2, , xn] 或者 x1, [x2, , xn]

其中，x1、x2、、xn为任意对象。
【例5.9】使用元组字面量创建元组实例对象示例。

t1=1,2,3
t2=
t3=1,
i1=1
t4=''a'',''b'',''c''
t5=2.0,
printt1,t2,t3,t4,t5,i1
1, 2, 3 1, ''a'', ''b'', ''c'' 2.0, 1
注意，如果元组中只有一个项目时，后面的逗号不能省略，这是因为Python解释器把x1解释为x1，例如，1解释为整数1，1,解释为元组。
5.3.2使用tuple对象创建元组实例对象
也可以通过创建tuple对象来创建元组。其基本形式为：

tuple #创建一个空列表
tupleiterable#创建一个列表，包含的项目为可枚举对象iterable中的元素

【例5.10】使用tuple对象创建元组实例对象示例。

t1=tuple
t2=tuple"abc"
t3=tuple[1,2,3]
t4=tuplerange3
printt1,t2,t3,t4
''a'', ''b'', ''c'' 1, 2, 3 0, 1, 2
5.3.3元组的系列操作
元组支持系列的基本操作，包括索引访问、切片操作、连接操作、重复操作、成员关系操作、比较运算操作，以及求元组长度、最大值、最小值等。
【例5.11】元组的系列操作示例。

t1=1,2,3,4,5,6,7,8,9,10
lent1 #输出：10
maxt1 #输出：10
sumt1 #输出：55
5.4列表
列表是一组有序项目的数据结构。创建一个列表后，可以访问、修改、添加或删除列表中的项目，即列表是可变的数据类型。Python没有数组，可以使用列表代替。
5.4.1使用列表字面量创建列表实例对象
使用列表字面量，可以创建列表实例对象。列表字面量列表采用方括号中用逗号分隔的项目定义。其基本形式为：

[x1, [x2, , xn]]

【例5.12】使用列表字面量创建列表实例对象示例。

l1=[]
l2=[1]
l3=["a","b","c"]
printl1,l2,l3 #输出：[] [1] [''a'', ''b'', ''c'']
5.4.2使用list对象创建元组实例对象
也可以通过创建list对象来创建列表。其基本形式为：

list #创建一个空列表
listiterable#创建一个列表，包含的项目为可枚举对象iterable中的元素

書城介紹　 \|　合作申請　\|　索要書目　 \|　新手入門　\|　聯絡方式　 \|　幫助中心　\|　找書說明　 \|　送貨方式　\|　付款方式	香港用户　 \|　台灣用户　\|　海外用户

	megBook.com.hk
Copyright © 2013 - 2024 （香港）大書城有限公司　 All Rights Reserved.