北理工嵩天Python语言程序设计笔记

---

1 背景

1. 北理工 嵩天/黄天宇/礼欣 Python语言程序设计
2. 实践、认识、再实践、再认识。。。这就是辩证唯物论的全部认识论，这就是辩证唯物论的知行统一观。——教员《实践论》
3. 快速入门（2）、基础语法（5）、编程思维（2）
4. 每周1~2小时，连续9周

2 Python基本语法元素

2.1 程序设计基本方法

2.1.1 计算机与程序设计

• 计算机：功能性；可编程性

• 计算机的发展参照摩尔定律，表现为指数方式

• 程序设计，亦称编程

• 程序设计语言，亦称编程语言，程序设计的具体实现方式

2.1.2 编译和解释

• 计算机执行源程序的两种方式：编译和解释

• 源代码（人类可读） & 目标代码（人类不可读(专家除外)）

• 编译：将源代码一次性转换成目标代码的过程 （英文翻译）

  解释：将源代码逐条转换成目标代码同时逐条运行的过程（同声传译）

• 静态语言：使用编译执行的编程语言：C/C++语言、Java语言

  脚本语言：使用解释执行的编程语言：Python语言、JavaScript语言、PHP语言

2.1.3 程序的基本编写方法

• IPO

  I：Input 输入，程序的输入

  P：Process 处理，程序的主要逻辑

  O：Output 输出，程序的输出

• 编程解决问题的步骤

  • 分析问题
  • 划分边界
  • 设计算法
  • 编写程序
  • 调试测试
  • 升级维护

• 求解计算问题的精简步骤

  确定IPO、编写程序、调试程序

2.1.4 计算机编程

训练思维、增进认识、带来乐趣、提高效率、就业机会

2.2 Python开发环境配置

2.2.1 Python语言概述

• Python “蟒蛇”——Guido van Rossum
• Python语言拥有者是Python Software Foundation(PSF)
• Python来源——Monty Python组合

2.2.2 Python程序编写与运行

• 交互式和文件式

2.2.3 实例1: 温度转换

#TempConvert.py
TempStr = input("请输入带有符号的温度值: ")
if TempStr[-1] in ['F', 'f']:
    C = (eval(TempStr[0:-1]) - 32)/1.8
    print("转换后的温度是{:.2f}C".format(C))
elif TempStr[-1] in ['C', 'c']:
    F = 1.8*eval(TempStr[0:-1]) + 32
    print("转换后的温度是{:.2f}F".format(F))
else:
    print("输入格式错误")

2.3 Python程序语法元素分析

2.3.1 程序的格式框架

• 代码高亮

• 缩进表达程序的格式框架，长度一致，程序内一致即可，一般用4个空格或1个TAB

• 注释

  单行注释：以#开头，其后内容为注释

  多行注释：以’’'开头和结尾

2.3.2 命名与保留字

• 变量：用来保存和表示数据的占位符号

• 命名：关联标识符的过程

  命名规则: 大小写字母、数字、下划线和中文等字符及组合

  注意事项: 大小写敏感、首字符不能是数字、不与保留字相同

• 保留字：也叫关键字，基本单词，大小写敏感

2.3.3 数据类型

• 字符串：由0个或多个字符组成的有序字符序列，由一对单引号或一对双引号表示，

  1. 正向递增序号（0考试）和反向递减序号（-1开始）
  2. 使用[ ]获取字符串中一个或多个字符：
     • 索引：<字符串>[M]
     • 切片：<字符串>[M: N]，前闭后开

• 数字类型：整数和浮点数都是数字类型

• 列表类型：由0个或多个数据组成的有序序列

  1. 列表使用[ ]表示，采用逗号(,)分隔各元素

  2. 使用保留字in 判断一个元素是否在列表中

2.3.4 语句与函数

• 赋值语句：由赋值符号构成的一行代码
• 分支语句：由判断条件决定程序运行方向的语句，冒号及后续缩进用来表示后续语句与条件的所属关系。
• 函数：根据输入参数产生不同输出的功能过程

2.3.5 Python程序的输入输出

• input()：从控制台获得用户输入的函数

  input()函数的使用格式：
  <变量> =input(<提示信息字符串>)

• print()：以字符形式向控制台输出结果的函数

  print(<拟输出字符串或字符串变量>)

  字符串类型的一对引号仅在程序内部使用，输出无引号

  print("Hello:",i) # 其中的逗号有空格的作用
  print('1' + '2')
  print(chr(9800 + i), end="") # end可以设置输出是否换行，默认换行
  

• print()函数的格式化

  print("转换后的温度是{:.2f}C".format(C))
  

  { }表示槽，后续变量填充到槽中；{:.2f }表示将变量C填充到这个位置时取小数点后2位

• eval()：去掉参数最外侧引号并执行余下语句的函数

  >>>eval("1")
  1
  >>>eval("1+2")
  3
  >>>eval('"1+2"') 
  '1+2'
  >>>eval('print("Hello")') 
  Hello
  

3 Python基本图形绘制

3.1 深入理解Python语言

3.1.1 计算机技术的演进

1946-1981：计算机系统结构时代

1981-2008：网络和视窗时代

2008-2016：复杂信息系统时代

2017-：人工智能时代

3.1.2 编程语言的多样初心

各编程语言所处历史时期和使命不同，Python是计算时代演进的选择！

3.1.3 Python语言的特点

Python语言是通用语言

语法简洁、生态高产

人生苦短，我学Python

全栈能力

3.1.4 "超级语言"的诞生

机器语言-汇编语言-高级语言-超级语言

3.2 实例2: Python蟒蛇绘制

#PythonDraw.py
import turtle
turtle.setup(650, 350, 200, 200)
turtle.penup()
turtle.fd(-250)
turtle.pendown()
turtle.pensize(25)
turtle.pencolor("purple")
turtle.seth(-40)
for i in range(4):
    turtle.circle(40, 80)
    turtle.circle(-40, 80)
turtle.circle(40, 80/2)
turtle.fd(40)
turtle.circle(16, 180)
turtle.fd(40 * 2/3)
turtle.done()

3.3 模块1: turtle库的使用

3.3.1 turtle库基本介绍

• turtle(海龟)库是turtle绘图体系的Python实现，Python语言的标准库之一
• Python计算生态= 标准库+ 第三方库
• 库Library、包Package、模块Module，统称模块
• turtle(海龟)是一种真实的存在，有一只海龟，其实在窗体正中心，在画布上游走

