模块

configparser

#对配置文件进行解析

import configparser
config = configparser.ConfigParser() #这是生成一个实例
config["DEFAULT"] = {'ServerAliveInterval': '45', #serveraliveinterval = 45
'Compression': 'yes', #compression = yes
'CompressionLevel': '9'} #生成 compressionlevel = 9
#config["DEFAULT"]生成[DEFAULT],
config['bitbucket.org'] = {} #生成 [bitbucket.org]
config['bitbucket.org']['User'] = 'hg' #生成 user = hg
config['topsecret.server.com'] = {} #生成 [topsecret.server.com]
topsecret = config['topsecret.server.com'] #创建别名
topsecret['Host Port'] = '50022' #生成 host port = 50022
topsecret['ForwardX11'] = 'no' #生成 forwardx11 = no
config['DEFAULT']['ForwardX11'] = 'yes' #在[DEFAULT]下生成 forwardx11 = yes
with open('example.ini', 'w') as configfile: #写入
config.write(configfile)

re模块-正则

在线正则测试 http://tool.oschina.net/regex

头疼去吧

print(re.findall(r"-?d+.?d*","1-12*(60+(-40.35/5)-(-4*2))")) #匹配出所有数字
# #['1', '-12', '60', '-40.35', '5', '-4', '2']
print(re.findall(r"-?d+.d+|(-?d+)","1-12*(60+(-40.35/5)-(-4*2))")) #匹配所有整数
#|管道符左边是匹配所有小数,右边是匹配所有整数,()特性是先执行取结果,右边的执行匹配显示,左边匹配就抛弃
#['1', '-12', '60', '', '5', '-4', '2']

re.findall遍历匹配

#可以获取字符串中所有匹配的字符串，返回一个列表

import re
#如下匹配的字符串
预定义字符集匹配
print(re.findall("a","abc 121b3 a_ef * | - =")) #匹配所有a字符,a可变成任意字符或数字或空格符( 或 )
#['a', 'a']
print(re.findall("^a","abc 121b3 a_ef * | - =a")) #^a匹配以a开头的 a$匹配以a结尾的
#['a']
print(re.findall("w","abc123a_ef * | - =")) #w匹配字母数字下划线,不匹配特殊字符和空格
#['a', 'b', 'c', '1', '2', '3', 'a', '_', 'e', 'f']
print(re.findall("W","abc123a_ef * | - =")) #W匹配非字母数字下划线,匹配特殊字符和空格
#[' ', '*', ' ', '|', ' ', '-', ' ', '=']
print(re.findall("s","abc 123 a_ef * | - =")) #s匹配任意空白字符等同于[ f]
#[' ', ' ', ' ', ' ', ' ', ' ']
print(re.findall("S","abc 123 a_ef * | - =")) #S 匹配任意非空白字符
#['a', 'b', 'c', '1', '2', '3', 'a', '_', 'e', 'f', '*', '|', '-', '=']
print(re.findall("d","abc 123 a_ef * | - =")) #d匹配任意数字0-9
#['1', '2', '3']
print(re.findall("D","ta_ef- =")) #D匹配非数字字符
#['t', 'a', '_', 'e', 'f', '-', ' ', '=']

print(re.findall(r'a\c',"a\c ac a\\c"))          #r原生显示\
#['a\c', 'a\c']

