首页 > 代码库 > day06模块
day06模块
原博文地址：http://www.cnblogs.com/linhaifeng/articles/6384466.html#_label2
时间模块time
import time
print(time.time())#1970年到现在的秒数，1970unix元年
print(time.localtime().tm_year)#2017
print(time.localtime())#time.struct_time(tm_year=2017, tm_mon=6, tm_mday=9, tm_hour=14, tm_min=40, tm_sec=4, tm_wday=4, tm_yday=160, tm_isdst=0)
#结构化的时间
print(time.strftime("%Y-%m-%d %H-%M-%S"))#2017-06-09 14-41-22
print(time.strftime("%Y-%m-%d %X"))#2017-06-09 14:41:22
print(time.mktime(time.localtime()))#1496990564.0 时间戳
#格式化字符串转成结构化时间
print(time.strftime("%Y %X",time.localtime()))#2017 14:48:12
print(time.strptime("2017-06-04 11:11:11","%Y-%m-%d %X"))#time.struct_time(tm_year=2017, tm_mon=6, tm_mday=4, tm_hour=11, tm_min=11, tm_sec=11, tm_wday=6, tm_yday=155, tm_isdst=-1)
print(time.ctime(223342113))#Sat Jan 29 07:28:33 1977 秒转为结构化时间
random模块
import random
print(random.random())#【0,1】，不能取到0和1，只能是之间的小数
print(random.randint(1,3))#[1,3]大于1且小于3的整数 ，包括1,3
print(random.randrange(1,3))#1和3之间的整数，不包括3，包括1【1.3）
a=[1,2,3,4,5,6]
print(random.choice(a))#列表中任意一个
print(random.sample(a,3))#随机选择几个元素，这里是三个，结果是一个列表
print(random.uniform(1,3))#生成1-3之间的小数
random.shuffle(a)#打乱a的顺序
print(a)
随机生成验证码
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())
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 返回操作系统平台名称
shutil模块
高级的 文件、文件夹、压缩包 处理模块
shutil.copyfileobj(fsrc, fdst[, length])
将文件内容拷贝到另一个文件中
1 import shutil
3 shutil.copyfileobj(open(‘old.xml‘,‘r‘), open(‘new.xml‘, ‘w‘))
shutil.copyfile(src, dst)
拷贝文件
1 shutil.copyfile(‘f1.log‘, ‘f2.log‘) #目标文件无需存在
shutil.copymode(src, dst)
仅拷贝权限。内容、组、用户均不变
1 shutil.copymode(‘f1.log‘, ‘f2.log‘) #目标文件必须存在
shutil.copystat(src, dst)
仅拷贝状态的信息，包括：mode bits, atime, mtime, flags
1 shutil.copystat(‘f1.log‘, ‘f2.log‘) #目标文件必须存在
拷贝文件和权限
shutil.copy(src, dst)
1 import shutil
3 shutil.copy(‘f1.log‘, ‘f2.log‘)
拷贝文件和状态信息
shutil.copy2(src, dst)
1 import shutil
3 shutil.copy2(‘f1.log‘, ‘f2.log‘)
shutil.ignore_patterns(*patterns)
递归的去拷贝文件夹
shutil.copytree(src, dst, symlinks=False, ignore=None)
1 import shutil
2
3 shutil.copytree(‘folder1‘, ‘folder2‘, ignore=shutil.ignore_patterns(‘*.pyc‘, ‘tmp*‘)) #目标目录不能存在，注意对folder2目录父级目录要有可写权限，ignore的意思是排除
拷贝软连接
import shutil
shutil.copytree(‘f1‘, ‘f2‘, symlinks=True, ignore=shutil.ignore_patterns(‘*.pyc‘, ‘tmp*‘))
‘‘‘
通常的拷贝都把软连接拷贝成硬链接，即对待软连接来说，创建新的文件
‘‘‘
递归的去删除文件
shutil.rmtree(path[, ignore_errors[, one rror]])
1 import shutil
2
3 shutil.rmtree(‘folder1‘)
递归的去移动文件，它类似mv命令，其实就是重命名。
shutil.move(src, dst)
1 import shutil
3 shutil.move(‘folder1‘, ‘folder3‘)
压缩文件
shutil.make_archive(base_name, format,...)
创建压缩包并返回文件路径，例如：zip、tar
- base_name： 压缩包的文件名，也可以是压缩包的路径。只是文件名时，则保存至当前目录，否则保存至指定路径，
如 data_bak =>保存至当前路径
如：/tmp/data_bak =>保存至/tmp/ - format： 压缩包种类，“zip”, “tar”, “bztar”，“gztar”
- root_dir： 要压缩的文件夹路径（默认当前目录）
- owner： 用户，默认当前用户
- group： 组，默认当前组
- logger： 用于记录日志，通常是logging.Logger对象
#将 /data 下的文件打包放置当前程序目录
import shutil
ret = shutil.make_archive("data_bak", ‘gztar‘, root_dir=‘/data‘)
#将 /data下的文件打包放置 /tmp/目录
import shutil
ret = shutil.make_archive("/tmp/data_bak", ‘gztar‘, root_dir=‘/data‘)
shutil 对压缩包的处理是调用 ZipFile 和 TarFile 两个模块来进行的，详细：
zipfile压缩解压缩
import zipfile
# 压缩
z = zipfile.ZipFile(‘laxi.zip‘, ‘w‘)
z.write(‘a.log‘)
z.write(‘data.data‘)
z.close()
# 解压
z = zipfile.ZipFile(‘laxi.zip‘, ‘r‘)
z.extractall(path=‘.‘)
z.close()
tarfile压缩解压缩
import tarfile
# 压缩
>>> t=tarfile.open(‘/tmp/egon.tar‘,‘w‘)
>>> t.add(‘/test1/a.py‘,arcname=‘a.bak‘)
>>> t.add(‘/test1/b.py‘,arcname=‘b.bak‘)
>>> t.close()
# 解压
>>> t=tarfile.open(‘/tmp/egon.tar‘,‘r‘)
>>> t.extractall(‘/egon‘)
>>> t.close()
六 json&pickle模块
之前我们学习过用eval内置方法可以将一个字符串转成python对象，不过，eval方法是有局限性的，对于普通的数据类型，json.loads和eval都能用，但遇到特殊类型的时候，eval就不管用了,所以eval的重点还是通常用来执行一个字符串表达式，并返回表达式的值。
1 import json
2 x="[null,true,false,1]"
3 print(eval(x)) #报错，无法解析null类型，而json就可以
4 print(json.loads(x))
什么是序列化？
我们把对象(变量)从内存中变成可存储或传输的过程称之为序列化，在Python中叫pickling，在其他语言中也被称之为serialization，marshalling，flattening等等，都是一个意思。
为什么要序列化？
1：持久保存状态
需知一个软件/程序的执行就在处理一系列状态的变化，在编程语言中，‘状态‘会以各种各样有结构的数据类型(也可简单的理解为变量)的形式被保存在内存中。
内存是无法永久保存数据的，当程序运行了一段时间，我们断电或者重启程序，内存中关于这个程序的之前一段时间的数据（有结构）都被清空了。
在断电或重启程序之前将程序当前内存中所有的数据都保存下来（保存到文件中），以便于下次程序执行能够从文件中载入之前的数据，然后继续执行，这就是序列化。
具体的来说，你玩使命召唤闯到了第13关，你保存游戏状态，关机走人，下次再玩，还能从上次的位置开始继续闯关。或如，虚拟机状态的挂起等。
2：跨平台数据交互
序列化之后，不仅可以把序列化后的内容写入磁盘，还可以通过网络传输到别的机器上，如果收发的双方约定好实用一种序列化的格式，那么便打破了平台/语言差异化带来的限制，实现了跨平台数据交互。
反过来，把变量内容从序列化的对象重新读到内存里称之为反序列化，即unpickling。
如何序列化之json和pickle：
json
如果我们要在不同的编程语言之间传递对象，就必须把对象序列化为标准格式，比如XML，但更好的方法是序列化为JSON，因为JSON表示出来就是一个字符串，可以被所有语言读取，也可以方便地存储到磁盘或者通过网络传输。JSON不仅是标准格式，并且比XML更快，而且可以直接在Web页面中读取，非常方便。
JSON表示的对象就是标准的JavaScript语言的对象，JSON和Python内置的数据类型对应如下：
复制代码
1 import json
2
3 dic={‘name‘:‘alvin‘,‘age‘:23,‘sex‘:‘male‘}
4 print(type(dic))#<class ‘dict‘>
5
6 j=json.dumps(dic)
7 print(type(j))#<class ‘str‘>
8
9
10 f=open(‘序列化对象‘,‘w‘)
11 f.write(j) #-------------------等价于json.dump(dic,f)
12 f.close()
13 #-----------------------------反序列化<br>
14 import json
15 f=open(‘序列化对象‘)
16 data=http://www.mamicode.com/json.loads(f.read())# 等价于data=json.load(f)
复制代码
注意点
pickle
复制代码
1 import pickle
2
3 dic={‘name‘:‘alvin‘,‘age‘:23,‘sex‘:‘male‘}
4
5 print(type(dic))#<class ‘dict‘>
6
7 j=pickle.dumps(dic)
8 print(type(j))#<class ‘bytes‘>
9
10
11 f=open(‘序列化对象_pickle‘,‘wb‘)#注意是w是写入str,wb是写入bytes,j是‘bytes‘
12 f.write(j) #-------------------等价于pickle.dump(dic,f)
13
14 f.close()
15 #-------------------------反序列化
16 import pickle
17 f=open(‘序列化对象_pickle‘,‘rb‘)
18
19 data=http://www.mamicode.com/pickle.loads(f.read())# 等价于data=pickle.load(f)
20
21
22 print(data[‘age‘])
复制代码
Pickle的问题和所有其他编程语言特有的序列化问题一样，就是它只能用于Python，并且可能不同版本的Python彼此都不兼容，因此，只能用Pickle保存那些不重要的数据，不能成功地反序列化也没关系。
七 shelve模块
shelve模块比pickle模块简单，只有一个open函数，返回类似字典的对象，可读可写;key必须为字符串，而值可以是python所支持的数据类型
复制代码
import shelve
f=shelve.open(r‘sheve.txt‘)
# f[‘stu1_info‘]={‘name‘:‘egon‘,‘age‘:18,‘hobby‘:[‘piao‘,‘smoking‘,‘drinking‘]}
# f[‘stu2_info‘]={‘name‘:‘gangdan‘,‘age‘:53}
# f[‘school_info‘]={‘website‘:‘http://www.pypy.org‘,‘city‘:‘beijing‘}
print(f[‘stu1_info‘][‘hobby‘])
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：
# print(root.iter(‘year‘)) #全文搜索
# print(root.find(‘country‘)) #在root的子节点找，只找一个
# print(root.findall(‘country‘)) #在root的子节点找，找所有
import xml.etree.ElementTree as ET
tree = ET.parse("xmltest.xml")
root = tree.getroot()
print(root.tag)
#遍历xml文档
for child in root:
print(‘========>‘,child.tag,child.attrib,child.attrib[‘name‘])
for i in child:
print(i.tag,i.attrib,i.text)
#只遍历year 节点
for node in root.iter(‘year‘):
print(node.tag,node.text)
#---------------------------------------
import xml.etree.ElementTree as ET
tree = ET.parse("xmltest.xml")
root = tree.getroot()
#修改
for node in root.iter(‘year‘):
new_year=int(node.text)+1
node.text=str(new_year)
node.set(‘updated‘,‘yes‘)
node.set(‘version‘,‘1.0‘)
tree.write(‘test.xml‘)
#删除node
for country in root.findall(‘country‘):
rank = int(country.find(‘rank‘).text)
if rank > 50:
root.remove(country)
tree.write(‘output.xml‘)
自己创建 xml文档
import xml.etree.ElementTree as ET
new_xml = ET.Element("namelist")
name = ET.SubElement(new_xml,"name",attrib={"enrolled":"yes"})
age = ET.SubElement(name,"age",attrib={"checked":"no"})
sex = ET.SubElement(name,"sex")
sex.text = ‘33‘
name2 = ET.SubElement(new_xml,"name",attrib={"enrolled":"no"})
age = ET.SubElement(name2,"age")
age.text = ‘19‘
et = ET.ElementTree(new_xml) #生成文档对象
et.write("test.xml", encoding="utf-8",xml_declaration=True)
ET.dump(new_xml) #打印生成的格式
九 configparser模块
配置文件模块
# 注释1
; 注释2
[section1]
k1 = v1
k2:v2
user=egon
age=18
is_admin=true
salary=31
[section2]
k1 = v1
读取
import configparser
config=configparser.ConfigParser()
config.read(‘a.cfg‘)
#查看所有的标题
res=config.sections() #[‘section1‘, ‘section2‘]
print(res)
#查看标题section1下所有key=value的key
options=config.options(‘section1‘)
print(options) #[‘k1‘, ‘k2‘, ‘user‘, ‘age‘, ‘is_admin‘, ‘salary‘]
#查看标题section1下所有key=value的(key,value)格式
item_list=config.items(‘section1‘)
print(item_list) #[(‘k1‘, ‘v1‘), (‘k2‘, ‘v2‘), (‘user‘, ‘egon‘), (‘age‘, ‘18‘), (‘is_admin‘, ‘true‘), (‘salary‘, ‘31‘)]
#查看标题section1下user的值=>字符串格式
val=config.get(‘section1‘,‘user‘)
print(val) #egon
#查看标题section1下age的值=>整数格式
val1=config.getint(‘section1‘,‘age‘)
print(val1) #18
#查看标题section1下is_admin的值=>布尔值格式
val2=config.getboolean(‘section1‘,‘is_admin‘)
print(val2) #True
#查看标题section1下salary的值=>浮点型格式
val3=config.getfloat(‘section1‘,‘salary‘)
print(val3) #31.0
改写
import configparser
config=configparser.ConfigParser()
config.read(‘a.cfg‘)
#删除整个标题section2
config.remove_section(‘section2‘)
#删除标题section1下的某个k1和k2
config.remove_option(‘section1‘,‘k1‘)
config.remove_option(‘section1‘,‘k2‘)
#判断是否存在某个标题
print(config.has_section(‘section1‘))
#判断标题section1下是否有user
print(config.has_option(‘section1‘,‘‘))
#添加一个标题
config.add_section(‘egon‘)
#在标题egon下添加name=egon,age=18的配置
config.set(‘egon‘,‘name‘,‘egon‘)
config.set(‘egon‘,‘age‘,18) #报错,必须是字符串
#最后将修改的内容写入文件,完成最终的修改
config.write(open(‘a.cfg‘,‘w‘))
十 hashlib模块
hash：一种算法 ,3.x里代替了md5模块和sha模块，主要提供 SHA1, SHA224, SHA256, SHA384, SHA512 ，MD5 算法
三个特点：
1.内容相同则hash运算结果相同，内容稍微改变则hash值则变
2.不可逆推
3.相同算法：无论校验多长的数据，得到的哈希值长度固定。
十一 suprocess模块
见老师博客
十二 logging模块
一:如果不指定filename,则默认打印到终端
二:指定日志级别:
指定方式:
1:level=10
2:level=logging.ERROR
日志级别种类:
CRITICAL = 50
FATAL = CRITICAL
ERROR = 40
WARNING = 30
WARN = WARNING
INFO = 20
DEBUG = 10
NOTSET = 0
三:指定日志级别为ERROR,则只有ERROR及其以上级别的日志会被打印
logging.basicConfig(filename=‘access.log‘,
format=‘%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s‘,
datefmt=‘%Y-%m-%d %H:%M:%S %p‘,
level=10)
logging.debug(‘debug‘)
logging.info(‘info‘)
logging.warning(‘warning‘)
logging.error(‘error‘)
logging.critical(‘critical‘)
logging.log(10,‘log‘) #如果level=40,则只有logging.critical和loggin.error的日志会被打印
可在logging.basicConfig()函数中通过具体参数来更改logging模块默认行为，可用参数有
filename：用指定的文件名创建FiledHandler（后边会具体讲解handler的概念），这样日志会被存储在指定的文件中。
filemode：文件打开方式，在指定了filename时使用这个参数，默认值为“a”还可指定为“w”。
format：指定handler使用的日志显示格式。
datefmt：指定日期时间格式。
level：设置rootlogger（后边会讲解具体概念）的日志级别
stream：用指定的stream创建StreamHandler。可以指定输出到sys.stderr,sys.stdout或者文件，默认为sys.stderr。若同时列出了filename和stream两个参数，则stream参数会被忽略
re模块
#在线调试工具:tool.oschina.net/regex/#
#re.findall:找到符合条件的所有结果
#
res=re.findall(‘<a\shref=http://www.mamicode.com/.*? # for i in res: #
print(i) import re content=‘Extra strings Hello 123 456
World_This is a Regex Demo Extra strings‘ # content=re.sub(‘\d+‘,‘‘,content) # print(content) #用\1取得第一个括号的内容 #用法:将123与456换位置 # import re # content=‘Extra strings Hello 123 456 World_This
is a Regex Demo Extra strings‘ # # #
content=re.sub(‘(Extra.*?)(\d+)(\s)(\d+)(.*?strings)‘,r‘\1\4\3\2\5‘,content) #
content=re.sub(‘(\d+)(\s)(\d+)‘,r‘\3\2\1‘,content) # print(content) # import re # content=‘Extra strings Hello 123 456
World_This is a Regex Demo Extra strings‘ # #
res=re.search(‘Extra.*?(\d+).*strings‘,content) # print(res.group(1)) # import requests,re #
respone=requests.get(‘https://book.douban.com/‘).text # print(respone) # print(‘======‘*1000) # print(‘======‘*1000) # print(‘======‘*1000) # print(‘======‘*1000) #
res=re.findall(‘<li.*?cover.*?href="http://www.mamicode.com/(.*?)".*?title="(.*?)">.*?more-meta.*?author">(.*?)</span.*?year">(.*?)</span.*?publisher">(.*?)</span.*?</li>‘,respone,re.S) # #
res=re.findall(‘<li.*?cover.*?href="http://www.mamicode.com/(.*?)".*?more-meta.*?author">(.*?)</span.*?year">(.*?)</span.*?publisher">(.*?)</span>.*?</li>‘,respone,re.S) # # # for i in res: #
print(‘%s %s %s
%s‘ %(i[0].strip(),i[1].strip(),i[2].strip(),i[3].strip())) day06模块re.sub:字符串替换