Python语言

——取自崇天老师的视频(中国大学MOOC)，文章不适合新手，此文章只作为记忆记录方便查阅，记录的标准为方便自己再次学习和直接利用资源——

官方文档：http://docs.python.org/zh-cn/3/
建议作为某些疑惑内容深入理解和查阅，不建议初学阅读和学习教程。

pip 安装第三方库速度太慢
可设置 pip 从国内的镜像源下载安装:

• 阿里云 http://mirrors.aliyun.com/pypi/simple/
  中国科技大学 https://pypi.mirrors.ustc.edu.cn/simple/
  豆瓣 http://pypi.douban.com/simple/
  清华大学 https://pypi.tuna.tsinghua.edu.cn/simple/
  中国科学技术大学 http://pypi.mirrors.ustc.edu.cn/simple/

设置方法，以清华镜像源为例：

• 临时使用
  pip install -i https://pypi.tuna.tsinghua.edu.cn/simple xxxxxxx
• 永久设置
  pip config set global.index-url https://pypi.tuna.tsinghua.edu.cn/simple

Python语言诞生与1990年，创立者是Guido van Rossum，他为Python注入了一种开源、开放、可持续发展的一种精神，也是Python能持续发展的原因。Python是一种脚本语言，说到脚本，这里就不得不提到编译和解释，源代码：采用某种编程语言编写的计算机程序，人类可读，目标代码：计算机可直接执行。编译：是将源代码一次性转换为目标代码的过程，之后不再需要源码，解释：是将代码逐条转换为目标代码同时逐条运行的过程，每次程序运行都是随时翻译随及执行。而使用编译执行的语言叫做静态语言，如C/C++、Java。而使用解释执行的语言叫脚本语言，如Python、JS、PHP。

❤求解计算问题的精简步骤，也是通用的一种语言编写思路：
确定IPO：明确计算部分及功能边界，将程序分成输入、输出和计算三大部分。
编写程序：价格计算求解的设计变成现实
调试程序：确保程序按照正确逻辑能够正确运行

Python连接：
Python官网：https://www.python.org/downloads/
Pyhon123平台：https://python123.io/student/download

Python的两种编程方式：
交互式：对每隔输入语句即时运行结果，适合语法练习
文件式：批量执行一组语句并运行结果，编程的主要方式

入门篇

实例：温度转换

两种温度体系摄氏度和华氏度相互转换

#温度转换
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 = eval(TempStr[0:-1])*1.8 + 32
    print("{:.2f}F".format(F))
else: print("输入格式错误")

#：为注释
‘’’ （这里） ‘’’：为多行注释，这其实是套用的字符串语法
缩进：程序严格采用缩进分隔段落，也是唯一。
命名规则：大小写字母、数字、下划线和中文组合，（大小写敏感，首字母不能是数字，不能是保留字）
保留字：

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

列表：使用[]表示，采用’,’分割元素，如[‘F’，’f’]表示两个元素。使用in判断前者是否在列表中。
赋值语句：= ，如c = 9.
分支语句：if、elif、else
函数：类似于数学中的y=f(x),采用<函数名>([参数])方式使用
输入函数：TempStr = input()，用户输入信息以字符串类型保存在变量TempStr中
输出函数：print(“转换后温度为：{:.2f}C”.format(C))
评估函数eval()：去掉参数最外侧引号并执行余下语句的函数，如，eval(‘print(“Hello”)’)

#货币转换
RR = input()
if RR[:3] == "RMB":
    print("USD{:.2f}".format(eval(RR[3:]) / 6.78))
elif RR[:3] == "USD":
    print("RMB{:.2f}".format(eval(RR[3:])*6.78))

计算机计数的演进过程：

• 1946-1981：计算机系统结构时代（35年）
• 1981-2008：网络和视窗时代（27年）2008年安卓诞生
• 2008-2016：复杂信息系统时代（8年）
• 2016 : 人工智能时代

不同编程语言的初心：
C：学习指针、内存、数据类型，本质是理解计算机系统结构，解决的是性能问题。
Java：学习对象、跨平台、运行，本质是理解主客体关系，解决的是跨平台问题。
C++：学习对象、多态、继承，本质是理解主客体关系，解决的是大规模程序问题。
VB：学习对象、按钮、文本框，本质是理解交互逻辑，解决的是桌面应用问题。
Python：学习编程逻辑、第三方库，本质理解问题求解，解决的是问题本身。

编程语言的大致分类：

• 机器语言：
  • 一种二进制语言，直接使用二进制代码表达指令
  • 计算机硬件可以直接执行，与具体CPU型号有关
• 汇编语言：
  • 一种将二进制代码直接对应注记符的编程语言
  • 汇编也与CPU型号有关
• 高级语言：
  • 更接近自然语言，同时更容易描述计算问题
  • 高级语言代码与具体CPU型号无关，编译后运行
• 超级语言
  • 具有庞大计算生态，可以很容易利用已有代码功能
  • 编程思维不再是刀工火种，而是集成开发

turtle库

import 保留字，引入了一个绘图库，名字叫turtle，没错就是海龟。

turtle绘图体系诞生与1969年，主要用于程序设计入门，是python标准库之一。
Python计算生态 = 标准库 + 第三方库：

• 标准库：随解释器直接安装的功能模块。
• 第三方库：需经过安装才能使用的功能模块。
• 库Library、包Package、模块Module，统称模块。

turtle的原理：有一只海龟，在窗体正中心，在画布上游走，走的轨迹形成了回值的图形。画布空间最小单位是像素。

turtle空间体系

了解之前你一定能够要知道，海龟只有在落在地面上(默认)才可以画出线条，还有海龟有专门的转向方法和前后走的方法，默认右为前。

turtle画布使用数学中的绝对坐标，海龟最开始的坐标为(0,0)。

1、turtle.setup()

turtle.setup(width, height, startx, starty)

• width和height两个参数调整画布的大小，startx和starty两个参数调整画布左上角距屏幕左上角的距离。

(0,0)坐标在画布的最中心位置。

2、turtle.goto()

turtle.goto(x, y)

• 此语句可以直接跳到相应的绝对坐标上。

turtle画布使用海龟自身的前后左右为方向，海龟的前方为前方，可以通过方向函数改变其行进轨迹

3、turtle.circle()

turtle.circle(r, angle)

• r：正值代表圆心在海龟的左侧的距离，负值代表圆心在海龟的右侧的距离。
• angle绘制的角度，默认360度

4、turtle.bk()、turtle.fd()

turtle.bk(d)   #向后
turtle.fd(d)   #向前  原名turtle.forward

• d为要走的距离，单位是像素

turtle画布在前后左右的基础上，使用数学中的角度坐标

5、turtle.seth()

turtle.seth(angle)  #原名turtle.setheading()

• angle为角度，-90就是向下

6、turtle.left()、turtle.right()

turtle.left(angle)    #意为向左
turtle.right(angle)   #意为向左

• angle为角度值，turtle.left(50)就是向左转动50度。

7、RGB色彩体系
RGB是红绿蓝三个通道的颜色组合，几乎覆盖视力所能感知的所有颜色

turtle.colormode(mode)

white：   255，255，255 or 1，   1，   1     白色
yellow：  255，255，0   or 1，   1，   0     黄色
magenta： 255，0，  255 or 1，   0，   1     洋红
cyan：    0，  255，255 or 0，   1，   1     青色
blue：    0，  0，  255 or 0，   0，   1     蓝色
black：   0，  0，  0   or 0，   0，   0     黑色
seashell：255，245，238 or 1，   0.96，0.93  海贝色
gold：    255，215，0   or 1，   0.84，0     金色
pink：    255，192，203 or 1，   0.75，0.80  粉红色
brown：   165，42， 42  or 0.65，0.16，0.16  棕色
purple：  160，32， 240 or 0.63，0.13，0.94  紫色
tomato：  255，99， 71  or 1，   0.39，0.28  番茄色

8、turtle.up()、turtle.down()

turtle.penup()     #画笔抬起   别名是turtle.pu()
turtle.pendown()   #画笔落下   别名是turtle.pd()

9、turtle.pensize()

turtle.pensize(width)     #线条宽度  别名是turtle.width(width)

• width为线条宽度，单位为像素

10、turtle.pencolor()

turtle.pencolor(color)

• color为线条颜色，可以是颜色字符串、RGB的小数、RGB的元组值
• turtle.pencolor(“purple”)
• turtle.pencolor(0.63，0.13，0.94)
• turtle.pencolor((0.63，0.13，0.94))

10、turtle.done()

turtle.done(color)     #窗体手动退出

import用法

一：import <库名>                       import turtle           
<库名>.<函数名>(<参数>)                  turtle.pensize(25)

二：from <库名> import [<函数名> or * ]  from turtle import *
<函数名>.(<函数参数>)                    pensize(25)

三：import <库名> as <自起名字>           import turtle as t  
<库别名>.<函数名>(<参数>)                 t.pensize(25)

注意：第二种方法容易和程序其它名字重名。

一些代码实例：

#六边形的绘制
import  turtle
turtle.pencolor("tomato")
turtle.pensize(12)
for i in range(6):
     turtle.left(60)
     turtle.fd(200)

#八角图形的绘制
import turtle as t
t.pensize(2)
for i in range(8):
    t.fd(150)
    t.left(135)

#折叠图形的绘制
import  turtle
turtle.pencolor("tomato")
turtle.pensize(12)
turtle.fd(200)
for i in range(8):
     turtle.left(80)
     turtle.fd(200)

#风轮绘制
import  turtle
turtle.pencolor("tomato")
turtle.pensize(12)
turtle.fd(150)
turtle.seth(-90)
turtle.circle(-150,45)
turtle.seth(135)
turtle.fd(300)
turtle.seth(-135)
turtle.circle(150,45)
turtle.seth(0)
turtle.fd(150)
turtle.seth(90)
turtle.fd(150)
turtle.seth(0)
turtle.circle(-150,45)
turtle.seth(-135)
turtle.fd(300)
turtle.seth(-45)
turtle.circle(150,45)
turtle.seth(90)
turtle.fd(150)

基本数据类型

整数

整数与数学中的整数的概念一致，可正可负，没有取值范围限制，pow(x,y)，计算x的y次方，想算多大算多大。
python中，整数有四种表示形式十进制0、二进制0b00、八进制0o00、十六进制0x00

浮点数

与数学中实数的概念一致，带有小数点及小数的数字，取值值范围约-10的307次方到10的308次方，精度数量级10的-16次方。

浮点数间的运算存在不确定尾数，大多数的语言都存在这个问题，比如0.1+0.2可能得到的是0.30000000000000004。这是因为将二进制数0.1转换成十进制数是不能完全相等的，只是无限接近的数值。
比如二进制0.1为:
0.00011001100110011001100110011001100110011001100110011010
而是转化为十进制0.1时为：
0.1000000000000000055511151231257827021181583404541015625

我们可以强制输出1位小数来解决，round( 0.1+0.2 , 1 ) = 0.3，不确定尾数一般发生在10-16次方左右，所以round()十分有效。

浮点数可以采用科学计数法表示，4.3e-3 = 0.0043、9.6E5 = 960000.0

复数

与数学中的复数概念一致。
z = 1.23e-4 + 6.5e+89j 中，1.23e-4 为实部，6.5e+89j为虚部。

