python MOOC 笔记

Python MOOC 笔记

博客说明

1. 本文为MOOC上的python语言程序设计课程笔记，结合自己写c++的一些比较，仅个人所见，不一定全，也不保证没有错误，欢迎指正。
2. 本文只是自己写来记录记录学习过程，会持续更新至结束。
3. 本文也不适合入门者参考，因为我是以一个c++转python的身份写的，一些东西略去了，python入门学习建议观看MOOC原视频。
4. 因为是第一篇markdown写的文章，格式语法等可能尚有不足。

课程定位与绪论

1. 在线课程：MOOC
   
2. 在线实践：https://python123.io
   
3. 课程安排

第一章——python的基本语法元素

1.程序设计基本方法

1. 语言类型

2.程序编写方法
IPO:

六步：

2.python开发环境配置

官网下载安装即可

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

4.python程序语法元素分析（基于温度转换实例）

• python注释：
  #表示单行注释；
  '''三个单引号括起来的表示段落注释'''
• python缩进：
  python执行严格缩进表示层次（不像c++使用{}）
• python命名：
  python变量命名与c++类似，但是可以用中文！python大小写敏感，所以虽然if是关键字但是IF却可以用作变量名
• python数据类型：
  整数、浮点、字符串与c++类似，但有个列表类型，用[]括起来，逗号隔开；字符串用单引号或者双引号都行
• python数组编号：
  一个是正向递增序号，比如数组索引，和c++一样；
  一个是反向递减序号，最后一个元素为-1，往前依次递减
• python索引与切片：
  <字符串>[M]返回字符串中M号字符；
  <字符串>[M:N]返回字符串中M号到N号（不含N号）字符，类似matlab里的用法
• 关键字in：
  表示是否在一个列表中，返回逻辑值。
• 分支语句：
  if 条件：注意条件语句中条件后要加冒号；
  else if在python里是elif
• 简单常用函数:input(),print(),eval()
• print()函数的格式化:
  print(“转换后的温度是{:.2f}C”.format©)——{}表示槽，format中的后续变量将以指定格式填充到这个槽里面； print另有逗号输出
• eval()函数：
  评估函数：将参数最外侧的引号去掉执行剩余语句，比如数字字符串去掉引号就成了相应数字类型，比如用一个字符串表示的命令，去掉引号就成了python可执行命令。 如eval(‘print(“Hello”)’)会去掉参数外侧引号剩下print(“Hello”)，这是一个可执行的python语句——eval()函数是个很有意思的函数，可以在运行时由用户给出执行的函数

↑

第二章——python基本图形绘制

1.深入理解python语言

• 计算机技术的演进（略）
• 程序语言的江湖（略）
• python的特点
  • 强制可读
  • 较少底层元素
  • 多种编程方式
  • 支持中文字符
  • 大量且快速增长的库
  • 跨平台

2.python蟒蛇绘制

看看代码：

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.turtle库的函数全解

这个链接写得比较全

4.turtle程序语法元素分析

• import引用库：
  其实就像c++里的#include<>包一样：
  import <库名>
  from <库名> import <函数名>
  from <库名> import *
  import <库名> as <库别名>
• 循环语句：
  for <变量> in range()
  range函数产生序列
  range(N)产生0-N-1的序列
  range(M,N)产生M到N-1的序列

↑

第三章——基本数据类型

1.数字类型及操作

整数，浮点数，复数，基本和c++差不多(多个复数类型)，区别如下:

1. 整数对应数学中的整数，可正可负且没有范围限制，不同于c++中有signed unsigned区别以及short,int,long区别
2. 浮点数对应数学中的实数，如c++中一样有尾数误差
3. 数值运算符与c++基本一样，但几点注意:
   1. /是除法运算，且不会出现整数除整数还是整数丢失精度的问题，因为python另有一个//整数除符号，如10//3=3，10/3=3.33333333
   2. 另外有**运算符，表冥运算，和pow一样;
   3. python也有增强赋值运算符如+=，**=等;
4. 常用函数也与c++差不多:pow,round等。

函数	说明
pow(x,y,z)	x^y%z
round(x,n)	将x四舍五入到n位小数

1. python类型转换(可以直接在类型之间转换)

示例	结果
int(123.3)	123
int(‘123’)	123

2.字符串类型及操作

字符串的表示，操作符，处理函数，方法，格式化:

• 字符串表示：

有以上多种字符串表示法可以使在字符串中使用单、双引号更简单：字符串中有单引号那么用双引号括起来；字符串中有双引号用单引号括起来；两者都有用三单引号括起来

• 字符创编号与切片：
  • 字符串编号为从左往右由0递增或是从右往左由-1递减
  • 字符串切片：

用法	意义
str[M:N]	str中M到N-1号元素
str[:N]	str中第一个到N-1号元素
str[M:]	str中M号到最后一号元素
str[M:N:i]	str中M到N-1号元素,每次步进i
str[::-1]	str中由最后一个元素到第一个

