python入门（十六）：正则

1、正则：对一些字符串实现模糊的匹配

使用场景：

爬虫：例如，网页源码里面的url都提取出来。网页里面提取我们想要的数据

分析日志：例如，拿到所有的ip,看看哪些ip访问过我的网站

2、引入包

>>> import re                    #re=regular expression 正则表达式

3、匹配最开头

1) 匹配最开头的任意字符串

>>> re.match("abc","abcd")       #re.match(模式，目标字符串)

<_sre.SRE_Match object; span=(0, 3), match='abc'>#span(0,3)表示匹配的范围是(0,3),左闭右开； match='abc'表示匹配的内容是’abc’

>>> a=re.match("bc","abcd")      #匹配最开头的bc

>>> a                          #打印a，未返回任何值

>>> type(a)                     #查看a的类型

<class 'NoneType'>               #返回值是nonetype,为空

>>> result=re.match("abc","abcd")

>>> result

<_sre.SRE_Match object; span=(0, 3), match='abc'>

>>> type(result)               #匹配到后的类型是_sre.SRE_Match，正则表达式匹配结果的对象(匹配对象)

<class '_sre.SRE_Match'>

>>>re.match("中国","中国abcd")    #也可匹配出中文

>>> <_sre.SRE_Match object; span=(0, 2), match='中国'>

2) 匹配最开头的任意数字

>>> re.match("\d","3WSD")  　　 #匹配最开头的数字,d=digit，re.match(模式，目标字符串)

<_sre.SRE_Match object; span=(0, 1), match='3'>

>>> re.match("\d","ab1cd")        #字符串最开头为非数字时，未匹配出任何内容

>>>

>>> re.match(r"\d","ab1cd")       #由于在文件中，”\d可能需要需要写“\\d”，需要转转译一下为了统一，写正则，交互模式与文件中，前面都加个r

4、匹配任意位置，匹配第一个后便结束

1) 匹配任意位置字符串       #re.search(模式，目标字符串)

>>> re.search(r"b1c","ab1cd")     #可以匹配出非开头的字符串

<_sre.SRE_Match object; span=(1, 4), match='b1c'>

>>> re.search(r"b1c","ab1cd2323b1cdkjf") #当有多个可匹配的内容时，输出第一个便结束

<_sre.SRE_Match object; span=(1, 4), match='b1c'>

2) 匹配任意位置的数字

>>> re.search(r"\d","a1b1d1")       #当有多个可匹配的内容时，输出第一个便结束

<_sre.SRE_Match object; span=(1, 2), match='1'>

>>> re.search(r"\d","a21c3d4")       #“\d”是匹配所有的数字，并非只指1

<_sre.SRE_Match object; span=(1, 2), match='2'>

>>> re.search(r"\d","liuyujing")       #匹配不到任何内容时，依然返回none

>>>

>>> re.search(r"中","liuyujing中")    #也可匹配汉字

<_sre.SRE_Match object; span=(9, 10), match='中'>

5、匹配任意位置所有满足的字符串

1) 匹配出所有满足条件的字符串

>>> re.findall(r"ab","asabddabc")

['ab', 'ab']

2) 匹配出所有的数字

>>> re.findall(r"\d","liu1yu2jing3df")  #查找任意位置满足条件的字符串

['1', '2', '3']                         #以列表的方式返回

>>> re.findall(r"\d","liuyujingdf")      #未匹配上，返回空列表

[]

#可通过判断返回值是否为空，判断是否有匹配上的内容

6、显示取到的结果

>>> re.search(r"中","liuyujing中").group()

'中'

>>> re.search(r"\d","d3sf5").group()      #匹配到第一个结果便输出

'3'

>>> re.search(r"d","d3sf5").group()

'd'

>>> re.match(r"\d","d3sf5").group()     #当未匹配上任何内容时使用group会报错

Traceback (most recent call last):        #因为没有none.group()的用法

File "<stdin>", line 1, in <module>

AttributeError: 'NoneType' object has no attribute 'group'

>>> re.findall(r"abc","deabchabcijk").group()#findall返回值不为空时，也不可使用group

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

AttributeError: 'list' object has no attribute 'group'

