(转载)[python学习笔记]Python语言程序设计(北理工 嵩天)

作者：九命猫幺
博客出处：http://www.cnblogs.com/yongestcat/
欢迎转载，转载请标明出处。
如果你觉得本文还不错，对你的学习带来了些许帮助，请帮忙点击右下角的推荐

阅读目录

• 1.Python基本语法元素
  • 1.1 程序设计基本方法
  • 1.2 Python开发环境配置
  • 1.3 实例1：温度转换
  • 1.4 Python程序语法元素分析
• 2. Python基本图形绘制
  • 2.1 深入理解Python语言
  • 2.2 实例2：Python蟒蛇绘制
  • 2.3 模块1： turtle库的使用
  • 2.4 turtle语法元素分析
• 3. 基本数据类型
  • 3.1 数字类型及其操作
  • 3.2 实例3：天天向上的力量
  • 3.3 字符串类型及操作
  • 3.4 模块2：time库的使用
  • 3.5 实例4：文本进度条
• 4.程序的控制结构
  • 4.1 分支结构 
  • 4.2 实例5：身体质量指数BMI
  • 4.3 循环结构
  • 4.4 模块3：random库使用
  • 4.4 实例6：圆周率计算
• 5.函数和代码复用
  • 5.1 函数的定义与使用
  • 5.2 实例7：七段数码管绘制
  • 5.3 代码复用与函数递归
  • 5.4 模块4：Pyinstaller库的使用
  • 5.5 实例8：科赫雪花小包裹
• 6. 组合数据类型
  • 6.1 集合类型及操作
  • 6.2 序列类型及操作
  • 6.3 实例9：基本统计值计算
  • 6.4 字典类型及操作
  • 6.5 模块5：jieba库的使用
• 7. 文件和数据格式化
  • 7.1 文件的使用
  • 7.2 实例11：自动轨迹绘制
  • 7.3 一维数据的格式化
  • 7.4 二维数据的格式化和处理
  • 7.5 模块6：wordcloud库的使用
  • 7.6 实例12：政府工作报告词云
• 8. 程序设计方法学
  • 8.1 实例13：体育竞技分析
  • 8.2 Python程序设计思维
  • 8.3 Python第三方库安装
  • 8.4 模块7：os库的使用
  • 8.5 实例14：第三方库安装脚本
• 9. Python计算生态概览
  • 9.1 从数据处理到人工智能
  • 9.2 实例15：霍兰德人格分析雷达图
  • 9.3 从Web解析到网络空间
  • 9.4 从人机交互到艺术设计

 

赶时髦，python这么火，学习一哈

回到顶部

1.Python基本语法元素

1.1 程序设计基本方法

计算机发展历史上最重要的预测法则     摩尔定律：单位面积集成电路上可容纳晶体管数量约2年翻倍 cpu/gpu、内存、硬盘、电子产品价格等都遵循此定律

50年来计算机是唯一一个指数发展的领域

 

源代码、目标代码（机器代码）

编译、解释

静态语言、脚本语言

静态语言编译器一次性生成目标代码，优化更冲份，程序运行速度更快

脚本语言 执行程序时需要源代码，维护更灵活

   

程序的基本设计方法IPO

I：input  文件输入、网络输入、控制台输入、交互界面输入、内部参数输入

P：process 处理

O:output 控制台输出、图形输出、文件输出、网络输出、操作系统内部输出

6个步骤：

－分析问题：分析问题的计算部分，想清楚

－划分边界：划分问题的功能边界，规划IPO

－设计算法：设计问题的求解算法，关注算法

－编程

－调试测试

－升级维护

3个精简步骤：确定IPO、编程、调试运行

计算思维（编程体现了一种抽象交互关系、自动化执行的思维模式）、逻辑思维、实证思维   

1.2 Python开发环境配置

python 蟒蛇

psf 拥有者，开放、开源精神

Guido van Rossum创立

2002年 2.x

2008年 3.x

python3不兼容python2

交互式、文件式

 

linux自带python2和python3，无需安装，不过没有pip，要安装apt install python3-pip

trouble shooting：python3中import turtle  ModuleNotFoundError: No module named 'tkinter'报错

apt install python3-tk

apt install tk-dev或yum install tk-devel

然后import turtle不报错了

 

test一下

test1

 

test2

test3

1.3 实例1：温度转换

实例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("输入格式错误")

1.4 Python程序语法元素分析

程序的格式框架：

代码高亮 是辅助

缩进是语法要求  一般4个空格或者1个tab  表达代码间包含和层次关系的唯一手段 

注释：单行注释 #       多行注释  ''' '''

---

命名：给变量关联标识符的过程

命名大小写敏感、首字符不能是数字、不与保留字相同

保留字：被编程语言内部定义并保留使用的标识符 也大小写敏感 33个

 

 

---

数据类型

字符串  

用‘’或“”

正向递增序号、反向递减序号  正向0开始编号

索引： 可以使用[M]索引其中单个字符

切片：可以使用[M:N]返回其中一段子串,从第M到第N-1个字符

 

 

数字类型：整数、浮点数

列表：表示0到多个数据组成的有序序列，采用,分隔各元素，使用in判断一个元素是否在列表中

---

=   赋值主语句

分支语句if elif else构成

eval 评估函数 去除参数最外侧引号并执行余下语句的函数

 

垂直输出hello world

for i in "Hello World":

   print(i)

 

输出

x = input()

print(eval(x)**0,eval(x)**1,eval(x)**2,eval(x)**3,eval(x)**4,eval(x)**5)  

回到顶部

2. Python基本图形绘制

2.1 深入理解Python语言

计算机演进过程：

1946-1981 计算机系统结构时代  计算能力问题        1981年个人pc诞生                      

1981-2008 网络和视窗时代  交互问题                          2008 Android诞生   标志pc转向移动            

2008-2016 复杂信息系统时代 数据问题                       2016年alpha go打败人类               

2017-  人工智能时代 人类的问题

 

新计算时代  过度到人工智能时代的中间时代

---

编程语言的初心 

不完全统计600多中语言    常用的也就那么20来种

python已经在tiobe排行超过C++跃居第三

 

 

---

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

--强制可读性

--较少的底层语法元素

--多种编程方式

--支持中文字符

--C代码量的10%                  语法简洁    *10

--13万第三方库                  生态高产    *10

--快速增长的计算生态 每年2万

--避免重复造轮子

--开放共享

--跨操作系统平台

 