括号匹配
print(re.findall("com(?:aa|bb)","acomaavabbcombb ab a")) #(aa|bb)匹配aa或bb com(?:aa|bb)匹配comaa和combb #如果不加?:匹配aa或bb
#['comaa', 'combb']
print(re.findall("a[- ]c","abc a-ca_c a c a c=")) #[]匹配[]中包含的任意一个字符
#['a-c', 'a c']
print(re.findall("a[- ]c","abc a-c a c a_c a c a c=")) #[^]匹配[]中不包含的任意一个字符
#['abc', 'a c', 'a_c', 'a c']
print(re.findall("ab{2}","abvabb ab a")) #{}指定匹配abb {2,5}匹配2-5次 {,5}匹配0-5次 {,5} 匹配5-n次
#['abb']
特殊符号匹配
^ 匹配开头 $匹配结尾转意字符
print(re.findall("comaa|combb","acomaavabbcombb ab a")) # | comaa|combb 匹配comaa和combb
#['comaa', 'combb']
print(re.findall("a.c","abc a|c a c a_c a c a c=")) #"."匹配任意单个字符不能匹配
#['abc', 'a|c', 'a c', 'a_c', 'a c']
print(re.findall("a.c","abc a|c a c a_c a c a c=",re.S)) #"."和re.s匹配任意单个字符且能匹配
#['abc', 'a|c', 'a c', 'a_c', 'a c', 'a c']
print(re.findall("ab*","a ab abb abbb")) # * 匹配0或n个前一个位的字符
#['a', 'ab', 'abb', 'abbb']
print(re.findall("ab+","a ab abb abbb")) # + 匹配1或n个前一个位的字符
#['ab', 'abb', 'abbb']
print(re.findall("ab?","a ab abb abbb")) #?匹配0或1个b
#['a', 'ab', 'ab', 'ab']
贪婪和非贪婪匹配
*?,+?,??,{m,n}? 前面的*,+,?等都是贪婪匹配，也就是尽可能匹配，后面加?号使其变成惰性匹配
print(re.findall("a.*c","aa123cabbbc")) #.* 贪婪匹配匹配a开头c结尾
#['aa123cabbbc']
print(re.findall("a.*?c","aa123cabbbc")) #a.*?c 非贪婪匹配,匹配最短满足条件的
#['aa123c', 'abbbc']
1. a = re.findall(r"a(d+?)",'a23b') #非贪婪匹配
2. print(a)
3. b = re.findall(r"a(d+)",'a23b') #贪婪匹配
4. print(b)
5. 执行结果：
6. ['2']
7. ['23']

complie()

#编辑正则表达式模式,返回一个对象的模式（可以把那些常用的正则表达式编译成正则表达式对象，这样可以提高一点效率。）

re.compile(pattern,flags=0)

re.compile(pattern,flags=0)
pattern: 编译时用的表达式字符串。
flags 编译标志位，用于修改正则表达式的匹配方式，如：是否区分大小写，多行匹配等。常用的flags有：
标志
re.S(DOTALL) #使.匹配包括换行在内的所有字符
re.I（IGNORECASE） #使匹配对大小写不敏感
re.L（LOCALE） #做本地化识别（locale-aware)匹配，法语等
re.M(MULTILINE) #多行匹配，影响^和$
re.X(VERBOSE) #该标志通过给予更灵活的格式以便将正则表达式写得更易于理解
re.U #根据Unicode字符集解析字符，这个标志影响w,W,,B

match object对象

re.match 只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None

re.search 匹配整个字符串，直到找到一个匹配

#match和search一旦匹配成功，就是一个match object对象
start() 返回匹配开始的位置
end() 返回匹配结束的位置
span() 返回一个元组包含匹配 (开始,结束) 的位置
group() 返回被 RE 匹配的字符串,()内输入数字可以一次输入多个分组，对应组号匹配的字符串
a = "123abc456"
print(re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(0)) #123abc456,返回整体
print(re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(1)) #123
print(re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(2)) #abc
print(re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(3)) #456
#group(0) 列出所有匹配， group(1) 列出第一个括号匹配部分，
#group(2) 列出第二个括号匹配部分，group(3) 列出第三个括号匹配部分。

re.split

分隔操作,分割后返回列表

print(re.split("[ba]","a2bcd")) #用b和a当分隔符
#['', '2', 'cd']
print(re.split('d+','one1two2three3four4five5')) #用数字当分割符
#['one', 'two', 'three', 'four', 'five', '']

re.sub 替换