数值运算操作符

x + y 求和
x - y 求差
x * y 求积
x / y 求商，带小数
x // y 整除，不留小数
-y 负的y
+y 就是y
x % y 求余数
x ** y 幂运算，当y为正为x的y次方，当y为负是x开y次方。
同时也支持像 x += y 这样的操作。

类型间可以进行混合运算，生成结果为“最宽”类型

数值运算函数

实例：天天向上的力量

问题1：每天进步千分之一，一年后会进步多少？

#每天进步千分之一
dayup = pow(1.001,365)
daydown = pow(0.999,365)
print("向上：{:.2f}，向下：{:.2f}".format(dayup,daydown))

• 结果是向上1.44倍和向下0.67倍

问题2：每天进步千分之5呢？

#每天进步千分之5
dayfactor = 0.005
dayup = pow(1 + dayfactor,365)
daydown = pow(1 - dayfactor,365)
print("向上：{:.2f}，向下：{:.2f}".format(dayup,daydown))

• 结果是向上6.17倍，向下0.16倍
• 换做1%，结果为向上37.78倍，和向下0.03倍

问题3：工作日进步1%，休息日退步1%

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

• 结果是4.63

问题4：休息日退步1%，那工作日要多努力才能达到每天1%呢?

#休息日退步1%，那工作日要多努力才能达到每天1%呢?
def dayup(df):
    dayup = 1
    for i in range(365):
        if i % 7 in [6,0]:
            dayup = dayup*(1 - 0.01)
        else:
            dayup = dayup*(1 + df)
    return dayup
dayfactor = 0.01
while dayup(dayfactor) < 37.78:
    dayfactor += 0.001
print("工作日的努力参数：{:.3f}".format(dayfactor))

• 结果是1.9%
• 另外如果每天进步1.9%，那一年就是962.89倍!

字符串操作

1、字符串的表示

• 由0个或多个字符组成的有序字符序列，由一对单引号或一对双引号表示。
• 如果想在字符串中带有单引号或双引号字符，那再最外侧再加一对单引号或双引号。
• 如果两个都相表示字符，那最外侧加三引号’’’。

由一对单引或一对双引号表示，如：”你好”、’F’。
字符串是字符的有序序列，可以对其中的字符进行索引，如”你”是”你好”的第0个字符。

2、切片索引操作

• 索引：返回字符串中单个字符 <字符串>[M]，如“你好”[0] == ‘你’’
• 切片：返回字符串中一段字符串 <字符串>[M : N]，如“你好今天”[1:2] == “好今”

切片进阶：

<字符串>[M: N: K]  #其中k为步长

“123456789”[1:8:2]的结果为”2468”
“123456789”[ : :-1]的结果为”987654321”
“123456789”[1，3]它也等同于”123456789”[1，-9]，结果为”23”

3、python同具有转移字符操作

\n 换行（光标移动到下行行首**）
\r 回车（光标移动到本行首） 
...

4、字符串操作符
x + y 连接两个字符串
n * x 或 x * n 幅值n次字符串x
x in s 如果x是s的子串，返回True,否则返回False。

#根据输入，获取星期
weekStr = "一二三四五六日"
weekId = eval(input("请输入星期数字(1-7):"))
print("星期" + weekStr[weekId-1])

5、字符串处理的函数、方法

Unicode编码

• 之前大多只有英文，国际上广泛使用Ascll码来表示所有英文字符，随着计算机应用到世界各地，世界上的一批学者统一了一种编码，几乎涵盖了所有字符的编码形式。
• 从0到1114111(0x10FFFF)空间，每个编码对应一个字符
• Pyhton3中字符串的每个字符都是Unicode编码字符，也使得Python的程序能供不限于地方语言和地域

>>>chr(10004)         #输出一个特殊字符
'✔'

>>>str(ord("♉"))     #查询一个字符的Unicode值
9801

字符串类型格式化format()方法

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

"{}:计算机{}的CPU占用率为{}%".format("2020","C",10)
#输出结果为    2020：计算机C的CPU占用率为10%
#槽{}和format中逗号分隔的参数顺序是一样的

{ }内部对字符串的格式化配置方法如下：

Time库

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

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

1、时间获取
time.time() 获取当前时间戳，一个浮点数，从1970年1约1日凌晨00点开始的到现在一直累加的一个时间数值，单位是s。
time.ctime() 获取当前时间，转换成易读的字符串形式输出。
time.gmtime() 获取当前时间，表示为计算机可以处理的时间格式。

2、时间格式化
将时间合理的展示出来
time.strftime(tpl , ts)

import time
t = time.gmtime()
time.strftime("%Y-%m-%d %H:%M:%S",t)
#输出为"2020-10-18 19:46:20"

其中控制符：
%Y：年份——0000-9999
%m：月份——01-12
%B：月份名称——January-December
%b：月份缩写——Jan - Dec
%d：日期——01-31
%A：星期——Monday-Sunday
%a：星期缩写——Mon-Sun
%H：小时——0-24
%I：小时——0-12
%p：上/下午——AM，PM
%M：分钟——00-59
%S：秒——00-59

time.strptime(tpl , ts)

import time
t = '2020-10-18 19:46:20'
time.strptime(t, "%Y-%m-%d %H:%M:%S")
#与time.strftime()方法反向操作

3、程序计时
time.perf_counter() 获取CPU级别的精确时间值，可通过两次调用算出精确的延时时间。单位是秒。
time.sleep(s)休眠时间，time.sleep(3.3)意为程序等待3.3s

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




#文本进度条 单行动态刷新
import time
for i in range(101):
    print("\r{:3}%".format(i), end="")
    time.sleep(0.1)



#文本进度条
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/sclae)*100
    dur = time.time_perf_counter() - start
    print("\r{:^3.0f}%[{}->{}]{:.2f}s",format(c,a,b,dur),end="")
print("\n"+"执行结束".center(scale//2,'-'))

不同文本进度条的设计函数：

一些代码实例：

#三次方格式化
n = eval(input())
n3 = pow(n,3)
print("{:-^20}".format(n3))

# 星号三角形
n = eval(input())
for i in range(1,n+1,2):
    print("{0:^{1}}".format('*'*i, n))

#凯撒密码
s = input()
t = ""
for c in s:
    if 'a' <= c <= 'z': 
        t += chr( ord('a') + ((ord(c)-ord('a')) + 3 )%26 )
    elif 'A' <= c <= 'Z':
        t += chr( ord('A') + ((ord(c)-ord('A')) + 3 )%26 )
    else:
        t += c
print(t)

#字符串分段组合
s = input()
ls = s.split("-")
print("{}+{}".format(ls[0], ls[-1]))

程序的控制结构

python语法其中有很多其实和C语言或与其它语言都很相似，也可以说这些语法是通用的逻辑不同的表达

分支

1、单分支

if <条件>:
    <语句块>

#例子
tem = eval(input())
if tem == 99:
    print("猜对了")

2、二分支结构

if <条件>:
    <语句一>
else:
    <语句二>

#例子
tem = eval(input())
if tem == 99:
    print("猜对了")
else:
    print("猜错了")

二分之紧凑式：

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

#例子
tem = eval(input())
print("猜{}了".format("对" if tem == 99 else "错"))

如果条件为真就输出左边，否则输出右边，缺点就是不能赋值使用。

3、多分支

if <条件>:
    <语句一>
elif:
    <语句二>
   ...
else:
    <语句N>

4、判断操作符：
<、<=、>、>=、==、!=，以及逻辑操作符and、or、not

#例子
guess = eval(input())
if guess < 99 or guess == 100:
    print("猜错了")
else:
    print("猜对了")

异常处理

try:
    <语句一>
excpt:
    <语句二>

#例子
try:
    num = eval(input("亲输入一个整数："))
    print(num**2)
excpt:                               #只要程序出错就会进入excpt
    print("输入的不是整数")

try:
    <语句一>
excpt <异常类型>:
    <语句二>

#例子
try:
    num = eval(input("亲输入一个整数："))
    print(num**2)
excpt NameError:      #只要程序触发NameError类型错误就会进入excpt
    print("输入的不是整数")

#异常处理高级使用
try:
    <语句1>
excpt:                   #异常进入
    <语句2>
else：                   #没进异常就进入
    <语句3>
finally：                #最后一定会执行finally
    <语句4>

身体质量指数BMI
Body Mass Index

• 国际上常用的衡量人体肥胖和健康程度的重要标准，主要用于统计分析
• 定义：BMI = 体重(kg) / 身高²(m²)

健康标准：

• 偏瘦 国际【 < 18.5 】 国内【 < 18.5 】
• 正常 国际【 18.5 ~ 25 】 国内【 18.5 ~ 24 】
• 偏胖 国际【 25 ~ 30 】 国内【 24 ~ 28 】
• 肥胖 国际【 >= 30 】 国内【 >= 28 】

#BMI健康指数
height,weight = eval(input("请输入身高（米）和体重（公斤）[逗号隔开]："))
bmi = weight / pow(height,2)
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))

遍历循环

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

for <循环变量> in <遍历结构>:      #循环变量可以是命名规则中的任意名字
    <语句>

• 由保留字for和in组成，完成遍历所有元素后结束
• 每此循环，所获得元素放入循环变量，并执行一次语句块

2、计数循环（N次）

for i in range(N):      #循环N次
    print(i) #or print("nihao:",i)

• 遍历由range()函数产生的数字序列，产生循环

#循环遍历高级用法
for i in range(M，N，K):      #循环N-M次，步长为K
    print(i)

#例子
>>>for i in range(1,6,2):
    print("Hello:",i)

Hello: 1
Hello: 3
Hello: 5

3、字符串遍历循环：

for c in s :       #s是个字符串遍历字符串中每个字符
    <语句块>

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

#例子
>>>for c in "Python":
    print(c,end=",")

P,y,t,h,o,n,

4、列表遍历循环：

for item in ls :  #ls是个列表，遍历其每个元素
    <语句块>

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

#例子
>>>for item in [123,"PY",456]:
    print(item,end=",")

123,PY,456

5、文件遍历循环

for line in fi :  #fi是个文件，遍历其每一行
    print(line)    #并输出每一行

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

for in 遍历循环其实就是遍历其数据结构的每个元素（只要结构包含多个元素），其中它也可以遍历元组、字典等数据类型

无限循环

while <条件> :     #直到条件不满足时结束
    <语句>

1、循环控制保留字：
break： 跳出并结束当前循环
continue： 结束本次循环，继续之后的循环
注意：它们都搭配for和while使用，如果循环有嵌套，break只能跳出一层循环。而continue是结束当此循环，但还在循环中，并没有跳出循环本身。

#例子
>>>for c in "PYTHON":
    if c == "T":
        continue
    print(c,end="")

PYHON

#例子
>>>for c in "PYTHON":
    if c == "T":
        break
    print(c,end="")

PY

#双层循环例子
>>>s = "PYTHON"
>>>while s != "":
    for c in s:
        print(c,end="")
    s = s[:-1]

PYTHONPYTHOPYTHPYTPYP

2、循环的高级用法：循环 + else

#循环的高级用法：循环 + else
for <变量> in <遍历结构>:
    <语句1>