人生苦短 我学Python

    --C/C++：C归C  Python归Python

    --Java：针对特定开发和岗位需求

    --HTML/CSS/JS:不可替代的前端技术，全栈能力

    -R/GO/Matlab等：特定领域

 

Python是最高产的程序设计语言

    --掌握抽象并求解计算问题综合能力的语言

    -了解产业界解决复杂计算问题方法的语言

    -享受利用编程将创新变为实现乐趣的语言

 

工具决定思维：关注工具变革的力量！

---

python具有最庞大的生态库，是唯一的超级语言，前进步伐不可阻挡

2.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()

2.3 模块1： turtle库的使用

turtle库基本介绍

import 保留字 引入turtle绘图库 海龟绘图体系

turtle库是turtle绘图体系的Python实现  1969年诞生，主要用于程序设计入门 Python的标准库之一 入门级的图形绘制函数库

Python计算生态=标准库+第三方库

库library，包package，模块module ,统称模块

有一只海龟，其实在窗体正中心，在画布上游走，走过的轨迹绘制的图形，海龟由程序控制，可以变换颜色宽度

---

turtle绘图窗体布局

turtle的一个画布空间 最小单位是像素

屏幕坐标系：屏幕左上角为0 0

turtle.setup(width,height,startx,starty)后两个可选 默认屏幕中央  并不是必须的   用来设置窗体大小和窗体左上角与屏幕左上角的相对位置

---

turtle空间坐标系：

绝对坐标  海龟在屏幕中央 记为（0，0）坐标原点   turtle.goto(x,y) 

海龟坐标  以海归的视角turtle.fd(d),turtle.bk(d),turtle.circle(r,angle) 左侧r为止为中心行走angle角度的弧线

---

turtle角度坐标体系

绝对角度 改变海龟前进方向 turtle.seth(angle)

 

海龟角度 turtle.left(angle),turtle.right(angle)

---

RGB色彩体系 0-255整数或 0-1 的小数

 

默认采用小数制，可切换为整数制  turtle.colormode(mode) mode为1.0或255 

2.4 turtle语法元素分析

库引用

扩充Python程序功能的方式 使用import保留字完成，采用.()的编码风格  

from turtle import*    缺点 函数重名   适用于短的程序

from turtle import函数名 

可以as保留字起别名 import turtle as t    --推荐使用

---

画笔控制函数

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

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

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

画笔设置后一直有效，直到下次设置

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

-turtle.pencolor(color) color为颜色字符串或rgb值 画笔颜色，海龟在涂装 

      -颜色字符串 turtle.pencolor("purple")

       -rgb小数  turtle.pencolor(0.63，0.13，0.94)

       -rgb元组值  turtle.pencolor((0.63，0.13，0.94))

---

运动控制函数

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

-turtle.forward(d) 别名 turtle.fd(d)  向前行进，海龟走直线   d可以为负数

-turtle.circle(r,extent=none) 根据半径r绘制extent角度的弧线 r默认圆心在海龟左侧r距离的位置  -extent绘制角度，默认是360度

---

方向控制函数

turtle.setheading() 别名turtle.seth() 控制海龟面对方向：绝对角度 海龟角度

turtle.left() turtle.right()

---

循环语句

for in 保留字

range() 产生循环计算序列 range(N) range(M:N)    0到N-1 M到N-1

turtle.done() 运行结束 不退出  需要手工退出  去掉就自动退出了

回到顶部

3. 基本数据类型

3.1 数字类型及其操作

整数类型：可正可负 取值无限 pow(x,y) x的y次方

4种进制表示：10进制、二进制0b或0B开头 0b010、8进制0o或0O、16进制0x或0X

---

浮点型 10的308次方 精度达到：10的-16次方小数 即53位二进制   与数学中实数一致

不确定尾数 （浮点数运算）不是bug  53位二进制表示浮点数的小数部分 约10的-16次方  计算机中的二进制和十进制不完全对等 

二进制表示小数，可以无限接近，但不完全相同

0.1+0.2 结果接近0.3

0.1+0.2 == 0.3  false    用round(x,d)处理不确定尾数   不确定位数一般发生在10的-16次方左右

科学计数法  e或E作为幂的符号，10为基数  e  4.3e-3

---

复数类型 z.real z.imag  获得实部和虚部

---

数值运算操作符

x+y x-y x*y x/y x//y  +x -y x%y x**y         ps:x/y 是浮点数  别的语言中不是这样

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

x op =y   x+=y x-=y x*=y x/=y x//=y x%=y x**=y

类型间可以混合运算 结果生成为“最宽”的类型 隐式转换  整数->浮点数->复数  如123+4.0=127.0

数值运算函数

abs(x) 绝对值

divmod(x,y) 商余    divmod(10,3)  结果是二元数(3,1)

pow(x,y[,z]) 幂余

round(x[,d]) 四舍五入

max(x1,x2,..)

min(x1,x2,..)

int(x) 显示类型转换，  变为整数，舍弃小数

float(x)  转浮点数

complex(x)  转复数

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

问题分析：持续的价值    一年365天每天进步1%，累计进步多少？相反，每天退步1%，累计剩下多少？如果三天打渔二天晒网呢？

print("向上{:.2f},向下{:.2f}".format(pow(1.001,365),pow(0.999,365)))     结果：  向上1.44,向下0.69

---

如果是0.5% 1%呢

#DayDayUp1.py
factor=0.005
print("向上{:.2f},向下{:.2f}".format(pow(1+factor,365),pow(1-factor,365)))

结果：

0.5% :向上6.17,向下0.16

1%:向上37.78,向下0.03

---

如果是工作日的力量？工作日进步1%，休息日退步1%

#DayDayUp.py
dayup=1.0
factor=0.01
for i in range(365):
    if i % 7 in [6,0]:
        dayup *= 1-factor
    else:
        dayup *= 1+factor
print("{:.2f}".format(dayup))

结果：4.63

---

工作日的努力要达到多少才能和每天努力1%一样？

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

结果是:1.9%

---

3.3 字符串类型及操作

四种字符串表示方法：

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

由一对三引号或三双引号表示多行字符串            

三单引号表示字符串，程序啥都不执行，相当于注释，python实际没有真正提供多行注释

---

[M:N:K]根据步长对字符串切片 M和N均可以缺失，表示至开头或至结尾

[::-1]倒序

转义符\  \b 回退  \n 换行  \r 回车光标移动到行首

---

字符串操作符

