python语言程序设计完结

概述：

程序设计是计算机可编程的体现
程序设计，亦称编程，是深度应用计算机的主要手段
程序设计已经成为当今社会需求量最大的职业技能之一
程序设计语言是一种用于交互（交流）的人造语言
程序设计语言，亦称编程语言，程序设计的具体实现方式
编程语言相比自然语言更简单、更严谨、更精确
变成语言种类很多，但生命力强劲的却不多
编程语言有超过600种，绝大部分都不再被使用
C语言诞生于1972年，它是第一个被广泛使用的编程语言
python语言诞生于1990年，它是最流行，最好用的编程语言

编译和解释

编程语言按照执行方式划分，分为编译和解释两种
编译：将源代码一次性转换成目标代码的过程
解释：将源代码逐条转换成目标代码同时逐条运行的过程

根据执行方式的不同，编程语言分为两类：静态语言和脚本语言
静态语言就是：使用编译执行的编程语言，比如C++，Java语言；
编译器一次性生成目标代码，优化更充分，程序运行速度更快
脚本语言：使用解释执行的编程语言，比如python语言、js、php；
执行程序时需要源代码，维护更灵活，跨多个操作系统平台运行

程序的基本编写方法

IPO
-I Input输入， 程序的输入，一个程序的开始
-P Process处理，程序的主要逻辑
-O Output输出，程序的输出
编程解决问题的步骤：

1. 分析问题：分析问题的计算部分，想清楚
2. 划分边界：划分问题的功能边界，规划IPO
3. 设计算法：设计问题的求解算法，关注算法
4. 编写程序：编写问题的计算程序，编程序
5. 调试测试：调试程序使正确运行，运行调试
6. 升级维护：适应问题的升级维护，更新完善

计算机编程

变成能够训练思维
-编程体现了一种抽象交互关系、自动化执行的思维模式
-计算思维：区别逻辑思维和实证思维的第三种思维模式
-能够促进人类思考，增进观察力和深化对交互关系的理解
编程可以带来乐趣
编程可以带来就业机会
。。。。。。

python语言编写和运行

python有两种编程方式，一种是交互式，一种是文件式
交互式：对每个输入语句即时运行结果，适合语法练习
文件式：批量执行一组语句并运行结果，编程的主要方式，主要是将程序代码写入到一个ide中去运行

温度转换问题分析

摄氏度：中国等大多数国家使用，以1标准大气压下水额度结冰点为0度，沸点为100度，将温度进行等分刻画
华氏度：美国、英国等国家使用，以1标准大气压下水的结冰点为32度，沸点为212度，将温度进行等分刻画
两个温度的相互之间的转换（华氏温度转换为摄氏温度或者摄氏温度转化为华氏温度）怎么分析呐？
该问题中计算部分的理解和确定
理解1：直接将温度值进行转换
理解2：将温度信息发布的声音或图像形式进行理解和转换
理解3：监控温度信息发布渠道，实时获取并转换温度值
分析问题
——采用理解1 直接将温度值进行转换
温度数值需要表明温度体系，即摄氏度或华氏度
转换后也需要给出温度体系

划分边界
——输入 带华氏或摄氏标志的温度值
——处理 根据温度标志选择适当的温度转换算法
——输出 带摄氏或华氏标志的温度值

输入输出格式设计
标识放在温度最后，F表示华氏度，C表示摄氏度
82F表示华氏82度，28C表示摄氏28度

设计算法
根据华氏和摄氏温度定义，利用转换共识如下：
C=(F-32)/1.8
F = C*1.8+32
其中，C表示摄氏温度，F表示华氏温度

接下来我们实现这段代码，具体如下

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("输入温度错误")

python程序语法元素分析

程序的格式框架
——首先我们看到有的代码是高亮的，这个是编程的色彩辅助体系，不是语法要求
——缩进，表达程序的格式框架；严格明确，缩进是语法的一部分，缩进不正确程序运营错误；所属关系，表达代码间包含和层次关系的唯一手段；长度一致，程序内一致即可，一般用4个空格或者1个TAB
——注释，不被程序执行的辅助性说明信息；单行注释，以#开头，其后内容为注释；多行注释，以‘’‘开头和结尾
命名和保留字
比如温度转换程序中的C F TempStr，他们是程序中的变量，程序中用于保存和表示数据占位符号
——用来保存和表示数据的占位符号，变量采用标识符来表示，关联标识符的过程叫命名
——我们可以使用等号=向变量赋值或修改值，=被称为赋值符号
比如Tempstr=’82F‘，#这个表示向变量Tempstr赋值82F
命名：
命令规则：大小写字母、数字、下划线和汉字等字符及组合，需要注意的是：python大小写敏感、首字符不能是数字、不能与保留字相同
保留字
被编程语言内部定义并保留使用的标识符
——python语言有33个保留字（也叫关键字），比如说if elif else in等等
——保留字是编程语言的基本单词，大小写敏感
保留字的范围：

黑色的26个保留字是在python基础语法体系中出现的

数据类型
在温度转换这段代码中，包含了 字符串、整数、浮点数、列表这四种数据类型
数据类型-顾名思义，供计算机程序理解的数据形式，或者说程序设计语言通过一定方式向计算机表达数据的形式
字符串——由0个或者多个字符组成的有序字符序列，显著特点是在两侧有一对单引号或一对双引号
字符串的序号——正向递增和反向递减序号，如下图：

正是因为有了序号，所以我们可以使用列表获得字符串中的一个或者多个字符，变现为字符串的索引和切片操作，也就是我们使用[]这个符号获取字符串中的一个或者多个字符
——索引：返回字符串中单个字符，表达形式是 <字符串>[M]，比如Tempstr[-1]，表示的是取字符串的最后一个字符
——切片：返回字符串中一段字符字串，表达形式是<字符串>[M:N]，比如Tempstr[0:-1]表示的是，从取第一个字符到倒数第二个字符，相当于把字符串的最后一个字符去掉
我们看到温度转换代码中还有32 1.8等数字，我们把他们叫做数字类型
整数和浮点数都是数字类型
——整数，数学中的整数，比如32
——浮点数，数学中的实数，带有小数部分，比如1.8
——列表类型，由0个或多个数据组成的有序序列，当然，我们可以使用一个保留字in来判断前者是否与列表中某个元素相同，比如说温度转换中的这代代码 Tempstr[-1] in [‘F’, ‘F’]:
语句与函数
赋值语句：由赋值符号构成的一行代码，也就是用来给变量赋予新的数据值，赋值语句右侧的数据类型同时作用于变量
分支语句：由判断条件决定程序运行方向的语句，使用保留字if elif else构成条件判断的分支结构
函数：根据输入参数产生不同输出的功能过程，比如input eval，类似于数学中的函数