3.3.2 turtle绘图窗体布局

3.3.3 turtle空间坐标体系

绝对坐标：turtle.goto(x, y)

海龟坐标：turtle.fd(d)、turtle.bk(d)、turtle.circle(r,angle)

3.3.4 turtle角度坐标体系

绝对角度：seth()改变海龟行进方向：turtle.seth(angle) seth()只改变方向但不行进

海龟角度：turtle.left(angle)、turtle.right(angle)

3.3.5 RGB色彩体系

默认采用小数值可切换为整数值，turtle.colormode(mode)

1.0：RGB小数值模式；255：RGB整数值模式

3.3.6 写字

turtle.write(‘年’,font=(“Arial”, 18, “normal”))

3.3.7 隐藏海龟

turtle.hideturtle()
turtle.done()

3.4 turtle程序语法元素分析

3.4.1 库引用与import

• import <库名> ；<库名>.<函数名>(<函数参数>)

• from <库名> import<函数名>，from <库名> import *；<函数名>(<函数参数>)

• 给调用的外部库关联一个更短、更适合自己的名字

  import <库名> as <库别名> ；<库别名>.<函数名>(<函数参数>)

3.4.2 turtle画笔控制函数

• turtle.penup() 别名 turtle.pu() 抬起画笔，海龟在飞行

• turtle.pendown() 别名 turtle.pd() 落下画笔，海龟在爬行

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

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

• turtle.pencolor(color) color为颜色字符串或r,g,b值 画笔颜色，海龟在涂装

  pencolor(colorstring)
  pencolor(r,g,b)
  pencolor((r,g,b))

3.4.3 turtle运动控制函数

• turtle.forward(d) 别名turtle.fd(d) 向前行进，海龟走直线

• turtle.circle(r, extent=None) 根据半径r绘制extent角度的弧形

  r: 默认圆心在海龟左侧r距离的位置

  extent: 绘制角度，默认是360度整圆

3.4.4 turtle方向控制函数

• turtle.setheading(angle) 别名 turtle.seth(angle) 改变行进方向，海龟走角度
• turtle.left(angle) 海龟向左转
• turtle.right(angle) 海龟向右转

3.4.5 循环语句与range()函数

• 循环语句

for <变量> in range (<次数>):
<被循环执行的语句>

<变量>表示每次循环的计数，0到<次数>-1

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

4 基本数据类型

4.1 数字类型及操作

4.1.1 整数类型

• 可正可负，没有取值范围限制

• pow(x,y)函数：计算$x^y$ ，想算多大算多大

• 4种进制表示形式

  • 十进制：1010, 99, -217
  • 二进制，以0b或0B开头：0b010, -0B101
  • 八进制，以0o或0O开头：0o123, -0O456
  • 十六进制，以0x或0X开头：0x9a, -0X89

4.1.2 浮点数类型

• 带有小数点及小数的数字

• 浮点数间运算存在不确定尾数

  >>>0.1 + 0.3
  0.4
  >>>0.1 + 0.2
  0.30000000000000004
  

• round(x, d)：对x四舍五入，d是小数截取位数

• 浮点数间运算与比较用round()函数辅助

• 浮点数可以采用科学计数法表示，使用字母e或E作为幂的符号，以10为基数，格式如下：
  e 。4.3e-3值为0.0043 9.6E5值为960000.0

4.1.3 复数类型

z= 1.23e-4+5.6e+89j

z.real获得实部，z.imag获得虚部

4.1.4 数值运算操作符

• 二元操作符有对应的增强赋值操作符

• 类型间可进行混合运算，生成结果为"最宽"类型，整数->浮点数-> 复数

4.1.5 数值运算函数

一些以函数形式提供的数值运算功能

4.2 实例3: 天天向上的力量

#DayDayUpQ1.py
dayup= pow(1.001, 365)
daydown= pow(0.999, 365)
print("向上：{:.2f}，向下：{:.2f}".format(dayup, daydown))

#DayDayUpQ3.py
dayup= 1.0
dayfactor = 0.01
for i in range(365):
	if i% 7 in [6,0]:
		dayup= dayup*(1-dayfactor)
	else:
		dayup= dayup*(1+dayfactor)
print("工作日的力量：{:.2f}".format(dayup))

#DayDayUpQ4.py
def dayUP(df):
	dayup= 1
	for i in range(365):
		if i % 7 in [6,0]:
			dayup= dayup*(1 -0.01)
		else:
			dayup= dayup*(1 + df)
	return	dayup
dayfactor= 0.01
while dayUP(dayfactor) < 37.78:
	dayfactor+= 0.001
print("工作日的努力参数是：{:.3f}".format(dayfactor))

4.3 字符串类型及操作

4.3.1 字符串类型的表示

• 字符串由一对单引号或一对双引号表示，字符串是字符的有序序列，可以对其中的字符进行索引，从0开始；

