Python之路（八）：正则表达式

正则表达式　　　　　　　　　　　　　　　　　　　　　　　　　　　　

一、简介

就本质而言，正则表达式（re）是一种小型的、高度专业化的的编程语言，（在Python中）它内嵌在Python中，并通过 re 模块实现。正则表达式模式被编译成一系列的字节码，然后由用 C 编写的匹配引擎执行。

二、正则匹配之字符匹配

字符匹配（普通字符，元字符）

普通字符：无特殊字符的字符或字符串

元字符：有元字符的

1、普通子符匹配：大多数字符和字母都会和自身匹配

>>> s = "this is myblogs ,1 2 ,34"
>>> re.findall('is',s)
['is', 'is']
>>> re.findall('2',s)
['2']

2、常用元字符：

. 匹配任意一个字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符
^ 匹配起始位置
$ 匹配终止位置
* 匹配前面的字符0到多次,可以没有
＋匹配前面的字符1到多次,最少有一个
? 匹配前面的字符0-1次
{} 匹配次数如 {3}匹配3次，{1,5} 匹配1到五次
\ 转义符反斜杠后面跟元字符去除特殊功能, 反斜杠后面跟普通字母实现特殊功能
[] 或的作用 a[bc]d 匹配 abd acd ,中括号里只匹配一个字符，除了( 1、 - ：至，例[0-9] 2、 ^ :非例：[^0-9] 非0-9 ) "" 里面的特殊符号没有任何意义
() 分组匹配，分组匹配一般使用（），被括起来的表达式将作为一组，上面所说的只是针对单个字符串，如果需要匹配多个字符串，则用到了分组匹配。先匹配成功全部正则，再匹配成功的局部内容提取出来

元字符
元字符	说明	表达式示例	匹配后的字符串
.	匹配任意除还行符'\n'外的字符。	a.c	abc
^	匹配字符串开头；在多行模式中匹配每一行开头。	^abc	abc
$	匹配字符串末尾；在多行模式中匹配每一行末尾。	abc$	abc
*	匹配前一个字符0或无限次。	abc*	ab abccc
+	匹配前一个字符1或无限次。	abc+	abc abcccc
?	匹配前一个字符0或1次。	abc?	ab abc
{m}	匹配前一个字符m次。	ab{2}c	abbc
{m，n}	匹配前一个字符m至n次。 m和n可以省略：若省略m,则匹配0至n次；　　　　　　　若省略你，则匹配m至无限次。	ab{1,2}c	abc abbc
\|	\|代表左右表达式任意匹配一个它总是先尝试匹配左边表达式，一旦成功则跳过匹配右边的表达式如果\|没有被包括在()中，则它的范围是整个表达式。	abc\|def	abc def
()	被括起来的表达式将作为分组，从表达左边开始每遇到一个分组的左括号“（”，编号+1。	(abc){2}	abcabc
\	转义字符，使后一个字符改变原来的意思。	a\.c	a.c
[]	字符集。对应的位置可以是字符集中的任意字符。[a-c]就是给出范围	a[bcd]e	abe ace ade

import re
s = "this is myblogs , my name is blogs"
# . 表示任意字符，通用匹配
    ret = re.findall('.s',s)  #使用.匹配任意以s结尾的两位字符串
    print(ret)
    #输出：['is', 'is', 'gs', 'is', 'gs']
    ret = re.findall('.blogs',s)
    #['yblogs', ' blogs']
    ret = re.findall('b.og',s)
    #['blog', 'blog']

# ^ 表示匹配开头，只匹配开头内容
    ret = re.findall('^is',s)
    #[]
    ret = re.findall('^th',s)
    #['th']
    ret = re.findall('^this',s)
    #['this']

# $表示匹配结尾内容，只匹配结尾，用在字符之后
    ret = re.findall('$s',s)      #注意$要放字符串后边
    #[]
    ret = re.findall('s$',s)
    #['s']
    ret = re.findall('.s$',s)
    #['gs']

# *表示匹配前面字符0到多次，用在字符之后，只针对前面的一个字符
    s = "aabbccddabcdabcd"
    ret = re.findall('a*',s)    #匹配0到多次，所以会打印没有匹配到的
    #['aa', '', '', '', '', '', '', 'a', '', '', '', 'a', '', '', '', '']
    ret = re.findall('aa*',s)      #匹配第二个a出现的0到多次
    #['aa', 'a', 'a']
    ret = re.findall('ab*',s)    #匹配b出现的0到多次
    #['a', 'abb', 'ab', 'ab']