python程序的输入和输出

输入函数input()
从控制台获得用户输入的函数，使用格式：<变量> = input(<提示信息字符串>)，用户输入的信息以字符串类型保存在变量中

输出函数print()
以字符形式向控制台输出结果的函数，使用格式：print(<拟输出字符串或字符串变量>)，字符串类型的一对引号仅在程序内部使用，输出无引导
——格式化：以温度转化代码为例 print(“转换后的温度是{:.2f}F”.format(F))
其中{}表示槽，后续变量填充到槽中
{:.2f}表示将变量C填充到这个位置时取小数点后2位

评估函数eval()
去掉参数最外侧引号并执行余下语句的函数
——eval()函数的基本使用格式
eval(<字符串或字符串变量>)
比如说eval(“1”)执行后的结果时1；eval(“1+2”)执行后的结果是3，再比如我们在温度转换代码中的这段代码也体现该函数的应用eval(Tempstr[0:-1])

python基本图形绘制

深入理解python语言

据统计世界上有600多种编程语言，它可以覆盖由A到Z的全部字母表，举几个非常常用的语言





python语言的特点与优势
——强制可读性
——较少的底层语法元素
——多种编程方式
——支持中文字符
——C代码量的10%
——13万第三方库
——快速增长的计算生态
——避免重复造轮子
——开放共享
——跨操作系统平台

实例2python蟒蛇绘制

import turtle

turtle.setup(650, 350, 200, 200)
turtle.penup()
turtle.fd(-250)
turtle.pendown()
turtle.pensize(25)
turtle.seth(-40)
for i in range(3):
    turtle.circle(40, 80)
    turtle.circle(-40, 80)
turtle.circle(40, 80/2)
turtle.fd(40)
turtle.circle(16, 180)
turtle.fd(40 * 2/3)
turtle.done()

python蟒蛇绘制共这17行左右的代码，有很多的类似
清楚理解这些行代码能够掌握python基本绘图方法
我们可以参考框架结构、逐行分析、逐词理解
当然我们也可以针对代码进行举一反三：比如说我们可以改变蟒蛇的颜色、长度、以及它爬行的方向

模块1：turtle库的使用

## turtle库基本介绍
turtle（我们也称之为海归）库使turtle绘图体系的python实现，是python语言的标准库之一，同时也是入门级的图形绘制函数库
标准库：随解释器直接安装到操作系统中的功能模块
第三方库：需要经过安装才能使用的功能模块
在python中我们经常会遇到库Library、包Package、模块Module，统称为模块
turtle绘图窗体布局
顾名思义，其实这个就是turtle的绘图窗体

也就是turtle的一个画布空间，这个画布空间的最小单位是像素
窗体的左上角是坐标的起始点，我们使用
turtle.setup(width, height, startx, starty)函数来设置窗体的大小及位置，其中这4个参数中后两个四可选的，当然setup不是非必须的，只有当你需要设置窗口大小和窗口位置的时候才需要这个函数
举个例子
如果我们使用turtle.setup(800, 400, 0, 0)，则窗体默认是对应屏幕左上角

如果我们使用turtle.setup(800, 400)，则窗体默认是对应屏幕中间位置

所以，我们看到 这个坐标，其实就是相对于屏幕左上角的相对位置坐标

turtle空间坐标体系

在turtle窗体内部，形成了一个空间坐标体系，包含绝对坐标和海龟坐标两种，对于绝对坐标来讲，turtle也就是海龟最开始在画布的正中心，正中心的坐标就是（0，0），海龟的运行方向向着画布的右侧，所以整个窗体的右侧是X轴，上方向是Y轴，因此构成了一个绝对坐标系，我们选取4个点，那么这四个点根据坐标位置的不同就会有不同的坐标值。这里我们一定要区分，这个坐标值指的是海龟绘制过程中它的画布中间的空间坐标体系，也就是我们最常使用的；它与窗体在屏幕中间的位置的坐标是不同的，去利用空间坐标改变turtle的行进位置，我们可以使用函数，其中很重要的一个函数是goto，goto有两个重要的参数x和y，它指的是任何位置的海龟无论在哪里去到达某个位置的原理，举个例子：

import turtle
turtle.goto(100, 100)
turtle.goto(100, -100)
turtle.goto(-100, -100)
turtle.goto(-100, 100)
turtle.goto(0, 0)
turtle.done()

经过这样一个语句，我们可以在屏幕中绘制这样一个图形，运行之后的结果是

当然，我们把坐标标记上去之后就更加明了了

除了绝对坐标，在turtle空间坐标体系中，也就是说海龟本身从它自身的运动来讲，它看到的世界会是什么样子的呢，对于海龟来讲，无论这个方向是朝向哪个角度的，它都叫前进方向，反方向是后退方向，海龟运行的左侧叫左侧方向，右侧叫右侧方向。因此我们可以使用一些控制海龟的函数，比如，turtle.fd，指的是向海龟的正前方运行，turtle.bk表示的是向反方向运行，turtle.circle表示的是以海龟当前位置左侧的某一个点为圆心，进行曲线运行这些函数也能改变海龟的空间坐标位置，进而实现绘图功能。

turtle的角度坐标体系
我们可以使用turtle.seth(angle)函数来改变当前海龟的运行角度，这里我们需要注意的是seth并不在图像中绘制任何信息，它只是改变行进的方向，angle参数表示的是绝对度数

我们举两个例子：
我们可以使用turtle.seth(45)，那么海龟的朝向就是45°

如果使用turtle.seth(-135)，那么海龟的朝向就是-135度的方向

如果在此基本上，我们继续使用fd函数，它会朝着当前设定的方向直线运行。
此外，为了更好的改变海龟运行的方向，从海龟的坐标角度，对于海龟运行的一个方向，我们可以使用左右的方式，来改变它的运行角度，turtle提供了.left(angle)和right(angle)两个函数，分别让当前海龟向左或者向右去改变运行方向。

我们介绍了这么多函数，接下里我们实现一个小例子，比如我们要画一个大写的Z字，如图：

