python自学之《Python程序设计 （第3版）》——关于基础知识

全书共 13 章，此外，还包含两个附录。第 1 章到第 5 章介绍计算机与程序、编写简单程序、数字计算、对象和图形、字符串处理等基础知识。第 6 章到第 8 章介绍函数、判断结构、循环结构和布尔值等话题。第 9 章到第 13 章着重介绍一些较为高级的程序设计方法，包括模拟与设计、类、数据集合、面向对象设计、算法设计与递归等。附录部分给出了 Python快速参考和术语表。每一章的末尾配有丰富的练习，包括复习问题、讨论和编程联系等多种形式，帮助读者巩固该章的知识和技能。

第 1 章 计算机和程序 … 1
学习目标 … 1
1.1 通用机器 … 1
1.2 程序的力量 … 2
1.3 什么是计算机科学 … 2
1.4 硬件基础 … 3
1.5 编程语言 … 4
1.6 Python 的“魔法” … 6
1.7 Python 程序内部 … 10
1.8 混沌与计算机 … 12
1.9 小结 … 13
1.10 练习 … 14
复习问题 … 14
第 2 章 编写简单程序 … 17
学习目标 … 17
2.1 软件开发过程 … 17
2.2 示例程序：温度转换器 … 18
2.3 程序要素 … 19
2.3.1 名称 … 19
2.3.2 表达式 … 20
2.4 输出语句 … 22
2.5 赋值语句 … 23
2.5.1 简单赋值 … 23
2.5.2 赋值输入 … 24
2.5.3 同时赋值 … 26
2.6 确定循环 … 27
2.7 示例程序：终值 … 29
2.8 小结 … 31
2.9 练习 … 32
复习问题 … 32
第 3 章 数字计算 … 35
学习目标 … 35
3.1 数值数据类型 … 35
3.2 类型转换和舍入 … 38
3.3 使用 math 库 … 40
3.4 累积结果：阶乘 … 42
3.5 计算机算术的局限性 … 44
3.6 小结 … 46
3.7 练习 … 47
复习问题 … 47
第 4 章 对象和图形 … 52
学习目标 … 52
4.1 概述 … 52
4.2 对象的目标 … 53
4.3 简单图形编程 … 53
4.4 使用图形对象 … 56
4.5 绘制终值 … 60
4.6 选择坐标 … 64
4.7 交互式图形 … 66
4.7.1 获取鼠标点击 … 67
4.7.2 处理文本输入 … 68
4.8 graphics 模块参考 … 70
4.8.1 GraphWin 对象 … 70
4.8.2 图形对象 … 71
4.8.3 Entry 对象 … 74
4.8.4 显示图像 … 74
4.8.5 生成颜色 … 75
4.8.6 控制显示更新（高级） … 75
4.9 小结 … 76
4.10 练习 … 76
复习问题 … 76
第 5 章 序列：字符串、列表和文件 … 81
学习目标 … 81
5.1 字符串数据类型 … 81
5.2 简单字符串处理 … 84
5.3 列表作为序列 … 86
5.4 字符串表示和消息编码 … 87
5.4.1 字符串表示 … 87
5.4.2 编写编码器 … 88
5.5 字符串方法 … 89
5.5.1 编写解码器 … 89
5.5.2 更多字符串方法 … 92
5.6 列表也有方法 … 93
5.7 从编码到加密 … 94
5.8 输入/输出作为字符串操作 … 95
5.8.1 示例应用程序：
日期转换 … 95
5.8.2 字符串格式化 … 97
5.8.3 更好的零钱计数器 … 99
5.9 文件处理 … 99
5.9.1 多行字符串 … 100
5.9.2 文件处理 … 100
5.9.3 示例程序：批处理
用户名 … 103
5.9.4 文件对话框（可选） … 103
5.10 小结 … 105
5.11 练习 … 106
复习问题 … 106
第 6 章 定义函数 … 111
学习目标 … 111
6.1 函数的功能 … 111
6.2 函数的非正式讨论 … 112
6.3 带有函数的终值程序 … 115
6.4 函数和参数：令人兴奋的
细节 … 116
6.5 返回值的函数 … 119
6.6 修改参数的函数 … 122
6.7 函数和程序结构 … 126
6.8 小结 … 128
6.9 练习 … 129
复习问题 … 129
第 7 章 判断结构 … 133
学习目标 … 133
7.1 简单判断 … 133
7.1.1 示例：温度警告 … 133
7.1.2 形成简单条件 … 135
7.1.3 示例：条件程序执行 … 136
7.2 两路判断 … 137
7.3 多路判断 … 140
7.4 异常处理 … 142
7.5 设计研究：三者最大 … 144
7.5.1 策略 1：比较每个值和
所有其他值 … 145
7.5.2 策略 2：判断树 … 146
7.5.3 策略 3：顺序处理 … 147
7.5.4 策略 4：使用 Python … 148
7.5.5 一些经验 … 148
7.6 小结 … 149
7.7 练习 … 149
复习问题 … 149
第 8 章 循环结构和布尔值 … 153
学习目标 …153
8.1 for 循环：快速回顾 … 153
8.2 不定循环 … 154
8.3 常见循环模式 … 155
8.3.1 交互式循环 … 155
8.3.2 哨兵循环 … 156
8.3.3 文件循环 … 158
8.3.4 嵌套循环 … 160
8.4 布尔值计算 … 161
8.4.1 布尔运算符 … 161
8.4.2 布尔代数 … 163
8.5 其他常见结构 … 165
8.5.1 后测试循环 … 165
8.5.2 循环加一半 … 166
8.5.3 布尔表达式作为判断 … 166
8.6 示例：一个简单的事件循环 … 169
8.7 小结 … 172
8.8 练习 … 173
复习问题 … 173
第 9 章 模拟与设计 … 177
学习目标 … 177
9.1 模拟短柄壁球 … 177
9.1.1 一个模拟问题 … 177
9.1.2 分析与规格说明 … 178
9.2 伪随机数 … 178
9.3 自顶向下的设计 … 180
9.3.1 顶层设计 … 180
9.3.2 关注点分离 … 182
9.3.3 第二层设计 … 182
9.3.4 设计 simNGames … 183
9.3.5 第三层设计 … 184
9.3.6 整理完成 … 186
9.3.7 设计过程总结 … 188
9.4 自底向上的实现 … 188
9.4.1 单元测试 … 188
9.4.2 模拟结果 … 189
9.5 其他设计技术 … 190
9.5.1 原型与螺旋式开发 … 190
9.5.2 设计的艺术 … 191
9.6 小结 … 191
9.7 练习 … 192
复习问题 … 192
第 10 章 定义类 … 196
学习目标 … 196
10.1 对象的快速复习 … 196
10.2 示例程序：炮弹 … 197
10.2.1 程序规格说明 … 197
10.2.2 设计程序 … 197
10.2.3 程序模块化 … 199
10.3 定义新类 … 200
10.3.1 示例：多面骰子 … 201
10.3.2 示例：Projectile 类 … 203
10.4 用类数据处理 … 205
10.5 对象和封装 … 207
10.5.1 封装有用的抽象 … 207
10.5.2 将类放在模块中 … 208
10.5.3 模块文档 … 208
10.5.4 使用多个模块 … 210
10.6 控件 … 210
10.6.1 示例程序：掷骰
子程序 … 211
10.6.2 创建按钮 … 211
10.6.3 构建骰子类 … 213
10.6.4 主程序 … 215
10.7 动画炮弹 … 216
10.7.1 绘制动画窗口 … 217
10.7.2 创建 ShotTracker … 218
10.7.3 创建输入对话框 … 219
10.7.4 主事件循环 … 220
10.8 小结 … 221
10.9 练习 … 222
复习问题 … 222
第 11 章 数据集合 … 227
学习目标 … 227
11.1 示例问题：简单统计 … 227
11.2 应用列表 … 228
11.2.1 列表和数组 … 229
11.2.2 列表操作 … 229
11.2.3 用列表进行统计 … 231
11.3 记录的列表 … 235
11.4 用列表和类设计 … 237
11.5 案例分析：Python 计算器 … 241
11.5.1 计算器作为对象 … 241
11.5.2 构建界面 … 241
11.5.3 处理按钮 … 243
11.6 案例研究：更好的炮弹动画 … 246
11.6.1 创建发射器 … 246
11.6.2 追踪多次射击 … 248
11.7 无顺序集合 … 251
11.7.1 字典基础 … 251
11.7.2 字典操作 … 252
11.7.3 示例程序：词频 … 253
11.8 小结 … 257
11.9 练习 … 257
复习问题 … 257
第 12 章 面向对象设计 … 262
学习目标 … 262
12.1 OOD 的过程 … 262
12.2 案例研究：壁球模拟 … 263
12.2.1 候选对象和方法 … 264
12.2.2 实现 SimStats … 265
12.2.3 实现 RBallGame … 266
12.2.4 实现 Player … 267
12.2.5 完整程序 … 268
12.3 案例研究：骰子扑克 … 270
12.3.1 程序规格说明 … 271
12.3.2 识别候选对象 … 271
12.3.3 实现模型 … 272
12.3.4 基于文本的 UI … 275
12.3.5 开发 GUI … 277
12.4 OO 概念 … 282
12.4.1 封装 … 282
12.4.2 多态 … 283
12.4.3 继承 … 283
12.5 小结 … 284
12.6 练习 … 285
复习问题 … 285
第 13 章 算法设计与递归 … 287
学习目标 … 287
13.1 查找 … 287
13.1.1 简单的查找问题 … 287
13.1.2 策略 1：线性查找 … 288
13.1.3 策略 2：二分查找 … 288
13.1.4 比较算法 … 289
13.2 递归问题解决 … 290
13.2.1 递归定义 … 291
13.2.2 递归函数 … 292
13.2.3 示例：字符串反转 … 293
13.2.4 示例：重组词 … 294
13.2.5 示例：快速指数 … 295
13.2.6 示例：二分查找 … 296
13.2.7 递归与迭代 … 296
13.3 排序算法 … 298
13.3.1 天真的排序：选择
排序 … 298
13.3.2 分而治之：归并排序 … 299
13.3.3 排序比较 … 301
13.4 难题 … 303
13.4.1 汉诺依塔 … 303
13.4.2 停机问题 … 306
13.4.3 结论 … 308
13.5 小结 … 308
13.6 练习 … 309
复习问题 … 309
附录 A Python 快速参考 … 314
附录 B 术语表 … 323