• 转义字符——python中也有转义字符\
• 字符串操作：

操作	意义
x+y	将x,y两个字符串连接
x*n或n*x	将x字符串复制n遍
x in s	判断x是否在s中(即是否为其子串)

• 字符串八个常用方法：

方法	意义
str.lower()	将str转换成小写
str.upper()	将str转换成大写
str.split(sep=None)	将str按sep字符分割
str.count(sub)	求sub子串在str中出现次数
str.replace(old,new)	将str中old子串替换成new
str.center(width[,fillchar])	字符串按宽度width居中且以fillchar填充两边
str.strip(chars)	将字符串两端的chars字符(们)去掉
str.join(iter)	将str插入到iter的每个元素之间，用于字符串分隔

• 字符串操作函数：

函数	意义
len(x)	计算字符串长度，中文字符也算一个
hex(x),oct(x)	将整数x转换成十六进制或八进制的字符串形式
chr(x)	将unicode x转换成对应字符
ord(x)	将字符x转成unicode

• 字符串格式化
  字符串中的{}表示占位槽,.format()函数中的参数填进槽中，{}中可使用如下格式参数限制输出数据格式：

格式参数（按顺序）	参数意义
填充	表示未填满的位置使用的填充符号
对齐	表示对齐方式,<左对齐,>右对齐,^居中对齐
宽度	表示输出数据占据位置宽度
千分位符号	表示输出数千分位符号,","或者没有
精度	表示输出数精度,保留小数位数
类型	表示输出数类型b,c,d,e,f,%等

例子：

"{0:*<10,.3f}".format(6225.3738)#其中的:之前的0表示对应format中的0号参数

输出：

'6,225.374****'

3.time库的使用

• 作用
  • 计算机时间的表达
  • 提供获取系统时间并格式化输出功能
  • 提供系统级精确计时，用于程序性能分析
• 使用

import time
time.<b>()#调用相关函数

• 函数类别

类别	例子
时间获取	time(),ctime(),gmtime
时间格式化	strftime(),strptime
程序计时	sleep(),perf_counter()

• 函数介绍