else:              #正常结束循环后一定进入，就是没有被break跳出一定进入
    <语句2>

#或者是

while <条件> :
    <语句1>
else：             #正常结束循环后一定进入，就是没有被break跳出一定进入
    <语句2>

• 当循环没有倍break语句退出时，执行else语句块
• else语句块作为“正常”完成循环的奖励
• 这里else的用法与异常处理中else用法相似

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

PYTHON正常退出

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

PY

以上是python语法中的全部分支结构！如果你看过一边，那你已经掌握了所有关于分支循环的语法知识了！

random库

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

• 伪随机数：采用梅森旋转算法生成的伪随机序列中元素
• random库主要用于生成随机数
• 使用random库：import random
• 基本随机数函数：seed(),random()
• 扩展随机数函数：randint(),getrandbits(),uniform(),randrange(),choice(),shuffle()

计算机要产生随机数，需要一个随机数种子比如10,然后通过梅森旋转算法，产生一些列随机序列0.5714025946899135、0.4288890546751146、0.5780913011344704……并且，一个种子确定一个随机数序列。

♈、(a=None) 初始化给定的随机数种子，默认为第一次调用random时所对应的系统时间

#例子
>>>random.seed(10)   #产生种子10对应的序列
>0.57.......

建议使用给定的种子，因为种子一样随机数也一样，可以方便的复现之前程序运行的情况

♉、random( ) 生成一个0.0到1.0之间的随机小数

#例子
>>>random.random()
0.5714025946899135

♊、randint( a , b ) 生成一个a到b之间的整数

#例子
>>>random.randint(10,100)
64

♋、randrange(m,n[,k]) 生成一个[m,n)之间以k为步长的随机整数

#例子
>>>random.randrange(10,100,10)
80

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

#例子
>>>random.getrandbits(16)
37885

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

#例子
>>>random.uniform(10,100)
13.096321648808136

♎、choice( seq ) 从序列seq中随机选择一个元素

#例子
>>>random.choice([1,2,3,4,5,6,7,8,9])
8

♏、shuffle( seq )将序列seq中元素随机排列，返回打乱后的序列

#例子
>>>s = [1,2,3,4,5,6,7,8,9];random.shuffle(s);print(s)
[3,5,8,9,6,1,2,7,4]

计算圆周率

1、圆周率的近似计算公式

运用计算公式编写：

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

2、使用蒙特卡罗方法

蒙特卡罗方式是采用散点的方法，在正方形上进行随机散点，通过扇形内部点的数量和正方形上所有点的数量的比值，计算圆周率

运用蒙特卡罗方法编写：

#python
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)    #扇形内/正方型内 然后×4
print("圆周率值时：{}".format(pi))
print("运行时间是：{:.5f}s".format(perf_counter()-start))

3、理解方法思维：

• 数学思维：找到公式，利用公式求解
• 计算思维：抽象一种过程，用计算机自动化求解

一些代码实例：

#1-2+3-4...966‪‬‪‬‪‬‪‬‪‬‮‬‫‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬
s = 0
count = 1
while count <=966:
    if count%2 == 0:
        s -= count
    else:
        s += count
    count += 1
print(s)

#三位水仙花数
s = ""
for i in range(100, 1000):
    t = str(i)   #将整数变为字符串！！！！！！！
    if pow(eval(t[0]),3) + pow(eval(t[1]),3) + pow(eval(t[2]),3) == i :
        s += "{},".format(i)
print(s[:-1])

#四位玫瑰数
s = "";ls = []
for i in range(1000, 10000):
    t = str(i)   #将整数变为字符串！！！！！！！
    if pow(eval(t[0]),4) + pow(eval(t[1]),4) + pow(eval(t[2]),4) + pow(eval(t[3]),4) == i :
        ls.append(eval(t))
for i in ls:
    print(i)


#用户登录的三次机会
count = 0
while count < 3:
    name = input()
    password = input()
    if name == 'Kate'and password == '666666':
        print("登录成功！")
        break
    else:
        count += 1
        if count == 3:
            print("3次用户名或者密码均有误！退出程序。")


#找出100内所有素数
ls = [];
for i in range(100):
    if i < 2:
        continue;

    #难点：
    #1.range(2,2) 返回空值，直接跳过循环，未执行break,else语句会被执行
    #2.for.j循环执行完毕后，如果未找到满足i%j==0的数值，证明其是素数，break不会被执行，else会被执行；如果找到i%j==0的数值，证明其不是素数，break会被执行，else则不会被执行；
    for j in range(2, i):      
        if i%j == 0: 
            #print("{0}不是素数".format(i));
            break;
        else:
            #print("{0}是素数".format(i));
            ls.append(i);
#print(ls);

#求和
s = 0;
for k in ls:
    s += k;
print(s);
#运行结果
#[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]

函数

一、函数定义

• 函数是一段代码的表示
  • 函数是一段具有特定功能的、可重用的语句组
  • 函数是一种功能的抽象，一般函数表达特定功能，
  • 两个作用：①降低编程难度和②代码复用

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

    #计算n!
    def fact(n):
    s = 1
    for i in range(1,n+1):
      s *= i
    return s
    

• 类似像数学中的函数 y = f( x )

  • 函数定义时，所指定的参数是一种占位符
  • 函数定义后，如果不经过调用，不会被执行
  • 函数定义时，参数是输入、函数体时处理、结果是输出（IPO）。

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

  • 调用时要给出实际参数
  • 实际参数替换定义中的参数
  • 函数调用后得到返回值

二、参数

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

#例子
def fact():
    print("我也是函数")

1、函数定义时还可以为某些参数指定默认值，构成可选参数

• Python中要求在设定或定义函数的时候 ，所有的可选参数，必须放在非可选参数之后，非可选参数也就是必选参数，也就是说你调用这个函数的时候必须要有这个参数，必须要有你就放在前面，这是一种强制约定。

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

#计算n!//m       //为整除
def fact(n, m=1):     #如果调用时不给出m的值，m就为1
    s = 1
    for i in range(1,n+1):
        s *= i
    return s//m

2、可变参数传递

• 即不确定多少个

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

#计算n!
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,2,6,5)  #就是10！*2*6*5

3、参数传递的两种方式

• 如def一个函数fact( n , m = 1 )
  可以有fact( 10 , 5 ) ,这是按照位置传参
  也可以有fact( m = 5, n = 10 ),这是按照名称传参

三、函数的返回值

• 函数可以有返回0个或多个结果
  • return保留字用来传递返回值
  • 函数可以有返回值，可以刻没有，可以有return，也可以没有
  • return可以传递0个或多个返回值

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

>>>fact(10,5)
(725760, 10, 5)    #返回的是元组类型

局部变量和全局变量

①局部变量和全局变量是不同的变量

• 局部变量是函数内部的占位符，与全局变量可以重名但不同
• 函数运算结束后，局部变量被释放
• 可以使用global保留字在函数内部使用全局变量。

n,s=10,100     //此处为全局变量
def fact(n):
    s = 1          //此处未用global声明，所以s是局部变量
    for i in range(1,n+1):
        s*= i
        return s

>>>print(fact(n),s)
3628800, 100      #全局变量并未改动

n,s=10,100
def fact(n):
    global s          //声明s是全局变量
    for i in range(1,n+1):
        s*= i
        return s

>>>print(fact(n),s)
3628800, 3628800

② 局部变量为组合数据类型且未在函数内部创建，它等同于全局变量

ls = ["F","f"]      #通过使用[]真实创建了一个全局变量列表ls
def fact(a):
    ls.append(a)     #此处ls是列表类型，未创建则等同于全局变量
    return
func("C")

>>>print(ls)
['F','f','C']

ls = ["F","f"]      #通过使用[]真实创建了一个全局变量列表ls
def fact(a):
    ls = []          #此处真实创建列表类型
    ls.append(a)     #此处ls是列表类型，未创建则等同于全局变量
    return
func("C")

>>>print(ls)
['F','f']

• 在Pytho中，组合数据类型是由指针来体现的，所以函数中，没有真实创建组合数据类型，它使用的变量是使用的指针，而指针指向的是外部的全局变量

lambda函数

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

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

<函数名> = lambda <参数>: <表达式>    它等价于  def <函数名>(<参数>):
                                                <函数体>
                                                return <返回值>

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

谨慎使用lambda函数，它主要用作与一些特定函数方法的参数。
一般情况下，建议使用def定义的普通函数

七段数码管显示日期时间

#SevenDigitsDrawV2.py
import turtle, time
def drawGap(): #绘制数码管间隔
    turtle.penup()
    turtle.fd(5)
def drawLine(draw):   #绘制单段数码管
    drawGap()
    turtle.pendown() if draw else turtle.penup()
    turtle.fd(40)
    drawGap()
    turtle.right(90)
def drawDigit(d): #根据数字绘制七段数码管
    drawLine(True) if d in [2,3,4,5,6,8,9] else drawLine(False)
    drawLine(True) if d in [0,1,3,4,5,6,7,8,9] else drawLine(False)
    drawLine(True) if d in [0,2,3,5,6,8,9] else drawLine(False)
    drawLine(True) if d in [0,2,6,8] else drawLine(False)
    turtle.left(90)
    drawLine(True) if d in [0,4,5,6,8,9] else drawLine(False)
    drawLine(True) if d in [0,2,3,5,6,7,8,9] else drawLine(False)
    drawLine(True) if d in [0,1,2,3,4,7,8,9] else drawLine(False)
    turtle.left(180)
    turtle.penup()
    turtle.fd(20)
def drawDate(date):
    turtle.pencolor("red")
    for i in date:
        if i == '-':
            turtle.write('年',font=("Arial", 18, "normal"))
            turtle.pencolor("green")
            turtle.fd(40)
        elif i == '=':
            turtle.write('月',font=("Arial", 18, "normal"))
            turtle.pencolor("blue")
            turtle.fd(40)
        elif i == '+':
            turtle.write('日',font=("Arial", 18, "normal"))
        else:
            drawDigit(eval(i))
def main():
    turtle.setup(800, 350, 200, 200)
    turtle.penup()
    turtle.fd(-350)
    turtle.pensize(5)
#    drawDate('2018-10=10+')
    drawDate(time.strftime('%Y-%m=%d+',time.gmtime()))
    turtle.hideturtle()
    turtle.done()
main()

理解方法思维：

• 模块化思维：确定模块接口，封装功能
• 规则化思维：抽象过程为规则，计算机自动执行
• 化繁为简：将大功能拆分为小功能组合，分而治之

代码复用与函数递归

一、代码复用：

• 把代码当成资源进行抽象
  ①代码资源化：程序代码是一种用来表达计算的“资源”
  ②代码抽象化：使用函数等方法对代码赋予更高级别的定义
  ③代码复用：同一份代码在需要时可以被重复使用

• 函数和对象是代码复用的两种方式
  函数是将代码名在代码层面建立了初步抽象
  对象的属性和方法（即< a >.< b >< a >.< b >()）在函数之上再次组值进行抽象。

二、模块化设计

• 分而治之
  通过函数或对象封装将程序分为模块及模块间的表达
  具体包括：主程序、子程序和子程序间关系
  分而治之：是一种分成抽象、体系化的设计思想

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

三、递归

• 函数递归的定义：函数中调用函数自身的方式，
  • 类似于数学归纳法。是归纳法用编程思维的体现。
