绍兴网站设计公司企业网站建设的步骤

1.正则表达式

1.1含义：记录文本规则的代码，字符串处理工具

注意：需要导入re模块

1.2特点：

1.语法比较负杂，可读性较差

2.通用性很强，适用于多种编程语言

1.3步骤：

1.导入re模块   import re

2.使用match方法进行匹配操作

re.match()能匹配出以XXX开头的字符串，如果起始位置没有匹配成功，则返回None

3.如果上一步匹配成功使用group()提取数据

re.match(pattern,string)    pattern--匹配正则表达式     string--要匹配的字符串

import reres = re.match('pa','panda')
print(res)          #<re.Match object; span=(0, 2), match='pa'>
print(res.group())  #pa

import reres = re.match('pa','apnda')
print(res)          #None

注意：match是从开始位置匹配数据，匹配不到就没有

2.匹配单个字符

字符	功能
.	任意匹配一个字符，除\n
[ ]	匹配[ ]中列举的字符
\d	匹配数字，即0-9
\D	匹配非数字，即不是数字
\s	匹配空白，即空格，tab键
\S	匹配非空白
\w	匹配单词字符，即a-z，A-Z，0-9，_，汉字
\W	匹配非单词字符

2.1  .   任意匹配一个字符，除\n --常用

import re
res = re.match('.a.','panda')
print(res)          
print(res.group())   #pan

2.2 [ ] 匹配[ ]中列举的字符  --常用

import re
res = re.match('[hepa]','panda')
print(res)
print(res.group())   #p

匹配0-9

写法一：

import re
res = re.match('[0123456789]','26378')
print(res)
print(res.group())   #2

写法二：

import re
res = re.match('[0-9]','26378')
print(res)
print(res.group())   #2

import re
res = re.match('[0-45-9]','26378')
print(res)
print(res.group())   #2

a-zA-Z代表列举出所有的大小写字母

2.3 \d匹配数字0-9   --常用

import re
res = re.match('\d\d','76382')
print(res)
print(res.group())   #76

2.4\D匹配非数字  --常用

import re
res = re.match('\D\D\D','<_panda')
print(res)
print(res.group())   #<_p

 2.5 \s匹配空白 及空格和tab键

import re
res = re.match('.\s\s..','h   ello')
print(res)
print(res.group())   #h   e

2.6 \S匹配非空白

import re
res = re.match('.\S\S..','h13.(ello')
print(res)
print(res.group())   #h13.(

2.7 \w匹配单词字符，匹配单词字符，即a-z，A-Z，0-9，_，汉字

import re
res = re.match('.\w\w..','h_爱ello')
print(res)
print(res.group())   #h_爱el

2.8 \W匹配非单词字符

import re
res = re.match('\W\W','。￥llo')
print(res)
print(res.group())   #。￥

3.匹配多个字符

字符	功能
*	匹配前一个字符，出现0次或者无数次，即可有可无
+	匹配前一个字符，出现1次或者无数次，即至少一次
?	匹配前一个字符，出现1次或者0次
{m}	匹配前一个字符，出现m次
{m,n}	匹配前一个字符从m次到n次

3.1* 匹配前一个字符，出现0次或者无数次，即可有可无   --常用

import re
res = re.match('\w*','pandan')
print(res.group())     #panda

3.2+匹配前一个字符，出现1次或者无数次，即至少一次（小于1次会报错）    --常用

import re
res = re.match('\w+','pandan')
print(res.group())     #pandares = re.match('\S+','pandan')
print(res.group())     #pandares = re.match('\d+','01pandan')
print(res.group())     #01

3.3？匹配前一个字符，出现1次或者0次    --常用

import re
res = re.match('\w?','pandan')
print(res.group())     #pres = re.match('\S?','p1ms6kjn')
print(res.group())     #pres = re.match('\d?','pandan')
print(res.group())     #None

3.4{m}匹配前一个字符，出现m次

import re
res = re.match('\w{3}','pandan')
print(res.group())     #panres = re.match('\S{5}','p1ms6kjn')
print(res.group())     #p1ms6res = re.match('\d{0}','pandan')
print(res.group())     #None

3.5{m，n}匹配前一个字符从m次到n次

注意：必须满足m<n,总的可以匹配的数多于n个则匹配n个，总数小于n时，匹配的数要在m,n之间，有多少个匹配多少个。

import re
res = re.match('\w{3,4}','pandan')
print(res.group())     #pandres = re.match('\S{1,5}','p1ms6kjn')
print(res.group())     #p1ms6res = re.match('\w{2,7}','pandan')
print(res.group())     #panda

4.匹配开头结尾

4.1^

4.1.1 ^匹配开头字符串，表示以……开头，对……取反

import re
res = re.match('^p','python')
print(res.group())     #p
res = re.match('^py','python')
print(res.group())     #py
res = re.match('^py','ython')
print(res.group())     #报错

4.1.2 ^在[ ] 中表示不匹配（即表示除了[ ]内的匹配开头字符）

import re
res = re.match('[^p]','thonpy')
print(res.group())     #t
res = re.match('[^py]','panda')
print(res.group())     #报错
res = re.match('[^py]','%.1qm')
print(res.group())     #%

