python 内置标准模块 简介
自定义模块 和开源模块的使用参考 http://www.cnblogs.com/wupeiqi/articles/4963027.html
time 模块
1 1 >>> import time 2 2 >>> time.time() 3 3 1491064723.808669 4 4 >>> # time.time()返回当前时间的时间戳timestamp(定义为从格林威治时间1970年01月01日00时00分00秒起至现在的总秒数)的方法,无参数 5 5 >>> time.asctime() 6 6 'Sun Apr 2 00:39:32 2017' 7 7 >>> # time.asctime()把struct_time对象格式转换为字符串格式为'Sun Apr 2 00:39:32 2017' 8 8 >>> time.asctime(time.gmtime()) 9 9 'Sat Apr 1 16:41:41 2017' 10 10 >>> time.asctime(time.localtime()) 11 11 'Sun Apr 2 00:42:06 2017' 12 12 >>> time.ctime() 13 13 'Sun Apr 2 00:42:29 2017' 14 14 >>> # time.ctime()把时间戳转换为字符串格式'Sun Apr 2 00:42:29 2017',默认为当前时间戳 15 15 >>> time.ctime(1491064723.808669) 16 16 'Sun Apr 2 00:38:43 2017' 17 17 >>> time.altzone # 返回与utc时间的时间差,以秒计算 18 18 -32400 19 19 >>> time.localtime() # 把时间戳转换为struct_time对象格式,默认返回当前时间戳 20 20 time.struct_time(tm_year=2017, tm_mon=4, tm_mday=2, tm_hour=0, tm_min=45, tm_sec=26, tm_wday=6, tm_yday=92, tm_isdst=0) 21 21 >>> time.localtime(1491064723.808669) 22 22 time.struct_time(tm_year=2017, tm_mon=4, tm_mday=2, tm_hour=0, tm_min=38, tm_sec=43, tm_wday=6, tm_yday=92, tm_isdst=0) 23 23 >>> 24 24 >>> time.gmtime() # 将utc时间戳转换成struct_time对象格式,默认返回当前时间的 25 25 time.struct_time(tm_year=2017, tm_mon=4, tm_mday=1, tm_hour=16, tm_min=46, tm_sec=32, tm_wday=5, tm_yday=91, tm_isdst=0) 26 26 >>> time.gmtime(1491064723.808669) 27 27 time.struct_time(tm_year=2017, tm_mon=4, tm_mday=1, tm_hour=16, tm_min=38, tm_sec=43, tm_wday=5, tm_yday=91, tm_isdst=0) 28 28 >>> 29 29 >>> 30 30 >>> time.strftime('%Y-%m-%d %H:%M:%S', time.localtime()) # 将本地时间的struct_time格式转成自定义字符串格式 2017-04-01 23:15:47 31 31 '2017-04-02 00:47:49' 32 32 >>> 33 33 >>> time.strftime('%Y-%m-%d %H:%M:%S', time.gmtime()) # 将utc时间的struct_time格式转成自定义字符串格式 2017-04-01 23:15:47 34 34 '2017-04-01 16:48:27' 35 35 >>> 36 36 >>> time.strptime('2017-04-02 00:47:49', '%Y-%m-%d %H:%M:%S') # 将 日期字符串 转成 struct_time时间对象格式,注意转换后的tm_isdst=-1()夏令时状态 37 37 time.struct_time(tm_year=2017, tm_mon=4, tm_mday=2, tm_hour=0, tm_min=47, tm_sec=49, tm_wday=6, tm_yday=92, tm_isdst=-1) 38 38 >>> 39 39 >>> time.mktime(time.localtime()) 40 40 1491065416.0 41 41 >>> # 将struct_tiame时间对象转成时间戳 结果返回1491061855.0 ,忽略小于秒的时间(忽略小数点后面) 42 42 >>> 43 43 >>> time.mktime(time.localtime(1491061855.0011407)) 44 44 1491061855.0 45 45 >>> # 结果返回1491061855.0 ,忽略小于秒的时间(忽略小数点后面) 46 46 >>> 47 47 >>> time.mktime(time.gmtime(1491061855.0011407)) 48 48 1491033055.0 49 49 >>> 50 50 >>> # 结果返回1491033055.0 ,忽略小于秒的时间(忽略小数点后面) 51 51 >>>
时间转换关系图
格式字符及意义
%a 星期的简写。如 星期三为Web
%A 星期的全写。如 星期三为Wednesday
%b 月份的简写。如4月份为Apr
%B月份的全写。如4月份为April
%c: 日期时间的字符串表示。(如: 04/07/10 10:43:39)
%d: 日在这个月中的天数(是这个月的第几天)
%f: 微秒(范围[0,999999])
%H: 小时(24小时制,[0, 23])
%I: 小时(12小时制,[0, 11])
%j: 日在年中的天数 [001,366](是当年的第几天)
%m: 月份([01,12])
%M: 分钟([00,59])
%p: AM或者PM
%S: 秒(范围为[00,61],为什么不是[00, 59],参考python手册~_~)
%U: 周在当年的周数当年的第几周),星期天作为周的第一天
%w: 今天在这周的天数,范围为[0, 6],6表示星期天
%W: 周在当年的周数(是当年的第几周),星期一作为周的第一天
%x: 日期字符串(如:04/07/10)
%X: 时间字符串(如:10:43:39)
%y: 2个数字表示的年份
%Y: 4个数字表示的年份
%z: 与utc时间的间隔 (如果是本地时间,返回空字符串)
%Z: 时区名称(如果是本地时间,返回空字符串)
datetime模块,方便时间计算
1 >>> import datetime 2 >>> datetime.datetime.now() 3 datetime.datetime(2017, 4, 7, 16, 52, 3, 199458) 4 # 返回一组数据(年,月,日,小时,分钟,秒,微秒) 5 6 >>> print(datetime.datetime.now()) 7 2017-04-07 16:52:55.000164 8 # 打印返回格式(固定) 9 10 >>> datetime.datetime.now()+datetime.timedelta(days=3) 11 datetime.datetime(2017, 4, 10, 16, 53, 51, 180847) 12 # 时间加(减),可以是日,秒,微秒,毫秒,分,小时,周 13 #days=0, seconds=0, microseconds=0,milliseconds=0, minutes=0, hours=0, weeks=0 14 >>> print(datetime.datetime.now()+datetime.timedelta(weeks=1)) 15 2017-04-17 16:54:08.916243 16 17 >>> datetime.datetime.now().replace(minute=3,hour=2) 18 datetime.datetime(2017, 4, 7, 2, 3, 11, 163663) 19 # 时间替换 20 21 >>> datetime.datetime.now() 22 datetime.datetime(2017, 4, 7, 16, 58, 22, 195439) 23 24 >>> datetime.datetime.now().replace(day=1,month=1) 25 datetime.datetime(2017, 1, 1, 16, 59, 13, 210556) 26 >>> 27 # 直接替换相应位置数据
random模块
1 import random 2 >>> print(random.random()) 3 0.5364503211492734 4 >>> print(random.randint(1,10)) 5 3 6 >>> # 整数1-10(包括10),随机取一个值 7 >>> 8 >>> 9 >>> 10 >>> print(random.randrange(1, 10)) 11 8 12 >>> # 整数1-10(不包括10),随机取一个值
生成随机验证码
1 import random 2 3 checkcode = '' 4 for i in range(6): 5 current = random.randrange(0, 6) 6 if current != i and current+1 != i: 7 temp = chr(random.randint(65, 90)) 8 # 65-90是A-Z 9 elif current+1 == i: 10 temp = chr(random.randint(97, 122)) 11 # 97-122是a-z 12 else: 13 temp = random.randint(0, 9) 14 checkcode += str(temp) 15 print(checkcode) 16 17 # 一共6位验证码, 18 # 第一位有1/6几率是数字,其它都是大写字母 19 # 第二到第六位,都是有1/6几率是小写字母,1/6几率是数字,其它都是大写字母
OS模块
提供对操作系统进行调用的接口
1 os.getcwd() 获取当前工作目录,即当前python脚本工作的目录路径 2 os.chdir("dirname") 改变当前脚本工作目录;相当于shell下cd 3 os.curdir 返回当前目录: ('.') 4 os.pardir 获取当前目录的父目录字符串名:('..') 5 os.makedirs('dirname1/dirname2') 可生成多层递归目录 6 os.removedirs('dirname1') 若目录为空,则删除,并递归到上一级目录,如若也为空,则删除,依此类推 7 os.mkdir('dirname') 生成单级目录;相当于shell中mkdir dirname 8 os.rmdir('dirname') 删除单级空目录,若目录不为空则无法删除,报错;相当于shell中rmdir dirname 9 os.listdir('dirname') 列出指定目录下的所有文件和子目录,包括隐藏文件,并以列表方式打印 10 os.remove() 删除一个文件 11 os.rename("oldname","newname") 重命名文件/目录 12 os.stat('path/filename') 获取文件/目录信息 13 os.sep 输出操作系统特定的路径分隔符,win下为"\\",Linux下为"/" 14 os.linesep 输出当前平台使用的行终止符,win下为"\t\n",Linux下为"\n" 15 os.pathsep 输出用于分割文件路径的字符串 16 os.name 输出字符串指示当前使用平台。win->'nt'; Linux->'posix' 17 os.system("bash command") 运行shell命令,直接显示 18 os.environ 获取系统环境变量 19 os.path.abspath(path) 返回path规范化的绝对路径 20 os.path.split(path) 将path分割成目录和文件名二元组返回 21 os.path.dirname(path) 返回path的目录。其实就是os.path.split(path)的第一个元素 22 os.path.basename(path) 返回path最后的文件名。如何path以/或\结尾,那么就会返回空值。即os.path.split(path)的第二个元素 23 os.path.exists(path) 如果path存在,返回True;如果path不存在,返回False 24 os.path.isabs(path) 如果path是绝对路径,返回True 25 os.path.isfile(path) 如果path是一个存在的文件,返回True。否则返回False 26 os.path.isdir(path) 如果path是一个存在的目录,则返回True。否则返回False 27 os.path.join(path1[, path2[, ...]]) 将多个路径组合后返回,第一个绝对路径之前的参数将被忽略 28 os.path.getatime(path) 返回path所指向的文件或者目录的最后存取时间 29 os.path.getmtime(path) 返回path所指向的文件或者目录的最后修改时间
更多os模块猛击这里
sys模块
用于提供对解释器相关的操作
1 sys.argv 命令行参数List,第一个元素是程序本身路径 2 sys.exit(n) 退出程序,正常退出时exit(0) 3 sys.version 获取Python解释程序的版本信息 4 sys.maxint 最大的Int值 5 sys.path 返回模块的搜索路径,初始化时使用PYTHONPATH环境变量的值 6 sys.platform 返回操作系统平台名称 7 sys.stdout.write('please:') 8 val = sys.stdin.readline()[:-1]
更多sys模块猛击这里
shutil 模块
高级的 文件、文件夹、压缩包 处理模块
shutil.copyfileobj(fsrc, fdst)
将文件内容拷贝到另一个文件中,可以部分内容,如下(注意需要打开文件):
1 import shutil 2 3 with open('testfile', 'r', encoding='utf-8') as f,\ 4 open('testfile1', 'w', encoding='utf-8') as f1: 5 shutil.copyfileobj(f, f1)
shutil.copyfile(src, dst)
仅拷贝文件
用法是shutil.copyfile(src_path, dst_path),如下:
import shutil shutil.copyfile(r'C:\Users\笔记.txt', r'C:\test1\笔记.txt')
shutil.copystat(src, dst)
仅拷贝状态信息,包括:mode bits, atime, mtime, flags.用法格式同shutil.copyfile(src, dst)
shutil.copymode(src, dst)
仅拷贝权限。内容、组、用户均不变,用法格式同shutil.copyfile(src, dst)
shutil.copy(src, dst)
拷贝文件和权限,用法个是同shutil.copyfile(src, dst)
shutil.copy2(src, dst)
拷贝文件和状态信息,用法个是同shutil.copyfile(src, dst)
shutil.copytree(src, dst, symlinks=False, ignore=None)
拷贝一个目录,src是原目录路径,dst是新目录路径
shutil.rmtree(path)
删除一个目录,path为目录路径
shutil.move(src, dst)
移动文件或目录,src是原文件或目录的路径,dst是新目录路径!使用的copy2函数拷贝文件和状态信息
1 import shutil 2 3 shutil.move(r'C:\Users\笔记.txt', r'C:\test1')
shutil.make_archive(base_name, format,...)
创建压缩包并返回文件路径,例如:zip、tar
- base_name: 压缩包的文件名,也可以是压缩包的路径。只是文件名时,则保存至当前目录,否则保存至指定路径,
如:www =>保存至当前路径
如:/Users/wupeiqi/www =>保存至/Users/wupeiqi/ - format: 压缩包种类,“zip”, “tar”, “bztar”,“gztar”
- root_dir: 要压缩的文件夹路径(默认当前目录)
- owner: 用户,默认当前用户
- group: 组,默认当前组
- logger: 用于记录日志,通常是logging.Logger对象
1 #将 /Users/wupeiqi/Downloads/test 下的文件打包放置当前程序目录 2 3 import shutil 4 ret = shutil.make_archive("wwwwwwwwww", 'gztar', root_dir='/Users/wupeiqi/Downloads/test') 5 6 7 #将 /Users/wupeiqi/Downloads/test 下的文件打包放置 /Users/wupeiqi/目录 8 import shutil 9 ret = shutil.make_archive("/Users/wupeiqi/wwwwwwwwww", 'gztar', root_dir='/Users/wupeiqi/Downloads/test')
shutil 对压缩包的处理是调用 ZipFile 和 TarFile 两个模块来进行的,详细:
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 import zipfile 2 3 # 压缩 4 z = zipfile.ZipFile('laxi.zip', 'w') 5 z.write('a.log') 6 z.write('data.data') 7 z.close() 8 9 # 解压 10 z = zipfile.ZipFile('laxi.zip', 'r') 11 z.extractall() 12 z.close()
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
1 import tarfile 2 3 # 压缩 4 tar = tarfile.open('your.tar','w') 5 tar.add('/Users/wupeiqi/PycharmProjects/bbs2.zip', arcname='bbs2.zip') 6 # arcname指定压缩目录,不指定就默认文件绝对目录 7 tar.add('/Users/wupeiqi/PycharmProjects/cmdb.zip', arcname='cmdb.zip') 8 tar.close() 9 10 # 解压 11 tar = tarfile.open('your.tar','r') 12 tar.extractall() # 可设置解压地址 13 tar.close()
tarfile只打包不压缩,zip会压缩
logging 模块
用于便捷记录日志且线程安全的模块
1 import logging 2 3 4 logging.basicConfig(filename='log.log', 5 format='%(asctime)s %(filename)s : %(lineno)s -%(levelname)s : %(message)s', 6 datefmt='%m-%d-%Y %I:%M:%S %p', 7 level=10) 8 9 logging.debug('debug') 10 logging.info('info') 11 logging.warning('warning') 12 logging.error('error') 13 logging.critical('critical') 14 logging.log(10,'log')
对于等级level
CRITICAL level
=
50
FATAL
level
=
50
ERROR level
=
40
WARNING level
=
30
WARN
level
=
30
INFO level
=
20
DEBUG level
=
10
NOTSET level
=
0
日志格式
%(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 |
用户输出的消息 |
如果想同时把log打印在屏幕和文件日志里,就需要了解一点复杂的知识 了
Python 使用logging模块记录日志涉及四个主要类,使用官方文档中的概括最为合适:
logger提供了应用程序可以直接使用的接口;
handler将(logger创建的)日志记录发送到合适的目的输出;
filter提供了细度设备来决定输出哪条日志记录;
formatter决定日志记录的最终输出格式。
logger
每个程序在输出信息之前都要获得一个Logger。Logger通常对应了程序的模块名,比如聊天工具的图形界面模块可以这样获得它的Logger:
LOG=logging.getLogger(”chat.gui”)
而核心模块可以这样:
LOG=logging.getLogger(”chat.kernel”)
Logger.setLevel(lel):指定最低的日志级别,低于lel的级别将被忽略。debug是最低的内置级别,critical为最高
Logger.addFilter(filt)、Logger.removeFilter(filt):添加或删除指定的filter
Logger.addHandler(hdlr)、Logger.removeHandler(hdlr):增加或删除指定的handler
Logger.debug()、Logger.info()、Logger.warning()、Logger.error()、Logger.critical():可以设置的日志级别
handler
handler对象负责发送相关的信息到指定目的地。Python的日志系统有多种Handler可以使用。有些Handler可以把信息输出到控制台,有些Logger可以把信息输出到文件,还有些 Handler可以把信息发送到网络上。如果觉得不够用,还可以编写自己的Handler。可以通过addHandler()方法添加多个多handler
Handler.setLevel(lel):指定被处理的信息级别,低于lel级别的信息将被忽略
Handler.setFormatter():给这个handler选择一个格式
Handler.addFilter(filt)、Handler.removeFilter(filt):新增或删除一个filter对象
每个Logger可以附加多个Handler。接下来我们就来介绍一些常用的Handler:
1) logging.StreamHandler
使用这个Handler可以向类似与sys.stdout或者sys.stderr的任何文件对象(file object)输出信息。它的构造函数是:
StreamHandler([strm])
其中strm参数是一个文件对象。默认是sys.stderr
2) logging.FileHandler
和StreamHandler类似,用于向一个文件输出日志信息。不过FileHandler会帮你打开这个文件。它的构造函数是:
FileHandler(filename[,mode])
filename是文件名,必须指定一个文件名。
mode是文件的打开方式。参见Python内置函数open()的用法。默认是’a',即添加到文件末尾。
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并不会被更名,而是被删除。
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 每天凌晨
re模块
正则表达式使用反斜杆(\)来转义特殊字符,使其可以匹配字符本身,而不是指定其他特殊的含义。这可能会和python字面意义上的字符串转义相冲突,这也许有些令人费解。比如,要匹配一个反斜杆本身,你也许要用'\\\\'来做为正则表达式的字符串,因为正则表达式要是\\,而字符串里,每个反斜杆都要写成\\。
你也可以在字符串前加上 r 这个前缀来避免部分疑惑,因为 r 开头的python字符串是 raw 字符串,所以里面的所有字符都不会被转义,比如r'\n'这个字符串就是一个反斜杆加上一字母n,而'\n'我们知道这是个换行符。因此,上面的'\\\\'你也可以写成r'\\',这样,应该就好理解很多了。可以看下面这段
1 >>> import re 2 >>> s = '\x5c' 3 >>> print(s) 4 \ 5 >>> re.match('\\\\', s) #这样可以匹配 6 <_sre.SRE_Match object; span=(0, 1), match='\\'> 7 >>> re.match(r'\\', s) #这样也可以 8 <_sre.SRE_Match object; span=(0, 1), match='\\'> 9 >>> re.match('\\', s) #但是这样不行 10 Traceback (most recent call last): 11 File "<pyshell#5>", line 1, in <module> 12 re.match('\\', s) #但是这样不行 13 File "C:\Python36\lib\re.py", line 172, in match 14 return _compile(pattern, flags).match(string) 15 File "C:\Python36\lib\re.py", line 301, in _compile 16 p = sre_compile.compile(pattern, flags) 17 File "C:\Python36\lib\sre_compile.py", line 562, in compile 18 p = sre_parse.parse(p, flags) 19 File "C:\Python36\lib\sre_parse.py", line 848, in parse 20 source = Tokenizer(str) 21 File "C:\Python36\lib\sre_parse.py", line 231, in __init__ 22 self.__next() 23 File "C:\Python36\lib\sre_parse.py", line 245, in __next 24 self.string, len(self.string) - 1) from None 25 sre_constants.error: bad escape (end of pattern) at position 0 26 >>>
正则表达式语法
正则表达式(RE)指定一个与之匹配的字符集合;本模块所提供的函数,将可以用来检查所给的字符串是否与指定的正则表达式匹配。
正则表达式可以被连接,从而形成新的正则表达式;例如A和B都是正则表达式,那么AB也是正则表达式。一般地,如果字符串p与A匹配,q与B匹配的话,那么字符串pq也会与AB匹配,但A或者B里含有边界限定条件或者命名组操作的情况除外。也就是说,复杂的正则表达式可以用简单的连接而成。
正则表达式可以包含特殊字符和普通字符,大部分字符比如'A','a'和'0'都是普通字符,如果做为正则表达式,它们将匹配它们本身。由于正则表达式可以连接,所以连接多个普通字符而成的正则表达式last也将匹配'last'。(后面将用不带引号的表示正则表达式,带引号的表示字符串)
下面就来介绍正则表达式的特殊字符:
'.'
点号,在普通模式,它匹配除换行符外的任意一个字符;如果指定了 DOTALL 标记,匹配包括换行符以内的任意一个字符。
'^'
尖尖号,匹配一个字符串的开始,在 MULTILINE 模式下,也将匹配任意一个新行的开始。
'$'
美元符号,匹配一个字符串的结尾或者字符串最后面的换行符,在 MULTILINE 模式下,也匹配任意一行的行尾。也就是说,普通模式下,foo.$去搜索'foo1\nfoo2\n'只会找到'foo2′,但是在 MULTILINE 模式,还能找到 ‘foo1′,而且就用一个 $ 去搜索'foo\n'的话,会找到两个空的匹配:一个是最后的换行符,一个是字符串的结尾,演示:
1 >>> re.findall('(foo.$)', 'foo1\nfoo2\n') 2 ['foo2'] 3 >>> re.findall('(foo.$)', 'foo1\nfoo2\n', re.MULTILINE) 4 ['foo1', 'foo2'] 5 >>> re.findall('($)', 'foo\n') 6 ['', ''] 7 >>>
'*'
星号,指定将前面的RE重复0次或者任意多次,而且总是试图尽量多次地匹配。
'+'
加号,指定将前面的RE重复1次或者任意多次,而且总是试图尽量多次地匹配。
'?'
问号,指定将前面的RE重复0次或者1次,如果有的话,也尽量匹配1次。
*?, +?, ??
从前面的描述可以看到'*','+'和'?'都是贪婪的,但这也许并不是我们说要的,所以,可以在后面加个问号,将策略改为非贪婪,只匹配尽量少的RE。示例,体会两者的区别:
1 >>> re.findall('<(.*)>', '<H1>title</H1>') 2 ['H1>title</H1'] 3 >>> re.findall('<(.*?)>', '<H1>title</H1>') 4 ['H1', '/H1']
{m,n}
m和n都是数字,指定将前面的RE重复m到n次,例如a{3,5}匹配3到5个连续的a。注意,如果省略m,将匹配0到n个前面的RE;如果省略n,将匹配n到无穷多个前面的RE;当然中间的逗号是不能省略的,不然就变成前面那种形式了。
{m,n}?
前面说的{m,n},也是贪婪的,a{3,5}如果有5个以上连续a的话,会匹配5个,这个也可以通过加问号改变。a{3,5}?如果可能的话,将只匹配3个a。
'\'
反斜杆,转义'*','?'等特殊字符,或者指定一个特殊序列(下面会详述)
由于之前所述的原因,强烈建议用raw字符串来表述正则。
[]
方括号,用于指定一个字符的集合。可以单独列出字符,也可以用'-'连接起止字符以表示一个范围。特殊字符在中括号里将失效,比如[akm$]就表示字符'a','k','m',或'$',在这里$也变身为普通字符了。[a-z]匹配任意一个小写字母,[a-zA-Z0-9]匹配任意一个字母或数字。如果你要匹配']'或'-'本身,你需要加反斜杆转义,或者是将其置于中括号的最前面,比如[]]可以匹配']'
你还可以对一个字符集合取反,以匹配任意不在这个字符集合里的字符,取反操作用一个'^'放在集合的最前面表示,放在其他地方的'^'将不会起特殊作用。例如[^5]将匹配任意不是'5'的字符;[^^]将匹配任意不是'^'的字符。
注意:在中括号里,+、*、(、)这类字符将会失去特殊含义,仅作为普通字符。反向引用也不能在中括号内使用。
'|'
管道符号,A和B是任意的RE,那么A|B就是匹配A或者B的一个新的RE。任意个数的RE都可以像这样用管道符号间隔连接起来。这种形式可以被用于组中(后面将详述)。对于目标字符串,被'|'分割的RE将自左至右一一被测试,一旦有一个测试成功,后面的将不再被测试,即使后面的RE可能可以匹配更长的串,换句话说,'|'操作符是非贪婪的。要匹配字面意义上的'|',可以用反斜杆转义:\|,或是包含在反括号内:[|]。
(...)
匹配圆括号里的RE匹配的内容,并指定组的开始和结束位置。组里面的内容可以被提取,也可以采用\number这样的特殊序列,被用于后续的匹配。要匹配字面意义上的'('和')',可以用反斜杆转义:\(、\),或是包含在反括号内:[(]、[)]。
(?...)
这是一个表达式的扩展符号。'?'后的第一个字母决定了整个表达式的语法和含义,除了(?P...)以外,表达式不会产生一个新的组。下面介绍几个目前已被支持的扩展:
(?iLmsux)
'i'、'L'、'm'、's'、'u'、'x'里的一个或多个字母。表达式不匹配任何字符,但是指定相应的标志:re.I(忽略大小写)、re.L(依赖locale)、re.M(多行模式)、re.S(.匹配所有字符)、re.U(依赖Unicode)、re.X(详细模式)。关于各个模式的区别,下面会有专门的一节来介绍的。使用这个语法可以代替在re.compile()的时候或者调用的时候指定flag参数。
例如,上面举过的例子,可以改写成这样(和指定了re.MULTILINE是一样的效果):
1 >>> re.findall('(?m)(foo.$)', 'foo1\nfoo2\n') 2 ['foo1', 'foo2'] 3 >>> re.findall('(foo.$)', 'foo1\nfoo2\n', re.MULTILINE) 4 ['foo1', 'foo2'] 5 >>>
另外,还要注意(?x)标志如果有的话,要放在最前面。
(?:...)
匹配内部的RE所匹配的内容,但是不建立组。
(?P<name>...)
和普通的圆括号类似,但是子串匹配到的内容将可以用命名的name参数来提取。组的name必须是有效的python标识符,而且在本表达式内不重名。命名了的组和普通组一样,也用数字来提取,也就是说名字只是个额外的属性。
演示一下:
1 >>> m=re.match('(?P<var>[a-zA-Z_]\w*)', 'abc=123') 2 >>> m.group('var') 3 'abc' 4 >>> m.group(1) 5 'abc' 6 >>>
匹配之前以name命名的组里的内容。
演示一下:
1 >>> re.match('<(?P<tagname>\w*)>.*</(?P=tagname)>', '<h1>xxx</h2>') #这个不匹配 2 >>> re.match('<(?P<tagname>\w*)>.*</(?P=tagname)>', '<h1>xxx</h1>') #这个匹配 3 <_sre.SRE_Match object; span=(0, 12), match='<h1>xxx</h1>'> 4 >>>
(?#...)
注释,圆括号里的内容会被忽略。
(?=...)
如果 ... 匹配接下来的字符,才算匹配,但是并不会消耗任何被匹配的字符。例如 Isaac (?=Asimov) 只会匹配后面跟着 'Asimov' 的 'Isaac ',这个叫做“前瞻断言”。
(?!...)
和上面的相反,只匹配接下来的字符串不匹配 ... 的串,这叫做“反前瞻断言”。
(?<=...)
只有当当前位置之前的字符串匹配 ... ,整个匹配才有效,这叫“后顾断言”。字符串'abcdef'可以匹配正则(?<=abc)def,因为会后向查找3个字符,看是否为abc。所以内置的子RE,需要是固定长度的,比如可以是abc、a|b,但不能是a*、a{3,4}。注意这种RE永远不会匹配到字符串的开头。举个例子,找到连字符('-')后的单词:
1 >>> m = re.search('(?<=-)\w+', 'spam-egg') 2 >>> m.group(0) 3 'egg'
(?<!...)
同理,这个叫做“反后顾断言”,子RE需要固定长度的,含义是前面的字符串不匹配 ... 整个才算匹配。
(?(id/name)yes-pattern|no-pattern)
如有由id或者name指定的组存在的话,将会匹配yes-pattern,否则将会匹配no-pattern,通常情况下no-pattern也可以省略。例如:(<)?(\w+@\w+(?:\.\w+)+)(?(1)>)可以匹配 '<user@host.com>' 和 'user@host.com',但是不会匹配 '<user@host.com'。
下面列出以'\'开头的特殊序列。如果某个字符没有在下面列出,那么RE的结果会只匹配那个字母本身,比如,\$只匹配字面意义上的'$'。
字符:
. 匹配除换行符以外的任意字符
\w 匹配字母或数字或下划线或汉字
\s 匹配任意的空白符
\d 匹配数字
\b 匹配单词的开始或结束
^ 匹配字符串的开始
$ 匹配字符串的结束
次数:
* 重复零次或更多次
+ 重复一次或更多次
? 重复零次或一次
{n} 重复n次
{n,} 重复n次或更多次
{n,m} 重复n到m次
匹配之搜索
python提供了两种基于正则表达式的操作:匹配(match)从字符串的开始检查字符串是否个正则匹配。而搜索(search)检查字符串任意位置是否有匹配的子串(perl默认就是如此)。
注意,即使search的正则以'^'开头,match和search也还是有许多不同的。
1 >>> re.match("c", "abcdef") # 不匹配 2 >>> re.search("c", "abcdef") # 匹配 3 <_sre.SRE_Match object at ...>
模块的属性和方法
re.compile(pattern[, flags])
把一个正则表达式pattern编译成正则对象,以便可以用正则对象的match和search方法。
得到的正则对象的行为(也就是模式)可以用flags来指定,值可以由几个下面的值OR得到。
以下两段内容在语法上是等效的:
prog = re.compile(pattern) result = prog.match(string)
result = re.match(pattern, string)
区别是,用了re.compile以后,正则对象会得到保留,这样在需要多次运用这个正则对象的时候,效率会有较大的提升。再用上面用过的例子来演示一下,用相同的正则匹配相同的字符串,执行100万次,就体现出compile的效率了(数据来自我的台式电脑英特尔 Core i5-6500 @ 3.20GHz 四核):
>>> import timeit >>> timeit.timeit( setup="import re; reg = re.compile('<(?P<tagname>\w*)>.*</(?P=tagname)>')", stmt="reg.match('<h1>xxx</h1>')", number=1000000) 0.3993007156773078 >>> timeit.timeit( setup='import re', stmt="re.match('<(?P<tagname>\w*)>.*</(?P=tagname)>', '<h1>xxx</h1>')", number=1000000) 0.8457147421697897 >>>
re.I
re.IGNORECASE
让正则表达式忽略大小写,这样一来,[A-Z]也可以匹配小写字母了。此特性和locale无关。
re.L
re.LOCALE
让\w、\W、\b、\B、\s和\S依赖当前的locale。
re.M
re.MULTILINE
影响'^'和'$'的行为,指定了以后,'^'会增加匹配每行的开始(也就是换行符后的位置);'$'会增加匹配每行的结束(也就是换行符前的位置)。
re.S
re.DOTALL
影响'.'的行为,平时'.'匹配除换行符以外的所有字符,指定了本标志以后,也可以匹配换行符。
re.U
re.UNICODE
让\w、\W、\b、\B、\d、\D、\s和\S依赖Unicode库。
re.X
re.VERBOSE
运用这个标志,你可以写出可读性更好的正则表达式:除了在方括号内的和被反斜杠转义的以外的所有空白字符,都将被忽略,而且每行中,一个正常的井号后的所有字符也被忽略,这样就可以方便地在正则表达式内部写注释了。也就是说,下面两个正则表达式是等效的:
a = re.compile(r"""\d + # the integral part
\. # the decimal point \d * # some fractional digits""", re.X) b = re.compile(r"\d+\.\d*") re.search(pattern, string[, flags])
扫描string,看是否有个位置可以匹配正则表达式pattern。如果找到了,就返回一个MatchObject的实例,否则返回None,注意这和找到长度为0的子串含义是不一样的。搜索过程受flags的影响。
re.match(pattern, string[, flags])
如果字符串string的开头和正则表达式pattern匹配的话,返回一个相应的MatchObject的实例,否则返回None
注意:要在字符串的任意位置搜索的话,需要使用上面的search()。
re.split(pattern, string[, maxsplit=0])
用匹配pattern的子串来分割string,如果pattern里使用了圆括号,那么被pattern匹配到的串也将作为返回值列表的一部分。如果maxsplit不为0,则最多被分割为maxsplit个子串,剩余部分将整个地被返回。
>>> re.split('\W+', 'Words, words, words.') ['Words', 'words', 'words', ''] >>> re.split('(\W+)', 'Words, words, words.') ['Words', ', ', 'words', ', ', 'words', '.', ''] >>> re.split('\W+', 'Words, words, words.', 1) ['Words', 'words, words.']
如果正则有圆括号,并且可以匹配到字符串的开始位置的时候,返回值的第一项,会多出一个空字符串。匹配到字符结尾也是同样的道理:
>>> re.split('(\W+)', '...words, words...') ['', '...', 'words', ', ', 'words', '...', '']
注意,split不会被零长度的正则所分割,例如:
>>> re.split('x*', 'foo') ['foo'] >>> re.split("(?m)^$", "foo\n\nbar\n") ['foo\n\nbar\n']
re.findall(pattern, string[, flags])
以列表的形式返回string里匹配pattern的不重叠的子串。string会被从左到右依次扫描,返回的列表也是从左到右一次匹配到的。如果pattern里含有组的话,那么会返回匹配到的组的列表;如果pattern里有多个组,那么各组会先组成一个元组,然后返回值将是一个元组的列表。
由于这个函数不会涉及到MatchObject之类的概念,所以,对新手来说,应该是最好理解也最容易使用的一个函数了。下面就此来举几个简单的例子:
#简单的findall >>> re.findall('\w+', 'hello, world!') ['hello', 'world'] #这个返回的就是元组的列表 >>> re.findall('(\d+)\.(\d+)\.(\d+)\.(\d+)', 'My IP is 192.168.0.2, and your is 192.168.0.3.') [('192', '168', '0', '2'), ('192', '168', '0', '3')] re. finditer(pattern, string[, flags])
和上面的findall()类似,但返回的是MatchObject的实例的迭代器。
还是例子说明问题:
>>> for m in re.finditer('\w+', 'hello, world!'): print(m.group()) hello world >>>
re.sub(pattern, repl, string[, count])
替换,将string里,匹配pattern的部分,用repl替换掉,最多替换count次(剩余的匹配将不做处理),然后返回替换后的字符串。如果string里没有可以匹配pattern的串,将被原封不动地返回。repl可以是一个字符串,也可以是一个函数(也可以参考我以前的例子)。如果repl是个字符串,则其中的反斜杆会被处理过,比如 \n 会被转成换行符,反斜杆加数字会被替换成相应的组,比如 \6 表示pattern匹配到的第6个组的内容。
例子:
>>> re.sub(r'def\s+([a-zA-Z_][a-zA-Z_0-9]*)\s*\(\s*\):', r'static PyObject*\npy_\1(void)\n{', 'def myfunc():') 'static PyObject*\npy_myfunc(void)\n{'
如果repl是个函数,每次pattern被匹配到的时候,都会被调用一次,传入一个匹配到的MatchObject对象,需要返回一个字符串,在匹配到的位置,就填入返回的字符串。
例子:
>>> def dashrepl(matchobj): if matchobj.group(0) == '-': return ' ' else:
return '-' >>> re.sub('-{1,2}', dashrepl, 'pro----gram-files') 'pro--gram files' >>>
零长度的匹配也会被替换,比如:
>>> re.sub('x*', '-', 'abcxxd') '-a-b-c-d-' >>>
特殊地,在替换字符串里,如果有\g这样的写法,将匹配正则的命名组(前面介绍过的,(?P...)这样定义出来的东西)。\g这样的写法,也是数字的组,也就是说,\g<2>一般和\2是等效的,但是万一你要在\2后面紧接着写上字面意义的0,你就不能写成\20了(因为这代表第20个组),这时候必须写成\g<2>0,另外,\g<0>代表匹配到的整个子串。
例子:
>>> re.sub('-(\d+)-', '-\g<1>0\g<0>', 'a-11-b-22-c') 'a-110-11-b-220-22-c' >>>
更多正则表达式请看http://www.jb51.net/article/50511.htm