• 两个关键特征：
  • 链条：计算过程存在递归链条
  • 基例：存在一个或多个不需要再次递归的基例
• 函数+分支
  • 递归本身是一个函数，需要函数定义方式描述
  • 函数内部，采用分支语句对输入参数进行判断
  • 基例和链条，分别编写对应代码

#实现s[::-1]
def rvs(s):
    if s == "":
        return s
    else:
        return rvs(s[1:])+s(0)

例子解析

• 斐波那契数列,也称黄金分割数列，费式数列，神奇数列
  即0，0，1，2，3，5，8，13，21，34，55，89…….
  即每一项都等于前一项和前前一项之和，前一项和后一项之比越来越靠近0.618
  F(n) = F(n-1) + F(n-2)

def f(n):
    if n == 1 or n == 2:
        return 1
    else:
        return f(n-1)+f(n-2)

• 汉诺塔

count = 0
def hanoi(n, src, dst, mid):
    global count
    if n -- 1:
        print("{}:{}->{}".format(1,src,dst))
        count += 1
    else:
        hanoi(n-1, src, mid, dst)
        print("{}:{}->{}".format(n,src,dst))
        count += 1
        hanoi(n-1, mid, dst, src)


>>>hanoi(3, "A", "C", "B")
>>>print(count)
1:A->C
2:A->B
1:C->B
3:A->C
1:B->A
2:B->C
1:A->C
7

我们只知道递归过程只关心链条，我们只关心当圆盘数量为n的时候，它怎么拆解为当前与当前n-1之间的一个关系，至于n-1下面怎么去做，我们不需要去关心

如何理解递归？

• 看过《盗梦空间吗》？本质上就是递归
• 学过数学归纳法吗？本质上就是递归
• 听过这个故事吗？“从前有座山，山里有座庙，庙里有个老和尚在讲故事…”
• 假设有个捡金币游戏，每一条路都有两个分叉路口，每过一个分叉路口都能捡到1金币，假设在第10个路的尽头放着10枚金币，并且没有路可走了，你只能原路回来，请问你能捡到几枚金币？

科赫雪花

分型几何是一种迭代的几何图形，广泛存在与自然界中

代码实现：

#KochDrawV1.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(800,400)
    turtle.penup()
    turtle.goto(-300, -50)
    turtle.pendown()
    turtle.pensize(2)
    koch(600,3)     # 0阶科赫曲线长度，阶数
    turtle.hideturtle()
main()



#KochDrawV2.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()

• 还有康托尔集、谢尔宾斯基三角形、门格海绵…

PyInstaller库

PyInstaller第三方库的作用式可以将.py源代码转换成Windows、Linux、Mac OS X 下无需源代码的可执行文件.exe。

• PyInstaller库是第三方库
  官方网站：http://www.pyinstaller.org

使用pip工具安装，pip一般默认和python一起安装。因为式第三方库，所以需要在命令行使用。

• 安装：
  (cmd命令行) pip install pyinstaller

• 打包成exe：
  (cmd命令行) pyinstaller -F <文件名.py>

• 添加图标打包成exe：
  (cmd命令行) pyinstaller -i <图片名.ico> -F <文件名.py>

常用参数：
-h 查看帮助
--clean 清理打包过程中的临时文件
-D，--onedir 默认值，生成dist文件夹
-F，--onedir 在dist文件夹中只生成独立的打包文件
-i<图标文件名.ioc> 指定打包过程使用的图标(icon)文件

#1、以整数17为随机数种子，获取用户输入整数N为长度，产生3个长度为N位的密码，密码的每位是一个数字。每个密码单独一行输出。
import random
def genpwd(length):
    a = 10**(length-1)
    b = 10**length - 1
    return "{}".format(random.randint(a, b))
length = eval(input())
random.seed(17)
for i in range(3):
    print(genpwd(length))


#2、获得用户输入数字N，计算并输出从N开始的5个质数，单行输出，质数间用逗号,分割。‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬

注意：需要考虑用户输入的数字N可能是浮点数，应对输入取整数；最后一个输出后不用逗号。
def prime(m):
    count = 0
    ls = []
    num = m
    while count < 5:
        end = int(pow(num, 0.5)) + 1  # 缩小遍历的范围，提升速度
        for i in range(2, end):
            if num%i == 0:
                break
        else:
            count += 1
            ls.append(num)
        num += 1
    return ls
n = eval(input())
if n != int(n):  # 因为可能输入有浮点数
    n = int(n) + 1
else:  # 保证输入5.0时，输出为整数5。这里只根据题目中只输入正浮点或者正整数时做的处理
    n = int(n)
# 上面的if...else可以用一行代码搞定
# n = (int(n) + 1) if (n > int(n)) else int(n)
ls = prime(n)
length = len(ls)
for  i in range(length):
    if i < (length-1):
        print(ls[i], end=',')
    else:
        print(ls[i])

# 看了答案后优化的版本
def prime(m):
    if m < 2:
        return False
    else:
        end = int(pow(m, 0.5) + 1)
        for i in range(2, end):
            if m%i == 0:
                return False
        else:
            return True

n = eval(input())
if n != int(n):  # 因为可能输入有浮点数
    n = int(n) + 1
else:  # 保证输入5.0时，输出为整数5。这里只根据题目中只输入正浮点或者正整数时做的处理
    n = int(n)
count = 5
while count > 0:
    if prime(n):
        if count > 1:
            print(n, end=',')
        else:
            print(n)
        count -= 1
    n += 1

组合数据类型

3.14是一个数据，但程序中要处理的往往是一组数据。那如何让程序更好的组织一组数据？
Python中有三大类组合数据类型：

• 集合类型
• 序列类型
  • 元组类型
  • 列表类型
• 字典类型

一、集合类型及操作

1、集合类型的定义

• 集合是多个元素的无序组合
  • 集合类型与数学中的集合概念一致，集合元素之间无序，每一个元素唯一，不存在相同元素。
  • 集合元素不可更改!，不能是可变数据类型。
• 集合是多个元素的无序组合
  • 集合用大括号{}表示，元素间用逗号分隔。
  • 建集合类型用{}或set(),建立空集合类型时必须使用set()

#使用{}建立集合，其中包含字符串、元组、整数等众多类型数据
>>> A = {"python",123,("python",123)}   
{"python",123,("python",123)}

>>> B = set("py123")     #使用set()建立集合
{'p','y','1','2','3'}

>>>C = {"python",123,"python",123}   #集合元素不重复
{'python',123}

2、集合操作符

• S | T 并
• S & T 交
• S - T 差
• S ^ T 补
• 并且可以使用真假判断操作S <= T
• 可以使用增强操作符：|=、-=、&=、^=

#使用{}建立集合，其中包含字符串、元组、整数等众多类型数据
>>>A = {"p","y",123}
>>>B = set("pypy123")
>>>A-B      #A中有的但B没有的
{123}

>>>B-A
{'3','1','2'}

>>>A&B
{'p','y'}

>>>A|B
{'1','p','2','y','3',123}

>>>A^B
{'2',123,'3','1'}

3、集合处理方法

• 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数少1)若S为空产生KeyError异常
• S.copy() 返回集合S的一个副本
• S.len(S) 返回集合S的元素个数
• x in S 判断S中元素x，x在集合中返回True，否则返回False
• x not in S 判断S中元素x，x不在集合中返回True，否则返回False
• set(x) 将其他类型变量x转变为集合类型

#其中的pop方法，可以配合try，except使用
>>>try:
    while True:
        print(A.pop(),end="")
    except:
        pass
p123y

>>>A
set()       #A变成了一个空集合

>>>A={"p","y",132}
>>>for item in A:
    print(item,end="")
p123y

>>>A
{"p",132,"y"}     #集合定义后顺序不定相同


#包含关系
>>>"p" in {"p","y",123}
True
>>> {"p","y"} >= {"p","y",123}
False

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

二、序列类型及操作

1、序列类型定义

序列是具有先后关系的一组元素

• 序列是一维元素向量，元素类型可以不同
• 类似数学元素序列：s0,s1,……sn-1
• 元素间由序号引导，通过下标访问序列的特定元素

序列是基类类型

• 它衍生出：①字符串类型、②元组类型、③列表类型
• 字符串继承了它的元素下标定义，及①反向递减序号和②正向递增序号。

2、序列处理函数及方法

• S + T 连接两个序列S和T
• S * n 或 n * S 将序列复制n次
• S[i] 索引，返回S中的第i个元素
• S[i:j]或S[i:j:k] 切片，返回序列S中第i到第j以k为步长的元素子序列
• x in S 判断S中元素x，x在集合中返回True，否则返回False
• x not in S 判断S中元素x，x不在集合中返回True，否则返回False
• len(S) 返回序列S的元素个数
• min(S) 返回序列S中最小元素，S中元素需要可以比较
• max(S) 返回序列S中最大元素，S中元素需要可以比较
• S.index(x)或S.index(x,i,j) 返回序列S从i开始到j位置中第一次出现元素x的位置
• S.count(x) 返回序列S中出现x的总次数

>>>ls = ["python",123,".io"]
>>>len(ls)       #查看序列S的元素个数
3

>>>s = "python123.io"
>>>max(s)        #查看序列S中最大元素
'y'

元组类型及操作方法

1、元组类型的定义

元组是序列类型的一张扩展：

• 元组是一种序列类型，一旦创建就不能被修改。
• 使用小括号()或tuple()创建，元素间用逗号，分隔
• 可以使用或不使用小括号

def func():
    return 1,2     #1，2本身就是一个元组类型

元组类型就是将元素有序的排列，它的元素的每个值是不能改变的

元组继承序列类型的全部通用操作：

• 元组因为创建后不能修改，因此没有特殊操作

>>>TTT = "cat","dog","tiger","human"
>>>TTT[::-1]         #倒序输出
('human','tiger','dog','cat')

