python 内置标准模块 简介

时间  2019-11-09
标签 python 内置 标准 模块 简介 栏目 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 >>>
复制代码

时间转换关系图html

格式字符及意义python

%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:  时区名称（若是是本地时间，返回空字符串）git

 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),随机取一个值
复制代码

生成随机验证码shell

复制代码 
 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模块猛击这里bash

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模块猛击这里dom

shutil 模块

 高级的 文件、文件夹、压缩包 处理模块ide

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 两个模块来进行的，详细：

import zipfile

# 压缩
z = zipfile.ZipFile('laxi.zip', 'w')
z.write('a.log')
z.write('data.data')
z.close()

# 解压
z = zipfile.ZipFile('laxi.zip', 'r')
z.extractall()
z.close()

zipfile 压缩解压
zipfile压缩解压 
import tarfile

# 压缩
tar = tarfile.open('your.tar','w')
tar.add('/Users/wupeiqi/PycharmProjects/bbs2.zip', arcname='bbs2.zip')
# arcname指定压缩目录,不指定就默认文件绝对目录
tar.add('/Users/wupeiqi/PycharmProjects/cmdb.zip', arcname='cmdb.zip')
tar.close()

# 解压
tar = tarfile.open('your.tar','r')
tar.extractall()  # 可设置解压地址
tar.close()

tarfile 压缩解压
tarfile

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

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程