第一章：程序设计基本方法

计算机与程序设计

计算机是根据指令操作数据的设备
计算机发展参照摩尔定律，表现为指数形式

编译和解释

计算机执行源程序两种方式：编译和解释
编译：将源代码一次性转换成目标代码的过程。执行编译过程的程序叫编译器(compiler)。
解释：将原代码逐条转换成目标代码同时逐条运行的过程。执行解释过程的程序叫解释器(interpreter)。
静态语言：使用编译执行的编程语言(C/C++,java)
脚本语言：使用解释执行的编程语言(Python,JavaScript，PHP)

程序的基本写法

IPO：
input输入:文件输入、控制台输入、交互输入、内部参数输入等。
process处理(主要逻辑)：算法（灵魂）
output输出：控制台、文件、网络、操作系统内部变量等输出。

计算机编程

能够训练思维：

编程体现一种抽象交互、自动化执行的思维方式
计算思维：区分逻辑思维和实证思维的第三种思维模式。

实例1 --温度转换

题目本身简单，但学会这种思维，其他常见的"转换"问题解决方法同理。

Python程序语法元素分析

程序的格式框架

python中用"缩进"表达程序的语法框架，表达代码间包含关系的唯一手段
注释：用于提高代码可读性的辅助文字，不被执行。

命名与保留字

变量：用来保存和表示数据的占位符号，变量采用标识符（名字）来表示。
命名：数字字母下划线。
“注意”：大小写敏感，数字不能放开头，不与保留字同。
python中共有33个保留字，查询方法：

import keyword
print(keyword.kwlist)

数据类型

字符串：由0个或多个字符组成的"有序"字符序列。# 有序–>可以索引、切片
整数：数学中的整数
浮点数：数学中的实数，带有小数点部分
列表：由0个或多个数据组成的"有序"序列

补充

字符串的使用，使用[ ]获取一个或多个字符

法（1）索引：返回字符串中单个字符 <字符串>[M] ,如TempStr[0]为串的第0个字符，TempStr[-1]为串的最后一个字符

法（2）切片：返回字符串中子串 <字符串>[M:N]，注意子串是第M个字符开始到第N个之前的字符（不包含第N个字符）

评估函数eval()

是去掉参数最外侧引号并执行余下语句的函数，引号不区分单引号’ '和双引号" "

如：eval(“1”)执行结果为1；eval(’“1+2”’)执行结果为’1+2’；eval(‘print(“Hello”)’)执行print(“Hello”)语句，结果为Hello

字符串序号分正向和反向

如：C36摄氏温度向华氏温度转化时，需要跳过字符C，从第1个字符开始转化，直到最后一个字符，切片操作为[1:]，’ : '意为到最后一个字符

语句与函数

赋值语句
分支语句
函数

Python程序的输入输出

input（）控制台输入
print（）控制台输出，格式化
注：这两兄弟，在控制台显示的时候，一个添加引号形成字符串，一个将字符串自动去掉引号。
补充："eval()"去掉参数最外侧引号并执行余下语句的函数

例子
在这里插入图片描述

第二章 Python基本图形绘制

2.1 深入理解Python语言

2.1.1计算机技术的演进

1946-1981：计算机系统结构时代（35年）：
1981-2008：网络和视窗时代（27年）
2008-2016：复杂信息系统时代（8年）
2016- ：人工智能时代

计算能力问题–>交互问题–>数据问题–>人类的问题

2.1.2编程语言的多样初心

C: 性能
Java：跨平台
C++：大规模程序
VB：桌面应用
Python：计算时代演进的选择

Python语言的特点

通用语言
脚本语言
开源、跨平台、多模型语言

C/C++：python归python ，c归c
Java：针对特定开发和岗位需求
HTML/CSS/JS：不可替代的前端技术，全栈能力
其他语言： R/Go/Matlab等，特定领域
工具决定思维：关注工具变革的力量！

超级语言的诞生

机器语言 --> 代码直接执行，与CPU有关
汇编语言 --> 助记符，汇编器，与CPU有关
高级语言 --> 编译器，与CPU无关
超级语言 --> 整合已有程序，庞大计算生态

== python是唯一的超级语言！ ==

2.2 实例2：Python蟒蛇绘制

== import turtle == 导入海归绘图库

“举一反三：”

Python蟒蛇绘制问题是各类图形绘制问题的代表
–圆形绘制、五角星绘制、国旗绘制、机器猫绘制…

2.3 模块1：turtle库的调用

2.3.1 turtle库基本介绍

--注：turtle库是turtle绘图体系的python实现
--1969年诞生，是python标准库之一，入门级图形绘制函数库
--Python计算生态 = 标准库 + 第三方库
-库Library、包Package、模快Module，统称模块

2.3.2 turtle绘图窗体布局

turltle.setup(width, height, startx, starty)
--注：-	setup()设置窗体大小及位置4个参数后两个可选，不选则默认在窗口的正中间，setup（）不是必须的

2.3.3 turtle空间坐标体系

–1)绝对坐标：和数学中的坐标系（象限）知识相同
–turtle.goto(x,y)

–2)海龟坐标：后退<–>前进；左侧<–>右侧

–3)空间坐标体系：turtle.bk(d),turtle.fd(d),burtle.circle(r,angle)

2.3.4 turtle角度坐标体系

--1)绝对角度：0/360,90/-270,180/-180,270/-90
--turtle.seth(angle):改变海龟行进方向，angle为绝对度数，只改变方向不前进。--2)海龟角度：turtle.left(angle),turtle.right(angle)

2.3.5 RGB色彩体系

--RGB指 红 蓝 绿 组合
--RGB整数值，小数值
--turtle.colormode(mode),默认小数值mode = 1 表示rgb小数值模式mode = 255 表示rgb整数值模式

2.4 turtle程序语法元素分析

2.4.1 库引用和 import

import turtle
turtle. 格式：<a>.<b>()
<库名>.<函数名>(<函数参数>)
或 <库别名>.<函数名>(<函数参数>)

2.4.2 画笔控制函数

画笔操作后一直有效，一般成对出现

turtle.penup() 别名 turtle.pu()
抬起画笔，海龟在飞行,飞行的轨迹不在画布上面显示
turtle.pendown()，别名 turtle.pd()
落下画笔，海龟在爬行

画笔设置后一直有效，直至下次重新设置

turtle.pensize(width) 别名 turtle.width(width)
画笔宽度，海龟的腰围
turtle.pencolor(color) color为颜色字符串或r,g,b值
画笔颜色，海龟在涂装
pencolor(color)的color可以有三种形式