# ＋ 匹配前面的字符1到多次,最少有一个
    ret = re.findall('a+',s)      #最少出现一个a
    #['aa', 'a', 'a']
    ret = re.findall('aa+',s) #最少出现一个aa
    #['aa']
    ret = re.findall('ab+',s)    #最少出现一个ab
    #['abb', 'ab', 'ab']

# ?  匹配前面的字符0-1次,只能出现一次或没有
    s = "aa bb cc dd abcd ababcdcd"
    ret = re.findall('aa?',s)
    #['aa', 'a', 'a', 'a']
    ret = re.findall('ab?',s)
    #['a', 'a', 'ab', 'ab', 'ab']  #匹配出现一次b或者没有，所结果中b只能出现一次或者没有

# / 转义功能，去除后面字符的特殊意义
    s = "* *? +> <>"
    ret = re.findall('^\*',s)   #匹配*号
    #['*']
    ret = re.findall('\*.',s)
    #['* ', '*?']

#{} 指定匹配次数
    s = "aa bb aaa bbb aabbcc aaabbb  abab ababab"
    ret = re.findall('a{1,2}',s)   #匹配a出现的1-2次，即a aa
    #['aa', 'aa', 'a', 'aa', 'aa', 'a', 'a', 'a', 'a', 'a', 'a']
    ret = re.findall('ab{1,2}',s)     #匹配ab或 abb
    #['abb', 'abb', 'ab', 'ab', 'ab', 'ab', 'ab']

# []   或的作用
    s = "abc adc aec adec abbc addc abbbc adddc ac abbddc"
    ret = re.findall('a[db]c',s)   #匹配abc 或adc
    #['abc', 'adc']
    ret = re.findall('a[db]+c',s)   #匹配ac中间至少1个b或d，可以有多个
    #['abc', 'adc', 'abbc', 'addc', 'abbbc', 'adddc', 'abbddc']
    ret = re.findall('a[db]?c',s)   #匹配ac中间一个a或b，可以没有
    #['abc', 'adc', 'ac']
    ret = re.findall('a[db]*c',s) #匹配ac中间0到多个b或d
    #['abc', 'adc', 'abbc', 'addc', 'abbbc', 'adddc', 'ac', 'abbddc']
    ret = re.findall('a[^db]c',s)   #匹配ac中间不出现b或d的情况 ^在这里表示非
    #['aec']

    s = "abc abbbbbc  a1231c  a_+_+_+_+_+_c "
    ret = re.findall('a[a-z,0-9]+c',s)  #匹配ac中间是字母或数字
    #['abc', 'abbbbbc', 'a1231c']

示例

() 分组匹配 : 分组匹配一般使用（），被括起来的表达式将作为一组，上面所说的只是针对单个字符串，如果需要匹配多个字符串，则用到了分组匹配。先匹配成功全部正则，再匹配成功的局部内容提取出来

import re
s = "aa bb aaa bbb aabbcc aaabbb  abab ababab"
ret = re.findall('(ab).',s)   ＃同时匹配ab
print(ret)
#['ab', 'ab', 'ab', 'ab']

3、预定义字符集

\ :　　a、反斜杠后边跟元字符去除特殊功能

　　 b、反斜杠后边跟普通字符实现特殊功能。

　　 c、引用序号对应的字组所匹配的字符串

\w 　　匹配包括下划线的任何单词字符。等价于'[A-Za-z0-9_]'。
\W 匹配任何非单词字符。等价于 '[^{A-Za-z0-9_]'。}
\s 匹配任意空白字符，等价于 [\t\n\r\f].
\S 匹配任意非空字符
\d 匹配任意数字，等价于 [0-9].
\D 匹配任意非数字
\A 匹配字符串开始
\Z 匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串。c
\z 匹配字符串结束
\G 匹配最后匹配完成的位置。
\b 匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er\b' 可以匹配never 中的 'er'，但不能匹配 verb 中的 'er'。
\B 匹配非单词边界。'er\B' 能匹配 verb 中的 'er'，但不能匹配 never 中的 'er'。
\n, \t, 等. 匹配一个换行符。匹配一个制表符。等
\1...\9 匹配第n个分组的子表达式。
\10 匹配第n个分组的子表达式，如果它经匹配。否则指的是八进制字符码的表达式。

