内置方法，序列化模块pickle和json---day15

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.
'''