内置函数和序列化

3、内置函数

abs、round、sum、max、min、sorted、pow、range、bin、oct、hex、chr、eval、esec、repr、hash

abs：绝对值函数

round：四舍五入函数（注：n.5 n为偶数则舍去，n.5 n为奇数，则进一）注：其余情况正常四舍五入

sum：计算序列的和，列表、集合、元组、字典皆可，注：字典只会取到键，所有元素必须是数字，不能是字符或其它

max：获取列表里面的最大值（高级函数）

min：获取列表里面的最小值（高级函数）

​ 列表、集合、元组、字典皆可，注：字典只会取到键，所有元素必须是数字，不能是字符或其它

sorted：找出最大值和最小值，注：字典只有键（高级函数）

pow：计算某个数值的n次方，注：两个参数是计算n次方，三个参数是计算n次方后对第三个参数取余

range：产生指定范围的可迭代对象

bin：将十进制数转化为二进制数

oct：将十进制数转化为八进制数

hex：将十进制数转化为十六进制数

chr：将ASCII编码转换为字符

eval：将字符串当作python代码执行

esec：将字符串当作python代码执行（功能更强大）

​ 注：慎用eval和esec尤其是在和用户交互数据的时候

repr：不转义字符输出字符串

hash：生成哈希值，两个相同的字符串，无论哈希多少次，都会产生相同的唯一值

​ hash的两个作用：给密码加密和文件的校验，比较文件内容

# abs
intvar = -16
ret = abs(intvar)
print(ret)

# round
fvar1 = 3.5
fvar2 = 4.5
fvar3 = 4.51
fvar4 = 4.2
fvar5 = 3.2
print(round(fvar1), round(fvar2), round(fvar3), round(fvar4), round(fvar5))

# sum
lst = (1, 2, 3, 4, 5)
lst = [1, 2, 3, 4, 5]
lst = {1, 2, 3, 4, 5}
lst = {1: 2, 3: 4}
ret = sum(lst)
print(ret)

# max,min
lst = [10, 100, -3, 40]
lst = (10, 100, -3, 40)
lst = {10, 100, -3, 40}
lst = {10: 100, -3: 40}
maxvar = max(lst)
minvar = min(lst)
print(maxvar, minvar)

# sorted
lst = [10, 100, -3, 40]
lst = (10, 100, -3, 40)
lst = {10, 100, -3, 40}
lst = {10: 100, -3: 40}
lst_new = sorted(lst)
maxvar = lst_new[-1]
minvar = lst_new[0]
print(maxvar, minvar)

lst = [("a", 25), ("b", 50), ("c", 18)]
def func(n):
    return n[-1]
ret1 = min(lst, key=func)
ret2 = max(lst, key=func)
print(ret1, ret2)

# pow
ret = pow(2, 3)
print(ret)
ret = pow(2, 3, 5)
print(ret)

# range
for i in range(1, 11, 3):
    print(i)
for i in range(10, 0, -3):
    print(i)

# bin oct hex
res = bin(5)
print(res)
res = oct(8)
print(res)
ret = hex(255)
ret = hex(16)
print(ret)

# chr
ret = chr(65)
print(ret)
ret = chr(97)
print(ret)

# eval
strvar = "print('123')"
print(strvar)
eval(strvar)

# exec
strvar = "a = 10"
strvar = '''
for i in range(10):
    print(i)
'''
exec(strvar)
# print(a)

# repr
ret = "E:\workspace3.6\text"
print(repr(ret))

# hash
strvar1 = "abccc"
strvar2 = "abccc"
print(hash(strvar1))
print(hash(strvar2))
with open("ceshi1.txt",mode="r",encoding="utf-8") as fp:
    strvar = fp.read()
    res1 = hash(strvar)

with open("ceshi2.txt",mode="r",encoding="utf-8") as fp:
    strvar = fp.read()
    res2 = hash(strvar)

print(res1,res2)

4、pickle序列化模块

（转化字节流）

dumps、loads、dump、load

文件内部进行数据序列化操作时用：dump、load

文件外部进行数据序列化操作时用：dumps、loads

使用方式：import 导入 pickle 模块 import pickle

序列化：把不能直接存储在文件中的数据变得可存储，这个过程就是序列化

反序列化：把文件中的数据取出，恢复成原来的数据类型，这个过程就是反序列化

文件中存储两种存储形式：字符串和字节流

import pickle
# 列表
lst = [1, 2, 3]
res = pickle.dumps(lst)
print(res)

# 函数
def func():
    print("函数")
res = pickle.dumps(func)
print(res)

# 迭代器
it = iter(range(10))
res = pickle.dumps(it)
print(res)

res = pickle.loads(res)
print(res, type(res))
for i in range(4):
    res2 = next(res)
    print(res2)

# 文件S 
dic = {'a': 1, 'b': 2}
with open("ceshi3.txt", mode="wb") as fp:
    pickle.dump(dic, fp)
with open("ceshi3.txt", mode='rb') as fp:
    res = pickle.load(fp)
print(res, type(res))

5、json序列化模块

（转化字符串）

编程语言通用的序列化方式，序列化成字符串，

可序列化成字符串的类型：int、float、bool、str、list、tuple、dict、None

dumps、loads、dump、load

使用方式：import 导入 json 模块 import json

load：文件中是一次性反序列化所有数据

loads：文件中是一次性反序列化一行数据

json和pickle的区别：

​ json可连续dump，不可连续load

​ pickle可连续dump，可连续load

json的dumps两个参数：ensure_ascii=False 不通过ascii来显示内容 sort_keys=True 对字典的键来进行排序

try … except … 抛出异常

注：当进行多次dump操作的时候，load会出错，可以使用loads操作

import json

# 字典
dic = {"name": "eric", "age": 30, "classroom": "python30", "family": ["阿斯蒂", "阿松大", "阿萨德", "阿什顿"]}

ret = json.dumps(dic, ensure_ascii=False, sort_keys=True)
print(ret, type(ret))

dic = json.loads(ret)
print(dic, type(dic))

# 文件
with open("ceshi5.json", mode="w", encoding="utf-8") as fp:
    json.dump(dic, fp, ensure_ascii=False)

with open("ceshi5.json", mode='r', encoding='utf-8') as fp:
    ret = json.load(fp)
print(ret, type(ret))

# 多次dump json
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')
with open("ceshi6.json", mode='r', encoding="utf-8") as fp:
    for i in fp:
        dic = json.loads(i)
        print(dic)

# 多次dump pickle
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="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:
    with open("ceshi7.pkl", mode="rb") as fp:
        while True:
            dic = pickle.load(fp)
            print(dic)
except:
    pass