预定义字符集
\d	匹配任何十进制数；它相当于类 [0-9]	a\dc	a1c
\D	匹配任何非数字字符；它相当于类 [^0-9]	a\Dc	abc
\s	匹配任何空白字符；它相当于类 [ \t\n\r\f\v]	a\sc	a c
\S	匹配任何非空白字符；它相当于类 [^ \t\n\r\f\v]	a\Sc	abc
\w	匹配任何字母数字字符；它相当于类 [a-zA-Z0-9_]	a\wc	abc
\W	匹配任何非字母数字字符；它相当于类 [^a-zA-Z0-9_]	a\Wc	a c
\b	匹配一个单词边界，也就是指单词和空格间的位置

import re
m = re.findall('\d','ww3wa8.d0')  # \d  匹配任何十进制数；
print(m)
#['3', '8', '0']

f = re.findall('\D','ww3wa8.d0')  #\D  匹配任何非数字字符；
print(f)
#['w', 'w', 'w', 'a', '.', 'd']

n = re.findall('\s','ww3 wa8.d0')  #\s  匹配任何空白字符
print(n)
#[' ']

y = re.findall('\S','ww3 wa8.d0')  #\S  匹配任何非空白字符
print(y)
#['w', 'w', '3', 'w', 'a', '8', '.', 'd', '0']

k = re.findall('\w','ww3 wa8.d0') #匹配任何字母数字字符
print(k)
#
['w', 'w', '3', 'w', 'a', '8', 'd', '0']

t = re.findall('\W','ww3 wa8.d0')  #\W 匹配任何非字母数字字符
print(t)
#[' ', '.']

示例

注释1：\b例如：

　　　'er/b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。

　　　\b只是匹配字符串开头结尾及空格回车等的位置, 不会匹配空格符本身　

import re
m = re.findall('\babc\b','abc sdsadasabcasdsadasdabcasdsa')
print(m)
输出结果：
[]

m = re.findall(r'\babc\b','abc sdsadasabcasdsadasdabcasdsa')
print(m)
输出结果：
['abc']

import re
ret = re.findall(r"abc\b","fgdfgb abc ")
print(ret)
#输出：['abc']

ret = re.findall(r"abc\b","fgdfgb abc*")
print(ret)
#输出：['abc']  
#后面跟特殊字符都可以匹配到

ret = re.findall(r"abc\b","fgdfgb abcdf")
print(ret)
#[]

ret = re.findall(r"\babc","fgdfgb abcdf")
print(ret)
#['abc']
#从单词前面匹配

\b 就是用在你匹配整个单词的时候。如果不是整个单词就不匹配。你想匹配 I 的话，你知道，很多单词里都有I的，但我只想匹配I，就是“我”，这个时候用 \bI\b

注释2：引用序号对应的字组所匹配的字符串

import re
s = "xgzxhahazxxgxghkhdjfk"
ret = re.search(r"(xg)(zx)haha\2\1\1",s).group()
print(ret)
#输出：xgzxhahazxxgxg

反斜杠的困扰

与大多数编程语言相同，正则表达式里使用"\"作为转义字符，这就可能造成反斜杠困扰。

假如你需要匹配文本中的字符"\"，那么使用编程语言表示的正则表达式里将需要4个反斜杠"\\\\"：

前两个和后两个分别用于在编程语言里转义成反斜杠，转换成两个反斜杠后再在正则表达式里转义成一个反斜杠。

Python里的原生字符串很好地解决了这个问题，这个例子中的正则表达式可以使用r"\\"表示。

同样，匹配一个数字的"\\d"可以写成r"\d"。有了原生字符串，你再也不用担心是不是漏写了反斜杠，写出来的表达式也更直观。

import re
m = re.findall('\babc\b','abc sdsadasabcasdsadasdabcasdsa')
print(m)
运算结果：
[]


m = re.findall(r'\babc\b','abc sdsadasabcasdsadasdabcasdsa')
print(m)
运算结果：
['abc']

4、贪婪匹配

