python入门[中国大学mooc笔记][嵩天]

认真学习python

python学习笔记

#by SN

第0周 课程安排

1. python基本语法（温度转换）
2. python基本图形绘制（蟒蛇绘制）
3. 基本数据类型
4. 程序的控制结构（分支，循环，随机数）
5. 函数和代码复用（递归）
6. 组合数据类型（集合，序列，字典。jieba分词，词频统计）
7. 文件和数据类型（文件读写，词云）
8. （进阶）程序设计方法学（自顶与自底，思维生态与体验，利用os库整理操作系统文件夹）
9. python的计算生态纵览

第1周 python基本语法元素

1. 程序设计的基本方法

   • 计算机：根据指令操作数据的设备（功能性和可编程性）
   • 硬件规模：摩尔定律（表现为运行速度）：单位面积集成电路上的晶体管数量每两年翻一番
   • C（1972）python（1990，02年2.0版本,08年3.0，注意3.x不与2.0兼容）
   • 原代码经过编译（一次性翻译&静态语言&优化更好）或解释（现场口译&脚本语言&保留源代码灵活维护）变为目标机器码
   • 编写方法：IPO（input，process算法，output），想清楚边界

2. python开发环境配置

• 略

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))#到-1是指不包含，注意是不包含尾巴
elif Tempstr[-1] in ["c", "C"]:#判断输入是否是摄氏温度
    F = eval(Tempstr[0:-1]) * 1.8 + 32
    print("转换后的温度是{:.2f}F".format(F))
else :#其他输入
    print("输入格式错误！")

1. python语法元素分析

• 程序的格式框架

  • 高亮不是语法

  • 缩进与多层缩进，是严格的语法，单一程序内缩进长度一样

  • 注释：单行用#,多行用```

• 命名与保留字

  • 变量：用标识符表示，单一 = 表示赋值符号（命名规则：大小写敏感，首字母不为数字）

  • 保留字：编程语言内部定义保留使用的标识符 ：if else in， True Fause None 是三个首字母大写的保留字

    • 33个保留字表：

    • and	as	assert	break	class	continue
      def	del	elif	else	except	finally
      for	from	False	global	if	import
      in	is	lambda	nonlocal	not	None
      or	pass	raise	return	try	True
      while	with	yield

• 数据类型

  • 数据类型：解释与理解的角度，类型就是与信息绑定的计算机唯一的理解形式
    • 字符串类型：一对引号囊括的字符序列（序列是可以索引或切片的，正向索引0，反向-1）
      • a[1]第二个字符，tempstr[0,-1]不包含最后一个字符的输入
    • 整数和实数（浮点数）
    • 列表类型：[]表示，中间元素用,隔开
      • 使用保留字in判断元素是否在列表中
        • Tempstr in [“c”,“C”] 返回True和Fause两种值

• 语句与函数

  • 赋值语句：赋值同时赋类型
    • Tempstr = input(“请输入带有符号的温度值：”) # input()返回的是字符串类型，那么左边也是字符串类型
  • 分支语句：带判断
    • if elif else
    • 分支语句后必须要有 :
  • 函数：类似数学中的函数
    • f（x）

• python程序的输入输出

  • eg：input（“请输入”）获取用户输入
  • eg：print（“输入错入”）做输出
    • print的格式化方法与槽{}
  • eg：eval（）：评估函数。去掉外侧引号，然后python解释该语句（可能是计算，可能是函数）
    • 作用就是字符串变为python语句

第2周 python基本图形绘制

1. 深入理解python语言

   • 1946—1981—2008—2016
   • 机器语言：01字符串，二进制代码，CPU直接执行，也与CPU绑定
   • 汇编语言：只是机器语言的助记符版本，是一一对应的，也与具体CPU绑定
   • 高级语言：与CPU型号无关，依靠对应CPU的编译器或者解释器
     • c语言：指针，内存，数据类型 （性能）
     • java语言：面向对象，跨平台，运行时（软件类）
     • c++：对象，多态，继承（主客体本质，大规模程序）
     • VB：交互逻辑（桌面）
     • python：理解问题，较少底层，强制可读（所有专业，性能不再是首要考虑，生态高产）
   • 超级语言

2. 实例2：python蟒蛇绘制

   #PythonDraw.py
   import turtle as t
   t.setup(650,350)#高650，宽350像素
   t.penup()
   t.fd(-250)#绝对行进就用goto（）
   t.pendown()#penup()和pendown()是成对的
   t.pensize(30)
   t.pencolor("red")#字符串也可以，用元组，用三参数也可以
   t.seth(-40)#这是设置行进的绝对方向，相对方向用right（）或left（）
   for i in range(4):
       t.circle(40,80)
       t.circle(-40,80)
   t.circle(40,80/2)#r：以相对左侧r距离为圆心， 后面是圆心角大小（没给就是转一圈）
   t.fd(40)
   t.circle(16,180)
   t.fd(40* 2/3)
   t.done()#没有这一行绘图窗口会自动关闭
   

3. 模块1：turtle库的使用

   • turtle库是标准库，随着解释器直接安装到操作系统，而第三方库需要自己安装
   • 库library，包package，模块module在本课统称为模块
   • RGB（红绿蓝）色彩体系
     • （255,255,255）为白色，（0,0,0）是黑色 （需要预先使用turtle.mode(255)）
     • turtle.mode(1.0)则是使用三位0到1的小数

4. 语法分析

   • 库引用

     • 使用import A 编写时使用 A.B© 此方法不会函数重名冲突
     • 使用from A import *，编写时使用 B.©、
     • 推荐 import turtle as t （t是库别名）

   • 函数

     • pencolor（）与pensize（）

     • penup() pendown()成对提笔与落笔

     • fd（）与circle（）直走与弧形

     • setheading（angle）转向绝对角度，left（）和right（）相对角度

     • 循环语句与range函数

       • for in 保留字为循环结构

         for i in range(5):
             #range(M,N)返回M到N-1的序列
             print("Hello",i)#注意这个“，”连接打印效果为空格
             #print会自动换行，因为默认的end=“\n”,可以修改print("Hello",i,end="")不会提行
         