import turtle
turtle.left(45)
turtle.fd(150)
turtle.right(135)
turtle.fd(300)
turtle.left(135)
turtle.fd(150)
turtle.done()

绘制结果如下：

RGB色彩体系
在我们绘图的过程中，我们都希望自己的绘制的图形是有颜色的
在turtle库中，最常用的色彩体系叫RGB
RGB由三种颜色构成的万物色
——RGB指红蓝绿三个通道的颜色组合
——覆盖视力所能感知的所有颜色
——RGB每色取值范围0-255整数或0-1小数

我们看一些常用的颜色，如下：

我们以purple为例，RGB的整数值分别是160，32，240，它的小数值是0.63, 0.13, 0.94 ,也就是说向系统中告知它的色彩的具体值，我们就能够形成紫色。
turtle库默认采用RGB的小数值来表示颜色，我们当然也可以切换采用整数来表示
我们使用turtle.colormode(mode)来去改变色彩数值的使用
——1.0：RGB小数值模式
——255：RGB整数值模式
我们在使用过程中也可以查阅相关文档获取自己想要的颜色

turtle程序语法元素分析

库引用与import
我们以蟒蛇绘制图形的脚本为例，我们发现前面有很多相似的.turtle样式：

这里就是用了库引用的方式
也就是扩充python程序功能的方式
——使用import保留字完成，采用.()编码风格
import <库名>
<库名>.<函数名>(<函数参数>)
来调用相关功能

当然我们也可以使用from和import两个保留字共同完成这个代码，具体的方式是：
from <库名> import <函数名>
from <库名> import *
<函数名>(<函数参数>)
使用这种方式，再去写代码的时候，就不需要使用turtle.的形式了，直接使用函数名加函数参数来去完成库的使用，具体实现如下：

from turtle import *

setup(800, 400)
penup()
fd(-250)
pendown()
pensize(25)
seth(-40)
for i in range(4):
    circle(40, 80)
    circle(-40, 80)
circle(40, 80/2)
fd(40)
circle(16, 180)
fd(40 * 2/3)
done()

这个虽然简单了，但是其实存在一些问题，我们比较下

import <库名>
<库名>.<函数名>(<函数参数>)，这种方式加起来是新程序中的函数名，

如果使用from <库名> import <函数名>
from <库名> import *
<函数名>(<函数参数>)，这种方式加起来是新程序中的函数名，这里面呢会带来一个问题，如果我们使用第一种方法，就不会出现函数重名的问题；如果使用第二种方法，就会出现可能与程序中用户自定义的函数名冲突，冲突的话，函数就会执行异常。

我们将这两种方式通盘考虑，我们可以使用import和as保留字共同完成这个引用，具体形式如下：
import <库名> as <库别名>
<库别名><函数名>(<函数参数>)
也就是说，给调用的外部库关联一个更短、更适合自己的名字
这对编写程序来讲会带来很多便利
比如说我们将turtle as t执行后如下：

import turtle as t

t.setup(800, 400)
t.penup()
t.fd(-250)
t.pendown()
t.pensize(25)
t.seth(-40)
for i in range(4):
    t.circle(40, 80)
    t.circle(-40, 80)
t.circle(40, 80/2)
t.fd(40)
t.circle(16, 180)
t.fd(40 * 2/3)
t.done()

这种方式我们冗余的代码量最少，同时也防止了函数重名的问题

turtle画笔控制函数

在蟒蛇代码例子中，其中有四行代码与画笔控制函数有关系，分别是
turtle.penup()
turtle.pendown()
turtle.pensize(25)
turtle.pencolor(“purple”)
这里面我们将海龟想象成一个画笔，海龟是一个形象图案，画笔是一个抽象图案，那么画笔控制函数是控制海龟或者控制画笔的一种方式函数。
画笔操作后，一直有效，一般是成对出现

turtle.penup()，别名，turtle.up()，指的是抬起画笔，海龟在飞行
turtle.pendown()，别名，turtle.pd()，指的是落下画笔，海龟在爬行
所以我们说画笔操作是成对出现，你不能只让海龟在天上飞，并不形成绘制图形，这样是不行的，所以让它降下来。
画笔操作后，一直有效，直至下次重新设置
turtle.pensize(width)，别名turtle.width(width)，指的是画笔宽度，海龟的腰围

画笔操作后，一直有效，直至下次重新设置
turtle.pencolor(color)，color为颜色字符串或rgb值，指的是画笔颜色，海龟在涂装
color的参数有三种形式，分别是
——颜色字符串：turtle.pencolor(“purple”)
——RGB的小数值：turtle.pencolor(0.63, 0.13, 0.94)
——RGB的元组值：turtle.pencolor((0.63, 0.13, 0.94))

turtle运动控制函数

在蟒蛇代码例子中，其中有2个函数与运动控制函数有关系，分别是fd()，circle()函数
运动控制函数能控制海龟行进的方向，包括让海归走直线还是走曲线，最常用的函数是：
1、turtle.forward(d) ，别名是turtle.fd(d)，指的是向前行进，海归走直线，参数d：表示的是行进距离，可以为负数
2、另一个函数是turtle.circle(r, extent=None)，指的是根据半径r绘制extent角度的弧形，-r表示的是默认圆心在海龟左侧r距离的位置，-extent：绘制角度，默认是360度整圆，我们举两个例子：

turtle.circle(100)

表示的是半径100，画一个整圆，运行结果是：

turtle.circle(-100, 90)

表示的是半径为-100，角度为90度，运行结果是：

turtle方向控制函数

在蟒蛇代码例子中，其中有1个函数与运动控制函数有关系，它就是seth(angle)。
turtle.setheading(angle)，别名turtle.seth(angle)，表示的是改变行进方向，海龟走角度，其中参数angle表示的是：改变行进方向，海龟走角度。
比如说turtle.seth(45)，表示的是我们将海龟的方向转化为绝对坐标下的45度；turtle.seth(-135)，表示的是我们将海龟的方向转化为绝对坐标下的-135度方向，
除了绝对角度，turtle还提供了控制海龟面对方向的绝对角度和海龟角度，分别是：
turtle.left(angle)，海龟向左转
turtle.right(angle)，海龟向右转
——angle：在海龟当前行进方向上旋转的角度

这边我们需要注意的是，方向控制函数只改变海龟行进的方向，并不实际在绘图上让海龟行动，如果希望海龟行动，需要使用运动控制函数，让海龟走直线或者走曲线。