>> re.findall(r"ab","liuyujing").group()   #当返回值是[]时，也不可使用.group()

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

AttributeError: 'list' object has no attribute 'group'

7、编译（将模式进行编译）

>>> pattern = re.compile(r"\d")       #将查找数字编译到pattern中

>>> type(pattern)            #pattern的类型也是正则表达式匹配结果的对象（匹配对象）

<class '_sre.SRE_Pattern'>

>>> pattern.match("1df").group()      #pattern.match(目标字符串)

'1'

>>> pattern.search("d3fg").group()    #pattern.search(目标字符串)

'3'

>>> pattern.findall("dkjf678djfd5")     #pattern.findall(目标字符串)

['6', '7', '8', '5']

注意：pattern中，已经将匹配的模式(“\d”)编译，所以后续使用正则时，仅需要写match等匹配方法和目标字符串即可

好处：编译后，可以使用不同的匹配方法（match,search,findall）,方便复用正则表达式

>>> pattern1 = re.compile(r"abc")               #pattern1将模式“abc”进行了编译

>>> pattern1.match("abcdefghijk").group()

'abc'

>>> pattern1.search("deabchijk").group()

'abc'

>>> pattern1.findall("deabchabcijk").group()      #findall不可与group()一起用

Traceback (most recent call last)

File "<stdin>", line 1, in <module>

AttributeError: 'list' object has no attribute 'group'

>>> pattern1.findall("deabchabcijk")

['abc', 'abc']

8、模式：

1) \d\D：匹配第一个任意数字后结束

>>> re.search(r"\d","ab1234df").group()          #\d匹配第一个任意数字后结束

'1'

>>> re.search(r"\D","ab1234df").group()          #\D匹配第一个非数字后结束

'a'

>>> re.search(r"\D","*b1234df").group()           #特殊符号\D也可匹配

'*'

>>> re.search(r"\D","~b1234df").group()           #特殊符号\D也可匹配

'~'

>>> re.search(r"\D"," b1234df").group()            #空格\D也可匹配

' '

>>> re.search(r"\D","“b1234df").group()            #单引号\D也可匹配

'“'

>>> re.search(r"\D","12b1234df").group()          #匹配第一个非数字后结束

'b'

2) \w\W(匹配第一个所有的大小写字母和数字和下划线)

>>> re.search(r"\w"," a").group()                w匹配的范围是：”a-z A-Z 0-9 _”

'a

>>> re.search(r"\w"," A").group()            # w匹配的范围是：”a-z A-Z 0-9 _”

'A'

>>> re.search(r"\w"," ADS").group()          #w匹配的范围是：”a-z A-Z 0-9 _”

'A'

>>> re.search(r"\w"," Z").group()            #w匹配的范围是：”a-z A-Z 0-9 _”

'Z'

>>> re.search(r"\w"," _").group()            #w匹配的范围是：”a-z A-Z 0-9 _”

'_'

>>> re.search(r"\w","中").group()            #w根据系统的语言，可以匹配中文

'中'

>>> re.search(r"\W","*&*").group()         #W匹配的范围是：非”a-z A-Z 0-9 _”

'*'

>>> re.search(r"\W"," &^").group()

' '

3) \s\S space空白(匹配第一个任意不可见的字符和空白字符后结束)

>>> re.search(r"\s","\t").group()

'\t'

>>> re.search(r"\s","\n").group()

'\n'

>>> re.search(r"\s","\r").group()

'\r'

>>> re.search(r"\s","() ").group()

' '

>>> re.search(r"\s"," ").group()

' '

>>> re.search(r"\s","[] ").group()

' '

>>> re.search(r"\S","[] ").group()         #匹配到第一个非空白后结束

'['

>>> re.search(r"\S","\t a").group()

'a'

>>> re.search(r"\S","\t a!").group()

'a'

4) .  匹配非回车的所有字符，只会匹配一个字符

>>> re.findall(r"\D.S","Df %$DJS")

['DJS']

>>> re.search(r"a.b","a b").group()             #.可匹配空格

'a b'

>>> re.search(r"f.b","df45b")                  #返回值为空，因为.只能匹配两者之间的一

>>>                                      #个字符