x+y 连接两个字符串

n*x或x*n 复制n次字符串x

x in s

---

字符串处理函数 

len(x) 字符串长度    中英文长度都是1

str(x) 强制类型转换为字符串  和eval相反操作

hex(x)  整数x转变为8进制形式

oct(x) 整数x转变为16进制形式

chr(x) 将unicode编码返回其字符形式

ord(x)  上面的反操作

unicode编码 统一字符编码 从0到1114111(0x10FFFF) Python字符串每个字符都是unicode编码

---

字符串处理方法 

.  形式 面向对象的术语 表示对象的动作

8个字符串处理方法

.lower() .upper()   大小写转换

.split(sep=None)  字符串分割，返回一个列表    例："a,b,c".split(',')结果是['a', 'b', 'c']

.count(sub)       字符串sub在其中出现次数

.replace(old,new)         字符串替换

.center(width[,fillchar])     字符串格式处理，字符串居中  例： 'python'.center(30,'=')  结果'============python============'

.strip(chars)     去除字符换两边字符         如：'= python= '.strip(' =np')结果'ytho'

.join(iter) 填充字符    如：','.join('12345')结果'1,2,3,4,5'

---

字符串类型的格式化  

格式化是对字符串进行格式化表达的方式

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

槽 相当于占位信息符，只在字符串中有用

 

format方法的格式控制  6种格式控制标记

 

分为2组

前三个参数是一组   默认填充空格左对齐

如：            "{:=^20}".format("python")     结果：           '=======python======='

如：            "{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+003.140000 314.000000%'

3.4 模块2：time库的使用

time库是Python中处理时间的标准库

时间获取

time()  获取当前时间戳，即计算机系统内部时间值，浮点数  1970年1月1日0点0分开始到当前系统以秒为单位的浮点数       如：1537763974.4934046

ctime() 获取当前时间，返回字符串，人类易读  如：'Mon Sep 24 12:41:59 2018'

gmtime() 获取当前时间，struct_time格式，计算机易处理的格式   

            如：time.struct_time(tm_year=2018, tm_mon=9, tm_mday=24, tm_hour=4, tm_min=42, tm_sec=52, tm_wday=0, tm_yday=267, tm_isdst=0)

---

时间格式化 

strftime()

格式化字符串

striptime() 

---

程序计时 

perf_counter()

 

sleep()

3.5 实例4：文本进度条

问题分析：采用字符串方式打印可以动态变化的文本进度条  能在一行中逐渐变化

刷新的本质：用后打印的字符覆盖之前的字符

print() 默认加换行  print( ，end=””)不换行   \r退格到行首

idle不是主要的运行环境 所以\r功能在idle屏蔽了 用shell执行

#TextProBar.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,'-'))

回到顶部

4.程序的控制结构

4.1 分支结构 

单分支结构

if <条件>:

    <程序1> 

---

二分支结构

if <条件1>:

        <程序1> 

else：

        <程序2> 

---

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

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

如：

guess = eval(input())

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

---

多分支结构

if <条件1>:

    <程序2>

elif <条件2>:

    <程序3

… 

else:

    <程序n>

---

条件判断>  >=   <   <=    ==   != 

条件组合x and y      x or y     not x

---

异常处理 

try:

    程序1

except [NameError]:

    程序2

 

try:

    程序1

except:

    程序2

else:

    程序3

finally:

   程序4

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

问题分析：BMI是身体肥胖程度的刻画（BODY MASS INDEX）  BMI=体重(kg)/身高的平方(m)，接收用户信息判断身体肥胖程度

#CalBMI.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指标为  国内{},国际{}".format(who,nat))

4.3 循环结构

for 遍历循环

for <循环变量> in <遍历结构>：

    <语句块> 

记数循环

for I in range(5):

    print(i）

 

for I in range(m:n:k):

    print(i）

字符串遍历循环

for c in s:

    <语句块>

 

for c in "Python123":
    print(c)

列表遍历循环ls是列表

for item in ls:

    <语句块>

 

for item in [123,"py",456]:
    print(item,end=',')

文件遍历循环  fi是文件标识符

for line in fi:

   <语句块>

---

while 无限循环

while <条件>:

   <语句>

---

循环控制保留字break  continue

 

循环扩展：两种循环后面都可以加else分支  else为没有被break退出是执行的，作为正常运行的奖励  

4.4 模块3：random库使用

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

计算机没法产生真正的随机数，但是可以使用梅森旋转算法产生伪随机数

使用 import random

---

random库包括2类函数，常用共8个

基本随机数函数：seed(),random()

括展随机数函数：randint(),getrandbits(),uniform(),randrange(),choice(),shuffle()

随机数种子

seed(a=None)    初始化给定的随机数种子，默认为系统当前时间，例：random.seed(10) #产生种子10对应的序列 0.5714025946899135 0.4288890546751146  ..

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

为什么要使用随机数种子呢，因为可以使用相同的随机数种子复现程序的执行情况

randint(a,b)        生成一个[a,b]之间的整数，例：random.randint(10,100)

randrange(m,n[,k])    生成一个[m,n)之间以k为步长的随机整数,例：random.random(10,100,10)

getrandbits(k)       生成一个k比特长的随机整数

uniform(a,b)         生成一个[a,b]之间的随机小数

choice(seq)          从序列中随机选择一个元素，例：random.choice([1,2,3,4,5,6])

shuffle(seq)          将序列中元素随机排序，返回打乱后的序列，例：s=[1,2,3,4];random.shuffle(s);print(s)  

4.4 实例6：圆周率计算

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

蒙特卡罗方法     工程方法

数学思维

计算思维

time库perf_counter来关注程序性能

据统计，程序80%的时间消耗在不到10%的代码上   有点儿类似28法则

关注循环

回到顶部

5.函数和代码复用

5.1 函数的定义与使用

函数定义

函数是一段具有特定功能可复用的语句

df <函数名>(参数):

    <函数体>

    return <返回值>

其中参数可以是0个到多个，是占位符

函数不经过调用是不会执行的 

函数就是IPO的实现

函数也是一段完整代码的封装

---

函数的参数传递

可选参数传递：可以为参数指定默认值，变为可选参数，可选参数要放在非可选参数之后

可变参数传递：不确定参数有多少个

---

参数传递的两个方式

默认是按照位置，可以按照名称方式传递

---

函数的返回值

return可以返回0个或多个结果

函数可以有返回值也可以没有

可以有return 也可以没有

返回多个值的时候是返回元组类型 用() 元素用逗号分隔

---

局部变量与全局变量

函数外边的是全局变量，里面是局部变量

局部变量是函数内部的占位符，可能与全局变量重名单不相同

函数运行结束后局部变量被释放

规则1：局部变量与全局变量是不同变量

可以使用global保留字在函数内部使用全局变量

规则2：局部变量如果是组合数据类型且未被创建，等同于全局变量    组合数据类型实际是指针的原因

---

lambda函数

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

lambda函数是一种匿名函数，没有名字的函数

lambda函数用于定义一种简单的能够在一行内表示的函数

是一种函数的紧凑表达形式

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

f = lambda x,y : x + y

f(10,15)

谨慎使用lambda函数

用于特定的方法的参数

一般就算是1行代码，也建议用def方式定义

5.2 实例7：七段数码管绘制

问题分析：用turtle绘制数码管样式的时间

from turtle import*
from time import*
def drawGap():
    penup()
    fd(5)
def drawLine(draw):              #绘制单段数码管
    drawGap()
    pendown() if draw else penup()
    fd(40)
    drawGap()
    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)
    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)
    left(180)
    penup()
    fd(20)