*?,+?,??,{m,n}? 前面的*,+,?等都是贪婪匹配，也就是尽可能匹配，后面加?号使其变成惰性匹配

从前面的描述可以看到'*'，'+'和'?'都是贪婪的，但这也许并不是我们说要的，所以，可以在后面加个问号，将策略改为非贪婪，只匹配尽量少的RE

示例：

import re
m = re.findall(r'a(\d+?)','a23b')
print(m)
#输出结果：
#       ['2']

import re
i = re.findall(r'a(\d+)','a23b')
print(i)
#输出结果：
#       ['23']

三、正则匹配方式（re模块常用函数）

1,compile()

编译正则表达式模式，返回一个对象的模式

pattern: 编译时用的表达式字符串

re.compile(pattern,flags=0)

flags 编译标志位，用于修改正则表达式的匹配方式，如：是否区分大小写，多行匹配等。

常用的flags有：

re.U	根据Unicode字符集解析字符，这个标志影响\w,\W,\b,\B
re.S(DOTALL)	使.匹配包括换行在内的所有字符
re.I（IGNORECASE	re.I（IGNORECASE
re.L（LOCALE）	做本地化识别（locale-aware)匹配，法语等
re.M(MULTILINE)	多行匹配，影响^和$
re.X(VERBOSE)	该标志通过给予更灵活的格式以便将正则表达式写得更易于理解

示例：

import re
tt = "Tina is a good girl, she is cool, clever, and so on..."
rr = re.compile(r'\w*oo\w*')
print(rr.findall(tt))   #查找所有包含'oo'的单词
#执行结果：['good', 'cool']

2、findall(pattern, string)

　　re.findall 以列表形式返回所有匹配的字符串

　　re.findall可以获取字符串中所有匹配的字符串。

　　注意：
　　findall如果使用了分组，则输出的内容将是分组中的内容而非find到的结果，
　　为了得到find到的结果，要加上问号来启用“不捕捉模式”，就可以了。

ret = re.findall("www.(baidu|xinlang)\.com","www.baidu.com")
#输出：['baidu']
ret = re.findall("www.(?:baidu|xinlang)\.com","www.baidu.com")
#输出：['www.baidu.com']

3、match

从起始位置开始根据模型去字符串中匹配指定内容，匹配单个

格式：re.match(pattern, string, flags=0)

Pattern：对象是一个编译好的正则表达式

string ：匹配时使用的文本

flags: ：编译时用的匹配模式。默认不写

import re
m = re.match(r'hello', 'hello world!')
print(m.group())
#输出结果：hello


m = re.search('alex','alexdj')
print(m.group())
#输出结果：alex

s = '123abc4545'
ret = re.match(r'\w',s)
print(ret)
#输出：<_sre.SRE_Match object; span=(0, 1), match='1'>
rr = re.match(r'\w',s).group()   只匹配字符串开头
print(rr)
#输出：'1'

4、search

re.search(pattern, string, flags=0)

根据模型去字符串中匹配指定内容，匹配单个

匹配字符串的所有,但是匹配停止时,只返回第一个匹配的字符 pattern 是正则规则 string 是字符串 flags 是匹配模式

s = '123abc4545'
ret =  re.search(r'\w',s)
print(ret)
#输出：<_sre.SRE_Match object; span=(0, 1), match='1'>
rr = re.search(r'\w',s).group()
print(rr)
#输出：'1'
rrr = re.search(r'\D',s).group()
print(rrr)
#输出：'a'

PS：以上match和search都返回的是对象，其返回的对象有以下属性和方法：

