Python必学基础

Python学习笔记

声明：
1、本文依据Mooc课程“Python语言程序设计”，北理工嵩天老师的课程。
2、推荐这门课作为一些非计算机专业学习，内容深入浅出，而且结合简单的实际应用进行讲解。
3、课程笔记，学习专用，未完，持续更新，后续学习进阶版也会更新。
4、欢迎学习交流，转载请先联系作者，盗版必究，尊重知识。

第一章 Python基本语法元素

1.1 程序设计的基本方法

1、计算机

#功能性：对数据的操作表现为数据计算、输入、输出和结果储存等

#可编程性：根据一系列指令自动地、可预测的、准确的完成操作者的意图。

2、摩尔定律Moore‘s Law

计算机史上最重要的预测法则：单位面积集成电路上可容纳晶体管的数量约每两年翻一番。

计算机发展是以指数方式的发展。

3、python

python诞生于1990年，是当今最好用的语言。

4、程序执行的两种方式

将源代码（人类可读）与目标代码（机器和某些顶尖专家可读）相互转换

#编译：将源代码一次性转换成目标代码的过程，使用编译执行的编程语言，如c、c++、Java等静态语言

静态语言 编译器一次性生成目标代码，优化充分，运行快

#解释：将源代码逐条转换为目标代码并同时逐条运行的过程，使用解释执行的编程语言称为脚本语言，如Python、js、php

脚本语言 执行程序时需要源代码，维护更灵活，可以跨多个操作系统平台

5、程序的基本编写方法

#IPO

I–input输入，程序的输入：文件、网络、控制台、交互界面、程序内部输入等

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

O–output输出，程序的输出：展示运算结果的方式

1.2 python开发环境配置

Python意为忙着，属于PSF，PSF是一个致力于保护Python语言开放、开源和发展的非营利组织。python的创始者是Guido。

网上方法很多，自己去学学即可。

1、python的两种编程方式

交互式和文件式

#交互式

对每个输入语句即时运行结果，适合语法练习

#文件式

批量执行一组语句并运行结果，编程的主要方式

1.3 摄氏度和华氏温度转换

输入输出格式：82F–华氏82度，28C–摄氏28度

算法设计：根据转换公式：C=(F-32)/1.8，F=C*1.8+32

#TempConvert.py

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

1.4 1.3代码解析

#缩进

表达程序的格式框架，表达代码间包含和层次关系的唯一手段，单一程序内锁紧长度相同即可，一般用4个空格或者1个tab

#注释

#开头，其后内容为注释，单行注释；’’'开头和结尾表示多行注释

#变量

用来保存和表示数据的占位符号

#命名

大小写字母、数字、下划线、汉字等字符的组合

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

#保留字

编程语言内部定义的并保留使用的标识符，即关键词

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
def	if	pass	del

#数据类型

供计算机程序理解的数据形式

-整数类型 10011101

-字符串类型 “10,011,101”

-列表类型 [10,011,101]

#字符串的序号

正向增序序号：从0开始

反向递减序号：-12，-11.。。，-1，保证最后一个为-1

#分支语句

有判断条件决定程序运行方向的语句，例如if，elif，else

#语句和函数

根据输入参数不同输出结果

#python输入和输出

#输入函数input()

从控制台输入

#输出函数print()

以字符串型是向控制台输出结果

print()函数的格式化

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

#eval()

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

如eval(“1+2”)会得到3

第二章 Python基本图形绘制

2.1 深入理解Python语言

1946-1981年计算机系统结构时代：计算能力问题

1981-2008网络和视窗时代：交互问题

2008-2016安卓系统产生，复杂信息时代：数据问题

2016-？人工智能时代：计算能力问题、人类的问题

#高级语言 接近自然语言，编译器，与cpu幸好无关

#汇编语言 有助记符，汇编器，与cpu型号有关

#机器语言 代码直接执行，与cpu型号有关

#超级语言 Python是目前唯一的超级语言

2.2 Python蟒蛇绘制

#PythonDraw.py
import turtle
turtle.setup(650,350,200,200)
turtle.penup()
turtle.fd(-250)
turtle.pendown() 
turtle.pensize(25)
turtle.pencolor("red")
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,100)
turtle.fd(40*2/3)
turtle.done()

2.3 代码解析

#turtle库概述

1969年诞生的海龟库，有一只海龟，在窗体正中心，在画布上游走，走过的轨迹形成了绘制的图形

#turtle绘图窗体

-setup()设置窗体大小及位置

-4个参数中后两个可选，分别表示长、宽、左上角x/y坐标

-setup()不是必须的

#turtle的空间坐标体系

turtle的空间坐标是绝对坐标，窗体中心为海归起始位置（0，0）

turtle.goto(x,y)表示走向

海龟是头朝右的乌龟

turtle.fd(d)朝海龟正前方

turtle.bk(d)朝海龟后方

turtle.circle(r,angle)朝海龟左侧沿距离r的原点绕行

turtle.seth(angle)改变海归方向，但不行进

turtle.colormode(mode)

#import用法

import <库名>

<库名>.<函数名>(<函数参数>)

import <库名> as <库别名>

<库别名>.<函数名>(<函数参数>)

from <库名> import <函数名>

from <库名> import *

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

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

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

turtle.pensize(25)#画笔的宽度，别名turtle.width()

turtle.pencolor("red")#设置画笔颜色

第三章 基本数据类型

3.1 数字类型及操作

#整数类型

pow(x,y) x的y次方

#4中进制表示形式

十进制：99

二进制，以0b或者0B开头：0b010，-0B101

八进制，以0o或者0O开头：0o123，-0O456

十六进制，以0x或者0X开头：0x9a，-0X89

#浮点类型

浮点数的小数部分二进制与十进制并不是一一对应，存在不确定尾数

例如输入0.1+0.2==0.3会显示false，但可以使用round解决，round（0.1+0.2）==0.3会显示true

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

#复数类型

定义与数学相同

z.real获得实部，z.imag获得虚部，z为复数

#数值运算操作符

+、-、*、/

x//y整数除，得到整数商

%取余