def drawDate(date):#date为日期，格式约定为 '%Y-%m=%d+'
    pencolor("red")
    for i in date:
        if i == '-':
            write('年',font=("Arial",18,"normal"))
            pencolor("green")
            fd(40)
        elif i == '=':
            write('月',font=("Arial",18,"normal"))
            pencolor("blue")
            fd(40)
        elif i == '+':
            write('日',font=("Arial",18,"normal"))
        else:
            drawDigit(eval(i))
def main():
    setup(800,350,200,200)
    penup()
    fd(-300)
    pensize(5)
    drawDate(strftime('%Y-%m=%d+',gmtime()))
    hideturtle()
    done()
main()

结果：

5.3 代码复用与函数递归

代码复用

代码抽象化：使用函数等方法对代码赋予更高级别的定义

函数和对象是代码复用的2中主要形式

函数是在代码层面建立了初步抽象

对象有属性和方法，是更高级别的抽象

封装

---

模块化设计

分而治之：

通过函数或对象封装将程序划分为模块与模块间的表达

主程序、子程序与子程序之间的关系

一般将子程序看作模块，主程序看作模块与模块间的关系

是一种分而治之、分层抽象、体系化的设计思想

紧耦合：两个部分之间交流很多，无法独立存在

松耦合：两个部分之间交流很少，可以独立存在，有各自清晰简单的接口

模块化设计基本思路和原则：模块内部紧耦合，模块之间松耦合

---

函数递归：函数定义中调用自身的方式

两个关键特征

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

基例：存在一个或者多个不需要再次递归的基例  递归的最末段

类似数学归纳法，先证明第一个取值命题成立，然后第n个取值命题成立，第n+1取值命题也成立，那么命题成立

递归可以理解为数学归纳法思维在编程中的体现

---

函数递归的调用

函数+分支语句   ：基例和链条分别编写代码

3个小栗子

5.4 模块4：Pyinstaller库的使用

是第三方库 需要安装

pip工具

shell中使用使用             pyinstaller –F <文件名.py>

5.5 实例8：科赫雪花小包裹

#KochDraw.py
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(600,600)
    turtle.penup()
    turtle.goto(-200, 100)
    turtle.pendown()
    turtle.pensize(2)
    level = 3      # 3阶科赫雪花，阶数
    koch(400,level)     
    turtle.right(120)
    koch(400,level)
    turtle.right(120)
    koch(400,level)
    turtle.hideturtle()
main()

结果：

回到顶部

6. 组合数据类型

6.1 集合类型及操作

集合是多个元素的无序组合，每个元素唯一，不存在相同元素

集合元素不可更改，不能是可变数据类型，比如列表类型就不能作为元素，整数浮点数复数字符串元组类型等都是不可变数据类型

用{}表示，元素间用逗号分隔

建立集合用{}或者set()

例如：B = set(“pypy123”) 结果{‘1’,’2’,’3’,’p’,’y’}

建立空集合必须用set()

---

6个集合操作符

S | T  并

S – T  差

S & T 交

S ^ T  补

S <= T、S < T  包含与子集关系

S >= T、S > T

增强操作符

S |= T

S –= T

S &= T

S ^= T

---

10个集合处理方法

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

S.copy()  返回集合S的一个副本

len(S) 返回个数

x in S 判断S中是否有元素x

x not in S 同上相反

set(x) 将其他类型变量x转变为集合类型

---

集合类型应用场景

包含关系的比较

数据去重

6.2 序列类型及操作

序列是有先后顺序的一组元素

序列是一维元素向量，元素类型可以不同，类似C语言中的一维数组

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

序列是一个基类类型

一般不直接用序列类型而是使用其衍生类型，比如字符串、元组、列表

---

序列处理函数与方法

---

元组类型

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

使用()或者tuple()创建,元素间用逗号分隔

可以使用或不适用小括号,比如函数返回多个返回值就是使用没有括号的元组类型,python内部认为是一个值，是一个元组

元组类型继承了序列的所有通用操作

元组类型因为一旦定义不能修改，所以没有特殊操作

---

列表类型及操作

列表是序列类型的扩展，十分常用

列表是一种序列类型，创建后可以随意修改，长度无限制，元素类型可不同

列表本质是指针，如果通过赋值语句给另外一个变量，那么实际并没有创建一个新列表，可以类似linux的硬链接,[]或者函数list()才是真正创建一个列表，赋值仅仅传递引用

一些例子

一些例子

---

序列类型应用场景

包含元组列表

元组用于元素不改变的场景，更多用于固定场景 比如函数返回值

列表则更加灵活，是常用的序列类型

最主要作用：表示一组有序数据并进而操作它们

元素遍历 for item in lt

数据保护 利用元组不可修改的特性

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

问题分析：给出一组数据，给出概要理解，比如 求和、平均值、方差、中位数…

总个数：len()

求和：for … in

平均值：上2个除

方差：各数据与平均值的平方的和的平均数

中位数：排序，取中间的或者中间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
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.4 字典类型及操作

字典类型的定义

映射 是一种键(索引)和值(数据)的对应

用{}或者dict()创建字典，键值对用:表示     {key:value,key2:value2…}

type()可以检测变量的类型

{}可以用来声明空字典，这就是集合类型中定义空集合不能用{}的原因

