数字类型及操作
- 整数类型
- 数值运算函数
整数类型
与数学中整数的概念一致
- 可正可负，没有取值范围限制
- pow(x,y)函数：计算 xy，想算多大算多大
>>> pow(2,100)
1267650600228229401496703205376
整数类型
4种进制表示形式
- 十进制：1010, 99, -217
- 二进制，以0b或0B开头：0b010, -0B101
- 八进制，以0o或0O开头：0o123, -0O456
- 十六进制，以0x或0X开头：0x9a, -0X89
关于Python整数，就需要知道这些。
- 整数无限制 pow()
4种进制表示形式
浮点数类型
与数学中实数的概念一致
- 带有小数点及小数的数字
- 浮点数取值范围和小数精度都存在限制，但常规计算可忽略
- 取值范围数量级约-10308至10308，精度数量级10-16
浮点数类型
不确定尾数
浮点数类型
浮点数间运算存在不确定尾数，不是bug
53位二进制表示小数部分，约10-16
0.00011001100110011001100110011001100110011001100110011010 (二进制表示)
0.1000000000000000055511151231257827021181583404541015625 (十进制表示)
二进制表示小数，可以无限接近，但不完全相同
0.1 + 0.2
结果无限接近0.3，但可能存在尾数
浮点数类型
浮点数间运算存在不确定尾数
>>> 0.1 + 0.2 == 0.3
False
>>> round(0.1+0.2, 1) == 0.3
True
浮点数类型
浮点数间运算存在不确定尾数
- round(x, d)：对x四舍五入，d是小数截取位数
- 浮点数间运算及比较用round()函数辅助
- 不确定尾数一般发生在10-16左右，round()十分有效
浮点数类型
浮点数可以采用科学计数法表示
- 使用字母e或E作为幂的符号，以10为基数，格式如下：
<a>e<b> 表示 a*10b
- 例如：4.3e-3 值为0.0043 9.6E5 值为960000.0
关于Python浮点数，需要知道多些。
- 取值范围和精度基本无限制
- 运算存在不确定尾数 round()
- 科学计数法表示
复数类型
与数学中复数的概念一致
如果x2 = -1，那么x的值什么？
- 定义 j = −� ，以此为基础，构建数学体系
- a+bj 被称为复数，其中，a是实部，b是虚部
复数类型
复数实例
z = 1.23e-4+5.6e+89j
- 实部是什么？ z.real 获得实部
- 虚部是什么？ z.imag 获得虚部
数值运算操作符
操作符是完成运算的一种符号体系
| 操作符及使用 |
描述 |
| x + y |
加，x与y之和 |
| x – y |
减，x与y之差 |
| x * y |
乘，x与y之积 |
| x / y |
除，x与y之商 10/3结果是3.3333333333333335 |
| x // y |
整数除，x与y之整数商 10//3结果是3 |
数值运算操作符
操作符是完成运算的一种符号体系
| 操作符及使用 |
描述 |
| + x |
x本身 |
| - y |
x的负值 |
| x % y |
余数，模运算 10%3结果是1 |
| x ** y |
幂运算，x的y次幂，xy |
| 当y是小数时，开方运算 10**0.5结果是 �� |
数值运算操作符
二元操作符有对应的增强赋值操作符
| 增强操作符及使用 |
描述 |
|
x op= y |
即 x = x op y，其中，op为二元操作符 |
| x += y x -= y x *= y x /= y x //= y x %= y x **= y |
|
| >>> x = 3.1415 >>> x **= 3 # 与 x = x **3 等价 31.006276662836743 |
数字类型的关系
类型间可进行混合运算，生成结果为"最宽"类型
- 三种类型存在一种逐渐"扩展"或"变宽"的关系：
整数 -> 浮点数 -> 复数
- 例如：123 + 4.0 = 127.0 (整数+浮点数 = 浮点数)
数值运算函数
一些以函数形式提供的数值运算功能
| 函数及使用 |
描述 |
| abs(x) |
绝对值，x的绝对值 abs(-10.01) 结果为 10.01 |
| divmod(x,y) |
商余，(x//y, x%y)，同时输出商和余数 divmod(10, 3) 结果为 (3, 1) |
| pow(x, y[, z]) |
幂余，(x**y)%z，[..]表示参数z可省略 pow(3, pow(3, 99), 10000) 结果为 4587 |
数值运算函数
一些以函数形式提供的数值运算功能
| 函数及使用 |
描述 |
| round(x[, d]) |
四舍五入，d是保留小数位数，默认值为0 round(-10.123, 2) 结果为 -10.12 |
| max(x1,x2, … ,xn) |
最大值，返回x1,x2, … ,xn中的最大值，n不限 max(1, 9, 5, 4 3) 结果为 9 |
| min(x1,x2, … ,xn) |
最小值，返回x1,x2, … ,xn中的最小值，n不限 min(1, 9, 5, 4 3) 结果为 1 |
数值运算函数
一些以函数形式提供的数值运算功能
| 函数及使用 |
描述 |
| int(x) |
将x变成整数，舍弃小数部分 int(123.45) 结果为123； int("123") 结果为123 |
| float(x) |
将x变成浮点数，增加小数部分 float(12) 结果为12.0； float("1.23") 结果为1.23 |
| complex(x) |
将x变成复数，增加虚数部分 complex(4) 结果为 4 + 0j |
实例3: 天天向上的力量
"天天向上的力量"问题分析
基本问题：持续的价值
- 一年365天，每天进步1%，累计进步多少呢？
1.01365
- 一年365天，每天退步1%，累计剩下多少呢？
0.99365
需求分析
天天向上的力量
-
- 数学公式可以求解，似乎没必要用程序
- 如果是"三天打鱼两天晒网"呢？
- 如果是"双休日又不退步"呢？
"天天向上的力量"第一问
问题1： 1‰的力量
- 一年365天，每天进步1‰，累计进步多少呢？
1.001365
- 一年365天，每天退步1‰，累计剩下多少呢？
0.999365
天天向上的力量
问题1： 1‰的力量
#DayDayUpQ1.py
dayup = pow(1.001, 365) daydown = pow(0.999, 365)
print("向上：{:.2f}，向下：{:.2f}".format(dayup, daydown))
编写上述代码，并保存为DayDayUpQ1.py文件
天天向上的力量
1‰的力量，接近2倍，不可小觑哦
"天天向上的力量"第二问
天天向上的力量
问题2： 5‰和1%的力量
- 一年365天，每天进步5‰或1%，累计进步多少呢？
1.005365 1.01365
- 一年365天，每天退步5‰或1%，累计剩下多少呢？
0.995365 0.99365
天天向上的力量
问题2： 5‰和1%的力量
#DayDayUpQ2.py
dayfactor = 0.005
dayup = pow(1+dayfactor, 365) daydown = pow(1-dayfactor, 365)
使用变量的好处：一处修改即可
print("向上：{:.2f}，向下：{:.2f}".format(dayup, daydown))
编写上述代码，并保存为DayDayUpQ2.py文件
天天向上的力量
问题2： 5‰和1%的力量
>>> (5‰运行结果)
向上：6.17，向下：0.16
1.005365 = 6.17
0.995365 = 0.16
>>> (1%运行结果)
向上：37.78，向下：0.03
1.01365 = 37.78
0.99365 = 0.03
5‰的力量，惊讶！ 1%的力量，惊人！
"天天向上的力量"第三问
天天向上的力量
问题3： 工作日的力量
-
- 一年365天，一周5个工作日，每天进步1%
- 一年365天，一周2个休息日，每天退步1%
- 这种工作日的力量，如何呢？
1.01365 (数学思维) for..in.. (计算思维)
天天向上的力量
#DayDayUpQ3.py dayup = 1.0
dayfactor = 0.01
for i in range(365):
if i % 7 in [6,0]:
采用循环模拟365天的过程抽象 + 自动化
dayup = dayup*(1-dayfactor)
else:
dayup = dayup*(1+dayfactor)
print("工作日的力量：{:.2f} ".format(dayup))
天天向上的力量
问题3： 工作日的力量
1.001365 = 1.44
1.005365 = 6.17
1.01365 = 37.78
尽管提高1%，但介于1‰和5‰的力量之间
"天天向上的力量"第四问
天天向上的力量
问题4： 工作日的努力
- 工作日模式要努力到什么水平，才能与每天努力1%一样？
- A君: 一年365天，每天进步1%，不停歇
- B君: 一年365天，每周工作5天休息2天，休息日下降1%，要多努力呢？
for..in.. (计算思维) def..while.. ("笨办法"试错)
天天向上的力量
问题4： 工作日的努力
B君(工作日-x%) A君(365-1%)
把x再加点儿
比不过
比较一下
比上了
输出x
def..while..
("笨办法"试错)
#DayDayUpQ4.py
def dayUP(df): dayup = 1
天天向上的力量
根据df参数计算工作日力量的函数
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
参数不同，这段代码可共用
def保留字用于定义函数
while保留字判断条件是否成立
条件成立时循环执行
print("工作日的努力参数是：{:.3f} ".format(dayfactor))
天天向上的力量
问题4： 工作日的努力
>>> (运行结果)
工作日的努力参数是：0.019
1.01365 = 37.78 1.019365 = 962.89
工作日模式，每天要努力到1.9%，相当于365模式每天1%的一倍！
天天向上的力量
GRIT：perseverance and passion for long-term goals
1.01365 = 37.78 1.019365 = 962.89
- GRIT，坚毅，对长期目标的持续激情及持久耐力
- GRIT是获得成功最重要的因素之一，牢记天天向上的力量
"天天向上的力量"举一反三
#DayDayUpQ3.py dayup = 1.0
dayfactor = 0.01
for i in range(365):
if i % 7 in [6,0]:
for..in.. (计算思维)
dayup = dayup*(1-dayfactor)
else:
dayup = dayup*(1+dayfactor)
print("工作日的力量：{:.2f} ".format(dayup))
#DayDayUpQ4.py
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
def..while..
("笨办法"试错)
print("工作日的努力参数是：{:.3f} ".format(dayfactor))
举一反三
天天向上的力量
- 实例虽然仅包含8-12行代码，但包含很多语法元素
- 判断条件循环、次数循环、分支、函数、计算思维
- 清楚理解这些代码能够快速入门Python语言
举一反三
问题的变化和扩展
- 工作日模式中，如果休息日不下降呢？
- 如果努力每天提高1%，休息时每天下降1‰呢？
- 如果工作3天休息1天呢？
举一反三
问题的变化和扩展
- "三天打鱼，两天晒网"呢？
- "多一份努力"呢？ (努力比下降多一点儿）
- "多一点懈怠"呢？（下降比努力多一点儿）
字符串类型及操作
- 字符串类型的表示
- 字符串类型的格式化
字符串类型的表示
字符串
由0个或多个字符组成的有序字符序列
- 字符串由一对单引号或一对双引号表示
"请输入带有符号的温度值: "或者 'C'
- 字符串是字符的有序序列，可以对其中的字符进行索引
"请" 是 "请输入带有符号的温度值: " 的第0个字符
字符串
字符串有 2类共4种 表示方法
- 由一对单引号或双引号表示，仅表示单行字符串
"请输入带有符号的温度值: "或者 'C'
- 由一对三单引号或三双引号表示，可表示多行字符串
''' Python
语言 ''' Q: 老师老师，三引号不是多行注释吗？
Python语言为何提供 2类共4种 字符串表示方式？
字符串有 2类共4种 表示方法字符串
- 如果希望在字符串中包含双引号或单引号呢？
'这里有个双引号(")' 或者 "这里有个单引号(')"
- 如果希望在字符串中既包括单引号又包括双引号呢？
''' 这里既有单引号(')又有双引号 (") '''
字符串的序号
正向递增序号 和 反向递减序号
反向递减序号
-12 -11-10 -9 -8 -7 -6 -5 -4 -3 -2 -1
3 4 5 6 7 8 9 10 11
正向递增序号
字符串的使用
使用[ ]获取字符串中一个或多个字符
- 索引：返回字符串中单个字符 <字符串>[M]
"请输入带有符号的温度值: "[0] 或者 TempStr[-1]
- 切片：返回字符串中一段字符子串 <字符串>[M: N]
"请输入带有符号的温度值: "[1:3] 或者 TempStr[0:-1]
字符串切片高级用法
使用[M: N: K]根据步长对字符串切片
- <字符串>[M: N]，M缺失表示至开头，N缺失表示至结尾
"〇一二三四五六七八九十"[:3] 结果是 "〇一二"
- <字符串>[M: N: K]，根据步长K对字符串切片
"〇一二三四五六七八九十"[1:8:2] 结果是 "一三五七"
"〇一二三四五六七八九十"[::-1] 结果是 "十九八七六五四三二一〇"
字符串的特殊字符
转义符 \
- 转义符表达特定字符的本意
"这里有个双引号(\")" 结果为 这里有个双引号(")
- 转义符形成一些组合，表达一些不可打印的含义
"\b"回退 "\n"换行(光标移动到下行首) "\r" 回车(光标移动到本行首)
字符串操作符
由0个或多个字符组成的有序字符序列
| 操作符及使用 |
描述 |
| x + y |
连接两个字符串x和y |
| n * x 或 x * n |
复制n次字符串x |
| x in s |
如果x是s的子串，返回True，否则返回False |
字符串操作符
获取星期字符串
-
- 输入：1-7的整数，表示星期几
- 输出：输入整数对应的星期字符串
- 例如：输入3，输出 星期三
字符串操作符
获取星期字符串
#WeekNamePrintV1.py
weekStr = "星期一星期二星期三星期四星期五星期六星期日" weekId = eval(input("请输入星期数字(1-7)："))
pos = (weekId – 1 ) * 3 print(weekStr[pos: pos+3])
字符串操作符
获取星期字符串
#WeekNamePrintV2.py weekStr = "一二三四五六日"
weekId = eval(input("请输入星期数字(1-7)："))
print("星期" + weekStr[weekId-1])
字符串处理函数
一些以函数形式提供的字符串处理功能
| 函数及使用 |
描述 |
| len(x) |
长度，返回字符串x的长度 len("一二三456") 结果为 6 |
| str(x) |
任意类型x所对应的字符串形式 str(1.23)结果为"1.23" str([1,2])结果为"[1,2]" |
| hex(x) 或 oct(x) |
整数x的十六进制或八进制小写形式字符串 hex(425)结果为"0x1a9" oct(425)结果为"0o651" |
字符串处理函数
一些以函数形式提供的字符串处理功能
| 函数及使用 |
描述 |
| chr(u) |
x为Unicode编码，返回其对应的字符 |
| ord(x) |
x为字符，返回其对应的Unicode编码 |
chr(u)
Unicode 单字符
ord(x)
Unicode编码
Python字符串的编码方式
- 统一字符编码，即覆盖几乎所有字符的编码方式
- 从0到1114111 (0x10FFFF)空间，每个编码对应一个字符
- Python字符串中每个字符都是Unicode编码字符
Unicode编码
一些有趣的例子
>>> "1 + 1 = 2 " + chr(10004)
'1 + 1 = 2 ✔'
>>> "这个字符♉的Unicode值是：" + str(ord("♉"))
'这个字符♉的Unicode值是： 9801'
>>> for i in range(12):
print(chr(9800 + i), end="")
♈♉♊♋♌♍♎♏♐♑♒♓
字符串处理方法
"方法"在编程中是一个专有名词
- "方法"特指<a>.<b>()风格中的函数<b>()
- 方法本身也是函数，但与<a>有关，<a>.<b>()风格使用
- 字符串及变量也是<a>，存在一些方法
字符串处理方法
一些以方法形式提供的字符串处理功能
| 方法及使用 1/3 |
描述 |
| str.lower() 或 str.upper() |
返回字符串的副本，全部字符小写/大写 "AbCdEfGh".lower() 结果为 "abcdefgh" |
| str.split(sep=None) |
返回一个列表，由str根据sep被分隔的部分组成 "A,B,C".split(",") 结果为 ['A','B','C'] |
| str.count(sub) |
返回子串sub在str中出现的次数 "a apple a day".count("a") 结果为 4 |
字符串处理方法
一些以方法形式提供的字符串处理功能
| 方法及使用 2/3 |
描述 |
|
str.replace(old, new) |
返回字符串str副本，所有old子串被替换为new "python".replace("n","n123.io") 结果为 "python123.io" |
|
str.center(width[,fillchar]) |
字符串str根据宽度width居中，fillchar可选 "python".center(20,"=") 结果为 '=======python=======' |
字符串处理方法
一些以方法形式提供的字符串处理功能
| 方法及使用 3/3 |
描述 |
|
str.strip(chars) |
从str中去掉在其左侧和右侧chars中列出的字符 "= python= ".strip(" =np") 结果为 "ytho" |
|
str.join(iter) |
在iter变量除最后元素外每个元素后增加一个str ",".join("12345") 结果为 "1,2,3,4,5" #主要用于字符串分隔等 |
字符串类型的格式化
格式化是对字符串进行格式表达的方式
- 字符串格式化使用.format()方法，用法如下：
<模板字符串>.format(<逗号分隔的参数>)
字符串类型的格式化
"{ }:计算机{ }的CPU占用率为{ }%".format("2018-10-10","C",10）
字符串中槽{}的默认顺序 format()中参数的顺序
0 1 2
字符串类型的格式化
"{1}:计算机{0}的CPU占用率为{2}%".format("2018-10-10","C",10)
format()方法的格式控制
槽内部对格式化的配置方式
{ <参数序号> ： <格式控制标记>}
： <填充> <对齐> <宽度> <,> <.精度> <类型>
引导 用于填充的
符号 单个字符
< 左对齐
> 右对齐
槽设定的输
出宽度
数字的千位
分隔符
浮点数小数
精度 或 字
整数类型
b, c, d, o, x, X
^ 居中对齐
符串最大输
出长度
浮点数类型
e, E, f, %
format()方法的格式控制
： <填充> <对齐> <宽度> <,> <.精度> <类型>
引导 用于填充的
符号 单个字符
< 左对齐
> 右对齐
槽设定的输
出宽度
>>>"{0:=^20}".format("PYTHON") '=======PYTHON======='
^ 居中对齐
>>>"{0:*>20}".format("BIT")
'*****************BIT‘
>>>"{:10}".format("BIT") 'BIT '
format()方法的格式控制
： <填充> <对齐> <宽度> <,> <.精度> <类型>
>>>"{0:,.2f}".format(12345.6789) '12,345.68'
数字的千位
分隔符
浮点数小数
精度 或 字符串最大输
整数类型
b, c, d, o, x, X浮点数类型
>>>"{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%'
出长度
e, E, f, %
模块2: time库的使用
time库是Python中处理时间的标准库
time库基本介绍- 程序计时应用
- 计算机时间的表达
- 提供获取系统时间并格式化输出功能
import time time.<b>()
- 提供系统级精确计时功能，用于程序性能分析
time库概述
time库包括三类函数
-
- 时间获取：time() ctime() gmtime()
- 时间格式化：strftime() strptime()
- 程序计时：sleep(), perf_counter()
时间获取
| 函数 |
描述 |
|
time() |
获取当前时间戳，即计算机内部时间值，浮点数 >>>time.time() 1516939876.6022282 |
|
ctime() |
获取当前时间并以易读方式表示，返回字符串 >>>time.ctime() 'Fri Jan 26 12:11:16 2018' |
时间获取
| 函数 |
描述 |
|
gmtime() |
获取当前时间，表示为计算机可处理的时间格式 >>>time.gmtime() time.struct_time(tm_year=2018, tm_mon=1, tm_mday=26, tm_hour=4, tm_min=11, tm_sec=16, tm_wday=4, tm_yday=26, tm_isdst=0 |
时间格式化
将时间以合理的方式展示出来
- 格式化：类似字符串格式化，需要有展示模板
- 展示模板由特定的格式化控制符组成
- strftime()方法
时间格式化
| 格式化字符串 |
日期/时间说明 |
值范围和实例 |
| %Y |
年份 |
0000~9999，例如：1900 |
| %m |
月份 |
01~12，例如：10 |
| %B |
月份名称 |
January~December，例如：April |
| %b |
月份名称缩写 |
Jan~Dec，例如：Apr |
| %d |
日期 |
01~31，例如：25 |
| %A |
星期 |
Monday~Sunday，例如：Wednesday |
格式化控制符
| 格式化字符串 |
日期/时间说明 |
值范围和实例 |
| %a |
星期缩写 |
Mon~Sun，例如：Wed |
| %H |
小时（24h制） |
00~23，例如：12 |
| %h |
小时（12h制） |
01~12，例如：7 |
| %p |
上/下午 |
AM, PM，例如：PM |
| %M |
分钟 |
00~59，例如：26 |
| %S |
秒 |
00~59，例如：26 |
时间格式化
>>>t = time.gmtime()
>>>time.strftime("%Y-%m-%d %H:%M:%S",t)
'2018-01-26 12:55:20'
>>>timeStr = '2018-01-26 12:55:20'
>>>time.strptime(timeStr, “%Y-%m-%d %H:%M:%S”)
时间格式化
| 函数 |
描述 |
|
strptime(str, tpl) |
str是字符串形式的时间值 tpl是格式化模板字符串，用来定义输入效果 >>>timeStr = '2018-01-26 12:55:20' >>>time.strptime(timeStr, "%Y-%m-%d %H:%M:%S") time.struct_time(tm_year=2018, tm_mon=1, tm_mday=26, tm_hour=4, tm_min=11, tm_sec=16, tm_wday=4, tm_yday=26, tm_isdst=0) |
程序计时
程序计时应用广泛
- 程序计时指测量起止动作所经历时间的过程
- 测量时间：perf_counter()
- 产生时间：sleep()
| 函数 |
描述 |
|
perf_counter() |
返回一个CPU级别的精确时间计数值，单位为秒 由于这个计数值起点不确定，连续调用差值才有意义 >>>start = time.perf_counter() 318.66599499718114 >>>end = time.perf_counter() 341.3905185375658 >>>end - start 22.724523540384666 |
程序计时
| 函数 |
描述 |
|
sleep(s) |
s拟休眠的时间，单位是秒，可以是浮点数 >>>def wait():
time.sleep(3.3) >>>wait() #程序将等待3.3秒后再退出 |
实例4: 文本进度条
"文本进度条"问题分析
文本进度条
用过计算机的都见过
- 进度条什么原理呢？
需求分析
文本进度条
- 采用字符串方式打印可以动态变化的文本进度条
- 进度条需要能在一行中逐渐变化
问题分析
如何获得文本进度条的变化时间？
- 采用sleep()模拟一个持续的进度
- 似乎不那么难
"文本进度条"简单的开始
#TextProBarV1.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("------执行结束------")
"文本进度条"单行动态刷新
单行动态刷新
刷新的关键是 \r
- 刷新的本质是：用后打印的字符覆盖之前的字符
- 不能换行：print()需要被控制
- 要能回退：打印后光标退回到之前的位置 \r
#TextProBarV2.py
import time
IDLE屏蔽了\r功能for i in range(101): print("\r{:3}%".format(i), end="")
单行动态刷新
#TextProBarV2.py
import time
命令行执行for i in range(101): print("\r{:3}%".format(i), end="")
"文本进度条"实例完整效果
#TextProBarV3.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,'-'))
"文本进度条"举一反三
#TextProBarV3.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,'-'))
举一反三
计算问题扩展
- 文本进度条程序使用了perf_counter()计时
- 计时方法适合各类需要统计时间的计算问题
- 例如：比较不同算法时间、统计部分程序运行时间
进度条应用
- 在任何运行时间需要较长的程序中增加进度条
- 在任何希望提高用户体验的应用中增加进度条
- 进度条是人机交互的纽带之一
举一反三
文本进度条的不同设计函数
| 设计名称 |
趋势 |
设计函数 |
| Linear |
Constant |
f(x) = x |
| Early Pause |
Speeds up |
f(x) = x+(1-sin(x*π*2+π/2)/-8 |
| Late Pause |
Slows down |
f(x) = x+(1-sin(x*π*2+π/2)/8 |
| Slow Wavy |
Constant |
f(x) = x+sin(x*π*5)/20 |
| Fast Wavy |
Constant |
f(x) = x+sin(x*π*20)/80 |
文本进度条的不同设计函数
| 设计名称 |
趋势 |
设计函数 |
| Power |
Speeds up |
f(x) = (x+(1-x)*0.03)2 |
| Inverse Power |
Slows down |
f(x) =1+(1-x)1.5 *-1 |
| Fast Power |
Speeds up |
f(x) = (x+(1-x)/2)8 |
| Inverse Fast Power |
Slows down |
f(x) = 1+(1-x)3 *-1 |