python常用模块详解2

Posted zycorn

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了python常用模块详解2相关的知识,希望对你有一定的参考价值。

序列化模块补充:

1.json格式的限制,json格式的key必须是字符串数据类型
2.json格式的字符串必须是""
如果数字是key,那么dump之后会强转成字符串数据类型
import json
dic = {1:2,3:4}
str_dic = json.dumps(dic)
print(str_dic)#{"1": 2, "3": 4}
new_dic = json.loads(str_dic)
print(new_dic)#{‘1‘: 2, ‘3‘: 4}
json是否支持元组,对元组做value的字典会把元组强制转换为列表.
import json
dic = {"abc":(1,2,3)}
str_dic = json.dumps(dic)
print(str_dic)#{"abc": [1, 2, 3]}
new_dic = json.loads(str_dic)
print(new_dic)#{‘abc‘: [1, 2, 3]}
json是否支持元组做key?不可以.
import json
dic = {(1,2,3):"abc"}
str_dic = json.dumps(dic)
print(str_dic)#TypeError: keys must be a string
new_dic = json.loads(str_dic)
print(new_dic)
对列表的dump.
import json
lst = [1,2,"abc",12.3]
with open("json_demo",w)as f:
    json.dump(lst,f)
with open(json_demo)as f:
    ret = json.load(f)
    print(ret)#[1, 2, ‘abc‘, 12.3]
能不能多次dump数据到文件里,可以多次dump但不能load出来.
import json
dic = {abc:(1,2,3)}
lst = [1,2,3,"abc",12.3]
with open(json_demo,w)as f:
    json.dump(dic,f)
    json.dump(lst,f)    #{"abc": [1, 2, 3]}[1, 2, 3, "abc", 12.3]
with open("json_demo")as f:
    ret = json.load(f)
    print(ret)