循环语句和range函数
循环语句是指按照一定次数循环执行一组语句，使用形式为
for <变量> in range(<参数>)
<被循环执行的语句>
举个例子：

for i in range(5):
    print(i)

我们发现打印出来的结果是12345

实际上range（）函数是产生循环技术序列
比如说
range(N)，会产生0到N-1的整数序列，共N个
range(M,N)，会产生M到N-1的整数序列，共N-M个

基本数据类型

数字类型及操作
整数类型：
与数学中的概念一致，可正可负，没有取值范围限制
pow(x,y)函数，计算x的y次方，想算多大算多大
python的整数提供了四种进制表现形式，最常用的就是十进制
比如1010，99，-27
二进制表现形式：以0b或0B开头：0b010,-0B101
八进制表现形式：以0o或0O开头：0o123, -0O456
十六进制表现形式：以0x或0X开头：0x9a,-0X89

浮点数类型及操作
与数学中的实数的概念一致
带有小数点及小数的数字
浮点数取值范围和小数精度都存在限制，但常规计算可以忽略
取值范围数量级约-10的-308次方至10的308次方，精度数量级10的-16次方

浮点数间的运算存在不确定尾数，不是bug
举个例子

a = 0.1 + 0.3
print(a)

b = 0.1 + 0.2
print(b)

运行结果：

那么，0.30000000000000004后面的很多0就是不确定尾数造成的，那么，为什么会产生这样一种情况呢？
我们知道，计算机中所有的数字都是采用二进制进行表示的，具体来说，在python语言中，使用53位二进制来表示一个浮点数的小数部分，那么0.1在计算机中表示的二进制是如下一串010的数字，但是呢我们需要知道，由于计算机中的二进制和十进制之间不存在严格的对等关系，所以0.1在用二进制表示的时候，它是一个无限的小数，计算机只能截取其中的53位无限的接近0.1，但它并不是真正意义上的0.1；那么经过53位二进制小数表示的这么一个浮点数，如果转换成10进制，它就是0.1，但是后面还会有一个很长很长的尾数，只是在计算机中，将浮点数结果输出的时候，只输出了其中的16位小数，之后的并没有输出出来，所以，正是因为二进制表示小数，它可以无限接近一个十进制的小数，但并不完全相同这样一个问题，所以使得0.1和0.2进行计算的时候，它在计算机内部经过二进制转换再经过二进制运算，在经过反向转换，转换成十进制的小数的时候，结果会无限接近0.3，但可能出现一个不确定的尾数，这就是浮点数运算存在不确定尾数的原因

因此，我们可以明确的知道0.1+0.2==0.3的结果是false，那么为了解决这个问题，我们可以使用一个函数，这个函数就是round函数，这个函数的作用就是
round(x,y)表示的是对x进行四舍五入，d是小数截取位数
浮点数间运算及比较用round()函数辅助
不确定尾数一般发生在10的-16次方左右，round()十分有效

print(round(0.1 + 0.2, 1) == 0.3)

运行结果是

浮点数可以采用科学计数法表示
使用字母e或E作为幂的符号，以10为基数，格式如下：
e 表示a*10的b次方
例如：4.3e-3值为0.0043 9.6E5值为9600000.0

复数类型

数值运算操作符



类型间可以进行混合运算，生成结果为“最宽”类型
三种类型存在一种逐渐扩宽或者变宽的关系：整数》浮点数》复数

实例：天天向上的力量
基本问题就是：持续的价值
一年365天，每天进步1‰，累计进步多少呢？
一年365天，每天进步1‰，累计进步多少呢？
我们可以使用如下代码程序进行计算输出

dayup = pow(1.001, 365)
daydown = pow(0.999, 365)
print("向上：{:.2f}, 向下：{:.2f}".format(dayup, daydown))

运行结果如下：

那如果要计算5‰和1%的力量呢，我们可以使用如下代码

dayfactor = 0.005
dayup = pow(1 + dayfactor, 365)
daydown = pow(1-dayfactor, 365)
print("向上：{:.2f}, 向下：{:.2f}".format(dayup, daydown))

运行结果：

如上，我们看到，因为我们引入了变量，所以它的好处是我们只需要修改一处，就能实现我们想要的结果

OK，如果是工作日呢，我们叫做工作日的力量：
一年365天，一周5个工作日，每天进步1%
一年365天，一周2个休息日，每天退步1%
这种工作日的力量如何呢？
如下：

dayfactor = 0.01
dayup = 1.0
for i in range(365):
    if i % 7 in [6, 0]:
        dayup = dayup*(1 - dayfactor)
    else:
        dayup = dayup*(1 + dayfactor)

print("{:.2f}".format(dayup))

运行结果如下：

但是事实上，有时候工作日努力，休息日不努力，很难达到预期效果，所以，这个时候我们就要问了，工作日模式要努力到什么水平，才能与每天努力1%一样？
小伙伴A：一年365天，每天进步1%，不停歇
小伙伴B：一年365天，每周工作5天休息2天，休息日下降1%，要多努力呢？
我们抛开数学思维，我们使用计算机，当然我们可以用一种笨方法进行试错，也就是说给小伙伴一个值，用来计算是否能够匹配上A，如果还不行，就继续增加这个值，也就是让B的努力多一点，直到匹配上A；在这里我们知道，当A一年365天，每天进步1%的话，最终累计进步是37.78，我们整体的思路是，让B持续的努力（让这个数值不断的+0.001），直到不小于37.78，程序代码如下：

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
dfactor = 0.01
while dayUp(dfactor) < 37.78:
    dfactor += 0.001
print("工作日努力的参数是：{:.3f}".format(dfactor))

运行后的结果是：

也就是小伙伴B努力为0.019才能和小伙伴A持平

字符串类型及操作

字符串类型的表示
字符串有2类共4种表示方法，为什么这样表示呢？
——如果希望在字符串中包含双引号或单引号呢？我们可以用如下表现形式
‘这里有个双引号(“)‘或者“这里有个单引号(’)”
——如果希望在字符串中既包括单引号又包括双引号呢？我们可以用如下表现形式
‘’‘这里既有单引号(’)又有双引号(”)’‘’

字符换的序号