• 字符串有2类共4种表示方法：

  • 由一对单引号或双引号表示，仅表示单行字符串

  • 由一对三单引号或三双引号表示，可表示多行字符串（多行注释）

  • 在字符串中包含双引号或单引号：

    '这里有个双引号(")‘或者"这里有个单引号(’)"

    ‘’‘这里既有单引号(’)又有双引号(") ‘’’

• 字符串的使用：索引，返回字符串中单个字符；切片：返回字符串中一段字符子串。

• 使用[M:N: K]根据步长对字符串切片，M缺失表示至开头，N缺失表示至结尾，根据步长K对字符串切片；[::-1] 逆序

• 转义符\

  • 转义符表达特定字符的本意，“这里有个双引号(”)"

  • 转义符形成一些组合，表达一些不可打印的含义

    “\b"回退，”\n"换行(光标移动到下行首)，"\r"回车(光标移动到本行首)

4.3.2 字符串操作符

4.3.3 字符串处理函数

• Unicode编码

从0到1114111(0x10FFFF)空间，每个编码对应一个字符

4.3.4 字符串处理方法

• 方法：特指.()风格中的函数()
  
  
  

4.3.5 字符串类型的格式化

• 字符串格式化使用.format()方法，用法如下：

  <模板字符串>.format(<逗号分隔的参数>)

字符串中槽{}的默认顺序与format()中参数的顺序对应

• 槽内部对格式化的配置方式

  { <参数序号> ：<格式控制标记>}
  

>>>"{0:=^20}".format("PYTHON")
'=======PYTHON======='
>>>"{0:*>20}".format("BIT")
'*****************BIT'
>>>"{:10}".format("BIT")
'BIT   ' 
>>>"{0:,.2f}".format(12345.6789)
'12,345.68'
>>>"{0:b},{0:c},{0:d},{0:o},{0:x},{0:X}".format(425)
'110101001,Ʃ,425,651,1a9,1A9'
>>>"{0:e},{0:E},{0:f},{0:%}".format(3.14)
'3.140000e+00,3.140000E+00,3.140000,314.000000%'

4.3.6 f-string 格式化

f-string 格式化 就是在字符串模板前面加上f，然后占位符使用{} ,里面直接放入对应的数据对象。

f'税前薪资是：{salary}元， 缴税：{tax}元， 税后薪资是：{aftertax}元'
print(f'文章中 {{ 符号 出现了 {times1} 次')

Python解释器是3.6 以后的版本才支持，各种设置和format的槽内部是一样的。

采用 f-string 方式格式化的 字符串内容本身就有 { 或者 } 符号，一定要 双写 进行转义，否则会被当成是 格式化占位符。

4.4 模块2: time库的使用

4.4.1time库基本介绍

提供系统级精确计时功能，用于程序性能分析

import time
time.<b>()

4.4.2 时间获取

4.4.3 时间格式化

将时间以合理的方式展示出来

4.4.4 程序计时应用

• 程序计时指测量起止动作所经历时间的过程
• 测量时间：perf_counter()
• 产生时间：sleep()
  
  

4.5 实例4: 文本进度条

4.5.1 需求分析

• 采用字符串方式打印可以动态变化的文本进度条
• 进度条需要能在一行中逐渐变化

4.5.2 简单的开始

#TextProBarV1.py
import time
scale = 10
print("------执行开始------")
for i in range(scale+1):
	a = '*'* i
	b = '.'* (scale -i)
	c = (i/scale)*100
	print("{:^3.0f}%[{}->{}]".format(c,a,b))
	time.sleep(0.1)
print("------执行结束------")

4.5.3 单行动态刷新

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

#TextProBarV2.py
import time
for i in range(101):
	print("\r{:3}%".format(i), end="")
	time.sleep(0.1)

IDLE屏蔽了\r功能

4.5.4 完整效果

#TextProBarV3.py
import time
scale = 50
print("执行开始".center(scale//2,"-"))
start = time.perf_counter()
for i in range(scale+1):
	a = '*'* i
	b = '.'* (scale -i)
	c = (i/scale)*100
	dur= time.perf_counter() -start
	print("\r{:^3.0f}%[{}->{}]{:.2f}s".format(c,a,b,dur),end='')
	time.sleep(0.1)
print("\n"+"执行结束".center(scale//2,'-'))

5 程序的控制结构

5.1 程序的分支结构

5.1.1 单二多分支结构

• 单分支结构

  if <条件> :
  <语句块>

• 二分支结构

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

• 二分支结构紧凑形式：适用于简单表达式的二分支结构

  <表达式1> if <条件> else <表达式2>

  print("猜{}了".format("对" if guess==99 else "错"))
  

• 多分支结构：

  if <条件1> :
  <语句块1>
  elif <条件2> :
  <语句块2>
  ……
  else:
  <语句块N>

5.1.2 条件判断及组合

• 条件判断

<，<=，>=，>，==，！=

• 条件组合

x and y，x or y，notx

5.1.3 程序的异常处理

• 异常处理的基本使用：

try:
<语句块1>
except :
<语句块2>

try :
	num= eval(input("请输入一个整数: "))
	print(num**2)
except :
	print("输入不是整数")

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

try :
	num= eval(input("请输入一个整数: "))
	print(num**2)
except NameError:
	print("输入不是整数")

标注异常类型后，仅响应此类异常，异常类型名字等同于变量名。

• 异常处理的高级使用

  try:
  <语句块1>
  except :
  <语句块2>
  else :
  <语句块3>
  finally :
  <语句块4>

else对应语句块3在不发生异常时执行，finally对应语句块4一定执行

5.2 实例5: 身体质量指数BMI

• BMI：Body Mass Index
  国际上常用的衡量人体肥胖和健康程度的重要标准，主要用于统计分析

• 定义：BMI = 体重(kg) / 身高²(m2)

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

5.3 程序的循环结构

5.3.1 遍历循环

遍历某个结构形成的循环运行方式

for <循环变量> in <遍历结构> :
<语句块>

• 计数循环(N次)

  for i in range(N):
  <语句块>

• 计数循环(特定次)

  for i in range(M,N,K):
  <语句块>

• 字符串遍历循环：s是字符串，遍历字符串每个字符，产生循环

  for c in s:
  <语句块>

• 列表遍历循环：ls是一个列表，遍历其每个元素，产生循环

  for item in ls:
  <语句块>

• 文件遍历循环：fi是一个文件标识符，遍历其每行，产生循环

  for line in fi:
  <语句块>

5.3.2 无限循环

反复执行语句块，直到条件不满足时结束

while <条件> :
<语句块>

CTRL + C 退出执行

5.3.3 循环控制保留字

• break跳出并结束当前整个循环，执行循环后的语句
• continue结束当次循环，继续执行后续次数循环
• break仅跳出当前最内层循环

5.3.4 循环的高级用法

• 循环与else

  for <变量> in <遍历结构> :
  <语句块1>
  else:
  <语句块2>

  或

  while <条件> :
  <语句块1>
  else:
  <语句块2>

• 当循环没有被break语句退出时，执行else语句块

• else语句块作为"正常"完成循环的奖励

for c in "PYTHON":
	if c == "T":
		continue
	print(c, end="")
else:
	print("正常退出")
    
>>> PYHON正常退出

for c in "PYTHON":
	if c == "T":
		break
	print(c, end="")
else:
	print("正常退出")
    
>>> PY

5.4 模块3: random库的使用

5.4.1 random库基本介绍

• random库是使用随机数的Python标准库
• 伪随机数: 采用梅森旋转算法生成的(伪)随机序列中元素
• random库主要用于生成随机数
• 使用random库: import random

5.4.2 基本随机数函数

随机数种子，随机序列

>>>import random
>>>random.seed(10)
>>>random.random()
0.5714025946899135
>>>random.seed(10)
>>>random.random()
0.5714025946899135

设置种子，产生的随机数就不变了。

5.4.3 扩展随机数函数

一行好几段代码，用分号

5.5 实例6: 圆周率的计算

• 圆周率的近似计算公式

$\pi =\sum _{k=0}^{\infty }[\frac{1}{16^k}(\frac{4}{8k+1}-\frac{2}{8k+4}-\frac{1}{8k+5}-\frac{1}{8k+6})]$

#CalPiV1.py
pi = 0
N  = 100
for k in range(N) :
	pi += 1/pow(16,k)*( \
	4/(8*k+1) –2/(8*k+4) -\
	1/(8*k+5) –1/(8*k+6))
print("圆周率值是: {}".format(pi))

代码后面增加斜杠\换行

• 蒙特卡罗方法

#CalPiV2.py
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 = hits + 1
pi = 4 * (hits/DARTS)
print("圆周率值是: {}".format(pi))
print("运行时间是: {:.5f}s".format(perf_counter()-start))

6 函数和代码复用

6.1 函数的定义与使用

6.1.1 函数的定义

• 降低编程难度和代码复用

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

• 函数定义时，所指定的参数是一种占位符

• 函数定义后，如果不经过调用，不会被执行

• 函数定义时，参数是输入、函数体是处理、结果是输出(IPO)

6.1.2 函数的使用及调用过程

• 调用是运行函数代码的方式

• 调用时要给出实际参数

• 实际参数替换定义中的参数

• 函数调用后得到返回值

6.1.3 函数的参数传递

• 函数可以有参数，也可以没有，但必须保留括号

  def <函数名>():
  <函数体>
  return <返回值>

• 可选参数传递，可选参数需要放在非可选参数后面，并且赋初值 def fact(n,m=1) :

  def <函数名>(<非可选参数>,<可选参数>):
  <函数体>
  return <返回值>

  def fact(n,m=1) :
  	s = 1
  	for i in range(1, n+1):
  		s *= i
  	return s//m
  

• 函数定义时可以设计可变数量参数，既不确定参数总数量

  def <函数名>(<参数>, *b):
  <函数体>
  return <返回值>

  def fact(n, *b) :
  	s = 1
  	for i inrange(1, n+1):
  		s *= i
  	for item in b:
  		s *= item
  	return s
  
  fact(10,3,5,8)
  

• 函数调用时，参数可以按照位置或名称方式传递

  def fact(n,m=1) :
      
  fact(10,5 )  # 位置传递
  fact( m=5,n=10 )  # 名称传递
  

6.1.4 函数的返回值

• 函数可以返回0个或多个结果

• 函数可以有返回值，也可以没有，可以有return，也可以没有

• return可以传递0个返回值，也可以传递任意多个返回值

  return s//m, n, m
  >>>fact(10,5 )
  (725760, 10, 5)  # 元组
  >>>a,b,c= fact(10,5)
  >>>print(a,b,c)
  725760 10 5
  

6.1.5 局部变量和全局变量

• 局部变量和全局变量是不同变量
  • 局部变量是函数内部的占位符，与全局变量可能重名但不同
  • 函数运算结束后，局部变量被释放
  • 可以使用global保留字在函数内部使用全局变量
• 局部变量为组合数据类型且未创建，等同于全局变量

6.1.6 lambda函数

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

<函数名> = lambda <参数>:<表达式>

等价于

def <函数名>(<参数>):
<函数体>
return <返回值>

>>>f = lambda x, y : x + y
>>>f(10, 15)
25
>>>f = lambda: "lambda函数"
>>>print(f())
lambda函数

• lambda函数主要用作一些特定函数或方法的参数
• lambda函数有一些固定使用方式，建议逐步掌握
• 一般情况，建议使用def定义的普通函数

6.1.7 内置函数

• Python map() 函数

  第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。

  map(function, iterable, ...)
  >>> def square(x) :         # 计算平方数
  ...     return x ** 2
  ... 
  >>> map(square, [1,2,3,4,5])    # 计算列表各个元素的平方
  <map object at 0x100d3d550>     # 返回迭代器
  >>> list(map(square, [1,2,3,4,5]))   # 使用 list() 转换为列表
  [1, 4, 9, 16, 25]
  >>> list(map(lambda x: x ** 2, [1, 2, 3, 4, 5]))   # 使用 lambda 匿名函数
  [1, 4, 9, 16, 25]
  

  Python 2.x 返回列表。Python 3.x 返回迭代器。

6.2 实例7: 七段数码管绘制

import turtle, time


def drawLine(draw):  # 绘制单段数码管

    turtle.pendown() if draw else turtle.penup()
    turtle.fd(40)
    turtle.right(90)


def drawDigit(digit):  # 根据数字绘制七段数码管
    drawLine(True) if digit in [2, 3, 4, 5, 6, 8, 9] else drawLine(False)
    drawLine(True) if digit in [0, 1, 3, 4, 5, 6, 7, 8, 9] else drawLine(False)
    drawLine(True) if digit in [0, 2, 3, 5, 6, 8, 9] else drawLine(False)
    drawLine(True) if digit in [0, 2, 6, 8] else drawLine(False)
    turtle.left(90)
    drawLine(True) if digit in [0, 4, 5, 6, 8, 9] else drawLine(False)
    drawLine(True) if digit in [0, 2, 3, 5, 6, 7, 8, 9] else drawLine(False)
    drawLine(True) if digit in [0, 1, 2, 3, 4, 7, 8, 9] else drawLine(False)
    turtle.left(180)
    turtle.penup()  # 为绘制后续数字确定位置
    turtle.fd(20)  # 为绘制后续数字确定位置

def drawDate(date):   #data为日期，格式为'%Y-%m=%d+'
    turtle.pencolor("red")
    for i in date:
        if i== '-':
            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(-300)
    turtle.pensize(5)
    drawDate(time.strftime('%Y-%m=%d+', time.gmtime()))
    turtle.hideturtle()
    turtle.done()


main()

6.3 代码复用与函数递归

6.3.1 代码复用与模块化设计

• 代码复用：函数和对象是代码复用的两种主要形式
• 模块化设计：分而治之，模块内部紧耦合、模块之间松耦合

6.3.2 函数递归的理解

• 函数定义中调用函数自身的方式

• 链条：计算过程存在递归链条

• 基例：存在一个或多个不需要再次递归的基例

• 递归是数学归纳法思维的编程体现

6.3.3 递归的实现

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

eg. 斐波那契数列、汉诺塔

6.4 模块4: PyInstaller库的使用

• 将.py源代码转换成无需源代码的可执行文件

(cmd命令行) pyinstaller -F <文件名.py>

pyinstaller –i curve.ico –F SevenDigitsDrawV2.py

6.5 实例8: 科赫雪花小包裹

科赫雪花

import turtle


def koch(size, n):
    if n == 0:
        turtle.fd(size)
    else:
        for angle in [0, 60, -120, 60]:
            turtle.left(angle)
            koch(size / 3, n - 1)


def main():
    turtle.setup(800, 400)
    turtle.penup()
    turtle.goto(-300, -50)
    turtle.pendown()
    turtle.pensize(2)
    koch(600, 3)  # 3阶科赫曲线，阶数
    turtle.hideturtle()
    turtle.done()


main()

7 组合数据类型

7.1 集合类型及操作

7.1.1集合类型的定义

• 集合类型与数学中的集合概念一致

• 集合元素之间无序，每个元素唯一，不存在相同元素

• 集合元素不可更改，不能是可变数据类型

• 集合用大括号{} 表示，元素间用逗号分隔

• 建立集合类型用{} 或set()

• 建立空集合类型，必须使用set()，{}无法生成空集合，因为它生成了空字典

>>>A = {"python", 123, ("python",123)}  #使用{}建立集合
{123, 'python', ('python', 123)}
>>>B = set("pypy123")         #使用set()建立集合
{'1', 'p', '2', '3', 'y'}
>>>C = {"python", 123, "python",123}
{'python', 123}

7.1.2 集合操作符

7.1.3 集合处理方法

try:
    while True:
    	print(A.pop(), end="")
except: 
	pass

7.1.4 集合类型应用场景

• 数据去重：集合类型所有元素无重复

>>>ls = ["p", "p", "y", "y", 123]
>>>s = set(ls)    # 利用了集合无重复元素的特点
{'p', 'y', 123}
>>>lt= list(s)   # 还可以将集合转换为列表
['p', 'y', 123]

7.2序列类型及操作

7.2.1 序列类型定义

• 序列是一维元素向量，元素类型可以不同

• 元素间由序号引导，通过下标访问序列的特定元素

• 字符串类型、元组类型、列表类型

7.2.2 序列处理函数及方法

• 序列类型通用操作符
  
  

7.2.3 元组类型及操作

• 元组是一种序列类型，一旦创建就不能被修改

• 使用小括号() 或tuple() 创建，元素间用逗号, 分隔

• 可以使用或不使用小括号

>>>creature = "cat", "dog","tiger","human"
>>>creature 
('cat', 'dog', 'tiger', 'human')
>>>color = (0x001100, "blue", creature)
>>>color
(4352, 'blue', ('cat', 'dog', 'tiger', 'human'))

• 元组继承了序列类型的全部通用操作
• 元组因为创建后不能修改，因此没有特殊操作

7.2.4 列表类型及操作

• 列表是一种序列类型，创建后可以随意被修改

• 使用方括号[] 或list() 创建，元素间用逗号, 分隔

• 列表中各元素类型可以不同，无长度限制

• sorted(ls)：按递增顺序排序，列表被改变

• 
  

• List sort()方法

list.sort(cmp=None, key=None, reverse=False)

cmp – 可选参数, 如果指定了该参数会使用该参数的方法进行排序。

key – 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。

reverse – 排序规则，reverse = True 降序， reverse = False 升序（默认）。

7.2.5序列类型应用场景

数据保护：如果不希望数据被程序所改变，转换成元组类型

7.3 实例9: 基本统计值计算

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

7.4字典类型及操作

7.4.1 字典类型定义

• 键值对：键是数据索引的扩展
• 字典是键值对的集合，键值对之间无序
• 采用大括号{}和dict()创建，键值对用冒号: 表示
  {<键1>:<值1>, <键2>:<值2>, … , <键n>:<值n>}

>>>d = {"中国":"北京","美国":"华盛顿","法国":"巴黎"}
>>>d 
{'中国': '北京', '美国': '华盛顿', '法国': '巴黎'}
>>>d["中国"]
'北京'
>>> de = {} ; type(de) # 空字典
<class 'dict'>

7.4.2 字典处理函数及方法

>>>d = {"中国":"北京","美国":"华盛顿","法国":"巴黎"}
>>>"中国"in d 
True
>>>d.keys()
dict_keys(['中国', '美国', '法国'])
>>>d.values()
dict_values(['北京', '华盛顿', '巴黎'])

>>>d = {"中国":"北京","美国":"华盛顿","法国":"巴黎"}
>>>d.get("中国","伊斯兰堡")
'北京'
>>>d.get("巴基斯坦","伊斯兰堡")
'伊斯兰堡' 
>>>d.popitem()
('美国', '华盛顿')

7.4.3 字典类型应用场景

元素遍历
for k in d:
<语句块>

7.5 模块5: jieba库的使用

7.5.1 jieba库基本介绍

• 中文文本需要通过分词获得单个的词语
• jieba是优秀的中文分词第三方库，需要额外安装
• jieba库提供三种分词模式，最简单只需掌握一个函数

7.5.2 jieba分词的原理

• 利用一个中文词库，确定中文字符之间的关联概率
• 中文字符间概率大的组成词组，形成分词结果
• 除了分词，用户还可以添加自定义的词组

7.5.3 jieba库使用说明

• 精确模式：把文本精确的切分开，不存在冗余单词
• 全模式：把文本中所有可能的词语都扫描出来，有冗余
• 搜索引擎模式：在精确模式基础上，对长词再次切分
• 
  

7.6 实例10: 文本词频统计

• 文本去噪及归一化

• 使用字典表达词频

• 文本词频统计

  • 英文文本：Hamet
    分析词频
    https://python123.io/resources/pye/hamlet.txt
  • 中文文本：《三国演义》分析人物
    https://python123.io/resources/pye/threekingdoms.txt

7.6.1 Hamlet英文词频统计

def getText():
    txt = open("hamlet.txt", "r").read()
    txt = txt.lower()
    for ch in '!"#$%&()*+,-./:;<=>?@[\\]^_‘{|}~':
        txt = txt.replace(ch, " ")
    return txt


hamletTxt = getText()
words = hamletTxt.split()
counts = {}
for word in words:
    counts[word] = counts.get(word, 0) + 1
items = list(counts.items())
items.sort(key=lambda x: x[1], reverse=True) # 按照x的第1（从0开始）个元素排序
for i in range(10):
    word, count = items[i]
    print("{0:<10}{1:>5}".format(word, count))

7.6.2 《三国演义》人物出场统计"实例

import jieba

txt = open("threekingdoms.txt", "r", encoding="utf-8").read()
words = jieba.lcut(txt)
counts = {}
for word in words:
    if len(word) == 1:
        continue
    else:
        counts[word] = counts.get(word, 0) + 1
items = list(counts.items())
items.sort(key=lambda x: x[1], reverse=True)
for i in range(15):
    word, count = items[i]
    print("{0:<10}{1:>5}".format(word, count))

将词频与人物相关联，面向问题

import jieba

txt = open("threekingdoms.txt", "r", encoding="utf-8").read()
excludes = {"将军", "却说", "荆州", "二人", "不可", "不能", "如此"}
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))

8 文件和数据格式化

8.1文件的使用

8.1.1 文件的类型

• 文件是数据的抽象和集合

• 文件展现形态：文本文件和二进制文件

  • 本质上，所有文件都是二进制形式存储
  • 形式上，所有文件采用两种方式展示

• 文本文件：由单一特定编码组成的文件，由于存在编码，也被看成是存储着的长字符串：.txt文件、.py文件等

• 二进制文件：直接由比特0和1组成，没有统一字符编码，.png文件、.avi文件等

8.1.2 文件的打开和关闭

• 文件处理的步骤:打开-操作-关闭
  

• 文件的打开
  
  注意：Windows路径使用\，\ 在Python中为转义字符，所以用 / 或者 \\ 表示 \ ，

“D:/PYE/f.txt”；“D:\\PYE\\f.txt”；“f.txt”；"./PYE/f.txt"

• 文件的关闭

<变量名>.close()

# 文本形式打开文件
tf= open("f.txt", "rt")
print(tf.readline())
tf.close()
# 二进制形式打开文件
bf = open("f.txt", "rb")
print(bf.readline())
bf.close()

8.1.3 文件内容的读取

注意：它们读完之后再读是接着后面读，不是从头开始，文件操作指针停在当前位置。

• 按数量读入，逐步处理

  fname= input("请输入要打开的文件名称:")
  fo= open(fname,"r")
  txt = fo.read(2)
  while txt != "":
      #对txt进行处理
      txt= fo.read(2)
  fo.close()
  

• 一次读入，分行处理

  fname= input("请输入要打开的文件名称:")
  fo= open(fname,"r")
  for line in fo.readlines():
  	print(line)
  fo.close()
  

• 分行读入，逐行处理

  fname= input("请输入要打开的文件名称:")
  fo= open(fname,"r")
  for line in fo:
  	print(line)
  fo.close()
  

8.1.4 数据的文件写入

fo= open("output.txt","w+")
ls = ["中国","法国","美国"]
fo.writelines(ls)
for line in fo:
	print(line)
fo.close()
>>> (没有任何输出)

fo= open("output.txt","w+")
ls = ["中国","法国","美国"]
fo.writelines(ls)
fo.seek(0)
for line in fo:
	print(line)
fo.close()
>>> 中国法国美国

8.1.5 with 语句和写入缓冲

(以下内容参考http://www.python3.vip/tut/py/basic/13/)

如果我们开发的程序 在进行文件读写之后，忘记使用close方法关闭文件， 就可能造成意想不到的问题。

我们可以使用with 语句 打开文件，像这样，就不需要我们调用close方法关闭文件。 Python解释器会帮我们调用文件对象的close方法。

如下

# open返回的对象 赋值为 变量 f
with open('tmp.txt') as f:
    linelist = f.readlines() 
    for line in linelist:
        print(line)

对文件的操作都放在with下面的缩进的代码块中。

• 写入缓冲

执行write方法写入字节到文件中的时候，其实只是把这个请求提交给 操作系统。

操作系统为了提高效率，通常并不会立即把内容写到存储文件中， 而是写入内存的一个 缓冲区 。

等缓冲区的内容堆满之后，或者程序调用close 关闭文件对象的时候，再写入到文件中。

如果你确实希望，在调用write之后，立即把内容写到文件里面，可以使用 文件对象的 flush方法f.flush()。

8.2 实例11: 自动轨迹绘制

• 步骤1：定义数据文件格式（接口）
• 步骤2：编写程序，根据文件接口解析参数绘制图形
• 步骤3：编制数据文件

#AutoTraceDraw.py
import turtle as t
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","")
	datals.append(list(map(eval, line.split(","))))
f.close()
#自动绘制
fori in range(len(datals)):
    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])

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

8.3.1 数据组织的维度

• 一维数据：由对等关系的有序或无序数据构成，采用线性方式组织，对应列表、数组和集合等概念
• 二维数据：由多个一维数据构成，是一维数据的组合形式，表格
• 多维数据：由一维或二维数据在新维度上扩展形成
• 高维数据：仅利用最基本的二元关系展示数据间的复杂结构，键值对
• 数据的操作周期：存储<-> 表示<-> 操作

8.3.2 一维数据的表示

• 如果数据间有序：使用列表类型
• 如果数据间无序：使用集合类型

8.3.3 一维数据的存储

• 存储方式一：空格分隔
• 存储方式二：逗号分隔
• 存储方式三：其他方式：使用其他符号或符号组合分隔，建议采用特殊符号

8.3.4 一维数据的处理

• 一维数据的读入处理：从空格分隔的文件中读入数据

  txt= open(fname).read()
  ls = txt.split()
  f.close()
  

• 一维数据的写入处理：采用空格分隔方式将数据写入文件

  ls = ['中国','美国','日本']
  f = open(fname, 'w')
  f.write(''.join(ls))
  f.close()
  

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

8.4.1 二维数据的表示

• 列表类型可以表达二维数据
• 使用二维列表，使用两层for循环遍历每个元素

8.4.2 CSV数据存储格式

• CSV: Comma-Separated Values

• 国际通用的一二维数据存储格式，一般.csv扩展名

• 每行一个一维数据，采用逗号分隔，无空行

• Excel和一般编辑软件都可以读入或另存为csv文件

• 如果某个元素缺失，逗号仍要保留

• 二维数据的表头可以作为数据存储，也可以另行存储

• 逗号为英文半角逗号，逗号与数据之间无额外空格

8.4.3 二维数据的存储

• 一般索引习惯：ls[row][column]，先行后列
• 根据一般习惯，外层列表每个元素是一行，按行存

8.4.4 二维数据的处理

• 从CSV格式的文件中读入数据

  fo= open(fname)
  ls = []
  for line in fo:
      line = line.replace("\n","")
      ls.append(line.split(",")) 
  fo.close()
  

• 将数据写入CSV格式的文件

  ls = [[],[],[]] #二维列表
  f = open(fname, 'w')
  for item inls:
  	f.write(','.join(item) + '\n') 
  f.close()
  

• 二维数据的逐一处理

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

8.5 模块6: wordcloud库的使用

• wordcloud是优秀的词云展示第三方库

8.6.1 wordcloud库使用说明

• wordcloud.WordCloud()代表一个文本对应的词云
• 可以根据文本中词语出现的频率等参数绘制词云
• 词云的绘制形状、尺寸和颜色都可以设定

8.6.2 wordcloud库常规方法

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

8.6.3 配置对象参数

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)
w.generate(" ".join(jieba.lcut(txt)))
w.to_file("pywcloud.png")

8.6 实例12: 政府工作报告词云

政府工作报告等文 -> 有效展示的词云

import jieba
import wordcloud

f = open("新时代中国特色社会主义.txt", "r", encoding="utf-8")
t = f.read()
f.close()
ls = jieba.lcut(t)
txt = " ".join(ls)
w = wordcloud.WordCloud(font_path="msyh.ttc",
                        width=1000, height=700, background_color="white",
                        stopwords={'的', '和', '是', '在', '以', '为', '对'})
w.generate(txt)
w.to_file("grwordcloud.png")

• 更有形的词云

from imageio import imread
mask = imread("5.png")

• 中华人民共和国国民经济和社会发展第十四个五年规划和2035年远景目标纲要
  

9 程序设计方法学

9.1 实例13: 体育竞技分析

• 体育竞技分析：模拟N场比赛

  • 计算思维：抽象+ 自动化
  • 模拟：抽象比赛过程+ 自动化执行N场比赛
  • 当N越大时，比赛结果分析会越科学

• 自顶向下（分而治之）

  • 将一个总问题表达为若干个小问题组成的形式
  • 使用同样方法进一步分解小问题
  • 直至，小问题可以用计算机简单明了的解决

• 自底向上(执行)（模块化集成）

  • 逐步组建复杂系统的有效测试方法
  • 分单元测试，逐步组装
  • 按照自顶向下相反的路径操作
  • 直至，系统各部分以组装的思路都经过测试和验证

9.2 Python程序设计思维

9.2.1 计算思维与程序设计

• 逻辑思维：推理和演绎，数学为代表，A->B B->C A->C

• 实证思维：实验和验证，物理为代表，引力波<-实验

• 计算思维：设计和构造，计算机为代表，汉诺塔递归

  Computational Thinking 抽象问题的计算过程，利用计算机自动化求解

9.2.2 计算生态与Python语言

• 竞争发展；相互依存；迅速更迭
• 创新：跟随创新、集成创新、原始创新

9.2.3 用户体验与软件产品

• 方法1：进度展示

  • 如果程序需要计算时间，可能产生等待，请增加进度展示
  • 如果程序有若干步骤，需要提示用户，请增加进度展示
  • 如果程序可能存在大量次数的循环，请增加进度展示

• 方法2：异常处理

  • 当获得用户输入，对合规性需要检查，需要异常处理
  • 当读写文件时，对结果进行判断，需要异常处理
  • 当进行输入输出时，对运算结果进行判断，需要异常处理

• 其他类方法

  • 打印输出：特定位置，输出程序运行的过程信息
  • 日志文件：对程序异常及用户使用进行定期记录
  • 帮助信息：给用户多种方式提供帮助信息

9.2.4 基本的程序设计模式

• 自顶向下设计
• 模块化设计
• 配置化设计：引擎+配置：程序执行和配置分离，将可选参数配置化
• 应用开发：产品定义，系统架构，设计与实现，用户体验

9.3 Python第三方库安装

9.3.1 看见更大的Python世界

• PyPI: Python Package Index
• https://pypi.org/

9.3.2 第三方库的pip安装方法

pip –h
pip install <第三方库名>  # 安装指定的第三方库
pip install –U <第三方库名>  # 使用-U标签更新已安装的指定第三方库
pip uninstall <第三方库名>  # 卸载指定的第三方库
pip download <第三方库名>  # 下载但不安装指定的第三方库
pip show <第三方库名>  # 列出某个指定第三方库的详细信息
pip search <关键词>  # 根据关键词在名称和介绍中搜索第三方库
pip list  # 列出当前系统已经安装的第三方库

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

• 集成安装：结合特定Python开发工具的批量安装，Anaconda

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

• 某些第三方库pip下载后，需要编译再安装

http://www.lfd.uci.edu/~gohlke/pythonlibs/

pip install <文件名>

Python官方文档：https://docs.python.org/zh-cn/3/

9.4 模块7: os库的基本使用

os库提供通用的、基本的操作系统交互功能

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

9.4.1 os库之路径操作

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

import os.path
import os.path as op

9.4.2 os库之进程管理

os.system(command)

• 执行程序或命令command
• 在Windows系统中，返回值为cmd的调用返回信息

import os
os.system("C:\\Windows\\System32\\calc.exe")
>>>
0  # 调用成功，返回0

9.4.3 os库之环境参数

9.5 实例14: 第三方库自动安装脚本

• 需求：批量安装第三方库需要人工干预，能否自动安装？
• 自动执行pip逐一根据安装需求安装

#BatchInstall.py
import os
libs = {"numpy","matplotlib","pillow","sklearn","requests",\
"jieba","beautifulsoup4","wheel","networkx","sympy",\
"pyinstaller","django","flask","werobot","pyqt5",\
"pandas","pyopengl","pypdf2","docopt","pygame"}
try:
    for lib in libs:
    os.system("pip install " + lib)
    print("Successful")        
except:
	print("Failed Somehow")

10 Python计算生态概览

10.1 从数据处理到人工智能

10.1.1 Python库之数据分析

Numpy: 表达N维数组的最基础库

Pandas: Python数据分析高层次应用库

• Series = 索引+ 一维数据
• DataFrame= 行列索引+ 二维数据

SciPy: 数学、科学和工程计算功能库

10.1.2 Python库之数据可视化

Matplotlib: 高质量的二维数据可视化功能库

• 提供了超过100种数据可视化展示效果
• 通过matplotlib.pyplot子库调用各可视化效果
• Python最主要的数据可视化功能库，基于Numpy开发

Seaborn: 统计类数据可视化功能库

• 提供了一批高层次的统计类数据可视化展示效果
• 主要展示数据间分布、分类和线性关系等内容
• 基于Matplotlib开发，支持Numpy和Pandas

Mayavi：三维科学数据可视化功能库

• 提供了一批简单易用的3D科学计算数据可视化展示效果
• 目前版本是Mayavi2，三维可视化最主要的第三方库
• 支持Numpy、TVTK、Traits、Envisage等第三方库

10.1.3 Python库之文本处理

PyPDF2：用来处理pdf文件的工具集

• 提供了一批处理PDF文件的计算功能
• 支持获取信息、分隔/整合文件、加密解密等
• 完全Python语言实现，不需要额外依赖，功能稳定

NLTK：自然语言文本处理第三方库

• 提供了一批简单易用的自然语言文本处理功能
• 支持语言文本分类、标记、语法句法、语义分析等
• 最优秀的Python自然语言处理库

Python-docx：创建或更新Microsoft Word文件的第三方库

• 提供创建或更新.doc.docx等文件的计算功能
• 增加并配置段落、图片、表格、文字等，功能全面

10.1.4 Python库之机器学习

Scikit-learn：机器学习方法工具集

• 提供一批统一化的机器学习方法功能接口
• 提供聚类、分类、回归、强化学习等计算功能
• 机器学习最基本且最优秀的Python第三方库

TensorFlow：机器学习计算框架

• 谷歌公司推动的开源机器学习框架
• 将数据流图作为基础，图节点代表运算，边代表张量
• 应用机器学习方法的一种方式，支撑谷歌人工智能应用

10.2 实例15: 霍兰德人格分析雷达图

• 霍兰德人格分析
  • 霍兰德认为：人格兴趣与职业之间应有一种内在的对应关系
  • 人格分类：研究型、艺术型、社会型、企业型、传统型、现实性
  • 职业：工程师、实验员、艺术家、推销员、记事员、社会工作者

import numpy as np
import matplotlib.pyplot as plt
import matplotlib

matplotlib.rcParams['font.family'] = 'SimHei'
radar_labels = np.array(['研究型(I)', '艺术型(A)', '社会型(S)',
                         '企业型(E)', '常规型(C)', '现实型(R)'])
data = np.array([[0.40, 0.32, 0.35, 0.30, 0.30, 0.88],
                 [0.85, 0.35, 0.30, 0.40, 0.40, 0.30],
                 [0.43, 0.89, 0.30, 0.28, 0.22, 0.30],
                 [0.30, 0.25, 0.48, 0.85, 0.45, 0.40],
                 [0.20, 0.38, 0.87, 0.45, 0.32, 0.28],
                 [0.34, 0.31, 0.38, 0.40, 0.92, 0.28]])  # 数据值
data_labels = ('艺术家', '实验员', '工程师', '推销员', '社会工作者', '记事员')
angles = np.linspace(0, 2 * np.pi, 6, endpoint=False)
data = np.concatenate((data, [data[0]]))
angles = np.concatenate((angles, [angles[0]]))
radar_labels = np.concatenate((radar_labels, [radar_labels[0]]))
fig = plt.figure(facecolor="white")
plt.subplot(111, polar=True)
plt.plot(angles, data, 'o-', linewidth=1, alpha=0.2)
plt.fill(angles, data, alpha=0.25)
plt.thetagrids(angles * 180 / np.pi, radar_labels)
plt.figtext(0.52, 0.95, '霍兰德人格分析', ha='center', size=20)
legend = plt.legend(data_labels, loc=(0.94, 0.80), labelspacing=0.1)
plt.setp(legend.get_texts(), fontsize='large')
plt.grid(True)
plt.savefig('holland_radar.jpg')
plt.show()

10.3 从Web解析到网络空间

10.3.1 Python库之网络爬虫

Requests: 最友好的网络爬虫功能库

Scrapy: 优秀的网络爬虫框架

pyspider: 强大的Web页面爬取系统

10.3.2 Python库之Web信息提取

Beautiful Soup: HTML和XML的解析库

Re: 正则表达式解析和处理功能库

Python-Goose:提取文章类型Web页面的功能库

10.3.3 Python库之Web网站开发

Django: 最流行的Web应用框架

Pyramid: 规模适中的Web应用框架

Flask: Web应用开发微框架

• 提供了最简单构建Web系统的应用框架
• 特点是：简单、规模小、快速
• Django > Pyramid > Flask

10.3.4 Python库之网络应用开发

WeRoBot: 微信公众号开发框架

• 提供了解析微信服务器消息及反馈消息的功能
• 建立微信机器人的重要技术手段

aip: 百度AI开放平台接口

MyQR: 二维码生成第三方库

10.4 从人机交互到艺术设计

10.4.1 Python库之图形用户界面

PyQt5: Qt开发框架的Python接口

• 提供了创建Qt5程序的Python API接口
• Qt是非常成熟的跨平台桌面应用开发系统，完备GUI
• 推荐的Python GUI开发第三方库

wxPython: 跨平台GUI开发框架

PyGObject: 使用GTK+开发GUI的功能库

10.4.2 Python库之游戏开发

PyGame: 简单的游戏开发功能库

• 提供了基于SDL的简单游戏开发功能及实现引擎
• 理解游戏对外部输入的响应机制及角色构建和交互机制
• Python游戏入门最主要的第三方库

Panda3D:开源、跨平台的3D渲染和游戏开发库

cocos2d: 构建2D游戏和图形界面交互式应用的框架

10.4.3 Python库之虚拟现实

VR Zero: 在树莓派上开发VR应用的Python库

pyovr: Oculus Rift的Python开发接口

Vizard: 基于Python的通用VR开发引擎

• 专业的企业级虚拟现实开发引擎
• 提供详细的官方文档
• 支持多种主流的VR硬件设备，具有一定通用性

10.4.4 Python库之图形艺术

Quads: 迭代的艺术

• 对图片进行四分迭代，形成像素风
• 可以生成动图或静图图像
• 简单易用，具有很高展示度

ascii_art: ASCII艺术库

• 将普通图片转为ASCII艺术风格
• 输出可以是纯文本或彩色文本
• 可采用图片格式输出

turtle: 海龟绘图体系

10.5实例16: 玫瑰花绘制

略

课程总结

• Python语法的三个阶段
  • Python基础语法：函数式编程
  • Python进阶语法：面向对象编程
  • Python高级语法：Pythonic编程