模块介绍
模块,用一坨代码实现了某个功能的代码集合。
类似于函数式编程和面向过程变成,函数式编程则完成一个功能,其他代码用来调用即可,提供了代码的重用性和代码间的耦合。而对于一个复杂的功能,可能需要多个函数才成完成(函数又可以在不同的.py文件中),n个.py文件组成的代码集合就成为模块。
如: os是系统相关的模块,file是文件操作相关的模块
模块分为三种:
- 自定义模块
- 内置标准模块(又称标准库)
- 开源模块
自定义模块和开源模块的使用参考 http://www.cnblogs.com/wupeiqi/articles/4963027.html
time & datetime模块
时间相关操作,时间有三种表示方式:
- 时间戳 1970年1月1日之后的秒,即: time.time()
- 格式化字符串 2018-11-11 11:11, 即:time.strftime('%Y-%m-%d')
- 结构化时间 元组包含了:年,日,星期等... time.struct_time 即:time.localtime()
import time # print(time.clock()) #返回处理器时间,3.3开始已废弃 , 改成了time.process_time()测量处理器运算时间,不包括sleep时间,不稳定,mac上测不出来 # print(time.altzone) #返回与utc时间的时间差,以秒计算\ # print(time.asctime()) #返回时间格式"Fri Aug 19 11:14:16 2016", # print(time.localtime()) #返回本地时间 的struct time对象格式 # print(time.gmtime(time.time()-800000)) #返回utc时间的struc时间对象格式 # print(time.asctime(time.localtime())) #返回时间格式"Fri Aug 19 11:14:16 2016", #print(time.ctime()) #返回Fri Aug 19 12:38:29 2016 格式, 同上 # 日期字符串 转成 时间戳 # string_2_struct = time.strptime("2016/05/22","%Y/%m/%d") #将 日期字符串 转成 struct时间对象格式 # print(string_2_struct) # # # struct_2_stamp = time.mktime(string_2_struct) #将struct时间对象转成时间戳 # print(struct_2_stamp) #将时间戳转为字符串格式 # print(time.gmtime(time.time()-86640)) #将utc时间戳转换成struct_time格式 # print(time.strftime("%Y-%m-%d %H:%M:%S",time.gmtime()) ) #将utc struct_time格式转成指定的字符串格式 #时间加减 import datetime # print(datetime.datetime.now()) #返回 2016-08-19 12:47:03.941925 #print(datetime.date.fromtimestamp(time.time()) ) # 时间戳直接转成日期格式 2016-08-19 # print(datetime.datetime.now() ) # print(datetime.datetime.now() + datetime.timedelta(3)) #当前时间+3天 # print(datetime.datetime.now() + datetime.timedelta(-3)) #当前时间-3天 # print(datetime.datetime.now() + datetime.timedelta(hours=3)) #当前时间+3小时 # print(datetime.datetime.now() + datetime.timedelta(minutes=30)) #当前时间+30分 # # c_time = datetime.datetime.now() # print(c_time.replace(minute=3,hour=2)) #时间替换
random模块
随机数
mport random
print random.random()
print random.randint(1,2)
print random.randrange(1,10)
生成随机验证码
import random
checkcode = ''
for i in range(4):
current = random.randrange(0,4)
if current != i:
temp = chr(random.randint(65,90))
else:
temp = random.randint(0,9)
checkcode += str(temp)
print checkcode
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下为"\r\n",Linux下为"\n" os.pathsep 输出用于分割文件路径的字符串 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所指向的文件或者目录的最后修改时间
更多猛击这里
sys模块
用于提供对解释器相关的操作
sys.argv 命令行参数List,第一个元素是程序本身路径 sys.exit(n) 退出程序,正常退出时exit(0) sys.version 获取Python解释程序的版本信息 sys.maxint 最大的Int值 sys.path 返回模块的搜索路径,初始化时使用PYTHONPATH环境变量的值 sys.platform 返回操作系统平台名称 sys.stdout.write('please:') val = sys.stdin.readline()[:-1]
更多猛击这里
shutil模块
高级的文件,文件夹,压缩包 处理模块
1. shutil.copyfileobj(fsrc,fdst)
把一个文件的内容拷贝到另一个文件中,可以部分内容
with open("f_old",'r',encoding="utf-8") as f1,\
open("f_new","w",encoding="utf-8") as f2:
shutil.copyfileobj(f1,f2) #拷贝文件的内容
2. shutil.copyfile(src,dst)
拷贝文件,但是不拷贝所有权限
shutil.copyfile("f_old","f_new") #同一目录下拷贝文件
shutil.copyfile(r'D:\PycharmProjects\pyhomework\day5\shutil_mode\shutil_mod\f_old',r'd:\f_new') #通过绝对路径拷贝文件
3. shutil.copymode(src,dst)
仅拷贝权限。内容、组、用户均不变
[root@whtest137 ~]# ll total 8 -rwxr-xr-x 1 root root 0 Apr 1 16:05 zhangqigao #有执行权限 -rw-r--r-- 1 whtest whtest 0 Apr 1 16:06 zhangqigao_old #没有执行权限 >>> import os,shutil >>> os.chdir("/root") #拷贝"zhangqigao_old"权限给"zhangqigao" >>> shutil.copymode("zhangqigao_old","zhangqigao") [root@whtest137 ~]# ll total 8 -rw-r--r-- 1 root root 0 Apr 1 16:05 zhangqigao # 获得跟"zhangqigao_old"一样的文件权限 -rw-r--r-- 1 whtest whtest 0 Apr 1 16:06 zhangqigao_old
4.shutil.copystat(src,dst)
拷贝文件的状态信息,如:mode bits, atime, mtime, flags
#两个文件的创建时间和用户权限都不同 [root@jenkins_sh temp]# ll total 0 -rw-r--r-- 1 root root 0 Apr 1 17:31 zhangqigao -rwxr-xr-x 1 jenkins jenkins 0 Apr 1 16:26 zhangqigao_old #python操作 >>> import os,shutil >>> os.chdir("/temp") #zhangqigao 这个文件状态 >>> os.stat("zhangqigao") posix.stat_result(st_mode=33188, st_ino=76808194, st_dev=2053L, st_nlink=1, st_uid=0, st_gid=0, st_size=0, st_atime=1491039109, st_mtime=1491039109, st_ctime=1491039109) #zhangqigao_old的文件状态 >>> os.stat("zhangqigao_old") posix.stat_result(st_mode=33261, st_ino=76808195, st_dev=2053L, st_nlink=1, st_uid=101, st_gid=103, st_size=0, st_atime=1491035188, st_mtime=1491035188, st_ctime=1491035242) #拷贝zhangqigao_old 文件状态给zhangqigao 文件 >>> shutil.copystat("zhangqigao_old","zhangqigao") # 拷贝后,zhangqigao文件的文件状态 >>> os.stat("zhangqigao") posix.stat_result(st_mode=33261, st_ino=76808194, st_dev=2053L, st_nlink=1, st_uid=0, st_gid=0, st_size=0, st_atime=1491035188, st_mtime=1491035188, st_ctime=1491039237) #操作后两个文件比较 [root@jenkins_sh temp]# ll total 0 -rwxr-xr-x 1 root root 0 Apr 1 16:26 zhangqigao #状态包括文件权限,文件创建的时间等,不包括文件所属用户和用户组 -rwxr-xr-x 1 jenkins jenkins 0 Apr 1 16:26 zhangqigao_old
5. shutil.copy(src,dst)
拷贝文件和权限
#拷贝前 [root@jenkins_sh temp]# ll total 0 -rwxr-xr-x 1 jenkins jenkins 0 Apr 1 16:26 zhangqigao_old #拷贝中 >>> import os,shutil >>> os.chdir("/temp") >>> shutil.copy("zhangqigao_old","zhangqigao") #拷贝结果输出 [root@jenkins_sh temp]# ll total 0 -rwxr-xr-x 1 root root 0 Apr 1 17:42 zhangqigao #拷贝了zhangqigao_old文件和文件权限 -rwxr-xr-x 1 jenkins jenkins 0 Apr 1 16:26 zhangqigao_old
6. shutil.copy2(src,dst)
拷贝文件和状态信息
#拷贝前 [root@jenkins_sh temp]# ll total 0 -rwxr-xr-x 1 jenkins jenkins 0 Apr 1 16:26 zhangqigao_old #拷贝中 >>> import os,shutil >>> os.chdir("/temp") >>> shutil.copy2("zhangqigao_old","zhangqigao") #拷贝后 [root@jenkins_sh temp]# ll total 0 -rwxr-xr-x 1 root root 0 Apr 1 16:26 zhangqigao #拷贝了zhangqigao_old的文件和状态 -rwxr-xr-x 1 jenkins jenkins 0 Apr 1 16:26 zhangqigao_old
7. shutil.copytree(src,dst)
递归去拷贝文件,相当于cp -r
#操作前 [root@jenkins_sh temp]# ll total 4 drwxr-xr-x 2 root root 4096 Apr 1 17:53 xiaogao [root@jenkins_sh temp]# cd xiaogao/;ll total 0 -rwxr-xr-x 1 root root 0 Apr 1 16:26 zhangqigao -rwxr-xr-x 1 jenkins jenkins 0 Apr 1 16:26 zhangqigao_old #操作中 >>> import os,shutil >>> os.chdir("/temp") >>> shutil.copytree("xiaogao","gaogao") #递归拷贝 #操作结果 [root@jenkins_sh temp]# ll total 8 drwxr-xr-x 2 root root 4096 Apr 1 17:53 gaogao #拷贝成功 drwxr-xr-x 2 root root 4096 Apr 1 17:53 xiaogao [root@jenkins_sh temp]# cd gaogao/;ll total 0 -rwxr-xr-x 1 root root 0 Apr 1 16:26 zhangqigao -rwxr-xr-x 1 root root 0 Apr 1 16:26 zhangqigao_old
8. shutil.rmtree(path[,ignore_errors[,onerror]])
递归去删除文件,相当于rm -rf
#操作前 [root@jenkins_sh temp]# ll total 4 drwxr-xr-x 2 root root 4096 Apr 1 17:53 xiaogao [root@jenkins_sh temp]# cd xiaogao/;ll total 0 -rwxr-xr-x 1 root root 0 Apr 1 16:26 zhangqigao -rwxr-xr-x 1 jenkins jenkins 0 Apr 1 16:26 zhangqigao_old #操作中 >>> import os,shutil >>> os.chdir("/temp") >>> shutil.rmtree("xiaogao") #操作结果 [root@jenkins_sh temp]# ll total 0 #成功删除xiaogao目录
9. shutil.move(src,dst)
递归的去移动文件,相当于mv
#操作前 [root@jenkins_sh temp]# ll total 4 drwxr-xr-x 2 root root 4096 Apr 1 18:07 xiaogao -rw-r--r-- 1 root root 0 Apr 1 18:07 zhangqigao #操作中 >>> import shutil >>> shutil.move("/temp/zhangqigao","/temp/xiaogao") #把文件移到目录中 #操作结果 [root@jenkins_sh xiaogao]# ll total 4 drwxr-xr-x 2 root root 4096 Apr 1 18:08 xiaogao [root@jenkins_sh temp]# cd xiaogao/;ll total 0 -rw-r--r-- 1 root root 0 Apr 1 18:07 zhangqigao
10.shutil.make_archive((base_name, format, root_dir=None,base_dir=None,verbose=0,dry=0,owner=None,group=None,logger=None)
创建压缩包并返回文件路径,例如:zip、tar
- base_name: 压缩包的文件名,也可以是压缩包的路径。只是文件名时,则保存至当前目录,否则保存至指定路径,
- 如:www =>保存至当前路径
- 如:/Users/wupeiqi/www =>保存至/Users/wupeiqi/
- format: 压缩包种类,“zip”, “tar”, “bztar”,“gztar”
- root_dir: 要压缩的文件夹路径(默认当前目录)
- owner: 用户,默认当前用户
- group: 组,默认当前组
- logger: 用于记录日志,通常是logging.Logger对象
#将 /Users/wupeiqi/Downloads/test 下的文件打包放置当前程序目录 import shutil ret = shutil.make_archive("wwwwwwwwww", 'gztar', root_dir='/Users/wupeiqi/Downloads/test') #将 /Users/wupeiqi/Downloads/test 下的文件打包放置 /Users/wupeiqi/目录 import shutil ret = shutil.make_archive("/Users/wupeiqi/wwwwwwwwww", 'gztar', root_dir='/Users/wupeiqi/Downloads/test')
11. zipfile
以zip的形式压缩文件,注意了这个只能压缩文件,不能压缩目录,如果压缩,也只能显示空目录。
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() #解压 z.close()
12. tarfile
以tar的形式打包文件,这边能打包所有文件,包括目录
import tarfile # 打包 tar = tarfile.open('your.tar','w') #不加arcname打的是绝对路径,也就是/Users/wupeiqi/PycharmProjects/bbs2.zip,加这个表示你在your.tar中加什么文件就写什么文件名,也就是bbs2.zip tar.add('/Users/wupeiqi/PycharmProjects/bbs2.zip', arcname='bbs2.zip') tar.add('/Users/wupeiqi/PycharmProjects/cmdb.zip', arcname='cmdb.zip') tar.close() # 解压 tar = tarfile.open('your.tar','r') tar.extractall() # 可设置解压地址 tar.close()
参考:http://www.cnblogs.com/wupeiqi/articles/4963027.html
json & pickle模块
用于序列化的两个模块
- json, 用于字符串和python数据类型间进行转换
- pickle, 用于python特有的类型和python数据类型间进行转换
Json模块提供了四个功能:dumps, dump, loads, load
pickle模块提供了四个功能:dumps, dump, loads, load
使用方法参考:这里
shelve模块
shelve模块是一个简单的k,v将内存数据通过文件持久化的模块,可以持久化任何pickle可支持的python数据格式
import shelve d = shelve.open('shelve_test') #打开一个文件 class Test(object): def __init__(self,n): self.n = n t = Test(123) t2 = Test(123334) name = ["alex","rain","test"] d["test"] = name #持久化列表 d["t1"] = t #持久化类 d["t2"] = t2 d.close()
详细使用方法实例:http://www.cnblogs.com/zhangqigao/articles/6672235.html
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("xmltest.xml") root = tree.getroot() print(root.tag) #遍历xml文档 for child in root: print(child.tag, child.attrib) for i in child: print(i.tag,i.text) #只遍历year 节点 for node in root.iter('year'): print(node.tag,node.text)
修改和删除xml文档内容
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") tree.write("xmltest.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模块
用于生成和修改常见配置文档,当前模块的名称在python3.x版本中变更为configparser
文档格式如下
[DEFAULT]
ServerAliveInterval = 45
Compression = yes
CompressionLevel = 9
ForwardX11 = yes
[bitbucket.org]
User = hg
[topsecret.server.com]
Port = 50022
ForwardX11 = no
如果想用python生成一个这样的文档怎么做呢?
import configparser
config = configparser.ConfigParser()
config["DEFAULT"] = {'ServerAliveInterval': '45',
'Compression': 'yes',
'CompressionLevel': '9'}
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)
写完了还可以再读出来
>>> import configparser
>>> config = configparser.ConfigParser()
>>> config.sections()
[]
>>> config.read('example.ini')
['example.ini']
>>> config.sections()
['bitbucket.org', 'topsecret.server.com']
>>> 'bitbucket.org' in config
True
>>> 'bytebong.com' in config
False
>>> config['bitbucket.org']['User']
'hg'
>>> config['DEFAULT']['Compression']
'yes'
>>> topsecret = config['topsecret.server.com']
>>> topsecret['ForwardX11']
'no'
>>> topsecret['Port']
'50022'
>>> for key in config['bitbucket.org']: print(key)
...
user
compressionlevel
serveraliveinterval
compression
forwardx11
>>> config['bitbucket.org']['ForwardX11']
'yes'
configparser增删改查语法
[section1]
k1 = v1
k2:v2
[section2]
k1 = v1
import ConfigParser
config = ConfigParser.ConfigParser()
config.read('i.cfg')
# ########## 读 ##########
#secs = config.sections()
#print secs
#options = config.options('group2')
#print options
#item_list = config.items('group2')
#print item_list
#val = config.get('group1','key')
#val = config.getint('group1','key')
# ########## 改写 ##########
#sec = config.remove_section('group1')
#config.write(open('i.cfg', "w"))
#sec = config.has_section('wupeiqi')
#sec = config.add_section('wupeiqi')
#config.write(open('i.cfg', "w"))
#config.set('group2','k1',11111)
#config.write(open('i.cfg', "w"))
#config.remove_option('group2','age')
#config.write(open('i.cfg', "w"))
hashlib模块
用于加密相关的操作,3.x里代替了md5模块和sha模块,主要提供SHA1, SHA224, SHA256, SHA384, SHA512, MD5算法
import hashlib
m = hashlib.md5()
m.update(b"Hello")
m.update(b"It's me")
print(m.digest())
m.update(b"It's been a long time since last time we ...")
print(m.digest()) #2进制格式hash
print(len(m.hexdigest())) #16进制格式hash
'''
def digest(self, *args, **kwargs): # real signature unknown
""" Return the digest value as a string of binary data. """
pass
def hexdigest(self, *args, **kwargs): # real signature unknown
""" Return the digest value as a string of hexadecimal digits. """
pass
'''
import hashlib
# ######## md5 ########
hash = hashlib.md5()
hash.update('admin')
print(hash.hexdigest())
# ######## sha1 ########
hash = hashlib.sha1()
hash.update('admin')
print(hash.hexdigest())
# ######## sha256 ########
hash = hashlib.sha256()
hash.update('admin')
print(hash.hexdigest())
# ######## sha384 ########
hash = hashlib.sha384()
hash.update('admin')
print(hash.hexdigest())
# ######## sha512 ########
hash = hashlib.sha512()
hash.update('admin')
print(hash.hexdigest())
python 还有一个 hmac 模块,它内部对我们创建 key 和 内容 再进行处理然后再加密
散列消息鉴别码,简称HMAC,是一种基于消息鉴别码MAC(Message Authentication Code)的鉴别机制。使用HMAC时,消息通讯的双方,通过验证消息中加入的鉴别密钥K来鉴别消息的真伪;
一般用于网络通信中消息加密,前提是双方先要约定好key,就像接头暗号一样,然后消息发送把用key把消息加密,接收方用key + 消息明文再加密,拿加密后的值 跟 发送者的相对比是否相等,这样就能验证消息的真实性,及发送者的合法性了。
import hmac
h = hmac.new(b'天王盖地虎', b'宝塔镇河妖')
print h.hexdigest()
更多关于md5,sha1,sha256等介绍的文章看这里https://www.tbs-certificates.co.uk/FAQ/en/sha256.html
subprocess 模块
在没有subprocess这个模块的时候,通过os.system(),os.popen(),commands这三个模块和操作系统做交互
1. os.system()
作用:执行操作系统命令,只返回命令的执行状态(0:成功,非0:失败),不返回命令的执行结果
>>> import os
>>> os.system("ls -l")
total 16708
-rw-------. 1 root root 1350 Jan 4 01:51 anaconda-ks.cfg
-rw-r--r--. 1 root root 8017 Jan 4 01:51 install.log
0 #执行返回的状态
>>> res = os.system("ls -l")
total 16708
-rw-------. 1 root root 1350 Jan 4 01:51 anaconda-ks.cfg
-rw-r--r--. 1 root root 8017 Jan 4 01:51 install.log
>>> res
0 #0: 表示成功
>>> res = os.system("lm")
sh: lm: command not found
>>> res
32512 #非0:表示失败
2. os.popen()
作用:执行操作系统命令,不返回命令的执行状态,只返回命令的执行结果。
>>> import os
>>> os.popen("ls -l")
<open file 'ls -l', mode 'r' at 0x7f5ded070540>
>>> res = os.popen("ls -l")
>>> a = res.read()
>>> print(a) #打印返回结果
total 16708
-rw-------. 1 root root 1350 Jan 4 01:51 anaconda-ks.cfg
-rw-r--r--. 1 root root 8017 Jan 4 01:51 install.log
注:执行popen() 不是直接返回命令的执行结果的,而是需要read一下,这是因为popen相当于打开了一个文件,它把结果存到文件中,只不过它是相当于存在内存中了,但是你好像打开文件的样子去取一样。
3. commands模块
作用:即可以获取命令的执行状态,也可以获取命令的执行结果,但是只能在python2.7有这个命令,在python3.5之后就没有,还有就是这个模块只支持Linux, Windows不支持,这里知道这个命令就行了。
>>> import commands #导入commands命令
>>> commands.getstatusoutput("ls -l")
(0, 'total 16708\n-rw-------. 1 root root 1350 Jan 4 01:51 anaconda-ks.cfg\n
-rw-r--r--. 1 root root 8017 Jan 4 01:51 install.log') #元组的形式返回
>>> res = commands.getstatusoutput("ls -l")
>>> res[0] #执行状态
0
>>> print(res[1]) #执行结果
total 16708
-rw-------. 1 root root 1350 Jan 4 01:51 anaconda-ks.cfg
-rw-r--r--. 1 root root 8017 Jan 4 01:51 install.log
上面说的commands模块在python3.5以后的版本就没有了,而且它又不支持windows,所以python3.5之后又出来新的模块更为强大,subprocess模块
1. subprocess.run()
作用: 运行命令,返回命令的执行结果(Python3.5以后的版本才会有这个命令)
>>> import subprocess
# python 解析则传入命令的每个参数的列表
>>> subprocess.run(["df","-h"])
Filesystem Size Used Avail Use% Mounted on
/dev/mapper/VolGroup-LogVol00
289G 70G 204G 26% /
tmpfs 64G 0 64G 0% /dev/shm
/dev/sda1 283M 27M 241M 11% /boot
CompletedProcess(args=['df', '-h'], returncode=0)
# 需要交给Linux shell自己解析,则:传入命令字符串,shell=True
>>> subprocess.run("df -h|grep /dev/sda1",shell=True)
/dev/sda1 283M 27M 241M 11% /boot
CompletedProcess(args='df -h|grep /dev/sda1', returncode=0)
注:执行的命令需要让python去解释执行这个命令,执行的命令以及参数,需要以列表的形式传入。第二种情况:但是如果需要交给Linux shell环境去解析的还,这传入命令的字符串,并且声明shell=True即可
2. subprocess.call()
作用:执行命令,返回命令的状态,0或者非0
>>> import subprocess
>>> res = subprocess.call(["ls","-l"])
total 26976
-rw-r--r-- 1 1000 1000 10914 Jan 17 15:57 aclocal.m4
drwxr-xr-x 5 root root 4096 May 12 14:21 build
-rwxr-xr-x 1 1000 1000 43940 Jan 17 15:57 config.guess
>>> res #返回命令的状态
0
3. subprocess.check_call()
作用:执行命令,如果执行结果为0,正常返回,否则抛出异常
>>> import subprocess
>>> res = subprocess.check_call(["ls","-l"])
total 26976
-rw-r--r-- 1 1000 1000 10914 Jan 17 15:57 aclocal.m4
drwxr-xr-x 5 root root 4096 May 12 14:21 build
>>> res
0
4. subprocess.getstatusoutput()
作用: 接受字符串形式的命令,返回元组形式,第一个元素是执行状态,第二个是命令结果
>>> import subprocess
>>> subprocess.getstatusoutput('ls /bin/ls')
(0, '/bin/ls') #0:执行状态,'bin/ls':执行结果
5. subprocess.getoutput()
作用: 接受字符串形式的命令,并且返回命令的结果
>>> import subprocess
>>> subprocess.getoutput('ls /bin/ls')
'/bin/ls' #返回命令的结果
6. subprocess.check_output()
作用: 执行命令,并且返回结果,不是打印
>>> import subprocess
>>> res = subprocess.check_output(["ls","-l"])
>>> res
b'total 26976\n-rw-r--r-- 1 1000 1000 10914 Jan 17 15:57 aclocal.m4\n
drwxr-xr-x 5 root root 4096 May 12 14:21 build\n
-rwxr-xr-x 1 1000 1000 43940 Jan 17 15:57 config.guess\n
-rw-r--r-- 1 root root 756903 May 12 14:18 config.log\n' #这边是以字节类型返回的
logging模块
很多程序都有记录日志的需求,并且日志中包含的信息即有正常的程序访问日志,还可能有错误,警告等信息输出,python的logging模块提供了标准的日志接口,你可以通过它存储各种格式的日志,logging的日志可以分为debug,info,warning,error和critical 5个级别,下面我们看看这个日志模块logging怎么用
一. 简单用法
说明:日志级别有五个,分别是,debug, info ,warning, error 和critical ,其中debug级别最低,critical级别最高,级别越低,打印的日志越多
import logging
logging.debug("logging debug")
logging.info("logging info")
logging.warning("user [abc] attempted wrong password more than 3 times")
logging.error("logging error")
logging.critical("logging critical")
#输出
WARNING:root:user [abc] attempted wrong password more than 3 times
ERROR:root:logging error
CRITICAL:root:logging critical
1.1. 日志级别
看一下这几个日志级别分别代表什么意思
Level | When it’s used |
---|---|
DEBUG | Detailed information, typically of interest only when diagnosing problems. |
INFO | Confirmation that things are working as expected. |
WARNING | An indication that something unexpected happened, or indicative of some problem in the near future (e.g. ‘disk space low’). The software is still working as expected. |
ERROR | Due to a more serious problem, the software has not been able to perform some function. |
CRITICAL | A serious error, indicating that the program itself may be unable to continue running. |
1.2. 日志写入文件
import logging
logging.basicConfig(filename="catalina.log",level=logging.INFO) #输入文件名,和日志级别
#---日志输出---
logging.debug("logging debug")
logging.info("logging info")
logging.warning("logging warning")
#输出到文件中的内容
INFO:root:logging info
WARNING:root:logging warning
注: 这句中的level=loggin.INFO意思是,把日志纪录级别设置为INFO,也就是说,只有比日志是INFO或比INFO级别更高的日志才会被纪录到文件里,所以debug日志没有记录,如果想记录,则级别设置成debug也就是level=loggin.DEBUG
1.3. 加入日期格式
logging.basicConfig(filename="catalina.log",
level=logging.INFO,
format='%(asctime)s %(module)s:%(levelname)s %(message)s', #格式请见第5点内容
datefmt='%m/%d/%Y %H:%M:%S %p') #需要加上format和datefmt
#----日志内容-----
logging.debug("logging debug")
logging.info("logging info")
logging.warning("logging warning")
#文件输出
04/11/2017 14:20:22 PM logging_mod:INFO logging info
04/11/2017 14:20:22 PM logging_mod:WARNING logging warning
1.4. 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 | 用户输出的 |
二. 复杂日志输出
之前的写法感觉要么就输入在屏幕上,要么就是输入在日志里面,那我们有没有既可以输出在日志上,又输出在日志里面呢?很明显,当然可以。下面我们就来讨论一下,如何使用复杂的日志输出。
1 简介
python使用logging模块记录日志涉及的四个主要类:
①logger:提供了应用程序可以直接使用的接口。
②handler:将(logger创建的)日志记录发送到合适的目的输出。
③filter:提供了细度设备来决定输出哪条日志记录。
④formatter:决定日志记录的最终输出格式。
2 logger
①每个程序在输出信息之前都需要获得一个logger。logger通常对应了程序的模块名,比如聊天工具的图形界面模块可以这样获得它的logger:
logger = logging.getLogger("chat.gui")
核心模块可以这样写:
logger = logging.getLogger("chat.kernel")
②logger.setLevel(lel)
说明:指定最低的日志级别,低于lel的级别将被忽略(debug是最低的内置级别,critical为最高)
logger.setLevel(logging.DEBUG) #设置级别为debug级别
③Logger.addFilter(filt)、Logger.removeFilter(filt)
说明:添加或删除指定的filter
④logger.addHandler(hdlr)、logger.removeHandler(hdlr)
说明:增加或删除指定的handler
logger.addHandler(ch)#添加handler
logger.removeHandler(ch) #删除handler
⑤Logger.debug()、Logger.info()、Logger.warning()、Logger.error()、Logger.critical()
说明:可以设置的日志级别
logger.debug('debug message')
logger.info('info message')
logger.warn('warn message')
logger.error('error message')
logger.critical('critical message')
⑤获取handler个数
handler_len = len(logger.handlers)
print(handler_len)
#输出
1
3、hander
handler对象负责发送相关的信息到指定目的地。Python的日志系统有多种Handler可以使用。有些Handler可以把信息输出到控制台,有些Logger可以把信息输出到文件,还有些 Handler可以把信息发送到网络上。如果觉得不够用,还可以编写自己的Handler。可以通过addHandler()方法添加多个多handler 。
①Handler.setLevel(lel)
说明:指定被处理的信息级别,低于lel级别的信息将被忽略。
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
②Handler.setFormatter()
说明:给这个handler选择一个格式
ch_formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s") #生成格式
ch.setFormatter(ch_formatter) #设置格式
③Handler.addFilter(filt)、Handler.removeFilter(filt)
说明:新增或删除一个filter对象
三. handler详解
1、logging.StreamHandler
说明:使用这个Handler可以向类似与sys.stdout或者sys.stderr的任何文件对象(file object)输出信息,也就是屏幕输出。
它的构造函数是:StreamHandler([strm]),其中strm参数是一个文件对象,默认是sys.stderr。
import logging
logger = logging.getLogger("TEST-LOG")
logger.setLevel(logging.DEBUG)
ch = logging.StreamHandler() #创建一个StreamHandler对象
ch.setLevel(logging.DEBUG) #设置输出StreamHandler日志级别
ch_formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
ch.setFormatter(ch_formatter) #设置时间格式
logger.addHandler(ch)
# 'application' code
logger.debug('debug message')
logger.info('info message')
logger.warn('warn message')
logger.error('error message')
logger.critical('critical message')
#输出
2017-04-11 16:42:49,764 - TEST-LOG - DEBUG - debug message
2017-04-11 16:42:49,764 - TEST-LOG - INFO - info message
2017-04-11 16:42:49,764 - TEST-LOG - WARNING - warn message
2017-04-11 16:42:49,765 - TEST-LOG - ERROR - error message
2017-04-11 16:42:49,765 - TEST-LOG - CRITICAL - critical message
2、logging.FileHandler
说明:和StreamHandler类似,用于向一个文件输出日志信息,不过FileHandler会帮你打开这个文件。
它的构造函数是:FileHandler(filename[,mode])。filename是文件名,必须指定一个文件名。mode是文件的打开方式。参见Python内置函数open()的用法。默认是’a',即添加到文件末尾。
import logging
#create logging
logger = logging.getLogger("TEST-LOG")
logger.setLevel(logging.DEBUG)
fh = logging.FileHandler("debug.log",encoding="utf-8") #日志输出到debug.log文件中
fh.setLevel(logging.INFO) #设置FileHandler日志级别
fh_formatter = logging.Formatter("%(asctime)s %(module)s:%(levelname)s %(message)s")
fh.setFormatter(fh_formatter)
logger.addHandler(fh)
# 'application' code
logger.info('info message')
logger.warn('warn message')
logger.error('error message')
logger.critical('critical message')
#输出到文件中
2017-04-11 17:09:50,035 logging_screen_output:INFO info message
2017-04-11 17:09:50,035 logging_screen_output:WARNING warn message
2017-04-11 17:09:50,035 logging_screen_output:ERROR error message
2017-04-11 17:09:50,035 logging_screen_output:CRITICAL critical message
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并不会被更名,而是被删除。
import logging
from logging import handlers #需要导入handlers
logger = logging.getLogger(__name__)
log_file = "timelog.log"
#按文件大小来分割,10个字节,保留个数是3个
fh = handlers.RotatingFileHandler(filename=log_file,maxBytes=10,backupCount=3)
formatter = logging.Formatter('%(asctime)s %(module)s:%(lineno)d %(message)s')
fh.setFormatter(formatter)
logger.addHandler(fh)
logger.warning("test1")
logger.warning("test12")
logger.warning("test13")
logger.warning("test14")
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:每天凌晨
import logging
from logging import handlers
import time
logger = logging.getLogger(__name__)
log_file = "timelog.log"
#按时间来分割文件,按5秒一次分割,保留日志个数是3个
fh = handlers.TimedRotatingFileHandler(filename=log_file,when="S",interval=5,backupCount=3)
formatter = logging.Formatter('%(asctime)s %(module)s:%(lineno)d %(message)s')
fh.setFormatter(formatter)
logger.addHandler(fh)
logger.warning("test1")
time.sleep(2)
logger.warning("test12")
time.sleep(2)
logger.warning("test13")
time.sleep(2)
logger.warning("test14")
logger.warning("test15")
四. 控制台和文件日志共同输出
需要什么样的输出,只需要添加相应的handler就ok了
1、逻辑图
2. 代码如下:
import logging
#create logging
logger = logging.getLogger("TEST-LOG")
logger.setLevel(logging.DEBUG)
#屏幕handler
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
#文件handler
fh = logging.FileHandler("debug.log",encoding="utf-8")
fh.setLevel(logging.INFO)
#分别创建输出日志格式
ch_formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
fh_formatter = logging.Formatter("%(asctime)s %(module)s:%(levelname)s %(message)s")
#设置handler的输出格式
ch.setFormatter(ch_formatter)
fh.setFormatter(fh_formatter)
#添加handler
logger.addHandler(ch)
logger.addHandler(fh)
# 'application' code
logger.debug('debug message')
logger.info('info message')
logger.warn('warn message')
logger.error('error message')
logger.critical('critical message')
注:如果添加时间分割或者文件大小分割,再添加handler即可。添加方式请见第三节中的3、4点
re模块
常用正则表达式符号
'.' 默认匹配除\n之外的任意一个字符,若指定flag DOTALL,则匹配任意字符,包括换行
'^' 匹配字符开头,若指定flags MULTILINE,这种也可以匹配上(r"^a","\nabc\neee",flags=re.MULTILINE)
'$' 匹配字符结尾,或e.search("foo$","bfoo\nsdfsf",flags=re.MULTILINE).group()也可以
'*' 匹配*号前的字符0次或多次,re.findall("ab*","cabb3abcbbac") 结果为['abb', 'ab', 'a']
'+' 匹配前一个字符1次或多次,re.findall("ab+","ab+cd+abb+bba") 结果['ab', 'abb']
'?' 匹配前一个字符1次或0次
'{m}' 匹配前一个字符m次
'{n,m}' 匹配前一个字符n到m次,re.findall("ab{1,3}","abb abc abbcbbb") 结果'abb', 'ab', 'abb']
'|' 匹配|左或|右的字符,re.search("abc|ABC","ABCBabcCD").group() 结果'ABC'
'(...)' 分组匹配,re.search("(abc){2}a(123|456)c", "abcabca456c").group() 结果 abcabca456c
'\' 转义
[a-z] 匹配[a-z]
[A-Z] 匹配[A-Z]
[0-9] 匹配数字0-9
'\A' 只从字符开头匹配,re.search("\Aabc","alexabc") 是匹配不到的
'\Z' 匹配字符结尾,同$
'\d' 匹配数字0-9
'\D' 匹配非数字
'\w' 匹配[A-Za-z0-9]
'\W' 匹配非[A-Za-z0-9]
's' 匹配空白字符、\t、\n、\r , re.search("\s+","ab\tc1\n3").group() 结果 '\t'
'(?P<name>...)' 分组匹配 re.search("(?P<province>[0-9]{4})(?P<city>[0-9]{2})(?P<birthday>[0-9]{4})","371481199306143242").groupdict("city")
结果:{'province': '3714', 'city': '81', 'birthday': '1993'}
一、 常用匹配方法
re.match 从头开始匹配
re.search 匹配包含
re.findall 把所有匹配到的字符放到以列表中的元素返回
re.split 以匹配到的字符当做列表分隔符
re.sub 匹配字符并替换
1、re.match(pattern, string, flags=0)
说明:在string的开始处匹配模式
>>> import re
>>> a = re.match('in',"inet addr:10.161.146.134") #从头开始匹配in字符
>>> a.group()
'in'
>>> a = re.match('addr',"inet addr:10.161.146.134") #开头匹配不到,所以返回none
>>> print(a)
None
2、re.search(pattern, string, flags=0)
说明:在string中寻找模式
>>> import re
>>> a = re.search('addr',"inet addr:10.161.146.134") #在字符串中寻找
>>> a.group()
'addr'
3、re.findall(pattern, string, flags=0)
说明:把匹配到的字符以列表的形式返回
>>> import re
>>> re.findall('[0-9]{1,3}',"inet addri:10.161.146.134")
['10', '161', '146', '134'] #符合条件的以列表的形式返回
4、re.split(pattern, string, maxsplit=0, flags=0)
说明:匹配到的字符被当做列表分割符
>>> import re
>>> re.split('\.',"inet addri:10.161.146.134")
['inet addri:10', '161', '146', '134']
5、re.sub(pattern, repl, string, count=0, flags=0)
说明:匹配字符并替换
>>> import re
>>> re.sub('\.','-',"inet addri:10.161.146.134")
'inet addri:10-161-146-134' #默认全部替换
>>> re.sub('\.','-',"inet addri:10.161.146.134",count=2)
'inet addri:10-161-146.134' #用count控制替换次数
6、finditer(pattern, string)
说明:返回迭代器
>>> import re
>>> re.finditer('addr',"inet addr:10.161.146.134")
<callable_iterator object at 0x00000000030C4BE0> #返回一个迭代器
二、常用方法
1、group([group1, ...])
说明:获得一个或多个分组截获的字符串;指定多个参数时将以元组形式返回。group1可以使用编号也可以使用别名;编号0代表整个匹配的子串;不填写参数时,返回group(0);没有截获字符串的组返回None;截获了多次的组返回最后一次截获的子串。
>>> import re
>>> a = re.search('addr',"inet addr:10.161.146.134")
>>> a.group()
'addr'
>>> a.group(0)
'addr'
2、groups(default=None)
说明:以元组形式返回全部分组截获的字符串。相当于调用group(1,2,…last)。default表示没有截获字符串的组以这个值替代,默认为None。这个要跟分组匹配结合起来使用'(...)'
>>> import re
>>> a = re.search("(\d{2})(\d{2})(\d{2})(\d{4})","320922199508083319") #一个小括号表示一个组,有4个括号,就是4个组
>>> a.groups()
('32', '09', '22', '1995')
3、groupdict(default=None)
说明:返回以有别名的组的别名为键、以该组截获的子串为值的字典,没有别名的组不包含在内。default含义同上。这个是跟另外一个分组匹配结合起来用的,即:'(?P<name>...)'
>>> import re
>>> a = re.search("(?P<province>[0-9]{4})(?P<city>[0-9]{2})(?P<birthday>[0-9]{4})","371481199306143242")
#以下两种情况获取的值都是一样的
>>> a.groupdict()
{'birthday': '1993', 'city': '81', 'province': '3714'}
>>> a.groupdict("city")
{'birthday': '1993', 'city': '81', 'province': '3714'}
4、span([group])
说明:返回(start(group), end(group))
>>> import re
>>> a = re.search('addr',"inet addr:10.161.146.134")
>>> a.group()
'addr'
>>> a.span() #获取'addr'在字符串中的开始位置和结束位置
(5, 9)
5、start([group])
说明:返回指定的组截获的子串在string中的起始索引(子串第一个字符的索引),group默认值为0。
>>> import re
>>> a = re.search('addr',"inet addr:10.161.146.134")
>>> a.group()
'addr'
>>> a.span()
(5, 9)
>>> a.start() #获取字符串的起始索引
5
6、end([group])
说明:返回指定的组截获的子串在string中的结束索引(子串最后一个字符的索引+1),group默认值为0。
>>> import re
>>> a = re.search('addr',"inet addr:10.161.146.134")
>>> a.group()
'addr'
>>> a.span()
(5, 9)
>>> a.end() #获取string中的结束索引
9
7、compile(pattern[, flags])
说明:根据包含正则表达式的字符串创建模式对象
>>> import re
>>> m = re.compile("addr") #创建正则模式对象
>>> n = m.search("inet addr:10.161.146.134") #通过模式对象去匹配
>>> n.group()
'addr'
三、反斜杠的困扰
与大多数编程语言相同,正则表达式里使用"\"作为转义字符,这就可能造成反斜杠困扰。假如你需要匹配文本中的字符"\",那么使用编程语言表示的正则表达式里将需要4个反斜杠"\\\\":前两个和后两个分别用于在编程语言里转义成反斜杠,转换成两个反斜杠后再在正则表达式里转义成一个反斜杠。Python里的原生字符串很好地解决了这个问题,这个例子中的正则表达式可以使用r"\\"表示。同样,匹配一个数字的"\\d"可以写成r"\d"。有了原生字符串,你再也不用担心是不是漏写了反斜杠,写出来的表达式也更直观。
>>> import re
>>> a = re.split("\\\\","C:\ \zhangqigao\yhd_settings")
>>> a
['C:', ' ', 'zhangqigao', 'yhd_settings']
>>> re.findall('\\','abc\com')
Traceback (most recent call last)
>>> re.findall('\\\\','abc\com')
['\\']
>>> re.findall(r'\\','abc\com')
['\\']
四、其他匹配模式
1、re.I(re.IGNORECASE
)
说明:忽略大小写(括号内是完整的写法,下同)
>>> import re
>>> a = re.search('addr',"inet Addr:10.161.146.134",flags=re.I)
>>> a.group()
'Addr' #忽略大小写
2、re.M(MULTILINE
)
说明:多行模式,改变'^'和'$'的行为,详细请见第2点
>>> import re
>>> a = re.search('^a',"inet\naddr:10.161.146.134",flags=re.M)
>>> a.group()
'a'
3、re.S(DOTALL
)
说明:点任意匹配模式,改变'.'的行为
>>> import re
>>> a = re.search('.+',"inet\naddr:10.161.146.134",flags=re.S)
>>> a.group()
'inet\naddr:10.161.146.134'