Python学习【第6篇】：Python之常用模块1
collocations 模块
时间模块
random模块
os模块
sys模块
序列化模块
re模块
常用模块二：这些模块和面向对象有关
hashlib模块
configparse模块
logging模块
三、正则表达式
像我们平常见的那些注册页面啥的，都需要我们输入手机号码吧，你想我们的电话号码也是有限定的吧（手机号码一共11位，并且只以13,14,15,17,18开头的数字这些特点）如果你的输入有误就会提示，那么实现这个程序的话你觉得用While循环so easy嘛，那么我们来看看实现的结果
import re phone_number=input('请输入你的电话号码：') if re.match('^(13|14|15|17|18)[0-9]{9}$',phone_number): '''^这个符号表示的是判断是不是以13|14|15|17|18开头的， [0-9]: []表示一个字符组，可以表示0-9的任意字符 {9}:表示后面的数字重复九次 $:表示结束符 ''' print('是合法的手机号码') else: print('不是合法的手机号码') 判断手机号码输入是否合法
那么什么是正则呢？
首先你要知道的是，谈到正则，就只和字符串相关了。在线测试工具 http://tool.chinaz.com/regex/
比如你要用‘1’去匹配‘1’，或者用‘2’去匹配‘2’，直接就可以匹配上。
字符组：[字符组] 在同一位置可能出现的各种字符组成了一个字符组，在正则表达式中用[]表示 字符分为很多类，比如数字，字母，标点等登。 假如你现在要求一个位置‘只能出现一个数字’，那么这个位置上的字符只能是0、1、2、3.......9这是个数之一。
字符组：
字符：
量词：
.^$
*+?{}
注意：前面的*，+，？等都是贪婪匹配，也就是尽可能多的匹配，后面加？就变成了非贪婪匹配，也就是惰性匹配。
贪婪匹配：
几个常用的配贪婪匹配
|
1
2
3
4
5
|
*？；重复任意次，但尽可能少重复+？：重复一次或更多次，但尽可能少重复？？：重复0次或1次，但尽可能少重复{n,m}：重复n到m次，但尽可能少重复{n,}： 重复n次以上，但尽可能少重复 |
.*?的用法：
|
1
2
3
4
5
6
|
.是任意字符*是取0到无限长度?是非贪婪模式和在一起就是取尽量少的任意字符，一般不会这么单独写，大多用在：.*?x意思就是取前面任意长度的字符，直到一个x出现 |
字符集：
举个例子，比如html源码中有<title>xxx</title>标签，用以前的知识，我们只能确定源码中的<title>和</title>是固定不变的。因此，如果想获取页面标题(xxx)，充其量只能写一个类似于这样的表达式：<title>.*</title>，而这样写匹配出来的是完整的<title>xxx</title>标签，并不是单纯的页面标题xxx。 想解决以上问题，就要用到断言知识。 在讲断言之前，读者应该先了解分组，这有助于理解断言。 分组在正则中用()表示，根据小菜理解，分组的作用有两个： n 将某些规律看成是一组，然后进行组级别的重复，可以得到意想不到的效果。 n 分组之后，可以通过后向引用简化表达式。 先来看第一个作用，对于IP地址的匹配，简单的可以写为如下形式： \d{1,3}.\d{1,3}.\d{1,3}.\d{1,3} 但仔细观察，我们可以发现一定的规律，可以把.\d{1,3}看成一个整体，也就是把他们看成一组，再把这个组重复3次即可。表达式如下： \d{1,3}(.\d{1,3}){3} 这样一看，就比较简洁了。 再来看第二个作用，就拿匹配<title>xxx</title>标签来说，简单的正则可以这样写： <title>.*</title> 可以看出，上边表达式中有两个title，完全一样，其实可以通过分组简写。表达式如下： <(title)>.*</\1> 这个例子实际上就是反向引用的实际应用。对于分组而言，整个表达式永远算作第0组，在本例中，第0组是<(title)>.*</\1>，然后从左到右，依次为分组编号，因此，(title)是第1组。 用\1这种语法，可以引用某组的文本内容，\1当然就是引用第1组的文本内容了，这样一来，就可以简化正则表达式，只写一次title，把它放在组里，然后在后边引用即可。 以此为启发，我们可不可以简化刚刚的IP地址正则表达式呢？原来的表达式为\d{1,3}(.\d{1,3}){3}，里边的\d{1,3}重复了两次，如果利用后向引用简化，表达式如下： (\d{1,3})(.\1){3} 简单的解释下，把\d{1,3}放在一组里，表示为(\d{1,3})，它是第1组，(.\1)是第2组，在第2组里通过\1语法，后向引用了第1组的文本内容。 经过实际测试，会发现这样写是错误的，为什么呢？ 小菜一直在强调，后向引用，引用的仅仅是文本内容，而不是正则表达式！ 也就是说，组中的内容一旦匹配成功，后向引用，引用的就是匹配成功后的内容，引用的是结果，而不是表达式。 因此，(\d{1,3})(.\1){3}这个表达式实际上匹配的是四个数都相同的IP地址，比如：123.123.123.123。 至此，读者已经掌握了传说中的后向引用，就这么简单。 对于分组的理解
import re import re ret=re.search('<(\w+)>\w+<(/\w+)>','<h1>hello</h1>') print(ret.group()) # 给分组起个名字。就用下面的分组命名，上面的方法和下面的分组命名是一样的，只不过就是给命了个名字 ret=re.search('<(?P<tag_name>\w+)>\w+</(?P=tag_name)>','<h1>hello</h1>') #(?P=tag_name)就代表的是（\w+） print(ret.group()) # 了解（和上面的是一样的，是上面方式的那种简写） ret=re.search(r'<(\w+)>\w+</\1>','<h1>hello</h1>') print(ret.group(1))
四、re模块
# 1.re模块下的常用方法 # 1.findall方法 import re ret = re.findall('a','eva ang egons') # #返回所有满足匹配条件的结果，放在列表里 print(ret) # 2.search方法 # 函数会在字符串中查找模式匹配，只会找到第一个匹配然后返回 # 一个包含匹配信息的对象，该对象通过调用group()方法得到匹配的 # 字符串，如果字符串没有匹配，则报错 ret = re.search('s','eva ang egons')#找第一个 print(ret.group()) # 3.match方法 print(re.match('a','abc').group()) #同search，只从字符串开始匹配,并且guoup才能找到 # 4.split方法 print(re.split('[ab]','abcd')) #先按'a'分割得到''和'bcd'，在对''和'bcd'分别按'b'分割 # 5.sub方法 print(re.sub('\d','H','eva3sdf4ahi4asd45',1)) # 将数字替换成'H'，参数1表示只替换一个 # 6.subn方法 print(re.subn('\d','H','eva3sdf4ahi4asd45')) #将数字替换成’H‘，返回元组（替换的结果，替换了多少次） # 7.compile方法 obj = re.compile('\d{3}')#将正则表达式编译成一个正则表达式对象，规则要匹配的是三个数字 print(obj) ret = obj.search('abc12345eeeee')#正则表达式对象调用search，参数为待匹配的字符串 print(ret.group()) #.group一下就显示出结果了 # 8.finditer方法 ret = re.finditer('\d','dsf546sfsc')#finditer返回的是一个存放匹配结果的迭代器 # print(ret)#<callable_iterator object at 0x00000000021E9E80> print(next(ret).group())#查看第一个结果 print(next(ret).group())#查看第二个结果 print([i.group() for i in ret] )#查看剩余的左右结果 re模块相关的方法
import re ret = re.findall('www.(baidu|oldboy).com','www.oldboy.com') print(ret) #结果是['oldboy']这是因为findall会优先把匹配结果组里内容返回,如果想要匹配结果,取消权限即可 ret = re.findall('www.(?:baidu|oldboy).com','www.oldboy.com') print(ret) #['www.oldboy.com'
ret = re.split('\d+','eva123dasda9dg')#按数字分割开了 print(ret) #输出结果：['eva', 'dasda', 'dg'] ret = re.split('(\d+)','eva123dasda9dg') print(ret) #输出结果：['eva', '123', 'dasda', '9', 'dg'] # # 在匹配部分加上()之后和不加括号切出的结果是不同的， # 没有括号的没有保留所匹配的项，但是有括号的却能够保留了 # 匹配的项，这个在某些需要保留匹配部分的使用过程是非常重要的 split的优先级查询
random模块
random.random()#用于生成一个0到1的随机浮点数: 0 <= n < 1.0
random.uniform(a,b) #生成有范围的浮点数
random.randint（a,b)#生成有范围的整数
random.randrange(10, 100, 2)，结果相当于从[10, 12, 14, 16, ... 96, 98]序列中获取一个随机数
random.choice从序列中获取一个随机元素
random.shuffle
random.shuffle的函数原型为：random.shuffle(x[, random])，用于将一个列表中的元素打乱。如:
p = ["Python", "is", "powerful", "simple", "and so on..."] random.shuffle(p) print p #---- 结果（不同机器上的结果可能不一样。） #['powerful', 'simple', 'is', 'Python', 'and so on...']
random.sample
从指定序列中随机获取指定长度的片断。sample函数不会修改原有序列。
list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] slice = random.sample(list, 5) #从list中随机获取5个元素，作为一个片断返回 print slice print list #原有序列并没有改变。
随机整数：
随机选取0到100间的偶数：
随机浮点数：
随机字符：
多个字符中选取特定数量的字符：
多个字符中选取特定数量的字符组成新字符串：
随机选取字符串：
洗牌：
随机生成一个手机号
import random a=random.choice(['139','188','185','136','158','151','186']) b=random.sample('0123456789',8) print a+''.join(b)
随机生成一个字符串
b=random.sample('abcdefjhigklmnopqrstuvwxyz',5) print 'HS'+''.join(b)
生成身份证
def gennerator(): listcode=['230200','230201','230202','230203','230204','230205','230206','230207','230208']#山西省的部分BM #id = codelist[random.randint(0,len(codelist))]['code'] #地区项 id=random.choice(listcode) id = id + str(random.randint(1930,2013)) #年份项 da = date.today()+timedelta(days=random.randint(1,366)) #月份和日期项 id = id + da.strftime('%m%d') id = id+ str(random.randint(100,999))#，顺序号简单处理 i = 0 count = 0 weight = [7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2] #权重项 checkcode ={'0':'1','1':'0','2':'X','3':'9','4':'8','5':'7','6':'6','7':'5','8':'5','9':'3','10':'2'} #校验码映射 for i in range(0,len(id)): count = count +int(id[i])*weight[i] id = id + checkcode[str(count%11)] #算出校验码 return id
Time
获取当前时间
-
%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）
例子
import datetime def get_currentdate(fmt="%Y-%m-%d"): return datetime.datetime.now().strftime(fmt) print(get_currentdate() )
例子
def get_timestamp(str_len=13): print("get_timestamp") if isinstance(str_len, int) and 0 < str_len < 17: return str(time.time()).replace(".", "")[:str_len]
获取随机字符串
def gen_random_string(str_len): """ generate random string with specified length """ print("gen_random_string") return ''.join( random.choice(string.ascii_letters + string.digits) for _ in range(str_len))
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) 运行shell命令，获取执行结果 os.environ 获取系统环境变量 os.path 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的大小 os模块常用方法
注意：os.stat('path\filename') 获取文件\目录信息的结构说明
stat 结构: st_mode: inode 保护模式 st_ino: inode 节点号。 st_dev: inode 驻留的设备。 st_nlink: inode 的链接数。 st_uid: 所有者的用户ID。 st_gid: 所有者的组ID。 st_size: 普通文件以字节为单位的大小；包含等待某些特殊文件的数据。 st_atime: 上次访问的时间。 st_mtime: 最后一次修改的时间。 st_ctime: 由操作系统报告的"ctime"。在某些系统上（如Unix）是最新的元数据更改的时间，<br>在其它系统上（如Windows）是创建时间（详细信息参见平台的文档）。 ststat 结构
os 用于操作系统相关
os.system()
os.getcwd() 获取当前工作目录，即当前python脚本工作的目录路径
os.path.abspath(path):返回path的绝对路径
BASE_DIR=os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
获取最新文件
import os def new_file(test_dir): #列举test_dir目录下的所有文件（名），结果以列表形式返回。 lists=os.listdir(test_dir) #sort按key的关键字进行升序排序，lambda的入参fn为lists列表的元素，获取文件的最后修改时间，所以最终以文件时间从小到大排序 #最后对lists元素，按文件修改时间大小从小到大排序。 lists.sort(key=lambda fn:os.path.getmtime(test_dir+'\\'+fn)) #获取最新文件的绝对路径，列表中最后一个值,文件夹+文件名 file_path=os.path.join(test_dir,lists[-1]) return file_path #返回D:\pythontest\ostest下面最新的文件 print new_file('D:\\system files\\workspace\\selenium\\email126pro\\email126\\report')
根据日期获取最新的文件
import os import datetime import time def read(result_dir): l=os.listdir(result_dir) l1=[] l2=[] for i in l: print(i) l1.append(i) st = l.sort(key=lambda fn: os.path.getmtime(result_dir+"\\"+fn) if not os.path.isdir(result_dir+"\\"+fn) else 0) #第二句 d=datetime.datetime.fromtimestamp(os.path.getmtime(result_dir+"\\"+i)) print(d) time_end=time.mktime(d.timetuple()) print(time_end) l2.append(time_end) print (l1[l2.index(max(l2))])
SYS
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]
XLRD
导入模块：import xlrd
打开excel文件读取数据data=xlrd.open_workbook(‘excelfile.xls’)
获取工作表
table=data.sheets()[0]#通过索引顺序获取
table=data.sheet_by_index(0)#通过索引顺序
table=data.sheet_by_name(u’sheet1’)#通过名称
获取整行和整列的值（数组）
table.row_values(i)#行
table.col_values(i)#列
获取行数和列数
nrows=table.nrows#行数
ncols=table.ncols#列数
循环行列表数据
for i in range(nrows):
print table.row_values(i)
单元格
cell_A1=table.cell(0,0).value
cell_C4=table.cell(2,3).value
五、序列化模块
1.什么是序列化-------将原本的字典，列表等内容转换成一个字符串的过程就叫做序列化
2.序列化的目的
1.以某种存储形式使自定义对象持久化
2.将对象从一个地方传递到另一个地方
3.使程序更具维护性
json
Json模块提供了四个功能：dumps、loads、dump、load
import json dic={'k1':'v1','k2':'v2','k3':'v3'} print(type(dic)) str_dic = json.dumps(dic) #将字典转换成字符串，转换后的字典中的元素是由双引号表示的 print(str_dic,type(str_dic))#{"k1": "v1", "k2": "v2", "k3": "v3"} <class 'str'> dic2 = json.loads(str_dic)#将一个字符串转换成字典类型 print(dic2,type(dic2))#{'k1': 'v1', 'k2': 'v2', 'k3': 'v3'} <class 'dict'> list_dic = [1,['a','b','c'],3,{'k1':'v1','k2':'v2'}] str_dic = json.dumps(list_dic) #也可以处理嵌套的数据类型 print(type(str_dic),str_dic) #<class 'str'> [1, ["a", "b", "c"], 3, {"k1": "v1", "k2": "v2"}] list_dic2 = json.loads(str_dic) print(type(list_dic2),list_dic2) #<class 'list'> [1, ['a', 'b', 'c'], 3, {'k1': 'v1', 'k2': 'v2'}] dumps和loads
import json f=open('json_file','w') dic = {'k1':'v1','k2':'v2','k3':'v3'} json.dump(dic,f)# #dump方法接收一个文件句柄，直接将字典转换成json字符串写入文件 f.close() f = open('json_file') dic2 = json.load(f) #load方法接收一个文件句柄，直接将文件中的json字符串转换成数据结构返回 f.close() print(type(dic2),dic2) dump和load
pickle
json 和 pickle 模块
json：用于字符串和python数据类型之间进行转换
pickle：用于python特有的类型和python的数据类型进行转换
# -------------------------- import pickle # dic= {'k1':'v1','k2':'v2','k3':'v3'} # str_dic=pickle.dumps(dic) # print(str_dic) #打印的是bytes类型的二进制内容 # # dic2 = pickle.loads(str_dic) # print(dic2) #有吧字典给转换回来了 import time struct_time = time.localtime(1000000000) print(struct_time) f = open('pickle_file','wb') pickle.dump(struct_time,f) f.close() f = open('pickle_file','rb') struct_time2 = pickle.load(f) print(struct_time.tm_year) pickle的dumps,sump和loads,load方法
shelve
shelve也是python提供给我们的序列化工具，比pickle用起来更简单一些。
shelve只提供给我们一个open方法，是用key来访问的，使用起来和字典类似
import shelve f = shelve.open('shelve_file') f['key'] = {'int':10, 'float':9.5, 'string':'Sample data'} #直接对文件句柄操作，就可以存入数据 f.close() import shelve f1 = shelve.open('shelve_file') existing = f1['key'] #取出数据的时候也只需要直接用key获取即可，但是如果key不存在会报错 f1.close() print(existing) shelve shelve
这个模块有个限制，它不支持多个应用同一时间往同一个DB进行写操作。所以当我们知道我们的应用如果只进行读操作，我们可以让shelve通过只读方式打开DB
1 import shelve
2 f = shelve.open('shelve_file', flag='r')
3 existing = f['key']
4 f.close()
5 print(existing)
由于shelve在默认情况下是不会记录待持久化对象的任何修改的，所以我们在shelve.open()时候需要修改默认参数，否则对象的修改不会保存。
import shelve
f1 = shelve.open('shelve_file')
print(f1['key'])
f1['key']['new_value'] = 'this was not here before'
f1.close()
f2 = shelve.open('shelve_file', writeback=True)
print(f2['key'])
f2['key']['new_value'] = 'this was not here before'
f2.close()
设置writeback
writeback方式有优点也有缺点。优点是减少了我们出错的概率，并且让对象的持久化对用户更加的透明了；但这种方式并不是所有的情况下都需要，首先，使用writeback以后，shelf在open()的时候会增加额外的内存消耗，并且当DB在close()的时候会将缓存中的每一个对象都写入到DB，这也会带来额外的等待时间。因为shelve没有办法知道缓存中哪些对象修改了，哪些对象没有修改，因此所有的对象都会被写入。