函数	描述
time()	返回当前时间浮点数
ctime()	返回当前时间字符串
gmtime()	获取当前时间结构体
strftime(tpl,ts)	将gmtime()获取的时间ts换成tpl模板指定的字符串如:time.strftime(’%Y-%m-%d %H:%M:%S",t)
strptime(ts,tpl)	与strftime相反,strptime将时间字符串转换成时间结构
perf_counter()	返回一个CPU级别精确的时间计数值,单位秒,一个 步骤前后两次perf_counter()然后时间值相减可计时
sleep(s)	程序休眠s秒

perf_counter用例:

start=time.perf_counter()
#do something here
end=time.perf_counter()
end-start#operation duration

• time库的时间格式控制符

格式化字符串	日期/时间说明	值范围和实例
%Y	年份	0000~9999,例如:1900
%m	月份	01~12,例如:10
%B	月份名称	January~December,例如:April
%b	月份名称缩写	Jan~Dec,例如:Apr
%d	日期	01~31,例如:25
%A	星期	Monday~Sunday,例如:Wednesday
%a	星期缩写	Mon~Sun,例如:Wed
%H	小时(24时制)	00~23,例如:12
%h	小时(12时制)	01~12,例如:7
%p	上下午	AM,PM
%M	分钟	00~59
%S	秒	00~59

4.文本进度条实例

废话不多讲，上代码：

#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.5)
print("执行结果")

这样的代码虽然每一行都输出进度，但是怎么控制单行输出进度呢？即这里需要控制print函数使其不换行（print函数默认换行），每次都在原位更新进度。

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

print函数中end的参数给定分隔符，默认的是换行，这里设为空就不换行，前面的\r表示回车。但是如果在IDLE中运行时不会原位刷新，因为IDLE中屏蔽了\r功能，所以应该在cmd或类似的环境中运行。

**提示：**有趣的是c++中也有\r功能，之前一直不知道。它表示回到行首，这样就可以原位输出。但是如果输出的字符串不如原来的长的话是不能完全覆盖的，也就是边输出边覆盖而不是先把原来的删除再输出.

↑

第四章——程序的控制结构

1.程序分支结构

• 单分支结构
  if <条件句>:
    <表达式>

结构图如下：

• 二分支结构
  • 一般语法如下：
    if <条件>:
      <语句1>
    else:
      <语句2>
  • 还有一种紧凑形式
    <表达式1> if <条件> else <表达式2>

**注意：**紧凑形式不支持带=的赋值语句，仅支持简单表达式

结构图如下：

• 多分支结构
  语法如下：
  if <条件1>:
    <语句1>
  elif <条件2>:
    <语句2>
  …
  else:
    <语句n>

结构图如下：

• 条件组合与关系运算
  关系运算符>，>=，<，<=，==，!=等与c++一致，但是python可支持连续比较，比如1<2<3输出true；逻辑运算符有and，or，not等
• 异常处理
  • 一般用法:
    try:
      <语句块1>
    except:
      <语句块2>
  • 指定异常类型:
    try:
      <语句块1>
    except <异常类型>:
      <语句块2>
  • 更高级用法:
    try:
      <语句块1>
    except:
      <语句块2>
    else:
      <语句块3> #else语句块在不发生异常时执行
    finally:
      <语句块4> #finally语句块一定执行

2.BMI实例

很简单的代码，主要就是处理分支语句，根据BMI¹判定胖瘦，略

3.程序循环结构

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

**注意：**遍历循环除了可以计数循环，还能遍历字符串循环、遍历文件循环，甚至可以对元组、列表、字典遍历循环，反正只要后边的遍历结构包含了多个元素，都可以遍历循环

• 无限循环
  while <条件>:
    <语句>

• 循环控制保留字

  • break
  • continue

• 循环的高级用法
  for <变量> in <遍历结构>:
    <语句块1>
  else:
    <语句块2>

  while <条件>:
    <语句块1>
  else:
    <语句块2>
  以上else与异常处理里面的else相似，表示循环没有遇到break时执行

4.random库的使用

random是用于生成随机数的标准库，使用梅森旋转算法生成伪随机数。
给个实例，清晰明了：

import random
random.seed(10)#设置种子,不设的话是系统时间，最好不设
random.random()#产生0到1的随机小数
random.randomint(1,10)#生成1到10之间的随机整数
random.randomrange(20,100,10)#生成20到100之间以10为步长的随机整数，第三个参数可不给
random.getrandbits(16)#生成一个16比特长的随机整数
random.uniform(10,100)#生成10到100的随机小数
s=[1,2,3,4,5,6,7,8,9]
random.choice(s)#在给出序列中随机选取一个数
random.shuffle(s)#将列表s随机打乱

5.圆周率实例

用了个蒙特卡洛法求圆周率²，很简单，不过有几个小点注意下：

1. python代码换行，末尾加个\就可换行，就像matlab中末尾加个...换行一样
2. 多赋值。比如x,y=random(),random()，再比如a,b=eval(input()),eval(input())

↑

第五章——函数和代码复用

1.函数的定义和使用

• 函数的理解与使用

  语法如下：

  def <函数名>(<参数列表>):

    <函数体>

    return <返回值>

• 函数使用及调用过程

  略。与c++一样，编程语言都差不多。

• 函数的参数传递

  与c++法则一样。同样地：

  1. 可给定可选参数，可选参数在非可选参数后面，如：

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

  2. 可给定可变参数，用*表示，不确定参数放最后，只能有一个（因为不确定参数可以表示任意多个），如下：

     def fact(n,*b):
         s=1
         for i in range(1,n+1):
             s*=i
         for item in b:
             s*=item
         return s
     #使用
     fact(10,3)#可变参数为一个
     fact(10,3,5,8)#可变参数为3个
     

  3. 参数传递有两种方式，按顺序传递与按名称方式传递。

     def fact(start,stop):
         s=1
         for i in range(start,stop+1):
             s*=i
         return s
     fact(1,5)#输出1连乘到5
     fact(stop=7,start=3)#输出3连乘到7，使用了按名称传递参数
     

• 函数的返回值

  • 函数可以没有返回值，甚至可以没有return关键字

  • 函数可以返回一个返回值也可以返回多个，返回多个时各个值用逗号隔开，如：

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

  • 接收多个返回值时可用多赋值，即赋值号前多个变量，用逗号隔开，如：

    a,b,c=fact(10,5)
    print(a,b,c)
    

• 局部变量与全局变量

  • 生存期与作用域不同，参考c++

  • 可用global关键字声明变量为全局变量（这个全局变量必须定义过了，所以一般放在函数前面定义，在函数里面再声明为全局，如：

    times=0
    def fact(n):
        global times#声明times是个全局变量，否则会生成局部变量覆盖上面的那个变量
        times+=1
        s=1
        for i in range(1,n+1):
            s*=i
        return s
    

  • 局部变量为组合数据类型且未在函数内部真实创建时，等同于全局变量，如：

    ls=["F","f"]
    def func(a):
        ls.append(a)
        return
    func("C")
    print(ls)
    #输出为:['F','f','C']
    

    对比：

    ls=["F","f"]
    def func(a):
        ls=[]
        ls.append(a)
        return
    func("C")
    print(ls)
    #输出为:['F','f']
    

  python中组合类型是由指针体现的，如果没有在函数中真实创建该组合类型，那么是通过指针操作全局变量

• lambda函数

  lambda是一种匿名函数显然，使用lambda保留字定义，以函数名为返回结果，是一种单行函数紧凑表达形式，语法如下：

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

  相当于：

  def <函数名>(<参数>):

    <函数体>

    return <返回值>

  不一样的是只能使用表达式做返回值，没有复杂的函数体语句，如：

  f=lambda x,y:x+y
  f(10,15)
  #输出为:25
  #定义无参的
  f=lambda :"lambda函数"
  print(f())
  #输出:lambda函数
  

2.七段数码管绘制实例

主要理解

• 模块思维：确定模块接口，封装功能
• 规则化思维
• 化繁为简思维

代码如下：

#七段数码管绘制
import turtle,time
def drawGap():
    turtle.penup()
    turtle.fd(5)
def drawLine(draw):
    drawGap()
    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,5,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):#date 日期格式为:'%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()

