数字类型及操作
- 整数类型
- 数值运算函数
整数类型
与数学中整数的概念一致
- 可正可负,没有取值范围限制
- 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 |