（三）Python函数库与数据类型

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=\sqrt{(-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输出

举一反三

比较不同排序方法的时间

进图条扩展

在任何运行时间需要较长的程序中增加进度条

在任何希望提高用户体验的应用中增加进度条

进度条是人机交互的纽带之一

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

结论：开始慢，后来速度随着进度增加的函数更符合人的心理期望