---

一些例子

6.5 模块5：jieba库的使用

优秀的中文分词第三方库

由于中文是连续书写的 需要通过特定手段获得单个词语

jieba库提供3种分词模式，最简单只需要掌握一个函数

通过中文词库方式识别确定汉字之间关联概率 概率大的组成词组，形成分词效果

除了分词，用户也可以添加自定义的词组

---

三种模式

精确模式：把文本精确的切分开，不存在冗余单词  最常用的分词模式

全模式：把文本中所有可能的词语都扫描出来，存在冗余

搜索引擎模式：更加智能，在精确模式的基础上，对长词再次切分，存在冗余，在某些特定场景下使用

6.6 实例10：文本词频统计

问题分析：一篇文章，出现了哪些词？哪些词最多？

中英文各一个程序：分别是哈姆雷特和三国演义

#CalHamletV1.py
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)
for i in range(10):
word, count = items[i]
print ("{0:<10}{1:>5}".format(word, count))

#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. 文件和数据格式化

7.1 文件的使用

文件的类型

文本文件、二进制文件     只是展示方式，本质上都是二进制数据

文本文件：由单一特定编码组成的文件，如utf-8编码   由于存在编码，文本文件也被看为一个长字符串

二级制文件：数据间没有统一字符编码，01组成，比如png avi等文件

---

文件的打开和关闭

打开->操作->关闭                    文件存储状态和占用状态转换

文件的打开

<变量名> = open(<文件名>,<打开模式>)

文件句柄

文件路径和名称，使用相对路径或者绝对路径，同一个路径的话就直接文件名，斜杠\是转移字符使用反斜杠/替换,或者\\

打开模式

<变量名>.close   关闭文件

当程序退出的时候，python也会自动关闭文件

---

文件内容的读取

.read(size=-1)   读入全部内容，如果给出参数，读入前size长度

.readline(size=-1) 读入一行，如果给了size，读入该行前size长度

.readlines(hint=-1)   读入文件所有行，以每行为元素形成列表,hint参数可选，读入前hint行

遍历全文本

文件的逐行处理

---

文件写入

.write(s)   向文件写入一个字符串或字节流   如：f.write(“abc”)

.writelines(lines)   将一个元素全为字符串的列表写入文件   如：ls=[‘a’,’b’,’c’],f.writelines(ls)

.seek(offset) 改变当前文件操作指针的位置，offset含义如下：0文件开头，1-当前位置，2-文件结尾

例子：

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

7.2 实例11：自动轨迹绘制

问题分析：根据脚本来绘制图形  不是写代码而是写数据绘制轨迹

#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()
#自动绘制
for i 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.rt(datals[i][2])
    else:
        t.lt(datals[i][2])

自动化思维

将数据和功能分离开来

数据驱动

接口化设计

可以扩展

  扩展接口设计，增加更多控制接口

  扩展功能设计，增加弧形等更多功能

  扩展应用需求，发展自动轨迹绘制到动画绘制

7.3 一维数据的格式化

一维数据：由对等关系的有序或无序数据构成，采用线性方式组织，对应列表、集合、数组等概念

二维数据：由多个一维数据组成，是一维数据的组合形式

多维数据：是一维或二维数据在新唯独上扩展形成，比如中国大学排行榜加入时间维度

高维数据：仅利用最基本的二元关系展示数据间的复杂结构，比如字典类型中的key-value形式

---

操作周期

---

一维数据的表示

如果数据间有序，使用列表类型

如果数据间无序，使用集合类型

---

一维数据的存储

---

一维数据的处理

类似于一个驱动

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

二维列表

两层for循环遍历二维列表

csv:comma-separated values  逗号分隔  国际通用   一般.csv为扩展名

每行一个一维数据，无空行

一般的软件都能生成csv格式文件

如果每个元素缺失，逗号要保留

表头可以作为数据存储，也可以令行存储

如果数据中包含逗号，不同的软件有不同的约定，比如转义符或者其他方式

按行存或者按列存都行，一般索引习惯 ls[row][col] 先行后列，按行存

---

二维数据的处理

读入处理

7.5 模块6：wordcloud库的使用

词云展示的第三方库

wordcloud库把词云当作一个WordCloud对象

wordcloud.WordCloud()代表一个文本对应的词云

可以根据文本中词语出现的频率等参数绘制词云

绘制词云的形状、尺寸、颜色都可以设定

w = wordcloud.WordCloud()

以WordCloud对象为基础

配置参数、加载文本、输出文件

常规方法

w.generate(txt)  向WordCloud对象w中加载文本txt 如：w.generate(“Python and WordCloud”)

w.to_file(filename) 将词云输出为图像文件，.png或.jpg格式 如：w.to_file(“output.png”)

绘制词云的步骤：

setp1：配置对象参数

setp2：加载词云文本

step3：输出词云文件

生成默认400*200的图片

wordcloud干啥了：

a.分隔：以空格为分隔单词

b.统计：单词出现次数并过滤

c.字体：根据统计配置字号

d.布局：颜色环境尺寸

对象参数

width 默认400

height 默认200

min_font_size 最小字号 默认4号

max_font_size 最大字号 根据高度自动调节

font_step 默认1，字体步进间隔

font_path 字体路径，默认None，如：w=wordcloud.WordCloud(font_path=”msyh.ttc”)

max_words 指定词云显示的最大单词数量，默认200   比如词云显示的不那么有力，可以修改这个

stop_words 指定排除单词 如：w=wordcloud.WordCloud(stop_words={“Python”})

background_color  指定背景色  默认黑色

默认显示的矩形效果，使用mask参数可以改变

中文的话需要先用jieba库分词，中文不是空格分隔的

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

常规矩形词云

#GovRptWordCloudv1.py
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(
width = 1000, height = 700,
background_color = “white”,
font_path = “msyh.ttc”
)
w.generate(txt)
w.to_file(“grwordcloud.png”)

不规则图形词云

#GovRptWordCloudv2.py
import jieba
import wordcloud
from scipy.misc import imread
mask = imread("chinamap.jpg")
excludes = { }
f = open("新时代中国特色社会主义.txt", "r", encoding="utf-8")
t = f.read()
f.close()
ls = jieba.lcut(t)
txt = " ".join(ls)
w = wordcloud.WordCloud(\
    width = 1000, height = 700,\
    background_color = "white",
    font_path = "msyh.ttc", mask = mask
    )
w.generate(txt)
w.to_file("grwordcloudm.png")