想dump多个数据到文件里用dumps
import json
dic = {abc:(1,2,3)}
lst = [1,2,3,"abc",12.3]
with open("json_demo",w)as f:
    str_dic = json.dumps(dic)
    str_lst = json.dumps(lst)
    f.write(str_dic+"
")
    f.write(str_lst+
)
with open(json_demo)as f:
    for line in f:
        ret = json.loads(line)
        print(ret)
#{‘abc‘: [1, 2, 3]}
#[1, 2, 3, ‘abc‘, 12.3]
中文格式 (ensure_ascii = False)
import json
dic = {"abc":(1,2,3,),"country":"中国"}
ret = json.dumps(dic,ensure_ascii=False)
print(ret)#{"abc": [1, 2, 3], "country": "中国"}
dic_new = json.loads(ret)
print(dic_new)#{‘abc‘: [1, 2, 3], ‘country‘: ‘中国‘}

with open("json_demo","w")as f:
    json.dump(dic,f)
with open("json_demo")as f:
    ret = json.load(f)
    print(ret)#{‘abc‘: [1, 2, 3], ‘country‘: ‘中国‘}
json的其他参数,是为了用户看的更方便,但是会相对浪费空间.
import json
data = {"username":["李华","李二楞"],"sex":"male",age:21}
json_dic = json.dumps(data,sort_keys=True,indent=4,separators=(,,:),ensure_ascii=False)
print(json_dic)
# {
#     "age":21,
#     "sex":"male",
#     "username":[
#         "李华",
#         "李二楞"
#     ]
# }
注:set不能被dump/dumps
序列化模块之pickle

dump的结果是bytes,dump用的f文件句柄需要以wb的形式打开,load所用的模式是rb模式
支持几乎所有对象的序列化
对于对对象的序列化需要这个对象的类在内存中
对于多次的dump和load的操作做了良好的处理
import pickle
dic = {1:(1,2,3),("abc","def"):1.23}
pic_dic = pickle.dumps(dic)
print(pic_dic)#bytes类型
new_dic = pickle.loads(pic_dic)
print(new_dic)#{1: (1, 2, 3), (‘abc‘, ‘def‘): 1.23}
pickle几乎支持所有对象的序列化.
import pickle
class Student:
    def __init__(self,name,age):
        self.name = name
        self.age = age

alex = Student("alex",83)
ret = pickle.dumps(alex)
print(ret)#bytes类型
new_ret = pickle.loads(ret)
print(new_ret.name)#alex
print(new_ret.age)#83

with open("pickle_demo",wb)as f:
    pickle.dump(alex,f)
with open("pickle_demo",rb)as f:
    a = pickle._load(f)
    print(a.name)#alex
    print(a.age)#83
序列化模块之shelve:
import shelve
f = shelve.open("shelve_demo")
f[key] = {k1:123,k2:k3}
f.close()
f = shelve.open("shelve_demo")
ret = f[key]
f.close()
print(ret)#{‘k1‘: 123, ‘k2‘: ‘k3‘}
shelve如果你写定了一个文件,改动的比较少,读文件的操作比较多,且你大部分的读取都需要基于某个key获得某个value

hashilib模块(摘要算法的模块):

能够把一个字符串的数据类型的变量转换成一个定长的,密文的字符串,字符串里的每一个字符都是一个十二禁止的数字

对于同一个字符串,不管这个字符串有多长,只要是相同的,无论在任何环境下,多少次执行,在任何语言中,
使用相同的算法/相同的手段得到的结果都是相同的.如果不是相同的字符串,得到的结果一定不同
算法:对于相同的字符串,用相同的算法,相同的手段,得到的值一定是相同的
md5是一个算法,32位的字符串,每个字符都是一个十六进制
md5算法:效率快,算法相对简单

import hashlib
s1 = alex3714
s2 = alex21348174612571
md5_obj = hashlib.md5()
md5_obj.update(s1.encode("utf-8"))
res = md5_obj.hexdigest()
print(res,len(res),type(res))
#aee949757a2e698417463d47acac93df 32 <class ‘str‘>
数据库->撞库
import hashlib
s1 = 1232312
md5_oobj = hashlib.md5()
md5_oobj.update(s1.encode(utf-8))
res = md5_oobj.hexdigest()
print(res,len(res),type(res))
# f7fc239ea412bcec46a2c6ca3a58c517 32 <class ‘str‘>
加盐
import hashlib
s1 = corn123#1c22330a641d90698dbdf1ae3a10a6a6 32 <class ‘str‘>
md5_obj = hashlib.md5(任意的字符串作为盐.encode(utf-8))
md5_obj.update(s1.encode(utf-8))
res = md5_obj.hexdigest()
print(res,len(res),type(res))
#00ed5d09379b4287cc1654705aeb6cd8 32 <class ‘str‘>
动态加盐:
用用户名作为加盐,因为用户名不能相同,这样比较安全.
import hashlib
username = input(username>>>)
password = input("password>>>")
md5_obj = hashlib.md5(username.encode("utf-8"))
md5_obj.update(password.encode(utf-8))
res = md5_obj.hexdigest()
print(res,len(res),type(res))
sha1也是一种算法,40位的字符串,每个字符都是一个十六进制.
算法相对复杂,计算也慢.
import hashlib
s1 = corn
sha1_obj = hashlib.sha1()
sha1_obj.update(s1.encode(utf-8))
res = sha1_obj.hexdigest()
print(res,len(res),type(res))
#7cacb75c4cc31d62a6c2a0774cf3c41a70f01bc0 40 <class ‘str‘>
sha1算法加盐.
import hashlib
s1 = corn
sha1_obj = hashlib.sha1(123.encode(utf-8))
sha1_obj.update(s1.encode(utf-8))
res = sha1_obj.hexdigest()
print(res,len(res),type(res))
#dbd08e07817591b800c61a43ab5664bbf65a4b69 40 <class ‘str‘>
sha1算法动态加盐.
import hashlib
username = input("username>>>")
password = input("password>>>")
sha1_obj = hashlib.sha1(username.encode(utf-8))
sha1_obj.update(password.encode(utf-8))
res = sha1_obj.hexdigest()
print(res,len(res),type(res))
md5和sha1的区别:
md5:32位字符串,目前 MD5 是一种不可逆算法。具有很高的安全性。它对应任何字符串都可以加密成一段唯一的固定长度的代码。
sha1:40位字符串,sha1基于md5,加密后的数据长度更长,它对长度小于 24的输入,产生长度为160bit的散列值.比md5多32位.因此,比md5更加安全,但sha1的运算速度就比md5要慢了。

文件的一致性校验.
import hashlib
md5_obj = hashlib.md5()
with open(shelve_demo.dir,rb)as f:
    md5_obj.update(f.read())
    ret = md5_obj.hexdigest()
md5_obj = hashlib.md5()#需要实例化两次
with open("shelve_demo.bak",rb)as f:
    md5_obj.update(f.read())
    ret1 = md5_obj.hexdigest()
    print(ret,ret1)
#d4d69a04f38df23025caf0ed85f9961c d4d69a04f38df23025caf0ed85f9961c

 

configparser模块:
有一种固定格式的配置文件,有一个对应的模块去帮你做这个文件的字符串处理

setting.py 配置
import configparser

corn = configparser.ConfigParser()
corn[DEFAULT] = {ServerAliveInterval:45,
                   Compression:yes,
                   CompressionLevel:9,
                   ForwardX11:yes
                   }

corn[bitbucket.org] = {User:hg}
corn[topsecret.serve.com] = {Host port:50022,ForwardX11:no}

with open(example.ini,w)as f:
    corn.write(f)

 

logging模块:

1.日志格式的规范
2.操作的简化
3.日志的分级管理

logging 不能帮你做的事情.
1.自动帮你打印你要打印的内容
2.需要程序员自己在开发过程中定义好
3.在哪些地方需要打印,要打印的内容是什么,内容级别

logging模块的使用:
1.普通配置型 简单的,可定制化差
2.对象配置型 复杂的,可定制化强

认识日志分级
import logging

logging.debug("debug message")  #调试模式
logging.info("info message")    #基础信息
logging.warning("warning message")#警告
logging.error("error message")  #错误
logging.critical("critical message")#严重错误

import logging
logging.basicConfig(level=logging.DEBUG,
                    format=%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s,
                    datefmt=%a, %d %b %Y %H:%M:%S,
                    filename=test.log)
logging.debug(debug message)      # 调试模式
logging.info(info message)        # 基础信息
logging.warning(warning message)  # 警告
logging.error(error message)      # 错误
logging.critical(critical message)# 严重错误

basicConfig
# 不能将一个log信息既输出到屏幕 又输出到文件
logger对象的形式来操作日志文件

创建一个logger对象
创建一个文件管理操作符
创建一个屏幕管理操作符
创建一个日志输出的格式

文件管理操作符 绑定一个 格式
屏幕管理操作符 绑定一个 格式

logger对象 绑定 文件管理操作符
logger对象 绑定 屏幕管理操作符

import logging
# 创建一个logger对象
logger = logging.getLogger()
# 创建一个文件管理操作符
fh = logging.FileHandler(logger.log,encoding=utf-8)
# 创建一个屏幕管理操作符
sh = logging.StreamHandler()
# 创建一个日志输出的格式
format1 = logging.Formatter(%(asctime)s - %(name)s - %(levelname)s - %(message)s)

# 文件管理操作符 绑定一个 格式
fh.setFormatter(format1)
# 屏幕管理操作符 绑定一个 格式
sh.setFormatter(format1)
logger.setLevel(logging.DEBUG)
# logger对象 绑定 文件管理操作符
# logger.addHandler(fh)
# logger对象 绑定 屏幕管理操作符
logger.addHandler(sh)

logger.debug(debug message)      # 调试模式
logger.info(我的信息)        # 基础信息
logger.warning(warning message)  # 警告
logger.error(error message)      # 错误
logger.critical(critical message)# 严重错误

 

以上是关于python常用模块详解2的主要内容,如果未能解决你的问题,请参考以下文章

常用模块详解

python3 常用模块详解

python之路-基础篇-常用模块详解

26.Python文件I/Oos模块&shutil模块详解

python中math模块的常用详解

26.Python文件I/Oos模块&shutil模块详解