1.内置方法
ads 绝对值函数
val = -16
res = abs(val)
print(res) #16
round 四舍五入(n.5 n为偶数则舍去，n.5 n为奇数 则进一)
奇进偶不进
val = 3.5 #4
val = 4.5 #4
val = 4.51 #5
val = 4.12 #4
val = 4.6 #5
res = round(val)
print(res)
sum 计算一个序列的和
lst = [1,2,3,4,5]
res = sum(lst)
print(res) #15
max 获取一个序列里边的最大值
lst = [10,100,-3,40]
res1 = max(lst)
res2 = min(lst)
print(res1,res2) #100 -3
sorted 找出最小值和最大值
lst_new = sorted(lst)
min_val = lst_new[0]
max_val = lst_new[-1]
print(min_val,max_val)
#min 获取一个序列里面的最小值sorted(iterable,key=函数) max 和 min 同sorted用法
''' 找出年龄最小的元组'''
lst = [("王振",25),("刘伟",50),("刘思敏",18)]
def func(n):
return n[-1]
res = min(lst,key=func) #把lst里面的一个一个元素传入函数func中，返回索引-1的元素
res = max(lst,key=func) #把lst里面的一个一个元素传入函数func中，发挥索引-1的元素
pow 计算某个数值的x方
res = pow(2,3) #8
#第三个参数的作用是取余
res = pow(2,3,5) #先是算前面两位2**3的次方，然后再用得到的结果%5
print(res) #3
range 产生指定范围数据的可迭代对象
bin 将十进制数据转换为二进制
oct 将十进制数据转换为八进制
hex 将纸巾纸数据转换为十六进制
chr 将ascii编码转换为字符
ord 将字符转换为ascii编码
eval 将字符串当做python代码执行
strvar = 'print(111)'
#strvar = 'a = 10' eval 执行不了
exec 将字符串当做python代码执行(功能更强大)
strvar = 'a=10' 返回为None
strvar = '''
for i in range(10):
print(i)
'''
exec(strvar)
repr 不转义字符输出字符串
strvar = 'E:\nython30\tay15'
print(repr(strvar))
input 接收输入字符串
hash 生成哈希值 两个相同的字符串，无论哈希多少次，都会产生相同的唯一值
让密码加密hashlib
文件的校验 比较文件内容
2.序列化模块 pickle
序列化：把不能够直接存储在文件中的数据变得可存储，这个过程就是序列化
反序列化：把文件中的数据内容拿出来，恢复成原来的数据类型，这个过程就是反序列化
在文件中存储的数据，要么是字符串要么是字节流
python中，所有的数据类型都可以通过dumps和loads进行序列化和反序列化
dumps 和 loads
import pickle
dumps 把任意对象序列化成一个bytes
序列化列表
lst = [1,2,3]
res = pickle.dumps(lst)
print(res)
#序列化函数
def func():
print('我是func函数')
res = pickle.dumps(func)
print(res)
序列化迭代器
it = iter(range(10))
res = pickle.dumps(it)
loads 把任意butes反序列化成原来的数据
res = pickle.loads(res)
print(res,type(res))
for i in range(3):
res2 = next(res)
print(res2)
dump 和 load
dump 把对象序列化后写入file-like Object文件对象
dic = {'a':1,'b':2}
with open('ceshi3.txt',mode='wb') as fp:
#dump(要转换的数据，文件对象)
pickle.dump(dic,fp)
load 把file-like Object即文件对象中的内容拿出来，反序列化成原数据
with open('ceshi3.txt',mode='rb') as fp:
res = pickle.load(fp)
print(res,type(res))
3.序列化模块 json
所有的编程语言都能够识别的数据格式叫作json，是字符串
能够通过json序列化成字符串的有如下类型(int，float，bool，str，list，tuple，dict，None)
pickle 序列化成字节流
json 序列化成字符串
json用法
import json
dumps 和 loads 是一堆，序列化字符串
dic = {"name":"王振","age":30,"classroom":"python30","family":["爸爸","妈妈","哥哥","姐姐"]}
#ensure_ascii = False,不通过ascii来显示内容
#sort_keys =True 对字典的键进行排序
res = json.dumps(dic,ensure=False,sort_keys=True)
print(res,type(res))
loads 反序列化成原来的数据类型
dic = json.loads(res)
print(dic,type(dic))
dump 和 load 是一对，针对于文件，把数据进行序列化操作
dic = {"name":"王振","age":30,"classroom":"python30","family":["爸爸","妈妈","哥哥","姐姐"]}
with open('ceshi.json',mode='w',encoding='utf-8') as fp:
#dump（要转换的数据，文件对象）
json.dump(dic,fp,ensure_ascii=False)
load 反序列化成原来的数据类型
with open('ceshi5.txt',mode='r',encoding='utf-8') as fp:
dic = json.load(fp)
print(dic,type(dic))
json 和 pickle 两个模块区别
json可以连续dump ，不可以连续load(load是一次性拿出所有数据进行反序列化，容易出错) 但是可以用loads来解决
dic1 = {"a":1,"b":2}
dic2 = {"c":3,"d":4}
with open('ceshi6.json',mode='w',encoding='utf-8') as fp:
json.dump(dic1,fp)
fp.write('\n')
json.dump(dic2,fp)
fp.write('\n')
load的弊端 一次性读取全部
with open('ceshi6.json',mode='r'.encoding='utf-8') as fp:
dic = json.load(fp)
print(dic)
解决办法 用loads，一行一行反序列化
with open('ceshi6.json',mode='r',encoding='utf-8') as fp;
#文件对象是迭代器，一次迭代一行
for i in fp:
dic =json.loads(i)
print(dic)
pickle 可以连续dump 可以连续load
import pickle
dic1 = {"a":1,"b":2}
dic2 = {"c":3,"d":4}
with open('ceshi7.pkl',mode='wb') as fp:
pickle.dump(dic1,fp)
pickle.dump(dic2,fp)
#方法一
with open('ceshi7.pkl',mode='rb') as fp:
dic = pickle.load(fp)
print(dic)
dic = pickle.load(fp)
print(dic)
#方法二
'''try ... except ... 抑制报错 如果try代码块里面有问题，就执行except中的代码'''
'''
try:
把有问题的代码放进来
except:
如果出现异常执行这个分支的代码
'''
try:
with open('ceshi7.pkl',mode='rb') as fp:
while True:
dic = pickle.load(fp)
print(dic)
except:
pass
总结：json和pickle两个模块的区别：
(1)josn序列化之后的数据类型是str，所以编程语言都是识别(数据交流)
json不能连续load，只能一次性拿出来所有数据，可以用loads解决，for循环文件对象，然后loads取每一行
(2)pickle序列化之后的数据类型是bytes(存储转换)
所有数据类型都可以转换，但仅限于python之间的存储传输
pickle可以连续load，多套数据放到同一个文件中
4.time模块
time.sleep() 程序睡眠等待
# ### 进度条效果
#(1) 定义进度条的样式
'''
print('[%s]'%('###'))
print('[%-50s]'%('###')) #左填充右边补空格
print('[%-50s]'%('##############'))
print('[%-50s]'%('######################'))
print('[%-50s]'%('###############################'))
'''
#(2) 让进度条动起来
'''
strvar = ''
for i in range(50):
strvar += '#'
time.sleep(0.1)
print('\r[%-50s]'%(strvar),end='')
#首先[]是一个格式化，-50表示从左到右填充，不足的补空格，\r表示把后面内容调到前面来并替换之前的内容
'''
#(3) 根据文件的大小，调整进度条的位置
def progress(percent):
if percent > 1:
percent = 1
# 打印出对应的 # 号效果
strvar = int(50 * percent) * '#'
# %% => %号的符号效果
print('\r[%-50s] %d%%' %(strvar,int(100 * percent)),end = '') #用int转换成整数
recv_size = 0
#假设文件总大小是102800
total_size = 102800
while recv_size < total_size:
time.sleep(0.01)
#一次接收1024字节
recv_size += 1024
percent = recv_size/total_size
progress(percent)
# 30% 50% 80%
#0.3 0.5 0.8 0.9 1 最大为1 不超过1
'''
大概思路：写个函数用于调整进度条，如果参数大于1，就让它等于1，因为最大只能为1.即为100%
然后根据百分比打印对应的#号，然后用了\r 每次循环就把后面的#调到前面并替换掉，然后再添加这个进度显示
百分比 100 * 对应的参数就是为显示的百分之进度，然后用int转换成整数
定义一个接收文件大小的变量，然后假设这个文件大小为102800，当接收文件大小的变量的值小于文件大小的时候
执行循环下面的代码。每次循环接收文件的大小加1024，百分之就为接收文件大小除以文件总大小，得到的结果
调用函数progress，并把结果当做参数传入函数progress.
'''