回到顶部

8. 程序设计方法学

8.1 实例13：体育竞技分析

---

自顶向下（设计）        分而治之

将一个总问题表达为若干个小问题组成的形式

使用相同的方法进一步分解小问题

解决复杂问题的有效设计方法

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

逐步组建复杂系统的有效测试方法

分单元测试，逐步组装

---

#MatchAnalysis.py
from random import random
def printIntro():
    print("这个程序模拟两个选手A和B的某种竞技比赛")
    print("程序运行需要A和B的能力值（以0到1之间的小数表示）")
def getInputs():
    a = eval(input("请输入选手A的能力值(0-1): "))
    b = eval(input("请输入选手B的能力值(0-1): "))
    n = eval(input("模拟比赛的场次: "))
    return a, b, n
def simNGames(n, probA, probB):
    winsA, winsB = 0, 0
    for i in range(n):
        scoreA, scoreB = simOneGame(probA, probB)
        if scoreA > scoreB:
            winsA += 1
        else:
            winsB += 1
    return winsA, winsB
def gameOver(a,b):
    return a==15 or b==15
def simOneGame(probA, probB):
    scoreA, scoreB = 0, 0
    serving = "A"
    while not gameOver(scoreA, scoreB):
        if serving == "A":
            if random() < probA:
                scoreA += 1
            else:
                serving="B"
        else:
            if random() < probB:
                scoreB += 1
            else:
                serving="A"
    return scoreA, scoreB
def printSummary(winsA, winsB):
    n = winsA + winsB
    print("竞技分析开始，共模拟{}场比赛".format(n))
    print("选手A获胜{}场比赛，占比{:0.1%}".format(winsA, winsA/n))
    print("选手B获胜{}场比赛，占比{:0.1%}".format(winsB, winsB/n))
def main():
    printIntro()
    probA, probB, n = getInputs()
    winsA, winsB = simNGames(n, probA, probB)
    printSummary(winsA, winsB)
main()

8.2 Python程序设计思维

计算思维与程序设计

第三种人类思维特征

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

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

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