第3周 基本数据类型

1. 数字类型以及操作

   • 整数，浮点（实数），复数

     • 整数

       pow(2,10)#1024
       1010,99,-217#十进制
       0b110，-0B1101#二进制
       0o175#八进制
       0xA24#十六进制
       

     • 浮点数

       #有精度10^-16^
       #注意***不确定尾数***的问题不是bug，0.1+0.2会等于0.30000000000002，这是因为计算机用53位二进制表示小数部分，这个就是精度来源，也就是说0.1+—10^-16^
       #0.1 + 0.2 == 0.3会返回False
       #round（0.1+0.2,1【1是指保留一位小数后四舍五入】）== 0.3会返回True，所以浮点数的比较需要用round函数
       #科学计数法 E-3
       

     • 复数（python独有）

       #j表示复数单位
       

   • 数值运算操作符

     x + y
     x - y
     x * y
     x / y  #10/3=3.3333333333，python里面整数直接除的结果是浮点数
     x // y#注意这是商的整数部分
     
     x % y #x mod y
     x ** y #pow(x,y) 10**0.5就是根号十
     注意python里面不同类型可以混合运算，结果取拓宽的类型（这里也可能产生不确定的尾数）
     
     二元赋值增强略
     

   • 数值运算函数

     abs(x)#绝对值
     divmod(x,y)#商余操作，返回序列 divmod（10,3）结果为（3,1）
     pow(x,y[,z])#(x ** y) % z #[]表示可以省略  #注意使用z的话可以略过可能计算机不能获取的巨大中间数得到目标，并且运算更快
     round(x[,d])#四舍五入取整函数，d是保留的小数位数，默认为0
     max(a,b,c,d……)#min也可以
     
     类型转换函数
     int(x)#注意这是函数，不是保留字,作用是将x变为整数，去掉小数部分
     ~int(123.45) = 123 int（“123”）=123
     float(x),complex(x)类似
     

2. 实例3：天天向上的力量

   #daydayupQ4.py
   def dayUP(df):
       dayup = 1.0
       dayfactor = 0.01
       for i in range(365):#这就是计算思维，抽象自动化
           if i%7 in [6,0]:
               dayup *= (1-dayfactor)
           else:
               dayup *= (1+df)
       return dayup
   df = 0.01
   while dayUP(df) < 37.78:  #这是全年无休的进步#利用试错法，这是由于计算机强大的算力
       df += 0.001
   print("至少在工作日进步:{0:.3f}".format(df))
   

3. 字符串

   • 字符串类型的表示

     • 字符的有序序列（有序就是可以索引）

     • "请输入温度："#一对引号
       """python
       		语言"""#一对三引号
       #单引号也可以
       #注意一对三单引号就是字符串，但是这个字符串无关联的放在代码里可以看成多行注释
       #这种冗余是为了方便字符串内部的引号
       

     • 字符串的索引和切片

       顾头不顾尾

       #正向序号从0开始，逆向从-1开始
       索引：str[m]
       切片：str[m,n,step],三个参数都可以缺失，m缺失去表示到开头（等效于m=0），n缺失表示到结尾（注意:并不等效于n=-1）,step默认为1
       

       ==技巧str[ : :-1]==表示逆序列

       而s[:-1]表示切去最后一个字符

       ==转义符反斜杠\==其后的字符真的只有字符本意，\".\n.\t.\b(这是光标回退)

   • 字符串操作符(三个)

     #x,y,s是字符串。n是整数。
     x + y #连接
     x * n #复制连接
     x in s #子串判断
     

   • 字符串处理函数

     #x是字符串,other是任意其他类型，i是整数,u是unicode编码
     len(x)#字符串长度 len("1235") = 4
     str(other)#强制类型转换，有点像eval(x)的逆函数
     hex(i)或oct(i)#返回整数对应的十六进制或八进制小写的字符串 hex(15)="0xf"
     	print(hex(20))
     
     chr(u)#编码变字符 chr(10004)返回“√”  而str(ord(“√”))=10004
     ord(x)#字符变编码
     #9803的巨蟹的编码
     

     unicode是python的编码，此编码几乎覆盖了所有字符文字，从0到1114111（0x10ffff），每个编码对应一个字符

   • 字符串的处理方法（八个）

     "ABC".lower()="abc"
     "abc".uper()="ABC"
     "a,bb,c".split(",")=["a","bb","c"]#是根据“，”分割，但是字符串本身要有“，”
     “my name is sn”.count("n")=2
     
     "my name is aaa".replace("aaa","sn")
     "hello".center(width[,fillchar])#"hello".center(9,"=") 是===hello===
     “===hello===”.strip(" =po")是"hell"
     ",".join("hello")是"h,e,l,l,o"#除了最后一个字符后都会有，，参加到
     

     .func()方法是面向对象的形式

   • 字符串的格式化操作

     • “hello”.format()

     #槽 {}表示，默认0,1,2……(可以不使用默认)对应后面的参数
     #槽内部还有参数来规定输出格式
     #前三个是字符串：填充(#=*)，对齐（<^>）和宽度(20)(默认是空格填充，左对齐)
     "hello {0:=^7}".("world")是 hello =world=
     #后三个是数字相关 <,> (千位分隔符) <.2精度> 
     “{0：,.3f}”.format(12345.6789)是123,45.679
     类型 整型：b是二进制  c是字符 d是十进制  x是十六进制 X是大写的十六进制  
     	浮点：e是科学计数法 f浮点  %是百分数
     