我们之前讲过，字符串存在正序和逆序，这个就不多说了，我们来直接说下字符串的切片
我们可以使用[M:N:K]根据步长对字符串切片
——<字符串>[M:N]，M缺失表示至开头，N缺失表示至结尾，举例子：
“0一二三四五六七八九十”，[3]结果是“0一二”
——<字符串>[M:N:K]，根据步长K对字符串切片，举个例子：
“0一二三四五六七八九十”，[1:8:2]结果是“一三五七”
——那，如果我们想让我们的字符串反转，该怎么做呢？
“零一二三四五六七八九十”，[::-1]，结果是“十九八七六五四三二一零”

字符串的特殊字符
转义符
-转义符表达特定字符的本意，使用反斜杠/表示
“这里有个双引号（“)”结果为这里有个双引号（”)
-转义符形成一些组合，表达一些不可打印的含义
”\b"回退“\n"换行（光标移动到下行首）“\r”回车（光标移动到本行首)

字符串操作符

字符串处理函数

一些以函数形式提供的字符串处理功能

字符串的处理方法

常用的八个处理方法如图：

字符串类型的格式化

使用.format()方法实现，具体使用的过程中我们需要使用一个概念，叫槽，槽相当于一个占位信息符，使用{}来表示，它只在字符串中有用，规则就是format中的参数按照顺序填到模板字符串的槽中，如下：

进一步我们可以在槽中指定需要添加的参数的位置，如下，{1}对应了format中的C，其他同理

接下来，我们也可以对format进行格式控制，简单说，在槽的内部，除了槽的参数序号之外，我们可以通过一个冒号，来引导一些参数，控制某一个变量在槽位置的输出格式
python一共提供了六种格式标记，分别是填充、对其、宽度，一个逗号，精度和类型，这六种方式看起来很复杂，也不好记忆

我们简单将上述六种类型分成两类，举个示例

time库的使用

time库基本介绍

处理时间的标准库
计算机时间的表达
提供获取系统时间并格式化输出功能
提供系统级精确计时功能，用于程序性能分析
使用import引入即可
包括三类函数：
——时间获取：time() ctime() gmtime()
——时间格式化：strftime() strptime()
——程序计时：sleep() perf_counter()

时间获取

时间格式化

以合理方式展示出来的方法，我们可以使用gmtime这个函数

程序计时应用

——指的是测量起止动作所经历的过程
——测量时间：perf_counter()，它可以获取计算机中CPU也就是中央处理器以其频率运行的时钟，这个时间往往是以纳秒来计算的，所以这样获取的时间会非常的精准
——产生时间：sleep()

文本进度条问题分析

文本进度条：采用字符串方式打印可以动态变化的文本进度条，需要在一行中逐渐变化
——采用sleep函数模拟
我们简单来个程序，如下：

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("++++++执行开始++++++")

执行之后的结果是

我们看到，我们上面的程序代码实现的结果是没有动态刷新的，接下来我们要实现动态刷新
——刷新的本质：用后打印的字符覆盖之前的字符
——不能换行：print()需要被控制
——要能回退：打印后光标退回到之前的位置\r
刷新的关键就是\r，直接上一段简单的代码

import time

for i in range(101):
    #输出的字符串，输出之前把光标放在行的行首，并且不换行
    print("\r{:3}%".format(i), end="")
    time.sleep(0.1)

运行之后我们可以看到这个数值变化的过程，直到100%停止

那么，我们进一步丰富下，看下效果

import time

scale = 50
start = time.perf_counter()
print("执行开始".center(scale//2, "-"))
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, "+"))

运行后的结果，我们可以看到进度覆盖的变化

程序的控制结构

程序的分支结构

单分支结构

根据判断条件结果而选择不同向前路径的运行方式，使用方式：
if <条件>：
<语句块>
举个例子：

guess = eval(input())
if guess == 99:
    print("猜对了")
    
    
#当然，我们的判断条件也可以直接使用真假来表示
if True:
    print("你真棒")

二分支结构

根据判断条件结果而选择不同向前路径的运行方式，使用方式
if <条件>:
<语句块1>
else:
<语句块2>
举个简单例子：

guess = eval(input())
if guess == 99:
    print("猜对了")
else:
    print("猜错了")


#当然，我们的判断条件也可以直接使用真假来表示
if True:
    print("你真棒")
else:
    print("你也好棒")

多分支结构

"""
if <条件>：
    <语句块1>
elif:
    <语句块2>
    ......
else:
    <语句块2>
"""

条件判断及组合

程序的异常处理

"""
try:
    <语句块1>
except:
    <语句块2>
    
或者使用

try:
    <语句块1>
except <异常类型>：
    <语句块2>
"""

try:
    <语句块1>
except <异常类型>：
    <语句块2>
else:
    <语句块3>
finally:
    <语句块4>
其中，语句块4一定执行，语句块3在不发生异常时执行

实例5：身体质量指数BMI

——指的是对身体质量的刻画
——Body Mass Index
——国际上常用的衡量人体肥胖和健康程度的重要标准，主要用于统计分析
——定义：BMI=体重kg/身高的平方（m的平方）
标准的数值内容如下

height, weight = eval(input("请输入身高\米和体重\公斤，逗号隔开： "))
bmi = weight / pow(height, 2)
print("BMI数值为：{:.2f}".format(bmi))
#国内，国际
who, nat = "", ""
if bmi < 18.5:
    who, nat = "偏廋", "偏廋"
elif 18.5 <= bmi < 24:
    who, nat = "正常", "偏廋"
elif 24 <= bmi < 25:
    who, nat = "偏胖", "正常"
elif 25 <= bmi < 28:
    who, nat = "偏胖", "偏胖"
elif 28 <= bmi < 30:
    who, nat = "肥胖", "偏胖"
elif 30 <= bmi:
    who, nat = "肥胖", "肥胖"
print("BMI指数国内是{}，国际是{}".format(who, nat))

其实总体代码逻辑很简单，我们实现的方式也有很多种，大家也可以自行进行丰富处理

程序的循环结构

遍历循环

