正则表达式
一。正则表达式语法javascript
推荐网站：java
©️ http://regexr.com/ 边写边测试正则python
RegExr是一个在线工具，能够编辑并测试正则表达式。它提供了一个简单的界面来输入正则表达式，且能够在实时可编辑源文本窗口能够看到匹配的内容 还有侧边栏，提供了正则表达式的描述和用例，帮助学习程序员
©️ https://regexper.com/ 对现有的正则作图形化解释正则表达式
用图形来解释正则表达式编程
©️ http://www.txt2re.com/ 对现有文本，自动生成正则表达式框架
Txt2re是一个在视觉上经过单击筛选的文本项提取任意文本的工具。它很是简单，适用于各类类型的输入，包括HTML和其余相似的脚本语言的输入。ide
1. 正则语法表函数
| 字符 | 描述 |
|---|---|
| \ | 将下一个字符标记为一个特殊字符、或一个原义字符、或一个向后引用、或一个八进制转义符。例如，“n"匹配字符"n"。"\n"匹配一个换行符。串行"\\"匹配"\"而"\("则匹配"("。 |
| ^ | 匹配输入字符串的开始位置。若是设置了RegExp对象的Multiline属性，^也匹配“\n"或"\r"以后的位置。 |
| $ | 匹配输入字符串的结束位置。若是设置了RegExp对象的Multiline属性，$也匹配“\n"或"\r"以前的位置。 |
| * | 匹配前面的子表达式零次或屡次。例如，zo*能匹配“z"以及"zoo"。*等价于{0,}。 |
| + | 匹配前面的子表达式一次或屡次。例如，“zo+"能匹配"zo"以及"zoo"，但不能匹配"z"。+等价于{1,}。 |
| ? | 匹配前面的子表达式零次或一次。例如，“do(es)?"能够匹配"does"或"does"中的"do"。?等价于{0,1}。 |
| {n} | n是一个非负整数。匹配肯定的n次。例如，“o{2}"不能匹配"Bob"中的"o"，可是能匹配"food"中的两个o。 |
| {n,} | n是一个非负整数。至少匹配n次。例如，“o{2,}"不能匹配"Bob"中的"o"，但能匹配"foooood"中的全部o。"o{1,}"等价于"o+"。"o{0,}"则等价于"o*"。 |
| {n,m} | m和n均为非负整数，其中n<=m。最少匹配n次且最多匹配m次。例如，“o{1,3}"将匹配"fooooood"中的前三个o。"o{0,1}"等价于"o?"。请注意在逗号和两个数之间不能有空格。 |
| ? | 当该字符紧跟在任何一个其余限制符（*,+,?，{n}，{n,}，{n,m}）后面时，匹配模式是非贪婪的。非贪婪模式尽量少的匹配所搜索的字符串，而默认的贪婪模式则尽量多的匹配所搜索的字符串。例如，对于字符串“oooo"，"o+?"将匹配单个"o"，而"o+"将匹配全部"o"。 |
| . | 匹配除“\n"以外的任何单个字符。要匹配包括"\n"在内的任何字符，请使用像"(.|\n)"的模式。 |
| (pattern) | 匹配pattern并获取这一匹配。所获取的匹配能够从产生的Matches集合获得，在VBScript中使用SubMatches集合，在JScript中则使用$0…$9属性。要匹配圆括号字符，请使用“\("或"\)"。 |
| (?:pattern) | 匹配pattern但不获取匹配结果，也就是说这是一个非获取匹配，不进行存储供之后使用。这在使用或字符“(|)"来组合一个模式的各个部分是颇有用。例如"industr(?:y|ies)"就是一个比"industry|industries"更简略的表达式。 |
| (?=pattern) | 正向确定预查，在任何匹配pattern的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不须要获取供之后使用。例如，“Windows(?=95|98|NT|2000)"能匹配"Windows2000"中的"Windows"，但不能匹配"Windows3.1"中的"Windows"。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配以后当即开始下一次匹配的搜索，而不是从包含预查的字符以后开始。 |
| (?!pattern) | 正向否认预查，在任何不匹配pattern的字符串开始处匹配查找字符串。这是一个非获取匹配，也就是说，该匹配不须要获取供之后使用。例如“Windows(?!95|98|NT|2000)"能匹配"Windows3.1"中的"Windows"，但不能匹配"Windows2000"中的"Windows"。预查不消耗字符，也就是说，在一个匹配发生后，在最后一次匹配以后当即开始下一次匹配的搜索，而不是从包含预查的字符以后开始 |
| (?<=pattern) | 反向确定预查，与正向确定预查类拟，只是方向相反。例如，“(?<=95|98|NT|2000)Windows"能匹配"2000Windows"中的"Windows"，但不能匹配"3.1Windows"中的"Windows"。 |
| (?<!pattern) | 反向否认预查，与正向否认预查类拟，只是方向相反。例如“(?<!95|98|NT|2000)Windows"能匹配"3.1Windows"中的"Windows"，但不能匹配"2000Windows"中的"Windows"。 |
| x|y | 匹配x或y。例如，“z|food"能匹配"z"或"food"。"(z|f)ood"则匹配"zood"或"food"。 |
| [xyz] | 字符集合。匹配所包含的任意一个字符。例如，“[abc]"能够匹配"plain"中的"a"。 |
| [^xyz] | 负值字符集合。匹配未包含的任意字符。例如，“[^abc]"能够匹配"plain"中的"p"。 |
| [a-z] | 字符范围。匹配指定范围内的任意字符。例如，“[a-z]"能够匹配"a"到"z"范围内的任意小写字母字符。 |
| [^a-z] | 负值字符范围。匹配任何不在指定范围内的任意字符。例如，“[^a-z]"能够匹配任何不在"a"到"z"范围内的任意字符。 |
| \b | 匹配一个单词边界，也就是指单词和空格间的位置。例如，“er\b"能够匹配"never"中的"er"，但不能匹配"verb"中的"er"。 |
| \B | 匹配非单词边界。“er\B"能匹配"verb"中的"er"，但不能匹配"never"中的"er"。 |
| \cx | 匹配由x指明的控制字符。例如，\cM匹配一个Control-M或回车符。x的值必须为A-Z或a-z之一。不然，将c视为一个原义的“c"字符。 |
| \d | 匹配一个数字字符。等价于[0-9]。 |
| \D | 匹配一个非数字字符。等价于[^0-9]。 |
| \f | 匹配一个换页符。等价于\x0c和\cL。 |
| \n | 匹配一个换行符。等价于\x0a和\cJ。 |
| \r | 匹配一个回车符。等价于\x0d和\cM。 |
| \s | 匹配任何空白字符，包括空格、制表符、换页符等等。等价于[ \f\n\r\t\v]。 |
| \S | 匹配任何非空白字符。等价于[^ \f\n\r\t\v]。 |
| \t | 匹配一个制表符。等价于\x09和\cI。 |
| \v | 匹配一个垂直制表符。等价于\x0b和\cK。 |
| \w | 匹配包括下划线的任何单词字符。等价于“[A-Za-z0-9_]"。 |
| \W | 匹配任何非单词字符。等价于“[^A-Za-z0-9_]"。 |
| \xn | 匹配n，其中n为十六进制转义值。十六进制转义值必须为肯定的两个数字长。例如，“\x41"匹配"A"。"\x041"则等价于"\x04&1"。正则表达式中可使用ASCII编码。. |
| \num | 匹配num，其中num是一个正整数。对所获取的匹配的引用。例如，“(.)\1"匹配两个连续的相同字符。 |
| \n | 标识一个八进制转义值或一个向后引用。若是\n以前至少n个获取的子表达式，则n为向后引用。不然，若是n为八进制数字（0-7），则n为一个八进制转义值。 |
| \nm | 标识一个八进制转义值或一个向后引用。若是\nm以前至少有nm个得到子表达式，则nm为向后引用。若是\nm以前至少有n个获取，则n为一个后跟文字m的向后引用。若是前面的条件都不知足，若n和m均为八进制数字（0-7），则\nm将匹配八进制转义值nm。 |
| \nml | 若是n为八进制数字（0-3），且m和l均为八进制数字（0-7），则匹配八进制转义值nml。 |
| \un | 匹配n，其中n是一个用四个十六进制数字表示的Unicode字符。例如，\u00A9匹配版权符号（©）。 |
http://www.regexlab.com/zh/regref.htm工具
| 用户名 | /^[a-z0-9_-]{3,16}$/ |
|---|---|
| 密码 | /^[a-z0-9_-]{6,18}$/ |
| 密码2 | (?=^.{8,}$)(?=.*\d)(?=.*\W+)(?=.*[A-Z])(?=.*[a-z])(?!.*\n).*$ (由数字/大写字母/小写字母/标点符号组成，四种都必有，8位以上) |
| 十六进制值 | /^#?([a-f0-9]{6}|[a-f0-9]{3})$/ |
| 电子邮箱 | /^([a-z0-9_\.-]+)@([\da-z\.-]+)\.([a-z\.]{2,6})$/ /^[a-z\d]+(\.[a-z\d]+)*@([\da-z](-[\da-z])?)+(\.{1,2}[a-z]+)+$/或\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)* |
| URL | /^(https?:\/\/)?([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-]*)*\/?$/ 或 [a-zA-z]+://[^\s]* |
| IP 地址 | /((2[0-4]\d|25[0-5]|[01]?\d\d?)\.){3}(2[0-4]\d|25[0-5]|[01]?\d\d?)/ /^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$/ 或 ((2[0-4]\d|25[0-5]|[01]?\d\d?)\.){3}(2[0-4]\d|25[0-5]|[01]?\d\d?) |
| HTML 标签 | /^<([a-z]+)([^<]+)*(?:>(.*)<\/\1>|\s+\/>)$/或<(.*)(.*)>.*<\/\1>|<(.*) \/> |
| 删除代码\\注释 | (?<!http:|\S)//.*$ |
| 匹配双字节字符(包括汉字在内) | [^\x00-\xff] |
| 汉字(字符) | [\u4e00-\u9fa5] |
| Unicode编码中的汉字范围 | /^[\u2E80-\u9FFF]+$/ |
| 中文及全角标点符号(字符) | [\u3000-\u301e\ufe10-\ufe19\ufe30-\ufe44\ufe50-\ufe6b\uff01-\uffee] |
| 日期(年-月-日) | (\d{4}|\d{2})-((0?([1-9]))|(1[1|2]))-((0?[1-9])|([12]([1-9]))|(3[0|1])) |
| 日期(月/日/年) | ((0?[1-9]{1})|(1[1|2]))/(0?[1-9]|([12][1-9])|(3[0|1]))/(\d{4}|\d{2}) |
| 时间(小时:分钟, 24小时制) | ((1|0?)[0-9]|2[0-3]):([0-5][0-9]) |
| 中国大陆固定电话号码 | (\d{4}-|\d{3}-)?(\d{8}|\d{7}) |
| 中国大陆手机号码 | 1\d{10} |
| 中国大陆邮政编码 | [1-9]\d{5} |
| 中国大陆身份证号(15位或18位) | \d{15}(\d\d[0-9xX])? |
| 非负整数(正整数或零) | \d+ |
| 正整数 | [0-9]*[1-9][0-9]* |
| 负整数 | -[0-9]*[1-9][0-9]* |
| 整数 | -?\d+ |
| 小数 | (-?\d+)(\.\d+)? |
| 空白行 | \n\s*\r 或者 \n\n(editplus) 或者 ^[\s\S ]*\n |
| QQ号码 | [1-9]\d{4,} |
| 不包含abc的单词 | \b((?!abc)\w)+\b |
| 匹配首尾空白字符 | ^\s*|\s*$ |
| 编辑经常使用 |
如下是针对特殊中文的一些替换(editplus)
^[0-9].*\n
^[^第].*\n
^[习题].*\n
^[\s\S ]*\n
^[0-9]*\.
^[\s\S ]*\n
<p[^<>*]>
href="javascript:if\(confirm\('(.*?)'\)\)window\.location='(.*?)'"
<span style=".[^"]*rgb\(255,255,255\)">.[^<>]*</span>
<DIV class="xs0">[\s\S]*?</DIV> |
3.如何写出高效率的正则表达式
若是纯粹是为了挑战本身的正则水平，用来实现一些特效（例如使用正则表达式计算质数、解线性方程），效率不是问题；若是所写的正则表达式只是为了知足一两次、几十次的运行，优化与否区别也不太大。可是，若是所写的正则表达式会百万次、千万次地运行，效率就是很大的问题了。我这里总结了几条提高正则表达式运行效率的经验（工做中学到的，看书学来的，本身的体会），贴在这里。若是您有其它的经验而这里没有说起，欢迎赐教。
为行文方便，先定义两个概念。
误匹配：指正则表达式所匹配的内容范围超出了所须要范围，有些文本明明不符合要求，可是被所写的正则式“击中了”。例如，若是使用\d{11}来匹配11位的手机号，\d{11}不单能匹配正确的手机号，它还会匹配98765432100这样的明显不是手机号的字符串。咱们把这样的匹配称之为误匹配。
漏匹配：指正则表达式所匹配的内容所规定的范围太狭窄，有些文本确实是所须要的，可是所写的正则没有将这种状况囊括在内。例如，使用\d{18}来匹配18位的身份证号码，就会漏掉结尾是字母X的状况。
写出一条正则表达式，既可能只出现误匹配（条件写得极宽松，其范围大于目标文本），也可能只出现漏匹配（只描述了目标文本中多种状况种的一种），还可能既有误匹配又有漏匹配。例如，使用\w+\.com来匹配.com结尾的域名，既会误匹配abc_.com这样的字串（合法的域名中不含下划线，\w包含了下划线这种状况），又会漏掉ab-c.com这样的域名（合法域名中能够含中划线，可是\w不匹配中划线）。
精准的正则表达式意味着既无误匹配且无漏匹配。固然，现实中存在这样的状况：只能看到有限数量的文本，根据这些文本写规则，可是这些规则将会用到海量的文本中。这种状况下，尽量地（若是不是彻底地）消除误匹配以及漏匹配，并提高运行效率，就是咱们的目标。本文所提出的经验，主要是针对这种状况。
掌握语法细节。正则表达式在各类语言中，其语法大体相同，细节各有千秋。明确所使用语言的正则的语法的细节，是写出正确、高效正则表达式的基础。例如，perl中与\w等效的匹配范围是[a-zA-Z0-9_]；perl正则式不支持确定逆序环视中使用可变的重复（variable repetition inside lookbehind，例如(?<=.*)abc），可是.Net语法是支持这一特性的；又如，JavaScript连逆序环视（Lookbehind,如(?<=ab)c）都不支持，而perl和python是支持的。《精通正则表达式》第3章《正则表达式的特性和流派概览》明确地列出了各大派系正则的异同，这篇文章也简要地列出了几种经常使用语言、工具中正则的比较。对于具体使用者而言，至少应该详细了解正在使用的那种工做语言里正则的语法细节。
先粗后精，先加后减。使用正则表达式语法对于目标文本进行描述和界定，能够像画素描同样，先大体勾勒出框架，再逐步在局步实现细节。仍举刚才的手机号的例子，先界定\d{11}，总不会错；再细化为1[358]\d{9}，就向前迈了一大步（至于第二位是否是三、五、8，这里无心深究，只举这样一个例子，说明逐步细化的过程）。这样作的目的是先消除漏匹配（刚开始先尽量多地匹配，作加法），而后再一点一点地消除误匹配（作减法）。这样有先有后，在考虑时才不易出错，从而向“不误不漏”这个目标迈进。
留有余地。所能看到的文本sample是有限的，而待匹配检验的文本是海量的，暂时不可见的。对于这样的状况，在写正则表达式时要跳出所能见到的文本的圈子，开拓思路，做出“战略性前瞻”。例如，常常收到这样的垃圾短信：“发*票”、“发#漂”。若是要写规则屏蔽这样烦人的垃圾短信，不但要能写出能够匹配当前文本的正则表达式 发[*#](?:票|漂)，还要可以想到 发.(?:票|漂|飘)之类可能出现的“变种”。这在具体的领域或许会有针对性的规则，很少言。这样作的目的是消除漏匹配，延长正则表达式的生命周期。
明确。具体说来，就是谨慎用点号这样的元字符，尽量不用星号和加号这样的任意量词。只要能肯定范围的，例如\w，就不要用点号；只要可以预测重复次数的，就不要用任意量词。例如，写析取twitter消息的脚本，假设一条消息的xml正文部分结构是<span class=”msg”>…</span>且正文中无尖括号，那么<span class=”msg”>[^<]{1,480}</span>这种写法的思路要好于<span class=”msg”>.*</span>，缘由有二：一是使用[^<]，它保证了文本的范围不会超出下一个小于号所在的位置；二是明确长度范围，{1,480}，其依据是一条twitter消息大体能的字符长度范围。固然，480这个长度是否正确还可推敲，可是这种思路是值得借鉴的。说得狠一点，“滥用点号、星号和加号是不环保、不负责任的作法”。
不要让稻草压死骆驼。每使用一个普通括号()而不是非捕获型括号(?:…)，就会保留一部份内存等着你再次访问。这样的正则表达式、无限次地运行次数，无异于一根根稻草的堆加，终于能将骆驼压死。养成合理使用(?:…)括号的习惯。
宁简勿繁。将一条复杂的正则表达式拆分为两条或多条简单的正则表达式，编程难度会下降，运行效率会提高。例如用来消除行首和行尾空白字符的正则表达式s/^\s+|\s+$//g;，其运行效率理论上要低于s/^\s+//g; s/\s+$//g; 。这个例子出自《精通正则表达式》第五章，书中对它的评论是“它几乎老是最快的，并且显然最容易理解”。既快又容易理解，何乐而不为？工做中咱们还有其它的理由要将C==(A|B)这样的正则表达式拆为A和B两条表达式分别执行。例如，虽然A和B这两种状况只要有一种可以击中所须要的文本模式就会成功匹配，可是若是只要有一条子表达式（例如A）会产生误匹配，那么不论其它的子表达式（例如B）效率如何之高，范围如何精准，C的整体精准度也会因A而受到影响。
巧妙定位。有时候，咱们须要匹配的the，是做为单词的the（两边有空格），而不是做为单词一部分的t-h-e的有序排列（例如together中的the）。在适当的时候用上^，$，\b等等定位锚点，能有效提高找到成功匹配、淘汰不成功匹配的效率。
4. 为何要用 r’ ..‘ 字符串（ raw 字符串）？
达式的存在。缘由是ASCII 字符和正则表达式特殊字符间所产生的冲突。好比，特殊符号“\b”在
ASCII 字符中表明退格键，但同时“\b”也是一个正则表达式的特殊符号，表明“匹配一个单词边界”。
为了让RE 编译器把两个字符“\b”当成你想要表达的字符串，而不是一个退格键，你须要用另外一个
反斜线对它进行转义，便可以这样写：“\\b”。
但这样作会把问题复杂化，特别是当你的正则表达式字符串里有不少特殊字符时，就更容
易使人困惑了。在第六章，咱们曾介绍过原始字符串，它常常被用于简化正则表达式的复杂程度。
事实上，不少Python 程序员在定义正则表达式时都只使用原始字符串。
下面的例子用来讲明退格键“\b” 和正则表达式“\b”(包含或不包含原始字符串)之间的区别：
>>> m = re.match('\bblow', 'blow') # backspace, no match #退格键,没有匹配
>>> if m is not None: m.group()
...
>>> m = re.match('\\bblow', 'blow') # escaped \, now it works #用\转义后，如今匹
配了
>>> if m is not None: m.group()
...
'blow'
>>> m = re.match(r'\bblow', 'blow') # use raw string instead #改用原始字符串
>>> if m is not None: m.group()
...
'blow'
你可能注意到咱们在正则表达式里使用“\d”，没用原始字符串，也没出现什么问题。那是由于
ASCII 里没有对应的特殊字符，因此正则表达式编译器可以知道你指的是一个十进制数字
二。python的re模块
3、导入正则表达式模块
3.一、导入正则表达式模块
|
1
|
>>>
import
re
|
3.二、查看正则表达式模块方法
|
1
2
3
|
>>>
dir
(re)
[
'DEBUG'
,
'DOTALL'
,
'I'
,
'IGNORECASE'
,
'L'
,
'LOCALE'
,
'M'
,
'MULTILINE'
,
'S'
,
'Scanner'
,
'T'
,
'TEMPLATE'
,
'U'
,
'UNICODE'
,
'VERBOSE'
,
'X'
,
'_MAXCACHE'
,
'__all__'
,
'__builtins__'
,
'__doc__'
,
'__file__'
,
'__name__'
,
'__package__'
,
'__version__'
,
'_alphanum'
,
'_cache'
,
'_cache_repl'
,
'_compile'
,
'_compile_repl'
,
'_expand'
,
'_pattern_type'
,
'_pickle'
,
'_subx'
,
'compile'
,
'copy_reg'
,
'error'
,
'escape'
,
'findall'
,
'finditer'
,
'match'
,
'purge'
,
'search'
,
'split'
,
'sre_compile'
,
'sre_parse'
,
'sub'
,
'subn'
,
'sys'
,
'template'
]
>>>
|
4、经常使用的正则表达式处理函数
4.一、re.search
re.search 函数会在字符串内查找模式匹配，只到找到第一个匹配而后返回，若是字符串没有匹配，则返回None。
提示：当咱们不会用模块方法的时候用help
|
1
2
|
>>>
help
(re.search)
search(pattern, string, flags
=
0
)
|
第一个参数：规则
第二个参数：表示要匹配的字符串
第三个参数：标致位，用于控制正则表达式的匹配方式
实例：下面的例子kuangl
|
1
2
3
4
5
6
7
8
|
>>> name
=
"Hello,My name is kuangl,nice to meet you..."
>>> k
=
re.search(r
'k(uan)gl'
,name)
>>>
if
k:
...
print
k.group(
0
),k.group(
1
)
...
else
:
...
print
"Sorry,not search!"
...
kuangl uan
|
4.二、re.match
re.match 尝试从字符串的开始匹配一个模式，也等于说是匹配第一个单词
|
1
2
|
>>>
help
(re.match)
match(pattern, string, flags
=
0
)
|
第一个参数：规则
第二个参数：表示要匹配的字符串
第三个参数：标致位，用于控制正则表达式的匹配方式
实例：下面的例子匹配Hello单词
|
1
2
3
4
5
6
7
8
9
10
|
>>> name
=
"Hello,My name is kuangl,nice to meet you..."
>>> k
=
re.match(r
"(\H....)"
,name)
>>>
if
k:
...
print
k.group(
0
),
'\n'
,k.group(
1
)
...
else
:
...
print
"Sorry,not match!"
...
Hello
Hello
>>>
|
re.match与re.search的区别：re.match只匹配字符串的开始，若是字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串，直到找到一个匹配。
4.三、re.findall
re.findall 在目标字符串查找符合规则的字符串
|
1
2
|
>>>
help
(re.findall)
findall(pattern, string, flags
=
0
)
|
第一个参数：规则
第二个参数：目标字符串
但三个参数：后面还能够跟一个规则选择项
返回的结果是一个列表，建中存放的是符合规则的字符串，若是没有符合规则的字符串呗找到，就会返回一个空值。
实例：查找邮件帐号
|
1
2
3
|
>>> mail
=
'<user01@mail.com> <user02@mail.com> user04@mail.com'
#第3个故意没有尖括号
>>> re.findall(r
'(\w+@m....[a-z]{3})'
,mail)
[
'user01@mail.com'
,
'user02@mail.com'
,
'user04@mail.com'
]
|
4.四、re.sub
re.sub 用于替换字符串的匹配项
|
1
2
|
>>>
help
(re.sub)
sub(pattern, repl, string, count
=
0
)
|
第一个参数：规则
第二个参数：替换后的字符串
第三个参数：字符串
第四个参数：替换个数。默认为0，表示每一个匹配项都替换
实例：将空白处替换成-
|
1
2
3
4
5
6
|
>>> test
=
"Hi, nice to meet you where are you from?"
>>> re.sub(r
'\s'
,
'-'
,test)
'Hi,-nice-to-meet-you-where-are-you-from?'
>>> re.sub(r
'\s'
,
'-'
,test,
5
)
#替换至第5个
'Hi,-nice-to-meet-you-where are you from?'
>>>
|
4.五、re.split
re.split 用于来分割字符串
|
1
2
|
>>>
help
(re.split)
split(pattern, string, maxsplit
=
0
)
|
第一个参数：规则
第二个参数：字符串
第三个参数：最大分割字符串，默认为0，表示每一个匹配项都分割
实例：分割全部的字符串
|
1
2
3
4
5
6
|
>>> test
=
"Hi, nice to meet you where are you from?"
>>> re.split(r
"\s+"
,test)
[
'Hi,'
,
'nice'
,
'to'
,
'meet'
,
'you'
,
'where'
,
'are'
,
'you'
,
'from?'
]
>>> re.split(r
"\s+"
,test,
3
)
#分割前三个
[
'Hi,'
,
'nice'
,
'to'
,
'meet you where are you from?'
]
>>>
|
4.六、re.compile
re.compile 能够把正则表达式编译成一个正则对象
|
1
2
|
>>> help(re.compile)
compile(pattern, flags=
0
)
|
第一个参数：规则
第二个参数：标志位
实例：
|
1
2
3
4
5
6
7
8
9
|
>>> test
=
"Hi, nice to meet you where are you from?"
>>> k
=
re.
compile
(r
'\w*o\w*'
)
#匹配带o的字符串
>>>
dir
(k)
[
'__copy__'
,
'__deepcopy__'
,
'findall'
,
'finditer'
,
'match'
,
'scanner'
,
'search'
,
'split'
,
'sub'
,
'subn'
]
>>>
print
k.findall(test)
#显示全部包涵o的字符串
[
'to'
,
'you'
,
'you'
,
'from'
]
>>>
print
k.sub(
lambda
m:
'['
+
m.group(
0
)
+
']'
,test)
# 将字符串中含有o的单词用[]括起来
Hi, nice [to] meet [you] where are [you] [
from
]?
>>>
|
5、用urllib二、re、os 模块下载文件的脚本
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
#!/usr/bin/env python
import
urllib2
import
re
import
os
URL
=
'http://image.baidu.com/channel/wallpaper'
read
=
urllib2.urlopen(URL).read()
pat
=
re.
compile
(r
'src="http://.+?.js">'
)
urls
=
re.findall(pat,read)
for
i
in
urls:
url
=
i.replace(
'src="'
,'
').replace('
">
','
')
try
:
iread
=
urllib2.urlopen(url).read()
name
=
os.path.basename(url)
with
open
(name,
'wb'
) as jsname:
jsname.write(iread)
except
:
print
url,
"url error"
|
三。re模块的正则使用
-
每一个你不满意的现在，都有一个你没有努力的曾经。