>>>color = (0x001100,"python123.io",TTT)
>>>color[-1][2]      #索引
'tiger'
>>>color
(0x001100,"python123.io", ('cat','dog','tiger','human')

列表类型及操作

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

• 列表是一种序列类型，创建后可以随意被修改
• 使用方括号[]或list()创建，元素间用逗号，分隔
• 列表中各元素类型可以不同，无长度限制

>>>ls = ["cat","dog","tiger",1024]
>>>ls
['cat','dog','tiger',1024]
>>>lt = ls
>>>lt         #并没有创建两个列表，只是lt和ls同时指向了同一列表
['cat','dog','tiger',1024]

注：方括号[]真正创建一个列表，赋值仅传递引用

1、列表类型操作函数和方法

• ls[i] = x 替换列表ls第i元素为x
• ls[i:j:k] = lt 用列表lt替换ls切片后对应元素子列表
• del ls[i] 删除列表ls中第i元素
• del ls[i:j:k] 删除列表ls中第i到第j以k为步长的元素
• ls += lt 更新列表ls，将列表lt元素增加到列表ls中
• ls *= n 更新列表ls，将其元素重复n次
• ls.append(x) 在列表ls最后增加一个元素x
• ls.clear() 删除列表ls中所有元素
• ls.insert(i,x) 在列表ls的第i位置增加元素x
• ls.pop(i) 将列表ls中第i位置元素取出并删除该元素
• ls.remove(x)将列表ls中出现的第一个元素删除
• ls.reverse()将列表ls中的元素反转

>>>ls = ["cat","dog","tiger",1024]
>>>ls[1:2] = [1,2,3,4]      #向[1到2）元素间替换元素为1，2，3，4
['cat',1,2,3,4,'tiger',1024]
>>>del ls[::3]      #删除以3为步长的元素
[1,2,4,'tiger']

>>>ls = ["cat","dog","tiger",1024]
>>>ls.append(1234)
['cat','dog','tiger',1024,1234]
>>>ls.insert(3,"human")
['cat','dog','tiger','human',1024,1234]
>>>ls.reverse()
[1234,1024,'human','tiger','dog',cat]


lt = []                   #定义一个空列表
lt += [1,2,3,4,5]         #向lt新增5个元素
lt[2] = 6                 #修改lt中第二个元素
lt.insert(2,7)            #向lt中第二个位置增加一个元素
del lt[1]                 #从lt中第一个位置删除一个元素
del lt[1:4]               #删除lt中第1-3位置元素
0 in lt           #判断lt中是否包含数字0
lt.append(0)      #向lt新增数字0
lt.index(0)       #返回数字0所在lt中的索引
len(lt)           #lt的长度
max(lt)           #lt中最大元素
lt.clear()        #清空lt

序列类型应用场景

• 元组用于元素不改变的应用场景，更多用于固定搭配场景
• 列表更加灵活，它是最常用的序列类型
• 最主要作用：表示一组有序数据，进而操作它们

1、元素遍历

for item in ls:
    <语句块>

由于元组类型数据具有不可改变元素的特点，它可以对数据进行保护。

2、数据保护

• 如果不希望数据被程序改变，转换成元组类型。

>>>ls = ["cat","dog","tiger",1024]
>>>lt tuple(ls)
>>>lt
('cat','dog','tiger',1024)

如果在多人参与的项目中，需要保护数据，就让接口使用元组类型进行传递，也间接的保护了数据

基本统计值计算

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

能力扩展：

• 获取多个数据：从控制台获取多个不确定数据的方法
• 分隔多个函数：模块化设计方法
• 充分利用函数：充分利用Python提供的内容函数

字典类型及操作

字典类型定义

• 理解”映射“
  • 映射是一种键(索引)和值(数据)的对应
• 字典类型是“映射”的体现
  • 键值对：键是数据索引的扩展
  • 字典是键值对的集合，键值对之间无序
  • 采用大括号{}和dict()创建，键值对用冒号:表示，之间用逗号分隔
• 在字典变量中，通过键获得值
  • []用来向字典变量中索引或增加元素

#例
>>>d = {"中国":"beijing","美国":"华盛顿"}
>>>d["中国"]
'beijing'

>>>de = {};type(de)     #type(x) 返回变量x的类型
<classs 'dict'>

1、字典类型处理函数及方法

• del d[k] 删除字典中键值k对应的数据值
• k in d 判断键值k是否在字典d中，是返回True，否则返回False
• d.keys() 返回字典d中所有键的信息
• d.values() 返回字典d中所有的值的信息
• d.items() 返回字典d中所有键值对信息

>>>d = {"中国":"beijing","美国":"华盛顿"}
>>>"中国" in d
True

>>>d.keys()
dict_keys(['中国'，'美国']) #这些数据可以用for in 遍历，但不能当作列表操作

>>>d.values()
dict_values(['beijing'，'华盛顿'])

• d.get(k,<default>) 键k存在，则返回相应值，不在则返回< default >值
• d.pop(k,<default>) 键k存在，则取出相应值，不在则返回< default >值
• d.popitem 随机从字典d中取出一个键值对，以元组形式返沪
• d.clear() 删除所有的键值对
• len(d) 返回字典d中元素的个数

>>>d = {"中国":"beijing","美国":"华盛顿"}
>>>d.get("中国","意大利")   #如果中国在就返回对应的值，不在就返回 意大利
'北京'

>>>d.get("巴基斯坦","伊斯兰堡")   #巴基斯坦不在，所以返回伊斯兰堡
"伊斯兰堡"

>>>d.popitem()
('美国','华盛顿')

>>>d = {}        #定义一个空字典
>>>d["a"] = 1;d["b"] = 2     #向d新增2个键值对元素
>>>d["b"] = 3      #修改第2个元素
>>>"C" in d        #判断字符"C"是否是d的键
>>>len(d)         #计算d的长度
>>>d.clear()      #清空d

• 创建字典时，如果相同键对应不同值，字典采用最后（最新）一个”键值对”。

>>>d={'a': 1,'b': 2,'b': '3'}
>>>print(d['b'])
3

2、字典类型应用场景
映射的表达

• 映射无处不在，键值对无处不在

①元素的遍历

for k in d:
    <语句块>

注：

• 映射关系采用键值对表达
• 字典类型使用{}和dic()创建，键值对之间用:分隔
• d[key]方式既可以索引，也可以赋值
• 字典类型由一批操作方法和函数，最重要的是.get()

jieba库

• jieba是优秀的中文分词第三方库
  • 中文文本需要通过分词获得单个的词语
  • jieba是优秀的中文分词第三方库，需要额外安装

1、jieba库的安装
(cmd命令行)pip install jieba

2、jieba分词的原理

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

3、jieba分词的三种模式

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

4、jieba库常用函数

• jieba.lcut(s) 精确模式，返回一个列表类型的分词结果

>>>jieba.lcut("中国是一个伟大的国家")
['中国','是','一个','伟大','的','国家']

• jieba.lcut(s,cut_all=True) 全模式，返回一个列表类型的分词结果，存在沉余

>>>jieba.lcut("中国是一个伟大的国家",cut_all=True)
['中国','国是','一个','伟大','的','国家']

• jieba.lcut_for_search() 搜索引擎模式，返回一个列表类型的分词结果，存在沉余

>>>jieba.lcut_for_search("中华人民共和国是伟大的")
['中华','华人','人民','共和','共和国','中华人民共和国','是','伟大','的']

• jieba.add_word(w) 向分词词典增加新词

>>>jieba.add.word("蟒蛇语言")

5、文本词频统计

#哈姆雷特
#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  #如果单次出现过就+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))


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

#三国修正
#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))

#字典反转输出
s = input()
try:
    d = eval(s)
    e = {}
    for k in d:
        e[d[k]] = k
    print(e)
except:
    print("输入错误")

#沉默的羔羊最多单词
import jieba
f = open("沉默的羔羊.txt", encoding='utf-8')
ls = jieba.lcut(f.read())
#ls = f.read().split()
d = {}
for w in ls:
    d[w] = d.get(w, 0) + 1
maxc = 0
maxw = ""
for k in d:
    if d[k] > maxc and len(k) > 2:
        maxc = d[k]
        maxw = k
    if d[k] == maxc and len(k) > 2 and k > maxw:
        maxw = k
print(maxw)
f.close()

#一个数中，含有的不同数字之和
n = input()
ss = set(n)
s = 0
for i in ss:
    s += eval(i)
print(s)

#人名最多统计
s = '''双儿 洪七公 赵敏 赵敏 逍遥子 鳌拜 殷天正 金轮法王 乔峰 杨过 洪七公 郭靖 
       杨逍 鳌拜 殷天正 段誉 杨逍 慕容复 阿紫 慕容复 郭芙 乔峰 令狐冲 郭芙 
       金轮法王 小龙女 杨过 慕容复 梅超风 李莫愁 洪七公 张无忌 梅超风 杨逍 
       鳌拜 岳不群 黄药师 黄蓉 段誉 金轮法王 忽必烈 忽必烈 张三丰 乔峰 乔峰 
       阿紫 乔峰 金轮法王 袁冠南 张无忌 郭襄 黄蓉 李莫愁 赵敏 赵敏 郭芙 张三丰 
       乔峰 赵敏 梅超风 双儿 鳌拜 陈家洛 袁冠南 郭芙 郭芙 杨逍 赵敏 金轮法王 
       忽必烈 慕容复 张三丰 赵敏 杨逍 令狐冲 黄药师 袁冠南 杨逍 完颜洪烈 殷天正 
       李莫愁 阿紫 逍遥子 乔峰 逍遥子 完颜洪烈 郭芙 杨逍 张无忌 杨过 慕容复 
       逍遥子 虚竹 双儿 乔峰 郭芙 黄蓉 李莫愁 陈家洛 杨过 忽必烈 鳌拜 王语嫣 
       洪七公 韦小宝 阿朱 梅超风 段誉 岳灵珊 完颜洪烈 乔峰 段誉 杨过 杨过 慕容复 
       黄蓉 杨过 阿紫 杨逍 张三丰 张三丰 赵敏 张三丰 杨逍 黄蓉 金轮法王 郭襄 
       张三丰 令狐冲 赵敏 郭芙 韦小宝 黄药师 阿紫 韦小宝 金轮法王 杨逍 令狐冲 阿紫 
       洪七公 袁冠南 双儿 郭靖 鳌拜 谢逊 阿紫 郭襄 梅超风 张无忌 段誉 忽必烈 
       完颜洪烈 双儿 逍遥子 谢逊 完颜洪烈 殷天正 金轮法王 张三丰 双儿 郭襄 阿朱 
       郭襄 双儿 李莫愁 郭襄 忽必烈 金轮法王 张无忌 鳌拜 忽必烈 郭襄 令狐冲 
       谢逊 梅超风 殷天正 段誉 袁冠南 张三丰 王语嫣 阿紫 谢逊 杨过 郭靖 黄蓉 
       双儿 灭绝师太 段誉 张无忌 陈家洛 黄蓉 鳌拜 黄药师 逍遥子 忽必烈 赵敏 
       逍遥子 完颜洪烈 金轮法王 双儿 鳌拜 洪七公 郭芙 郭襄 赵敏'''
ls = s.split()
d = {}
for i in ls:
    d[i] = d.get(i, 0) + 1
max_name, max_cnt = "", 0
for k in d:
    if d[k] > max_cnt:
        max_name, max_cnt = k, d[k]
print(max_name)

文件和数据格式化

文件的使用

文件是数据的抽象和集合

• 文件是存储在辅助存储器上的数据序列
• 文件是数据存储的一种形式
• 文件展现形态：文本文件和二进制文件

文本文件 VS 二进制文件

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

文件是数据的抽象和集合

• 文本文件
  • 由单一特定编码组成的文件，如UTF-8编码
  • 由于存在编码，也被看成存储着的长字符串
  • 适用于例如：.txt、.py、…
• 二进制文件
  • 直接由比特0和1组成，没有统一字符编码
  • 一般存在于二进制0和1组织结构
  • 适用于：.png、.avi、…

"中国是个伟大的国家！"
二进制：中国是个伟大的国家！
二进制：b'\xd6\xd0\xb9\xfa\xca\...............'

f.txt文件保存："中国是个伟大的国家！"
#文本形式打开文件
tf = open("f.txt","rt")   #rt为文本，rb为二进制
print(tf.readline())
tf.close()
>>>
中国是个伟大的国家!

tf = open("f.txt","rb")   #rt为文本，rb为二进制
print(tf.readline())
tf.close()
>>>
b'\xd6\xd0\xb9\xfa\xca\....

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

• 读文件
  • a.read(size)
  • a.readline(size)
  • a.readlines(hint)
• 写文件
  • a.write(s)
  • a.writelines(lines)
  • a.seek(offset)

1、文件的打开

<变量名> = open(<文件名>，<打开模式>)
#文件句柄    文件路径和名称    文本or二进制

# windows的路径使用的是'\'，而在python是转移字符，需要用'/'代替，也可以用\\
例子：D:\PCC\f.txt
"D:/PCC/f.txt"  或者  "D:\\PCC\\f.txt"
这是绝对路径，而  相对路径  是文件和程序之间的路径：
"./PY/f.txt"

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

f = open("f.txt") #文本形式、只读模式、默认值 等同于f = open("f.txt"，"rt") 
f = open("f.txt","a")  #文本形式、追加写模式、不可读
f = open("f.txt","a+")  #文本形式、追加写模式、可读

2、文件的关闭

<文件名>.close()

3、文件内容的读取
<f>.read(size=-1) 读入全部内容，如果给出参数，读入前size长度
<f>.readline(size=-1) 读入一行内容，如果给出参数，读入该行前size长度
<f>.readlines(hint=-1) 读入文件所有行，以每行为元素形成列表，如果给出参数，读入前hint行

4、文件全文本操作
遍历全文本：方法一

#一次性读入
fname = input("请输入要打开的文件名称：")
fo = open(fname,"r")
txt = fo.read()
#对全文本txt进行处理
fo.close()

对于一个大文件，一次性读入全部会占用大量的内存！
遍历全文本：方法一

#分次读入
fname = input("请输入要打开的文件名称：")
fo = open(fname,"r")
txt = fo.read(2)   #读入两个字节
    while txt != "":
    #对全文本txt进行处理
    txt = fo.read(2)
fo.close()

逐行遍历文件：方法一

#一次读入分行处理
fname = input("请输入要打开的文件名称：")
fo = open(fname,"r")
for line in fo.readlines():   #所有信息以行生成一个列表
    print(line)
fo.close()

逐行遍历文件：方法二

#分行读入，逐行处理
fname = input("请输入要打开的文件名称：")
fo = open(fname,"r")
for line in fo:
    print(line)
fo.close()

5、数据的文件写入

<f>.write(s) 向文件写入一个字符串或字节流
<f>.writelines(s) 将一个元素为字符串的列表拼接写入文件
<f>.seek(offset) 改变当前文件操作指针的位置，offset含义如下：0-文件开头；1-当前位置；2-文件结尾

f.seek(0)   #回到文件开头

一定要关心写入文件的指针的位置变化！！！

fo = open("fs.txt","w+")
ls = ["中国","法国","美国"]
fo.writelines(ls)
fo.seek(0)   #缺少这句，下面就不会输出正确！！因为指针在文件的末尾
for line in fo:
    print(line)
fo.close()

自动轨迹绘制

• 不是写代码，而是写数据绘制
• 数据脚本是自动化最重要的第一步

基本思路

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

接口定义：

300,      0,           144,       1,0,0
300,      1,           144,       0,1,0
行进距离   转向判断0左    转向角度    RGB

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

理解方法思维：

• 自动化思维：数据和功能分离，数据驱动的自动运行
• 接口化设计：格式化设计接口，清晰明了
• 二维数据应用：应用纬度组值数据，二维数据最常用

一二纬数据的格式化

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

二维数据由多个一纬数据构成，是一纬数据的组合形式
多维数据是由一纬或er纬数据在新的纬度上的扩展形成
高纬数据仅利用最基本的二元关系展示数据间的复杂结构（字典）

数据的操作周期
存储 < - > 表示 < - > 操作

1、一纬数据的表示

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

一纬数据的存储
存储方式一：空格分隔

• 使用一个或多个空格分隔进行存储，不换行
• 缺点：数据中不能存在空格

存储方式二：逗号分隔

• 使用英文半角逗号分隔进行存储，不换行
• 缺点：数据中不能存在英文逗号

存储方式三：采用特殊符号

• 缺点：通用性差

数据的处理

• 将存储的数据读入程序
• 将程序表示的数据写入文件

#从空格分隔的文件中读入数据
txt = open(fname).read()
ls = txt.split()
f.close()

#从特殊分隔的文件中读入数据,假设%
txt = open(fname).read()
ls = txt.split("%")   
f.close()

#采用空格分隔方式将数据写入文件
ls = ['中国'，'美国'，'日本']
f = open(fname,'w')
f.write(' '.join(ls))
f.close()

2、二纬数据的表示
使用二维列表类型表达二维数据

• 基础操作使用时，二维列表几乎可以操作所有的二维数据

使用列表类型

• 使用两层for循环遍历每个元素
• 外层列表中每个元素可以对应一行，也可以对应一列

CSV数据存储格式
CSV：Comma-Separated Values

• 国际通用的一二纬数据存储格式，一般.CSV扩展名
• 每行一个一纬数据，采用逗号分隔，无空行
• Excel和一般编辑软件都可以读入或另存为CSV文件
• 如果某个元素缺失，逗号仍要保留
• 二维数据的表示可以作为数据存储，也可以另行存储

#从CSV格式的文件中读入数据
fo = open(fname)
ls = []
for line in fo:
    line = line.replace("\n","")
    ls.append(line.split(","))
fo.close()

#将数据写入CSV格式的文件中
ls = [[],[],[]]  #二维列表
f = open(fname，'w')
for item in ls:
    f.write(','.join(item) + '\n')
f.close()

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

wordcloud库

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

• 词云以词语为基础单位，更加直观和艺术的展示文本

安装：(cmd命令行) pip install wordcloud

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

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

方法：
w.generate(txt)向WordCloud对象w中加载文本txt
w.to_flie(fliename)将词云输出为图像文件，.png或.jpg格式

步骤：
1：配置对象参数、2：加载词云文本、3：输出词云文件

import wordcloud
c = wordcloud.WordCloud()
c.generate("wordcloud by Python")
c.to_flie("123.png")
#1、默认输出400*200像素
#2、需要给它一个以空格分隔单词的大字符串！！

配置对象参数：
w = wordcloud.WordCloud(<参数>)
width：宽度
height： 高度
min_font_size：最小字号
max_font_size：最大字号
font_step：步进间隔，默认1
font_path：指定字体文件路径

w = wordcloud.WordCloud(font_path = "msyh.ttc")

max_words：指定词云显示的最大单词数，默认200

w = wordcloud.WordCloud(max_words = 20)

stop_words：指定不显示的单词列表

w = wordcloud.WordCloud(stop_words={"Python"})

mask：指定词云形状，默认为长方形，需要引用imread()函数

>>>from scipy.misc import imread
>>>mk=imread("pic.png")
>>>w = wordcloud.WordCloud(mask=mk)

background_color：指定词云的背景颜色，默认黑色

>>>w = wordcloud.WordCloud(background_color="white")

#例
import jieba
import wordcloud
txt = "程序设计语言是计算机能够理解和\
设别用户操作意图的一种交互式体系，它按照\
特定。"
w = wordcloud.WordCloud(background_color="white",\
            font_path="msyh.ttc",height=700)
w.generate(" ".join(jieba.lcut(txt)))
w.to_flie("py.png")

词云实例：工作报告

用词云简化报告：

import jieba
import wordcloud
#f = open("新时代中国特色社会主义.txt","r",encoding="utf-8")
f = open("关于实施乡村振兴战略的意见.txt","r",encoding="utf-8")
t = f.read()
f.close()
ls = jieba.lcut(t)
txt = " ".join(ls)
w = wordcloud.WordCloud( font_path = "msyh.ttc",\
                         width = 1000, height = 700, background_color = "white",\
                         max_words = 30    #最大单词数
                         )
w.generate(txt)
w.to_file("grwordcloud1.png")

如果想要生成不同形状的词语，需要找一张那样形状的图片，然后引入一个新库，将图片变成一个变量，再将词云付给这个变量

import jieba
import wordcloud
from scipy.misc import imread
mask = imread("fivestart.png")   #图片文件
#f = open("新时代中国特色社会主义.txt","r",encoding="utf-8")
f = open("关于实施乡村振兴战略的意见.txt","r",encoding="utf-8")
t = f.read()
f.close()
ls = jieba.lcut(t)
txt = " ".join(ls)
w = wordcloud.WordCloud( font_path = "msyh.ttc",mask = mask\
                         width = 1000, height = 700, background_color = "white",\
                         max_words = 30    #最大单词数
                         )
w.generate(txt)
w.to_file("grwordcloud1.png")

实例1：打印输出附件文件的有效行数，注意：空行不计算为有效行数。

def getfile(s):
    lines = open(s, 'r')#注意不能加.read(),会拆分
    count = 0
    for line in lines:
        line = line.strip('\n')
        if len(line) > 0:
            count += 1
        else:
            count += 0
    return count


def main():
    s = "latex.log"     #这是加载的文件
    count = getfile(s)
    print("共{}行".format(count))
main()

#---------------------------------------------
t = open("latex.log","rt",encoding='utf-8')
s=0
for i in t:
    i=i.replace("\n","")
    if i=="":
        continue
    s+=1
print("共{}行".format(s))

实例2：统计附件文件的小写字母a-z的字符分布，即出现a-z字符的数量，并输出结果。

t = open("latex.log","rt",encoding='utf-8')
t=t.read()
s=0
t=list(t)
counts ={}
for i in t:
    if i<='z' and i>='a':
        counts[i]=counts.get(i,0)+1
    s+=1
print("共{}字符".format(s),end="")
#控制输出97是a的Unicode，122是z的Unicode。
for i in range(97,123):
    print(",{}:{}".format(chr(i),counts[chr(i)]),end="")

实例3：统计附件文件中与其他任何其他行都不同的行的数量，即独特行的数量。

#即与其它行重复的叫做独特行，多个重复只有一行为非独特行
f = open("latex.log")
ls = f.readlines()
s = set(ls)
for i in s:
    ls.remove(i)
t = set(ls)
print("共{}独特行".format(len(s)-len(t)))

实例4：附件是一个CSV文件，请将每行按照列逆序排列后输出，不改变各元素格式（如周围空格布局等）。

f=open("data.csv")
line=f.readlines()
for i in line:
    i=i.replace('\n','')
    a=i.split(",")
    a.reverse()     #<=
    print(",".join(a))

实例5：附件是一个CSV文件，其中每个数据前后存在空格，请对其进行清洗，要求如下：
（1）去掉每个数据前后空格，即数据之间仅用逗号(,)分割；
（2）清洗后打印输出。

f=open("data.csv")
line=f.readlines()
for i in line:
    i=i.replace('\n','')
    i=i.replace(" ",'')
    a=i.split(",")
    print(",".join(a))

实例6：打印输出附件文件的平均列数，计算方法如下：
（1）有效行指包含至少一个字符的行，不计算空行；
（2）每行的列数为其有效字符数；
（3）平均列数为有效行的列数平均值，采用四舍五入方式取整数进位。

f = open("latex.log")
s, c = 0, 0
for line in f:
    line = line.strip("\n") 
    #for line in f获取的line包含每行最后的换行符（\n），所以，去掉该换行符进行统计。
    if line == "":
        continue
    s += len(line)
    c += 1
print(round(s / c))

实例7：附件是一个CSV格式文件，提取数据进行如下格式转换：
（1）按行进行倒序排列；
（2）每行数据倒序排列；
（3）使用分号（;）代替逗号（,）分割数据，无空格；
按照上述要求转换后将数据输出。

f = open("data.csv")
ls = f.readlines()
ls = ls[::-1]
lt = []
for item in ls:
    item = item.strip("\n")
    item = item.replace(" ", "")
    lt = item.split(",")
    lt = lt[::-1]
    print(";".join(lt))
f.close()

程序设计方法学

体育竞技分析

问题分析：

• 需求：毫厘是多少呢？如何科学分析体育竞技比赛？
• 输入：球员的水平
• 输出：可预测的比赛成绩

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

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

解决复杂问题的有效方法：自顶向下

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

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

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

程序总体框架及步骤

• 步骤1：打印程序的介绍性信息式 -printInfo()
• 步骤2：获得程序运行参数：proA,proB,n -getInputs()
• 步骤3：利用球员A和B的能力值，模拟n局比赛 -simNGames()
• 步骤4：输出球员A和B获胜比赛的场次及概率 -printSummary()

第一阶段：程序总体框架及步骤

def main():     #主函数的框架
    printInntro()
    probA,probB, n = getInputs()
    winsA, winsB = simNGames(n,probA,probB)
    printSummary(winsA,winsB)

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

第二阶段：模拟N局比赛
需要调用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

第三阶段：模拟N局比赛

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"
                if serving == "A":
        else"
            if random() < probB:
                scoreB += 1
            else:
                serving = "A"
    return scoreA, scoreB

def gameOver(a,b):
    return a==15 or b==15

>>>
这个程序模拟了两个选手A和B的某种竞技比赛
程序运行需要A和B的能力值
请输入选手A的能力值(0-1):0.45
请输入选手B的能力值(0-1):0.50
模拟比赛场次:1000
竞技分析开始，共模拟1000场比赛
选手A获胜365场比赛，占比36.5%
选手B获胜635场比赛，占比63.5%

计算思维与程序设计

三种人类思维特征：

• 逻辑思维：推理和演绎，数学为代表，A->B B->C A->C
• 实证思维：实验和验证，物理为代表，引力波<-实验
• 计算思维：设计和构造，计算机为代表，汉诺塔递归

计算思维：抽象和自动化

• 计算思维：Computational Thinking
• 抽象问题的计算过程，利用计算机自动化求解
• 计算思维是基于计算机的思维方式

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

• 计算思维基于计算机强大的算力及海量数据
• 抽象计算过程，关注设计和构造，而非因果
• 以计算机程序设计实现的主要手段
• 编程是将计算思维变成现实的手段

计算生态与Python语言

1983年，Richard Stallman启动GNU项目，1989年，GNU通用许可协议诞生，自由软件时代诞生。
1991年，Linus Torvalds发布了Linus内核，1998年，网景浏览器开源，产生了Mozilla，开源生态逐步建立。开源思想深入演化和发展，形成了计算生态，计算生态没有顶层设计、以功能为单位、具备竞争发展、相互依存、迅速更迭三个特点。

• 以开源项目为代表的大量第三方库，多达15W。
• 库之间相互关联，逐级封装。
• 社区庞大，新技术更迭迅速，AlphaGo深度学习算法采用Python语言开源。

计算生态的运用：

• 编程的起点不是算法而是系统
• 编程如同搭积木，利用计算生态为主要模式
• 编程的目的是快速解决问题

用户体验与软件产品

实现功能、关注体验

• 用户体验指用户对产品建立的主观感受和认识
• 关心功能是实现，更要关心用户体验，才能做出好产品
• 编程只是手段，不是目的，程序最终为人类服务

提高用户体验的方法：

• 进度展示
  • 如果程序要计算时间，可能产生等待，请增加进度展示
  • 如果程序有若干步骤，需要提示用户，请增加进度展示
  • 如果程序可能存在大量次数的循环，请增加进度展示
• 异常处理
  • 当获得用户输入，对合规性需要检查，需要异常处理
  • 当读写文件时，对结果进行判断，需要异常处理
  • 当进行输入输出时，对运算结果进行判断
• 打印输出：特定位置，输出程序运行的过程信息
• 日志文件：对程序异常及用户使用进行定期记录
• 帮助信息：给用户多种方式提供帮助信息

用户体验时程序到产品的关键环节

基本的程序设计模式

从IPO开始

• 确定IPO：明确计算部分及功能边界
• 编写程序：将计算求解的设计变成现实
• 调试程序：确保程序按照正确逻辑能够正确运行

自顶向下设计

模块化设计

• 通过函数对象封装将程序划分为模块及模块间的表达
• 具体包含：主程序、子程序和子程序间关系
• 分而治之：分层抽象、体系化的设计思想
• 模块内部紧耦合、模块之间松耦合

配置化设计：

• 引擎+配置：程序执行和配置分离，将可选参数配置化
• 将程序开发变成配置文件编写，扩展功能而不修改程序
• 关键在于接口设计，清晰明了、灵活可扩展

应用开发的四个步骤

• 产品定义：对应用需求充分了解和明确定义，产品定义，而不仅时功能定义，需要考虑商业模式
• 系统架构：以系统方式思考产品的技术实现，系统架构，关注数据流、模块化、体系架构
• 设计与实现：结合架构完成关键设计及系统实现，结合可扩展性、灵活性等进行设计优化
• 用户体验：从用户角度思考应用效果，用户至上，体验优先，以用户为中心

Python第三方库安装

Python社区：https://pypi.org/( 13万个第三方库 )
PyPI

• Python Package Index
• PSF维护的战术全球Python计算生态
• 学会检索并利用PyPI，找到合适的第三方库开发程序

实例：开发与区块链相关的程序

• 第一步：在pypi.org搜索blockchain
• 第二步：挑选合适开发目标的第三方库作为基础
• 第三步：完成自己需要的功能

安装第三方库

方法一：使用pip命令
方法二：集成安装方法
方法三：文件安装方法

更新pip
python -m pip install --user --upgrade pip

如果安装的时候出现Requirement already satisfied:
pip install 库名 --target=路径就需要跟上路径

pip安装方法
支持Windows、MacOS、Linus三大平台，适合99%以上情况，需要联网
在命令行中打出pip -h可以打印帮助信息
pip install <第三方库名>就可以安装指定的第三方库
pip install -U <第三方库名>就可以对指定的第三方库进行版本更新
pip uninstall <第三方库名>就可以卸载指定的第三方库
pip download <第三方库名>就可以下载指定的第三方库，但不安装
pip show <第三方库名>就可以列出指定的第三方库的详细信息
pip search <关键词>就可以在全部第三方库中搜索和关键词有关系的第三方库
pip list就可以列出当前系统已经安装的第三方库

集成安装方法
结合特定Python开发工具的批量安装
Anaconda：http://www.continuum.io

• 支持近800个第三方库
• 适合数据计算领域开发

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

• 某些第三方库pip下载后，需要编译在安装
• 如果操作系统没有编译环境，则能下载但不能安装
• 可以直接下载编译后的版本用于安装吗？

文件安装方法：http://www.lfd.uci.edu/~gohlke/pythonlibs/（仅适用于windows）

在UCI页面上搜索相关库，下载相应版本的文件，使用pip install <文件名>安装

OS库的使用

os库提供通用的、基本的操作系统交互功能，支持三大主流操作系统，os库是python标准库，包含几百个函数，常用路径操作、进程管理、环境参数等几类。
路径操作
os.path字库以path为入口，用于操作和处理文件路径
import os.path 或者 import os.path as op

进程管理
os.system(command)

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

示例：windows下的计算器

import os
os.system("C:\\Windows\\System32\\calc.exe")

>>>
0

示例：windows下的画图

import os
os.system("C:\\Windows\\System32\\mspaint.exe  \
            D:\\PYECourse\\grwordcloudpng" )

>>>
0

环境参数
获取改变系统环境信息
os.chdir(path) ：修改当前程序操作路径
os.getcwd() ：返回程序的当前路径
os.getlogin() ：获取当前系统登陆用户名称
os.cpu_count() ：获取当前系统的CPU数量
os.urandom(n) ：获取n个字节长度的随机字符串，通常用于加解密运算

第三方库自动安装脚本

Numpy：N维数据表示和运算
Matplotlib：二维数据可视化
PIL：图像处理
Scikit-Learn：机器学习和数据挖掘
Requests：HTTP协议访问及网络爬虫
jieba：中文分词
Beautiful Soup：HTML和MXL解释器
Wheel：Python第三方库文件打包工具
PyInstaller：打包Python源文件为可执行文件
Django：Python最流行的Web开发框架
Flask：轻量级Web开发框架
WeRoBot：微信机器人开发框架
SymPy：数学符号计算工具
Pandas：高效数据分析和计算工具
Networkx：复杂网络和图结构的建模和分析
PyQt5：基于Qt的专业级GUI开发框架
PyOpenGL：多平台OpenGL开发接口
PyPDF2：PDF文件内容提取及处理
docopt：Python命令行解析器
PyGame：简单小游戏开发框架

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

其它实例

#获得用户的任何可能输入，将其中的英文字符进行打印输出，程序不出现错误
s = input()
for c in s:
    # c = str(c)
    if 'z'>=c>='a' or 'Z'>=c>="A":
        print(c, end="")

#获得用户输入的一个数字，可能是浮点数或复数，如果是整数仅接收十进制形式，且只能是数字。对输入数字进行平方运算，输出结果。
s = input()
try:
    if complex(s) == complex(eval(s)):
        print(eval(s)**2)
except:
    print("输入有误")

Python计算生态

Python库之数据分析

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

• Python接口使用，C语言实现，计算速度优异
• Python数据分析及科学计算的基础库，支撑Pandas等
• 提供直接的矩阵运算、广播函数、线性代数等功能

Numpy的最基础单元就是一个数组，数组相当于一个变量，那么可以用数组变量直接的操作符进行运算，进而减少了for循环的使用，也使得整体的编程逻辑变得直接，正是有Numpy的这样的特点，我们可以将N维数组，看成简单的数值运算。（ http://www.numpy.org ）
进而数据分析我们用Pandas。

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

• 提供了加单易用的数据结构和数据分析工具
• 理解数据类型与索引的关系，操作索引即操作数据
• Python最主要的数据分析功能库，基于Numpy开发

Pandas提供了两个数据结构，一个叫series一个叫DataFrame，series是通过索引来与一维数据进行关联，Series = 索引 + 一位数据进而通过索引来操作数据。DataFrame是使用行列的二维索引，来操作二维数据的方法DataFrame = 行列索引 + 二维数据
（ http://pandas.pydata.org）

SciPy：数学、科学和工程计算功能库（ http://www.scipy.org）

• 提供了一批数学算法及工程数据运算功能
• 类似于Matlab，可用于入傅里叶变换、信号处理、优化算法、稀疏图像运算、稀疏图像压缩、图像处理、线性代数等
• Python最主要的科学计算功能库，基于Numpy开发

Matplotlib：高质量的二维数据可视化功能库（ http://matplotlib.org）

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

Seaborn：统计类数据可视化功能库（ http://seaborn.pydata.org）

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

Mayavi：三维科学数据可视化功能库（http://docs.enthought.com/mayavi/mayavi/）

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

Python库之文本处理

PyPDF2：用来处理dpf文件的工具集（http://mstamy2.github.io/PyPDF2）

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

#将两个文件整合
from PyPDF2 import PdfFileReader, PdfFileMerger
merger = PdfFileMerger()
input1 = open("document1.pdf","rb")
input2 = open("document2.pdf","rb")
merger.append(fileobj = input1, pages = (0,3))
merger.merge(position = 2, fileobj = input2, pages = (0,1))
output = open("document-output.pdf","wb")
merger.write(output)

NLTK：自然语言文本处理第三方库（http://www.nltk.org/）

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

#将文本形成树结构
from PyPDF2 import PdfFileReader, PdfFileMerger
t = treebank.parsed_sents('wsj_000.mrg')[0]
t.draw()

*Python-docx：创建或更新Microsoft Word文件的第三方库
（http://python-docx.readthedocs.io/en/latest/index.html）

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

#
from docx import Document
document = Document()
document.add_heading('Document Title', 0)
p = document.add_paragraph('A plain paragraph having some ')
document.add_page_break()
document.save('demo.docx')

Python库之机器学习

Scikit-learn：机器学习方法工具集（http://scikit-learn.org/）

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

TensorFlow：AlphaGo背后的机器学习计算框架（https://www.tensorflow.org/）

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

import tensorflow as tf
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init)
res = sess.run(result)
print('result:',res)

