python3.x Day4 模块！！

json and pickle模块

用途是为了持久化信息，这种持久化方式可以和其他程序语言兼容，一般都支持json，json只能持久化数据，pickle是python特有的方式，可以持久化所有信息和数据结构

#json,pickle的序列化和反序列化
 
import json,pickle
 
#序列化
info={
    'name':"wy",
    'age':22
}
print(info["age"])
# with open("json_test.txt",mode="w",encoding="utf-8") as f:
#     f.write( json.dumps(info))
#完全等同于
with open("json_test.txt",mode="w",encoding="utf-8") as f:
    json.dump(info,"json_test.txt")
with open("json_test.txt", mode="wb", encoding="utf-8") as f:
    json.dump(info, "json_test.txt")
    pickle.dump(info,"json_test.txt")
 
#反序列化
 
# with open("json_test.txt",mode="r",encoding="utf-8") as f:
#     data=json.loads(f.read())
with open("json_test.txt",mode="r",encoding="utf-8") as f:
    data=json.load("json_test.txt")
with open("json_test.txt",mode="rb",encoding="utf-8") as f:
    data=pickle.load("json_test.txt")
 
print(data["age"])
 
#json对于基础数据类型字典的序列化和反序列化，所有语言通用，可以通过json来在不同语言之间传递数据。
#pickle，对于全部数据类型字典的序列化和反序列化，只能python使用，具体使用方法和json一样的。
 
#重要：程序中，每个序列化文件只dump一次，每次load一个序列化文件！！！

time模块

import time
# 标准库：
# 1、time和datetime
# a.time模块：
#提供属性：
#         timezone，获取当前时区的秒数，北京时间东八区为28800
#         altzone，与GMT与夏令时之间换算的秒数
#         daylight，是否使用了夏令时，0代表没有使用，1代表使用
#         tzname，不知道
#提供方法：
time.time()#，获取当前时间，GMT时间，秒数，当前时间减掉1970.1.1 00:00:00，时间戳
time.sleep()#，睡几秒。。。。
time.gmtime()#，传入一个时间戳秒数，返回一个九位元组，不传则返回当前标准时间的元组，结果是UTC时区
time.localtime()#，传入一个时间戳秒数，返回一个九位元组，不传则返回当前标准时间的元组，结果是UTC+8时区（常用），做定时任务？直接取 呵呵
time.mktime()#，传入一个元组，转为一个秒数时间戳。
time.strftime()#，一个九位元组转为格式化字符串时间，参数("%Y-%m-%d %H:%M:%S",时间九位元组)
time.strptime()#，格式化字符串时间，转为格式九位元组，要传入一个格式化日期，参数(字符串时间，"%Y-%m-%d %H:%M:%S")
time.asctime()#，传一个九位元组，返回一个字符串，接收九位元组
time.ctime()#，传一个时间戳秒数，返回一个字符串，接收秒数

datetime模块

import datetime
# b.datetime模块（平时主要使用这个）：
    # 提供属性：
    #     datetime类
    # 提供方法：
datetime.datetime.now() #获取当前时间
datetime.datetime.now()+datetime.timedelta(3) #timedelta()方法无法单独使用，与now()方法结合来计算3天后的时间，
datetime.datetime.now()+datetime.timedelta(-3) #timedelta()方法无法单独使用，与now()方法结合来计算3天前的时间，
datetime.datetime.now()+datetime.timedelta(hours=3) #计算3小时后的时间。
datetime.datetime.now()+datetime.timedelta(hours=-3) #计算3小时前的时间。
datetime.datetime.now()+datetime.timedelta(minutes=30) #计算30分钟后的时间。
 
datetime.datetime.now().replace(minute=3,hour=2) #时间替换，改改分钟，改改小时
 
# 时间有三种形式：
# a.时间戳
# b.格式化字符串
# c.九位元组

random模块，取随机数的

import random
#random函数：
#简易的验证码，可以考虑这么干
random.random() #获取0 - 1之间随机的浮点数
random.uniform(1,10) #获取1-10之间随机1个浮点数
random.randint(1,7) #获取包括1,7在内的 随机整数
random.randrange(1,7) #获取包括1，不包括7在内的随机整数
random.choice([]) #传入一个列表随机取1个元素
random.sample([],3)#传入一个列表，随机取3个元素
random.shuffle([]) #把传入的一个列表，顺序随机打乱

os模块，怼操作系统用的

import os
 
#os模块用于操作操作系统
 