4. time库的使用

   • 三类函数：时间获取，时间格式化，程序计时
   • 时间获取

   import time as ti
   print(ti.ctime())
   		==>Fri Mar 11 19:58:24 2022
   # (直接用time.time()返回的是浮点数（1970年1月1日开始），时间戳不易读)
   #gmtime（）则是得到一个时间结构体（计算机可读），里面有年月日时分秒的域
   #time.struct_time(tm_year=2022, tm_mon=3, tm_mday=11, tm_hour=12, tm_min=2, tm_sec=41, tm_wday=4, tm_yday=70, tm_isdst=0)
   

   • 时间格式化

     ti.strftime("%Y-%m-%d %H:%M:%S",ti.gmtime())
     是2022-03-11 12:45:27
     格式化代号能被计算机用对应域替换
     反过来还有ti.strptime(“2022-03-11 12:45:27”,%Y-%m-%d %H:%M:%S)可以返回一个时间结构体
     

   • 程序计时

     perf_counter()返回一个精确（CPU级别）的时间计数值（起点未知），调用两次做差就可以算出时间,单位是秒
     start = ti.perf_counter()
     ...
     end = ti.perf_counter()
     
     ti.sleep（3）#休眠3.3秒
     

5. 实例4：文本进度条

format里面{.2f}的.2f前一定要加：，应该是{:.2f}

进度条与程序计时

进度条先慢后快更符合人类需求

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

第4周 基本数据类型

1. 程序的分支结构

   • 单分支

   • 二分支

     • 紧凑模式（紧凑不能赋值，只能返回一个表达式）

       # stmt1 if condition else stmt2
       print("猜{}了".format("对" if i==1 else "错"))
       

   • 多分支

     • if<>: elif<>: else:

   • 条件判断与逻辑运算

     • ==，!=, <= 等
     • and（&&） or（||） not（~）

   • 异常处理

     #num = eval(input(“请输入一个整数”))万一输入不是整数呢？
     try:
         <stmt1>
     except <异常类型（可缺省）>:
         <stmt2>#异常时执行
     else：
     	<stmt3>#不发生异常时候执行
     finally：
     	<stmt4>#一定会在最后执行一次
       eg:
     try:
         num = eval(input(“请输入一个整数”))
         print(num**2)
     except NameError:  #因为异常类型是python自定义的不用使用字符串表示nameerror
         print("输入不是整数")
     

2. 实例5：身体质量指数BMI

   • BOdy Mass Index = kg/m²

   • 输入体重和身高（多个输入）&& 输出健康范围

     • a,b =1,2是可行的赋值办法 me,myf =“sn”,“szp”
     • 注意多分支条件之间的覆盖与分叉（这是程序逻辑问题）
     • 读程序先读分支

     #BMI.py
     height,weight = eval(input("请输入身高（m）与体重（kg）[请使用，隔开]"))
     bmi = weight / height**2
     print("BMI的数值为：{0:.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))  
     

3. 程序的循环结构

   • 遍历循环（遍历某一结构）

     • for i in 结构:

       #计数循环  利用range（N）产生序列结构
       for i in range(m,n,k):  [这个产生的就是切片一样的逻辑，顾头不顾尾]
       #其他结构体
       for c in "python123":  这就是遍历字符串，元素就是字符
       for item in ["1","python"]: 遍历序列
       for line in fi: 遍历文件的行
           只要是多个元素组成的结构都可以遍历
       

   • 无限循环（条件循环）

     • while condition:
     • ctrl + c 可以退出无限循环

   • 两个保留字：

     • break（打破内层循环结构，结束）
     • continue（结束当次循环，继续看条件是否需要继续循环，作用是跳过）

   • 与else扩展搭配，else作为正常完成循环（没有被break）的奖励

     • 类似之前有try的else奖励

4. 模块3:random

   • 计算机利用种子经过梅森旋转来产生伪随机数

   • 种子相同，随机数相同

     random.seed(10)#设置种子为10，不调用就默认使用当前系统时间
     random.random()#生成一个[0.0,1.0）的小数，如果重置为10，继续调用random（）结果不变，使用固定种子可以复现
     #扩展
     random.randint(a,b)#产生[a,b]之间的整数
     random.choice(seq)#随机选择序列里的一个元素
     random.shuffle(seq)#打乱序列并返回序列
     

5. 实例6：圆周率计算

   • 蒙特卡罗方法：随机撒点概率法

     #culpi.py
     #数学方法 #使用 \ 换行的技巧
     pi = 0
     N = 100
     for i in range(N):
         pi += 1/pow(16,i)*(\
             4/(8*i+1) - 2/(8*i+4) -\
             1/(8*i+5) - 1/(8*i+6))
     print("圆周率是：{}".format(pi))
     #撒点（计算思维）
     import random as r
     import time as t
     darts = 1000*1000
     hits = 0.0
     start = t.perf_counter()
     
     for i in range(1,darts+1):
         x , y = r.random(),r.random()
         dist = pow(x**2+y**2, 0.5)
         if dist <= 1.0:
             hits += 1
     pi = 4*(hits/darts)
     print("圆周率是：{}".format(pi))
     print("运行的时间是：{:.5f}".format(t.perf_counter()-start))#主要就是花在了循环里
     

第5周 函数和代码复用

1. 函数的定义与使用

   • 可选参数（定义时赋值）放在非可选技能后
   • 可变参数 也靠最后放*b，表示变量名是b的一个元组，也就是不确定数量的参数，max和min函数使用了*b
   • python 默认是位置传递，也可以名称传递
   • return 可以返回0个或任意多个返回值，多个值返回的就是元组，可以直接用，隔开的变量来接收元组的值
   • 注意函数内部的局部变量和程序的全局变量，函数使用完后局部变量会被回收，函数内部用global声明一下就可以使用全局变量
     • 但是全局组合数据类型可以直接在函数内部使用（使用不包含真实创建，也就是不包含[ ]），说白了组合数据类型是指针，而[ ]就是malloc
   • lambda函数，是函数的紧凑表达定义，略 f=lambda x,y: x+y

2. 实例7 ：七段数码管绘制

   #pipedraw.py
   import turtle as t
   import time as ti
   #定义单条线的是否绘制函数
   def drawGap():
       t.penup()
       t.fd(5)
   def drawLine(draw):
       drawGap()
       t.pendown() if draw else t.penup()
       t.fd(40)
       drawGap()
       t.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)
       t.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)
       t.left(180)
       t.penup()
       t.fd(20)
   def drawDate(date):
       t.pencolor("red")
       for i in date:
           if i == "-":
               t.write("年",font=("Arial",18,"normal"))
               t.pencolor("green")
               t.fd(40)
           elif i == "=":
               t.write("月",font=("Arial",18,"normal"))
           elif i == "+":
               t.write("日",font=("Arial",18,"normal"))
           else:
               drawDigit(eval(i))
   def main():
       t.setup(800,350,200,200)
       t.penup()
       t.fd(-300)
       t.pensize(5)
       drawDate(ti.strftime("%Y-%m=%d+",ti.gmtime()))
       t.hideturtle()
       t.done()
   main()
   