MXNet：基于神经网络的深度学习计算框架（https://mxnet.incubator.apache.org/）

• 提供可扩展的神经网络及深度学习计算功能
• 可用于自动驾驶、机器翻译、语音识别等众多领域
• Python最重要的深度学习计算框架

比如去识别一张图片，我们可以构造深度学习神经网络，来提高准确率，在MXNet下只需要几十行代码，就可能完成这样的功能。

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

通用雷达图绘制：matplotlib库
专业的多维数据表示：numpy库

#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
 #用numpy中的array方法去将多维数据组织起来
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()

Python库之网络爬虫

Requests：最友好的网络爬虫功能库（http://www.python-requests.org/）

• 提供了简单易用的类HTTP协议网络爬虫功能
• 支持连接池、SSL、Cookies、HTTP（S）代理等
• Python最主要的页面级网络爬虫功能库

import requests
r = requests.get('https://api.github.com/user',\
                    auth=('user','pass'))
r.status_code    #获得访问状态效果
r.headers['content-type']   
r.encoding
r.text    #获取其中的文本信息

Scrapy：优秀的网络爬虫框架（http://scapy.org）

• 提供了构建网络爬虫系统的框架功能，功能本成品
• 支持批量和定制网页爬取、提供数据处理流程等
• Python最主要且最专业的网络爬虫框架