os.getcwd() #获取当前的工作路径
os.chdir("path")#切换工作路径,推荐使用os.chdir(r"c:\Users")
os.curdir #当前路径
os.pardir #父级路径
os.makedirs(r"c:\a\b\c") #递归的创建路径
os.removedirs(r"c:\a\b\c") #递归删除空路径
os.mkdir(r"c:\a\b") #生成单级路径，相当于linux mkdir
os.rmdir(r"c:\a\b") #删除单级路径。
os.listdir(r"c:\a\b") #查看路径下的东西，返回list
os.remove(r"c:\a\b") #删除一个文件
os.rename("oldname","newname") #文件重命名
os.stat(r"c:\a\b") #返回文件状态信息。
 
os.sep #很重要，这个属性是，系统的分隔符，主要用于跨平台
os.linesep #很重要，这个属性是，系统的换行符，主要用于跨平台
os.environ #很重要，返回系统的环境变量
os.pathsep #很重要，路径的分隔符，分隔的是路径，比如环境变量。
 
os.name #返回程序运行的操作系统简称标记
os.system("xxxx") #用于执行命令
 
os.path.abspath("xxx") #获取某文件的绝对路径
os.path.split("xxxx\\xxxx") #分割路径和文件，返回元组，元素1是路径，元素2是文件
os.path.dirname("xxxx") #返回传入路径的所在路径
os.path.basename("xxxx") #返回路径中的最后的
os.path.exists("xxxx") #返回路径是否存在
os.path.isabs("xxxx") #是否为绝对路径
os.path.isfile("xxxx") #判断是否是一个文件
os.path.isdir("xxxx") #判断是否为一个路径
os.path.join("xxx","mmm") #组合路径结果。如果绝对路径没有出现在第一个参数，而出现在后边了，那前边的参数就被忽略了
os.path.getatime("xxxx") #获取文件的最后存取时间，时间戳
os.path.getmtime("xxxx") #获取文件的修改存取时间，时间戳

shutil文件操作用的

import shutil #用于文件操作。
 
#用户拷贝文件
file1=open("xxxx","r",encoding="utf-8")
file2=open("xxxx2","w",encoding="utf-8")
shutil.copyfileobj(file1,file2) #把file1 文件指针流灌输到 file2文件指针流
shutil.copyfile("xxxx","xxxx2") #把xxxx 拷贝到xxxx2
shutil.copymode() #仅拷贝权限，内容，组，用户，均不变
shutil.copystat() # 仅拷贝了文件状态，什么修改时间，权限，之类的，linux更好用点
shutil.copy("xxxx","xxxx2") #拷贝文件和权限
shutil.copy2("xxxx","xxxx2") #完全拷贝文件和权限。
 
shutil.copytree("xxxx","xxxx2") #完全的整个的 把目录树下的东西 连根复制到另一个路径去 #有用
shutil.rmtree("xxxx") #完全删掉整个目录树 #有用
 
shutil.move() #递归的去移动文件
 
shutil.make_archive("xxxx","gztar","mode2_2") #压缩文件，xxxx压缩以后的文件名，gztar压缩格式，mode2_2被压缩的路径，压缩格式支持，zip gztar tar bztar

sys模块 python环境用的

import sys
 
# 获取脚本名字
print 'The name of this program is: %s' %(sys.argv[0])
# 获取参数列表
print 'The command line arguments are:'
for i in sys.argv:
    print i
# 统计参数个数
print 'There are %s arguments.'%(len(sys.argv)-1)
 
sys.platform #获取当前执行环境的平台，如win32表示是Windows 32bit操作系统，linux2表示是linux平台；
 
sys.path #path是一个目录列表，供Python从中查找第三方扩展模块。在python启动时，sys.path根据内建规则、PYTHONPATH变量进行初始化。
 
sys.builtin_module_names #返回一个列表，包含内建模块的名字
sys.exit(n) #调用sys.exit(n)可以中途退出程序，当参数非0时，会引发一个SystemExit异常，从而可以在主程序中捕获该异常

configparser模块，用于读取ini格式配置文件，我最喜欢的配置文件形式

import configparser,os
conf_file=os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))+os.sep+"conf"+os.sep+"transact_setting.conf"
 
config=configparser.ConfigParser() #得到一个配置文件实例
 
config.read(conf_file)
 
def get_config():
    return config #用这个config实例，就当个字典用就ok了

hashlib用来加密的

import hashlib,hmac,datetime
 
pwd="welkjasf199725" #这是输入的密码
 
