浏览目录
一、re模块
先看一道例题：
我们平时登录注册要输电话号码，输入不符合电话号码规则，就会提示你输入错误。那么怎么判断电话号码是否符合输入条件呢？我们一般都会这样写。
while True: phone_number=input("please input your phone nunber：") if len(phone_number) ==11 and phone_number.isdigit() \ and (phone_number.startswith("13") or phone_number.startswith("17") or phone_number.startswith("17") or phone_number.startswith("18")): print("是合法的电话号码") else: print("是不合法的电话号码")
是不是感觉还行啊，容易理解，也不难。那咱们看一个更简单的。
import re phone_number=input("please input your phone number:") if re.match("^(13|14|17|18)[0-9]{9}$",phone_number ): print("是合法的电话号码") else: print("是不合法的电话号码")
哇！使用re 模块方法更简单。那么我们常用的re方法还有哪些呢？
import re ret=re.findall("a","eva egon yuan") #返回所有满足匹配条件的结果，放在列表里 print(ret) #结果：[\'a\', \'a\'] ret=re.search("a","eva egon yuan").group() print(ret) #结果：a #函数会在字符串内查找模式匹配，直到找到第一个匹配，然后返回一个包含匹配信息的对象， #该对象可以通过调用group()方法得到匹配的字符串，如果字符串没有匹配，则返回None ret=re.match("a","abc").group() print(ret) #结果：a #同search,不过尽在字符串开始处匹配 ret=re.split("[ab]","abcd") print(ret) #结果：[\'\', \'\', \'cd\'] #先按"a"分割得到""和"bcd",在对""和"bcd"分别按"b"分割 ret=re.sub("\d","H","eva3egon4yuan4",1) print(ret) #结果：evaHegon4yuan4 #将数字替换为"H"，参数1表示只替换1个 ret=re.subn("\d","H","eva3egon4yuan4") print(ret) #结果：(\'evaHegonHyuanH\', 3) #将数字替换为"H",返回元组（替换的结果，替换了多少次） obj=re.compile("\d{3}") #将正则表达式编译成为一个 正则表达式对象，规则要匹配的是3个数字 ret=obj.search("abc123eeee") #正则表达式对象调用search,参数为待匹配的字符串 print(ret.group()) #结果：123 import re ret=re.finditer("\d","ds3sy4784a") print(ret) #<callable_iterator object at 0x000000E6BE57F5F8> print(next(ret).group()) #3 print(next(ret).group()) #4 print([i.group() for i in ret]) #结果：[\'7\', \'8\', \'4\'] #查看剩余的左右结果
注意：
1、findall的优先级查询
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\']
2、split的优先级查询
import re ret=re.split("\d+","eva3egon4yuan") print(ret) #结果 ： [\'eva\', \'egon\', \'yuan\'] ret=re.split("(\d+)","eva3egon4yuan") print(ret) #结果 ： [\'eva\', \'3\', \'egon\', \'4\', \'yuan\'] #在匹配部分加上（）之后所切出的结果是不同的， #没有（）的没有保留所匹配的项，但是有（）的却能够保留了匹配的项， #这个在某些需要保留匹配部分的使用过程是非常重要的。
二、 collections 模块
python中的扩展数据类型
在内置数据类型（dict、list、set、tuple）的基础上，collections模块还提供了几个额外的数据类型：Counter、deque、defaultdict、namedtuple和OrderedDict等。
1.namedtuple
生成可以使用名字来访问元素内容的tuple
from collections import namedtuple Point=namedtuple("Point",["x","y"]) p=Point(1,2) print(p) #结果：Point(x=1, y=2)
from collections import namedtuple Circle=namedtuple("circle",["x","y","r"]) d=Circle(2,3,2) print(d) #circle(x=2, y=3, r=2)
2.deque
双端队列，可以快速的从另外一侧追加和推出对象
使用list存储数据时，按索引访问元素很快，但是插入和删除元素就很慢了，因为list是线性存储，数据量大的时候，插入和删除效率很低。
deque是为了高效实现插入和删除操作的双向列表，适合用于队列和栈：
from collections import deque q=deque(["a","b","c"]) q.append("x") q.appendleft("y") print(q) #结果：deque([\'y\', \'a\', \'b\', \'c\', \'x\'])
deque除了实现list的append()和pop()外，还支持appendleft()和popleft()，这样就可以非常高效地往头部添加或删除元素。
from collections import deque dq = deque([1,2]) dq.append(\'a\') # 从后面放数据 [1,2,\'a\'] dq.appendleft(\'b\') # 从前面放数据 [\'b\',1,2,\'a\'] dq.insert(2,3) #[\'b\',1,3,2,\'a\'] #2为索引，3为数字 print(dq.pop()) # 从后面取数据 print(dq.pop()) # 从后面取数据 print(dq.popleft()) # 从前面取数据 print(dq) #deque([1, 3])
3.Counter
计数器，主要用来计数
from collections import Counter c=Counter("abhdsfifhabaacsdfgsfa") print(c) #结果：Counter({\'a\': 5, \'f\': 4, \'s\': 3, \'b\': 2, \'d\': 2, \'h\': 2, \'i\': 1, \'c\': 1, \'g\': 1}) #跟踪值出现的次数
4.OrderedDict
有序字典
使用dict时，Key是无序的。如果想要保持key的顺序，就用OrderedDict。
d=dict([("a","1"),("b",2),("c",3)]) print(d) #结果：{\'c\': 3, \'b\': 2, \'a\': \'1\'} # dict中的Key是无序的
from collections import OrderedDict od=OrderedDict([("a","1"),("b","2"),("c","3")]) print(od) #OrderedDict([(\'a\', \'1\'), (\'b\', \'2\'), (\'c\', \'3\')]) #OrderedDict的Key是有序的
od=OrderedDict() od["z"]=1 od["y"]=2 od["x"]=3 print(od.keys()) #结果：odict_keys([\'z\', \'y\', \'x\']) #按照插入的key的顺序返回
5.defaultdict
带有默认值的字典
from collections import defaultdict dd=defaultdict(lambda:"N/A") dd["key1"]="abc" print(dd["key1"]) #key1存在 结果：abc print(dd["key2"]) #key2不存在 结果：N/A
三、time模块
常见的两种方法
1.time.sleep(secs) (线程)推迟指定的时间运行。单位为秒。 2.time.time() 获取当前时间戳
表示时间的三种方法
在Python中，通常有这三种方式来表示时间：时间戳、元组(struct_time)、格式化的时间字符串：
(1)时间戳(timestamp) ：通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。我们运行“type(time.time())”，返回的是float类型。
(2)格式化的时间字符串(Format String)： ‘1995-10-04’
%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)元组(struct_time) ：struct_time元组共有9个元素共九个元素:(年，月，日，时，分，秒，一年中第几周，一年中第几天等）
下面我们来看一下python中表示时间的几种格式：
#导入时间模块 >>>import time #时间戳 >>>time.time() 1500875844.800804 #时间字符串 >>>time.strftime("%Y-%m-%d %X") \'2017-07-24 13:54:37\' >>>time.strftime("%Y-%m-%d %H-%M-%S") \'2017-07-24 13-55-04\' #时间元组:localtime将一个时间戳转换为当前时区的struct_time time.localtime() time.struct_time(tm_year=2017, tm_mon=7, tm_mday=24, tm_hour=13, tm_min=59, tm_sec=37, tm_wday=0, tm_yday=205, tm_isdst=0)
注：时间戳是计算机能够识别的时间；时间字符串是人能够看懂的时间；元组则是用来操作时间的
几种格式之间的转化
时间戳与结构化时间转化
#时间戳-->结构化时间 #time.gmtime(时间戳) #UTC时间，与英国伦敦当地时间一致 #time.localtime(时间戳) #当地时间。例如我们现在在北京执行这个方法：与UTC时间相差8小时，UTC时间+8小时 = 北京时间 >>>time.gmtime(1500000000) time.struct_time(tm_year=2017, tm_mon=7, tm_mday=14, tm_hour=2, tm_min=40, tm_sec=0, tm_wday=4, tm_yday=195, tm_isdst=0) >>>time.localtime(1500000000) time.struct_time(tm_year=2017, tm_mon=7, tm_mday=14, tm_hour=10, tm_min=40, tm_sec=0, tm_wday=4, tm_yday=195, tm_isdst=0) #结构化时间-->时间戳 #time.mktime(结构化时间) >>>time_tuple = time.localtime(1500000000) >>>time.mktime(time_tuple) 1500000000.0
结构化时间与字符串时间的转化
#结构化时间-->字符串时间 #time.strftime("格式定义","结构化时间") 结构化时间参数若不传，则现实当前时间 >>>time.strftime("%Y-%m-%d %X") \'2017-07-24 14:55:36\' >>>time.strftime("%Y-%m-%d",time.localtime(1500000000)) \'2017-07-14\' #字符串时间-->结构化时间 #time.strptime(时间字符串,字符串对应格式) >>>time.strptime("2017-03-16","%Y-%m-%d") time.struct_time(tm_year=2017, tm_mon=3, tm_mday=16, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=75, tm_isdst=-1) >>>time.strptime("07/24/2017","%m/%d/%Y") time.struct_time(tm_year=2017, tm_mon=7, tm_mday=24, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=0, tm_yday=205, tm_isdst=-1)
串时间的转化
#结构化时间 --> %a %b %d %H:%M:%S %Y串 #time.asctime(结构化时间) 如果不传参数，直接返回当前时间的格式化串 >>>time.asctime(time.localtime(1500000000)) \'Fri Jul 14 10:40:00 2017\' >>>time.asctime() \'Mon Jul 24 15:18:33 2017\' #时间戳 --> %a %d %d %H:%M:%S %Y串 #time.ctime(时间戳) 如果不传参数，直接返回当前时间的格式化串 >>>time.ctime() \'Mon Jul 24 15:19:07 2017\' >>>time.ctime(1500000000) \'Fri Jul 14 10:40:00 2017\'
来看一道例题：计算时间差
import time true_time=time.mktime(time.strptime(\'2017-09-11 08:30:00\',\'%Y-%m-%d %H:%M:%S\')) time_now=time.mktime(time.strptime(\'2017-09-12 11:00:00\',\'%Y-%m-%d %H:%M:%S\')) dif_time=time_now-true_time struct_time=time.gmtime(dif_time) print(\'过去了%d年%d月%d天%d小时%d分钟%d秒\'%(struct_time.tm_year-1970,struct_time.tm_mon-1, struct_time.tm_mday-1,struct_time.tm_hour, struct_time.tm_min,struct_time.tm_sec))
四、random模块
random:随机数模块
random模块中常用的方法
#导入模块 import random #随机小数 >>> random.random() # 大于0且小于1之间的小数 0.7664338663654585 >>> random.uniform(1,3) #大于1小于3的小数 1.6270147180533838 #随机整数 >>> random.randint(1,5) # 大于等于1且小于等于5之间的整数 >>> random.randrange(1,10,2) # 大于等于1且小于10之间的奇数 #随机选择一个返回 >>> random.choice([1,\'23\',[4,5]]) # #1或者23或者[4,5] #随机选择多个返回，返回的个数为函数的第二个参数 >>> random.sample([1,\'23\',[4,5]],2) # #列表元素任意2个组合 [[4, 5], \'23\'] #打乱列表顺序 >>> item=[1,3,5,7,9] >>> random.shuffle(item) # 打乱次序 >>> item [5, 1, 3, 7, 9] >>> random.shuffle(item) >>> item [5, 9, 7, 1, 3]
例：生成随机验证码
import random def v_code(): code="" for i in range(5): num=random.randint(0,9) #生成0-9之间的整数 alf_upper=chr(random.randint(65,90)) #生成65-90之间的整数，转化成字母 alf_lower = chr(random.randint(97, 122))生成97-122之间的整数，转化成字母 add=random.choice([num,alf_upper,alf_lower]) #从字母数字中随机选一个 code="".join([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.popen("bash command).read() 运行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的大小 \'\'\'
六、sys模块
sys模块是与python解释器交互的一个接口
sys常用方法：
sys.argv 命令行参数List，第一个元素是程序本身路径 sys.exit(n) 退出程序，正常退出时exit(0),错误退出sys.exit(1) sys.version 获取Python解释程序的版本信息 sys.path 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值 sys.platform 返回操作系统平台名称
import sys try: sys.exit(1) except SystemExit as e: print(e)
七、序列化模块
序列化：将原本的字典、列表等内容转换成一个字符串的过程
序列化的目的:
1、以某种存储形式使自定义对象持久化；
2、将对象从一个地方传递到另一个地方。
3、使程序更具维护性。
Json
Json模块提供了四个功能:dumps,dump,loads,load
优点：通用的序列化模块
缺点：只有很少的一部分数据类型能够通过Json转化成字符串
import json dic = {\'k1\':\'v1\',\'k2\':\'v2\',\'k3\':\'v3\'} str_dic = json.dumps(dic) #序列化：将一个字典转换成一个字符串 print(type(str_dic),str_dic) #<class \'str\'> {"k3": "v3", "k1": "v1", "k2": "v2"} #注意，json转换完的字符串类型的字典中的字符串是由""表示的 dic2 = json.loads(str_dic) #反序列化：将一个字符串格式的字典转换成一个字典 #注意，要用json的loads功能处理的字符串类型的字典中的字符串必须由""表示 print(type(dic2),dic2) #<class \'dict\'> {\'k1\': \'v1\', \'k2\': \'v2\', \'k3\': \'v3\'} 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\'}]
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)
Pickle
Pickle模块提供了四个功能:dumps,dump,loads,load
优点：所有的python中的数据类型都可以转化为字符串形式
缺点：pickle序列化的内容只有python能理解，且部分反序列化依赖python代码。
import pickle dic = {\'k1\':\'v1\',\'k2\':\'v2\',\'k3\':\'v3\'} str_dic = pickle.dumps(dic) print(str_dic) #一串二进制内容 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_time2.tm_year)
Shelve
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)
这个模块有个限制，它不支持多个应用同一时间往同一个DB进行写操作。所以当我们知道我们的应用如果只进行读操作，我们可以让shelve通过只读方式打开DB.
import shelve f = shelve.open(\'shelve_file\', flag=\'r\') existing = f[\'key\'] f.close() 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以后，shelf在open()的时候会增加额外的内存消耗，并且当DB在close()的时候会将缓存中的每一个对象都写入到DB，这也会带来额外的等待时间。因为shelve没有办法知道缓存中哪些对象修改了，哪些对象没有修改，因此所有的对象都会被写入。