一、序列号模块(*****)
1.1 什么是序列化,反序列化
# 序列化: 把内存中的数据转化成一种中间的格式（json或pickle），然后存放在硬盘中，永久保存 # 反序列化：从硬盘中读出（json或pickle）格式，然后反解成python 的数据类型
1.2 为什么要使用序列化
# 1、数据格式的持久化 # 2、跨平台交互
1.3 如何使用序列化
import json dict = {'name':'jmz','age':23,'sex':'boy','school':{'small_school':'lala','middle_school':'chajj school'}} with open('json.txt','w',encoding='utf-8') as f: f.write(json.dumps(dict)) # json.dump(dict,f) # 这是上面的简写 with open('json.txt','r',encoding='utf-8') as f: res = json.loads(f.readline()) # res = json.load(f) # 上面的简写 print(res['name'])
import pickle def func(name): print(name) dict = {'name':'jmz','school with open('pick.pkl','wb') a # pickle 只保存 bytes 类型的数据 f.write(pickle.dumps(dic # pickle.dump(dict,f) with open('pick.pkl','rb') a res = pickle.loads(f.rea # res = pickle.load(f) print(res) res['func'](res['name'])
1.4 总结
# json： # 优点：所有的语言都支持json # 缺点：只支持 部分的python 数据类型 # pickle: # 优点：支持所有的python 数据类型 # 缺点：只有python 语言支持 # 注意： # pickle 在保存数据时，只保存bytes类型，在转化成pickle 时已是bytes类型了
二、hash模块(*****)
2.1 什么是hash
# hash 是一种算法，该算法是用来效验数据内容的 # 多数用来加密数据，保证数据的安全。
2.2 怎么使用
import hashlib m1= hashlib.md5() # 创建 一个md5的工厂 m1.update('中文'.encode('utf-8')) # 向 工厂中添加内容 # 注意内容必须是 bytes类型 print(m1.hexdigest()) # 得到hash 结果，md5 是固定32位的 hash算法加密 m2 = hashlib.sha512() m2.update(b'hello') m2.update(b'jmz') m2.update(b'shanghai') m2.update(b'haha') print(m2.hexdigest()) # sha512 是可变长的 hash算法加密
2.3 流程
# 流程: # 1、创建一个hash 工厂(hashlib.XXX()) # 2、向工厂中添加 bytes 数据。 一定要是 bytes 数据类型 # 3、得出hash算法后结果
三、日志模块(*****)
3.1 错误级别
# 1、debug 10 调试错误 # 2、info 20 提示错误 # 3、warning 30 警告错误 # 4、error 40 错误 # 5、critical 50 致命错误
3.2 日志基础使用(了解)
import logging logging.basicConfig( filename='access.log', format = '%(asctime)s - %(name)s -%(levelname)s -%(module)s:%(message)s', datefmt='%Y-%m-%d %X', level=10, # 可以接受的至少什么等级的错误 ) logging.debug('这是一个调试错误') logging.info('这是一个info错误') logging.warning('这是一个warining错误') logging.error('这是一个error错误') logging.critical('这是一个critical错误') # 中文错误在文件的编码使用的是系统的默认编码
3.3 日志原理(项目中不推荐使用,需了解)
#logger：产生日志的对象 #Filter：过滤日志的对象 #Handler：接收日志然后控制打印到不同的地方，FileHandler用来打印到文件中，StreamHandler用来打印到终端 #Formatter对象：可以定制不同的日志格式对象，然后绑定给不同的Handler对象使用，以此来控制不同的Handler的日志格式
#!/usr/bin/env python # -*- coding:utf-8 -*- # Author Jmz import logging # logger对象： 生成对象，产生atm日志 logger1=logging.getLogger('atm') # handle对象, 控制日志内容的去向，文件or终端 # FileHandler 文件 # StreamHandler 终端 a1=logging.FileHandler('a1.log',encoding='utf-8') a2=logging.FileHandler('a2.log',encoding='utf-8') ch = logging.StreamHandler() # 建立 logger 和 handle 之间的绑定关系 logger1.addHandler(a1) logger1.addHandler(a2) logger1.addHandler(ch) # Formatter 对象： 定制日志格式 format1 = logging.Formatter('%(asctime)s - %(name)s -%(levelname)s -%(module)s:%(message)s',datefmt='%Y-%m-%d %X') format2 = logging.Formatter('%(asctime)s-%(module)s:%(message)s',datefmt='%Y-%m-%d %X') # 为handle对象定制 日志格式 a1.setFormatter(format1) a2.setFormatter(format2) # 设置 保存 错误的级别 先 logger 后a1 or a2 # 先顶级过滤 logger 后 才是handle过滤 logger1.setLevel(10) a1.setLevel(20) a2.setLevel(30) # 输出错误 logger1.debug('这是一个bug错误') logger1.error('这是一个error错误') logger1.info('这是一个info错误')
format参数中可能用到的格式化串： %(name)s Logger的名字 %(levelno)s 数字形式的日志级别 %(levelname)s 文本形式的日志级别 %(pathname)s 调用日志输出函数的模块的完整路径名，可能没有 %(filename)s 调用日志输出函数的模块的文件名 %(module)s 调用日志输出函数的模块名 %(funcName)s 调用日志输出函数的函数名 %(lineno)d 调用日志输出函数的语句所在的代码行 %(created)f 当前时间，用UNIX标准的表示时间的浮 点数表示 %(relativeCreated)d 输出日志信息时的，自Logger创建以 来的毫秒数 %(asctime)s 字符串形式的当前时间。默认格式是 “2003-07-08 16:49:45,896”。逗号后面的是毫秒 %(thread)d 线程ID。可能没有 %(threadName)s 线程名。可能没有 %(process)d 进程ID。可能没有 %(message)s用户输出的消息
原理图
3.4 日志记录,公司常用
#!/usr/bin/env python # -*- coding:utf-8 -*- # Author Jmz """ logging配置 """ import os import logging.config # 定义三种日志输出格式 开始 standard_format = '[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]' \ '[%(levelname)s][%(message)s]' #其中name为getlogger指定的名字 simple_format = '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s' id_simple_format = '[%(levelname)s][%(asctime)s] %(message)s' # 定义日志输出格式 结束 logfile_dir = os.path.dirname(os.path.abspath(__file__)) # log文件的目录 logfile_name = 'all2.log' # log文件名 # 如果不存在定义的日志目录就创建一个 if not os.path.isdir(logfile_dir): os.mkdir(logfile_dir) # log文件的全路径 logfile_path = os.path.join(logfile_dir, logfile_name) # log配置字典 LOGGING_DIC = { 'version': 1, 'disable_existing_loggers': False, 'formatters': { 'standard': { 'format': standard_format }, 'simple': { 'format': simple_format }, }, 'filters': {}, 'handlers': { #打印到终端的日志 'console': { 'level': 'DEBUG', 'class': 'logging.StreamHandler', # 打印到屏幕 'formatter': 'simple' }, #打印到文件的日志,收集info及以上的日志 'default': { 'level': 'DEBUG', 'class': 'logging.handlers.RotatingFileHandler', # 保存到文件 'formatter': 'standard', 'filename': logfile_path, # 日志文件 'maxBytes': 1024*1024*5, # 日志大小 5M 'backupCount': 5, 'encoding': 'utf-8', # 日志文件的编码，再也不用担心中文log乱码了 }, }, 'loggers': { #logging.getLogger(__name__)拿到的logger配置 '': { 'handlers': ['default', 'console'], # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕 'level': 'DEBUG', 'propagate': True, # 向上（更高level的logger）传递 }, }, } def load_my_logging_cfg(): logging.config.dictConfig(LOGGING_DIC) # 导入上面定义的logging配置 logger = logging.getLogger(__name__) # 生成一个log实例 logger.info('It works!') # 记录该文件的运行状态 if __name__ == '__main__': load_my_logging_cfg()
四、正则模块(*****)
4.1 正则方法
_compile(pattern, flags) # 匹配正则 search(pattern,[string,],flags=0) ===> _compile(pattern, flags).search(string) # 查找符合正则规则的pattern的string, # 存在返回 匹配对象，不存在返回None re.search(pattern,string).group() # 返回第一个匹配到的结果，没有匹配则报错 split(pattern,string,maxsplit=0) # 以pattern 分割 string,并确认分割maxsplit份。默认分割全部，返回分割后的新列表 sub(pattern,repl,string) # 在string 将匹配(pattern)到的内容替换成repl 返回替换后的结果 findall(pattern,string) # 在 string 在 匹配到所有的pattern ，返回 列表 match(pattern,string) # 在string的起始位置开始匹配pattern，存在返回对象，不存在，返回None re.match(pattern,string).group(1) # 返回匹配到的下标为1的结果，下标为0则为本身
4.2 举例使用方式
import re content = 'asd3fdsjk43dsndf' print(re.findall('\d',content)) # ['3', '4', '3']
import re test = '+-dsad-+dsa--dd++' print(re.sub('\+\-','-',test)) # -dsad-+dsa--dd++
import re a = '23dasd2321dasdf3' # search().group() 只取都第一个 print(re.search('\d',a).group()) # 2 #单纯使用search 可以确认是否存在值,存在为真 不存在为假 if re.search('\d',a): print('ok') else: print('no') # ok
import re a = 'sda123dsa432' # 已什么作为分割点，分割， 1 别是分割1次 res = re.split('\d',a,1) print(res) # ['sda', '23dsa432']
import re content = 'jmz3s4[22],[3],[dsada]' res = re.match('.*?\[(.*?)\].*?\[(.*?)\].*?\[(.*?)\]',content) print(res.group()) # jmz3s4[22],[3],[dsada] print(res.group(1)) # 22 print(res.group(2)) # 3 print(res.group(3)) # dsada
五、os模块(*****)
os模块是与操作系统交互的一个接口
os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径 os.chdir("dirname") 改变当前脚本工作目录；相当于shell下cd os.curdir 返回当前目录: ('.') os.pardir 获取当前目录的父目录字符串名：('..') os.makedirs('dirname1/dirname2') 可生成多层递归目录 os.removedirs('dirname1') 若目录为空，则删除，并递归到上一级目录，如若也为空，则删除，依此类推 os.mkdir('dirname') 生成单级目录；相当于shell中mkdir dirname os.rmdir('dirname') 删除单级空目录，若目录不为空则无法删除，报错；相当于shell中rmdir dirname os.listdir('dirname') 列出指定目录下的所有文件和子目录，包括隐藏文件，并以列表方式打印 os.remove() 删除一个文件 os.rename("oldname","newname") 重命名文件/目录 os.stat('path/filename') 获取文件/目录信息 os.sep 输出操作系统特定的路径分隔符，win下为"\\",Linux下为"/" os.linesep 输出当前平台使用的行终止符，win下为"\t\n",Linux下为"\n" os.pathsep 输出用于分割文件路径的字符串 win下为;,Linux下为: os.name 输出字符串指示当前使用平台。win->'nt'; Linux->'posix' os.system("bash command") 运行shell命令，直接显示 os.environ 获取系统环境变量 os.path.abspath(path) 返回path规范化的绝对路径 os.path.split(path) 将path分割成目录和文件名二元组返回 os.path.dirname(path) 返回path的目录。其实就是os.path.split(path)的第一个元素 os.path.basename(path) 返回path最后的文件名。如何path以／或\结尾，那么就会返回空值。即os.path.split(path)的第二个元素 os.path.exists(path) 如果path存在，返回True；如果path不存在，返回False os.path.isabs(path) 如果path是绝对路径，返回True os.path.isfile(path) 如果path是一个存在的文件，返回True。否则返回False os.path.isdir(path) 如果path是一个存在的目录，则返回True。否则返回False os.path.join(path1[, path2[, ...]]) 将多个路径组合后返回，第一个绝对路径之前的参数将被忽略 os.path.getatime(path) 返回path所指向的文件或者目录的最后存取时间 os.path.getmtime(path) 返回path所指向的文件或者目录的最后修改时间 os.path.getsize(path) 返回path的大小
在Linux和Mac平台上，该函数会原样返回path，在windows平台上会将路径中所有字符转换为小写，并将所有斜杠转换为饭斜杠。 >>> os.path.normcase('c:/windows\\system32\\') 'c:\\windows\\system32\\' 规范化路径，如..和/ >>> os.path.normpath('c://windows\\System32\\../Temp/') 'c:\\windows\\Temp' >>> a='/Users/jieli/test1/\\\a1/\\\\aa.py/../..' >>> print(os.path.normpath(a)) /Users/jieli/test1
os路径处理 #方式一：推荐使用 import os #具体应用 import os,sys possible_topdir = os.path.normpath(os.path.join( os.path.abspath(__file__), os.pardir, #上一级 os.pardir, os.pardir )) sys.path.insert(0,possible_topdir) #方式二：不推荐使用 os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
六、sys模块(****)
1 sys.argv 命令行参数List，第一个元素是程序本身路径 2 sys.exit(n) 退出程序，正常退出时exit(0) 3 sys.version 获取Python解释程序的版本信息 4 sys.maxint 最大的Int值 5 sys.path 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值 6 sys.platform 返回操作系统平台名称
import time # print('\r[# ]',end='') # time.sleep(0.3) # print('\r[### ]',end='') # time.sleep(0.3) # print('\r[####### ]',end='') # time.sleep(0.3) # print('\r[###########]',end='') # x = 0 # while x <= 50: # print('\r[%-50s] %d%%'%(x*'#',x//50*100),end='') # %-50s 表示总共50个字符，不足以空格补充 # x+=10 # time.sleep(0.3) def proccess(x,width=40): if x > 1: x =1 pro_format = ('[%%-%ds]'%width) %(int(x*width)*'#') # '%%' 表示% res = '%s %d%%'%(pro_format,int(x*100)) print('\r %s'%res,end='') start =0 total = 10484 while start <= total: start += 1024 proccess(start/total) time.sleep(0.3) # 补充知识点 1 # 在windows 中 \r 表示光标移动至行首， \n 跳到下一行，光标不变 # linux \n 表示就是\r\n # 补充知识点2 # %-30s 表示共30个字符，不足以空格补充 # %% 表示%， 因为格式化操作 % 有特殊意义 # ('[%%-%ds]'%10)%('###') ===> '[%-10s]'%('###') ===> [### ]
七、random 随机模块(*****)
1 random.random() # (0,1) 0-1 之间取不到0和1 2 random.randint(2,5) # [2,5] 取2与5之间的整数 3 random.choice([1,2,['jmz','ggf'],'aa']) # 在 [1,2,['jmz','ggf'],'aa'] 列表 中随机取一个返回 4 random.sample([1,2,['jmz','ggf'],'aa'],2) # 在 [1,2,['jmz','ggf'],'aa'] 列表中 随机取2个组成新的列表 5 random.shuffle([1,2,['jmz','ggf'],'aa']) # 将列表的下标打乱。 6 random.uniform(4,6) # （4,6） 取大于4小于6的小数
import random print(random.random()) # (0,1) 去小数 # 0.644271281361324 print(random.randint(2,4)) # [2,4] # 4 print(random.choice([1,2,3,['a','jmz']])) # 在[1,2,3,['a','jmz']] 中随机取一个 # 2 print(random.sample([1,2,3,['a','jmz']],2)) # [1,2,3,['a','jmz']] 中取两个 组成 新历史列表 # [3, 2] print(random.uniform(2,5)) # 4.7414246822271595 l = ['a','d',3,4,5] print(random.shuffle(l)) # None print(l) # ['d', 'a', 3, 5, 4]
# ascii编码表 十进制数与字符的转化 # chr() ord() # 十进制 转 字符 print(chr(43)) # 字符装 十进制数 print(ord('+'))
import random def make_code_one(): ''' 随机生成以为字符 a-z A-Z 0-9 :return: ''' s1 = random.randint(ord('a'),ord('z')) s2 = random.randint(ord('A'),ord('Z')) s3 = random.randint(ord('0'),ord('9')) res = random.choice([s1,s2,s3]) return chr(res) def make_code(n): res = '' for i in range(n): res = res + make_code_one() return res print(make_code(4))
八、time模块(*****)
8.1 时间戳,结构化时间,格式化时间
import time # 1、时间戳 以unix元年（1970-01-01 00:00:00）开始计算一直到当前时间的秒数 print(time.time()) # 1526911211.354357 # 2、结构化时间 print(time.localtime()) # 本地的结构化时间 # time.struct_time(tm_year=2018, tm_mon=5, tm_mday=21, tm_hour=22, tm_min=0, tm_sec=11, tm_wday=0, tm_yday=141, tm_isdst=0) print(time.localtime().tm_year) # 2018 print(time.gmtime()) # 世界的结构化时间 # time.struct_time(tm_year=2018, tm_mon=5, tm_mday=21, tm_hour=14, tm_min=0, tm_sec=11, tm_wday=0, tm_yday=141, tm_isdst=0) # 3、格式化时间 print(time.strftime('%Y-%m-%d %X')) # 2018-05-21 22:00:11
8.2时间戳,结构化时间与格式化时间之间的相互转化
# 1、时间戳 结构化时间 相互转化 print(time.localtime(1526911211.354357)) # 时间戳转结构化时间 # time.struct_time(tm_year=2018, tm_mon=5, tm_mday=21, tm_hour=22, tm_min=0, tm_sec=11, tm_wday=0, tm_yday=141, tm_isdst=0) print(time.mktime((2009, 2, 17, 17, 3, 38, 1, 48, 0))) # 格式化时间转 时间戳 # 1234861418.0 # 2、结构化时间 格式化时间 相互转化 print(time.strftime('%Y-%m-%d %X',(2009, 2, 17, 17, 3, 38, 1, 48, 0))) # 结构化时间转 格式化时间 # 2009-02-17 17:03:38 print(time.strptime('2018-04-09 14:23:14','%Y-%m-%d %H:%M:%S')) # 格式化时间转 结构化时间 # 1.1 时间戳转结构化时间 ===> localtime,gmtime # 1.2 结构化时间转时间戳 ===> mktime # 2.1 结构化时间转格式化时间 ===> strftime # 2.2 格式化时间转结构化时间 ===> strptime
图解
# time 模块没有之间进行时间戳与格式化时间的转换,但可以自己手写一个
import time # 格式化时间转 时间戳 def mktime(string,format): return time.mktime(time.strptime(string,format)) # 时间戳转 格式化时间 def date(format,strtime=time.time()): struct_time = time.localtime(strtime) return time.strftime(format,struct_time) print(mktime('2017-08-09 14:13:34','%Y-%m-%d %H:%M:%S')) # 1502259214.0 print(date('%Y-%m-%d')) # 2018-05-21
%a Locale’s abbreviated weekday name. %A Locale’s full weekday name. %b Locale’s abbreviated month name. %B Locale’s full month name. %c Locale’s appropriate date and time representation. %d Day of the month as a decimal number [01,31]. %H Hour (24-hour clock) as a decimal number [00,23]. %I Hour (12-hour clock) as a decimal number [01,12]. %j Day of the year as a decimal number [001,366]. %m Month as a decimal number [01,12]. %M Minute as a decimal number [00,59]. %p Locale’s equivalent of either AM or PM. (1) %S Second as a decimal number [00,61]. (2) %U Week number of the year (Sunday as the first day of the week) as a decimal number [00,53]. All days in a new year preceding the first Sunday are considered to be in week 0. (3) %w Weekday as a decimal number [0(Sunday),6]. %W Week number of the year (Monday as the first day of the week) as a decimal number [00,53]. All days in a new year preceding the first Monday are considered to be in week 0. (3) %x Locale’s appropriate date representation. %X Locale’s appropriate time representation. %y Year without century as a decimal number [00,99]. %Y Year with century as a decimal number. %z Time zone offset indicating a positive or negative time difference from UTC/GMT of the form +HHMM or -HHMM, where H represents decimal hour digits and M represents decimal minute digits [-23:59, +23:59]. %Z Time zone name (no characters if no time zone exists). %% A literal '%' character.
九、datetime模块(*****)
# datetime 就是基于time 模块发展而来，到用法更简单
import datetime,time print(datetime.datetime.now()) # 2018-05-21 22:52:39.542560 print(datetime.date.fromtimestamp((time.time()))) # 2018-05-21 时间转日期 print(datetime.datetime.now() + datetime.timedelta(-3)) print(datetime.datetime.now() - datetime.timedelta(3)) # 2018-05-18 22:56:21.981011 上面两个的效果是 一样的 都是 在当天的基础上减3天 print(datetime.datetime.now() + datetime.timedelta(hours=-3)) print(datetime.datetime.now() - datetime.timedelta(hours=3)) # 2018-05-21 19:58:22.163141 上面两个的效果是 一样的 都是 在当天的基础上减3小时 print(datetime.datetime.now() + datetime.timedelta(minutes=30)) #当前时间+30分 # 2018-05-21 23:29:06.690998 c_time = datetime.datetime.now() print(c_time.replace(minute=30,hour=2,day=19)) # 2018-05-19 02:30:19.485846
十、configparser 模块(***)
# 用户对 ini 一类文件的读写操作 # 一般使用与 对环境，或系统 配置文件的 读写操作
import configparser config = configparser.ConfigParser() # 生成object 对象 config["DEFAULT"] = {'ServerAliveInterval': '45', 'Compression': 'yes', 'CompressionLevel': '9', 'time' : 12.34} config['bitbucket.org'] = {} config['bitbucket.org']['User'] = 'hg' config['topsecret.server.com'] = {} topsecret = config['topsecret.server.com'] topsecret['Host Port'] = '50022' # mutates the parser topsecret['ForwardX11'] = 'no' # same here config['DEFAULT']['ForwardX11'] = 'yes' with open('example.ini', 'w') as configfile: config.write(configfile)
res = configparser.ConfigParser() res.read('example.ini') print(res.sections()) print(res.options('topsecret.server.com')) print(res.get('bitbucket.org','forwardx11')) print(res.getint('bitbucket.org','CompressionLevel')) print(res.getfloat('bitbucket.org','time'))
十一、subprocess 模块(*****)
# 看名字即知 和 子进程有关。 # 主要使用： # 执行命令获取进程执行的结果保存。 # 注意 # os模块 也可以执行命令 开启了一个进程，但是无法保存结果。
import subprocess,time # 开启子进程执行 res = subprocess.Popen('tasklist' ,shell=True # ,stdout=subprocess.PIPE # 标准化输出 # ,stderr=subprocess.PIPE # 错误输出 ) time.sleep(1) print(res) print(res.stdout.read().decode('gbk')) # res.stdout.read() 拿到的是一个utf-8或者gbk的16进制码，这个是操作系统默认字符编码有关 # 在没有stdout=subprocess.PIPE的情况下，子进程命令结果或直接输入到终端，能否正常显示，取决于该程序的结束时间是否大于子进程的结束时间，大于则显示，小于则来不急显示 # 在有stdout=subprocess.PIPE的情况下，只有需要（res.stdout.read()）是才会显示
十二、shutil模块(***)
# 高级的 文件、文件夹、压缩包 处理模块
# 1、shutil.copyfileobj(fsrc, fdst[, length]) # 将文件内容拷贝到另一个文件中 # shutil.copyfileobj(open('old.xml','r'), open('new.xml', 'w')) # 2、shutil.copyfile(src, dst) #拷贝文件 # 3、shutil.copymode(src, dst) # 仅拷贝权限。内容、组、用户均不变 # 4、shutil.copystat(src, dst) # 仅拷贝状态的信息，包括：mode bits, atime, mtime, flags # 5、shutil.copy(src, dst) # 拷贝文件和权限 # 6、 shutil.copy2(src, dst) # 拷贝文件和状态信息 # 7、shutil.copytree(src, dst, symlinks=False, ignore=None) #递归的去拷贝文件夹 # shutil.copytree('folder1', 'folder2', ignore=shutil.ignore_patterns('*.pyc', 'tmp*')) # #目标目录不能存在，注意对folder2目录父级目录要有可写权限，ignore的意思是排除 # 8、shutil.rmtree(path[, ignore_errors[, onerror]]) # 递归的去删除文件 # 9、shutil.move(src, dst) # mv 递归的去移动文件，它类似mv命令，其实就是重命名。 # 10、shutil.make_archive(base_name, format,...) # base_name： 压缩包的文件名，也可以是压缩包的路径。只是文件名时，则保存至当前目录，否则保存至指定路径， # 如 data_bak =>保存至当前路径 # 如：/tmp/data_bak =>保存至/tmp/ # format： 压缩包种类，“zip”, “tar”, “bztar”，“gztar” # root_dir： 要压缩的文件夹路径（默认当前目录） # owner： 用户，默认当前用户 # group： 组，默认当前组 # logger： 用于记录日志，通常是logging.Logger对象
# 压缩 import shutil res =shutil.make_archive('a',format='zip') print(res)
# 解压 import zipfile z= zipfile.ZipFile('a.zip','r') z.extractall('./a') z.close()
shutil 压缩的原理就是通过zipfile,tarfile 进行压缩
import zipfile # zip 压缩 z = zipfile.ZipFile('a.zip','w') z.write('a.txt') z.write('index.py') z.close() # zip解压 z = zipfile.ZipFile('a.zip','r') z.extractall('./a') z.close()
import tarfile,os # 压缩 t = tarfile.TarFile('a.tar','w') t.add('a.txt') t.close() # 解压 t= tarfile.TarFile('a.tar','r') t.extractall('./a') t.close()
十三、shelve模块(***)
import shelve # shelve 比 pickle 更简单 # 添加数据 f= shelve.open(r'test') f['jmz'] = {'name':'jmz','age':25,'weight':175.3} f['jly'] = {'name':'jly','age':27,'weight':165.3} f.close() # 读和改 f= shelve.open(r'test',writeback=True) # 改变数据必须要加writeback=True，添加则不需要 f['jmz']['age'] =35 # 改数据 print(f['jmz']) f.close()
十四、xml 模块(***)
xml是实现不同语言或程序之间进行数据交换的协议，跟json差不多，但json使用起来更简单，不过，古时候，在json还没诞生的黑暗年代，大家只能选择用xml呀，至今很多传统公司如金融行业的很多系统的接口还主要是xml。
xml的格式如下，就是通过<>节点来区别数据结构的:
<?xml version="1.0"?> <data> <country name="Liechtenstein"> <rank updated="yes">2</rank> <year>2008</year> <gdppc>141100</gdppc> <neighbor name="Austria" direction="E"/> <neighbor name="Switzerland" direction="W"/> </country> <country name="Singapore"> <rank updated="yes">5</rank> <year>2011</year> <gdppc>59900</gdppc> <neighbor name="Malaysia" direction="N"/> </country> <country name="Panama"> <rank updated="yes">69</rank> <year>2011</year> <gdppc>13600</gdppc> <neighbor name="Costa Rica" direction="W"/> <neighbor name="Colombia" direction="E"/> </country> </data>
xml协议在各个语言里的都 是支持的，在python中可以用以下模块操作xml：
import xml.etree.ElementTree as ET tree = ET.parse('b.xml') root = tree.getroot() # 获取内容主体 print(root) print(tree.find('country')) # 返回第一个country子节点元素 print(tree.findall('country')) # 返回所有的country子节点元素 print(tree.iter('year')) # 返回所有的 year 元素
# 遍历 for country in tree.findall('country'): rank = country.find('rank') print('%s-->%s-->%s'%(rank.tag,rank.attrib,rank.text)) # tag 标签 # attrib 获取的是元素的属性 # text 获取元素的文本内容 # {'updated': 'yes'}---->2 # {'updated': 'yes'}---->5 # {'updated': 'yes'}---->69 # 增加元素 country2 = ET.Element('country') # 创建一个新元素 country2.text='jmz' country2.attrib = {'updated':'yes','version':'1.0'} root.append(country2) # 主体部分 添加一个新元素 tree.write('new.xml',encoding='utf-8') # tree # 修改 for year in tree.iter('year'): year.text = str(2016) # xml 必须是str类型 year.set('updated','yes') year.set('version','1.0') tree.write('b.bat.xml')
import xml.etree.ElementTree as ET new_xml = ET.Element('namelist') name = ET.SubElement(new_xml,'jmz',attrib={'updated':'yes'}) # 创建子节点 age = ET.SubElement(name,'age',attrib={'year':'1994'}) age.text = 'jmz' sex = ET.SubElement(name,'sex',text='男') sex.text = '男' name2 = ET.SubElement(new_xml,'jly',attrib={'updated':'yes'}) age2 = ET.SubElement(name2,'age',attrib={'year':'1994'}) age2.text = 'jly' sex2 = ET.SubElement(name2,'sex') sex2.text = '女' object = ET.Element('object') object.text = 'oldboy' object.attrib={'addr':'shanghai','time':'2018-01-01'} et=ET.ElementTree(new_xml) et.write('namelist.xml',encoding='utf-8',xml_declaration=True) ET.dump(new_xml)