3.代码复用与函数递归

• 模块化设计

  • 紧耦合：两个部分之间交流很多，无法独立存在
  • 松耦合：两个部分之间交流较少，可以独立存在
  • 模块内部紧耦合，模块之间松耦合

• 函数递归思想——基例，链条，数学归纳法等（略）

• 递归调用过程（略）

• 有一个有趣的问题：

  python中最多能递归多少层次呢？我们知道在c++中函数调用是在栈上的，所以递归深度太深会导致栈溢出，那么python是不是呢？经过测试，python也是会溢出的，比如一个简单的求阶乘函数，发现递归994次时超出最大递归深度，这个函数中是没有临时变量的，也就是单纯保存函数地址溢出了：

  def fact(n):
      if n==1:
          return 1
      else:
          return n*fact(n-1)
  fact(993)#运行成功
  fact(994)#运行出错
  

4.PyInstaller库的使用

PyInstaller是一个第三方库，主要用于将python的.py文件编译成计算机可直接执行的文件（在windows上即.exe文件），这样使用方就不需要安装python就可以使用了。

1. PyInstaller安装

   在cmd下运行pip install命令即可安装python的第三方库，如下安装PyInsatller：

   pip install PyInstaller
   

2. 在要发布的.py文件的文件夹下打开cmd窗口（快捷方式为在目标路径下shift+右键->在此处打开命令窗口），执行命令pyinstaller -F加文件名.py。之后会生成三个目录，_pycache_，build，dist，前两个可删除，第三个目录下存在编译好的可执行文件。

3. PyInstaller常用参数

   参数	描述
   -h	查看帮助
   –clean	清理打包过程中的临时文件
   -D，–onedir	默认值，生成dist文件夹
   -F，–onefile	在dist文件夹下只生成独立的打包文件
   -i <图表文件名.ico>	制定打包程序使用的图标(ico)文件

5.科赫雪花实例

分形几何中有一种特殊曲线——科赫曲线³，以下给出代码：

#绘制n阶科赫曲线
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
    koch(400,level)
    turtle.right(120)
    koch(400,level)
    turtle.right(120)
    koch(400,level)
    turtle.hideturtle()
main()

↑

第六章——组合数据类型

1.集合类型及操作

• 集合类型的定义

  1. 集合是多个元素的无序组合
     • 集合类型与数学中集合概念一致
     • 集合元素无序、唯一
     • 集合元素不可改
  2. 集合用大括号{}表示，元素间用逗号,分隔
  3. 建立集合用{}或是set()函数
  4. 建立一个空集合必须使用set()函数

• 集合操作符

  集合的运算如数学中——并、差、交、补。

  操作符及应用	描述
  S|T	返回S与T的并集
  S-T	返回S与T的差集
  S&T	返回S与T的交集
  S^T	返回S与T的补集，相当于（S|T)-(S&T)
  S<T或S<=T,S>T或S>=T	判断S与T的包含关系，大的是母集小的是子集

  增强操作符	描述
  S|=T	S=S|T
  S-=T	S=S-T
  S&=T	S=S&T
  S^=T	S=S^B

  注意： 因为python中算术运算符优先于逻辑运算符，而求差集用的是算术运算符-，所以差集要比其他几个都优先，如a^b-c=a^(b-c)而不是(a^b)-c

• 集合处理方法

  操作函数或方法	描述
  S.add(x)	增加元素
  S.discard(x)	移除元素，如果x不在S中不报错
  S.remove(x)	移除元素，如果x不在S中抛出KeyError
  S.clear()	清除S中所有元素
  S.pop()	返回S中随机一个元素同时将其删除，S为空抛出KeyError
  S.copy()	返回S的一个副本
  len(S)	返回S中元素个数
  x in S	返回x是否在S中
  x not in S	返回x是否1不在S中
  set(x)	将一个其他类型变量x转换为集合

• 集合类型应用场景

  包含判断、数据去重等

2.序列类型及操作

• 序列类型定义

  • 系列是以为元素向量，元素类型可不同

  • 通过下标访问

  • 序列类型为一种基类

    与字符串类型一样，有正向递增序号和反向递减序号