pyspider：强大的Web页面爬取系统（http://docs.pyspider.org）

• 提供了完整的网页爬取系统构建功能
• 支持数据库后端、消息队列、优先级、分布式框架等
• Python重要的网络爬虫类第三方库

Python库之Web信息提取

Beautiful Soup：HTML和XML的解析库（https://www.crummy.com/software/BeautifulSoup/bs4）

• 提供了解析HTML和XML等Web信息的功能
• 又名beautifulsoup4或bs4，可以加载多种系欸引擎
• 常与网络爬虫搭配使用，入Scrapy、requests等

它将所有的HTML页面，以树形结构进行组织，通过上下行遍历和平行遍历等操作，来去解析其中的所有内容。

Re：正则表达式解析和处理功能库（https://docs.python.org/3.6/library/re.html）

• 提供了定义和解析正则表达式的一批通用功能
• 可以用于各类场景，包括定点的Web信息提取
• Python最主要的标准库之一，无序安装

Python-Goose（https://github.com/grangier/python-goose）

• 提供了对Web页面中文章信息、视频等元数据的提取功能
• 针对特定类型Web页面，应用覆盖面较广
• Python对主要的Web信息提取库

#只需要我们给出一个URL链接，就可以使用内部的解析方式
from goose import Goose
url = 'http://www.elmundo.es.elmundo/2012/10/28/espana/1351388909.html'
g = Goose({'use_meta_language': False,'target_language': 'es'})
article = g.extract(url=url)
article.cleaned_text[:150]