>>> re.search(r"a.b","a\nb").group()            #.不可匹配回车

Traceback (most recent call last):

File "<stdin>", line 1, in <module>

AttributeError: 'NoneType' object has no attribute 'group'

>>> re.search(r".b","df4b").group()             #.前面没有字母，可以匹配任何字母，只会

'4b'                                        #匹配前面的一个字符

>>> re.search(r"f.","df4b").group()              #.后面没有字母，可以匹配任何字母，只

'f4'                                         #会匹配后面的一个字符

5) a.*b匹配ab之间所有的字符

>>> re.search(r"a.*b","djgdja*&82364}{?>_bdjfhd").group()

'a*&82364}{?>_b'

>>> re.search(r"a.*b","djgdja*&82364}{?>_bdjfhddfdfdb").group()

'a*&82364}{?>_bdjfhddfdfdb'                #正则的贪婪性，匹配最多的ab之间的字符

>>> re.search(r"a.*?b","djgdja*&82364}{?>_bdjfhddfdfdb").group()

'a*&82364}{?>_b'                          #抑制正则的贪婪性，会滤掉后面的，只输出前面的ab之间的所有的内容

9、量词

1) + 匹配1次或多次

>>> re.search(r"\d+","dfg124df567").group() #匹配多个连续的数字

'124'

>>> re.search(r"\d+","dfg1df567").group()       #匹配一个数字

'1'

>>> re.search(r"\s+","\t \n \r djdjdj123").group()  #匹配多个连续的空格

'\t \n \r '

>>> re.search(r"\S+","!@#$GSFD DKF ").group()

'!@#$GSFD'

#尽量多的匹配，正则表达式的贪婪性

2) ? 最小匹配(抑制正则表达式的贪婪性)

>>> re.search(r"\w+?","!@#$GSFD DKF ").group()  #？最小匹配(1个)，抑制贪婪性

'G'

>>> re.search(r"\w+","!@#$GSFD DKF ").group()   #不加？,可匹配一个或多个

'GSFD'

3) * 匹配0次或多次

>>> re.search(r"\w*","!@#$GSFD DKF ").group()   #从头开始匹配，第一个字符是！，匹配了

''                                           #0次，所以返回为空

>>> re.search(r"\w*","GSFD DKF ").group()

'GSFD'

4) 匹配固定长度{}

>>> re.search(r"\w{3}","!@#$GSFD DKF ").group() #4+3，最先匹配4中的前3个

'GSF'

>>> re.search(r"\w{3}","!@#$DF %$DJS").group()  #2+3，会匹配后面的3

'DJS'

5) 匹配可变范围长度的

>>> re.search(r"\w{2,3}","!@#$DF %$DJS").group() #匹配2-3次同时满足的字符串

'DF'

>>> re.search(r"\w{1,4}","!@#$Df %$DJS").group() #匹配1-4个满足条件的

'Df'

6）设定最小匹配长度

>>> re.search(r"\w{3,}","!@#$Df %$DJS").group()  #匹配大于等于3次的正则

'DJS'

7) 设定最大匹配长度

>>> re.search(r"\w{,4}","!@#$Df %$DJS").group() #{,3}表示匹配0-3次，所以返回的是空

''

8) ? 0次或1次

>>> re.search(r"\w?","!@#$Df %$DJS").group()  #匹配0次

''

>>> re.search(r"\w?","Df %$DJS").group()       #匹配1次

'D'

>>> re.findall(r"\w?","Df %$DJS")              #findall会进行每个字母的匹配，未匹配上便返回“”，到最后一个字母后，默认还会进行一次匹配

['D', 'f', '', '', '', 'D', 'J', 'S', '']

小练习：

输入字符串，如果字符串中有“ok”,则打印找到了，如果没有找到，则结束

>>> a = input("请输入一个字符串：")

请输入一个字符串：How are you?

>>> if re.search("ok",a):

...     print("找到了")

... else:

...     print("输入的字符串中没有ok")

...

输入的字符串中没有ok

>>> a = input("请输入一个字符串：")

请输入一个字符串：I am ok!

>>> if re.search("ok",a):

...     print("找到了")

... else:

...     print("输入的字符串中没有ok")

...

找到了