odtm=datetime.datetime.now()
for i in range(1000000):
    mmm=hashlib.sha256() #使用sha256算法，还有其他很多算法
    mmm.update(str(i).encode("utf-8")) #update就是给mmm算法实例赋值
    mmm.hexdigest() #进行加密计算
ndtm=datetime.datetime.now()
print(ndtm-odtm)

logging模块，很重要，输出日志用的

import logging
 
# #日志级别 先后顺序：
# logging.debug("dddddddddddd")
# logging.info("kkkkkkkkkkkk")
# logging.warning("gogogogogogo")
# logging.error("eeeeeeeeeeeeee")
# logging.critical("stopstopstop")
#
# #输出日志到文件
# logging.basicConfig(filename="mode_error.log",
#                      level=logging.DEBUG,
#                      datefmt="%Y-%m-%d %H-%M-%S",
#                      format="%(asctime)s-[%(levelname)s]:%(filename)s - %(module)s - %(funcName)s,on:%(lineno)d %(message)s")
# logging.debug("dddddddddddd")
# logging.info("kkkkkkkkkkkk")
# logging.warning("gogogogogogo")
# logging.error("eeeeeeeeeeeeee")
# logging.critical("stopstopstop")
 
#创建一个logger对象
logger=logging.getLogger("TEST_LOGGER")
logger.setLevel(logging.DEBUG)
 
#设定一个屏幕handler（console handler） 并且设定一个级别
ch=logging.StreamHandler()
ch.setLevel(logging.WARNING)
 
#设定一个文件handler（file handler ）并且设定一个级别
fh=logging.FileHandler("mode_error.log",encoding="utf-8")
fh.setLevel(logging.ERROR)
 
#定义日志格式：
fh_formatter=logging.Formatter("%(asctime)s-[%(levelname)s]:%(filename)s - %(module)s - %(funcName)s,on:%(lineno)d %(message)s")
ch_formatter=logging.Formatter("%(asctime)s-[%(levelname)s]:on:%(lineno)d %(message)s")
 
#关联日志格式
fh.setFormatter(fh_formatter)
ch.setFormatter(ch_formatter)
 
#把 各个handler加入到logger
logger.addHandler(fh)
logger.addHandler(ch)
 
#开始使用日志
logger.error("loger loger loger")
logger.warning("dddddddddddddddddddddddddddddddddddddd")

re 也挺重要的，正则表达式模块

import re
 
a=re.match("","")#第一个参数是正则规则，第二个参数是需要匹配的字符串，match是从左到有匹配
a.group() #显示出来匹配到的东西
 
# 正则表达式
"." #匹配除\n外的字符，可以匹配特殊字符
"+" #匹配一次或者多次。
"^" #匹配开头，match方法下"^"没啥意义
"*" #匹配*号前边的字符0次或多次。
"?" #匹配一个字符1次或0次。
"$" #匹配字符结尾
"{m}"#匹配前一个规则m次。
"{n,m}"#匹配前一个规则n到m次
"|" #匹配re.match("abc|ABC","abcdefgABCDEFG") 匹配两边都算数
"(. . . )" #多个规则匹配后，结果分组，用a=re.match().groups()方法获取，返回的是元组
 
"\A" # 和 "^"一样的
"\Z" # 和 "$"一样的
"\w" #匹配[A-Z0-9a-z]的一个字符一次，必须匹配到一次，否则异常。
"\W" #匹配非[A-Z0-9a-z]的一个字符一次
"\d" #匹配数字0-9
"\D" #匹配非数字
"s" #匹配空白字符：\t \n \r 什么的
 
m=re.search("(?P<name>\d{2})(?P<sex>\d{4})(?P<savings>\d{3})","").groupdict() #这样取字典
print(m)
 
#re的方法
re.match("","")#第一个参数是正则规则，第二个参数是需要匹配的字符串，match是从左到有匹配
re.search("","")#第一个参数是正则规则，第二个参数是需要匹配的字符串，search是在字符串中搜索,仅匹配一次
re.findall("","")#第一个参数是正则规则，第二个参数是需要匹配的字符串，findall是按照规则全部取出，变成列表。
re.split("","")#第一个参数是正则规则，第二个参数是需要匹配的字符串，split是按照规则匹配，再按照匹配到的为分隔符，分割字符串
re.sub("","","",count=2) #第一个参数是正则，第二个参数是要替换为的东西，第三个参数是被匹配的字符串，第四个参数是替换几次，不写就全部替换
 
#如果想要匹配转义符 斜杠\ （遭遇的字符串里本来就有）那就需要\\\\4个斜杠来做这事，这是匹配一个\
# [^()] #中括号里边的^号 就是不包含的意思