目录
3 基本数据类型
3.1 数字类型及操作
3.1.1 整数类型
pow()函数
计算幂指数xy
用法：pow(x,y) 求x的y次幂
四种进制
十进制
二进制：以0b或0B开头，如0b010、0B101
八进制：以0o或0O开头，如0o123、0O456
十六进制：以0x或0X开头，如0x9a、0X89
实例：
>>> 0b1+0b1
2
>>> 0b1+0B10
3
>>> 0B1+0O11
10
>>> 0Xa+0o12
203.1.2 浮点数类型
取值范围数量级约-10 308至10 308
精度数量级10 -16
浮点数间的运算，可能存在不确定的尾数（不是bug，多数编程语言都存在）
原因：计算机用二进制表示小数，计算时只取53位，约10^-16（转回十进制时只有16位小数）
例如：0.1
二进制表示为0.000110011······（共53位）
转回十进制为0.1000000000000000346494004316······
那么计算0.1+0.2时，可能等于0.30000000004
>>> 0.1+0.2＝＝0.3 #两个等号表示判断
False如何解决？
round()函数：四舍五入
浮点数间的计算即比较需要用此函数辅助
用法：round(x,d)，对x四舍五入，d是小数截取位数
>>> 0.1+0.2
0.30000000000000004
>>> round(0.1+0.2,1)
0.3
>>> round(0.1+0.2,1)==0.3 #表示取一位小数比较
True浮点数的科学计数法
用e或E作为幂的符号，以十为基数
用法：xey 表示 x*10b
例如：
4.3e-3 为4.3*10-3，即0.0043
9.6E5 为9.6*105，即960000.0
3.1.3 复数类型
在众多编程语言中只有Python提供复数类型
常规编程不常用，但在进行空间变换，特别是与复变函数相关的科学体系中常用
用法：a+bj，a为实部，b为虚部，只能用j或J
例如：z＝1.23e-4+5.6e+89j
用z.real获取实部
用z.imag获取虚部
用z.conjugate()获取共轭复数
complex()函数：表示复数
用法：complex(a,b) 表示a+bj
>>> z=2-3j
>>> z.real
2.0
>>> z.imag
-3.0
>>> z.conjugate()
(2+3j)
>>> (2+3j)+(3+2j)
(5+5j)
>>> complex(1.23e-4+5.6e+89j).real
0.000123
>>> complex(1.23e-4+5.6e+89j).imag
5.6e+89
>>> complex(1.23e-4+5.6e+89j).conjugate()
(0.000123-5.6e+89j)3.1.4 数值操作运算符
六个功能函数
abs(x) 求x的绝对值
divmod(x,y) 求商和余数(x//y,x%y)
pow(x,y[,z]) 求x的y次幂
如果有第三个参数还能将结果和z取余（也就是数太大了，取需要的后几位），即(x**y)%z
round(x[,d]) 对x四舍五入到d位小数，d默认为0
max(x1,x2,...,xn) 求最大值，n不限
min(x1,x2,...,xn) 求最小值，n不限
代码：
>>> abs(-6.5)
6.5
>>> divmod(10,3)
(3, 1)
>>> pow(7,10)
282475249
>>> pow(7,10,10)
9
>>> pow(7,10,100)
49
>>> round(23.92318415321)
24
>>> round(23.92318415321,4)
23.9232
>>> max(65,64,98,0,-6,pow(2,7))
128
>>> min(65,64,98,0,-6,pow(-2,7))
-128数值类型转换函数
int(x) 将x变成整数
舍弃小数，浮点数，整数字符串，都可以
float(x) 将x变成浮点数
增加小数部分，整数，数字字符串，都可以
float（12）得12.0
float（“1.23”）得1.23
complex(x) 将整数x变成复数，补上虚数部分0j
>>> int(6.88)
6
>>> int(756e-2)
7
>>> int("7.5") #转不了两层
Traceback (most recent call last):
File "<pyshell#14>", line 1, in <module>
int("7.5")
ValueError: invalid literal for int() with base 10: '7.5'
>>> int("9")
9
>>> float(13)
13.0
>>> float("13.5")
13.5
>>> float("13")
13.0
>>> float(pow(2,3))
8.0
>>> complex(9)
(9+0j)3.2 实例三：天天向上的力量
3.2.1 每天进/退 1‰
公式：1.001365
0.999365
代码：
dayup = pow(1.001,365)
daydown = pow(0.999,365)
print("DAYDAY UP :{:.2f},DAYDAY DOWN :{:.2f}".format(dayup,daydown))结果：
DAYDAY UP:1.44,DAYDAY DOWN :0.693.2.2 每天进/退 5‰或 1%——参数
问题分析：有两个值，能否设一个变量呢？
代码：
factor = 0.005 #优势：只需修改变量fact为0.005或0.1
dayup = pow(1+factor,365)
daydown = pow(1-factor,365)
print("DAYDAY UP :{:.2f},DAYDAY DOWN :{:.2f}".format(dayup,daydown))结果：
DAYDAY UP:6.17,DAYDAY DOWN :0.163.2.3 工作日进1% 休息日退1%
问题分析：365天，每7天为一个周期，七天中前五天为工作日，后两天为休息日
代码：
dayup = 1.0
factor = 0.01
for i in range (365):
if i%7 in [6,0]:
dayup=dayup*(1-factor)
else:
dayup=dayup*(1+factor)
print("工作日的力量:{:.2f}".format(dayup))结果：
工作日的力量:4.633.2.4 工作日要多努力？——函数
问题：休息日退1%，工作日要进多少才能和每天进1%的结果相同？
分析：假设工作日努力值为x，把结果和每天进步1%的结果（37.78）比较，如果≥1.44则输出这个x；如果＜1.44，则把x再变大一丢丢。
解决办法：def…while…
代码：
#def定义一个函数
def DAYDAYUP(f): #根据参数f计算工作日的进步值
dayup=1
for i in range(365):
if i % 7 in [6, 0]:
dayup = dayup * (1 - 0.1)
else:
dayup = dayup * (1 + f)
return dayup
#开始编写
factor=0.01
while DAYDAYUP(factor)<37.78: #while循环调用函数DAYDAYUP()
factor+=0.001 #等价于factor=factor+0.001
print('追平1%的日进步值是:{:.3f}'.format(factor))结果：
追平1%的日进步值是:0.019- 保留字def：自定义函数
- 保留字while：判断循环，当满足while后的条件时进行
3.2.5 练习：两天打鱼三天晒网
问题：假如两天进步1%，接下来三天偷懒进步5‰，再良心发现进步三天1%......
问题分析：跟3.2.3相似
代码：
#假如两天进步1%，接下来三天偷懒只进步5‰，再良心发现进步三天1%......
dayup=1
for i in range(365):
if i%5 in[0,1,]:
dayup=dayup*(1+0.01)
else:
dayup=dayup*(1-0.005)
print("两天打渔，三天晒网:{:.2f}".format(dayup))结果：
两天打渔，三天晒网:1.433.3 字符串类型及操作
3.3.1 字符串类型的表示
表示方法-两类四种
由一对单引号或双引号表示，仅表示单行字符串
由一对三单引号或三双引号表示，可表示多行字符串
注：三单引号跟多行注释怎么一样呢？因为Python并没有多行注释的规定，多行注释本身就是多行字符串，只是因为这个多行字符串没给到变量中，也没有任何操作，可以当注释用。
如果在字符串中也要有单引号/双引号/单引号和双引号该如何操作？
>>> print("abc""abc")
abcabc
>>> print('"abc"')
"abc"
>>> print("'abc'")
'abc'
>>> print(""abc"") #不能两对双引号
SyntaxError: invalid syntax
>>> print("'abc"abc"'")
SyntaxError: invalid syntax
>>> print('''"abc"'abc'''')
SyntaxError: EOL while scanning string literal
#乱七八蕉，总之要向下面这样，不要让四个引号连一起
>>> print('''aaa"abc"'abc'ccc''')
aaa"abc"'abc'ccc字符串是有序字符序列，可以对字符索引
字符串序号
正向递增序号：第一个为0，往后递增
反向递减序号：第一个为-1，往前递减
字符串的使用
使用 [ ] 获取字符串中一个或多个字符
索引：返回字符串中单个字符
格式：字符串[M]
切片：返回字符串中一段字符子串
格式：字符串[M:N]
字符串[M:] 默认到结尾
字符串[:N] 默认到开头
切片的高级用法：字符串[M:N:K] 根据步长K进行切片
>>> "壹贰叁肆伍陆柒捌玖拾"[5]
'陆'
>>> t="壹贰叁肆伍陆柒捌玖拾"
>>> t[5]
'陆'
>>> t[1:3]
'贰叁'
>>> t[0:-1]
'壹贰叁肆伍陆柒捌玖'
>>> t[-3]
'捌'
>>> t[2:]
'叁肆伍陆柒捌玖拾'
>>> t[:3]
'壹贰叁'
>>> t[1:9:2]
'贰肆陆捌'
>>> t[2:10:3]
'叁陆玖'字符串的逆序
本质上是切片
格式:字符串[::-1]
>>> t[::-1]
'拾玖捌柒陆伍肆叁贰壹'字符串的特殊字符
转义符：表达特定字符的本意
用法：反斜杠 \
例如：双引号里面还要出行双引号
>>> print("\"2022-2225\"")
"2022-2225"常用转义符
\b 回退
\n 换行
\r 回车
3.3.2 字符串操作符
x+y 把字符串x和y连接起来
n*x或x*n 复制字符串n次
x in y 判断x是否为y的子串，是返回Ture，不是返回False
例如：
>>> "壹贰叁肆"+"伍陆柒捌"
'壹贰叁肆伍陆柒捌'
>>> '壹贰叁'*3
'壹贰叁壹贰叁壹贰叁'
>>> '壹贰叁' in "壹贰叁肆伍陆柒捌玖拾"
True
>>> '壹叁' in "壹贰叁肆伍陆柒捌玖拾"
False
实例：获取星期字符串
week="星期一星期二星期三星期四星期五星期六星期日"
num=eval(input("请输入星期数字："))
begin=(num-1)*3 #注意先减掉1
print(week[begin:begin+3])改进：
week="一二三四五六日"
num=eval(input("请输入星期数字："))
print("星期"+week[num-1]) #注意要减13.3.3 字符串处理函数
len(x) 求字符串的长度
str(x) 把任意类型的x变成字符串（加引号）
和eval()函数功能相反
hex(x) 把整数x转为十六进制的字符串（大写o）
oct(x) 把整数x转为八进制的字符串（小写o）
hex和oct的作用：计算机内部用的二进制，转为十六或八进制方便程序猿查看操作
chr(u) u为Unicode编码，返回其对应的字符
ord(x) x为字符，返回其对应的Unicode编码
Unicode编码
Python字符串的编码形式
统一字符编码，即覆盖几乎世界所有字符的编码形式
>>> for i in range(12):
print(chr(9800+i),end="")结果：
♈♉♊♋♌♍♎♏♐♑♒♓3.3.4 字符串处理方法
"方法"在编程中是一个专有名词
"方法"特指<a>.<b>()风格中的函数<b>()
方法本身也是函数，但与<a>有关，方法必须采用<a>.<b>()形式使用
字符串及变量也是<a>，存在一些方法
<a>.<b>()是面向对象的使用格式，a是对象，b是方法（功能）
字符串处理函数
str.lower() 把大写转为小写
str.upper() 把小写转为大写
str.split(sep＝None) 返回一个列表，由sep分割字符串
str.count(sub) 返回子串sub在str中出现的次数
str.replace(old,new) 把所有old子串替换为new的内容
str.center(宽度，填充字符) 字符串根据宽度居中（如果小于字符长度，则不填充字符）
str.strip(要删除的字符) 去掉两侧的某些字符（和顺序无关，删到两侧字符不是指定字符串里的字符）
str.join(字符串)在字符串两个字符之间添加字符str
例如：
>>> "a,b,c,A,B,C".lower()
'a,b,c,a,b,c'
>>> z="a,b,c,A,B,C"
>>> z.upper()
'A,B,C,A,B,C'
>>> z.split(",")
['a', 'b', 'c', 'A', 'B', 'C']
>>> z.count(",")
5
>>> z.replace("c,A","C,a")
'a,b,C,a,B,C'
>>> z.center(30,chr(9802))
'♊♊♊♊♊♊♊♊♊a,b,c,A,B,C♊♊♊♊♊♊♊♊♊♊'
>>> z.center(20,"&")
'&&&&a,b,c,A,B,C&&&&&'
>>> z.center(6,"&")
'a,b,c,A,B,C'
>>> z.strip("cA")
'a,b,c,A,B,C'
>>> z.strip(",aCb")
'c,A,B'
>>> "abcbbdghjcbag".strip("bca")
'dghjcbag'
>>> "喔".join(z)
'a喔,喔b喔,喔c喔,喔A喔,喔B喔,喔C'3.3.5 字符串类型的格式化
用.format()
槽
相当于C语言的 %d，用来占位，填写内容为format()括号内的内容，一一对应
槽内部对格式化的配置方式
例如：
>>> "{0:*^10}".format("四果汤汤") #必须按照{：要填充的单字符+对齐方式+字符串宽度}的数序设定
'***四果汤汤***'
>>> "{:5}".format("四果汤") #如果只给了宽度，默认左对齐，空格填充
'四果汤 '
>>> z=202121511.456
>>> "{:,}".format(z) #加千位符
'202,121,511.456'
>>> "{:.1f}".format(z) #保留几小数，会四舍五入
'202121511.5'
>>> "{:.6}".format('202121511.456') #保留左起几个字符
'202121'
# b是二进制，c是unicode值对应字符，d是十进制，o是八进制，x是十六进制（含大小写x/X）
>>> "{0:b},{0:c},{0:d},{0:o},{0:x},{0:X}".format(123) #没有0不行
'1111011,{,123,173,7b,7B'
# e/E是大小写的科学计数法，f为浮点数，%为百分数形式
>>> "{0:e}&{0:E}&{0:f}&{0:%}".format(3.14)
'3.140000e+00&3.140000E+00&3.140000&314.000000%'3.4 模块2：time库的使用
3.4.1 time库基本情况
处理时间的标准库之一
表达计算机时间
提供获取系统时间并格式化输出的功能
提供系统及精确计时功能，用于程序性能分析
用法：
import time
time.函数（）
time库包括三类函数
时间获取：time（），ctime（），gmtime（）
时间格式化：strftime（），strptime（）
程序计时：sleep（），perf_counter()
3.4.2 时间获取
time()
获取当前时间戳（即计算机内部表示时间的一个浮点数值）
表示1970年1月1日00:00（科学家选的）到当前的一个以秒为单位的数值，看不出什么
ctime()
获取当前时间并返回可读的字符串
gmtime()
获取当前时间并返回计算机可处理的形式
>>> import time
>>> time.time()
1658675509.249697
>>> time.ctime()
'Sun Jul 24 23:15:31 2022'
>>> time.gmtime()
time.struct_time(tm_year=2022, tm_mon=7, tm_mday=24, tm_hour=15, tm_min=17, tm_sec=28, tm_wday=6, tm_yday=205, tm_isdst=0)3.4.3 时间格式化
将时间以合适方式展现出来
strftime()
用法：time.strftime(时间格式模板，时间)
例如：
>>> time.strftime("%Y-%m-%d %H:%M:%S",time.gmtime())
'2022-07-24 15:28:16'
>>> time.strftime("%Y/%m/%d %H:%M:%S",time.gmtime())
'2022/07/24 15:28:31'
>>> t=time.gmtime()
>>> time.strftime("%Y/%m/%d %H:%M:%S",t)
'2022/07/24 15:27:46'时间控制符
%Y 年份 0000-9999
%m 月份 01-12
%B 月份全称 January-December
%b 月份缩写 Jan-Dec（三位）
%d 日期 01-31
%A 星期全称 Monday-Sunday
%a 星期缩写 Mon-Wed
%H 24小时制 00-23
%I 12小时制 01-12
%p 上/下午 AM/PM
%M 分 00-59
%S 秒 00-59
strptime()
不常用，strftime()的反用法，获取计算机内部能操作的时间格式（浮点数）
用法：time.strptime(时间字符串，相应控制符及格式)
例如：
>>> time.strptime("2022-07-24 15:28:16","%Y-%m-%d %H:%M:%S")
time.struct_time(tm_year=2022, tm_mon=7, tm_mday=24, tm_hour=15, tm_min=28, tm_sec=16, tm_wday=6, tm_yday=205, tm_isdst=-1)
>>> t="2022-07-24 15:28:16"
>>> time.strptime(t,"%Y-%m-%d %H:%M:%S")
time.struct_time(tm_year=2022, tm_mon=7, tm_mday=24, tm_hour=15, tm_min=28, tm_sec=16, tm_wday=6, tm_yday=205, tm_isdst=-1)3.4.4 程序计时应用
程序计时指测量起止动作所经历时间
sleep()
程序休眠一定时间，单位秒，可以是浮点数
用法：sleep(时间秒)
例如程序最后休眠（停留）几秒再关闭退出
perf_counter()
测量时间，CPU纳秒级别，单位秒
不是从0开始计时，所以要两次调用，减去差值
例如：
>>> import time
>>> start=time.perf_counter()
>>> end=time.perf_counter()
>>> end-start
71.584409148999843.5实例四：文本进度条
3.5.1问题分析
需求分析：
采用字符串方式打印可以动态变化的文本进度条
能在一行中逐渐变化
问题分析：
如何获得文本进度条的变化时间？
采用sleep()模拟一个持续的进度
3.5.2 简单的开始
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%[**********–＞]
------执行结束------3.5.3 单行动态刷新
刷新的本质：用后来打印的字符覆盖之前的字符
不能换行：end="" #空字符串
end=""，如果要在句末加什么信息，就填入引号内，没填默认换行
要能回退：\r
import time
for i in range(101):
print("\r{:3}%".format(i),end="") # \r让光标保留在行首
time.sleep(0.1)结果：从 0%运行到100%
3.5.4 完整代码
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 #当前百分比
d=time.perf_counter()-start #开始到当前经历的时间
print("\r{:^3.0f}%[{}–＞{}]{:.2f}s".format(c,a,b,d),end="")
time.sleep(0.1)
print("\n"+"执行结束".center(scale//2,"-"))结果：
-----------执行开始----------
100%[**************************************************–＞]5.46s
-----------执行结束----------运行一半的效果：
38 %[*******************–＞...............................]2.07s
2773
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