属性：
- string: 匹配时使用的文本。
- re: 匹配时使用的Pattern对象。
- pos: 文本中正则表达式开始搜索的索引。值与Pattern.match()和Pattern.seach()方法的同名参数相同。
- endpos: 文本中正则表达式结束搜索的索引。值与Pattern.match()和Pattern.seach()方法的同名参数相同。
- lastindex: 最后一个被捕获的分组在文本中的索引。如果没有被捕获的分组，将为None。
- lastgroup: 最后一个被捕获的分组的别名。如果这个分组没有别名或者没有被捕获的分组，将为None。
方法：
- group([group1, …]) ：获得一个或多个分组截获的字符串；指定多个参数时将以元组形式返回。group1可以使用编号也可以使用别名；编号0代表整个匹配的子串；不填写参数时，返回group(0)；没有截获字符串的组返回None；截获了多次的组返回最后一次截获的子串。
- groups([default]) ：以元组形式返回全部分组截获的字符串。相当于调用group(1,2,…last)。default表示没有截获字符串的组以这个值替代，默认为None。
- groupdict([default]) ：返回以有别名的组的别名为键、以该组截获的子串为值的字典，没有别名的组不包含在内。default含义同上。
- start([group]) ：返回指定的组截获的子串在string中的起始索引（子串第一个字符的索引）。group默认值为0。
- end([group]) ：返回指定的组截获的子串在string中的结束索引（子串最后一个字符的索引+1）。group默认值为0。
- span([group]) ：返回(start(group), end(group))。
- expand(template) ：将匹配到的分组代入template中然后返回。template中可以使用\id或\g、\g引用分组，但不能使用编号0。\id与\g是等价的；但\10将被认为是第 10个分组，如果你想表达\1之后是字符'0'，只能使用\g0。

5、group和groups

findall(pattern, string, flags=0)

group() 返回被 RE 匹配的字符串；获得一个或多个分组截获的字符串；指定多个参数时将以元组形式返回。

group1可以使用编号也可以使用别名；编号0代表整个匹配的子串；

groups（）不需要参数，返回一个元组，元组中的元就是正则表达式中定义的组。

示例：

import re
a = "374839dkjfkjrj85390"
print(re.search('([0-9]*)([a-z]*)([0-9]*)',a).group(0))  #group(0)返回re整体匹配的字符串
#374839dkjfkjrj85390

print(re.search('([0-9]*)([a-z]*)([0-9]*)',a).group(1))  #group(1)返回组号为1所匹配的字符串
#374839

print(re.search('([0-9]*)([a-z]*)([0-9]*)',a).group(2))  #group(2)返回组号为2所匹配的字符串
#dkjfkjrj

print(re.search('([0-9]*)([a-z]*)([0-9]*)',a).group(3))  #group(3)返回组号为3所匹配的字符串
#85390

print(re.search('([0-9]*)([a-z]*)([0-9]*)',a).groups(0))  #groups（）不需要参数，返回一个元组，元组中的元就是正则表达式中定义的组
#('374839', 'dkjfkjrj', '85390')

# group(1) 列出第一个括号匹配部分，group(2) 列出第二个括号匹配部分，group(3) 列出第三个括号匹配部分。

start() 返回匹配开始的位置；group默认值为0

end() 返回匹配结束的位置；group默认值为0

span() 返回一个元组包含匹配 (开始,结束) 的位置；返回(start(group), end(group))

示例：

import re
m = re.match(r'(\w+) (\w+)(?P<sign>.*)', 'hello world!')

print ("m.group(1,2):", m.group(1, 2))
#m.group(1,2): ('hello', 'world')
print ("m.groups():", m.groups())
#m.groups(): ('hello', 'world', '!')
print ("m.groupdict():", m.groupdict())
#m.groupdict(): {'sign': '!'}
print ("m.start(2):", m.start(2))
#m.start(2): 6
print ("m.end(2):", m.end(2))
#m.end(2): 11
print ("m.span(2):", m.span(2))
#m.span(2): (6, 11)

6、split()

分割

re.split(pattern, string, maxsplit=0, flags=0)

根据指定匹配进行分组

示例：

import re
 
p = re.compile(r'\d+')
print p.split('one1two2three3four4')

运算结果：
['one', 'two', 'three', 'four', '']

import re
ret = re.split("[bc]","abcd")
print(ret)
#['a','','d']
#先用b分成a和cd，再用c分成''和'd'

# #split 分割
import re
origin = "hello alex bcd alex lge alex acd 19"
n = re.split("a\w+",origin) #全部分割
print(n)
#输出['hello ', ' bcd ', ' lge ', ' ', ' 19']
m = re.split("a\w+",origin,2) #分割几组
print(m)
#输出['hello ', ' bcd ', ' lge alex acd 19']
c = re.split("a(\w+)",origin,2) #先匹配括号里的
print(c)
#输出['hello ', 'lex', ' bcd ', 'lex', ' lge alex acd 19']

7、sub

替换匹配的字符串