3. 代码复用与函数递归

   • 函数 和 对象是实现代码复用的两种方法，也是代码抽象的不同级别

   • 对象 ：属性和方法 是对一组数据变量和函数的抽象

   • 分而治之： 子程序是模块，主程序是模块的关系，函数内部紧耦合，模块之间松耦合来提高可复用性

   • 递归：在定义中调用自身（函数本身结构类似数学归纳法，有分支语句分别写基例和链条）

     • 字符串反转

       #s[::-1]
       def rvs(s):
           if s == "":#此为基例
               return s
           else:
               return rvs(s[1:])+s[0]
       

     • 斐波那契

     • 汉诺塔（A到C的n个变为A到C的n-1个是很好写的链条）不要去想过程

4. 模块4：PyInstaller库（打包）的使用

   • 将源代码打包成无需解释器的可执行文件
   • PyInstaller是第三方库，需要用命令行的pip指令来安装该库
   • pyinstallers -F sn.py (只用保留dist) -i tubiao.ico
   • 用-i可以打包一个图标.ico

5. 实例8: 科赫雪花小包裹

   • 分形几何：具有迭代关系（整体和局部很相似）的对称几何图形

   • 基例：直线 链条：画四个低阶的size为1/3的

     #snow.py
     import turtle as t
     def koch(size,n):
         if n == 0:
             t.fd(size)
         else:
             for angle in [0,60,-120,60]:
                 t.left(angle)
                 koch(size/3,n-1)
     def main():
         t.setup(600,600)
         t.penup()
         t.goto(-200,100)
         t.pendown()
         t.pensize(2)
         level = 3
         koch(400,level)
         t.right(120)
         koch(400,level)
         t.right(120)
         koch(400,level)
         t.hideturtle()
     main()
     

第6周 组合数据类型

1. 集合类型及操作

   • 多个元素的无序组合，集合内的元素不能是可变的（因为集合的互斥性）

   • { }表示

   • 建立集合用{}或者set（），注意建立空集合只能用set() #想想为什么不能用{}

     A = {"123","123","python","py"} ==>实际上还是只有一个”123“
     B = set("pypy123")  ==》是{"p","1","2","3","y"} set是把另一种组合类型转换来的，并且不再用顺序
     

   • 运算操作：

     S|T 并
     S-T 差
     S&T 交
     S^T 这是并减去交
     
     < > <= >=表示子集或真子集的判断
     

   • 方法

     A = set("python123")
     try:
         while True:
             print(A.pop(),end="")
     except:
         pass #pass是空语句，比注释更优雅
     
     >>>A
     set()#这就是空集合  为什么不是{}？后面会知道
     

   • 应用场景

     • 数据去重 : set（）本来就是用来转换其他组合数据的

2. 序列类型及操作

   • 一维元素向量，有顺序可以索引（完全同字符串索引），但元素类型可以不同

   • 常见衍生有三种：字符串“”，元组（），列表[ ] 有通用的序列方法，也有各自的方法

   • 操作符：

     x in s
     x not in s
     s + t
     s * n 或者 n*s
     s[i]
     s[i,j,k]#顾头不顾尾的切片
     ## s[::-1]是反序列
     

   • 序列的通用方法

     len(s)
     min(s) max(s)#（当元素类型相同且可比较时）
     s.index(x,i,j)#从i到j位置第一次出现x的下标，ij可以缺省
     s.count(x)#计数x的出现次数
     

     • 元组类型

       • 是序列的一种，一旦创建不能被修改

       • 使用（）或者tuple（）来创建，元素间用，来分割

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

       • 多个返回值在python内部其实就是返回了一个元组，只是使用隐式的括号

       • 用元组里的元素可以是元组（二维数组的索引方式），不能是列表，因为元组类型的元素不可以修改

       • 由于不能修改，方法就是通用方法

     • 列表类型

       • 是一种可以修改的组合类型

       • 使用[]或者list()来创建，没有元素限制

       • 注意：列表的赋值只是引用，不是创建，只有使用[]或list（）才是malloc

       • 列表的方法

         ls[i] = x
         ls[i,j] = lt #lt长度不一定等于j-i
         del ls[i]#删除切片也可以
         ls += lt #加在后面
         
         ls.append(x)
         ls.clear()
         ls.reverse()
         ls.insert(3,x)#第三添加x，其他的向后挪
         
         

     • 序列的应用场景

       • 元组：不改变的场景，函数返回值（数据保护）
       • 列表：处理数据或数据表示
       • 元素遍历 for item in tp：