有非常明显的特征：抽象和自动化，抽象问题的计算过程并利用计算自动化求解(并不是抽象因果关系仅仅是抽象过程）

1+2+..+100  高斯     vs  累计

圆周率        高数求和   vs     蒙特卡洛方法

汉诺塔问题   逻辑推理的2的n次方-1        vs      递归

计算思维基于计算机强大的算力和海量的数据

抽象计算过程，关注设计和构造，而非因果

以计算机程序设计为主要实现手段

编程是将计算思维变为现实的手段

---

计算生态与Python语言

从开源运动说起…

-1983年，Richard Stallman启动GNU项目

-1989年，GNU通用许可协议诞生，自由软件时代到来               大教堂模式

-1991年，Linus Torvalds发布了Linux内核                                           集市模式(成为主流)

-1998年，网景浏览器开源，产生了Mozilla，开源生态逐步建立

计算生态以开源项目为组织形式，充分利用“共识原则”和“社会他人”组织人员，在竞争发展、相互依存和迅速更迭中完成信息技术的更新换代，形成了技术的自我演进路径。

开源思想深入演化和发展，形成了计算生态

计算生态是没有顶层设计、以功能为单位、具备三个特点：竞争发展、相互依存和迅速更迭

 

python

-以开源项目为代表的大量第三方库         Python语言提供 > 13万个第三方库  并以两万+每年的速度发展

-库的建设经过野蛮生长和自然选择         同一个功能，Python语言提供2个以上第三方库

-库之间相互关联使用，依存发展             Python库间广泛联系，逐级封装

-社区庞大，新技术更迭迅速                      Alpha Go深度学习算法采用Python语言开源

API ！=  生态

 

创新：跟随创新、集成创新、原始创新                       

-计算生态加速科技类应用创新的重要支撑

-发展科技产品商业价值的重要模式

-国家科技体系安全和稳固的基础

 

刀耕火种 –> 站在巨人的肩膀上

  -编程的起点不是算法而是系统

  -变成如同搭积木，利用计算生态为主要模式

  -编程的目标是快速解决问题

优质的计算生态  python123  由老师、产业人员共同筛选的优质生态https://python123.io/index/monthly_packages/201808

---

用户体验与软件产品

实现功能 –> 关注体验

用户体验指用户对产品建立的主管感受和认识

关心功能实现，更要关心用户体验，才能做出好产品

编程只是手段，不是目的，程序最终为人类服务

 

提高用户体验的方法

方法1：进度展示   

  -如果程序需要计算时间，可能产生等待，请增加进度展示

  -如果程序需要若干步骤，需要提示用户，请增加进度展示

  -如果程序可能存在大量次数的循环，请增加进度展示

方法2：异常处理

  -当获得用户输入时候，对合规性需要检查，需要异常处理

  -当读写文件时，对结果进行判断，需要异常处理

  -当进行输入输出时，对运算结果进行判断，需要异常处理

其他方法：

  -打印输出：特定位置，输出程序运行的过程信息verbose

  -日志文件：对程序异常以及用户的使用进行定期记录

  -帮助信息：给用户多种方式提供帮助

 

软件程序 到 软件产品，其核心关键就是用户体验

---

基本的程序设计模式

IPO

模块化设计

自顶向下设计

配置化设计   （自动轨迹绘制实例）

  -引擎+配置：程序执行和配置分离，将可选参数配置化

  -将程序开放变为配置文件编写，扩展功能而不修改程序

  -关键在于接口设计，清晰明了，灵活扩展，这是一种更高级别的设计思路

 

应用开发的四个步骤：

1.产品定义    对应用需求充分理解和明确定义

  -产品定义，而不仅是功能定义，要考虑商业模式

2.系统架构  以系统方式思考产品的技术实现

  -系统架构，关注数据流、模块化、体系架构

3.设计与实现  结合架构完成关键设计及系统实现

  -结合可扩展性、灵活性、是否适应未来需求变化等进行设计优化

4.用户体验  从用户角度思考应用效果

  -用户至上，体验优先，以用户为中心构造软件产品

8.3 Python第三方库安装

看见更大的Python世界

13万个第三方库  全区社区 https://pypi.org

PYPI

  -Python Package Index

  -PSF维护的展示全球Python计算生态的主站

  -学会检索并利用PyPI，找到合适的第三方开发程序

 

3种安装方法：

  -方法1（主要方法）：使用pip命令

  -方法2：集成安装方法

  -方法3：文件安装方法

---

pip安装方法（最主要的方法）

pip  -h 可以查看帮助

pip install <第三方库名>                                 安装

pip install –U <第三方库名>                           升级

pip uninstall <第三方库名>                            卸载

pip download <第三方库名>                         下载单并不安装

pip show <第三方库名>                                  列出某个第三方库的详细信息

pip search 关键词                                             搜索第三方库

pip list                                                                  列出已安装的第三方库

---

集成安装方法

结合安装工具，批量安装，不过这样的安装工具不多，推荐一个叫anaconda

---

文件安装方法

为什么有些第三方库用pip可以下载，单无法安装？

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

  -如果操作系统没有编译环境，则能下载单不能安装

  -可以找编译后的版本来安装吗  http://www.lfd.uci.edu/~gohlke/pythonlibs   UCI页面  加州大学教授维护的 win系统的直接编译后的版本

pip install 文件

8.4 模块7：os库的使用

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

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

  -路径操作：os.path子库，处理文件路径及信息

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

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

---

路径操作

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

import os.path

import os.path as op

---

os库进程管理

os.system(command)   调用其他程序

---

os库之环境参数

获取或改变系统环境信息

8.5 实例14：第三方库安装脚本

第三方库自动安装脚本

用程序自动安装这20个第三方库

#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("pip3 install "+lib)
    print("Successful")        
except:
    print("Failed Somehow")

回到顶部

9. Python计算生态概览

9.1 从数据处理到人工智能

从数据处理到人工智能的完整链条：数据表示->数据清洗->数据统计->数据可视化->数据挖掘->人工智能

---

Python库之数据分析

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

  -Python接口使用，C语言实现，计算速度优异

  -Python数据分析及科学计算的基础库，支撑Pandas等

  -提供直接的矩阵运算、广播函数、线性代数等功能

 

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

  -提供了简单易用的数据结构和数据分析工具

  -理解数据类型与索引的关系，操作索引即操作数据

  -Python库最主要的数据分析功能库，基于Numpy开发

提供两个数据结构：

Series = 索引 + 一维数据

DataFrame = 行列索引 + 二维数据

 

Scipy：数学、科学和工程计算功能库

  -提供了一批数学算法及工程数据运算功能

  -类似Matlab，可用于傅里叶变换、信号处理等应用

  --Python最主要的科学计算功能库，基于Numpy开发

---

Python库之数据可视化

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

  -提供了超过100种数据可视化展示效果

  -通过matplotlib.pyplot子库调用各可视化效果

  -Python最主要的数据可视化功能库，基于Numpy开发

 

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

  -提供了一批高层次的统计类数据可视化展示效果

  -主要展示数据间分布、分类和线性关系等内容

  -基于Matplotlib开发，支持Numpy和Pandas

 

Mayavi：三维科学计算可视化功能库

  -提供了一批简单易用的3D科学计算数据可视化展示效果

  -目前是Mayavi2，三维可视化最主要的第三方库

  -支持Numpy、TVTK、Traits、Envisage等第三方库

---

Python库之文本处理

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

  -提供了一批处理PDF文件的计算功能

  -支持获取信息、分隔/整合文件、加密解密等

  -完全Python语言实现，不需要额外依赖，功能稳定

 

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

  --提供了一批简单易用的自然语言文本处理功能

  -支持语言文本分类、标记、语法句法、语义分析等

  -最优秀的Python自然语言处理库

 

Python-docx：创建或更新word文档的第三方库

  -提供创建或更新.doc .docx等文件的计算功能

  -增加并配置段落、图片、表格、文字等，功能全面

---

Python库之机器学习

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

  -提供一批统一化的机器学习方法功能接口

  -提供聚类、分类、回归、强化学习等计算功能

  -机器学习最基本且最优秀的Python第三方库

 

TensorFlow：AlphaGo背后的机器学习计算框架

  -谷歌公司推动的开源机器学习框架

  -将数据流图作为基础，图节点代表运算，边代表张量

  -应用机器学习方法的一种方式，支撑谷歌人工智能应用

 

MXNet：基于神经网络的深度学习计算框架

  -提供可扩展的神经网络及深度学习计算功能

  -可用于自动驾驶、机器翻译、语音识别等众多领域

  -Python最重要的深度学习计算框架

9.2 实例15：霍兰德人格分析雷达图

问题分析：

啥是雷达图

 

霍兰德认为：人格兴趣和职业之间有内在的对应关系

人格分类：研究型、艺术型、社会型、企业型、传统型、现实型

职业：工程师、实验员、艺术家、推销员、记事员、社会工作者

 

需求：雷达图方式验证霍兰德人格分析

输入：各职业人群结合兴趣的调研数据

输出：雷达图

展示多维数据以及绘制雷达图的能力

 

#HollandRadarDraw
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)']) #雷达标签
nAttr = 6
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, nAttr, endpoint=False)
data = np.concatenate((data, [data[0]]))
angles = np.concatenate((angles, [angles[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,frac = 1.2)
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()

 

目标+沉浸+熟练

  -编程的目标感：寻找感兴趣的目标，寻(wa)觅(jue)之

  -编程的沉浸感：寻找可实现的方法，思(zuo)考(mo)之

  -编程的熟练度：练习、练习、再练习，熟练之

编程不是最主要的，编程的感觉才是最重要的

9.3 从Web解析到网络空间

Python库之网络爬虫

Requests:最友好的网络爬虫库

  -提供了简单易用的类HTTP协议网络爬虫功能

  -支持连接池、SSL、Cookies、HTTP(S)代理等

  -Python最主要的页面级网络爬虫功能库

 

Scrapy：优秀的网络爬虫框架

  -提供了构建网络爬虫系统的框架功能，半成品

  -支持批量和定时页面爬取、提供数据处理流程等

  -Python最主要且最专业的网络爬虫框架

 

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

  -提供了完整的网页爬取系统构建功能

  -支持数据库后端、消息队列、优先级、分布式架构等

  -Python重要的网络爬虫第三方库

---

Python库之Web信息提取

Beautiful Soup：HTML和XML的解析库

  -提供了解析HTML和XML等Web信息的功能

  -又名beautifulsoup4或bs4，可以加载多种解析引擎

  -常与网络爬虫库搭配使用，如Scrapy、requests等

 

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

  -提供了定义和解析正则表达式的一批通用功能

  -可用于各类场景，包括定点的Web信息提取

  -Python最主要的标准库，无需安装

 

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

  -提供了对Web页面中文章信息/视频等元数据的提取功能

  -针对特定类型Web页面，应用覆盖面较广

 

相对于bs4库，抽象层次更加高，更加方便

---

Python库之Web网站开发

Django：最流行的Web应用框架

  -提供了构建Web系统的基本应用框架

  -MTV模式：模型(model)、模式(Template)、视图(Views)

  -Python最重要的Web应用框架，略微复杂的应用框架，比较适合专业的网站构建

 

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

  -提供了简单方便构建Web系统的应用框架

  -不大不小，规模适中，适合快速构建并适度扩展类应用

  -Python产品级Web应用框架，起步简单可扩展性好

 

Flask：Web应用开发微框架

  -提供了最简单构建Web系统的应用框架

  -特点是：简单、规模小、快速

-Django > Pyramid > Flask好

---

Python库之网络应用开发

WeRoBot：微信公众号开发框架

  -提供了解析微信服务器消息及反馈消息的功能

  -建立微信机器人的重要手段

 

aip：百度AI开放平台接口

  -提供了访问百度AI服务的Python接口

  -语音、人脸、OCR、NLP、知识图谱、图像搜索等领域

  -Python百度AI应用的最主要方式

 

MyQR：二维码生成第三方库

  -提供了生成二维码的系列功能

  -基本二维码、艺术二维码和动态二维码

9.4 从人机交互到艺术设计

Python库之图形用户界面

PyQT5:QT开放框架的Python接口

  -提供了创建QT5程序的Python API接口

  -Qt是非常成熟的跨平台桌面应用开发系统，完备GUI

  -推荐的Python GUI开发第三方库

 

wxPython：跨平台GUI开发框架

  -提供了专用于Python的跨平台GUI开发框架

  -Python最主要的图形用户界面

 

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

  -提供了整合GTK+、WebKitGTK+等库的功能

  -GTK+：跨平台的一种GUI框架

  -实例：Anaconda采用该库构建GUI

---

Python库之游戏开发

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

  -提供了基于SDL的简单游戏开发功能及实现引擎

  -理解游戏对外部输入的相应机制及角色构建和交互机制

  -Python游戏入门最主要的第三方库

 

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

  -一个3D游戏引擎，提供Python和C++两种接口，Python接口更加全面也是该库推荐使用的语言

  -支持很多先进特性：法线贴图、光泽贴图、卡通渲染等

  -由迪士尼和卡内基梅隆大学共同开发

 

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

  -提供了基于OpenGL的游戏开发图形渲染功能

  -支持GPU加速，采用树形结构分层管理游戏对象类型

  -适用于2D专业级游戏开发

---

Python库之虚拟现实

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

  -提供大量与vr开发相关的功能

  -针对树莓派的vr开发库，支持设备小型化，配置简单化

  -非常适合初学者实践vr开发及应用

 

pyovr：Oculus Rift的Python接口

  -针对Oculus VR设备的python开发库

  -基于成熟的VR设备，提供全套文档，工业级应用设备

  -Python+虚拟现实领域探索的一种思路

 

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

  -专业的企业级虚拟现实开发引擎

  -提供详细的文档

  -支持多种主流的VR硬件设备，具有一定的通用性

---

Python库之图形艺术

Quads：迭代的艺术

  -对图片进行四分迭代，形成像素风

  -可以生成动态或者静态图片

  -简单易用，具有很高展示度

 

ascii_art:ASCII艺术库

  -将普通图片转为ASCII艺术风格

  -输出可以是纯文本或彩色文本

  -可采用图片格式输出

 

turtle库

 

9.5 实例16：玫瑰花绘制

问题分析：

输入：你的想象力

输出：玫瑰花

#RoseDraw.py
import turtle as t
# 定义一个曲线绘制函数
def DegreeCurve(n, r, d=1):
    for i in range(n):
        t.left(d)
        t.circle(r, abs(d))
# 初始位置设定
s = 0.2 # size
t.setup(450*5*s, 750*5*s)
t.pencolor("black")
t.fillcolor("red")
t.speed(100)
t.penup()
t.goto(0, 900*s)
t.pendown()
# 绘制花朵形状
t.begin_fill()
t.circle(200*s,30)
DegreeCurve(60, 50*s)
t.circle(200*s,30)
DegreeCurve(4, 100*s)
t.circle(200*s,50)
DegreeCurve(50, 50*s)
t.circle(350*s,65)
DegreeCurve(40, 70*s)
t.circle(150*s,50)
DegreeCurve(20, 50*s, -1)
t.circle(400*s,60)
DegreeCurve(18, 50*s)
t.fd(250*s)
t.right(150)
t.circle(-500*s,12)
t.left(140)
t.circle(550*s,110)
t.left(27)
t.circle(650*s,100)
t.left(130)
t.circle(-300*s,20)
t.right(123)
t.circle(220*s,57)
t.end_fill()
# 绘制花枝形状
t.left(120)
t.fd(280*s)
t.left(115)
t.circle(300*s,33)
t.left(180)
t.circle(-300*s,33)
DegreeCurve(70, 225*s, -1)
t.circle(350*s,104)
t.left(90)
t.circle(200*s,105)
t.circle(-500*s,63)
t.penup()
t.goto(170*s,-30*s)
t.pendown()
t.left(160)
DegreeCurve(20, 2500*s)
DegreeCurve(220, 250*s, -1)
# 绘制一个绿色叶子
t.fillcolor('green')
t.penup()
t.goto(670*s,-180*s)
t.pendown()
t.right(140)
t.begin_fill()
t.circle(300*s,120)
t.left(60)
t.circle(300*s,120)
t.end_fill()
t.penup()
t.goto(180*s,-550*s)
t.pendown()
t.right(85)
t.circle(600*s,40)
# 绘制另一个绿色叶子
t.penup()
t.goto(-150*s,-1000*s)
t.pendown()
t.begin_fill()
t.rt(120)
t.circle(300*s,115)
t.left(75)
t.circle(300*s,100)
t.end_fill()
t.penup()
t.goto(430*s,-1070*s)
t.pendown()
t.right(30)
t.circle(-600*s,35)
t.done()

结果

作者：九命猫幺 博客出处：http://www.cnblogs.com/yongestcat/ 欢迎转载，转载请标明出处。 如果你觉得本文还不错，对你的学习带来了些许帮助，请帮忙点击右下角的推荐