• 序列类型处理函数及方法

  与字符串类似，有x in s，x not in s，s+t，s*n和n*s，s[i]，s[i:j]或s[i:j:k]等操作。

  确切来说应该是字符串与序列类似，因为字符串类型是序列类型的一个衍生

  有len(s)，min(s)，max(s)，s.index(x)及s.index(x,i,j)，s.count(x)——求序列长度，最小元素、最大元素、某个元素的第一次出现的索引以及在给定范围[i,j]中第一次出现的索引和某个元素出现的次数。

• 元组类型及操作

  • 元组是一种序列，一旦创建不可修改
  • 使用小括号()或tuple()创建，元素间逗号,分隔
  • 可使用小括号也可不使用，如函数返回多个返回值就是返回元组
  • 元组类型继承了序列类型的所有操作

• 列表类型及操作

  • 列表是一种序列，可修改

  • 用方括号[]或list()来生成

  • 用一个列表给另一个列表赋值，传递的是引用，如

    ls=["male","female","neutral","bisexual","transgender"]
    lt=ls#没有创建新的列表,lt与ls表示的是一个列表,意味着改变lt也会改变ls，除非改变的是引用
    lt=list(ls)#创建一个新列表与ls相同
    

  • 列表类型的操作方法

    函数或方法	描述
    ls[i]=x	将ls中i号元素赋值x
    ls[i:j:k]=lt	将ls中i:j:k段替换成列表lt
    del ls[i]	删除i号元素
    del ls[i:j:k]	删除i:j:k段元素
    ls+=lt	ls末尾增加lt
    ls*=n	ls自复制n遍
    ls.append(x)	向ls后追加元素x
    ls.clear()	清除ls列表
    ls.copy()	复制ls列表
    ls.insert(i,x)	在i位置插入一个元素x
    ls.pop(i)	弹出（即取出并删除）ls中i位置元素
    ls.remove(x)	移除ls中第一个出现的x元素
    ls.reverse()	反转ls列表

    注意： 列表的切片——i:j表示从i号开始到j号（不包括j号）；i:j:k表示i号开始到j号以步长为k步进，步长为k表示每隔k-1个取一个

• 序列类型应用场景

  表达一组有序数据，方便遍历；元组不可变，所以元组可以用来数据保护；列表非常灵活是最常用的序列类型。

3.基本统计值计算

简单地统计计算，求和、均值、方差、中位数等，略。

会用一些python内置函数，参考菜鸟教程的python内置函数。菜鸟教程是个不错的中文编程检索网站，适合当手册快速查询。

4.字典类型及操作

就是c++里面的dictionary，键值对数据类型。

• 字典是键值对的集合，无序

• 采用大括号{}或者dict()函数创建，键值对中以冒号:分隔键和值，逗号分,隔不同键值对

• 以中括号[]索引

  cap={"China":"Beijing","America":"Washton,D.C","France":"Palis"}
  whatever={}#生成一个空的字典,这是为什么不能用空大括号生成集合，因为是用来生成字典的
  cap["China"]
  #输出Beijing
  cap["the UK"]="London"#增加元素
  cap["France"]="Paris"#修改元素
  

• 操作函数与方法

  函数或方法	描述
  del d[k]	删除键k对应的值
  k in d	键k是否在字典d中
  d.keys()	返回所有键
  d.values()	返回所有值
  d.items()	返回所有键值对
  d.get(k,<default>)	键k存在返回其对应值，否则返回default
  d.pop(k,<default>)	键k存在弹出对应值，否则返回default
  d.popitem()	弹出键值对（以元组形式）
  len(d)	求长度（键值对个数）
  d.clear()	清除

• 字典表达的是一种映射关系

5.jieba库使用

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

• jieba库依靠中文词库确定字与字之间关联的概率从而分隔出一个个汉语词

• 除了分词，用户也可自定义词组

• jieba分词三个模式：精确模式（结合起来可以还原原来文本），全模式（可识别所有词），搜索引擎模式（在精确模式的基础上将长词切分成短词）

• jieba常用四个函数

  函数	描述
  jieba.lcut(s)	返回列表类型的分词结果
  jieba.lcut(s,cut_all=True)	全模式分词，存在冗余
  jieba.lcut_for_search(s)	搜索引擎模式
  jieba.add_word(w)	向分词词典增加新单词，如jieba.add_word(“蟒蛇语言”)

6.文本词频统计实例

看看代码吧，主要就是分词，英文根据空格，逗号等分词；中文可以用jieba库分词：

1. 哈姆雷特 词频统计

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

2. 三国演义 人物出场统计（实际上效果并不好）

   import jieba
   txt=open("threekindoms.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.item())
   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))
   

↑

第七章——文件和数据格式化

1.文件的使用

• 文件类型：文本文件和二进制文件