颜色字符串：turtle.pencolor(“purple”)
RGB的小数值：turtle.pencolor(0.63, 0.13, 0.94)
RGB的元组值：turtle.pencolor((0.63,0.13,0.94))

2.4.3 运动控制函数

控制海龟行进：走直线 & 走曲线

turtle.forward(d) 别名 turtle.fd(d）
向前行进，海龟走直线
d: 行进距离，可以为负数
turtle.circle(r, extent=None)
根据半径r绘制extent角度的弧形

r: 默认圆心在海龟左侧r距离的位置
extent: 绘制角度，默认是360度整圆

2.4.4 方向控制函数

turtle.setheading(angle) 别名： seth(angle)
改变行进方向，海龟走角度
turtle.left(),turtle.right()

在这里插入图片描述

range()函数

产生循环计数序列
range(N)产生 0 到 N-1的整数序列，共N个
range(M,N)产生 M 到 N-1的整数序列，共N-M个

第三章基本数据类型

3.1 数字类型及操作

--3.1.1整数类型：与数学中概念一致，+|-均可，无范围限制
--pow(x,y)函数
--3.1.2 4种进制表示形式：
十进制，二进制(0b,0B开头)，八进制(0o,0O开头)，十六进制(0x,0X)--3.1.3浮点数类型：浮点数范围和小数精度都存在限制，但常规计算可以忽略
浮点数间运算存在不确定尾数，发生在10E-16左右，不是bug
-- round(x,d):对x四舍五入，d是小数截取位数。用于浮点数间运算及比较。-- 浮点数采用科学计数法表示<a>e<b>表示 a*10b例如：4.3e-3 值为0.0043    9.6E5 值为960000.0--3.1.4复数类型：z = 1.23e-4+5.6e+89jZ.real获得实部，Z.imag获得虚部

–3.1.5数值运算操作符：类型间可以混合运算，生成结果为“最宽”类型。
在这里插入图片描述

–数值运算函数：
– abs(x) 绝对值
– divmod(x,y) => 同时输出商和余数
– pow(x,y[,z]) => 幂余，(x**y)%z
– round(x[,d]) => 四舍五入，d小数位数，默认为0
– max()最大值
– min()最小值
– int(x)
– float()
– complex(x)

3.2 实例3：天天向上的力量

略

GRIT，坚毅，对长期目标的持续激情及持久耐力
GRIT是获得成功最重要的因素之一，牢记天天向上的力量

3.3 字符串类型及操作

3.3.1 字符串类型的表示

– 单引号，双引号；三引号

– 索引 [M]
– 切片 [M,N,K]
在这里插入图片描述

str[::1] 的结果是012345678910

– 转义字符：\b回退，\n换行，\r回车（光标移到本行行首）
在这里插入图片描述

3.3.2 字符串操作符

– + 字符串拼接
– * 复制n次字符串
– in
在这里插入图片描述

3.3.3 字符串处理函数

– len(x)
– str(x) 任意类型所对应的字符串形式
– hex(x)或oct(x) 整数x的十六进制或八进制小写形式字符串
– chr(u) u为Unicode编码，返回其对应的字符
– ord(x) x为字符，返回其对应的Unicode编码

补充
若不想使print换行，添加end=""（空），
如print(t [eval (c )-1],end=’’)

3.3.4 字符串处理方法

– S.lower()或S.upper() 返回字符串副本，全部字符小写/大写
– S.split(sep=None) 返回一个列表，由str根据sep被分隔部分组成
– S.count(sub) 返回子字符串sub在str中出现的次数
– S.replace(old,new)
– S.center(width[,fillchar])

“python”.center(20,"=") 结果为 ‘=python=’
在一个20字符的宽度中，让我们的python字符居中，同时在空余的部分用等号来填充。
– S.strip(chars)从str中去掉在其左侧和右侧chars中列出的字符。
– S.join(iter) 在iter变量除最后元素外每个元素增加一个S。例如：’,’.join(“12345”) #主要用于字符串分割

3.3.5 字符串类型的格式化

字符串格式化使用.format()方法，用法如下：
<模板字符串>.format(<逗号分隔的参数>)

在这里插入图片描述

** “{:10}”.format(“BIT”) ** 中默认是空格填充左对齐

在这里插入图片描述
所有字符都用英文半角

3.4 模块2：time库的使用

3.4.1 time库的基本介绍

时间获取：time() ctime() gmtime()

gmtime（）得到一个计算机内部可以操作的时间，struct_time格式
时间格式化： strftime() ，strptime()

格式化：类似字符串格式化，需要有展示模板
展示模板由特定的格式化控制符组成
strftime()方法
strptime()方法
strptime()与strftime()是互补关系，能够将一段字符串变成时间

程序计时：sleep(),perf_counter()

3.4.2 时间获取

.time() 获取当前时间戳，即计算计算机内部时间值，浮点数。

.ctime()获取当前时间并以易读方式表示，返回字符串

.gmtime()获取当前时间，表示为计算机可处理的时间格式

3.4.3 时间格式化

.strftime(tpl,ts) : tpl是格式化模板字符串，用来定义输出效果，ts是计算机内部时间类型变量
t = time.gmtime()
time.strftime("%Y-%m-%d %H:%M:%S", t)

t = time.gmtime()
time.strftime("%Y-%m-%d %H:%M:%S", t)

timeStr = “2018-01-26 12:55:20”
time.strptime(timeStr,"%Y-%m-%d %H:%M:%S")

3.4.4 程序计时应用

程序计时指测量起止动作所经历时间的过程

测量时间：perf_counter()，非常精准
产生时间：sleep()，让程序去休眠或产生一点时间

start = time.perf_counter()
end = time.perf_counter()
end - start

sleep(s) s拟休眠时间，单位是秒，可以是浮点数

3.5 实例4：文本进度条

采用sleep()模拟一个持续的进度
这里理解一个重要的系统概念:刷新
刷新的关键是\r

刷新本质：用后打印的字符串覆盖之前的字符串。
不能换行：print()需要被控制
要能回退：打印后光标退回到之前的位置\r

# TextProBarV3.py
import time
scale = 50 # 文本进度条的大概的宽度
print("执行开始".center(scale//2,"-")) # p3.3.4 center填充函数
start = time.perf_counter() # 确定了一个开始时间
for i in range(scale + 1):a = "*" * i # 字符串与整数的乘积，表示复制字符串的次数，a是i个*的字符串b = "." * (scale - i)c = (i / scale) * 100dur = time.perf_counter() - start# 给end赋值空字符串，可以是print每一次输出字符串之后不会增加换行，只会把光标停留在当次输出字符串的后面# 这里的\rprint("\r{:^3.0f}%[{}->{}]{:.2f}s".format(c, a, b, dur), end="") time.sleep(0.1)
print("\n" + "执行结束".center(scale // 2, "-"))

第四章程序的控制结构

4.1 程序的分支结构

“程序的控制结构”：顺序结构、分支结构、循环结构

4.1.1 单分支结构

语法： if <条件>:
<语句块>

4.1.2 二分支结构

语法： if <条件>:
<语句块1>
else:
<语句块2>

紧凑形式：适用于简单表达式的二分支结构
<表达式1> if <条件> else <表达式2>
在这里插入图片描述

4.1.3 多分支结构

语法：if <条件1>:
<语句块1>
elif <条件2>：
<语句2>
…
else:
<语句块N>
注：注意多条件之间的包含关系，注意变量取值范围的覆盖。通俗点：多分支结构中，如果一个分支判断条件通过后，会执行对应的语句块，之后结束分支程序。即使，后续的elif条件也满足，也不会执行对应的语句块.所以这里其实也有一个顺序关系。

4.1.4 条件判断及组合

–条件判断操作符：<,<=,>=,>,==,!=

–条件组合三个保留字：and,or,not

4.1.5 程序的异常处理

try:<语句块1>
except [<异常类型>]：<语句块2>

注：标注异常类型后，仅响应该异常，异常类型名字等同于变量。
高级使用：

try:<语句块1>
except:<语句块2>
else:           # 不发生异常的时候执行(奖励)<语句块3>
finally:        # 无论是否异常一定会执行<语句块4>

4.2 实例5：身体质量指数BMI

BMI = 体重(Kg)/身高^2(m2)
略
注：阅读代码的时候，快速的方法是：先搞懂分支的范围关系，再深入看每个分支在做什么。而不是从上到下的顺序结构。

国际标准

#CalBMIv1.py
height, weight = eval(input("请输入身高(米)和体重(公斤)[逗号隔开]: "))
bmi = weight / pow(height, 2)
print("BMI 数值为：{:.2f}".format(bmi))
who = ""
if bmi < 18.5:who = "偏瘦"
elif 18.5 <= bmi < 25:who = "正常"
elif 25 <= bmi < 30:who = "偏胖"
else:who = "肥胖"
print("BMI 指标为:国际'{0}'".format(who))

国内标准

#CalBMIv2.py
height, weight = eval(input("请输入身高(米)和体重\(公斤)[逗号隔开]: "))
bmi = weight / pow(height, 2)
print("BMI 数值为：{:.2f}".format(bmi))
nat = ""
if bmi < 18.5:nat = "偏瘦"
elif 18.5 <= bmi < 24:nat = "正常"
elif 24 <= bmi < 28:nat = "偏胖"
else:nat = "肥胖"
print("BMI 指标为:国内'{0}'".format(nat))

国内国外合并

#CalBMIv3.py
height, weight = eval(input("请输入身高(米)和体重(公斤)[逗号隔开]: "))
bmi = weight / pow(height, 2)
print("BMI 数值为：{:.2f}".format(bmi))
who, nat = "", ""
if bmi < 18.5:who, nat = "偏瘦", "偏瘦"
elif 18.5 <= bmi < 24:who, nat = "正常", "正常"
elif 24 <= bmi < 25:who, nat = "正常", "偏胖"
elif 25 <= bmi < 28:who, nat = "偏胖", "偏胖"
elif 28 <= bmi < 30:who, nat = "偏胖", "肥胖"
else:who, nat = "肥胖", "肥胖"
print("BMI 指标为:国际'{0}', 国内'{1}'".format(who, nat))

4.3 程序的循环结构

4.3.1 遍历循环

for <循环变量> in <遍历结构>:
<语句块>
–从遍历结构中逐一提取元素，放在循环变量中。
–完整遍历所有元素后结束
–每次循环，所获得元素放入循环变量，并执行一次语句块

应用：计数循环、字符串遍历循环、列表遍历循环、文件遍历循环、等等
在这里插入图片描述

line每次读fi文件的一行

4.3.2 无限循环

while <条件>:
<语句块>

4.3.3 循环控制保留字

break 跳出并结束当前循环，执行循环后的语句
continue 结束当次循环，继续执行后续次数循环
break和continue可以与for和while循环搭配使用。

在这里插入图片描述

一个break只能跳出一个循环

4.3.4 循环的高级用法

在这里插入图片描述

当循环没有被break语句退出时，执行else语句块
else语句块作为“正常”完成循环的奖励
这里else的用法与异常处理中else用法相似

在这里插入图片描述

4.4 模块3：random库的使用

random库是使用随机数的Python标准库

4.4.1 random 标准库之一

伪随机数：采用梅森旋转算法生成的(伪)随机序列中元素
random库主要用于生成随机数

4.4.2 基本随机函数

seed(a=None) --初始化给定的随机数种子，默认为当前系统时间

random.seed(10) # 产生种子10对应的序列
这个在实战中用的比较多，“确定”的伪随机数便于对程序进行复现。
不用seed时，默认以系统时间作为种子

random()

生成一个[0.0，1.0)之间的随机小数
random.random()

例子

给了随机种子，下次重新运行程序时，只要种子相同，那么产生的随机数也是相同的。
如果不使用随机种子，就是使用系统时间，哪个时间是精确到微妙的，哪个时间是我们很难再现的

4.4.3 扩展随机数函数

randint(a,b) 生成[a,b]之间的整数
randrange(m,n[,k]) 生成一个[m,n)之间以k为步长的随机整数
getrandbits(k) 生成一个k比特长的随机整数
uniform(a,b) 生成一个[a,b]之间的随机小数
choice(seq) 从序列seq中随机选择一个元素
shuffle(seq) 将序列seq中元素随机排列，返回打乱后的序列

4.5 实例6：圆周率的计算

4.5.1 蒙特卡洛方法

from random import random
from time import perf_counter
DARTS = 1000 * 1000 # 撒点总数量
hits = 0.0  # 在圆内点的数量
start = perf_counter()
for i in range(1, DARTS+1):x, y = random(), random()dist = pow(x ** 2 + y ** 2, 0.5) # 计算点到圆心的距离，判断点是否在圆内if dist <= 1.0:hits += 1
pi = 4 * (hits / DARTS)
print("圆周率是：{}".format(pi))
print("运行时间是：{:.5f}s".format(perf_counter() - start))

第五章：函数的定义与使用

5.1.1 函数的理解和定义

函数是一段具有特定功能、可重用的语句组
降低编程难度和代码复用

def <函数名>(<参数(0个或多个)>)：
<函数体>
return <返回值>

不调用不会被执行

5.1.2 函数的使用及调用过程

调用是运行函数代码的方式
-调用时给出实际参数，替代定义中的形式参数
-函数调用得到返回值

5.1.3 函数的参数传递

参数的个数：0，1，或多个。但是必须保留括号
可变数量参数，既不确定参数总数量
传递参数两种方式：位置参数，名称传递

5.1.4 函数的返回值

return 保留字用来传递返回值
可以传，可以不传，可以传递0个，也可以传多个
方括号括着元素里面用逗号隔开属于列表，圆括号括着里面用逗号隔开，是元组

5.1.5 局部变量和全局变量

– (一般函数外部是全局变量，函数内部的变量是局部变量)

**规则一：**局部变量和全局变量是不同变量
–局部变量是函数内部的占位符，与全局变量可能重名但不同
–函数运算结束后，局部变量被释放
–可以用 global保留字在函数内部使用全局变量
(这里还分可变类型和不可变类型)
**规则二：**局部变量为组合数据类型且未创建，等同于全局变量
使用规则：
-基本数据类型，无论是否重名，局部变量与全局变量不同
-可以通过global保留字在函数内部声明全局变量
-组合数据类型，如果局部变量未真实创建，则是全局变量

5.1.6 lambda函数

lambda函数返回函数名作为结果

lambda函数是一种匿名函数，即没有名字的函数
使用lambda保留字定义，函数名是返回结果
lambda函数用于定义简单的、能够在一行内表示的函数

<函数名> = lambda <参数>:<表达式>
后面的内容只能使用表达式不能使用函数体
谨慎使用lambda函数
–主要作用特定函数或方法的参数
– 固定使用方式，逐步积累掌握
– 一般情况，用def定义普通函数，慎用lambda

5.2 七段数码管绘制

5.2.1 基本思路

1. 绘制单个数字对应的数码管
1. 获得一串数字，绘制对应的数码管
1. 获得当前系统时间，绘制对应的数码管

1.分析单个数码管：

七段数码管由7个基本线条组成
七段数码管可以有固定顺序(抽象出一条可以首尾相连且不重不漏的路径)
不同数字显示不同的线条，只需要判断7次各个数字是否需要经过某条线就行(通过pu，pd控制)

获取一段数字，绘制多个数码管：

每绘制完一个数字，向右移动一段距离，准备下一个数字的绘制

获取当前系统时间：

time库
增加年月日标记： write 方法
年月日颜色不同标记
线条之间适当小间隔，提高颜值

代码

#SevenDigitsDrawV2.py
import turtle, time
def drawGap(): #绘制数码管间隔turtle.penup()turtle.fd(5)
def drawLine(draw):   #绘制单段数码管drawGap()turtle.pendown() if draw else turtle.penup()turtle.fd(40)drawGap()turtle.right(90)
def drawDigit(d): #根据数字绘制七段数码管
## 如果属于[2,3,4,5,6,8,9]中有的线就画，没有就飞过去，准备第二条线的判断drawLine(True) if d in [2,3,4,5,6,8,9] else drawLine(False)drawLine(True) if d in [0,1,3,4,5,6,7,8,9] else drawLine(False)drawLine(True) if d in [0,2,3,5,6,8,9] else drawLine(False)drawLine(True) if d in [0,2,6,8] else drawLine(False)turtle.left(90)drawLine(True) if d in [0,4,5,6,8,9] else drawLine(False)drawLine(True) if d in [0,2,3,5,6,7,8,9] else drawLine(False)drawLine(True) if d in [0,1,2,3,4,7,8,9] else drawLine(False)turtle.left(180)turtle.penup() ## 为绘制后续数字确定位置turtle.fd(20)  ## 为绘制后续数字确定位置
def drawDate(date):turtle.pencolor("red")for i in date:if i == '-':#font是字体的参数，分别为字体名称，大小和类型turtle.write('年',font=("Arial", 18, "normal"))turtle.pencolor("green")turtle.fd(40)elif i == '=':turtle.write('月',font=("Arial", 18, "normal"))turtle.pencolor("blue")turtle.fd(40)elif i == '+':turtle.write('日',font=("Arial", 18, "normal"))else:drawDigit(eval(i))
def main():turtle.setup(800, 350, 200, 200)turtle.penup()turtle.fd(-350)turtle.pensize(5)
#    drawDate('2018-10=10+')drawDate(time.strftime('%Y-%m=%d+',time.gmtime())) ## 读取系统年月日时间turtle.hideturtle()turtle.done()
main()

5.2.2 理解思维方法

模块化思维：确定模块接口，封装功能
规则化思维：抽象过程为规则，计算机自动执行
化繁为简：将大功能变为小功能，分而治之(松耦合，紧耦合)

5.2.3 举一反三

绘制带小数点的七段数码管
带刷新的时间倒计时效果
绘制高级的数码管(多段)

5.3 代码复用与函数递归

5.3.1 代码复用与模块化设计

代码复用：把代码当成资源进行抽象
代码复用：|函数|和|对象|是代码复用的两种主要形式
函数：(将代码命名)：在代码层面建立了初步抽象
对象：(属性和方法):在函数基础上再次组织进行抽象
模块化设计：分而治之
模块化设计：紧耦合、松耦合

5.3.2 函数递归的理解

定义：函数定义中调用函数自身的方式
两个关键特征：
链条：计算过程存在递归链条
基例：存在一个或多个不需要再次递归的基例
类似数学归纳法：递归是数学归纳法思维的编程体现

5.3.3 函数递归的调用过程

递归的实现：函数+分支语句
递归本身是一个函数，需要函数定义方式的描述
函数内部，采用分支语句对输入参数进行判断
基例和链条，分别编写对应的代码

5.3.4 函数递归实例解析

字符串反转
斐波那契数列
汉诺塔 PS：学会找到基例和链条

5.4 模块：PyInstaller库的使用

5.4.1 概述

将.py源码转换成无需源代码的可执行文件
在命令窗口输入后回车可以查看对应的方法参数帮助
要配置Path，关闭后再开cmd窗口

实例8：科赫雪花小包裹

PS：分形几何，自然界常见
基本方法：
递归思想：函数+分支
递归链条：线段的组合
递归基例：初识线段
运用 PyInstaller库
举一反三
修改分形几何绘制阶数
修改科赫曲线的基本定义及旋转角度
修改绘制科赫雪花的基础框架图形
分形几何扩展：
康托尔集、谢尔宾斯基三角、门格海绵…
龙形曲线、空间填充曲线、科赫曲线…
函数递归的深入应用…

第六章组合数据类型

组合类型的三种表达形式：

集合类型
序列类型
字典类型

6.1 集合类型及操作

6.1.1 集合类型定义

与数学中概念一致
集合元素之间无序，每个元素之间唯一，不存在相同元素
集合元素不可更改，不能是可变数据类型(为什么？集合定义：元素唯一不重复)
集合建立用{}表示，元素逗号分隔，集合中的元素没有顺序
建立集合用{}或set()
建立空集合必须是set()：因为Python中字典类型使用更多，所以{}给了建立空字典

6.1.2 集合间操作

在这里插入图片描述

4个增强操作符

S|=T 更新集合S，包括在集合S和T中的所有元素
S-=T 更新集合S，包括在集合S但不在集合T中的元素
S&=T 更新集合S，包括同时在集合S和T中的元素
S^=T 更新集合S，包括集合S和T中的非相同元素
操作函数或操作方法：
- S.add(x) 如果X不在集合S中，将X增加到S
- S.discard(x) 移除S中的元素X，如果x不在S中，不报错
- S.remove(x) 移除S中元素X，如果x不在S中，产生KeyError异常
- S.clear() 移除S中所有元素
- S.pop() 随机返回S的一个元素，更新S，若S为[空]产生KeyError异常

例子

在这里插入图片描述
**解释：**其中A.pop()的意思是每次从A中取出一个元素，当A为空集合的时候会产生异常异常，这个异常能被try和except捕捉到，程序可以正常退出

6.1.3 集合类型应用场景

包含关系比较
数据去重

6.2 序列类型及操作

6.2.1 定义

序列是具有先后关系的一组元素
序列是一维元素向量，元素类型可以不同
元素间由序号引导，通过下标访问序列的特定元素

序列是一个基类类型

3个衍生类型：字符串、元组、列表
序号：反向递减，正向递增

6.2.2 函数和方法

通用操作符(6个)

列表或字符串中的元素顺序取反操作
函数和方法(5个)

6.2.3 元组类型及操作

元组是一种序列类型，一旦创建就不能被修改
使用小括号() 或tuple() 创建，元素间用逗号, 分隔
可以使用或不使用小括号
注： - 元组就是将元素进行有序的排列，用（）的形式来组织
特殊：单个元组，元素后面要加逗号

def func():return1,2

这里的返回值就是元组

元组继承序列了类型全部通用操作符
创建后不可修改，所以没有特殊操作

6.2.4 列表类型及操作

序列类型的一种扩展
- 创建后可以随意被修改
- []或list()创建，元素间逗号分隔
- 列表中各元素类型可以不同，无长度限制
定义:方括号[]真正创建一个列表，赋值仅传递引用（贴标签）

因为这里没有创建列表it，所以只是赋值引用，相当于吧ls改名为lt
函数和方法
增删改查

记忆

在这里插入图片描述
注意：列表中的第一个元素在第0个位置

6.2.5 序列类型应用场景

数据表示：元组和列表

元组用于元素不改变的应用场景，更多用于固定搭配场景
列表更加灵活，它是最常用的序列类型
最主要作用：表示一组有序数据，进而操作它们
元素遍历：ls、tp
数据保护：tp

6.2.6序列类型及操作小结

序列是基类类型，扩展类型包括：字符串、元组和列表
元组用()和tuple()创建，列表用[]和set()创建
元组操作与序列操作基本相同
列表操作在序列操作基础上，增加了更多的灵活性

6.3 实例9：基本统计值计算

6.3.1 基本统计值计算 ——问题分析

需求：给出一组数，对它们有个概要理解
基本统计值：总个数、求和、平均值、方差、中位数……
len()
for in 求和
均值：求和/总个数
方差： pow()函数
中位数：排序，然后……

6.3.2 实例讲解

代码主要思路：

掌握获得多数据输入的方法
使用多个函数通过参数传递的方式，将复杂的功能分割成几个很小的功能，并且将这些功能组织起来完成客户的需求。

#CalStatisticsV1.py
def getNum():       #获取用户不定长度的输入nums = []iNumStr = input("请输入数字(回车退出): ")while iNumStr != "":nums.append(eval(iNumStr))iNumStr = input("请输入数字(回车退出): ")return numsdef mean(numbers):  #计算平均值s = 0.0for num in numbers:s = s + numreturn s / len(numbers)def dev(numbers, mean): #计算方差sdev = 0.0for num in numbers:sdev = sdev + (num - mean)**2# 方差公式就是除以n-1return pow(sdev / (len(numbers)-1), 0.5)def median(numbers):    #计算中位数sorted(numbers)size = len(numbers)if size % 2 == 0:med = (numbers[size//2-1] + numbers[size//2])/2else:med = numbers[size//2]return medn =  getNum() #主体函数
m =  mean(n)
print("平均值:{},方差:{:.2},中位数:{}.".format(m, dev(n,m),median(n)))

6.3.3 举一反三

获取多个数据：从控制台获取多个不确定数据的方法
分隔多个函数：模块化设计方法
充分利用函数：充分利用Python提供的内置函数

6.4 字典类型及操作

6.4.1 定义

字典的理解
- 映射的概念：映射是一种键(索引)和值(数据)的对应
- 字典和序列不同：字典的索引值是由用户自己定义的
- 所以可以理解为，字典类型是数据组织与表达的一种新的形态，字典类型是映射的体现
字典的定义
- 键值对：键是数据索引的扩展
- 字典是键值对的集合，键值对之间无序
- 采用大括号{}和dict()创建，键值对用冒号: 表示

在这里插入图片描述

区别于集合
- 集合中不能用{}来定义一个空集合，原因就是因为字典定义空集合是用的{}，生成空的集合需要用set().
- 集合中的元素就是一个基本元素，不是键值对
字典类型操作函数和方法1
- d.keys和d.values并不返回列表类型，它返回的是一种字典的key类型和value类型，这种类型可以用for，in做遍历，都是不能当做列表类型来操作
字典类型操作函数和方法2

记忆

在这里插入图片描述

字典类型及操作小结

映射关系采用键值对表达
字典类型使用{}和dict()创建，键值对之间用:分隔
d[key] 方式既可以索引，也可以赋值
字典类型有一批操作方法和函数，最重要的是.get()

应用场景

映射无处不在，键值对无处不在
例如：统计数据出现的次数，数据是键，次数是值
最主要作用：表达键值对数据，进而操作它们

6.5 模块5：jieba库的使用

6.5.1 jieba库是优秀的中文分词第三方库

pip安装
原理：
- 中文文本需要通过分词获得单个的词语
- jieba是优秀的中文分词第三方库，需要额外安装
- jieba库提供三种分词模式，最简单只需掌握一个函数
三种分词模式
- 精确模式：精确分开，不存在冗余单词
- 全模式：所有可能词语扫描出来，有冗余
- 搜索引擎模式：精确模式基础上，对长词进行再次切分
常用函数：

关键是jieba.lcut(s)：能将能将字符串s进行精确的分词处理，并且返回一个列表类型

6.6 实例10：文本词频统计

哈姆雷特

#CalHamletV1.py
def getText():txt = open("hamlet.txt", "r").read()txt = txt.lower()  # 把txt中字母全部变小写for ch in '!"#$%&()*+,-./:;<=>?@[\\]^_‘{|}~':txt = txt.replace(ch, " ")   #将文本中特殊字符替换为空格return txthamletTxt = getText()
# .split()采用空格将hamletTxt中的字符串进行分隔，并且以列表形式返回给变量
words  = hamletTxt.split()
#为了表示一个单词和它出现的次数构成映射，用字典来表示
counts = {}
for word in words: # 表示如果键word存在就返回其对应的值，不存在就返回0，所以第一次不#存在返回0，此时word键在counts里面生成，对应的值是1。#第二次遇到同一个word时，返回对应值1，然后word对应的值变成1+1=2          counts[word] = counts.get(word,0) + 1
items = list(counts.items())
# 对一个列表按照键值对的两个元素的第二个元素进行排序，排序的方式是由大到小
items.sort(key=lambda x:x[1], reverse=True) 
for i in range(10):word, count = items[i]print ("{0:<10}{1:>5}".format(word, count))

程序理解
- items = list(counts.items())的使用，问：一个列表里面能放元组吗？
- 列表,元组,字典的元素可以是任何类型
- items.sort(key=lambda x:x[1], reverse=True) 还不懂？？？？

三国演义任务出场次数统计

#CalThreeKingdomsV2.py
import jieba
excludes = {"将军","却说","荆州","二人","不可","不能","如此"}
txt = open("threekingdoms.txt", "r", encoding='utf-8').read()
words  = jieba.lcut(txt)
counts = {}
for word in words:if len(word) == 1:continueelif word == "诸葛亮" or word == "孔明曰":rword = "孔明"elif word == "关公" or word == "云长":rword = "关羽"elif word == "玄德" or word == "玄德曰":rword = "刘备"elif word == "孟德" or word == "丞相":rword = "曹操"else:rword = wordcounts[rword] = counts.get(rword,0) + 1
for word in excludes:del counts[word]
items = list(counts.items())
items.sort(key=lambda x:x[1], reverse=True) 
for i in range(10):word, count = items[i]print ("{0:<10}{1:>5}".format(word, count))

第七章文件和数据格式化

7.1 文件的使用

7.1.1 文件的类型

文件是数据的抽象和集合
- 文件是存储在辅助存储器上的[数据序列]
- 文件是数据存储的一种形式
- 文件展现形态：文本文件和二进制文件
文本文件 VS 二进制文件
- 文本文件和二进制文件只是文件的展示方法
- 本质上：所有文件都是二进制形式存储
- 形式上，所有文件采用两种方式展示
文本文件：
- 由单一特定编码组成的文件，如UTF-8编码
- 由于存在编码，也被看成是存储着的长字符串
- 例如：.txt ， .py文件等
二进制文件：
- 直接由比特0、1组成，没有统一字符编码
- 一般存在二进制0，1的组织结构，即文件格式
- 例如：png、avi等
例子

7.1.2 文件打开和关闭

文件处理的步骤：打开——操作——关闭

# f.txt文件保存: "中国是个伟大的国家!"
# 文本形式打开文件
tf= open("f.txt", "rt") # rt表示以文本方式读取
print(tf.readline()) # 读第一行
tf.close()
>>>
中国是个伟大的国家!#二进制形式打开文件
bf = open("f.txt", "rb")
print(bf.readline())
bf.close()
>>>
b'\xd6\xd0\xb9\xfa\xca\xc7\xb8\xf6\xce\xb0\xb4\xf3\xb5\xc4\xb9\xfa\xbc\xd2\xa3\xa1'

a.read(size)
a.readline(size)
a.readlines(hint)
a.write(s)
a.writelines(lines)
a.seek(offset)

文件的存储状态文件的占用状态a = opne( , )a.close()文件的存储状态文件的占用状态
- 读文件：3种方法 VS 写文件： 3种方法 -文件的打开： <变量名> = open(<文件名>，<打开模式>)
- 变量名：文件句柄
- 文件名：文件路径和名称(源文件同目录可省略)
- 打开模式：文本or二进制；读or写
- 补充：windows下，文件目录之间用\，这个和python冲突，解决方式两种：\，或者用/ .
打开模式：
例子

f = open("f.txt") # -文本形式、只读模式、默认值
f = open("f.txt", "rt")# -文本形式、只读模式、同默认值
f = open("f.txt", "w")# -文本形式、覆盖写模式
f = open("f.txt", "a+")# -文本形式、追加写模式+ 读文件，如果没有+，就只能追加写模式，不能读文件
f = open("f.txt", "x")# -文本形式、创建写模式
f = open("f.txt", "b")# -二进制形式、只读模式
f = open("f.txt", "wb")# -二进制形式、覆盖写模式

7.1.3 文件内容的读取

操作方法描述
文件的全文本操作
- 遍历全文本：方法一：一次读入read，统一处理
- 遍历全文本：方法二：按数量读入，逐步处理

fo = open(filename,"r")
txt = fo.read(2)
while txt != "":# 对txt进行处理txt = fo.read(2)
fo.close()

文件的逐行操作
- 逐行遍历文件：方法一:一次读入，分行处理。缺点：对于大文件读取速度慢

fo = open(filename,"r")
for line in fo.readlines():print(line)
fo.close()

逐行遍历文件：方法二:分行读入，逐行处理。优点：大文件处理速度块

fo = open(filename,"r")
for line in fo: # 通过迭代器访问print(line)
fo.close()

7.1.4 数据的文件写入

操作方法描述
- .write(s) 向文件写入一个字符串或字节流
- .writelines(lines) 将一个元素全为字符串的列表写入文件，将各个元素直接拼接起来
- .seek(offset) 改变当前文件操作指针的位置，offset含义如下：0 - 文件开头；1 - 当前位置；2 - 文件结尾

在这里插入图片描述

# 写入一个字符串列表
fo = open("output.txt", "w+")
ls = ["中国", "法国", "美国"]
fo.writelines(ls) # 写过文件后，指针在文件最后面，指向下一次可能写入信息的位置
fo.seek(0)  # 调整文件写入后的指针，回到文件的初始位置。否则，没有结果输出
for line in fo:print(line)
fo.close()

文件的使用小结

文件的使用方式：打开-操作-关闭
文本文件&二进制文件，open( , )和.close()
文件内容的读取：.read() .readline() .readlines()
数据的文件写入：.write() .writelines() .seek()

7.2 实例11：自动化轨迹绘制

7.2.1 问题分析

需求：根据脚本来绘制图形？
不是写代码而是写数据绘制轨迹
数据脚本是自动化最重要的第一步

7.2.2 实例讲解

基本思路：

步骤1：定义数据文件格式(接口)：个性化
步骤2：编写程序，根据文件接口解析参数绘制图形
步骤3：编制数据文件

#AutoTraceDraw.py
importturtle ast
t.title('自动轨迹绘制')
t.setup(800, 600, 0, 0)
t.pencolor("red") # 初始绘制的画笔颜色
t.pensize(5) # 绘制画笔的粗细
#数据读取
# 将所有数据的信息读入之后，保存为列表
datals= []
f = open("data.txt")
for line in f:line = line.replace("\n","") # map的作用就是将第一个参数的功能作用到第二个参数# 每一行处理之后的信息作为列表，并且这个列表是我们定义的datals中的一个元素datals.append(list(map(eval, line.split(","))))# 至此，datals列表中每一个元素就是一行的信息，也就是一个小的列表
f.close()
#自动绘制
for i in range(len(datals)):#获得每个元素中的rgb值，改变当前画笔的颜色t.pencolor(datals[i][3],datals[i][4],datals[i][5])t.fd(datals[i][0])if datals[i][1]:t.right(datals[i][2])else:t.left(datals[i][2])

7.2.3 举一反三

理解方法思维
自动化思维：数据和功能分离，数据驱动的自动运行
接口化设计：格式化设计接口，清晰明了
二维数据应用：应用维度组织数据，二维数据最常用
应用问题扩展：
扩展接口设计，增加更多控制接口
扩展功能设计,增加弧形等更多功能
扩展应用需求，发展自动轨迹绘制到动画绘制

7.3 一维数据的格式化和处理

7.3.1 数据组织的维度：组织形式

一维数据：
- 由对等关系的有序或无序数据构成，采用线性方式组织
- 对应列表、数组和集合等概念
二维数据：
- 由多个一维数据构成，是一维数据的组合形式
- 表格是典型的二维数据，其中，表头是二维数据的一部分
多维数据
- 由一维或二维数据在新维度上扩展形成
- 比如，加入时间维度
高维数据
- 仅利用组基本的二元关系展示数据间的复杂结构
- 比如，字典嵌套
数据的操作周期：
- 存储<->表示<->操作

一维数据的表示

如果数据间有序：列表，for遍历
如果数据间无序：集合，for遍历

一维数据的存储

存储方式一：空格分隔
- 使用一个或多个空格分隔进行存储，不换行
- 缺点：数据中不能存在空格
存储方式二：逗号分隔
- 使用英文半角逗号分隔数据进行存储，不换行
- 缺点：数据中不能有英文逗号
存储方式三：其他方式，特殊字符
- 使用其他符号或符号组合分隔，建议采用特殊符号
- 缺点：需要根据数据特点定义，通用性较差

一维数据的处理

将存储的数据读入程序
- split方法

# 从空格分隔的文件中读入数据
# 中国 美国 日本 德国 法国 英国 意大利
txt= open(fname).read()# 用.read把文件读进来变成一个大字符串
ls = txt.split() # 根据空格分隔字符串中的信息，将每一个元素变成一个列表
f.close()>>> ls
['中国', '美国', '日本', '德国', '法国', '英国', '意大利']#从特殊符号分隔的文件中读入数据
#中国$美国$日本$德国$法国$英国$意大利
txt= open(fname).read()
ls = txt.split("$")
f.close()>>> ls
['中国', '美国', '日本', '德国', '法国', '英国', '意大利']

将程序表示的数据写入文件
- join(ls) 方法
将程序表示的数据写入文件
- join(ls) 方法
从一维数据的表示的列表形式写入文件的方法

# 采用空格分隔方式将数据写入文件
ls = ['中国','美国','日本']
f = open(fname, 'w')
# join方法的作用：将join前面的字符串分隔放置到后面join参数中各个元素之间的
# 如ls其中三个元素之间增加空格，生成的字符串就是'中国 美国 日本'
f.write(''.join(ls))
f.close()# 采用特殊分隔方式将数据写入文件
ls = ['中国','美国','日本']
f = open(fname, 'w')
f.write('$'.join(ls)) 
f.close()

一维数据的格式化和处理小结

数据的维度：一维、二维、多维、高维
一维数据的表示：列表类型(有序)和集合类型(无序)
一维数据的存储：空格分隔、逗号分隔、特殊符号分隔
一维数据的处理：字符串方法.split() 和.join()

7.4 二维数据的格式化和处理

二维数据的表示
CSV数据存储格式
二维数据的存储
二维数据的处理

7.4.1 二维数据的表示

list类型：二维列表
- 二维列表它本身是一个列表，二列表中的每一个元素又是一个列表
- 使用两层for遍历，第一次遍历每个元素，第二次遍历每个元素代表的列表
- 外层列表中每个元素可以对应一行，也可以对应一列？？？？

7.4.2 CSV格式与二维数据存储

注：CSV：Comma-Separated Values(由逗号分隔的值)
国际通用的一二维数据存储格式，后缀：.csv
每行一个一维数据，采用逗号分隔，无空行
Excel可读入输出，一般编辑软件都可以产生
如果某个元素缺失，逗号仍要保留
二维数据的表头可以作为数据存储，也可以另行存储
逗号为英文半角逗号，逗号与数据之间无额外空格

7.4.3 二维数据的存储

按行、列存储都可以
一般习惯：ls[row][column],先行后列
根据一般习惯，按行存

7.4.4 二维数据的处理

读入处理：

#从CSV格式的文件中读入数据
fo = open(filename)
ls = []
for line in fo:line = line.replace("\n", "") # 去掉每一行的最后一个回车换行符ls.append(line.split(","))
fo.close()

写入处理：

#将数据写入CSV格式的文件
ls = [[], [], []]  # 二维列表
f = open(fname, "w")
for item in ls:f.write(",".join(item) + "\n")
f.close()

二维数据的逐一处理

采用二层循环

ls = [[1,2],[3,4],[5,6]] #二维列表
for row in ls:for column in row:print(column)

7.5 模块6：wordcloud库的使用

wordcloud库概述：wordcloud是优秀的词云展示第三方库
wordcloud库基本使用：wordcloud库把词云当作一个WordCloud对象
- wordcloud.WordCloud()代表一个文本对应的词云
- 可以根据文本中词语出现的频率等参数绘制词云
- 词云的绘制形状、尺寸和颜色都可以设定
wordcloud库常规方法
- 以WordCloud对象为基础
- 配置参数、加载文本、输出文件
三步法

import wordcloud
c = wordcloud.WordCloud()# 步骤1：配置对象参数
c.generate("wordcloudby Python")# 步骤2：加载词云文本
c.to_file("pywordcloud.png")# 步骤3：输出词云文件

在这里插入图片描述

配制参数
例子

# wordcloud中我们是利用空格分隔单词的
import wordcloud
txt = "life is short, you need python"
w = wordcloud.WordCloud( \
background_color= "white")
w.generate(txt)
w.to_file("pywcloud.png")# 中文没有空格，所以需要事先分好import jieba
import wordcloud
txt = "程序设计语言是计算机能够理解和\
识别用户操作意图的一种交互体系，它按照\
特定规则组织计算机指令，使计算机能够自\
动进行各种运算处理。"
w = wordcloud.WordCloud( width=1000,\
font_path="msyh.ttc",height=700)
# 下面这句话的意思是，能够将这段文本通过jieba.lcut函数编程一个列表
# 进一步用join方法，将jion中的元素用jion前面的空格字符串来分隔来构成一个长字符串，这个厂字符串会赋值给WordCloud对象
w.generate(" ".join(jieba.lcut(txt)))
w.to_file("pywcloud.png")

在这里插入图片描述

7.6 实例12：政府工作报告词云

第八章程序设计方法学

8.3 Python第三方库安装

8.3.1 Python世界

https://pypi.org/
PyPI：Python Package Index
PSF维护的展示全球Python计算生态的主站
学会检索并利用PyPI，关键词检索

8.3.2 第三方库的pip安装方法

Win+r =>输入cmd回车，进入cmd，pip -h，可以常看常用命令及介绍

8.3.3 第三方库的集成安装方法

Anaconda —— 数据计算

8.3.4 第三方库的文件安装方法

某些第三方库pip下载后，需要编译再安装
直接下载编译后的安装，推荐一个个人博客：http://www.lfd.uci.edu/~gohlke/pythonlibs/

8.4 模快7：os库的基本使用

os库是标准库，包含几百个函数，常用路径操作、进程管理、环境参数等几类

路径操作：os.path子库，处理文件路径及信息
进程管理：启动系统中其他程序
环境参数：获得系统软硬件信息等环境参数

路径操作：os.path子库以path为入口，用于操作和处理文件路径

import os.path as op

函数描述
在这里插入图片描述

os.path.exists(path)并没有打开这个文件，只是去系统查看存不存在

8.4.2 进程管理：启动系统中其他程序

os.system(command)
执行程序或命令command
在windows系统中，返回值为cmd的调用返回信息

eg1: os.system("C:\\windows\\System32\\calc.exe")
#打开画图程序并同时用它打开一张图
eg2: os.system(C:\\windows\\System32\\mspaint.exe D:\\pycode\\grwordcloud.png")

8.4.3 环境参数：获得系统软硬件信息等环境参数

函数描述
os.chdir(path) 修改当前程序操作的路径
os.getcwd() 返回程序的当前路径
os.getlogin() 获得当前系统登陆用户名
os.cpu_count() 获得当前系统的CPU数量
os.urandom(n) 获得n个字节长度的随机字符串，通常用于加解密运算

在这里插入图片描述

北京理工大学：《Python语言程序设计》详细笔记

第一章：程序设计基本方法

计算机与程序设计

编译和解释

程序的基本写法

计算机编程

实例1 --温度转换

Python程序语法元素分析

Python程序的输入输出

第二章 Python基本图形绘制

2.1 深入理解Python语言

2.1.1计算机技术的演进

2.1.2编程语言的多样初心

Python语言的特点

超级语言的诞生

2.2 实例2：Python蟒蛇绘制

2.3 模块1：turtle库的调用

2.3.1 turtle库基本介绍

2.3.2 turtle绘图窗体布局

2.3.3 turtle空间坐标体系

2.3.4 turtle角度坐标体系

2.3.5 RGB色彩体系

2.4 turtle程序语法元素分析

2.4.1 库引用和 import

2.4.2 画笔控制函数

2.4.3 运动控制函数

2.4.4 方向控制函数

range()函数

第三章 基本数据类型

3.1 数字类型及操作

3.2 实例3：天天向上的力量

3.3 字符串类型及操作

3.3.1 字符串类型的表示

3.3.2 字符串操作符

3.3.3 字符串处理函数

3.3.4 字符串处理方法

3.3.5 字符串类型的格式化

3.4 模块2：time库的使用

3.4.1 time库的基本介绍

3.4.2 时间获取

3.4.3 时间格式化

3.4.4 程序计时应用

3.5 实例4：文本进度条

第四章 程序的控制结构

4.1 程序的分支结构

4.1.1 单分支结构

4.1.2 二分支结构

4.1.3 多分支结构

4.1.4 条件判断及组合

4.1.5 程序的异常处理

4.2 实例5：身体质量指数BMI

4.3 程序的循环结构

4.3.1 遍历循环

4.3.2 无限循环

4.3.3 循环控制保留字

4.3.4 循环的高级用法

4.4 模块3：random库的使用

4.4.1 random 标准库之一

4.4.2 基本随机函数

4.4.3 扩展随机数函数

4.5 实例6：圆周率的计算

4.5.1 蒙特卡洛方法

第五章：函数的定义与使用

5.1.1 函数的理解和定义

5.1.2 函数的使用及调用过程

5.1.3 函数的参数传递

5.1.4 函数的返回值

5.1.5 局部变量和全局变量

5.1.6 lambda函数

5.2 七段数码管 绘制

5.2.1 基本思路

代码

5.2.2 理解思维方法

5.2.3 举一反三

5.3 代码复用与函数递归

5.3.1 代码复用与模块化设计

5.3.2 函数递归的理解

5.3.3 函数递归的调用过程

5.3.4 函数递归实例解析

5.4 模块：PyInstaller库的使用

第三章基本数据类型

第四章程序的控制结构

5.2 七段数码管绘制

第六章组合数据类型

第七章文件和数据格式化

第八章程序设计方法学