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

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

计算机与程序设计

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

编译和解释

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

程序的基本写法

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

计算机编程

能够训练思维：

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

实例1 --温度转换

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

Python程序语法元素分析

程序的格式框架

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

命名与保留字

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

import keyword
print(keyword.kwlist)

数据类型

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

补充

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

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

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

2. 评估函数eval()

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

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

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

语句与函数

赋值语句
分支语句
函数

Python程序的输入输出

1. input（）控制台输入
2. 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 画笔控制函数

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

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

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

3. turtle.pensize(width) 别名 turtle.width(width)
   画笔宽度，海龟的腰围

4. 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 运动控制函数

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

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

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

2.4.4 方向控制函数

1. turtle.setheading(angle) 别名： seth(angle)
   改变行进方向，海龟走角度
2. 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+89j
  Z.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 字符串处理方法

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

2. – S.replace(old,new)
   – S.center(width[,fillchar])
   
   “python”.center(20,"=") 结果为 ‘=python=’
   在一个20字符的宽度中，让我们的python字符居中，同时在空余的部分用等号来填充。

3. – S.strip(chars)从str中去掉在其左侧和右侧chars中列出的字符。
   – S.join(iter) 在iter变量除最后元素外每个元素增加一个S。例如：’,’.join(“12345”) #主要用于字符串分割
   

3.3.5 字符串类型的格式化

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

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

所有字符都用英文半角

3.4 模块2：time库的使用

3.4.1 time库的基本介绍

1. 时间获取：time() ctime() gmtime()
   
   
   gmtime（）得到一个计算机内部可以操作的时间，struct_time格式

2. 时间格式化： strftime() ，strptime()

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

3. 程序计时：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 程序计时应用

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

• 测量时间：perf_counter()，非常精准
• 产生时间：sleep()，让程序去休眠或产生一点时间
  
  start = time.perf_counter()
  end = time.perf_counter()
  end - start

2. 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) * 100
    dur = time.perf_counter() - start
    # 给end赋值空字符串，可以是print每一次输出字符串之后不会增加换行，只会把光标停留在当次输出字符串的后面
    # 这里的\r
    print("\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)
略
注：阅读代码的时候，快速的方法是：先搞懂分支的范围关系，再深入看每个分支在做什么。而不是从上到下的顺序结构。

1. 国际标准

#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))

2. 国内标准

#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))

3. 国内国外合并

#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 基本随机函数

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

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

2. random()

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

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

4.4.3 扩展随机数函数

1. randint(a,b) 生成[a,b]之间的整数
2. randrange(m,n[,k]) 生成一个[m,n)之间以k为步长的随机整数
3. getrandbits(k) 生成一个k比特长的随机整数
4. uniform(a,b) 生成一个[a,b]之间的随机小数
5. choice(seq) 从序列seq中随机选择一个元素
6. 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函数

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

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

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

5.2 七段数码管 绘制

5.2.1 基本思路

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

1.分析单个数码管：

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

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

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

3. 获取当前系统时间：

• 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 实例讲解

代码主要思路：

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

#CalStatisticsV1.py
def getNum():       #获取用户不定长度的输入
    nums = []
    iNumStr = input("请输入数字(回车退出): ")
    while iNumStr != "":
        nums.append(eval(iNumStr))
        iNumStr = input("请输入数字(回车退出): ")
    return nums
 
def mean(numbers):  #计算平均值
    s = 0.0
    for num in numbers:
        s = s + num
    return s / len(numbers)
 
def dev(numbers, mean): #计算方差
    sdev = 0.0
    for num in numbers:
        sdev = sdev + (num - mean)**2
     # 方差公式就是除以n-1
    return 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])/2
    else:
        med = numbers[size//2]
    return med
 
n =  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 txt
 
hamletTxt = 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:
        continue
    elif word == "诸葛亮" or word == "孔明曰":
        rword = "孔明"
    elif word == "关公" or word == "云长":
        rword = "关羽"
    elif word == "玄德" or word == "玄德曰":
        rword = "刘备"
    elif word == "孟德" or word == "丞相":
        rword = "曹操"
    else:
        rword = word
    counts[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库是标准库，包含几百个函数，常用路径操作、进程管理、环境参数等几类

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

• 路径操作：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个字节长度的随机字符串，通常用于加解密运算