print(re.sub("^g","G","guolm is man, guolm")) #不加^ 匹配所有
#Guolm is man, guolm
print(re.sub("(w+)(s)(w+)(s)(w+)$",r"52341","alex make love"))
#位置替换 w+匹配多个字母数字下划线,s是空格 5-1是索引位置
#love make alex
print(re.sub("(w+)(W+)(w+)(W+)(w+)",r"52341","alex ' + = make ---/ love")) #W匹配非字母数字下划线
#love ' + = make ---/ alex

re.subn 替换,并返回次数

print(re.subn('[1-3]','A','12456ab13cdef')) #包含1至3的数字替换成A 并显示替换次数
#('AA456abAAcdef', 4)
print(re.subn("g.t","have",'I get A, I got B ,I gut C')) #包含g.t 替换成have 并返回替换次数
#('I have A, I have B ,I have C', 3)

finditer

搜索string，返回一个顺序访问每一个匹配结果（Match对象）的迭代器。找到 RE 匹配的所有子串，并把它们作为一个迭代器返回

iter = re.finditer(r'd+','12 drumm44ers drumming, 11 ... 10 ...')
for i in iter:
print(i)
print(i.group())
print(i.span())
# 12
# (0, 2)
# <_sre.SRE_Match object; span=(8, 10), match='44'>
# 44
# (8, 10)
# <_sre.SRE_Match object; span=(24, 26), match='11'>
# 11
# (24, 26)
# <_sre.SRE_Match object; span=(31, 33), match='10'>
# 10
# (31, 33)

hashlib

import hashlib
#定义一个hash容器把数据传入进去
m=hashlib.md5()
#m=hashlib.md5("bbbass".encode("utf-8")) #密码加严,先增加一段字符串
m.update("aaaaaass".encode("utf-8"))
print(m.hexdigest())
#f34ec82a17a5ff16f0083fecaf445512
#效果相同,sha256比md5更安全(没用)
ma=hashlib.sha256()
ma.update("aaaaaass".encode("utf-8"))
print(ma.hexdigest())
#d359e7a0615170c1404f4c49ad54be2ddd4e2a4fff8833c2d548dc9536d7a2a4
#定义一个hash容器把db文件内容数据传入进去
with open(r"E:installpycharmguolma.txt","rb") as f:
for line in f:
m.update(line)
md5_num=m.hexdigest()
print(md5_num)
#b9384ce6cab40771cbd807b3c7bdd4f7

http://www.cnblogs.com/alex3714/articles/5161349.html

loggin模块分5个级别 debug() info() warnging() error() critical()

import logging
logging.basicConfig(filename='example.log',
level=logging.WARNING,
format='%(asctime)s %(message)s',
datefmt='%m/%d/%Y %H:%M:%S %p')
#filename='example.log' 指定写入日志文件
#level=logging.WARNING(日志级别必须大写),日志级别达到WARNING级别写入db文件(文件默认生成)
#format='%(asctime)s %(message)s'日志格式, asctime当前时间, message当前内容
#datefmt='%m/%d/%Y %H:%M:%S %p' 日期格式
logging.debug('This message should go to the log file')
logging.info('So should this')
logging.warning('And this, too')
logging.error("wrong password more than 3 times")
logging.critical("server is down")
#db文件显示

06/07/2017 01:01:54 AM And this, too06/07/2017 01:01:54 AM wrong password more than 3 times

```
06/07/2017 01:01:54 AM server is down
```

日志格式