• 文件的打开和关闭

  1. 使用open()函数打开，使用close()函数关闭文件：

  f=open("fileName","openmode")
  #f是文件句柄
  #fileName可以用绝对路径或相对路径，和c++没差，一样有路径分隔符也是转义字符的问题
  #openmode可以是rt表示打开文本文件，rb表示打开二进制文件
  

  1. openmode的几种参数

  文件打开模式	描述
  ‘r’	只读文件，如果文件不存在，返回FileNotFoundError
  ‘w’	覆盖写模式，文件不存在则创建，存在则完全覆盖
  ‘x’	创建写模式，文件不存在则创建，存在返回FileExistError
  ‘a’	追加写模式，文件不存在则创建，存在则在文件最后追加内容
  ‘t’	文本文件模式，默认值
  ‘b’	二进制文件模式
  ‘+’	与r/w/x/a一同使用，在原功能基础上增加同时读写功能

  1. 示例

     f=open("f.txt")#文本，只读
     f=open("f.txt","rt")#文本，只读
     f=open("f.txt","w")#文本，覆盖写
     f=open("f.txt","a+")#文本，追加写，同时能够读
     f=open("f.txt","x")#文本，创建写模式
     #and so on...
     f.close()#关闭文件，如果没有这句，程序正常结束python解释器会自动关闭
     

• 文件内容的读取

  操作方法	描述
  f.read(size=-1)	读入全部内容，如果给出size，则读取前size长度
  f.readline(size=-1)	读入一行，如果给出size，则读入该行前size长度
  f.readlines(hint=-1)	读入所有行，返回一个行组成的列表，给出参数则读取前hint行

  可以直接用for line in f这样的语句遍历读取文件（f为打开的文件）