re.sub(pattern,repl,string,max=0)

import re
origin = '1hdsjhsd234bj245njh226nj'
new_str,count = re.subn("\d+","KKK",origin)
print(new_str,count) 
#输出KKKhdsjhsdKKKbjKKKnjhKKKnj 4
#new_str接收的是替换后的结果，count接收的是替换次数，count可以不接收，即可以不用写



import re
p = re.compile(r'(\w+) (\w+)')
s = "i say,hello world!"
rr = p.sub(r'\2\1',s)
print(rr) 
#输出sayi,worldhello!

def func(m):
    return m.group(1).title() + '' + m.group(2).title()
ret = p.sub(func,s)
print(ret) 
#输出ISay,HelloWorld!

#可以指定替换次数
import re
s = "i get you, i got you , i gut you"
ret = re.sub("g.t","have",s,2)
print(ret)
#输出：i have you, i have you , i gut you

8、subn

与 sub() 相同，但返回一个元组，里面是新的字符串和替换次数

示例：

import re

p = re.compile(r'(\w+) (\w+)')
s = 'i say, hello world!'
ret = p.subn(r'\2 \1', s)
print(ret)
#输出：('say i, world hello!', 2)

def func(m):
    return m.group(1).title() + ' ' + m.group(2).title()
ret = p.subn(func, s)
print (ret)
#输出：('I Say, Hello World!', 2)

9、finditer

搜索string，返回一个顺序访问每一个匹配结果（Match对象）的迭代器

#返回一个顺序访问每一个匹配结果（Match对象）的迭代器

import re
p = re.compile(r'\d+')
for m in p.finditer('one1two2three3four4'):
    print (m.group())

运算结果：
1
2
3
4

import re
p = re.compile(r'\d+')
w = p.finditer('12hjgyut56yuty15gyj..y.....yut44tyut...5ty..59.....5')
print(w)
#输出：<callable_iterator object at 0x000000000291FFD0>        
# 迭代器类型
for match in w:
    print(match.group(),match.span())
'''
输出：12 (0, 2)
      56 (8, 10)
      15 (14, 16)
      44 (30, 32)
      5 (39, 40)
      59 (44, 46)
      5 (51, 52)
'''

四、常用正则匹配

匹配手机号

import re
s = "my name is jeck, my phone is 18611112222, my email is jeck@gmail.com,my ip is 10.20.10.20,,my ID card is 110521199012256515"
ret = re.findall('(1[3578]\d{9})',s)
print(ret)
#输出：['18611112222']
rr = re.search('(1[3578]\d{9})',s).group()
print(rr)
#输出：18611112222
rrr = re.search('(13[0-9]|15[0|1|2|3|5|6|7|8|9]|18[0|1|2|3|5|6|7|8|9])\\d{8}',s).group()
print(rrr)
#输出：18611112222

匹配身份证

import re
s = "my name is jeck, my phone is 18611112222, my email is jeck@gmail.com,my ip is 10.20.10.20,,my ID card is 110521199012256515"
ret = re.search("([1-9]\\d{5}[1-9]\\d{3}((0\\d)|(1[0-2]))(([0|1|2]\\d)|3[0-1])\\d{3}([0-9]|X)$)",s).group()
print(ret)
#输出：110521199012256515

匹配IP地址

import re
s = "my name is jeck, my phone is 18611112222, my email is jeck@gmail.com,my ip is 10.20.10.20,,my ID card is 110521199012256515"
ret = re.search('\d+\.\d+\.\d+\.\d+',s).group()
print(ret)
#输出：10.20.10.20
rr = re.search('\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}',s).group()
print(rr)
#输出：10.20.10.20

匹配邮箱

import re
s = "my name is jeck, my phone is 18611112222, my email is jeck@gmail.com,my ip is 10.20.10.20,,my ID card is 110521199012256515"
ret = re.search('([a-zA-Z0-9._%+-])+@([a-zA-Z0-9.-]+\.[a-zA-Z]{2,4})',s).group()
print(ret)
#输出：jeck@gmail.com

posted @ 2017-07-25 13:30 西瓜撞地球 Views(164) Comments(0) 收藏举报

刷新页面返回顶部

西瓜撞地球

Python之路（八）：正则表达式

二、正则匹配之字符匹配

反斜杠的困扰

公告