%(name)s	Logger的名字
%(levelno)s	数字形式的日志级别
%(levelname)s	文本形式的日志级别
%(pathname)s	谁调用日志输出该函数的模块的完整路径名，可能没有
%(filename)s	谁调用日志输出该函数的模块的文件名(aa.py)
%(module)s	谁调用日志输出该函数的模块名(aa)
%(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	用户输出的消息

如果想同时把log打印在屏幕和文件日志里，就需要了解一点复杂的知识了

Python 使用logging模块记录日志涉及四个主要类，使用官方文档中的概括最为合适：

logger提供了应用程序可以直接使用的接口；

handler将(logger创建的)日志记录发送到合适的目的输出(输出到文件内或屏幕)

filter提供了细度设备来决定输出哪条日志记录(日志内容哪些输出,哪些不输出)

formatter决定日志记录的最终输出格式(日志格式)

logger
每个程序在输出信息之前都要获得一个Logger。Logger通常对应了程序的模块名，比如聊天工具的图形界面模块可以这样获得它的Logger：
LOG=logging.getLogger(”chat.gui”)
而核心模块可以这样：
LOG=logging.getLogger(”chat.kernel”)

Logger.setLevel(lel):指定最低的日志级别，低于lel的级别将被忽略。debug是最低的内置级别，critical为最高
Logger.addFilter(filt)、Logger.removeFilter(filt):添加或删除指定的filter
Logger.addHandler(hdlr)、Logger.removeHandler(hdlr)：增加或删除指定的handler
Logger.debug()、Logger.info()、Logger.warning()、Logger.error()、Logger.critical()：可以设置的日志级别

handler

handler对象负责发送相关的信息到指定目的地。Python的日志系统有多种Handler可以使用。有些Handler可以把信息输出到控制台，有些Logger可以把信息输出到文件，还有些 Handler可以把信息发送到网络上。如果觉得不够用，还可以编写自己的Handler。可以通过addHandler()方法添加多个多handler
Handler.setLevel(lel):指定被处理的信息级别，低于lel级别的信息将被忽略
Handler.setFormatter()：给这个handler选择一个格式
Handler.addFilter(filt)、Handler.removeFilter(filt)：新增或删除一个filter对象

每个Logger可以附加多个Handler。接下来我们就来介绍一些常用的Handler：
1) logging.StreamHandler
使用这个Handler可以向类似与sys.stdout或者sys.stderr的任何文件对象(file object)输出信息。它的构造函数是：
StreamHandler([strm])
其中strm参数是一个文件对象。默认是sys.stderr

2) logging.FileHandler
和StreamHandler类似，用于向一个文件输出日志信息。不过FileHandler会帮你打开这个文件。它的构造函数是：
FileHandler(filename[,mode])
filename是文件名，必须指定一个文件名。
mode是文件的打开方式。参见Python内置函数open()的用法。默认是’a'，即添加到文件末尾。

3) logging.handlers.RotatingFileHandler
这个Handler类似于上面的FileHandler，但是它可以管理文件大小。当文件达到一定大小之后，它会自动将当前日志文件改名，然后创建一个新的同名日志文件继续输出。比如日志文件是chat.log。当chat.log达到指定的大小之后，RotatingFileHandler自动把文件改名为chat.log.1。不过，如果chat.log.1已经存在，会先把chat.log.1重命名为chat.log.2。。。最后重新创建 chat.log，继续输出日志信息。它的构造函数是：
RotatingFileHandler( filename[, mode[, maxBytes[, backupCount]]])
其中filename和mode两个参数和FileHandler一样。
maxBytes用于指定日志文件的最大文件大小。如果maxBytes为0，意味着日志文件可以无限大，这时上面描述的重命名过程就不会发生。
backupCount用于指定保留的备份文件的个数。比如，如果指定为2，当上面描述的重命名过程发生时，原有的chat.log.2并不会被更名，而是被删除。

4) logging.handlers.TimedRotatingFileHandler
这个Handler和RotatingFileHandler类似，不过，它没有通过判断文件大小来决定何时重新创建日志文件，而是间隔一定时间就自动创建新的日志文件。重命名的过程与RotatingFileHandler类似，不过新的文件不是附加数字，而是当前时间。它的构造函数是：
TimedRotatingFileHandler( filename [,when [,interval [,backupCount]]])
其中filename参数和backupCount参数和RotatingFileHandler具有相同的意义。
interval是时间间隔。
when参数是一个字符串。表示时间间隔的单位，不区分大小写。它有以下取值：
S 秒
M 分
H 小时
D 天
W 每星期（interval==0时代表星期一）
midnight 每天凌晨

