--可正可负，没有取证范围
--pow(x,y)函数：计算x^y，想计算多大算多大
--4种进制表示形式
-十进制：10,88,-11
-二进制，以0B或0b开头：0b011，0B111
-八进制，以0O或0o开头：0o678,-0O123
-十六进制，以0x或0X开头:0x12,0X22
--带有小数点及小数的数字
--浮点数取值范围及小数精度都有限制，但一般计算可忽略不计
取值范围-10^307到10^308,精度数量级10^-16
--浮点数运算存在不确定尾数，不是bug
-浮点数间运算与比较用round()函数辅助
-round(x,d):对x四舍五入，d是小数截取位数
--浮点数可以采用科学计数法表示
-使用e或E作为幂的符合，以10为基数，格式如下: <a>e<b> 表示 a*10^b
ex: 4.5e-3 值为 0.0045 9.5E5 值为 950000.0
--定义j为根号-1,以此为基础，构建数学体系
--a+bj 被称为复数，其中，a是实部，b是虚部
x+y 和
x-y 差
x*y 积
x/y 商
x//y 整数除 10//3=3
x%y 余数，模运算 10%3=1
x**y 幂运算，x的y次幂，x^y 10**0.5结果是根号10
+x
-x
x op =y 等同于 x=x op y x **=3等同于x=x **3
类型之间可进行混合运算，生成结果为“最宽”类型
--整数 --> 浮点数 --> 复数
ex:123+1.0=124.0
--abs(x) #绝对值函数，abd(-10)=10
--divmod(x,y) #商余，(x//y,x%y),同时输出商和余数，divmod(10,3)=(3,1)
--pow(x,y[,z]) #幂余，(x**y)%z,[]表示可省略的参数
--round(x[,d]) #四舍五入，d是保留小数位数，默认是0
--max(n1,n2,...,nx) #最大值，不限参数个数
--min(n1,n2,...,nx) #最小值，不限参数个数
--int(x) #将x变为整数，舍弃小数部分 int(123.45)=123 int("123")=123
--float(x) #将x变为浮点数，增加小数部分 float(11)=11.0 float("12.3")=12.3
--complex(x) #将x变为复数，增加虚数部分 complex(4)=4+0j
一年365天，每天进步1‰，累计进步多少呢？
一年365天，每天退步1‰，累计退步多少呢?
#DayDayUp01.py
dayup=pow(1.001,365)
daydown=pow(0.999,365)
print("向上：{:.2f}，向下：{:.2f}".format(dayup,daydown))
向上：1.44,向下：0.69
一年365天，每天进步5‰或1%的力量，累计进步多少呢？
一年365天，每天退步5‰或1%的力量，累计退步多少呢?
#DayDayUp02.py
dayfactor= 0.005 #使用变量，好处可更改值
dayup = pow(1+dayfactor,365)
daydown = pow(1-dayfactor,365)
print("向上：{:.2f},向下:{:.2f}".format(dayup,daydown))
--向上：6.17,向下:0.16 （ 0.005 ）
--向上：37.78,向下:0.03（0.01）
一年365天，一周5个工作日，每天进步1%
一年365天，一周2个休息日，每天退步1%
这种工作日的力量，如何呢？
1.01365 (数学思维) for..in.. (计算思维)
#DayDayUp3.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
工作日模式要努力到什么水平，才能与每天努力1%一样？
A君: 一年365天，每天进步1%，不停歇
B君: 一年365天，每周工作5天休息2天，休息日下降1%，要多努力呢？
for..in.. (计算思维) def..while.. ("笨办法"试错)
#DayDayUp4.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.8:
dayfactor += 0.001
print("工作日的努力参数是:{:.3f}".format(dayfactor))
--工作日的努力参数是:0.019
由0个或多个字符组成的有序字符序列
-字符串由一对单引号或一对双引号表示
-字符串支持索引
字符串共有两类四种表示方法
--如果希望在字符串中包含双引号或单引号呢？
'这里有个双引号(")' 或者 "这里有个单引号(')"
-- 如果希望在字符串中既包括单引号又包括双引号呢？
-- ''' 这里既有单引号(')又有双引号 (") '''
字符串的序号
--正向递增序号从0开始，反向递减序号从-1开始
使用[]获取字符串中一个或多个字符
--索引：返回字符串中单个字符 <字符串>[M]
--切片：返回字符串中的一段字符子串 <字符串>[M:N]
字符串切片高级用法
--<字符串>[M,N],M缺失表示至开头，N缺失表示至结尾
--<字符串>[M,N,K],根据步长K对字符串切片
"〇一二三四五六七八九十"[1:8:2] 结果是 "一三五七"
"〇一二三四五六七八九十"[::-1] 结果是 "十九八七六五四三二一〇"
字符串的特殊字符 转义符\
--转义符表达特定字符的本意
"这里有个双引号(\")" 结果为 这里有个双引号(")
--转义符形成一些组合，表达一些不可打印的含义
"\b"回退
"\n"换行(光标移动到下行首)
"\r" 回车(光标移动到本行首)
x+y #连接两个字符串x和y
n*x或x*n #复制n次字符串x
x in s #如果x是s的子串，返回True,否则返回False
输入：1-7的整数，表示星期几
输出：输入整数对应的星期字符串
例如：输入3，输出 星期三
#weeknameprint.py
weekStr="星期一星期二星期三星期四星期五星期六星期日"
weekId=eval(input("请输入星期数字（1-7）："))
pos=(weekId-1)*3
print(weekStr[pos:pos+3])
一些以函数形式提供的字符串处理功能
len(x) #长度，返回字符串x的长度 len("123一二三")=6
str(x) #任意类型x所对应的字符串形式 str(1.23)="1.23" str[3,8]="[3,8]"
hex(x)或oct(x) #整数x的十六进制或八进制小写形式字符串 hex(425)结果为"0x1a9" oct(425)结果为"0o651"
chr(u) #x为Unicode编码，返回其对应的字符
ord(x) #x为字符，返回其对应的Unicode编码
Unicode编码
-Python字符串的编码方式
-Python字符串中每个字符都是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>，存在一些可用方法
一些以方法形式提供的字符串处理功能
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中出现的次数 "an apple a day".count("a") 结果为 4
str.replace(old,new) #返回字符串副本，所有的old子串被替换为new "python".replace("n","n456.io") 结果为"python456.io"
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)
"{1}:计算机{0}的CPU占用率为{2}%".format("2018-10-10","C",10)
format()方法的格式控制--槽内部对格式化的配置方式
{<参数序号>:<格式控制标记>}
: #引导符号
<填充> #用于填充的单个字符
<对齐> # < 左对齐 > 右对齐 ^ 居中对齐
<宽度> #槽设定的输出宽度
<,> #数字的千位分隔符
<.精度> #浮点数小数精度 或字符串最大输出长度
<类型> #整数类型 b,c,d,o,x,X 浮点数类型e,E,f,%
"{0:=^20}".format("PYTHON") #'=======PYTHON======='
"{0:*>20}".format("BIT") #'*****************BIT'
"{:10}".format("BIT") # 'BIT '
"{0:,.2f}".format(12345.6789) # '12,345.68'
"{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%'
time库是Python中处理时间的标准库
-计算时间的表达 import time
-提供获取系统时间并格式化输出功能
-提供系统精确计时功能，用于程序性能分析
--时间获取 ：time() ctime() gmtime()
--时间格式化： strftime() striptime()
--程序计时：sleep().perf_counter()
--time() #获取当前时间戳，即计算机内部时间值，浮点数
time.time() #1562557180.4364607
--ctime() #获取当前时间，并以易读方式表示，返回字符串
time.ctime() #'Mon Jul 8 11:42:00 2019'
--gmtime() #获取当前时间，表示为计算机可处理的时间格式
time.gmtime()
#time.struct_time(tm_year=2019, tm_mon=7, tm_mday=8, tm_hour=3, tm_min=43, tm_sec=49, tm_wday=0, tm_yday=189, tm_isdst=0)
将时间以合理的方式展现出来
--格式化，类似字符串格式化，需要有展示模板
--展示模板有特定格式化控制符组成
--strftime()方法
--strftime(tpl,ts) # tpl是格式化模板字符串，用来定义输出效果 ts是计算机内部时间类型变量
import time
t = time.gmtime()
time.strftime("%Y-%m-%d %H:%M:%S",t)
# '2019-07-08 03:51:47'
--strptime(str,tpl) #str是字符串形式的时间值，tpl是格式化模板字符串，用来定义输入效果
import time
timeStr= '2019-07-08 03:51:47'
time.striptime(timeStr,"%Y-%m-%d %H:%M:%S")
# time.struct_time(tm_year=2019, tm_mon=7, tm_mday=8, tm_hour=3, tm_min=51, tm_sec=47, tm_wday=0, tm_yday=189, tm_isdst=-1)
格式化字符串 日期/时间说明 值范围和实例
%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
%I 小时（12h制） 01~12，例如：7
%p 上/下午 AM, PM，例如：PM
%M 分钟 00~59，例如：26
%S 秒 00~59，例如：26
-程序计时指测量起止动作所经历时间的过程
-测量时间：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秒后再退出
采用字符串方式打印可以动态变化的文本进度条
进度条需要在同一行中逐渐变化
如何获得文本进度条的变化时间？ 采用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("------执行结束------")
------执行开始------
0 %[->..........]
10 %[*->.........]
20 %[**->........]
30 %[***->.......]
40 %[****->......]
50 %[*****->.....]
60 %[******->....]
70 %[*******->...]
80 %[********->..]
90 %[*********->.]
100%[**********->]
------执行结束------
刷新的关键是 \r
--刷新的本质是：用打印之后的字符覆盖之前的字符
--不能换行，print()需要被控制
--要能回退：打印后光标退回到之前的位置 \r
#TextProBarV2.py
import time
for i in range(101):
print("\r{:3}%".format(i), end="")
time.sleep(0.1)
#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
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
