python常用模块总结
Python总共有295个模块，其中一般模块219个（如hashlib、math），以‘’_”开头的模块76个（如_hashlib），这些模块中常用的是collections、time、random、os、sys、序列化（如json）、re、hashlib、configparse、logging。各个常用模块的功能如下：
collections模块
random模块
os模块
sys模块
re模块
hashlib模块
1、collections模块
collections模块是数据类型扩展模块，主要用来解决一些常规数据类型不容易解决的问题，扩展数据类型主要有counter、deque、namedtuple、defaultdict、orderdict。
1）可双向插入、删除的快速列表deque
from collections import deque,namedtuple,defaultdict,OrderedDict,Counter#此处使用from...import...方式是为了后边使用时不用在加collections. #两端插入快速列表 salary = deque([2900,3000,3100,3200]) salary.append(3400)#从末尾插入元素 salary.appendleft(2800)#从开头插入元素 print(salary) salary.pop()#从末尾删除元素 print(salary) salary.popleft()#从开头删除元素 print(salary) #运行结果：deque([2800, 2900, 3000, 3100, 3200, 3400]) #运行结果：deque([2800, 2900, 3000, 3100, 3200]) #运行结果：deque([2900, 3000, 3100, 3200])
2)带有名字的元组
当表示一个规则的空间形状或坐标时，只需要确定其名称和长、宽、高等属性即可，这是利用有名称的
#有名字的元组 #namedtuple('名称', [属性list]): rectangle = namedtuple('rectangle', ['length', 'width','height'])#创建带名字的元组，第一个rectangle为一个类，第二个rectangle为类型 p = rectangle(1, 2,3)#p为rectangle类的一个实例 print(type(rectangle)) print(type(p)) print(p.length) print(p.width) print(p.height) #运行结果：<class 'type'> #运行结果：<class '__main__.rectangle'> #运行结果：1 #运行结果：2 #运行结果：3
3）有默认值的字典
用途(实例）：有一批油管的长度要丈量，其中90%以上的油管长度都是9.60m（出厂规格），这时如果统计油管长度的字典有默认值9.60，就不需要重复输入了
#有默认值的字典 tubelengthdict=defaultdict(lambda :9.60) tubelengthdict[1]=9.68 tubelengthdict[3]=9.54 for i in range(5): print(i,':',tubelengthdict[i],end=' | ') #运行结果：0 : 9.6 | 1 : 9.68 | 2 : 9.6 | 3 : 9.54 | 4 : 9.6 |
4）有序的字典
有序字典是按key插入的先后顺序排序
testdict=OrderedDict({'d':2,'e':3,'f':4})
testdict['a']=1
testdict['g']=5
print(testdict)
#运行结果OrderedDict([('d', 2), ('e', 3), ('f', 4), ('a', 1), ('g', 5)])
5）字符串计数类型Counter
Counter类型用来统计字符串中每个元素出现的次数
staticnum=Counter("ASAFUHAIGBJKCNAUIFHUIHKHFKJLHAKHF") print(staticnum) print(type(staticnum)) print(staticnum['H']) #运行结果：Counter({'H': 6, 'A': 5, 'F': 4, 'K': 4, 'U': 3, 'I': 3, 'J': 2, 'S': 1, 'G': 1, 'B': 1, 'C': 1, 'N': 1, 'L': 1}) #运行结果：<class 'collections.Counter'> #运行结果：6
time模块用来做人与计算机之间的时间交互，共有三种格式：可分为计算机识别的格式（时间戳timestamp）、桥梁时间格式（结构化时间struct_time）、人习惯的格式（字符串格式Format String time）。
1)时间的三种格式和两种常用方法
三种时间格式：
时间戳：表示的是从1970年1月1日00:00:00开始按秒计算的偏移量，数值类型为浮点数，单位为秒；
结构化时间：可以直接转化为时间戳或字符串时间，类型为元祖；
字符串时间：以人习惯的方式表示时间，类型为字符串。
两种常用方法：
使用时间方法前必须先导入时间模块
#导入时间模块 import time #两种常用方法 1.time.sleep(secs) (线程)推迟指定的时间运行，单位为秒。 2.time.time() 获取当前时间戳
三种时间格式实例
#时间戳（实例） 1536577467.4527252 #结构化时间（实例） time.struct_time(tm_year=2018, tm_mon=9, tm_mday=10, tm_hour=19, tm_min=4, tm_sec=27, tm_wday=0, tm_yday=253, tm_isdst=0) #字符串时间 2018-09-10 19:04:27
2)三种时间格式的转换方法
转化为时间戳
只有结构化时间可以直接转化为时间戳，使用的函数是mktime（p_tuple）。字符串时间不能直接转化成时间戳。
#转化为时间戳 print(time.mktime(time.localtime()))#time.localtime()获取当前时间的结构化时间（地区）,mktime可将结构化时间转化为时间戳
#运行结果：1536578103.0
利用time.time方法也可直接获取当前时间的时间戳
print(time.time()) #获取当前时间的时间戳 #运行结果：1536578103.9763558
转化为结构化时间
字符串时间转化为结构化时间方法为：strptime(string, format)
#字符串时间转化为结构化时间 print(time.strptime("2018/09/10 19:24:00","%Y/%m/%d %H:%M:%S"))
#运行结果：time.struct_time(tm_year=2018, tm_mon=9, tm_mday=10, tm_hour=19, tm_min=24, tm_sec=0, tm_wday=0, tm_yday=253, tm_isdst=-1)
时间戳转化为结构化时间方法为：localtime(seconds=None)，gmtime(seconds=None)
#时间戳转化为结构化时间 print(time.localtime()) #获取当前时间的结构化时间（地区） print(time.gmtime()) #获取当前时间的结构化时间（格林尼治时间
#运行结果：time.struct_time(tm_year=2018, tm_mon=9, tm_mday=10, tm_hour=19, tm_min=25, tm_sec=25, tm_wday=0, tm_yday=253, tm_isdst=0)
#运行结果：time.struct_time(tm_year=2018, tm_mon=9, tm_mday=10, tm_hour=11, tm_min=25, tm_sec=25, tm_wday=0, tm_yday=253, tm_isdst=0)
转化为字符串时间
结构化时间转化为字符串时间strftime(format, p_tuple=None)，asctime(p_tuple=None)
#结构化时间转化为字符串时间 print(time.strftime("%Y/%m/%d %H:%M:%S",time.localtime(1500000000))) #获取输入时间的字符串时间 print(time.asctime(time.localtime())) #获取当前时间的字符串时间，固定格式%a %b %d %H:%M:%S %Y #运行结果：2017/07/14 10:40:00 #运行结果：Mon Sep 10 19:38:26 2018
时间戳转化为字符串时间：ctime(seconds=None)
#时间戳转化为字符串时间 print(time.ctime(1500000000))#获取输入时间的字符串时间，固定格式%a %b %d %H:%M:%S %Y #运行结果：Fri Jul 14 10:40:00 2017
3)字符串时间补充
在上边的代码中可以看到，字符串时间中有一些带有特殊意义的字母，它们是年、月、日、时、分、秒、星期等的缩写，各个字母与含义的对应表入下：
%y 两位数的年份表示（00-99） %Y 四位数的年份表示（000-9999） %m 月份（01-12） %d 月内中的一天（0-31） %H 24小时制小时数（0-23） %I 12小时制小时数（01-12） %M 分钟数（00=59） %S 秒（00-59） %a 本地简化星期名称 %A 本地完整星期名称 %b 本地简化的月份名称 %B 本地完整的月份名称 %c 本地相应的日期表示和时间表示 %j 年内的一天（001-366） %p 本地A.M.或P.M.的等价符 %U 一年中的星期数（00-53）星期天为星期的开始 %w 星期（0-6），星期天为星期的开始 %W 一年中的星期数（00-53）星期一为星期的开始 %x 本地相应的日期表示 %X 本地相应的时间表示 %Z 当前时区的名称 %% %号本身
3、random模块
import random print(random.random())#获得0-1之间的一个浮点数 print(random.uniform(2,8))#获得2-8之间的一个浮点数 print(random.randint(1,10))#获得1-10之间的一个整数 print(random.randrange(1,100,5))#获得1-100之间每隔5个数组成数组的一个整数 print(random.choice([1,2,3,4,5]))#random.choice(list)随机获得输入list中的一个元素 print(random.sample([1,2,3,4,5],2))#random.choice(list,n)随机获得输入list中的n 个元素 item=[1,3,5,6,7,8,9] random.shuffle(item)#将item（类型list）打乱重排 print(item) random.shuffle(item)#将item（类型list）再次打乱重排 print(item) #运行结果： 0.2795927143951151 5.780736466302746 8 6 3 [5, 2] [1, 5, 3, 8, 6, 7, 9] [7, 5, 6, 9, 8, 3, 1]
4、os模块
os模块是与操作系统进行交互的接口。功能主要包括目录的增删改，文件的删改，路径的获取、变更和操作。
1）模块使用前必须先导入
#导入os模块 import os
2） 路径的获取、变更和操作
路径的获取getcwd()，路径的变更os.chdir("dirname")，路径的拼接os.path...
os.getcwd()# 获取当前工作路径 os.chdir("dirname") #改变当前脚本的工作路径 #os.path系列 #路径返回系列 os.path.abspath(path)#返回输入目录的绝对路径 os.path.split(path)#将目录和文件名分开以元祖形式返回 os.path.dirname(path)#获取目录 os.path.basename（path）#获取文件名 #路径判断系列 os.path.exists(path)#判断路径是否存在 os.path.isabs(path)#判断是否是绝对路径 os.path.isfile(path)#判断是否是文件 os.path.isdir(path)#判断是否是目录 #路径拼接系列 os.path.join(path,path1,path2,...)#将多个目录拼接在一起，会自动忽略根目录之前的路径 #路径属性获取系列 os.path.getsize(path)#返回路径的大小 os.path.getatime(path)#获取路径最后访问时间 os.path.getmtime(path)#获取路径最后修改时间
3）目录的增删改查
目录的增加makedirs('dirname1/dirname2')、mkdir('dirname')，删除removedirs('dirname')、rmdir('dirname')，重命名rename('oldname','newname')、查os.stat('path/filename')
makedirs('dirname1/dirname2')#增加一个或一串目录 mkdir('dirname')#增加一个目录 removedirs('dirname')#删除一个或一串（父目录为空时）目录 rmdir('dirname')#删除一个目录 rename('oldname','newname')#重命名一个目录
os.stat('path/filename')#获取文件/目录信息
4）文件的删改查
文件之所以没有“增加”操作，是因为以写方式打开一个文件，保存时如果问价不存在会自动创建。文件的删除remove('filename')、重命名rename('oldname','newname')、查os.stat('path/filename')
remove('filename')#删除一个文件 rename('oldname','newname')#重命名一个文件 os.stat('path/filename') #获取文件/目录信息
5、sys模块
sys模块是用来获取、设置操作系统和编译器参数的。常用的方法如下：
import sys sys.argv#运行该脚本时，用户从外部输入的数据以list形式存在sys.argv中，sys.argv[0]是文件本身路径 sys.exit(0)#退出程序，不报异常；当参数为1时，退出程序报SystemExit异常 sys.path#返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值;利用sys.path.append()可以添加环境变量 sys.version#返回解释器的版本信息 sys.platform#返回操作系统名称（不准） sys.getdefaultencoding()#获取系统当前编码 sys.getfilesystemencoding()#获取文件系统使用编码方式
python是一门高级语言，高级语言的某些数据结构低级语言是不能识别的，这使得在传送python数据结构时只能转化成低级语言识别的数据，而json序列话就是将python数据类型转化成str，反序列化就是将str转化成python数据类型。与eval不一样json只能实现数据类型和str之间的转化，并不能执行其他代码，所以使得安全性有了保障。
import json #dumps和loads dic={'name':'lv','age':26,'tel':6224,520:186343} print(dic)#{'name': 'lv', 'age': 26, 'tel': 6224, 520: 186343} str_dic=json.dumps(dic)#将字典转化为字符串，序列化过程 print(type(str_dic),str_dic)#<class 'str'> {"name": "lv", "age": 26, "tel": 6224, "520": 186343} load_dic=json.loads(str_dic)#将json字符串转化字典，反序列化过程 print(type(load_dic),load_dic)#<class 'dict'> {'name': 'lv', 'age': 26, 'tel': 6224, '520': 186343}
import json #dump和load f=open('json_file','w') dic={'name':'lv','age':26,'tel':6224,520:186343} json.dump(dic,f)#将字典转化为字符串，并写入文件中 f.close() f=open('json_file','r') load_dic=json.load(f)#将json文件转化字典，反序列化过程 print(type(load_dic),load_dic)#<class 'dict'> {'name': 'lv', 'age': 26, 'tel': 6224, '520': 186343} f.close()
除json外，pickle也能实现类似的功能，用法与json类似，此处就不介绍了。
7、re模块
re模块是用来验证、查找满足规则的字符的。在Python中，如果在‘ahfiababoi13863615567aafga5ga54a5a54g5a4w5eaa31f3a47aw’要查找“13863615567”，可以利用字符串切片加for循环查找的方式，但这种方式比较繁琐，有没有什么简便的方法呢？
此处为大家介绍正则表达式，正则表达式用来检索、替换那些符合某个模式(规则)的文本的。
1）正则表达式
正则表达式之所以比单个查找比对字符简单，是因为它用特殊含义的字符和量词组合表示模式（规则），接下来将分字符组（基本概念）、特殊含义字符、量词、组合含义四部分为大家介绍。
字符组
‘af’、'ad'、'1sf'、'ad1'、'e8'、'rty'、's4'、'l4x'、'adf'、'784'、'4sw'......假设现在有10000个长度不等的字符串，要查找出其中所有“数字+字母”的组合，这是用Python字符串的操作方法会比较繁琐，用正则表达式只需[a-zA-Z][0-9]即可。一个[]代表一个字符组，括号中填写需要匹配的所有字符即可，每个[]只能匹配一个字符。
正则 |
待匹配字符 |
匹配 |
说明 |
[0123456789] |
8 |
True |
在一个字符组里枚举合法的所有字符，字符组里的任意一个字符 |
[0123456789] |
a |
False |
由于字符组中没有"a"字符，所以不能匹配 |
[0-9] |
7 |
True |
也可以用-表示范围,[0-9]就和[0123456789]是一个意思 |
[a-z] |
s |
True |
同样的如果要匹配所有的小写字母，直接用[a-z]就可以表示 |
[A-Z] |
B |
True |
[A-Z]就表示所有的大写字母 |
[0-9a-fA-F] |
e |
True |
可以匹配数字，大小写形式的a～f，用来验证十六进制字符 |
特殊含义字符
假如要表示字母或数字或下划线，根据上边的规则为[a-zA-Z0-9_]，用特殊含义字符为[\w]，可见使用特殊含义字符能简化表达式。
特殊含义字符表：
元字符 |
匹配内容 |
| . | 匹配除换行符以外的任意字符 |
| \w | 匹配字母或数字或下划线 |
| \s | 匹配任意的空白符 |
| \d | 匹配数字 |
| \n | 匹配一个换行符 |
| \t | 匹配一个制表符 |
| \b | 匹配一个单词的结尾 |
| ^ | 匹配字符串的开始 |
| $ | 匹配字符串的结尾 |
| \W |
匹配非字母或数字或下划线 |
| \D |
匹配非数字 |
| \S |
匹配非空白符 |
| a|b |
匹配字符a或字符b |
| () |
匹配括号内的表达式，也表示一个组 |
| [...] |
匹配字符组中的字符 |
| [^...] |
匹配除了字符组中字符的所有字符 |
正则表达式中的量词
当限制匹配次数时就要用到量词。
量词：
| 量词 | 含义 |
| * | 表示重复0次或多次 |
| + | 表示重复1次或多次 |
| ？ | 表示重复0次或1次 |
| {n} | 表示重复n次 |
| {n,} | 表示重复大于或等于n次 |
| {n,m} | 表示重复n到m次 |
字符量词的组合
.^$表示以.结尾的字符，如‘[吕][.]?[永]$’表示匹配姓‘吕’以‘永’结尾的名字 .?比配0次或1次任意字符 .*表示匹配任意字符尽量多的次数 r'\n'字符r为非转义，表示屁匹配‘/n’，不是匹配回车符 *? 重复任意次，但尽可能少重复 +? 重复1次或更多次，但尽可能少重复 ?? 重复0次或1次，但尽可能少重复 {n,m}? 重复n到m次，但尽可能少重复 {n,}? 重复n次以上，但尽可能少重复
分组与命名分组
>>> s='<div><a href="https://support.google.com/chrome/?p=ui_hotword_search" target="_blank">更多</a><p>dfsl</p></div>' >>> print re.search(r'<a.*>(.*)</a>',s).group(1)
#通过命名分组进行后向引用 >>> re.search(r'(?P<name>go)\s+(?P=name)\s+(?P=name)', 'go go go').group('name') 'go' #通过默认分组编号进行后向引用 >>> re.search(r'(go)\s+\1\s+\1', 'go go go').group() 'go go go'
2）re模块
re模块方法主要有findall(pattern, string, flags=0)、search(pattern, string, flags=0)、match(pattern, string, flags=0)、split(pattern, string, maxsplit=0, flags=0)、sub(pattern, repl, string, count=0, flags=0)、compile(pattern, flags=0)、finditer(pattern, string, flags=0)
import re ret=re.findall('l','uyhsfvafvbiusahjhgklahklalalahe')#以列表方式返回所有满足条件的结果 print(ret) ret=re.search('l','uyhsfvafvbiusahjhgklahklalalahe')#匹配满足条件的结果1次 print(ret.group())#调用group方法显示结果，类型为字符串 ret=re.match('l','luyhsfvafvbiusahjhgklahklalalahe')#在匹配对象开始处匹配满足条件的结果1次 print(ret.group())#调用group方法显示结果，类型为字符串 ret=re.split('l','uyhsfvafvbiusahjhgklahklalalahe')#将字符串以‘l’分割，并以列表方式返回分割后的结果 print(ret) ret=re.sub('old','new','uyhsfvafvbiusahjhgkoldlahkoldalalahe')#将字符串中的'old'替换为'new'，以元祖方式返回替换后额结果和替换次数 print(ret) obj = re.compile('\d{3}') #将正则表达式编译成为一个 正则表达式对象，规则要匹配的是3个数字 ret = obj.search('abc748ajakh') #正则表达式对象调用search，参数为待匹配的字符串 print(ret.group()) ret = re.finditer('[a-z]', 'a4fa85a4ga7ga4d') #finditer返回一个存放匹配结果的迭代器 print(ret) for i in ret: print([i.group()]) #运行结果：['l', 'l', 'l', 'l'] #运行结果：l #运行结果：l #运行结果：['uyhsfvafvbiusahjhgk', 'ahk', 'a', 'a', 'ahe'] #运行结果：uyhsfvafvbiusahjhgknewlahknewalalahe #运行结果：748 #运行结果：<callable_iterator object at 0x7f2cccc21940> #运行结果：['a']['f']['a']['a']['g']['a']['g']['a']['d']
8、hashlib模块
登录一个网站时，用户需要输入用户名和密码。用户名和密码一般存储在数据库或表格文件中，如果以明文方式存储，一旦密码遭泄露或破解将会造成难以预料的后果。哪有没有什么方法来避免这个问题呢？这就要用到我们今天要将的hashlib模块。
Python的hashlib提供了常见的摘要算法，如MD5，SHA1等等。
什么是摘要算法呢？摘要算法又称哈希算法、散列算法。它通过一个函数，把任意长度的数据转换为一个长度固定的数据串（通常用16进制的字符串表示）。
import hashlib md5=hashlib.md5()#创建hash对象 md5.update(b'how are you?') print(md5.hexdigest())#将hash对象转化为32为的16进制字符串 #运行结果：35179a54ea587953021400eb0cd23201
为了确保用户输入简单密码时也不容易被盗号，就要用到“加盐”算法，说白了就是先将用户的密码与一个字符串拼接，然后再进行整体加密。
import hashlib md5=hashlib.md5("salt".encode("utf8"))#创建hash对象时进行加盐 md5.update(b'how are') md5.update(b' you?')#update可以分多次完成，结果不变 print(type(md5.hexdigest()),md5.hexdigest()) #运行结果：1a9d6204f6be8bea3a1ac1ebf696197a
SHA1算法与MD5算法基本相同（只不过将代码中的md5改为sha1），只不过加密后生成的字符串为40为的16进制字符，更安全也更慢。
import hashlib sha1=hashlib.sha1("salt".encode("utf8")) sha1.update(b'how are') sha1.update(b' you?') print(sha1.hexdigest()) #运行结果：225883ca4521455793e98eea3a03e8013b240de6