日志输入到全局日志,db日志文件屏幕

import logging
#日志输入到全局日志,db日志文件屏幕
# create logger
logger = logging.getLogger('TEST-LOG') #TEST-LOG是日志名
logger.setLevel(logging.DEBUG) #logging.DEBUG 全局的日志级别
# 全局日志基本最高,子logging基本必须比全局高否则不显示日志输出
# create console handler and set level to debug
ch = logging.StreamHandler() #创建屏幕输出显示
ch.setLevel(logging.INFO) #屏幕输出日志级别
# create file handler and set level to warning
fh = logging.FileHandler("access.log") #文件的hander
fh.setLevel(logging.WARNING) #文件的日志级别
# create formatter
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
# add formatter to ch and fh
ch.setFormatter(formatter) #定义日志格式
fh.setFormatter(formatter) #定义日志格式
# add ch and fh to logger
logger.addHandler(ch) #屏幕输出绑定到logger接口
logger.addHandler(fh) #文件输出绑定到logger接口
# 'application' code
logger.debug('debug message')
logger.info('info message')
logger.warning('warn message')
logger.error('error message')
logger.critical('critical message')

日志输入到全局日志,db日志文件屏幕并按照时间切割保留最近3个db文件,每5秒切割1次

#!/usr/sbin/python
# -*- coding:utf-8 -*-
import logging
from logging import handlers #创建db文件日志切割,不加切割不用写
#日志输入到全局日志,db日志文件屏幕并安装时间日志切割保留最近3个文件,每5秒切割1次
# create logger
logger = logging.getLogger('TEST-LOG') #TEST-LOG是日志名
logger.setLevel(logging.DEBUG) #logging.DEBUG 全局的日志级别
# 全局日志级别最高,子logging级别必须比全局高否则不显示日志输出
# create console handler and set level to debug
ch = logging.StreamHandler() #创建屏幕输出显示
ch.setLevel(logging.INFO) #屏幕输出日志级别
# create file handler and set level to warning
#fh = logging.FileHandler("access.log") #文件显示(db文件保存日志) 不加日志切割用这个
fh = handlers.TimedRotatingFileHandler("access.log",when="S",interval=5,backupCount=3) #文件显示(db文件保存日志)
#TimedRotatingFileHandler 按时间切割保存, when="S",单位是秒(h是小时), interval=5,(5个单位切1次)backupCount=3 (保存最近3次,0是无限制保存)
#fh = handlers.RotatingFileHandler("access.log",maxBytes=4,backupCount=3)
#RotatingFileHandler 按时间切割保存 maxBytes=4 (文件满4bytes,就生成新文件) backupCount=3 (保存最近3次,0是无限制保存)
fh.setLevel(logging.WARNING) #文件的日志级别
# create formatter
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
# add formatter to ch and fh
ch.setFormatter(formatter) #定义日志格式
fh.setFormatter(formatter) #定义日志格式
# add ch and fh to logger
logger.addHandler(ch) #屏幕输出绑定到logger接口
logger.addHandler(fh) #文件输出绑定到logger接口
# 'application' code
logger.debug('debug message')
logger.info('info message')
logger.warning('warn message')
logger.error('error message')
logger.critical('critical message')

os模块