解释和编译之间的区别在于，编译是一次性翻译。一旦程序被编译，它可以重复运行而不需要编译器或源代码。在解释的情况下，每次程序运行时都需要解释器和源代码。编译的程序往往更快，因为翻译是一次完成的，但是解释语言让它们拥有更灵活的编程环境，因为程序可以交互式开发和运行。

>>> ans = eval(input("Enter an expression: "))
Enter an expression: 3+4*5
>>> print(ans)
23
>>> 

  1 #A program to calculate the value of some change in dollars
  2 
  3 def main():
  4     print("Change Counter")
  5     print()
  6     print("Please enter the count of each coin type.")
  7     quarters = eval(input("Quarters: "))
  8     dimes = eval(input("Dimes: "))
  9     nickels = eval(input("Nickels: "))
 10     pennies = eval(input("Pennies: "))
 11     total = quarters * .25 + dimes * .10 + nickels *.05 + pennies * .01
 12     print()
 13     print("The total value of your change is", total)
 14 main()

>>> 10/3
3.3333333333333335
>>> 10.0/3.0
3.3333333333333335
>>> 10/5
2.0
>>> 10//3
3
>>> 10.0//3.0
3.0
>>> 10%3
1
>>> 

  1 # A program that compute the real roots of a quadratic equation.
  2 # Illustrates use of the math library. 
  3 # Note: This program crashes if the equation has no real roots.
  4 
  5 import math #Makes the math library available.
  6 
  7 def main():
  8     print("This program finds the real solutions to quadratic")
  9     print()
 10 
 11     a = float(input("Enter coefficient a: "))
 12     b = float(input("Enter coefficient b: "))
 13     c = float(input("Enter coefficient c: "))
 14 
 15     discRoot = math.sqrt(b * b -4 * a * c)
 16     root1 = (-b + discRoot) / (2 * a)
 17     root2 = (-b - discRoot) / (2 * a)
 18 
 19     print()
 20     print("The solutions are:", root1, root2)
 21 
 22 main()

