Python基本图形绘制
0x1 深入理解Python语言
-
计算机技术演进
1946 - 1981 计算机系统结构时代 计算能力
1981 - 2008 个人pc计算机时代 交互问题 视窗、网络
2008 - 2016 复杂信息系统时代 数据问题
2017 - 人工智能时代 人类的问题
新计算时代
-
不同编程语言的初心和适用对象
C 理解计算机系统结构 关注性能 底层
JAVA 理解主客体关系 跨平台 软件类
C++ 理解主客体关系 大规模程序 核心软件
VB 理解交互逻辑 桌面应用
Python 理解问题求解 各类问题
python 是一个通用语言
0x2 python特点与优势
-
C的10%的代码量
强制可读性
较少的底层语法元素
多种编程方式
支持中文字符
-
强大的第三方库
快速增长的计算生态
避免重复造轮子
开放共享
跨操作系统平台
-
各语言的面向对象
C/C++: Python归Python ,C归C
Java : 针对待定开发和岗位需求
HTML/CSS/JS:不可替代的前端技术,全栈能力
-
超级语言的诞生
粘性整合已有程序,形成庞大的生态
具有庞大的计算生态,可以很容易利用已有代码功能
编程思维是集成开发
完成2+3功能的高级语言
Python是唯一的超级语言
0x3 【实例】python绘制蟒蛇
#PythonDraw.py
import turtle #引入了一个turtle绘图库
turtle.setup(650,350,200,200)
turtle.penup()
turtle.fd(-250)
turtle.pendown()
turtle.pensize(25)
turtle.pencolor("purple")
turtle.seth(-40)
for i in range(4):
turtle.circle(40,80)
turtle.circle(-40,80)
turrle.circle(40,80/2)
turtle.fd(40)
turtle.circle(16,180)
turtle.fd(40*2/3)
turtle.done()
-
举一反三
Python语法元素理解
程序参数的改变 颜色 长度 方向
0x4 模块一 turtle
-
Python函数库之一
turtle库是入门级图形绘制函数库
-
python计算生态 = 标准库 + 第三方库
标准库 :随解释器直接安装到操作系统中的功能模块
第三方库:需要经过安装才能使用的功能模块
库Library、包Package、模块Module ,统称模块
-
turtle的原理
有一直海龟,其实在窗体的正中心
在画布上游走,走过的轨迹形成了绘制的图形
海龟由程序控制,可以变换颜色、改变宽度等
-
模块1 turtle库的使用
turtle的绘图窗体
最小单位是像素
#设置启动窗体的位置和大小
turtle.setup(width,height,startx,starty)
示例:
>>> import turtle
>>> turtle.setup(800,400,0,0) #在左上角显示
>>> import turtle
>>> turtle.setup(800,400) #默认在屏幕中央显示
-
turtle空间坐标体系
绝对坐标 以海龟在中心为原点,做平面坐标系
#示例1:
import turtle
turtle.goto(100,100)
turtle.goto(100,-100)
turtle.goto(-100,-100)
turtle.goto(-100,100)
turtle.goto(0,0)
海龟坐标
turtle.fd(d) #向海龟的正前方向运行
turtle.bk(d) #向海龟的反方向运行
turtle.circle(r,angle) #以海龟左侧某一点为圆心,做曲线运行
r 半径 angle 角度
import turtle
turtle.circle(100,1)
turtle.circle(250,80)
turtle.circle(150,45)
turtle.circle(120,45)
turtle.circle(150,30)
turtle.circle(150,30)
turtle.circle(130,10)
turtle.circle(130,5)
turtle.circle(130,5)
turtle.circle(15,50)
turtle.circle(15,170)
turtle.circle(130,5)
turtle.circle(130,5)
turtle.circle(130,10)
turtle.circle(150,30)
turtle.circle(150,30)
turtle.circle(120,45)
turtle.circle(150,45)
turtle.circle(250,80)
turtle.circle(100,10)
turtle.circle(100,1)
#心形
绝对角度坐标体系,x轴为0度
turtle.seth(angle) #-seth()改变海龟行进方向,但不行进,angle为绝对度数
turtle.left(angle) #改变运行方向
turtle.right(angle) #改变运行方向
-
RGB色彩体系
红黄蓝三通道
RGB小数值、整数值
turtle.colormode(mode) #确定是用小数值还是整数值
1.0 表示小数值模式
255 表示整数值模式
0x5 turtle 程序语法元素分析
库引用与impot
#PythonDraw.py
import turtle #引入了一个turtle绘图库
turtle.setup(650,350,200,200)
turtle.penup()
turtle.fd(-250)
turtle.pendown()
turtle.pensize(25)
turtle.pencolor("purple")
turtle.seth(-40)
for i in range(4):
turtle.circle(40,80)
turtle.circle(-40,80)
turrle.circle(40,80/2)
turtle.fd(40)
turtle.circle(16,180)
turtle.fd(40*2/3)
turtle.done()
turtle.的编程风格
库引用
扩充Python程序功能的方式
使用import保留字完成,采用.()编码风格
import <库名>
#PythonDraw.py
import<库名>
<库名> . <函数名>(<函数参数>)
import用法
使用from和import保留字共同完成
#PythonDraw.py
from <库名> import <函数名>
from <库名> import*
<函数名>(函数参数)
使用上述方式可以不用turtle. 直接函数名加函数参数,如下
#PythonDraw.py
from turtle import* #引入了一个turtle绘图库
setup(650,350,200,200)
penup()
fd(-250)
pendown()
pensize(25)
pencolor("purple")
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更多用法
使用import和as保留字共同完成
#PythonDraw.py
import <库名> as <库别名> # 相当于自定义了一个简便的名字
<库别名> . <函数名>(<函数参数>)
- turtle画笔控制函数
turtle.penup() #抬起画笔,海龟在飞行
turtle.pendown() #落下画笔,海龟在爬行
turtle.pensize(25) # 设置画笔宽度 别名 turtle.width(width)
turtle.pencolor("purple") #修改画笔颜色,参数字符串小写
#pencolor(color)的参数可以有三种形式
颜色字符串 turtle.pencolor("purple")
RGB的小数值 turtle.pencolor(0.62,0.42,0.13)
RGB的元组值 turtle.pencolor((0.62,0.42,0.13))
将海龟想象为画笔
画笔操作后一直有效,一般成对出现
turtle运动控制函数
控制海龟行进方向:走直线或者曲线
#向前进,走直线
turtle.forward(d) 别名 turtle.fd(d)
d :行进距离,可以为负数,倒退行进
#根据半径r绘制extent角度的弧形
turtle.circle(r,extent=None)
r:默认圆心在海龟左侧r距离的位置
extent :绘制角度,默认是360度整圆
turtle方向控制函数
控制海龟面对方向:绝对角度和海龟角度
#当前海龟方向,改变为某一角度方向
turtle.setheading(angle) 别名 turtle.seth(angle)
angle:改变行进绝对方向,海龟走角度
#控制海龟向左转或向右转
turtle.left(angle)
turtle.right(angle)
angle: 在海归当前行进方向上旋转的角度
基本循环语句与range函数
循环语句
for<执行次数> in range(<要执行多少次>):
<被循环执行的语句>
#range的参数是循环的次数
#for in 之间的变量是每次执行的计数,0到<执行次数> - 1
示例:
for i in range(5):
print(i)
输出:
0
1
2
3
4
#输出print("Hello:",i) 中的逗号在输出时显示为空格
range函数
#产生循环计数序列
range(N) 即产生0到N-1的整数序列,共N个
如:range(5),则产生0,1,2,3,4
range(M,N) 即产生M到N-1的整数序列,共N-M个
如:range(2,5),则产生2,3,4
- python蟒蛇绘制代码分析
#PythonDraw.py
import turtle #引入了一个turtle绘图库
turtle.setup(650,350,200,200) #设立了一个窗体
turtle.penup() #将画笔抬起
turtle.fd(-250) #海龟倒退250
turtle.pendown() #放下画笔
turtle.pensize(25) #设置画笔宽度
turtle.pencolor("purple") #设置画笔颜色
turtle.seth(-40) #设置画笔起始角度为-40度
for i in range(4): #利用循环绘制路径,循环4次
turtle.circle(40,80) #先以半径为40像素,绘制80度
turtle.circle(-40,80) #再以反向40像素为半径,绘制80度
turrle.circle(40,80/2) #最后以40像素为半径,绘制40度
turtle.fd(40) #再向前走40像素
turtle.circle(16,180) #以16像素为半径,画180度
turtle.fd(40*2/3) #当前方向向前走80/3像素
turtle.done() #手动退出,删掉即自动退出
python基本数据类型
0x1数字类型及操作
整数类型
与数学整数概念一致
pow(x,y) 计算x的y次方,想算多大算多大
四种进制表示:
十进制:1010、99、-217
二进制:0b或0B开头 : 0b0101,-0B1010
八进制:以0o或0O开头: 0o123,0O456
十六进制:以0x或0X开头:0x9a,- 0X89
浮点数类型
与数学实数概念一致
浮点数取值范围和小鼠精度都存在限制
取值范围数量级约±10的308次方,精度数量约10的-16
浮点数之间的运算存在不确定尾数,不是bug
>>> 0.1 +0.2
0.30000000000000004
-
存在不确定尾数的原因
计算机中是二进制存储的,二进制表示小数可以无限接近0.1,但永远不完全相同
所以十进制表示的0.1加0.2结果无限接近0.3,但可能存在尾数
round函数
round(x,d): 对x四舍五入,d是小数截取位数
示例:
>>> round(0.1 + 0.2,1) == 0.3
True
#浮点数间运算及比较用round()函数辅助
#不确定位数一般在10的-16次方左右,固该函数有效
科学计数法表示浮点数
格式e表示 a*10的b次方
例如:4.3e-3 值为0.0043
复数类型
x的平方 = -1 ,那么x的值是?
定义 : j = ( − 1 ) j=\sqrt{(-1)} j=(−1)
a + bj 被称为复数,其中a为实部,b是虚部
>>> z = 10 + 10j #复数类型
>>> print(z)
(10+10j)
>>> a = 10
>>> print(a)
10
数值运算操作符
- 加减乘除与C相同
#特别注意
x / y #结果是浮点数除法
x // y #结果是整数无小数除法,直接约去小数,不四舍五入
示例:
>>> 3 // 4
0
>>> 7/2
3.5
>>> 7//2
3
>>> 19 / 5
3.8
>>> 19//5
3
- 模运算(取余运算)与C相同
x % y
- 幂运算
x ** y #表示x的y次幂,当y是小数时,做开方运算
示例:
>>> 2 ** 10
1024
>>> 49 ** 0.5
7.0
- 二元操作符对应的增强赋值操作
x op=y 相当于 x = x op y
#op 表示二元操作符,如 +、 -、 *、 /、 //、%、**
#与C中的 += 意思相同
不同数据类型间可以混合运算,生成结果为“最宽”类型
注意可能会产生不确定的尾数
数值运算函数
函数及使用 | 描述 |
---|---|
abs(x) | 绝对值,x的绝对值 |
divmod(x,y) | 商余,(x//y,x%y),同时输出商和余数 |
pow(x,y,z) | 幂余运算,(x**y)%z,参数z可省略 |
round(x,d) | 四舍五入,d是保留小数位数,默认为零 |
max(a,b,c,…) | 返回数字序列中最大值 |
min(a,b,c,…) | 返回数字序列最小值 |
>>> abs(-1)
1
>>> divmod(10,3)
(3, 1)
>>> pow(2,10,10)
4
>>> pow(2,10)
1024
>>> round(10.12345,4)
10.1235
>>> max(1,9,5,2,6)
9
>>> min(3,2,4,5,1,23)
1
数字类型转换函数
函数及使用 | 描述 |
---|---|
int(x) | 转变为整型,取整数部分 |
float(x) | 转变为浮点数,增加小数部分 |
complex(x) | 将x变成复数,增加虚数部分 |
>>> int(4.35)
4
>>> float(1.23)
1.23
>>> float(1)
1.0
>>> complex(5)
(5+0j)
0x2 【实例】 天天向上的力量
基本问题,持续价值
1.01的365次方
0.99的365次方
问题1 千分之一的力量
1.001的365次方
0.999的365次方
#DaydayupQ1.py
x = pow(1.001,365)
y = pow(0.999,365)
print("向上:{:.2f},向下:{:.2f}".format(x,y))
输出:
向上:1.44,向下:0.69
问题2 千分之五和1%
#DaydayupQ1.py
dayfactor = 0.005
dayup = pow(1 + dayfactor,365)
daydown = pow(1 - dayfactor,365)
print("向上:{:.2f},向下:{:.2f}".format(dayup,daydown))
输出:
向上:6.17,向下:0.16
#DaydayupQ1.py
dayfactor = 0.01
dayup = pow(1 + dayfactor,365)
daydown = pow(1 - dayfactor,365)
print("向上:{:.2f},向下:{:.2f}".format(dayup,daydown))
输出:
向上:37.78,向下:0.03
问题3 工作日力量
一周 5天工作日每天提升1%,休息日2天每天退步1%
#DaydayupQ3.py
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倍
结论:问题3的结果4.63倍介于,问题1的365天每天千分之一的1.44倍和问题2的365每天千分之五6.17倍之间。
问题4 工作日的努力
A 每天1%
B 工作日提升x,休息日下降1%
问当x为多少时,A与B的提升相等?
#DaydayupQ4.py
#def用来定义函数,占位符df是dayfactor的简写。
def dayUP(df): #函数dayUP
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
#根据df参数不同,函数内部会返回对应的结果,返回dayup
dayfactor = 0.01
while dayUP(dayfactor) < 37.78: #调用了上述函数
dayfactor += 0.001
print("工作日的努力参数是:{:.3f}".format(dayfactor)) #输出比上的结果
输出:
工作日的努力参数是:0.019
结论:工作日要努力约2%,才能跟不休息每天学1%的人相同
0x3 字符串类型及操作
字符串
由一对 ‘ ’ 或 ” “ 包含的一连串字符
可以索引” “[ ]
字符串有四种表示方法
前两种
"请输如带有符号的温度值" 或者 'C'
后两种
''' Python
语言 '''
或者
""" Python
语言 """
#注释也是''' ''',是因为没有被作用的字符串则被认为是注释
如果要在字符串内部表示 “ 则用 ‘ 构成字符串
如果要在字符串内部表示 ’ 则用 “ 构成字符串
如果 ‘ 和 ” 都要在字符串内部表示,则用 ’‘’ 构成字符串
索引 、 切片
切片高级用法
<字符串>[M:N] ,M缺失变送至开头,缺失表示至结尾
>>> "这是一个字符串"[:3]
'这是一'
<字符串>[M:N:K],使用[M:N:K]根据步长对字符串切片,k表示每移几位进行切片
>>> "123456789"[1:7:2]
'246'
>>> "123456789"[::-1] #可实现逆序的效果
'987654321'
更多测试
>>> "123456789"[2::-1]
'321'
>>> "123456789"[0::-1]
'1'
>>> "123456789"[:5:-1]
'987'
转义符 \
转义符表达特定字符的本意
>>>"这里有个双引号\" "
'这里有个双引号" '
\b 回退 \n换行 \r回车
字符串操作符
操作符及使用 | 描述 |
---|---|
x + y | 连接两个字符串x和y |
n *x | 复制n次字符串x |
x in s | 如果x是s的子串,返回true,否则返回False |
获取星期字符串
#WeekNamePrintV1.py
weekStr = "星期一星期二星期三星期四星期五星期六星期日"
weekID = eval(input("请输入星期数字(1-7):"))
pos = (weekId - 1) * 3
print(weekStr[pos:pos+3])
改进版
#WeekNamePrintV1.py
weekStr = "一二三四五六日"
weekID = eval(input("请输入星期数字(1-7):"))
print("星期"+weekStr[weekID])
字符串处理函数
函数及使用 | 描述 |
---|---|
len(x) | 返回字符串的长度 |
str(x) | 返回任意类型x对应的字符串形式,与eval()相对应 |
hen(x) 或oct(x) | 整数x的十六进制或八进制小写形式字符串 |
chr(u) | u为Unicode编码,返回其对应的字符 |
ord(x) | x为字符,返回其对应的Unicode编码 |
Unicode编码
python字符串的编码方式,适用于各国语言
从0到1114111(0x10FFFF)空间,每个编码对应一个字符
#示例1
>>> "1 + 1 = 2 " + chr(10004)
'1 + 1 = 2 ✔'
#示例2
>>> chr(9801)
'♉'
>>> str(ord("♉"))
'9801'
十二星座
>>> for i in range(12):
print(chr(9800 +i)) #无end参数时换行
♈
♉
♊
♋
♌
♍
♎
♏
♐
♑
♒
♓
>>> for i in range(12):
print(chr(9800 +i), end = "") #end参数 = 空时,不换行
♈♉♊♋♌♍♎♏♐♑♒♓
字符串处理方法
方法
“方法”在编程中是专有名词
方法特指 a . b( ) 风格中的函数b( )
方法本身也是函数,但与a有关,b是a提供的函数
-
面向对象中
a为对象,b为对象能够提供的功能
方法必用 . 的方式执行
一些以方法形式提供的字符串处理功能
方法及使用 | 描述 |
---|---|
str . lower()或str.upper() | 返回字符串的副本,全部字符小写/大写 |
str . split(sep) | 返回一个列表,由str根据sep被分隔的部分组成 |
str . count(sub) | 返回子串sub在str中出现的次数 |
str.replace(old,new) | 返回字符串str副本,所有old子串被替换为new |
str.center(width[,fillchar]) | 字符串str根据宽度with居中,fillchar可选,宽度是新的整个字符串的宽度 |
str.strip(chars) | 从str中去掉在其左侧和右侧chars中列出的字符 |
str.join(iter) | 在iter变量除最后元素外每个元素后增加一个str |
>>> "abcdefg".upper()
'ABCDEFG'
>>> "a,b,c,d,e,f,g".split(",") #默认是空格
['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> "an apple is bad".count("a")
3
>>> "abcdefg".split("c")
['ab', 'defg']
>>> "python".replace("n","n123.io")
'python123.io'
>>> "an".center(10,"=")
'====an===='
>>> "=python =".strip(" =np")
'ytho'
>>> ",".join("12345")
'1,2,3,4,5'
字符串类型的格式化
格式化是对字符串进行格式表达的方式
<模板字符串>.format(<逗号分隔的参数>)
槽
一对 { } 表示槽
不同的对应位置有不同的输出
示例:
“{}:计算机{}的CPU占用率为{}%”.format("2018-10-10","C",10) #其中有三个槽,与C中输出的位置对应相同,默认按顺序一一对应
“{0}:计算机{1}的CPU占用率为{2}%”.format("2018-10-10","C",10) #对应位置
>>> print("{0}:计算机{1}的CPU占用率为{2}%".format("2018-10-10","C",10))
2018-10-10:计算机C的CPU占用率为10%
>>> print("{1}:计算机{0}的CPU占用率为{2}%".format("2018-10-10","C",10)) #交换后,输出也交换
C:计算机2018-10-10的CPU占用率为10%
>>> print("{}:计算机{}的CPU占用率为{}%".format("2018-10-10","C",10)) #默认按顺序对应
2018-10-10:计算机C的CPU占用率为10%
format()方法的格式控制
类似于C输出的格式控制
: | <填充> | <对齐> | <宽度> | <,> | < . 精度> | <类型> |
---|---|---|---|---|---|---|
引导符号 | 用于填充的单个字符 | < 左对齐 ,> 右对齐,^ 居中对齐 | 槽设定的输出宽度 | 数字的千位分隔符 | 浮点数小数精度或字符串最大输出长度 | 整数类型b,c,d,o,x,X浮点数类型e,E,f,% |
示例:
>>> "{0:=^20}".format("PYTHON")
'=======PYTHON======='
>>> "{1:=^20}".format("PYTHON","ABC")
'========ABC========='
>>> "{1:=<20}".format("PYTHON","ABC")
'ABC================='
>>> "{1:20}".format("PYTHON","ABC")
'ABC ' #默认填充空格
>>> "{0:,.2f}".format(1234567.8910)
'1,234,567.89'
>>> "{0:b},{0:c},{0:d},{0:o},{0:x},{0:X}".format(425) #不同进制表示
'110101001,Ʃ,425,651,1a9,1A9'
>>> "{0:e},{0:E},{0:f},{0:%}".format(3.14)
'3.140000e+00,3.140000E+00,3.140000,314.000000%'
中文可以放到字符串中,不能在语法中出现
0x4 time库的使用
time库基本介绍
python中的标准库
计算机时间的表达
提供获取系统时间并格式化输出功能
提供系统级精确计时功能没用于程序性能分析
import time
time.<b>()
#包括三类函数
#时间获取: time() ctime() gmtime()
#时间格式化: strftime() strtime()
#程序计时: sleep(), perf_counter()
时间获取
函数 | 描述 |
---|---|
time() | 获取当前时间戳,即计算机内部时间值 |
ctime() | 获取当前时间,格式是,星期、‘月、日、时间、年份’ |
gmtime() | 获取当前时间,表示为计算机程序可编程利用的时间格式 |
>>> time.time()
1610244498.6032174 #表示从1970年1月1日0:00 开始至现在时刻的以秒为单位的数值
>>> time.ctime()
'Sun Jan 10 10:11:36 2021'
>>> time.gmtime()
time.struct_time(tm_year=2021, tm_mon=1, tm_mday=10, tm_hour=2, tm_min=29, tm_sec=12, tm_wday=6, tm_yday=10, tm_isdst=0)
时间格式化
类似字符串格式化,需要展示模板
函数 | 描述 |
---|---|
strftime(tpl,ts) | tpl是格式化模板字符串,用来定义输出效果,ts是计算机内部时间类型变量 |
%Y | 年份 0000~9999 |
%m | 月份 01~12 |
%B | 月份名称 January ~December |
%b | 月份名称缩写 Jan ~ Dec |
%d | 日期 01~31 |
%A | 星期 Monday ~ Sunday |
%a | 星期缩写 Mon ~ Sun |
%H | 小时 00 ~ 23 |
%I | 小时 01 ~ 12 |
%p | 上下午 AM,PM |
%M | 分钟 00 ~ 59 |
%S | 秒钟 00 ~ 59 |
strptime(str,tpl) | str是字符串形式的时间值,tpl是格式化模板字符串,用来定义输入效果 |
>>> time.strftime("%Y-%m-%d %H:%M:%S",t)
'2021-01-10 02:37:19'
>>> time.strptime('2021-01-10 02:37:19',"%Y-%m-%d %H:%M:%S")
time.struct_time(tm_year=2021, tm_mon=1, tm_mday=10, tm_hour=2, tm_min=37, tm_sec=19, tm_wday=6, tm_yday=10, tm_isdst=-1)
程序计时运用
测量起止动作所经历的时间
测量时间函数:perf_counter()
产生时间函数:sleep()
函数 | 描述 |
---|---|
perf_counter() | 返回一个CPU级别的精确时间计数值,单位为秒。由于这个计数值起点不确定,连续调用差值才有意义 |
sleep(s) | s 拟休眠时间,单位是秒,可以是浮点数 |
示例:
import time
>>> start = time.perf_counter()
>>> end = time.perf_counter()
>>> end - start
21.654742400000032
>>> def wait():
time.sleep(3.3)
>>> wait() # 这里则表示调用函数wait,使程序等待3.3秒再结束
0x5 【实列】 文本进度条
文本进度条问题要求:
采用字符串方式打印可以动态变化的文本进度条
进度条需要能在一行中逐渐变化
采用sleep()模拟一个持续进度
####初步结构
#TExtPorBarV1.py
import time
scale = 10
print("------执行开始------")
for i in range(scale +1):
a = '*' * i
b = '.' * (scale - i)
c = (i/scale)*100
print("{:^3.0f}%[{}->{}]".format(c,a,b))
time.sleep(0.1)
print("------执行结束------")
输出
文本进度条的单行动态刷新
刷新的本质是:用后打印的字符覆盖之前的字符
不能换行:print()需要被控制
要能回退:打印后光标退回到之前的位置\r
#TextProBarV1.py
import time
for i in range(101):
print("\r{:3}%".format(i),end="")
time.sleep(0.1)
输出:
IDLE输出会将每一个结果输出,用cmd命令提示符运行即可看到效果
完整文本进度代码
#TExtPorBarV1.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,'-'))
time.sleep(1)
输出:
cmd输出
举一反三
比较不同排序方法的时间
进图条扩展
在任何运行时间需要较长的程序中增加进度条
在任何希望提高用户体验的应用中增加进度条
进度条是人机交互的纽带之一
文本进度条的不同设计函数
结论:开始慢,后来速度随着进度增加的函数更符合人的心理期望