import platform
platform.platfrom() #显示系统版本
platform.system() #显示系统版本
os.chdir("/home") #切换到/home目录模块
os.getcwd() #获取当前目录
os.system("ls -h") #在python中执行shell命令(不能切换目录),
d=os.popen("df -h").read() #把df的执行结果赋值给d
print(d)
os.path.abspath(__file__) #os.path.abspath 返回文件绝对路径
os.mkdir("guol11") #创建1个目录
os.makedirs("/home/guolm/1112211/a2/a3") #创建多层目录
os.makedirs("/home/guolm/1112211aa",exist_ok=True) #创建文件存在,就覆盖不会报错
os.rmkdir("guol11") #目录为空，则删除,否则报错
os.removedirs("1112211/a2/a4/") #可写绝对路径,若目录为空，则删除，并递归到上一级目录，如若也为空，则删除,依此类推
os.listdir("") #列出当前目录所有,包含隐藏文件 os.listdir("..")列出上层目录所有
os.rename("guo","gg") #重命名 guo为gg
os.stat("gg") #获取文件或目录信息 os.stat("gg").st_size 获取文件大小 (看输出写参数)
os.sep #显示分割符，win下为"\",Linux下为"/"
os.linesep #输出行终止符，win下为" ",Linux下为" "
os.pathsep #分割文件路径的字符 win是; linux是:
os.environ #获取系统的环境变量
返回文件路径
```
import os,sys
```
file_path=os.path.abspath(__file__) #os.path.abspath 返回文件绝对路径
print(file_path)
#E:installpycharmguolmday6supba.py
print(os.path.split(file_path)) #优化返回文件的目录绝对路径
#('E:\install\pycharm\guolm\day6', 'supba.py')
print(os.path.dirname(file_path)) #返回文件的目录路径
#E:installpycharmguolmday6
print(os.path.dirname(os.path.dirname(file_path))) #返回文件的目录上层目录的路径
E:installpycharmguolm
print(os.path.basename(file_path)) #返回文件名
supba.py
print(os.path.exists(file_path)) #判断文件路径是否存在 True为真 False为假
#True
print(os.path.isabs(file_path)) #判断文件是否为绝对路径,True为真 False为假
#True
print(os.path.isfile(file_path)) #判断file_path是否为存在的文件
#True
print(os.path.isdir(file_path)) #判断file_path是否为存在的目录
#False
print(os.path.getatime(file_path)) #返回file_path文件或目录最后存取时间
#1496854045.527072
print(os.path.getatime(file_path)) #返回file_path文件或目录最后修改时间
#1496854045.527072

sys模块

import sys
print(sys.path) #返回模块路径
print(sys.version) #输出python版本信息
print(sys.maxsize) #输出最大的int值
print(sys.platform) #显示系统类型
sys.argv #把sys.argv写模块被调用会显示绝对路径,后边跟的值也是传参给列表
#命令行参数list,第一个元素是程序本身
#交互,用户可输入1行内容
# a=sys.stdin.readline()
# print(a)

json	pickle
{}	dict
[]	list
"string"	str
1234.56	int或float
true/false	True/False
null	None

json:    用于字符串和python数据类型间进行转换

pickle:  用于python特有的类型和python的数据类型间进行转换

pickle的写入是二进制形式用wb模式,可以序列化python任何数据类型

json  的写入是字符串形式用w模式,只支持序列化python的str,int,float,set,list,dict,tuple数据类型,但json可和其他语言序列化

pickle功能: dumps,dump,loads,load

json 功能:  dumps,dump,loads,load

序列化和反序列化主要用于动态数据存储
pickle.dumps   序列化      内存-->硬盘
pickle.loads   反序列化    硬盘-->内存

pickle

如下2个py文件功能是实现数据的动态存档

这个文件的作用,读取内存数据写入到db文件

import pickle
#import json as pickle 这是用json执行注意把wb改成w
account={
"id":63232223,
"credit":15000,
"balance":8000,
"expire_date":"2020-5-21",
"password":"sdfsf"
}
f=open("account1.db","wb")
f.write(pickle.dumps(account)) #相当于pickle.dump(account,f)
f.close()

这个文件的作用,读取db文件写入到内存

import pickle
#import json as pickle 这是用json执行注意把rb改成r
f=open("account1.db","rb")
account=pickle.loads(f.read())#相当于account=pickle.load(f)
print(account)
print(account["id"])
#可以加如下,执行后注释在执行看值是否改变
1. account["balance"]-=3400
2. f=open("account1.db","wb")
3. f.write(pickle.dumps(account))
4. f.close()

shelve模块比pickle简单