x**y=pow（x，y）但前者x，y为整数，后者不需要

x op=y与x=x op y相同

#数值运算函数

abs(x) 求x的绝对值

divmod(x,y) 同时输出商和余数divmod（10,3）=（3,1）

pow（x,y[,z]） 表示(x**y)%z，例如pow(3,pow(3,9),10000)结果为4587

round(x[,d]) 四舍五入，d是保留小数数位

max/min（1,2,4,3,5）

3.2 天天向上的力量

#DayDayupandDownQ3.py

def dayUp(df):    
    day = 1
    for i in range(365):        
        if ((i + 1) % 7 == 6 or (i + 1) % 7 == 0):     
            day *= (1 - df)        
        else:            
            day *= (1 + df)    
     return day

dayfactor = 0.01
while dayUp(dayfactor) < 37.78:    
    dayfactor += 0.001
print("一年365天：{:.3f}".format(dayfactor))

3.3 字符串类型及操作

1、简介

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

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

"这里阿拉法凉山大火"或者'C:'

-如果希望在字符串中包含双引号或者单引号的表示方法：

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

-如果希望文本中出现单引号和双引号

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

2、字符串的使用

-索引：返回字符串中单个字符 <字符串>[M]

"请输入带有符号的温度值："[0]或者TempStr[-1]

-切片返回字符串中一段字符子串 <字符串>[M:N]

"请输入带有符号的温度值："[1:3]或者TempStr[0:-1]

#字符串切片高级用法

使用[M:N:K]根据步长对字符串切片

-<字符串>[M:N:K]，根据步长K对字符串切片

"0123456789"[1:8:2]结果是"1357"

-<字符串>[M:N] M缺失表示至开头，N缺失表示至结尾

"01234567"[:3]结果是"012"

#字符串中的特殊字符

#转义符\

-表达特定字符的本意