>>> fact = 1
>>> for factor in [6,5,4,3,2,1]:
...     fact = fact * factor
...     print(fact)
... 
6
30
120
360
720
720
>>> for factor in [6,5,4,3,2]:
... 
KeyboardInterrupt
>>> for factor in [2,3,4,5,6]:
...     fact = fact * factor
...     print(fact)
... 
1440
4320
17280
86400
518400
>>> 
>>> fact = 1
>>> for factor in [2,3,4,5,6]:
...     fact = fact * factor
...     print(fact)
... 
2
6
24
120
720
>>> 

>>> 4.0 / 10.0 + 3.5 * 2
7.4
>>> 4.0 / 10.0 
0.4
>>> 10 % 4
2
>>> 10 % 4 + 6 / 2
5.0
>>> import math
>>> 20 // 3
6
>>> abs(4-20//3)**3
8
>>> sqrt(4.5-5.0) + 7 * 3
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'sqrt' is not defined
>>> math.sqrt(4.5-5.0) + 7 * 3
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: math domain error
>>> (math.sqrt(4.5-5.0)) + 7 * 3
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: math domain error
>>> sqrt(4.5-5.0) + 7 * 3
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'sqrt' is not defined
>>> 3*10 // 3 + 10 % 3
11
>>> 3**3
27
>>> 

>>> range(5)
range(0, 5)
>>> list(range(5))
[0, 1, 2, 3, 4]
>>> list(range(3,10))
[3, 4, 5, 6, 7, 8, 9]
>>> list(range(4, 13, 3))
[4, 7, 10]
>>> list(range(15, 5, -2))
[15, 13, 11, 9, 7]
>>> list(range(5, 3))
[]
>>> 

>>> for i in range(1, 11):
...     print(i*i)
... 
1
4
9
16
25
36
49
64
81
100

>>> for i in [1,3,5,7,9]:
...     print(i, ":", i**3)
... 
1 : 1
3 : 27
5 : 125
7 : 343
9 : 729
>>> 

>>> for j in range(0,y,x):
...     print(j, end=" ")
...     print(x+y)
... 
0 12
2 12
4 12
6 12
8 12

>>> for i in range(1,11):
...     ans = ans + i*i
...     print(i)
... 
1
2
3
4
5
6
7
8
9
10
>>> 

>>> round(314.159265, -1)
310.0
>>> -10 // 3
-4
>>> -10 % 3
2
>>> 10 // -3
-4
>>> 10 % -3
-2
>>> -10 // -3
3
>>>