import shelve
#内存写入db文件, 字典形式,
f=shelve.open(r'sheve.txt')
f["student1"]={"name":"egon","age":18,"height":"180cm"}
print(f['student1'])
f.close()
#读取db文件的数据
f=shelve.open(r'sheve.txt')
print(f['student1'])
print(f['student1']["name"])
f.close()

随机生成数模块

import random
print(random.random()) #不能传参,随机生成大于0小于1之间的小数
#0.14251
print(random.uniform(1,3)) #随机生成大于1小于3的小数
#2.14251
print(random.randint(1,6)) #随机生成大于等于1且小于等于6的整数
#4
print(random.randrange(1,6)) #大于等于1且小于6的整数
#5
print(random.choice([1,'23',[4,5]])) #随机得到1或23或[4,5]
#[4, 5]
print(random.sample([1,"23",[4,5]],2)) #随机获得任意2个元素,2可改
#[1, [4, 5]]
#随机更改itme元素顺序
item=[1,3,5,7,9]
random.shuffle(item)
print(item)
#[3, 5, 9, 7, 1]
#生成随机验证码
import random
def v_code():
code = ''
for i in range(5):
num=random.randint(0,9)
alf=chr(random.randint(65,90))
add=random.choice([num,alf])
code += str(add)
return code
print(v_code())
#W3E01

#高级的文件、文件夹、压缩包处理模块

copy

#覆盖,把old.xml覆盖到new.xml, new.xml不存在就新建
shutil.copyfileobj(open("old.xml","r"),open("new.xml","w")) #需要新建old.xml文件
#把old.xml覆盖到new.xml, new.xml不存在就新建
shutil.copyfile("old.xml","new.xml") #需要新建old.xml文件
#仅复制权限, 文件内容,组,用户都不变
shutil.copymode("f1.log","f2.log")
#仅拷贝状态的信息,包括：mode bits, atime, mtime, flags
shutil.copystat('f1.log', 'f2.log')
#拷贝文件和权限
shutil.copy('f1.log', 'f2.log')
#拷贝文件状态和信息
shutil.copy2('f1.log', 'f2.log')

#递归

#递归copy 把day2所以,复制给day4
#shutil.copytree('day2', 'day4', ignore=shutil.ignore_patterns('*.pyc', 'tmp*'))
#递归copy,软连接拷贝成硬链接
shutil.copytree('f1', 'f2', symlinks=True, ignore=shutil.ignore_patterns('*.pyc', 'tmp*'))
#递归删除删除day4及其子目录和文件
shutil.rmtree("day4")
#递归移动,它类似mv命令，也可重命名
shutil.move("./day4/2","./3223") #把day4目录的2文件,移动到当前目录,并改名为3223

压缩与解压缩

import shutil
#压缩
##data_bak是文件名(默认存放当前路径),gztar压缩格式,root_dir 指定压缩路径, 压缩格式“zip”, “tar”, “bztar”，“gztar”
#shutil.make_archive("data_bak","gztar",root_dir="./day3")
import tarfile
#压缩 (tar,gztar bztar)
t=tarfile.open("guolm.gztar","w") #可指定tar,gztar bztar
t.add(r'/Users/playcrab/PycharmProjects/untitled1/f1.log',arcname="f1.log") #压缩的文件,相当于把路径给重命名为f1.log
t.add(r'/Users/playcrab/PycharmProjects/untitled1/f2.log',arcname="f2.log") #压缩的文件,
t.close()
#解压缩 (tar,gztar bztar)
#把# guolm.tar的内容解压到guolm目录(不创建默认就生成)
t=tarfile.open("guolm.gztar","r") #读取
t.extractall("guolm") #解压路径名
t.close()
import zipfile
#zip压缩
z= zipfile.ZipFile('guolm.zip',"w")
z.write("f1.log")
z.write("f2.log")
z.close()
#zip解压缩
z=zipfile.ZipFile("guolm.zip","r")
z.extractall(path="./day3") #解压到当前day3目录下
z.close()

import subprocess