Python常用模块总结

sys

sys模块是与Python解释器交互的一个接口

sys.argv 命令行参数List，第一个元素是程序本身路径
sys.exit(n) 退出程序，正常退出时exit(0),错误退出sys.exit(1)
sys.version 获取Python解释程序的版本信息
sys.path 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值
sys.platform 返回操作系统平台名称

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.popen("bash command).read() 运行shell命令，获取执行结果
os.environ 获取系统环境变量
os.path.abspath(path) 返回path规范化的绝对路径 os.path.split(path) 将path分割成目录和文件名二元组返回 os.path.dirname(path) 返回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的大小

re

正则表达式，用来做字符串的匹配操作
元字符
. 除换行符以外的任何一个字符
？ 匹配0到1个任意字符
(+) 匹配1到多个任意字符
(*) 匹配0到多个任意字符
{,num2} 配置0到num2个{}前面那个字符
{num1,num2} 匹配num1到num2个{}前面那个字符
{num1,} 匹配num1到多个{}前面那个字符
^ 以……开头
$ 以……结尾
[a-z] 字符集，允许匹配a-z的任意一个字符，在[]中，除^代表非，\外，其他元字符不再有特殊意义
\ 后面跟元字符表示去除元字符特殊功能

> \d 匹配任何十进制数，相当于[0-9]
> \D 匹配任何非数字字符,相当于[^0-9]
> \s 匹配任何非空白字符,相当于[ \t\n\r\f\v]
> \S 匹配任何非空白字符,相当于[^ \t\n\r\f\v]
> \w 匹配任何字母数字字符,相当于[a-zA-Z0-9]
> \W 匹配任何非字母数字字符,相当于[^a-zA-Z0-9]
> \b 匹配一个单词边界
> r 原生字符

re.findall('kernel','kernelhjghjgbhjhjkerneljhjh') 在后面的那个字符串中找到符合前面规则的字符串以列表的形式返回
re.match(pattern,string,flag=0) 只从字符串开头开始匹配，配置成功，就会返回一个match object对象，必须到调用match object对象的方法才可以拿到值

> start() 返回匹配开始的位置
> end() 返回匹配结束的位置
> span() 返回一个元祖包含匹配（开始，结束）的位置
> group() 返回匹配成功的字符串
> groups() 获取模型中匹配到的分组结果
> groupdict() 同上，以key：value的形式 r = re.match(‘h(?P<name>\w+)’) 则key=name value=as

re.serach() 和match()类似，区别是可以从字符串的任意位置开始匹配，但只会匹配一次
re.sub(pattern,repl,string,max) 替换，根据pattern配置，将匹配的结果替换成repl，max表示最大替换次数
re.subn() 和re.sub()类似，区别是将匹配的次数也返回
re.split() 分割
re.compile() 将匹配规则封装成一个对象，在重复多次相同规则匹配的场景中效率会提高

time

时间处理模块

time模块的几种转换方式
print(time.time()) 时间戳
print(time.strftime("%Y-%m-%d %X")) 格式化的时间字符串
print(time.localtime()) 本地时区的struct_time
print(time.gmtime()) UTC时区的struct_time

扫描二维码关注公众号，回复： 2164039 查看本文章

时间戳转换为结构化时间
now_time = time.time() 时间戳
print(now_time)
struct_time = time.localtime(now_time) 时间戳转换为结构化时间
print(struct_time)

结构化时间转化为时间戳
struct_time = time.localtime(time.time()) 结构化时间
print(struct_time)
now_time = time.mktime(struct_time) 结构化时间转换为时间戳
print(now_time)

结构化时间转化为字符串时间
struct_time = time.localtime(time.time()) 结构化时间
print(struct_time)
str_time = time.strftime("%Y-%m-%d",struct_time) 结构化时间转换为字符串时间
print(str_time)

字符串时间转化为结构化时间
str_time = "2018-04-17" 字符串时间
struct_time = time.strptime(str_time,"%Y-%m-%d") 字符串时间转换为结构化时间
print(struct_time)

timedate

日期处理模块

timedate.date.today() 输出日期
timedate.date.fromtimestamp() 接收时间戳，转换成日期
timedate.current_time() 输出日期时间毫秒值
timedate.current_time.timetuple() 将日期时间毫秒值转换成struct_time
timedate.current_time.replace() 替换日期

json

只能适用于Python的基本数据类型，跨语言

json.loads() 接收一个字符串，转换成Python数据类型
json.load() 从文化中读取字符串，转换成Python数据类型
json.dumps() 接收一个Python数据类型。转换成字符串
json.dump() 接收一个Python数据类型，转换成字符串，写入到文件中

pickle

适用于Python的所有数据类型，但是只针对Python

pickle.loads() 接收字节，转换成Python数据类型
pickle.load() 从文化中读取字节，转换成Python数据类型
pickle.dumps() 接收一个Python数据类型。转换成字节
pickle.dump() 接收一个Python数据类型，转换成字节，写入到文件中

logging

日志处理模块

日志的级别
默认情况下Python的logging模块将日志打印到了标准输出中，且只显示了大于等于WARNING级别的日志，这说明默认的日志级别设置为WARNING（日志级别等级CRITICAL > ERROR > WARNING > INFO > DEBUG）

日志的配置
logging.basicConfig(level=logging.DEBUG,
format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',
datefmt='%a, %d %b %Y %H:%M:%S',
filename='/tmp/test.log',
filemode='w')
logging.debug('debug message')
logging.info('info message')
logging.warning('warning message')
logging.error('error message')
logging.critical('critical message')

配置参数
logging.basicConfig() 函数中可通过具体参数来更改logging模块默认行为，可用参数有：
filename：用指定的文件名创建FiledHandler，这样日志会被存储在指定的文件中。
filemode：文件打开方式，在指定了filename时使用这个参数，默认值为“a”还可指定为“w”。
format 指定handler使用的日志显示格式。
datefmt：指定日期时间格式。
level：设置rootlogger（后边会讲解具体概念）的日志级别
stream：用指定的stream创建StreamHandler。可以指定输出到sys.stderr,sys.stdout或者文件(f=open(‘test.log’,’w’))，默认为sys.stderr。若同时列出了filename和stream两个参数，则stream参数会被忽略。
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 用户输出的消息

logger对象配置

logger = logging.getLogger('kernel') # 创建logging对象
logger.setLevel(logging.DEBUG) # 指定全局被处理消息级别(全局处理消息级别要高于或等于局部消息处理级别）

ch = logging.StreamHandler() # 屏幕流
ch.setLevel(logging.DEBUG) # 指定局部被处理消息级别

fh = logging.FileHandler("access.log") # 文件流
fh.setLevel(logging.WARNING) # 指定局部被处理消息级别

formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') # 创建时间格式

ch.setFormatter(formatter) # 设置屏幕流时间格式
fh.setFormatter(formatter) # 设置文本流时间格式

logger.addHandler(ch) # 将屏幕流对象添加到logger中
logger.addHandler(fh) # 将文本流对象添加到logger中

logger.debug('debug message')
logger.info('info message')
logger.warn('warn message')
logger.error('error message')
logger.critical('critical message')

hashlib

加密模块

obj = hashlib.md5() # 创建hashlib对象
obj = hashlib.md5(bytes('kernel',encoding='utf-8')) # 创建hashlib对象并加言
obj.update(bytes('hello',encoding='utf-8')) # 加密
ret = obj.hexdigest() # 获取密文

configparser

操纵配置文件模块

import configparser
cfg = configparser.ConfigParser() # 创建configparser对象
cfg.read('conf',encoding='utf-8') # 读取配置文件

secs = cfg.sections() # 获取所有节点
print(secs)

options = cfg.options(secs[0]) # 获取指定节点的所有key
print(options)

item = cfg.items(secs[0]) # 获取指定节点的键值对组合
print(item)

val = cfg.get(secs[0],options[0]) # 获取指定节点下的指定key的值
print(val)

sec = cfg.remove_section(secs[0]) # 删除指定节点
cfg.write(open('conf','w'))
print(sec)

sec = cfg.has_section('jiedian1') # 检查是否存在该节点
print(sec)
sec = cfg.add_section('jiedian1') # 添加该节点
cfg.write(open('conf','w'))
print(sec)

cfg.set(secs[0],options[0],'111') # 修改指定节点下指定key的值
cfg.write(open('conf','w'))

cfg.remove_option(secs[0],options[0]) # 删除指定节点下指定键值对
cfg.write(open('conf','w'))

XML

操作XML文件模块

from xml.etree import ElementTree as ET
from xml.dom import minidom

# 修改XML
"""
解析XML的方式有两种
1.解析字符串方式
将字符串解析成XML对象，root代指XML文件的根节点
str_xml = open('xo.xml', 'r').read()
root = ET.XML(str_xml)
2.解析文件方式
获取xml文件的根节点
tree = ET.parse("xo.xml")
root = tree.getroot()
"""

# 遍历XML的所有内容
et = ET.parse('conf.xml')
root = et.getroot() # 获取根节点
print(root)

print(root.tag) # 顶层标签

for child in root: # 遍历XML文档的第二层
    print(' ' + child.tag,child.attrib) # 第二层节点的标签名和标签属性
    for i in child: # 遍历XML文档的第三层
        print('     ' + i.tag,i.attrib) # 第三层节点的标签名和标签属性
        print('         ' + str(i.text)) # 第三层节点的属性

# 遍历XML的指定节点
for node in root.iter('year'): # 遍历XML的所有year节点
    print(node.tag, node.text) # 节点的标签名称和内容

# 节点的标签名称和内容并修改节点内容
for node in root.iter('year'): # 遍历XML的所有year节点
    print(node.tag, node.text) # 节点的标签名称和内容
    new_year = int(node.text) + 1 # 将year节点的内容增加1
    node.text = str(new_year)
    node.set('name', 'kernel') # 设置属性和值
    node.set('age', '18')
    del node.attrib['name'] # 删除属性

# 删除节点
for country in root.findall('country'): # 遍历data下的所有country节点
    rank = int(country.find('rank').text) # 获取每一个country节点下rank节点的内容
    if rank > 50:
        root.remove(country)  # 删除指定country节点

"""
保存XML文件的方式也有两种
1.解析字符串方式
tree = ET.ElementTree(root)
tree.write("newnew.xml", encoding='utf-8')
2.解析文件方式
tree.write("new.xml",encoding='utf-8')
"""

# 创建XML文件
# 方式一
root = ET.Element("famliy")

son1 = ET.Element('son', {'name': '大儿子'}) # 创建大儿子节点
son2 = ET.Element('son', {"name": '二儿子'}) # 创建二儿子节点

grandson1 = ET.Element('grandson', {'name': '大孙子'}) # 在大儿子中创建两个孙子
grandson2 = ET.Element('grandson', {'name': '二孙子'})

son1.append(grandson1) # 将孙子添加到儿子节点中
son1.append(grandson2)

root.append(son1) # 把儿子添加到根节点中
root.append(son1)

tree = ET.ElementTree(root)
tree.write('oooo.xml',encoding='utf-8', short_empty_elements=False)

# 方式二
root = ET.Element("famliy")

son1 = root.makeelement('son', {'name': '大儿子'}) # 创建大儿子节点
son2 = root.makeelement('son', {"name": '二儿子'}) # 创建二儿子节点

grandson1 = root.makeelement('grandson', {'name': '大孙子'}) # 在大儿子中创建两个孙子
grandson2 = root.makeelement('grandson', {'name': '二孙子'})

son1.append(grandson1) # 将孙子添加到儿子节点中
son1.append(grandson2)

root.append(son1) # 把儿子添加到根节点中
root.append(son1)

tree = ET.ElementTree(root)
tree.write('oooo.xml',encoding='utf-8', short_empty_elements=False)

# 方式三
root = ET.Element("famliy")

son1 = root.SubElement('son', {'name': '大儿子'}) # 创建大儿子节点
son2 = root.SubElement('son', {"name": '二儿子'}) # 创建二儿子节点

grandson1 = root.SubElement('grandson', {'name': '大孙子'}) # 在大儿子中创建两个孙子
grandson2 = root.SubElement('grandson', {'name': '二孙子'})

son1.append(grandson1) # 将孙子添加到儿子节点中
son1.append(grandson2)

root.append(son1) # 把儿子添加到根节点中
root.append(son1)

tree = ET.ElementTree(root)
tree.write('oooo.xml',encoding='utf-8', short_empty_elements=False) # short_empty_elements=False 表示控制元素的格式如果值为False,没有内容,它们是作为一个单独闭合的标签，否则它们会以一对的形式发射开始/结束标记

# 方式四 原生保存的XML时默认无缩进，如果想要设置缩进的话,需要修改保存方式
def prettify(elem):
    """将节点转换成字符串，并添加缩进。
    """
    rough_string = ET.tostring(elem, 'utf-8')
    reparsed = minidom.parseString(rough_string)
    return reparsed.toprettyxml(indent="\t")

root = ET.Element("famliy")

son1 = ET.Element('son', {'name': '大儿子'}) # 创建大儿子节点
son2 = ET.Element('son', {"name": '二儿子'}) # 创建二儿子节点

grandson1 = ET.Element('grandson', {'name': '大孙子'}) # 在大儿子中创建两个孙子
grandson2 = ET.Element('grandson', {'name': '二孙子'})

son1.append(grandson1) # 将孙子添加到儿子节点中
son1.append(grandson2)

root.append(son1) # 把儿子添加到根节点中
root.append(son1)

raw_str = prettify(root)

f = open("xxxoo.xml",'w',encoding='utf-8')
f.write(raw_str)
f.close()

subprocess

执行系统命令模块

call

> 执行命令，返回状态码
> ret = subprocess.call(["ls", "-l"], shell=False)
> ret = subprocess.call("ls -l", shell=True)

check_call

> 执行命令，如果执行状态码是 0 ，则返回0，否则抛异常
> subprocess.check_call(["ls", "-l"])
> subprocess.check_call("exit 1", shell=True)

check_output

> 执行命令，如果状态码是 0 ，则返回执行结果，否则抛异常
> subprocess.check_output(["echo", "Hello World!"])
> subprocess.check_output("exit 1", shell=True)

subprocess.Popen(...)

> 用于执行复杂的系统命令
> 参数：
> args：shell命令，可以是字符串或者序列类型（如：list，元组）
> bufsize：指定缓冲。0 无缓冲,1 行缓冲,其他 缓冲区大小,负值 系统缓冲
> stdin, stdout, stderr：分别表示程序的标准输入、输出、错误句柄
> preexec_fn：只在Unix平台下有效，用于指定一个可执行对象（callable object），它将在子进 程运行之前被调用
> close_sfs：在windows平台下，如果close_fds被设置为True，则新创建的子进程将不会继承父进程的输入、输出、错误管道。
> close_sfs：在windows平台下，如果close_fds被设置为True，则新创建的子进程将不会继承父进程的输入、输出、错误管道。
> close_sfs：在windows平台下，如果close_fds被设置为True，则新创建的子进程将不会继承父进程的输入、输出、错误管道，所以不能将close_fds设置为True同时重定向子进程的标准输入、输出与错误(stdin, stdout, stderr)。
> shell：同上
> cwd：用于设置子进程的当前目录
> env：用于指定子进程的环境变量。如果env = None，子进程的环境变量将从父进程中继承。
> universal_newlines：不同系统的换行符不同，True -> 同意使用 \n
> startupinfo与createionflags只在windows下有效，将被传递给底层的CreateProcess()函数，用于设置子进程的一些属性，如：主窗口的外观，进程的优先级等等

import subprocess
"""
终端输入的命令分为两种：
输入即可得到输出，如：ifconfig
输入进行某环境，依赖再输入，如：python
"""

执行普通命令
ret1 = subprocess.Popen(["mkdir","t1"])
ret2 = subprocess.Popen("mkdir t2", shell=True)

在指定目录上创建文件夹
obj = subprocess.Popen("mkdir t3", shell=True, cwd='/home/dev',)

依赖环境的命令
obj = subprocess.Popen(["python"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True)
obj.stdin.write("print(1)\n")
obj.stdin.write("print(2)")

out_error_list = obj.communicate()
print(out_error_list)

obj = subprocess.Popen(["python"], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True)
out_error_list = obj.communicate('print("hello")')
print(out_error_list)