4.2 $ 匹配字符串结尾，表示以……结尾

import re
res = re.match('.*y$','thonpy')
print(res.group())     #thonpy
res = re.match('\S*da$','panda')
print(res.group())     #panda
res = re.match('..1$','%.1qm')
print(res.group())     #报错

5.匹配分组

|	匹配左右任意一个表达式
(ab)	将括号中字符做一个分组
\num	引用分组num匹配到的字符串
(?P<name>)	分组起别名
(?P=name)	引用别名为name分组匹配到的字符串

5.1 | 匹配左右任意一个表达式

import re
res = re.match('abc|csdn','abc')
print(res.group())   #abc
res = re.match('panda|monkey','key')
print(res.group())   #报错
res = re.match('cn|en|com','com')
print(res.group())   #com

5.2 （ab） 将括号中字符做一个分组

import re
res = re.match('w{3}\.\w*.(123|985|m73)\Sen','[e-mail]')
print(res.group())    #[e-mail]

\. ：表示匹配.

5.3  \num 引用分组num匹配到的字符串（经常在匹配标签时被使用）

import re
res = re.match(r'<(html)><(body)>login</\2></\1>','<html><body>login</body></html>')
print(res.group())    #<html><body>login</body></html>

注意：从外到内排序，编号从1开始

5.4  (?P<name>) 分组起别名

5.5 (?P=name)引用别名为name分组匹配到的字符串

import re
res = re.match(r'<(?P<L1>\w*)><(?P<L2>\w*)>\w*</(?P=L2)></(?P=L1)>','<html><body>login</body></html>')
print(res.group())    #<html><body>login</body></html>

 综合使用：

网址前缀一般为www，后缀.com、.cn、.org

import re
li = ['www.baidu.com','www.python.org','http.jd.cn','www.abc.cn']
for i in li:res = re.match(r'w{3}(\.)\w*\1(com|org|cn)', i)if res:print(res.group())else:print(f"{i}错误")

 

6.高级用法

6.1 search():扫描整个字符串并返回第一个成功匹配的对象，如果匹配失败，就返回None

import re
res = re.search('th','pythonth')
print(res.group())   #th
res = re.search('.','pythonth')
print(res.group())   #p
res = re.search('.*','pythonth')
print(res.group())   #pythonth

6.2 findall():以列表的形式返回整个字符串所有匹配到的字符串（如果匹配失败则返回一个空列表）

import re
res = re.findall('th','pythonth')
print(res)   #['th', 'th']
res = re.findall('.','pythonth')
print(res)   #['p', 'y', 't', 'h', 'o', 'n', 't', 'h']
res = re.findall('.*','pythonth')
print(res)   #['pythonth', '']
res = re.findall('\d','pythonth')
print(res)   #[]

 总结：

1.match()从开头开始匹配，匹配成功返回match对象，通过group()进行提取，匹配失败就返回None，只匹配一次

2.search()从头到尾匹配，匹配成功就返回第一个匹配成功的对象，通过group进行提取，匹配失败则返回None，只匹配一次

3.findall()从头到尾匹配，匹配成功返回一个列表，匹配所有匹配成功的数据，不需要经过group()进行提取，没有group

6.3 sub():将匹配到的数据进行替换

sub(pattern,repl,string,count)

     pattern--正则表达式

     repl--新内容

     string--字符串

     count--指替换的次数

import re
res = re.sub('world','python','hello world')
print(res)    #hello python
res = re.sub('world','python','hello world world world',2)
print(res)    #hello python python world
res = re.sub('\d','1','今天是28号')
print(res)    #今天是11号
res = re.sub('\d','1','今天是28号',1)
print(res)    #今天是18号

6.4 split():根据匹配进行切割字符串，并返回一个列表

split(pattern,string,maxsplit)

     pattern--正则表达式

     string--字符串

     maxsplit--指定最大分割次数

没有设置次数就默认全部分割

import re
res = re.split(',','good,morning')
print(res)      #['good', 'morning']
res = re.split('|','good,morning')
print(res)      #['', 'g', 'o', 'o', 'd', ',', 'm', 'o', 'r', 'n', 'i', 'n', 'g', '']
res = re.split(',','nice,to,meet,you',2)
print(res)      #['nice', 'to', 'meet,you']

7.贪婪与非贪婪

贪婪匹配：在满足匹配时，匹配尽可能长的字符串，在默认情况下，采用贪婪匹配

非贪婪匹配：在满足匹配时，匹配尽可能短的字符串，使用?来表示非贪婪匹配

import re
res = re.match('ing*','inggggggg')
print(res.group())   #inggggggg
res = re.match('ing*?','inggggggg')
print(res.group())   #in
res = re.match('g*?','ggggggg')
print(res.group())   #None
res = re.match('g{1,5}','ggggggg')
print(res.group())   #ggggg
res = re.match('g{1,5}?','ggggggg')
print(res.group())   #g

8.原生字符串

Python中，在字符串前面加上r表示原生字符串

正则表达式中匹配自促传中字符\需要\\\\，加上r后只需要\\

import re
res = re.match('\\\\','\pdf')
print(res.group())   #\
import re
res = re.match(r'\\\\',r'\\pdf')
print(res.group())   #\\