Python库之Web网站开发

Django：最流行的Web应用框架（https://www.djangoproject.com）

• 提供了构建Web系统的基础框架
• MTV模式：模型（model）、模板（Template）、视图（Views）
• Python最重要的Web应用框架，略微复杂的应用框架

略微专业也难的框架，使用时我们需要知道什么是WSGI、什么是路由、什么是功能处理逻辑

Pyramid：规模适中的Web应用框架（https://trypyramid.com/）

• 提供了简单方便构建Web系统的应用框架
• 不大不小，规模适中适合快速构建适度扩展类应用
• Python产品级Web应用框架，起步简单可扩展性好

#10行左右Hello Word程序
from wsgiref.simple_server import make_server
from pyramid.config import Configurator
from pyramid.response import Response
def hello_world(request):
    return Response('Hello World!')
if __name__=='__main__':
    with Configurator() as config:
        config.add_route('hello','/')
        config.add_view(hello_world, route_name='hello')
        app = config.make_wsgi_app()
    server = make_server('0.0.0.0', 6543, app)
    server.serve_forever()

Flask：Web应用开发微框架（http://flask.pocoo.org）

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

如果我们的需求仅仅是建立几个页面，那这个是首选

#5行左右Hello Word程序
from flask import Flask
app = Flask(__name__)
@app.route('/')
def hello_world():
    return 'Hello,World!'

Python库之网络应用开发

WeRoBot：微信公众号开发框架（https://github.com/offu/WeRoBot）

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

#对微信每个消息反馈一个Hello World
import werobot
robot = werobot.WeRoBot(token='tokenhere')
@robot.handler
def hello(message):
    return 'Hello World!'

aip：百度AI开放平台接口（https://github.com/Baidu-AIP/python-sdk）

• 提供了访问百度AI服务的Python功能接口
• 语音、人脸、OCR、NLP、只是图谱、图像搜索等领域
• Python百度AI应用的最主要方式

MyQR：二维码生成第三方库（https://github.com/sylnsfar/qrcode）

• 提供生成二维码的系列功能
• 基本二维码、艺术二维码和动态二维码

Python库之图形用户界面

PyQt5：Qt开发框架的Python接口（https://www.riverbankcomputing.com/software/pyqt）

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

wxPython：跨平台GUI开发框架（https://www.wxpython.org）

• 提供了专用于Python的跨平台GUI开发框架
• 理解数据类型与索引的关系，操作索引即操作数据
• Python最重要的数据分析功能库，基于Numpy开发

import wx
app = wx.App(False)
frame = wx.Frame(None, wx.ID_ANY,"Hello World")
frame.Show(True)
app.MainLoop()

PyGObject：使用GTK+开发GUI的功能库（https://pygobject.readthedocs.io）

• 提供了整合GTK+、WebKitGTK+等库的功能
• GTK+：跨平台的一种用户图形界面GUI框架

import gi
gi.require_version("Gtk","3.0")
from gi.repository import Gtk
window = Gtk.Window(title="Hello World")
window.show()
window.connect("destroy",Gtk.main_quit)
Gtk.main()

Python库之游戏开发

PyGame：简单的游戏开发功能库（http://www.pygame.org）

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

Panda3D：开源、跨平台的3D渲染和游戏开发库（http://www.panda3d.org）

• 一个3D游戏引擎，提供Python和C++两种接口
• 支持很多先进特性：法线贴图、光泽贴图、卡通渲染等
• 由迪士尼和卡耐基梅隆大学共同开发，相当优秀，相当好用。

cocos2d：构建2D游戏和图形界面交互式应用的框架（http://python.cocos2d.org/）

• 提供了基于OpenGL的游戏开发图形渲染功能
• 支持GPU加速，采用树型结构分层管理游戏对象类型
• 适用于2D专业级游戏开发

Python库之虚拟现实

VR Zero：在树莓派上开发VR应用的Python库（https://github.com/WayneKeenan/python-vrzero）

• 提供大量与VR开发相关的功能
• 针对树莓派的VR开发库，支持设备小型化，配置简单化
• 非常适合初学者实践VR开发及应用

pyovr：Oculus Rift的Python开发接口（https://github.com/cmbruns/pyovr）

• 针对Oculus VR设备的Python开发库
• 基于成熟的VR设备，提供全套文档，工业级应用设备
• Python+虚拟现实领域探索的一种思路

Vizard：基于Python的通用VR开发引擎（http://www.worldviz.com/vizard-virtual-reality-software）

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

Python库之图形界面

Quads：迭代的艺术（https://github.com/fogleman/Quads）

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

ascii_art：ASSCII艺术库（https://github.com/jontonsoup4/ascii_art）

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

turtle：海龟绘图体系（https://docs.python.org/3/library/turtle.html）

实例：玫瑰花绘制

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

实例：获取系统的递归深度、当前执行文件路径、系统最大UNICODE编码值等3个信息，并打印输出。

import sys
print("RECLIMIT:{}, EXEPATH:{}, UNICODE:{}".format(sys.getrecursionlimit(), sys.executable, sys.maxunicode))

实例：tabulate能够对二维数据进行表格输出，是Python优秀的第三方计算生态。

from tabulate import tabulate
data = [ ["北京理工大学", "985", 2000], \
         ["清华大学", "985", 3000], \
         ["大连理工大学", "985", 4000], \
         ["深圳大学", "211", 2000], \
         ["沈阳大学", "省本", 2000], \
    ]
print(tabulate(data, tablefmt='grid'))

实例：获得用户输入，去掉其中全部空格，将其他字符按收入顺序打印输出。

s = input()
s = s.replace(' ', '')
print(s)

#标答为
txt = input()
print(txt.replace(" ", ""))

实例：关键行指一个文件中包含的不重复行。关键行数指一个文件中包含的不重复行的数量。

with open('latex.log', 'r', encoding='utf-8') as f:
    ls = f.readlines()
    s = set(ls)
    print("共{}关键行".format(len(s)))

实例：读入一个字典类型的字符串，反转其中键值对输出。‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‮‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬

即，读入字典key:value模式，输出value:key模式。

s = input()
try:
    d = eval(s)
    e = {}
    for k in d:
        e[d[k]] = k
    print(e)
except:
    print("输入错误")

实例：《沉默的羔羊》之最多单词

import jieba
with open('沉默的羔羊.txt', 'r', encoding='utf-8') as f:
    ls = jieba.lcut(f.read())
    #ls = f.read().split()
    d = {}
    for w in ls:
        d[w] = d.get(w, 0) + 1
    maxc = 0
    maxw = ""
    for k in d:
        if d[k] > maxc and len(k) > 2:
            maxc = d[k]
            maxw = k
        if d[k] == maxc and len(k) > 2 and k > maxw:
            maxw = k
    print(maxw)

编程不重要，思想才重要！编程只是手段，熟练之，未雨绸缪为思想服务

Python语法的三个阶段：

• 函数式编程（基础）
• 面向对象编程（进阶）
• pythonic编程（高级）如何让Python语言调用其它语言编写的模块呢