"""
使用方式是
for <循环变量> in <>遍历结构:
    <语句块>


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

有哪些应用呢

1、计数循环
for i in range(N):
    <语句块>
——遍历由range()函数产生的数字序列，产生循环

2、计数循环(特定次)
for i in range(M, N, P):
    <语句块>
——遍历由range()函数产生的数字序列，产生循环

'''
3、字符串遍历循环
for c in s:
    <语句块>
——s是字符串，遍历字符串每个字符，产生循环
'''
for i in "python666":
    print(i, end= ',')

'''
4、列表遍历循环
for item in ls:
    <语句块>
——ls是一个列表，遍历其每个元素，产生循环
'''
for item in ["python666", '3', 'aa']:
    print(item, end= ',')

'''
5、文件遍历循环
for line in fi:
    <语句块>
——fi是一个文件标识符，遍历其每行，产生循环
'''

无限循环

由条件控制的循环运行方式，反复执行语句块，直到条件不满足时结束，比如while

循环控制保留字

break——跳出并结束当前整个循环，执行循环后的语句
continue——结束当次循环，继续执行后续次数循环
举几个例子吧

for c in "python":
    if c == "t":
        continue
    print(c, end=",")

for c in "python":
    if c == "t":
        break
    print(c, end=",")

循环的扩展

循环与else

'''
for <循环变量> in <遍历结构>:
    <语句块1>
else:
    <语句块2>
    
    
或者是


while <条件>:
    <语句块1>
else:
    <语句块2>
'''

random库基本介绍

随机数的python库

基本随机数函数：  seed()   random()
扩展随机数函数：  randint()   getrandbits()   uniform()   randrange()  choice()   shuffle()  

圆周率的计算问题分析

圆周率大家都知道，它是一个无理数，而且圆周率有一个近似计算的公式

接下来我们就要想办法用程序实现这个公式

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

当然我们也可以是使用蒙特卡罗方法，蒙特卡罗方法就是圆的面积跟单位方形的面积之比，就构成了圆周率的相关数据，如下图，如果我们向右图中撒点，如果这个点落在圆内部，它就是圆的面积的一部分，如果落在整个的方形中，就是方形面积的一部分，接下来我们用代码简单实现下

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()
    if pow(x**2 + y**2, 0.5) <= 1.0:
        hits += 1
pi = 4*(hits/darts)
end = perf_counter()
print("圆周率的值是：{}".format(pi))
print("所用时间是：{}".format(end-start))

运行之后的结果是：

函数和代码复用

函数的定义与使用

函数的理解和定义
函数是一段代码的表示，是一段具有特定功能的、可重用的语句组；
函数是一种功能的抽象，一般函数表达特定功能；
函数有两个作用：降低编程难度和代码复用
它的表达形式如下：

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

函数定义后，不经过调用，不会被执行

函数的使用及调用过程

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

fact(10)

函数的参数传递
函数可以有参数，也可以没有，但是必须保留括号
函数定义时可以为某些参数指定默认值，构成可选参数
举个例子

def fact(a, b=6):
    c = a+b
    return c


print(fact(10))

其中b就是可选参数
参数传递的两种方式：函数调用时，参数可以按照位置或名称方式传递

函数的返回值
函数可以返回0个或者多个结果
return保留字用来传递返回值
函数可以有返回值，也可以没有，可以有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


print(fact(10))

运行之后的结果是：

我们可以看到运行之后的结果其实是一个元组类型

局部变量和全局变量
其实两者的区别主要在于，局部是函数内部使用的变量，而函数外部，整个程序使用的变量叫全局变量
1、局部变量和全局变量是不同变量，局部变量是函数内部的占位符，与全局变量可能重名但不同，函数运算结束后，局部变量被释放，我们也可以使用global保留字在函数内部使用全局变量

2、局部变量为组合数据类型且未创建，等同于全局变量

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

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

举个例子：

f = lambda x, y : x+y
print(f(10, 15))

运行结果是25

为什么要涉及lambda函数呢？这就涉及了lamda函数的应用，一般在我们编写代码的时候，去定义这个函数，哪怕这个函数只有一行，我们也建议使用def和return方式来定义，要谨慎使用lambda函数，也就是说，lambda函数并不是定义函数的常用形式，它的存在主要用作一些特定函数或方法的参数，有些复杂的函数，它的某一个参数就是一个函数作为一个参数来使用，这种情况下，我们使用lambda函数。

实例：七段数码管绘制

七段数码管：由七段不同线条组成不同的数字，如图所示：

我们要想绘制这个七段数码管，简要的步骤如下：
1、绘制单个数字对应的数码管
2、获得一串数字，绘制对应的数码管
3、获得当前系统时间，绘制对应的数码管


完整代码如下：

import turtle
def drawLine(draw):
    #绘制单段数码管
    turtle.pendown() if draw else turtle.penup()
    turtle.fd(40)
    turtle.right(90)

def drawDigit(digit):
    #绘制七段数码管
    drawLine(True) if digit in [2,3,4,5,6,8,9] else drawLine(False)
    drawLine(True) if digit in [0,1, 3, 4, 5, 6,7, 8, 9] else drawLine(False)
    drawLine(True) if digit in [0, 2, 3, 5, 6, 8, 9] else drawLine(False)
    drawLine(True) if digit in [0, 2, 6, 8] else drawLine(False)
    turtle.left(90)
    drawLine(True) if digit in [0, 4, 5, 6, 8, 9] else drawLine(False)
    drawLine(True) if digit in [0, 2, 3, 5, 6,7, 8, 9] else drawLine(False)
    drawLine(True) if digit in [0, 1, 2, 3, 4, 7, 8, 9] else drawLine(False)
    turtle.left(180)
    turtle.penup()
    turtle.fd(20)
def drawDate(date):
    #获得要输出的数字
    for i in date:
        drawDigit(eval(i))  #通过eval函数将数字变成整数
def main():
    turtle.setup(800, 350, 200, 200)
    turtle.penup()
    turtle.fd(-300)
    turtle.pensize(5)
    drawDate("20240222")
    turtle.hideturtle()
    turtle.done
main()

代码复用与函数递归

我们可以编写的代码当成是一种资源进行抽象。同一份代码在需要时可以被重复使用
在函数定义中，调用函数自身的方式就是递归，其实递归不是程序设计的新名词，它在数学中也广泛存在，比如n的阶乘，在递归中，有两个关键的特征：
——链条：计算过程中存在的递归链条
——基例：存在一个或者多个不需要再次递归的基例
类似于数学中的归纳法
比如说n的阶乘，我们可以使用如下函数实现：

def fact(n):
    if n == 0:
        return 1
    else:
        return n*fact(n-1)


print(fact(4))

调用之后的运行之后的结果显示：

我们可以简单的使用如下图来理解递归调用的整个过程

这种函数递归的思想其实有很多的应用，比如说，字符串的反转，简单实现如下：

def fact(s):
    if s == "":
        return s
    else:
        return fact(s[1:])+s[0]

s = "qwedfc"
print(fact(s))

再比如斐波那契数列：F(n)=F(n-1)+F(n-2)，我们使用函数+分支结构，具体再细分就是分别实现递归基例和递归链条：

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

PyInstaller库的使用

PyInstaller库是将.py源代码转换成无需源代码的可执行文件，它是一个第三方库
官方网站：https://pyinstaller.org/en/stable/
第三方库就是使用前需要额外安装
安装第三方库需要使用pip工具
PyInstaller库常用的参数如下：

实例：科赫雪花小包裹

科赫雪花是一种高大上的分形几何，是一种迭代的几何图形，广泛存在于自然界中，这种典型的曲线我们叫做科赫曲线，也叫做雪花曲线，那么，我们怎么实现用python绘制出科赫曲线呢？
那我们的思想就是：函数+分支
递归链条：线段的组合
递归基例：初识线段
简单代码实现如下：

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

代码运行后如下：

组合数据类型

组合数据类型有三种重要的数据结构，他们分别是：集合类型、序列类型和字典类型

集合类型及操作

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

集合间操作：并、差、交、补

当然，他们还有大于等于小于等于操作符
除了这几种外，python还提供了如下的增强操作符：



那么，集合类型的应用场景有哪些呢？
首先是包含关系的比较，如下：

print("p" in {"p", "y", 123})
print({"p", "y"} >= {"p", "y", 123})

运行之后的结果是：

另外，集合有一个非常典型的数据应用场景，那就是数据去重，数据去重指的是，集合类型所有元素无重复，举个实例：

ls = ["p", "p", "y", "y", 123]
print(set(ls))
lt = list(set(ls))
print(lt)

运行之后：

序列类型及操作

序列类型是python组合数据类型中非常重要的一种类型结构
序列是具有先后关系的一组元素，与集合不同，序列元素之间存在先后关系，
序列是一维元素向量，元素类型可以不同
类似数学中的元素序列
元素间由序号引导，通过下标访问序列的特定元素
序列是一个基类类型，我们一般不直接使用序列，我们一般使用序列衍生出来的几种类型，比如说字符串类型，是序列类型的一种衍生，元组类型是一种衍生，列表类型是一种衍生，但是序列类型的所有操作，在字符串类型、元组类型和列表类型中都是适用的，同时他们也还具有各自的操作能力，所以它是一种基础的数据类型结构
序列类型有一个关于序号的定义，元素存在正向递增的序号的索引的关系和反向递减序号的索引关系，如下：

序列类型有一些通用的操作符，如下：


元组是序列类型的一种扩展
元组是一种序列类型，一旦创建就不能被修改
使用小括号()或tuple()创建，元素间用逗号，分割
可以使用或不适用小括号
元组类型继承了序列类型的全部通用操作
元组因为创建后不能修改，因此没有特殊操作
使用或不使用小括号
列表类型及操作
——列表是一种序列类型，创建后可以随意被更改
——使用方括号[]或list()创建，元素间用逗号，分割
——列表中各元素类型可以不同，无长度限制

在定义列表的时候，如果我们使用了[]或者使用了函数list，那么我们真正的创建了一个列表，但是，如果我们没有使用函数或者[]，仅仅使用赋值，那么，它只是将一段列表赋给了一个新的名字，相当于重新命名。
列表的操作函数和方法：

字典类型及操作

再说字典之前，我们要先理解一点就是映射的概念，映射其实就是一种键（索引）和值（数据）的对应，字典就是其中的一种体现；
在python中我们使用大括号{}和dict()创建，键值对用冒号：表示；

jieba库的使用

jieba库是优秀的中文分词第三方库
——中文文本需要通过分词获得单个的词语
——jieba是优秀的中文分词第三方库，需要额外安装
pip install jieba
具体的原理就是：我们知道词语与词语之间，它都是由汉字组成的，所以简单来说，jieba库是通过中文词库的方式来识别分词的，利用一个中文词库，确定汉字之间的关联概率，形成分词的结果

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

文件和数据格式化

文件的使用

文件时数据的抽象和集合
文件是存储在辅助存储器上的数据序列
文件是数据存储的一种形式
文件展现形态：文本文件和二进制文件，他们只是文件的展示方式，本质上，所有文件都是二进制形式存储的，形式上，所有文件采用两种方式展示

文本文件：
文件是数据的抽象和集合，由单一特定编码组成的文件，如UTF-8编码，由于存在编码，也被看成是存储着的长字符串，适用于例如 .txt文件， .py文件

二进制文件
文件是数据的抽象和集合
直接由比特0和1组成，没有统一字符编码，一般存在二进制0和1的组织结构，即文件格式；适用于例如： .png文件， .avi文件等

文件的打开和关闭

文件处理的步骤就是：打开——操作——关闭
文件的打开：
<变量名> = open(<文件名>, <打开模式>)
这里的文件名指的是文件路径和名称，源文件同目录可省路径，打开模式可以是文本或者二进制

python种提供了如下几种的读和写文件操作

python提供了7种打开模式：

总结如下：

二进制和文本形式文件打开

文件的关闭：
<变量名>close()
一般打开就要有对应的关闭操作

文件内容的读取：

在python中提供如下读取的方法
.read(size=-1),读入全部内容，如果给出参数，读入前size长度
.readline(size=-1),读入一行内容，如果给出参数，读入改行前size长度

遍历全文：方法一
fname = input("请输入要打开的文件名称")
fo = open(fname, "r")
txt = fo.read()
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()
分行读入，逐行处理，对于极大的文件处理非常有效

数据的文件写入

数据组织的维度

一维数据：由对等关系的有序或无序数据构成，采用线性方式组织——对应python中的列表、数组和集合等概念
二维数据：由多个一维数据构成，是一维数据的组合形式
多维数据：由一维或二维数据在新维度上扩展形成
高维数据：仅利用最基本的二元关系展示数据间的复杂结构，比如字典

数据的操作周期，可以简单理解为：存储《》表示《》操作

一维数据的表示：

如果数据间有序：我们可以使用列表表示，它可以有效的表达一维有序数据，我们也可以使用for循环遍历数据，进而对每个数据进行处理
如果数据间无序：我们可以使用集合表示，我们可以使用for循环遍历数据，进而对每个数据进行处理

一维数据的存储：

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

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

当然，我们也可以使用其他方式进行存储，比如说采用其他特殊字符进行分隔存储

一维数据的处理：

也就是将存储的数据读入程序或者说将程序表示的数据写入文件
比如说从分隔的文件中读取数据

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

二维数据的格式化和处理

二维数据的表示

我们一般采用列表类型可以表达二维数据，可以简单理解为嵌套
我们可以使用for循环进行两层遍历

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

wordcloud库基本介绍

优秀的词云展示第三方库，词云以词语为基本单位，更加直观和艺术的展示文本
使用pip install wordcloud进行安装

wordcloud库使用说明

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

w = wordcloud.WordCloud()
#以WordCloud对象为基础
#配置参数、加载文本、输出文件

步骤1：配置对象参数
步骤2：加载词云文本
步骤3：输出词云文件
来吧 简单搞个实例

import wordcloud

c = wordcloud.WordCloud()
c.generate("wordcloud by python")
c.to_file("pythoncloud.png")

运行完成后会生成一个图片，默认400*200像素

那么，从文本变成词云，wordcloud做了哪些事情呢，简单来说，wordcloud大概做了四件事情
首先是将文本以空格进行单词分割
统计：单词出现次数并过滤，将很短的单词过滤掉
字体：根据统计配置字号
布局：颜色环境尺寸等

配置对象参数

图片太多，直接上一个实例：

import wordcloud
txt = "life is short, you need python"
w = wordcloud.WordCloud(background_color='white')
w.generate(txt)
w.to_file("pywcloud.png")

运行之后我们可以看到如下内容：

当然，我们也可以对中文进行分词
举个例子

import jieba
import wordcloud
txt = "程序设计语言是用于书写计算机程序的语言。语言的基础是一组记号和一组规则。根据规则由记号构成的记号串的总体就是语言。在程序设计语言中，这些记号串就是程序。程序设计语言有3个方面的因素，即语法、语义和语用"
w = wordcloud.WordCloud(width = 1000, font_path="msyh.ttc", height=700)
w.generate(" ".join(jieba.lcut(txt)))
w.to_file("pywcloud1.png")

运行之后的数据：

程序设计方法学

体育竞技分析

比赛规则：
双人击球比赛：A&B，回合制，5局3胜
开始时一方先发球，直至判分，接下来胜者发球
球员只能在发球局得分，15分一局

自顶向下：解决复杂问题的有效方法，将一个总问题表达为若干个小问题组成的形式，使用同样方法进一步分解小问题，直到计算机可以很轻松的解决
自底向上：逐步组建复杂系统的有效测试方法，分单元测试，逐步组装，按照自顶向下相反的路径操作，直至，系统各部分以组装的思路都经过测试和验证

程序总体框架及步骤：
步骤1：打印程序的介绍性信息式
步骤2：获得程序运行参数：proA,proB,n
步骤3：利用球员A和B的能力值，模拟n局比赛
步骤4：输出球员 A和B获胜比赛的场次及概率
以上我们可以定义4个函数:
printInfo()
getInputs() 获得用户的输入
simNGames() 模拟n场比赛
prinSummary() 最后输出结果
第一阶段：程序总体框架及步骤

分别开始对这几个函数进行丰富


或者我们直接上代码：

def printInfo():
    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 prinSummary(winsA, winsB):
    n = winsA + winsB
    print("竞技分析开始，共模拟{}场比赛".format(n))
    print("选手A获胜{}场比赛，占比{: 0.1%}".format(winsA, winsA/n))
    print("选手B获胜{}场比赛，占比{: 0.1%}".format(winsA, winsA / n))

def gameOver(a, b):
    return a == 15 or b == 15
def simOneGame(probA, probB):
    scoreA, scoreB = 0, 0
    serving = "A"
    while not gameOver(scoreA, scoreB):
        if serving == "A":
            if random() < probA:
                scoreA += 1
            else:
                serving = "B"
        else:
            if random() < probB:
                scoreB += 1
            else:
                serving = "A"
    return scoreA, scoreB





def simNGames(n, probA, probB):
    winsA, winsB = 0, 0
    for i in range(n):
        scoreA, scoreB = simOneGame(probA, probB)
        if scoreA > scoreB:
            winsA += 1
        else:
            winsB += 1
    return winsA, winsB


def main():
    printInfo()
    probA, probB, n = getInputs()
    winsA, winsB = simNGames(n, probA, probB)
    prinSummary(winsA, winsB)


main()

运行结果是：

python程序设计思维

计算思维与程序设计

第3种人类思维特征
逻辑思维：推理和演绎，数学为代表
实证思维：实验和验证，物理为代表
计算思维：设计和构造，计算机为代表，比如汉诺塔递归
计算思维有很明显的特征，就是抽象和自动化
也就是说要抽象问题的计算过程，利用计算机自动化求解
计算思维是基于计算机的计算思维

抽象问题的计算过程，利用计算机自动化的求解，这是计算思维的核心概念，简单叫抽象加自动化

编程是将计算思维变成显示的手段

计算生态与python语言

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

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

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

比如说python
第三方库>15万个
同一个功能，python会提供2个及以上个库进行实现和竞争
库与库之间依存发展
庞大的社区，更迭迅速

看见更大的python世界

python社区https://pypi.org/

os库的使用

os库提供通用的、基本的操作系统交互功能
os库是python的标准库，包含几百个函数
常用路径操作（os.path）、进程管理(启动系统中其他程序)、环境参数（获得系统软硬件信息）等几

类 os库之路径操作

os.path子库以path为入口，用于操作和处理文件路径
import os.path
import os.path as op
常用的操作函数如下：

os库的进程管理

进程管理指的是，使用我们python编写的程序，去调用其他的外部程序，那么os库提供了一个函数是
os.system(command)
——执行程序或命令command
——在windows系统中，返回值为cmd的调用返回信息

os库的环境参数

环境参数指的是获取或改变操作系统中的环境信息，os库中有一些常用的函数，比如

“第三方库安装脚本”问题分析

需求就是：批量安装第三方库需要人工干预，能否自动安装
自动执行pip逐一根据安装需求安装

假设我们要安装如下第三方库



简单代码示例如下：

import os
libs = {"numpy", "jieba"}
try:
    for lib in libs:
        os.system("pip install"+ lib)
    print("successful")
except:
    print("failed")

简单来说就是取出里面每一个不同的元素，进行遍历，连接相同的部分去执行