• 数据的文件写入

  方法	描述	示例
  f.write(s)	写入字符串或字节流	f.write(“China is a great nation”)
  f.writelines(ls)	写入字符串列表	f.writelines(“China",“Britain”,“Brazil”)
  f.seek(offset)	改变当前文件指针位置	f.seek(0)#回到开头,1-当前；2-结尾

  注意： 如果使用读写模式写入数据，之后读取文件内容会发现读取不到，因为写完文件后文件指针在文件结尾，需要使用seek()函数回到文件头才能读取到文件

2.自动轨迹绘制实例

加载轨迹数据绘制，实现自动化，挺简单的上代码吧：

#数据格式为一行六个数，第一个是行进距离，第二个是左右转向（0左1右），第三个是转向角度
#第四五六个是rgb值
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是一个列表的列表
    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.right(datals[i][2])
    else:
        t.left(datals[i][2])

map函数是python内置函数，它的作用是将第一个参数的功能作用于第二个参数的每一个元素，类似于c++算法里面的for_each函数

• 自动化思维：数据与功能分离
• 接口化设计：格式化设计接口
• 二维数据应用：应用维度组织数据

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

• 一维数据表示

  有序可用列表表示

  无序可用集合表示

• 一维数据存储

  用空格、逗号或者特殊字符分隔

• 一维数据的处理

  存储数据到列表：读入，按分隔符分隔ls=txt.split()

  列表到存储数据：添加分隔符，txt.write(" ".join(ls))，写入

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

• 二维数据的表示

  用列表的列表即二维列表来表示

• CSV数据存储格式

  CSV：Comma-separated values

  • 国际通用，后缀为.csv
  • 以逗号分隔，每行一个一维数据无空行
  • 一般编辑软件均可产生，如Excel
  • 如果每个元素缺失，分隔的逗号仍要保留
  • 逗号为英文半角逗号，逗号与数据间无额外空格
  • 表头可作为数据存储也可另行存储
  • 数据中有逗号的情况，不同软件有不同解决方法，有的可能规定数据中的逗号要加转义符等

• 二维数据的存储

• 二维数据的处理

  #读入文件
  fo=open(fileName)
  ls=[]
  for line in fo:
      line.replace("\n","")
      ls.append(line.split(","))
  fo.close()
  #写入文件    
  ls=[[],[],[]]#一个二维列表
  f=open(fname,'w')
  for item in ls:
      f.write(','.join(item)+'\n')
  f.close()
  #遍历操作二维数据
  for row in ls:
      for col in row:
  		print(ls[row][col])#或其他操作
  

  以上处理未考虑数据中有逗号的情况

5.wordcloud库的使用

• 安装库

  pip install wordcloud
  

• 使用

  import wordcloud
  w=wordcloud.WordCloud()#生成词云对象，这是一个生成实例的工厂方法
  #然后可以设置w的属性，包括词云的形状、尺寸和颜色等
  

  常规方法：

  方法	描述
  w.generate(txt)	将文本txt加载到词云对象w
  w.to_file(filename)	将词云输出到文件，支持.png和.jpg

• WordCloud对象做了啥

  • 分隔单词
  • 统计词频
  • 根据词频给不同单词配置字号
  • 布局：颜色环境等

• WordCloud配置参数

  参数	作用
  width	生成图片的像素宽度，生成WordCloud对象时给定（可缺省）
  height	生成图片的像素高度，生成WordCloud对象时给定（可缺省）
  min_font_size	z最小字号，默认4
  max_font_size	最大字号
  font_step	字号递增量，默认为1
  font_path	指定字体文件路径，默认为None（字体文件为后缀.ttc）
  max_words	最大显示词数
  stopwords	给定排除的词，一般给定一个集合类型

  自定义词云形状背景色：

  from scipy.misc import imread
  mk=imread("pic.png")
  w=wordcloud.WordCloud(mask=mk)#这里给定了一张图片为词云形状，所以不必设图片大小
  w=wordcloud.WordCloud(background_color='white')#设定背景色，默认为黑色
  

  中文的词云只需要进行相应的中文分词法，可以使用前面的jieba库

6.政府工作报告词云

看代码的时候又到了：

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.TTF",\
                      width=1000,height=700,\
                      background_color="white")
w.generate(txt)
w.to_file("grwordcloud.png")

可能会出现的问题（参考CSDN博客）：

1. ModuleNotFoundError: No module named ‘matplotlib’。用pip install命令安装matplotlib模块就好
2. ImageFont.py的cannot open resource问题。原因是找不到字体，要么把上面对字体的设置去掉使用默认字体（可能会生成乱码词云），要么下载上面设置的字体文件（微软雅黑百度云下载）放在同一目录下，或者设置成别的字体，并下载相应字体文件放在同一目录下

↑

第八章——程序设计方法学

1.体育竞技问题实例

1. 自顶向下——将大问题分解成小问题直到小问题可执行

2. 自底向上——逐步组建复杂系统的有效测试方法

   • 分单元测试，逐步组装
   • 按照自顶向下相反的顺序操作
   • 直到各部分以组装的思路都得到测试和验证

3. 问题拆解、分析略，上代码：

   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 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:
                   score+=1
               else:
                   serving="A"
       return scoreA,scoreB
   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 printSummary(winsA,winsB):
       n=winsA+winsB
       print("竞技分析开始，共模拟{}场比赛".format(n))
       print("选手A获胜{}场比赛，共占比{:1.1%}".format(winsA,winsA/n))
       print("选手B获胜{}场比赛，共占比{:1.1%}".format(winsB,winsB/n))
   def main():
       printIntro()
       probA,probB,n=getInputs()
       winsA,winsB=simNGames(n,probA,probB)
       printSummary(winsA,winsB)
   

2.python程序设计思维

• 计算思维与程序设计

  • 逻辑思维：推理与演绎，以数学为代表
  • 实证思维：实验与验证，以物理学为代表
  • 计算思维：设计与构造，以计算机为代表

• 计算生态与Python语言

  1. 没有顶层设计、以功能为单位、具备三个特点：
     • 竞争发展
     • 相互依存
     • 迅速更迭
  2. python中有多达13万个第三方库，同一功能可能有多个库，经过竞争淘汰，剩下优秀的库
  3. 数据处理库——numpy，底层为c++，性能相当高，适合大数据处理，是matplotlib，pandas等库的基础
  4. API！=生态，API是由某个人、某个组织编写，是没有竞争淘汰机制的

• 用户体验与软件产品

  进度显示、异常处理、打印输出、日志信息、帮助信息等

• 基本的程序设计模式

  IPO，自顶向下与自底向上，模块化设计，配置化设计（引擎+配置）

  • 产品定义——不仅是功能定义，考虑商业模式
  • 系统架构——关注数据流、模块、体系架构
  • 设计与实现——可扩展、灵活性等
  • 用户体验——以用户为中心，是否用户友好

3.python第三方库安装

• 看见更大的Python世界

  • python社区：PyPI——Python Package Index
  • PSF维护和展示全球计算生态的主站

• 第三方库的pip安装方法（官方唯一方法）

  pip install+库名安装第三方库，如前所述，另外有一个pip install -U 库名更新相应的库的用法，其他详细用法通过pip -h查看。

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

  Anaconda集成开发环境，自带近800个第三方库，适合数据计算领域开发

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

  pip安装某些库的时候可能会下载成功安装失败，这是因为有些库提供的是源代码而不是可执行程序，所以需要根据不同的环境编译，如果没有相应的编译器就不能安装成功。可以在该网站找到对应系统编译好的可执行文件。

  好像打不开该网站

4.os库的使用

• os库是标准库提供了通用，基本的操作系统交互功能，如路径操作、进程管理、环境参数设置等

  • 路径操作，使用os.path子库，处理文件路径及信息
  • 进程管理
  • 环境参数

• 示例

  #os.path路径操作
  os.path.abspath(path)#返回path路径在当前系统中绝对路径
  os.path.normpath(path)#将路径字符串归一化处理，统一用\\表示分隔路径
  os.path.relpath(path)#转为相对路径
  os.path.dirname(path)#获取path中的目录名称
  os.path.basename(path)#获取path中的最后文件名称
  os.path.join(path,*paths)#组合path与paths，返回一个路径字符串
  os.path.exist(path)#判断路径path是否存在
  os.path.isfile(path)#判断是否是已存在文件
  os.path.isdir(path)#判断是否是已存在目录
  #可用time.ctime函数转换成可读的时间，以下时间分别为access,modifiy,create
  os.path.getatime(path)#返回path对应文件或目录上一次的访问时间
  os.path.getmtime(path)#返回path对应文件或目录上一次修改时间
  os.path.getctime(path)#创建时间
  os.path.getsize(path)#获取对应文件的大小
  #os.system进程管理
  os.system(cmd)#相当于在cmd窗口运行相应的程序，返回调用返回结果
  #获取或改变系统环境信息
  os.chdir(path)#改变当前程序操作的路径
  os.getcwd()#返回当前工作路径
  os.getlogin()#获取当前登录用户
  os.cpu_count()#获取当前cpu数量
  os.urandom(n)#产生n个字节长度的随机字符串
  

5.第三方库安装脚本

自动化安装第三方库，我们前面已经有了pip install安装命令来安装第三方库，又有os库调用系统cmd命令，这样可以在程序里通过os库使用pip命令自动化安装，目标安装库及代码如下：

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

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

↑

第九章——python计算生态概览

本章基本就是一个知识索引章节，基本没有知识点。

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

• 数据表示：采用合适方式用程序表达数据
• 数据清洗：数据归一化、数据转换、异常值处理
• 数据统计：数量、分布、中位数等
• 数据可视化
• 数据挖掘：从数据获取知识产生价值
• 人工智能：数据、语言、图像、视觉等方面深度分析与决策

1. 数据分析
   • numpy库通过python接口使用，c语言实现，计算速度优异
   • numpy是python科学计算的基础库，是pandasd等的基础
   • numpy提供直接地矩阵运算、广播函数、线性代数等功能
   • numpy是N维数组最基础库
   • pandas提供数据分析的高层次应用库
   • SciPy库是数学、科学和工程计算功能库，提供了一批数学算法及工程数据运算功能（类似MATLAB）
2. 数据可视化
   • matplotlib数据可视化：高质量的二维数据可视化功能库
   • matplotlib.pyplot子库相当于各个子库的快捷方式，可调用各可视化效果
   • seaborn库：统计类数据可视化功能库，基于matplotlib二次开发
   • mayavi：三维科学数据可视化功能库
3. 文本处理
   • 使用PyPDF2库：处理PDF文件，获取信息、分隔、整合文件、加密解密等
   • NLTK库：自然语言文本处理第三方库
   • Python-docx库：创建或更新Microsoft Word等文件的第三方库，通过程序操作Word文档
4. 及机器学习
   • sklearn库：机器学习方法工具集
   • TensorFlow：AlphaGo背后的机器学习计算框架
   • MXNet：基于神经网络的深度学习计算框架

2.霍兰德人格分析雷达图

主要用到matplotlib库

3.从web解析到网络空间

• python库之网络爬虫——requests库,scrapy库（优秀的网络爬虫框架），pyspider（强大的web页面爬取系统）
• web信息提取——解析HTML和XML，beautifulsoup库+正则表达式
• web网站开发——Django库：最流行的web应用框架，paramid库（规模适中），flask（轻量级网络框架）
• 网络应用开发

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

• 图形用户界面——pyqt5用户界面
• 游戏开发——panda3D：开源、跨平台的3D渲染和游戏开发库
• 虚拟现实——VR Zero：在树莓派上开发应用的Python库
• 图形艺术

5.玫瑰花绘制实例

↑

第N章——自己总结的想更就更的几点

1.python与c++的交互

• python调用c++的可执行程序

  • 代码示例如下，其实很简单：

    import os
    os.system("cmd")#可以直接执行命令调用exe
    os.system('xxx.exe')#比如也可以这样运行c++生成的exe文件
    

  • 同样的，c++调用python也可以像这样，先通过PyInstaller将python源代码打包成exe文件然后通过c++调用：

    #include "stdafx.h"
    #include <iostream>
    using namespace std;
    int _tmain(int argc, _TCHAR* argv[])
    {
    	system("simulateGames.exe");
    	system("pause");
    	return 0;
    }
    

    注意： c++里面的system就是使用cmd命令，但是如果上述程序不放在同一目录下，使用绝对目录调用exe的话，要注意绝对路径中不能有空格，因为cmd命令一遇到空格就认为这个命令结束了，后面是命令参数。

• python调用c++的库

  c++的dll库简直就是渣滓一样，还分什么c的dll，c++的dll，win的dll，MFC的dll，仿佛是换个库换套规则，既然人生苦短，咱们就别搞什么dll，反正以后再出个什么库说不定又出一套dll规则，不胜其烦。

[↑](#Python MOOC 笔记)

---

1. Body Mass Index ↩︎

2. 门特卡洛法求圆周率，即使用概率的方法求解圆周率：向方形中撒点，落在其内切圆中的概率乘以4即为圆周率pi ↩︎

3. 科赫曲线为分形几何中的一种曲线，参考科赫曲线。 ↩︎