3. 实例9：基本统计值计算

   #cal.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 += num
       return s/len(numbers)
   
   def dev(numbers,mean):
       sdev = 0.0
       for num in numbers:
           sdev += (num-mean)**2
       return (sdev/len(numbers))**0.5
   
   def median(numbers):
       numbers = sorted(numbers)
       size = len(numbers)
       if size%2 :
           return (numbers[size//2]+numbers[size//2-1])/2  #下标index只能是整数，不要使用/ 而要使用//
       else :
           return numbers[size//2]
   
   n =  getNum()
   m = mean(n)
   
   print("平均值：{}，方差{:.2},中位数{:.2}".format(m,dev(n,m),median(n)))
   

4. 字典类型及操作

   • 映射：就是键（索引）值（数值）对

     • 之前默认的索引是index
     • 字典通过键值对实现对索引的拓展，（键值对的集合，想想{}不能创建空集合的原因就是为了保留给空字典）

   • 字典类型函数与方法

     #k是键
     del d[k]
     k in d #注意是 索引in字典
     d.keys()#返回的是字典键表，和list不尽相同
     d.values()
     d.items()#返回所有键值对信息
     
     
     d = {"中国":"北京", "美国":"华盛顿", "法国":"巴黎"}
     "中国" in d
     d["日本"] = "东京"#没有的就会新增
     
     d.get(k,<default>)#如果k键存在返回值，否则返回默认值
     d.pop(k,<default>)#得到值后，会删除对应键值对
     d.popitem()#随机取出一个键值对，元组形式
     d.clear()
     len(d)
     
     d.get("英国"，"不在字典里")
     >>>不在字典里
     

   • 字典主要就是用来表示映射的，得出k的属性值

5. 模块5：jieba库的使用

   • 优秀的中文分词第三方库

   • shell: pip install jieba

   • 三种模式

     • 精确模式：物理切割，没有冗余
     • 全模式：所有可能的词语，可能有不同的理解与切分（组合起来是有冗余的）
     • 搜索引擎模式：是精确模式的进一步对长词语的切分，有利于搜索引擎使用

   • jieba库常用函数

     jieba.lcut(s) #精确模式，将字符串s切割成list并返回列表
     jieba.lcut("中国是一个伟大的国家")
     >>>["中国","是","一个","伟大","的","国家"]
     
     jieba.lcut(s，cut_all=True) #全模式
     jieba.lcut("中国是一个伟大的国家")
     >>>["中国","国是","一个","伟大","的","国家"]
     
     jieba.lcut_for_search(s) #搜索模式
     >>>["中华","华人","人民","共和","共和国"，"中华人民共和国"]
     
     
     jiaba.add_word("蟒蛇语言")#向词库里添加新的词汇
     

6. 实例10：词频统计

   #文本来源略，也可以自己选择txt文件 注意该实验我使用F5报错，是因为我的python默认路径在更上一层，找不到文件
   #CalHamletV1.py
   def getText():
       txt = open("ham.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 #这语句在没有该word时候，添加键值对并且赋值0+1，有的时候直接+1，两层意义
   items = list(counts.items()) #所有键值对的列表
   items.sort(key=lambda x:x[1], reverse=True)#按照键值对的第二个元素（x[1]）按照由大到小(reverse=True)来排列
   for i in range(10):
       word, counts = items[i] #键值对赋值给元组
       print("{0:<10}{1:>5}".format(word, counts))
   

   #三国演义出场次数统计，但是本代码只是词频统计 
   #Unicode的编码方式有三种 ：UTF-8、UTF-16、UTF-32。由于UTF-8与字节序无关（无需BOM），同时兼容ASCII编码，使得UTF-8编码成为现今互联网信息编码标准而被广泛使用。
   #three.py
   import jieba
   txt = open("threekingdoms.txt","r",encoding="utf-8").read()#解码不能用gbk了
   excludes = {"将军","却说","荆州","二人","不可","不能","如此"}
   words = jieba.lcut(txt)#英文文章使用空格来split文件得到的列表
   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):
       name, count = items[i]
       print("{0:<10}{1:>5}".format(name, count))
   

第7周 文件和数据格式化

1. 文件的使用

   • 文件的类型

     • 文件是数据的存储与集合

     • 文本文件与二进制文件（注意所有文件都是01串）

       • 文本文件是单一特定编码组成的文件，文本文件就是字符串，比如.txt,.py，可以说文本形式就是将二进制统一编码为了人类习惯的符号

       • 二进制文件是直接由0和1组成的（更侧重于存储形态），没有统一编码，一般由特定软件解读 如 .png,

         注意：\xab\x35 这样就是指没有编码的字节，打开时使用“rb”模式就可以看到文件的存储形式
         

   • 文件的打开关闭

     • 打开——操作——关闭

     • a = open( , )和a.close( )将文件标记和取消占用状态，可以认为是取锁

     • 文件的打开

       • fd = open (<文件路径>,<打开模式>)
         #windows的路径名用的是\（转义则\\），但是你可以沿用/
         打开模式：
         "r"只读（默认），不存在则错误
         "w"覆盖写，不存在则创建
         "x"创建写，存在则报错
         "a"追加写，不存在则创建，写的东西在源文件内容的后面
         上述模式加上+号，表示在原来的权限上加上同时 读写 权限
         
         "b""t"二进制模式与文本模式，默认是文本模式，但是你也可以加上希望的编码模式 ，encoding="utf-8"
         默认是 rt
         
         关闭是调用方法
         

   • 文件的内容读取

     #都是文件句柄的方法
     #读
     str = f.read(2)  #s是f里的两个码元，没有给参数size就是读入全部内容作为字符串
     	遍历全文本，一次读入，统一处理，很长的文件不适合
         设置size，多次read（）就可以分批处理了（fd有自己的指针位置）
         
     line = f.readline() #读入一行，给了参数就是前size个，和read一样
     list = f.readlines()#读入所有行，形成列表（列表的元素是行字符串），参数hint选择前hint行
     	行处理
         一次读入，分行处理
         fd = open（fname，“r”）
         for line in fo.reaglines():
             print(line)
         fo.close()
         分行读入，分行处理
         for line in fo: #可以直接 in 句柄
             print(line) #line是以\n结尾的，可以用 line.replace("\n","") 然后用line.split(“，”)来返回每一行的短串列表
                  
     #写
     f.write("") #写入字符串或者字节流  需要以写方式打开
     f.writelines(lines)#写入一个字符串列表  readlines的返回值就可以 ，但是写入时中间不会换行也没有空格
     
     #修改操作指针的位置
     f.seek(offset) #offset: 0文件开头 1当前位置 2文件结尾
     需要注意的是，一般在写了文件之后，操作指针都在文件末尾，如果马上想要打印，结果为空，应该先调用一次f.seek(0)
     
     

2. 实例11：自动轨迹绘制

   • 写数据参数来绘图，而不是写代码来绘图

   #要先约定数据接口（格式）
   #一行表示一次操作：（行进距离，转向（0左1右），转向的绝对角度，R，G，B）
   #autotracedraw.py
   import turtle as t 
   t.title("自动轨迹绘制")
   t.setup(800,600,0,0)
   t.pencolor("red")
   t.pensize(5)
   #数据读取
   datals = []
   fd = open("./data.txt","rt")
   for line in fd:
       line = line.replace("\n","")
       datals.append(list(map(eval,line.split(",")))) #map() doesn't return a list, it returns a map object.
   fd.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.right(datals[i][2])
       else:
           t.left(datals[i][2])
   

   data.txt自己写

   ==map() doesn’t return a list, it returns a map object.==注意，外套一个list的转换才行

3. 一维数据的格式化和处理

   • 有顺序：列表 无顺序：集合 元组不能修改不使用

   • 一维数据的存储：

     • 空格分隔不换行（简单，但是数据本身不能存在空格）
     • 逗号分隔不换行（简单，但数据本身不能含有英文逗号）
     • 其他方式 比如用$（请确保数据里没有）

   • 一维数据的处理

     • 是指存储格式到数据表示的转换（从文件获得数据结构，或者写入文件）

       split方法 和 join方法

       txt = open(fname).read()
       ls = txt.split() #存储格式变数据结构，默认是空格分隔 可以加入参数作为分隔符
       f.close
       
       #写入文件用str = “”.join(lsit)
       
       

4. 二维数据的格式化和处理

   • 使用二维列表表示

   • 使用两层for循环来遍历

   • CSV格式与二维数据存储

     • csv COMMA-SEPARATED VALUES

       • 就是通用的使用逗号隔开的一二维数据，比如一般的表格就可以用逗号和换行来存储
       • 元素缺失也应该有“，”
       • “，”和数据之间没有额外空格
       • 数据内部有逗号，在数据两侧加引号来表示该逗号不是分隔号（也可以在，前加上转义符）
       • 默认先行后列的索引习惯 ls[row][column]

     • 从csv读入数据

       #将csv转变为二维列表
       fo = open(fname)
       ls = []
       for line in fo:
           line = line.replace("\n","")
           ls.append(line.split(","))
       f.close()
       #将二维列表保存为csv
       ls = [[],[],[]]
       f = open(fname,"w")
       for item in ls：
       	f.write(",".join(item) + "\n")
       f.close()
       #遍历
       for row in ls:
           for culumn in row:
       

5. 模块6：wordcloud库的使用

   • (cmd命令行) pip install wordcloud

     • Microsoft Visual C++ 14.0 or greater is required. Get it with "Microsoft C++ Build Tools": https://visualstudio.microsoft.com/visual-cpp-build-tools/
       报这个错误是因为没有VC++，如果你有vs studio集成就不会报错，或者直接安装wordcloud的whl
       

     • 中文需要分词并且使用空格来join才能被wordcloud使用

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

   • https://python123.io/resources/pye/%E6%96%B0%E6%97%B6%E4%BB%A3%E4%B8%AD%E5%9B%BD%E7%89%B9%E8%89%B2%E7%A4%BE%E4%BC%9A%E4%B8%BB%E4%B9%89.txt

   • https://python123.io/resources/pye/%E5%85%B3%E4%BA%8E%E5%AE%9E%E6%96%BD%E4%B9%A1%E6%9D%91%E6%8C%AF%E5%85%B4%E6%88%98%E7%95%A5%E7%9A%84%E6%84%8F%E8%A7%81.txt

   • #注意：scipy已经将imread等命令删除，官方文档中有说明，需要使用的是imageio模块
     #cloud.py
     import jieba
     import wordcloud
     from imageio import imread
     mask = imread("fivestart.png")
     f = open("zhengfu.txt","r",encoding="utf-8")
     t = f.read()
     f.close()
     
     ls = jieba.lcut(t)
     txt = " ".join(ls)
     
     w = wordcloud.WordCloud( font_path="msyh.ttc",mask=mask,width = 1000, height = 700, background_color="white",max_words=50 )
     w.generate(txt)
     w.to_file("grwordcloud.png")
     

第8周 程序设计方法学

1. 实例13：体育竞技分析

   • 抽象+自动化

   • N轮模拟迭代后可以得到稳定的比例，可以科学估计选手水平

   • 自顶向下（解决问题）：讲一个总的问题拆解成子问题，一直划分直到计算机可解决 main到子函数

   • 自底向上（执行方案）：就是局部组装后整合 写子函数

   • #sport.py
     from random import random
     
     def printInfo():
             print("这个程序模拟两个选手A和B的竞赛")
             print("程序需要知道A和B的能力值（0到1之间的小数）以及比赛次数")
     
     def getInput():
         a = eval(input("请输入A的能力值（0到1之间的小数）："))
         b = eval(input("请输入B的能力值（0到1之间的小数）："))
         n = eval(input("请输入B比赛次数："))
         return a,b,n
     
     
     def gameover(scoreA,scoreB):
         return scoreA == 15 or scoreB == 15
     def simOneGame(proA,proB): #修改比赛规则只用修改此结构
         scoreA,scoreB = 0, 0
         serving = "A"
         while not gameover(scoreA,scoreB):
             if serving == "A":
                 if random() < proA:
                     scoreA += 1
                 else:
                     serving = "B"
             else:
                 if random() < proB:
                     scoreB += 1
                 else:
                     serving = "A"
         return scoreA, scoreB
     
     
     def simNGames(n,proA,proB):
         winsA, winsB = 0, 0
         for i in range(n):
             scoreA,scoreB = simOneGame(proA,proB)
             if scoreA > scoreB:
                 winsA += 1
             else :
                 winsB += 1
         return winsA, winsB
     
     
     
     def printSummary(winsA,winsB):
         n = winsB + winsA
         print("开始分析，共模拟{}场比赛".format(n))
         print("选手A胜利{}场比赛，胜率为{:0.1%}".format(winsA,winsA/n))
         print("选手B胜利{0：}场比赛，胜率为{1:0.1%}".format(winsB,winsB/n))
         #注意;想要在{：}的：前加index的话，每个字符串里的{}都要有index，不能有的有，有的没有
     
     def main():
         printInfo()
         proA, proB, n = getInput()
         winsA, winsB = simNGames(n,proA,proB)
         printSummary(winsA,winsB)
     
     main()
     

2. python程序设计思维

   • 计算机的高强算力可以避开数学逻辑，利用递归或者模拟原子结构来实现
   • 抽象 + 自动化
   • 计算生态：开源软件项目，自由软件，免费的分布的贡献的完善（真正推动）
     • “共识原则”“社会利他”
     • 给了活力与动力，甚至竞争
     • API ！=生态 前者是顶层设计的产物，后者是野蛮生长竞争的产物
     • http://python123.io
   • 用户体验
     • 进度展示
     • 异常处理
     • 打印信息
     • 日志文件
     • 使用帮助
   • 程序设计模式
     • IPO
     • 自顶向下
     • 模块化设计（松耦合与紧耦合）
     • 配置化设计（数据文件作为参数驱动，之后使用只需要修改配置文件）
     • 商业要求

3. python的第三方库安装

   • 更大的python世界

     • 全球社区主站 https://pypi.org/
       • pypi: python package index
       • 例子：搜索blockchain

   • pip安装方法

     • 命令行 （下载慢需要换pip源）

       pip search blockchain #搜索
       pip install <第三方库名>
       pip download <第三方库名>#下载不安装
       pip uninstall <第三方库名>#卸载
       pip install -U <第三方库名>#更新
       

   • 集成安装方法

     • anaconda（数据计算领域使用广泛）
     • 支持近800个第三方库，包含多个主流工具，就是下载一个工具包，一次安装800个库
     • 不止包含库还包含了一些主流开发工具

   • 文件安装方法

     • 有的文件pip可以下载但是不能安装
     • 这主要是因为下载的是库源代码，还需要编译，但是你的系统没有对应的编译环境
     • 方法：可以下载编译环境（不推荐），也可以直接下载编译后的版本 但是原作者不提供，可以靠网友分享
     • 加州大学的教授维护的UCI页面，下载编译后的库 http://www.lfd.uci.edu/~gohlke/pythonlibs/
       • 下载对应系统和python版本后 pip install <下载路径>
       • 一般是whl压缩包（whl格式本质上是一个压缩包，里面包含了py文件，以及经过编译的pyd文件。使得可以在不具备编译环境的情况下，选择合适自己的python环境进行安装。），所以需要先 pip install wheel

4. 模块7：os库的基本使用

   • 通用的基本的与操作系统交互功能的 标准 库

     • 路径操作:os.path子库，文件路径信息

       • import os.path as pa
         pa.abspath("123.txt") #返回绝对路径
         pa.relpath("D://123.txt") #relative path  返回 ..//..//123.txt
         文件的字节数，修改时间，文件是否是目录
         

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

       • os.system(command)
         返回值就是 cmd的调用 返回值信息（返回0就是正确运行）
         如果是可执行文件，就相当于利用cmd执行
         os.system("C:\\Windows\\System32\\cal.exe")就会打开计算器返回0
         就是命令行
         os.system("C:\\Windows\\System32\\mspaint.exe .\\sn.png")就是用画板打开图片，和cmd一样
         

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

       • os.chdir(pathname)#修改当前程序操作关注的路径（当前路径） change
         os.getcwd()#返回当前路径
         用户名称，cpu数量，加解密随机数
         

5. 实例14：第三方库自动安装脚本

   • 根据列表自动执行pip

库名	用途	pip安装指令
NumPy	N维数据表示和运算	pip install numpy
Matplotlib	二维数据可视化	pip install Maplotlib
PIL	图像处理	pip install PIL
Scikit-Learn	机器学习和数据挖掘	pip install Scikit-Learn
Requests	HTTP协议访问及网络爬虫	pip install Requests
jieba	中文分词	pip install jieba
Beautiful Soup	HTML和XML解析器	pip install beautifulsoup4
Wheel	python第三方库打包工具	pip install wheel
PyInstaller	打包源程序为可执行文件的库	pip install pyinstaller
Django	web开发框架	pip install gjango
Flask	轻量级web框架	pip install flask
WeRoBot	微信机器人开发框架	pip install werobot
Sympy	数学符号计算工具	pip install sympy
Pandas	高效数据分析和计算	pip install pandas
Networkx	复杂网络和图结构	pip install networkx
PyQt5	GUI开发框架	pip install pygt5
PyOpenGL	多平台OpenGl开发接口	pip install pyopengl
PyPDF2	PDF内容提取与处理	pip install pypdf2
docopt	python命令行解析	pip install docopt
PyGame	简单游戏开发框架	pip install pygame

• #BatchInstall.py
  import os
  libs = { "numpy","matplotlib","pillow","sklearn","requests",\
      "jieba","beautifulsoup4","wheel","networkx","sympy",\
      "pyinataller","ajango","flask","werobot","pyqt5",\
      "pandas","pyopengl","pypdf2","docopt","pygame"}
  try:
      for lib in libs:
          os.system("pip install " + lib)#注意insyall后需要一个空格
      print("Successful")
  except:
      print("Failed Somehow")
  

• 举一反三：

  • 可以调用其他各种程序
  • 能否设置化文件 之后只需要修改配置文件
  • 扩展异常检测的能力

第9周 python计算生态概览

1. 从数据处理到人工智能

   • 数据表示 数据清洗 数据统计 数据可视化 数据挖掘 人工智能
   • Python库之数据分析
     • Numpy：表达N维数组，内层C语言，速度优异，是数据分析的重要基础，支撑其他库，有一些基础运算功能（比如矩阵运算）
     • Pandas：数据分析高层次应用库，两种数据结构，基于Numpy但是拓展了表示方式
       • Series = 索引 + 一维数据
       • DataFrame = 行列索引 + 二维数据
     • SciPy：数学，科学和工程计算功能库，类似Matlab，也是基于NumPy
       • 科学计算功能库
       • 傅里叶变换，稀疏，信号处理，图像，信号
   • Python库之数据可视化
     • Matplotlib：高质量的二维数据可视化功能库
       • 超过100中数据可视化效果
       • 核心子库是matplotlib.pyplot
       • 也是基于Numpy
     • Seaborn：统计类数据可视化
       • 基于Matplotlib，支持NumPy和Pandas
       • 绘制一些分布，关系
     • Mayavi：三维度可视化 （很好看哦）
   • Python库之文本处理
     • PyPDF2：PDF文件处理
       • 获取信息，分割整合，加密解密（该库pyhon语言实现）
     • NLTK：自然语言文本处理，可以绘制分析树
     • Python-docx：处理Word
   • Python库之机器学习
     • Scikit-learn：机器学习方法库
     • TensorFlow：是谷歌推动的开源机器学习框架，Alphago
     • MXNet：基于神经网络的深度学习（可以实现人工智能的简单任务）

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

   • 该实例为展示实例，需要了解matplotlib的用法
   • 目标+沉浸+熟练

3. 从web解析到网络空间

   • Python库之网络爬虫
     • Requests:最友好的网络爬虫功能库、
       • 提供了简单易用的类HTTP协议网络爬虫功能
       • 支持连接池，SSL，Cookies，HTTP(S)代理等
       • 页面级
     • Scrapy：优秀的网络爬虫框架（框架就是指功能的半成品或者基础款）
       • 、批量定时与处理
     • Pyspider：强大的Web网页爬取系统
       • 完整版，专业级
   • Python库之Web信息提取
     • beautisoup4：HTML和XML的解析库
       • 接收爬虫抓获的页面并树形分析
     • Re：正则处理（标准库）
     • Python-Goose：文章类型提取
   • Python库之Web网站开发
     • Django：大型Web应用框架
     • Pyramid：规模适中
     • Flask：微框架
   • Python库之网络应用开发
     • WeRoBot：微信公众号的开发框架
       • 和微信服务器交互，可以给微信反馈消息
     • aip：访问百度ai技术的python接口
       • 是百度ai在用户端使用的主要接口
     • MyQR：二维码生成的第三方库
       • 有能动的二维码哦（doge）

4. 从人机交互到艺术设计

   • Python库之图形用户界面（GUI）
     • PyQt5：非常成熟，完备，跨平台（Qt5早就成熟了）
     • wxPython：提供了专用于Python的跨平台GUI开发框架
     • PyGObject：使用了GTK+
   • Python库之游戏开发
     • PyGame：入门
     • Panda3D：3D渲染和游戏开发库（非常强大，机器推荐）
     • cocos2D：基于OpenGL，支持GPU加速
   • Python库之虚拟现实
     • VR zero：入门级，基于树莓派（信用卡大小的微型嵌入式电脑），配置也简单
     • pyovr：针对O公司的VR设备
     • Vizard：通用VR开发引擎（专业，企业级）
   • Python库之图形艺术
     • Quads库：迭代的艺术（像素风格，可以动态，十分有趣）
     • ascii_art：字符风格
     • turtle

5. 实例16：玫瑰花绘制

   • 输入你的精力，输出你的意愿（doge）
   • 完结撒玫瑰花

6. 后续学习指导

   • python的进阶语法（面向对象编程）
   • python的高级语法（pythonic编程）
   • python everywhere

析树
- Python-docx：处理Word

• Python库之机器学习
  • Scikit-learn：机器学习方法库
  • TensorFlow：是谷歌推动的开源机器学习框架，Alphago
  • MXNet：基于神经网络的深度学习（可以实现人工智能的简单任务）

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

   • 该实例为展示实例，需要了解matplotlib的用法
   • 目标+沉浸+熟练

3. 从web解析到网络空间

   • Python库之网络爬虫
     • Requests:最友好的网络爬虫功能库、
       • 提供了简单易用的类HTTP协议网络爬虫功能
       • 支持连接池，SSL，Cookies，HTTP(S)代理等
       • 页面级
     • Scrapy：优秀的网络爬虫框架（框架就是指功能的半成品或者基础款）
       • 、批量定时与处理
     • Pyspider：强大的Web网页爬取系统
       • 完整版，专业级
   • Python库之Web信息提取
     • beautisoup4：HTML和XML的解析库
       • 接收爬虫抓获的页面并树形分析
     • Re：正则处理（标准库）
     • Python-Goose：文章类型提取
   • Python库之Web网站开发
     • Django：大型Web应用框架
     • Pyramid：规模适中
     • Flask：微框架
   • Python库之网络应用开发
     • WeRoBot：微信公众号的开发框架
       • 和微信服务器交互，可以给微信反馈消息
     • aip：访问百度ai技术的python接口
       • 是百度ai在用户端使用的主要接口
     • MyQR：二维码生成的第三方库
       • 有能动的二维码哦（doge）

4. 从人机交互到艺术设计

   • Python库之图形用户界面（GUI）
     • PyQt5：非常成熟，完备，跨平台（Qt5早就成熟了）
     • wxPython：提供了专用于Python的跨平台GUI开发框架
     • PyGObject：使用了GTK+
   • Python库之游戏开发
     • PyGame：入门
     • Panda3D：3D渲染和游戏开发库（非常强大，机器推荐）
     • cocos2D：基于OpenGL，支持GPU加速
   • Python库之虚拟现实
     • VR zero：入门级，基于树莓派（信用卡大小的微型嵌入式电脑），配置也简单
     • pyovr：针对O公司的VR设备
     • Vizard：通用VR开发引擎（专业，企业级）
   • Python库之图形艺术
     • Quads库：迭代的艺术（像素风格，可以动态，十分有趣）
     • ascii_art：字符风格
     • turtle

5. 实例16：玫瑰花绘制

   • 输入你的精力，输出你的意愿（doge）
   • 完结撒玫瑰花

6. 后续学习指导

   • python的进阶语法（面向对象编程）
   • python的高级语法（pythonic编程）
   • python everywhere