"这里有个双引号(\")"结果为 这里有个双引号(")

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

“\b” 回退

“\n” 换行，光标移动到下行首

“\r” 回车，光标移动到本行首

3、字符串的操作符+、*、in

x+y表示连接

n*x或者

x*n表示复制n次字符串x

x in s如果x是s的子串，返回True，否则返回False

例子

#WeekNamePrintV2.py
weekStr = "一二三四五六七"
weekId = eval(input("请输入星期数字（1-7）："))
print("星期"+weekStr[weekId-1])

4、字符串处理函数

函数及使用	描述
len(x)	长度
str(x)	任意类型转换为字符串类型，包括列表
hex(x)或者oct(x)	将十进制整数变成十六进制或八进制小写形式字符串，例如hen(425)=“0x1a9”, oct(425)=“0o651”
chr(u)	u为Unicode编码，返回其对应字符，如char(10004)为"√"
ord(x)	x为字符，返回其对应的Unicode编码

举例：

for i in range(9800,9812):    
	print(chr(i),end=" ")

输出星座符号：

♈ ♉ ♊ ♋ ♌ ♍ ♎ ♏ ♐ ♑ ♒ ♓

方法及使用	描述
str.lower()或者str.upper()	返回字符串的副本，全部字符小写/大写"ahaBJOIHLADShjl".lower()结果为全部小写
str.split(sep=None)	返回一个列表，由str根据被sep分割的部分组成。“A,B,C”.split(",")结果为[‘A’,‘B’,‘C’]
str.count(sub)	返回子串sub在str中出现的次数。“an apple a day”.count(“a”)结果为4
str.replace(old,new)	旧字符串替换为新字符串
str.center(width[,fillchar])	字符串str根据宽度width居中，fillchar可选"python".center(20,"=")结果为"=python="
str.strip(chars)	从str中去掉其左侧和右侧chars中列出的字符"= python".strip(" =np")结果为"ytho"
str.join(iter)	在iter变量除最后元素外每一个元素后增加一个str。例如",".join(“12345”)结果为"1,2,3,4,5"，#主要用于字符串分隔等

5、字符串的格式化

其使用方法是.format()，具体用法如下：

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

#槽：{}，其两种不同的使用方法

"{}：计算机{}的cpu占用率为{}%".format("2018-10-10","c",10)

"{0}：计算机{1}的cpu占用率为{2}%".format("2018-10-10","c",10)

#format方法的格式控制

槽内部对格式化的配置方法:

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

：	<填充>	<对齐>	<宽度>	<,>	<.精度>	<类型>
引导符号	用于填充的单个字符	<左 >右 ^居中对齐	槽设定的输出宽度	数字的千位分隔符	浮点数小数精度或者字符串最大输出长度	整数类型b,c,d,o,x,X浮点数类型e,E,f,%

"{0:=^20}".format("Python")

= 填充符号，空余空间填充

^ 居中对齐

20 长度/宽度20

输出 =======Python=======

print("{0:b},{0:c},{0:d},{0:o},{0:x},{0:X}".format(425))
110101001,Ʃ,425,651,1a9,1A9

3.4 time库

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

-计算机时间的表达

-提供获取系统时间并格式化输出的功能

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

1、time库的使用

函数	描述
time()	获取当前时间戳，即计算机内部时间值，浮点数
ctime()	获取当前时间并以易读方式表示，返回字符串
gmtime()	获取当前时间表示为计算机可以处理的时间格式

import time
print(time.time())
print(time.ctime())
print(time.gmtime())


#输出结果：1599469094.3461773
#输出结果：Mon Sep  7 17:05:08 2020
#输出结果：time.struct_time(tm_year=2020, tm_mon=9, tm_mday=7, tm_hour=9, tm_min=2, tm_sec=26, tm_wday=0, tm_yday=251, tm_isdst=0)

时间戳表示的是1970年1月1日到当前这一时刻为止以秒为单位的时间

2、时间格式化

-格式化：类似于字符串格式化，需要由展示模板

-展示模板由特定的格式化控制符组成

函数	描述
strftime(tpl,ts)	tpl是格式化模板字符串，用来定义输出效果。ts是计算机内部时间类型变量
strptime(tpl,ts)	str是字符串形式的时间值，tpl是格式化模板字符串，用来定义输入效果

import time
t = time.gmtime()
print(time.strftime("%Y-%m-%d-%H:%M:%S",t))
timestr = '2020-09-07 09:16:51'
print(time.strptime(timestr,"%Y-%m-%d %H:%M:%S"))


#输出结果：2020-09-07-09:15:50
#输出结果：time.struct_time(tm_year=2020, tm_mon=9, tm_mday=7, tm_hour=9, tm_min=16, tm_sec=51, tm_wday=0, tm_yday=251, tm_isdst=-1)

格式化字符串	日期/时间说明	值范围和实例
%Y	年份	0000~9999，例如2020
%m	月份	01~12
%B	月份名称	January~December
%b	月份名称缩写	Jan~Dec
%d	日期	01~31
%A	星期	Monday~Sunday
%a	星期缩写	Mon~Sun
%H	24小时制	00~23
	12小时制	01~12
	上/下午	AM，PM，例如：PM
%M	分钟	00~59
%S	秒	00~59

3、程序计时

sleep() 产生时间

perf_counter() 测量时间

函数	描述
perf_counter()	返回一个CPU级别的精确时间计数值，单位为秒，其起点不确定，需连续调用差值才有意义

import  time
start = time.perf_counter()
time.sleep(2.2)
end = time.perf_counter()
print(end - start)

#输出：2.1999606000000003

3.5 文本进度条

#TextProBarV1.py
import time
scale = 10
print("{0:-^20}".format("执行开始"))
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("{0:-^20}".format("执行结束"))


#输出结果：
--------执行开始--------
  0%[->..........]
 10%[*->.........]
 20%[**->........]
 30%[***->.......]
 40%[****->......]
 50%[*****->.....]
 60%[******->....]
 70%[*******->...]
 80%[********->..]
 90%[*********->.]
100%[**********->]
--------执行结束--------

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

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

第四章 程序控制

4.1分支结构

1、单分支结构

根据判断条件结果而选择不同的前进路径的运行方式

if <条件>:

​ <语句块>

2、二分支结构

根据条件判断结果而选择不同进行的方式

if <条件>:

​ <语句块1>

else:

​ <语句块2>

#紧凑形式

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

3、多分支结构

if <条件1>:

​ <语句块1>

elif <条件2>:

​ <语句块2>

.......

else:

​ <语句块n>

#条件组合

and、or、not

4、程序的异常处理

#异常的简单处理

try:

​ <语句块1>

except:

​ <语句块2>

or

try:

​ <语句块1>

except <异常类型>:

​ <语句块2>

#异常的高级処理

try:

​ <语句块1>

except:

​ <语句块2>

else:

​ <语句块3> #此语句在不发生异常时执行

finally:

​ <语句块4> #此语句一定会执行

4.2 身体的BMI指数

#CalBMI_V1.py
height, weight = eval(input("请输入身高（米）和体重（kg），并使用逗号隔开："))
bmi = weight/pow(height,2)
print("BMI数值为：{0:.2f}".format(bmi))
if bmi <18.5:
	who1 = "偏瘦"
	who2 = "偏瘦"
elif 18.5<=bmi<24:    
	who1 = "正常"    
	who2 = "正常"
elif 24<=bmi<25:    
	who1 = "正常"    
	who2 = "偏胖"
elif 25<=bmi<28:    
	who1 = "偏胖"    
	who2 = "偏胖"
elif 28<=bmi<30:    
	who1 = "偏胖"    
	who2 = "肥胖"
else:    
	who1 = "肥胖"    
	who2 = "肥胖"
print("BMI指标为：国际{},国内{}".format(who1,who2))


#输出结果：
请输入身高（米）和体重（kg），并使用逗号隔开：1.81,85
BMI数值为：25.95
BMI指标为：国际偏胖,国内偏胖

4.3 程序的循环结构

1、遍历循环

for <循环遍历> in <遍历结构>:

​ <语句块>

for c in s: #s是字符串，c表示一个可以装字母的容器，此句话意思是遍历字符串每一个字符

​ <语句块>

for item in []:

​ <语句块>

for line in file:

​ <语句块>

2、无限循环

while <条件>:

​ <语句块>

一直运行，直到不满足while条件

3、循环控制保留字

break 和 continue

break跳出并结束当前循环，执行循环后的语句，break只能跳出一层循环

continue跳出当次循环，继续执行后续次数循环

4、循环的高级用法else

for <> in <>:

​ <>

else:

​ <>

or

while <>:

​ <>

else:

​ <>

上述语句表示，如果没有执行break，程序正常执行，则会继续执行else，否则不会执行

4.4 random库

random库是使用随机数的Python标准库，无需安装

-其产生的随机数并不随机，而是一种伪随机数，是采用梅森旋转算大生成的（伪）随机序列中的元素

1、基本随机数函数

函数	描述
seed(a=None)	初始化给定的随机数种子，默认为当前系统时间，random.seed(10)#产生种子10的对应的序列
random()	生成一个(0.0,1.0)之间的随机小数
randint(a,b)	生成一个[a,b]之间的整数
randrange(m,n[,k])	生成一个[m,n)之间以k为步长的随机整数
getrandbits(k)	生成一个k bit长的随机整数
uniform(a,b)	生成一个[a,b]之间的随机小数
choice(seq)	从列表seq[]中随机选择一个元素
shuffle(seq)	将列表seq[]中元素随机排列，返回打乱后的序列

import random
random.seed(10)
print(random.random())

#输出结果：0.5714025946899135

默认种子为当前系统时间，如果设定种子，则随机过程可以再现

4.5 圆周率的计算

数学家们给出了圆周率的计算公式：

公式太长，请自己百度一下，本次编程采用此公式

工程上的蒙特卡罗方法：

直径为d的圆与边长为d的正方形的1/4中撒点，那么数量足够多时可算出圆与正方形的面积比，进而计算出圆周率

#公式法

#CalPiV1.py
pi = 0
N = 100
for k in range(N):    
	pi += 1/pow(16,k)*(\        #\表示在公式过长时可以换行
	4/(8*k+1)-2/(8*k+4)-\        
	1/(8*k+5)-1/(8*k+6))
print("圆周率：{}".format(pi))


#圆周率：3.141592653589793

#蒙特卡罗方法

#CalPiV2.py
from random import random
from time import perf_counter
DARTS = 1000*1000
hits = 0.0
start = perf_counter()
for i in range(1, DARTS):    
	x, y = random(), random()    
	dist = pow(x**2+y**2, 0.5)    
	if dist <= 1.0:        
		hits += 1
pi = 4*(hits/DARTS)
print("Pi是：{}".format(pi))
print("运行时间：{}".format(perf_counter()-start))


#输出结果：
Pi是：3.14006
运行时间：0.5747372

第五章 函数和代码复用

5.1 函数的定义与使用

函数是一段代码的表示，即Java里的方法，它具有特定功能，可以通过函数名的调用而重复使用该函数所包含的代码。

def <函数名>(<参数可有可无，但括号必须带>):

​ <函数体>

​ return <返回值>

1、函数参数

#可选参数与非可选参数

def <函数名>(<非可选参数>,<可选参数>):

​ <函数体>

​ return <返回值>

非可选参数也叫必选参数，可选参数给出默认值，如果没有给可选参数赋予新值，则会使用默认参数

例如计算n!//m

def fact(n,m=1): #n为非可选参数，m为可选，如果在函数调用时不传入m值，则会默认为1，传入新值则为新值

​ s = 1

​ for i in range(1,n+1):

​ s *=i

​ return s//m

#可变参数传递

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

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

实例：

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

#输出结果：435456000

2、局部变量和全局变量

#全局变量

作用在整个程序中的变量

#局部变量

仅在函数体内部使用的变量

规则一：局部变量用于函数体内部，全局变量用于整个程序，当二者相同时，函数内部为局部变量，但可以使用global修饰，使局部变量变为全局变量

规则二：局部变量为组合数据且未创建，等同于全局变量

ls = ['F', 'f']
def func(a):    
    ls.append(a)    
	return
func("C")
rint(ls)

#输出：['F', 'f', 'C']
#当func(c)中加一行ls = []，输出结果为['F', 'f']

#lambda函数

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

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

-使用lambda保留字定义，函数名是返回结果

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

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

#等价于

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

​ <函数体>

​ return <返回值>

例子

f = lambda x, y : x+y

print(f(10,15))

#输出结果为25

5.2 七段数码管绘制

#七段灯管v1
import turtle
def drawLine(draw):
    turtle.pendown() if draw else turtle.penup()
    turtle.fd(40)
    turtle.right(90)

def drawDight(dight):
    drawLine(True) if dight in [2, 3, 4, 5, 6, 8, 9] else drawLine(False)
    drawLine(True) if dight in [0, 1, 3, 4, 5, 6, 7, 8, 9] else drawLine(False)
    drawLine(True) if dight in [0, 2, 3, 5, 6, 8, 9] else drawLine(False)
    drawLine(True) if dight in [0, 2, 6, 8] else drawLine(False)
    turtle.left(90)
    drawLine(True) if dight in [0, 4, 5, 6, 8, 9] else drawLine(False)
    drawLine(True) if dight in [0, 2, 3, 5, 6, 7, 8, 9] else drawLine(False)
    drawLine(True) if dight in [0, 1, 2, 3, 4, 7, 8, 9] else drawLine(False)
    turtle.left(180)

def drawDate(date):
    for i in date:
        drawDight(eval(i))
        turtle.penup()
        turtle.fd(10)
        turtle.pendown()

def main():
    turtle.setup(800, 350, 200, 200)
    turtle.penup()
    turtle.fd(-300)
    turtle.pensize(5)
    drawDate("20181010")

    turtle.done

main()

#七段灯管v2
import turtle
import 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 drawDight(dight):
    drawLine(True) if dight in [2, 3, 4, 5, 6, 8, 9] else drawLine(False)
    drawLine(True) if dight in [0, 1, 3, 4, 5, 6, 7, 8, 9] else drawLine(False)
    drawLine(True) if dight in [0, 2, 3, 5, 6, 8, 9] else drawLine(False)
    drawLine(True) if dight in [0, 2, 6, 8] else drawLine(False)
    turtle.left(90)
    drawLine(True) if dight in [0, 4, 5, 6, 8, 9] else drawLine(False)
    drawLine(True) if dight in [0, 2, 3, 5, 6, 7, 8, 9] else drawLine(False)
    drawLine(True) if dight in [0, 1, 2, 3, 4, 7, 8, 9] else drawLine(False)
    turtle.left(180)

def drawDate(date):
    turtle.pencolor("red")
    for i in date:
        if i == '-':
            turtle.write('年', font = ("Arial", 18, "normal"))
            turtle.pencolor("green")
            turtle.penup()
            turtle.fd(40)
        elif i == '=':
            turtle.write("月", font = ("Arial", 18, "normal"))
            turtle.pencolor("blue")
            turtle.penup()
            turtle.fd(40)
        elif i == '+':
            turtle.write("日", font=("Arial", 18, "normal"))
        else:
            drawDight(eval(i))
        turtle.penup()
        turtle.fd(10)
        turtle.pendown()

def main():
    turtle.setup(800, 350, 200, 200)
    turtle.penup()
    turtle.fd(-300)
    turtle.pensize(5)
    t = time.gmtime()
    date = time.strftime("%Y-%m=%d+", t)
    drawDate(date)
    turtle.hideturtle()
    turtle.done

main()

5.3 代码复用与函数递归

代码资源化：程序代码是一种用来表达计算的资源

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

代码复用：同一份代码在需要时可以被重复使用

1、代码复用

函数 和 对象 是代码服用的两种主要形式

函数：将代码命名，在代码层面建立了初步抽象

对象：属性和方法.和.()，在函数之上再次组织进行抽象

2、模块化设计

通过函数或者对象封装将程序划分为模块及模块间的表达，具体包括：主程序、子程序和子程序之间的关系

#分而治之

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

3、递归

函数定义中调用自身的形式

#链条

计算过程中存在递归链条

#基例

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

#递归的实现

函数+分支语句

递归本身就是一个函数，函数内部需要分支语句对输入参数进行判断。

#将字符串反转

#字符串反转
def rvs(s):
    if s == "":
        return s
    else:
        return s[-1]+rvs(s[:-1])

print(rvs("akjvkavsdkfvdsgkajsf"))

#汉诺塔

#hanoi
count = 0
def hanoi(n, A, B, C):
    global count
    if n == 1:
        print(A, '-->', C)
        count += 1
    else:
        hanoi(n - 1, A, C, B)
        print(A, '-->', C)
        count += 1
        hanoi(n - 1, B, A, C)

def main():
    n = eval(input("输入层数："))
    A = 'A'
    B = 'B'
    C = 'C'
    hanoi(n, A, B, C)
    print(count)

main()

5.4 PyInstaller库的使用

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

-.py --> PyInstaller -->Windows、Linux、Mac OS X系统不安装python时也能执行文件

#PyIntaller库的安装

在cmd中输入代码pip install pyinstaller

C:\Users\MiuRui>pip install pyinstaller

#pyinstaller的使用

pyinstaller是命令行语言，只能在cmd中执行，而不能在编译器或者python自带的idle界面运行

1、找到所需转化程序代码的文件位置，然后控制cmd进入该目录

cd <文件位置>，位置不同，找到自己的路径即可

C:\Users\MiuRui>d:

D:\>cd D:\Code_Data\PythonPycharm

D:\Code_Data\PythonPycharm>

2、输入代码pyinstaller -F <文件名>

D:\Code_Data\PythonPycharm>pyinstaller -F SevenDightsDraw.py

执行这段代码后，目录中生成了额外的三个目录__pycache__、build、dist，其中的__pycache__、build可以删除，在dist中有一个同名文件，即是转化好的程序。

#pyinstaller命令行

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

5.5 科赫曲线

用python绘制科赫曲线

#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():#设置窗口大小、起点位置、size、color
    turtle.setup(600, 600, 200, 100)
    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()
    turtle.done()

main()

第六章 数据类型组合

6.1 集合类型及操作

集合是多个元素的无需组合，元素不可重复，且是不可变类型

#使用{}建立集合

#集合操作符

操作符及应用	描述
S|T	返回并集
S-T	差集，返回一个新集合，包含在S中但不在T中的元素
S&T	返回交集
S^T	补集，返回新集合，包括集合S和T中的非相同元素
S<=T或S	返回True/False，判断S和T的子集关系
S>=T或S>T	返回True/False，判断S和T的包含关系

#集合处理方法

操作函数或方法	描述
S.add(x)	如果x不在集合S中，将x增加到S
S.discard(x)	移除S中的元素x，如果x不在集合中，不报错
S.remove(x)	移除S中的元素x，如果x不在集合中，产生keyerror异常
S.clear()	移除所有元素
S.pop()	随机返回S的一个元素，更新S，若S为空产生KeyError异常
S.copy()	返回集合S的一个副本
len(S)	返回集合S的个数
x in S	布尔类型
x not in S	布尔类型

#数据去重

集合类型中所有元素均不重复

ls = ["p", "p", "y", "y", 123]

s = set(ls)

print(s)

lt = list(s)

6.2 序列类型及操作

序列是具有先后关系的一组元素，序列是一个基类类型，是以为元素向量，元素类型可以不同，元素间由序号引导，通过下标访问序列的特定元素。

字符串类型、元组类型、列表类型是序列类型的衍生，序列类型性的操作，都可以在上述三种类型中进行。

#序列类型操作符

操作符及应用	描述
x in S	布尔类型
x not in S
S+T	连接序列
S*n或者反过来	将序列S复制n次
S[i]	索引，返回s中的第i个元素，i是序列的序号
S[i:j] S[i:j:k]	切片操作，返货序列s中i到j以k为步长的元素的子序列

#取反操作

ls[::-1] #列表中的反转操作

#函数和方法，此方法为序列方法

函数和方法	描述
len(s)	返回序列s的长度
min(s)	返回序列s的最小元素，s中元素需要可比较
max(s)
s.index(x)或者s.index(x, i, j)	返回序列s从i到j位置中第一次出现元素x的位置
s.count(x)	序列s中出现x的总次数

1、元组类型

元组类型是一种序列类型，一旦创建不可更改，使用()或者tuple()创建，元素间用逗号，分隔。也可以不使用()

creature = "cat", "dog", "tiger", "human"
print(creature)

#输出：('cat', 'dog', 'tiger', 'human')

#元组类型操作

creature[::-1]

2、列表类型

列表类型是一种序列类型，创建后可以被更改，使用[]或者list()创建，元素间用逗号分隔

列表中元素类型可以不同，且没有长度限制

#操作函数和方法

函数和方法	描述
ls[i] = x	替换列表ls序号为i的元素为x
ls[i: j: k] = lt	将列表lt替换ls切片后所对应元素的子序列
del ls[i]	删除列表中第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.copy()	生成一个新列表，复制ls中所有元素
ls.insert(i,x)	在列表ls的第i位置增加元素x
ls.pop(i)	去除并删除第i元素
ls.remove(x)	将列表ls中出现的第一个元素x删除
la.reverse()	反转元素

例子：

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


#输出结果：['cat', 'dog', 'tiger', 1024, 1234]
#输出结果：['cat', 'dog', 'tiger', 'human', 1024, 1234]
#输出结果：[1234, 1024, 'human', 'tiger', 'dog', 'cat']

ls = []
print(ls)
ls += ['cat', 'dog', 'bird', 'human', 1024]
print(ls)
del ls[1:3]
print(ls)
print(0 in ls)
ls.append(0)
print(ls)
print(ls.index(0))
print(len(ls))
ls.clear()
print(ls)



#输出结果：
[]
['cat', 'dog', 'bird', 'human', 1024]
['cat', 10086, 'bird', 'human', 1024]
['cat', 'lhp', 10086, 'bird', 'human', 1024]
['cat', 10086, 'bird', 'human', 1024]
['cat', 'human', 1024]
False
['cat', 'human', 1024, 0]
3
4
[]

#遍历

for item in ls: #遍历列表

​ <语句块>

for item in tp: #遍历元祖

​ <语句块>

#数据保护

将数据转化为元组：lt = tuple(ls)

6.3 基本统计值计算

基本统计值：一组数据的总个数len()、和for…in…、平均值、方差(个数据与平均数差的平方和的平均数)·、中位数（排序，然后技术找中间，偶数找中间2个取平均）、、、

#CalStatisticsV1.py
def getNum():
    nums = []
    t = True
    while t:
        num = input("请输入数字（回车退出）：")
        if num == "":
            break
        else:
            nums.append(eval(num))
    return nums

def sum(nums):      #计算和
    sum=0
    for item in nums:
        sum += item
    return sum

def avg(nums):      #计算平均值
    return sum(nums)/len(nums)

def dev(nums):      #计算方差
    devsum = 0
    for item in nums:
        devsum += pow(item - avg(nums), 2)
    return pow(devsum/(len(nums)-1), 0.5)

def median(nums):        #计算中位数
    nums.sort()
    print(nums)
    if len(nums)%2 == 0:
        med = (nums[len(nums)//2-1] + nums[len(nums)//2])/2
    else:
        med = nums[len(nums)/2]
    return med



def main():
    ls = getNum()
    print("列表为：{}".format(ls))
    print("和为：{}".format(sum(ls)))
    print("平均数为：{}".format(avg(ls)))
    print("方差为：{}".format(dev(ls)))
    print("中位数为：{}".format(median(ls)))

main()


#输入2,8,5,9
#输出：
列表为：[2, 8, 5, 9]
和为：24
平均数为：6.0
方差为：3.1622776601683795
[2, 5, 8, 9]
中位数为：6.5

6.4 字典类型及操作

映射–一种键和值得对应

键值对：键是数据索引的扩展

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

采用大括号{}和dict{}创建，键值对用冒号:表示

<字典变量> = {<键1>:<值1>,<键2>:<值2>,<键3>:<值3>,...,<键n>:<值n>}

<值> = <字典变量>[<键>]

<字典变量>[<键>] = <值>

de = {} #创建空字典de

type(de) #检查变量类型

#字典类型操作函数和方法

函数和方法	描述
del d[k]	删除字典d中键k对应的数据值
k in d	判断键k是否在字典d中
d.keys()	返回字典d中所有键的信息
d.values()	返回字典d中所有的值信息
d.items()	返回字典d中所有的键值对信息
d.get(k, )	键k存在，返回值，不存在则返回值
d.pop(k, )	键k存在，取出值（即会删除），不存在则返回值
d.popitem()	随机从字典d中取出一个键值对，以元组形式返回
d.clear()
len(d)

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


#输出
True
dict_keys(['中国', '美国', '法国'])
dict_values(['北京', '华盛顿', '巴黎'])

6.5 jieba库

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

中文文本需要通过分词来获得单个的词语

jieba是优秀的中文分词第三方库，需安装

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

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

1、jieba分词的三种模式

精确模式、全模式、搜索引擎模式

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

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

搜索引擎模式，在精确模式基础上，对长词再次切分

函数	描述
jieba.lcut(s)	精确模式，返回一个列表类型的分词结果，最常用
jieba.lcut(s, cut_all=True)	全模式，返回一个列表类型的分词结果，存在冗余
jieba.lcut_for__search(s)	搜索引擎模式，有冗余
jieba.add_word(w)	向粉刺字典增加新词w

import jieba
for item in jieba.cut("中国是一个伟大的国家"):
    print(item)
print("\n")
for item in jieba.cut("中国是一个伟大的国家", cut_all=True):
    print(item)
print("\n")
for item in jieba.cut_for_search("中华人民共和国是伟大的"):
    print(item)
    
    
    
#输出：
Building prefix dict from the default dictionary ...
Loading model from cache C:\Users\MiuRui\AppData\Local\Temp\jieba.cache
Loading model cost 0.629 seconds.
Prefix dict has been built successfully.
中国
是
一个
伟大
的
国家


中国
国是
一个
伟大
的
国家


中华
华人
人民
共和
共和国
中华人民共和国
是
伟大
的

6.6 文本词频统计

#CalHamletV1.py

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

hamletTxt = getText()
words = hamletTxt.split()
counts = {}

for word in words:
    counts[word] = counts.get(word, 0) + 1      #重点

items = list(counts.items())
items.sort(key = lambda x:x[1], reverse = True)
for i in range(10):
    word, count = items[i]
    print("{0:<10}{1:>5}".format(word, count))
    
    
#输出结果：
the        1137
and         963
to          736
of          668
you         546
i           538
a           527
my          513
hamlet      455
in          435

三国演义：

#CalThreekingdomV1.py
import jieba

txt = open("threekingdoms.txt", encoding="utf-8").read()
excludes = {"将军", "却说", "荆州", "二人", "不可", "不能", "如此"}
words = jieba.lcut(txt)
counts = {}
for word in words:
    if len(word) == 1:
        continue
    elif word =="诸葛亮" or word == "孔明曰":
        rword = "孔明"
    elif word =="关公" or word == "云长":
        rword = "关羽"
    elif word =="玄德" or word == "玄德曰":
        rword = "刘备"
    elif word == "孟德" or word == "丞相":
        rword = "曹操"
    else:
        rword = word
    counts[rword] = counts.get(rword, 0) + 1

for word in excludes:
    del counts[word]

items = list(counts.items())
items.sort(key=lambda x: x[1], reverse=True)
for i in range(15):
    word, count = items[i]
    print("{0:<10}{1:>5}".format(word, count))
    
    
#输出结果：
曹操         1451
孔明         1383
刘备         1252
关羽          784
张飞          358
商议          344
如何          338
主公          331
军士          317
吕布          300
左右          294
军马          293
赵云          278
引兵          276
次日          271

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

7.1 文件的使用

文件式数据的抽象和集合，是存储在辅助存储器上的数据序列，使数据存储的一种形式，文件展现形态：文本文件和二进制文件。

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

如果文件是由单一特定编码组成的，如UTF-8编码，这样的文件叫文本文件，也可以看成一个长字符串。

二进制文件直接由比特0和1组成，没有统一字符编码，一般存在二进制0和1的组织结构，即文件格式，比如.png、.avi视频图片文件等。

#文件的打开与关闭

#文件存储状态

<变量名> = open(<路径和文件名，同目录可省略路径>,<打开模式，文本或者二进制，读或者写>)

#文件的占用状态，文件操作

a.close()

#文件的存储状态

读文件：

a.read(size)

a.readline(size)

a.readlines(hint)

写文件:

a.write(s)

a.writelines(lines)

a.seek(offset)

#文件的打开模式

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

#文件的关闭

<变量名>.close()

忘记关闭时，会在程序关闭时自动关闭。

#文件内容的读取

操作方法	描述
.read(size=-1)	读入全部内容，如果给出参数，则读入前size长度，如s = f.read(2)
.readline(size=-1)	读入一行，给出长度，可以读出前size长度
.readlines(hint=-1)	读入文件所有行，以每行为元素形成列表，如果给出参数，读入前hint行

遍历全文本：方法1##直接遍历全文件，但当文件特别巨大时，如100GB，会耗费很多资源，一次读入，统一处理

fname = input("请输入要打开的文件名称：")

fo = open(frame, "r")

txt = fo.read()

#对全文txt进行处理

fo.close()

遍历全文本：方法2##处理大文件更常用

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

逐行遍历文件：方法2##逐行读入

fname = input("请输入要打开的文件名称：")

fo = open(fname, "r")

for line in fo:

​ print(line)

fo.close()

#数据文件的写入

操作方法	描述
.write(s)	向文件写入一个字符串或字节流
.writelines(lines)	将一个元素全为字符串的列表写入文件
.seek(offset)	改变当前文件操作指针位置，offset含义如下：0-文件开头，1-当前位置，2-文件结尾，f.seek(0)#回到文件开头

fo = open("output.txt", "w+")
ls = ["中国", "法国", "美国"]
fo.writelines(ls)
fo.seek(0)      #缺失此语句，指针在末尾，无任何输出
for line in fo:
    print(line)
fo.close()

7.2 自动轨迹绘制

根据脚本绘制图形，不是写代码，而是写数据绘制轨迹，数据脚本是自动化最重要的第一步。

#基本思路：

-步骤1：定义数据文件格式（接口）

-步骤2：编写程序，根据文件接口解析参数绘制图形

-步骤3：绘制数据文件

#数据接口定义：

非常具有个性色彩：

<向前行进的距离>, <做判断，0左转，1右转>, <转向角度>,

data.txt中数据为：

300,0,144,1,0,0
300,0,144,0,1,0
300,0,144,0,0,1
300,0,144,1,1,0
300,0,108,0,1,0
184,0,72,1,0,1
184,0,72,0,0,0
184,0,72,0,0,0
184,0,72,0,0,0
184,1,72,1,0,1
184,1,72,0,0,0
184,1,72,0,0,0
184,1,72,0,0,0
184,1,72,0,0,0
184,1,720,0,0,0

#AutoTraceDraw.py
import turtle as t
t.title('自动轨迹绘制')
t.setup(800, 600, 200, 100)
t.color("red")
t.pensize(5)

#数据读取
datals = []
f = open("D:\\Code_Data\\PythonPycharm\\testTxt\\Data.txt")
for line in f:
    line = line.replace("\n", "")
    datals.append(list(map(eval, line.split(","))))     #map将第一个参数施加到第二个参数上
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])

t.done()

通过这个事例，将数据和功能分离，数据驱动的自行运行，是自动化的最基础的内容。

对于不同问题，接口自行设计。

7.3 一维数据的格式化

1、以为数据的存储

方法1：空格分隔

中国 美国 日本 德国 法国 英国 意大利

-使用一个或者多个空格分隔进行存储，不换行

-缺点：数据中不能存在空格

方法2：逗号分隔，与空格分隔基本一致

方法3：特殊符号分隔

中国$美国$日本$德国$法国$英国

f = open("D:\\Code_Data\\PythonPycharm\\testTxt\\hdahj.txt", encoding="utf-8")
txt = f.read()
txt = txt.split()
print(txt)
f.close()


#输出：
['中国', '美国', '日本', '德国', '法国', '英国', '意大利']

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

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

二维数据一般使用二维列表形式

CSV存储格式：Comma-Separated Values

国际通用的一二维数据存储格式，一般.csv扩展名，每行一个一维数据，采用逗号分隔，无空行。excel和一般编辑软件都可以读入或另存为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()

7.5 wordcloud库

w = word.WordCloud()

方法	描述
w.generate(txt)	向WordCloud对象w中加载文本txt，w.generate(“Python and WordCloud”)
w.to_file(filename)	将词云输出位图像文件，.png or .jpg。w.to_file(“outfile.png”)

绘制词云三步骤：

-步骤1：配置对象参数

-步骤2：加载词云

-步骤3：输出词云文件

参数	描述
width	图片宽度，默认400像素，w = wordcloud.WordCloud(width = 600)
heigth	图片高度，默认200像素，w = wordcloud.WordCloud(height = 400)
min_font_size	词云中最小字号，w = wordcloud.WordCloud(min_font_size=10)
max_font_size	词云中最大字号，w = wordcloud.WordCloud(min_font_size=20)
font_step	制定词云中字体字号的步进间隔，默认为1，w = wordcloud.WordCloud(font_step = 2)
font_path	制定字体文件的路径，默认为None，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()函数。
background_color	指定词云图片的背景颜色，默认为黑色，w = wordcloud.WordCloud(background_color=“color”)

from scipy.misc import imread #导入imread

mk = imread("pic.png") #使用imread获取pic。png的形状，并赋给mk

w = wordcloud.WordCloud(mask = mk)

7.6 政府工作报告词云

基本思路：

-步骤1：读取文件、分词整理

-步骤2：设置并输出词云

-步骤3：观察结果，优化迭代

#chineseWordCloudV1.py
import jieba
import wordcloud
from imageio import imread

route = input("请输入文件路径和文件名（格式如D:\\Code_Data\\1.txt或者D:/Code_Data/1.txt）：")
f = open(route, "r", encoding="utf-8")
t = f.read()
f.close()
ls = jieba.lcut(t)
txt = " ".join(ls)
shape = input("请输入词云形状路径和文件名（后缀为.png）：")
mk = imread(shape)
c = wordcloud.WordCloud(mask=mk, font_path="msyh.ttc",width=600, height=600, background_color="white")
c.generate(txt)
name = input("请输入词云名称（后缀为.png或者.jpg）：")
c.to_file(name)

第八章 程序设计方法学

8.1 体育竞技分析(自顶向下的分解)

程序总体框架及步骤

-步骤1：打印程序的介绍性信息式 -printInfo()

-步骤2：获得程序运行参数：proA，proB，n -getInputs()

-步骤3：利用球员A和B的能力值，模拟n局比赛 -simNGames()

-步骤4：输出球员A和B获胜比赛的场次及概率 -printSummary()

import random
def printIntro():
    print("这个程序模拟两个选手A和B的某种竞技比赛")
    print("程序运行需要A和B的能力值（以0到1之间的小数表示）")


def getInputs():
    a = eval(input("请输入运动员a的能力值（0~1）："))
    b = eval(input("请输入运动员b的能力值（0~1）："))
    n = eval(input("请输入模拟比赛的场次："))
    return a, b, n


def simOneGame(probA, probB):
    scoreA, scoreB = 0, 0
    serving = "A"
    while scoreA<15 and scoreB<15:
        if serving == "A":
            if random.random()<probA:
                scoreA += 1
            else:
                serving = "B"
        else:
            if random.random()<probB:
                scoreB += 1
            else:
                serving = "A"
    return scoreA, scoreB



def simNGames(n, probA, probB):
    winsA = 0
    winsB = 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获胜{}场比赛，占比为{:0.1%}".format(winsA, winsA/n))
    print("选手B获胜{}场比赛，占比为{:0.1%}".format(winsB, winsB/n))


def main():
    printIntro()
    probA, probB, n = getInputs()
    winsA, winsB = simNGames(n, probA, probB)
    printSummary(winsA, winsB)


main()

8.2 Python程序设计思维

计算思维被认为人类第三种思维特征。前两种分别是逻辑思维和实证思维。

#计算思维特征：抽象、自动化

抽象问题的计算过程，利用计算机自动化求解，因此说计算思维是基于计算机的思维方式

#计算生态

从开源运动说起

-1982年，Richard Stallman启动GNU项目，希望做出一个开源操作系统

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

-1991年，Linus Torvalds发布了Linux内核

-1998年，网景浏览器开源，产生了Mozilla、火狐等浏览器

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

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

#提高用户体验的方法：

方法1、进度展示：时间长或者步骤多或者产生大量次数循环，需增加进度展示

方法2、异常处理：检查用户输入，读写文件时对结果进行判断，输入输出对运算结果进行判断

其他方法：

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

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

8.3 Python第三方库的安装

Python全球社区： https://pypi.org/

pypi = Python package index

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

-第一步：pypi搜索blockchain

-第二步：挑选适合开发目标的第三方库作为基础

-第三步：完成自己需要的功能

#安装第三方库三种方法

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

-方法2：集成安装方法

-方法3：文件安装方法

#pip安装

pip install <第三方库名称>

pip install -U <第三方库名称> #-U表示update，可以更新已安装的第三方库

pip uninstall <第三方库名> #卸载

pip download <第三方库名> #下载，但并不安装

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

pip search <关键词> #根据关键词在名称和介绍中搜索第三方库

#集成安装方法

结合特定的安装工具，批量安装库

#文件安装方法

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

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

网站：http://www.lfd.uci.edu/~gohlke/pythonlibs/

-步骤1：在UCI页面搜索wordcloud

-步骤2：下载对应版本的文件

-步骤3：使用pip install <文件名>安 装

8.4 os库的基本介绍

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

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

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

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

1、os之路径操作

函数	描述
os.path.abspath(path)	返回path在当前系统中的绝对路径，os.path.abspath(“file.txt”)
os.path.normpath(path)	归一化path的表示形式，统一用\分隔路径
os.path.relpath(path)	返回当前程序与文件之间的相对路径（relative path）
os.path.dirname(path)	返回path中的目录名称
os.path.basename(path)	返回path中最后的文件名称
os.path.join(path,*paths)	组合path与paths，返回一个路径字符串
os.path.exists(path)	判断path对应文件或者目录是否存在，布尔类型
os.path.isfile(path)	判断path是否为已存在文件，布尔类型
os.path.isdir(path)	判断path所对应是否为已存在目录，布尔类型
os.path.getatime(path)	返回path对应文件或目录上一次的访问时间
os.path.getmtime(path)	返回path对应文件或目录最近一次的修改时间
os.path.getctime(path)	返回path对应文件或目录的创建时间

2、os进程管理

os进程管理可以控制其他程序的进行。

os.system(command)

-执行程序或命令command

-在windows系统中，返回值为cmd调用返回信息

函数	描述
os.chdir(path)	修改当前程序操作的路径
os.getcwd()	返回程序的当前路径
os.getlogin()	获得当前系统登录用户名称
os.urandom(n)	获得n个字节长度的随机字符串，通常用于加解密运算

8.5 第三方库安装脚本

第三方库安装脚本：

-需求：能否自动批量安装第三方库

#osTest
import os

libs = {"numpy", "matplotlib"}

try:
    for lib in libs:
        os.system("pip install "+lib)
    print("Successful")
except:
    print("Failed Somehow")

第九章 Python计算生态

9.1 从数据处理到人工智能

数据处理方面：Numpy、Pandas、Scipy

数据可视化：Matplotlib、Seaborn、Mayavi

文本处理：PyPDF2、NLTK、python-docx

机器学习：Scikit-learn、TensorFlow、MXNet

9.2 霍兰德人格分析雷达图

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

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

-输出：雷达图

9.5 玫瑰花绘制

-需求：用python绘制一朵玫瑰花，先给所思所想

-输入：想象力

-输出：玫瑰花

END