python——正则表达式

目录

  • 一正则表达式的引入
  • 二正则表达式的介绍和查找
    • (1)正则表达式的分组
    • (2)正则表达式查找常用的函数
      • re.match(pattern, string, flags=0)
      • re.search(pattern, string, flags = 0)
      • re.findall(pattern, string, flags = 0)
      • re.finditer(pattern, string, flags = 0)
      • re.sub(pattern, repl, string, count, flags)
      • re.split(pattern, string, maxsplit, flags)
  • 三re.Match类
  • 四re.compile方法的使用
  • 五 正则表达式的字符和特殊字符
  • 六 正则表达式的模式修饰符
  • 七 正则表达式贪婪与非贪婪

一正则表达式的引入

#需求:封装一个功能,判断用户输入的手机号码是否合法?
def checkPhone(phone):
    if len(phone) != 11:
        print('手机号码不是十一位')
        return
    if phone[0] != '1':
        print('手机号码开头不是1')
        return
    if not phone.isdigit():
        print('手机号码不是全部是数字')
        return
    print('该手机号码是正确的')
    checkPhone(112233)

使用正则表达式:

import re#需要引用re模块

result = re.search("^1\d{10}$", "12345678901")#^ 表示从什么开始(^1表示从1开始) \d表示0~9之间的数字   {10}表示出现次数为10位$结束
if result:
    print('手机号码合法')
else:
    print('手机号码不合法')
输出:
手机号码合法

二正则表达式的介绍和查找

正则表达式:是一个特殊的字符序列,通常用来检索,替换那些符合某个模式(规则)的文本
在python中需要通过正则表达式对字符串进行匹配的时候,可以使用re模块。re模块使python语言拥有全部的正则表达式功能。
应用场景:
爬虫
验证手机号码,身份证号码邮箱等
数据分析的数据清洗或者整理

\d 表示0~9之间的任意数字
+ 表示可以出现一次或者多次

正则表达式中使用 \ 作为转义字符,如果需要匹配文本中的字符 \ ,则使用编程语言表示的正则表达式里需要4个反斜杠 \ :前两个和后两个分别用于在编程语言里转义成反斜杠,转换成反斜杠后再在正则表达式里转义成一个反斜杠。

(1)正则表达式的分组

#匹配0-100数字
n = '100'
result = re.match(r'[1-9]?\d?$|100$', n)#|  表示或者
print(result)#
#验证邮箱  163  126 qq
email = '[email protected]'
result = re.match(r'\w{5,20}@(163|126|qq)\.(com|cn)$', email)#(word|word|word) 表示或者  [abc]表示一个字母而不是一个单词
print(result)#

result.group()获取组中匹配内容
相关方法:
起名方式:(?P<名字>正则) (?P=名字)
不需要引用分组内容:

msg = '

abc

'
msg1 = '

hello

'
result = re.match(r'<[0-9a-zA-Z]+>(.+), msg) print(result)# 输出: print(result.group(1))#输出:

abc

需要引用分组匹配的内容
1、number \number 引用第number组的数据

msg = '

abc

'
result = re.match(r'<([0-9a-zA-Z]+)><([0-9a-zA-Z]+)>(.+)$', msg) print(result)#

2、?P<名字>

msg = '

abc

'
result = re.match(r'<(?P\w+)><(?P\w+)>(.+)', msg) print(result)# print(result.group(1))#html

(2)正则表达式查找常用的函数

re.match(匹配字符串是否以指定的正则内容开头)
re.search(扫描整个字符串,找到第一个匹配)
re.findall(扫描整个字符串,找到所有的匹配)
re.finditer(扫描整个字符串,找到所有匹配的,并返回一个可迭代对象)
re.sub(正则表达式,‘新内容’, string)(扫描整个字符串,新内容替换正则内容指定的内容)
re.split(在字符串中搜素,对指定的内容进行分割)

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

匹配成功返回对象,匹配失败返回None

pattern:匹配的正则表达式
string:要匹配(验证)的字符串
flags: 标志位,用于控制正则表达式的匹配方式,如:是否区分大小写,多 行匹配等

可以使用group(num)函数来获取匹配的表达式, group()用来提出分组截获的字符串

import re
print(re.match("\d+", "123asd"))#验证成功后返回的对象
print(re.match("\d+", "hello12345"))

result1 = re.match(r'H', 'Hello')
result2 = re.match(r'e', 'Hello')
print(result1.group(0))#'H'p匹配到的元素
print(result1.span())#(0, 1)匹配到的元素所在位置
print(result2)

输出:
<re.Match object; span=(0, 3), match='123'>
None
H
(0, 1)
None

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

匹配成功返回对象,匹配失败返回None

import re
print(re.search('\d+', '123asd98'))#
print(re.search('\d+', 'hello12345'))
result1 = re.search(r'He', 'Hello')
result2 = re.search(r'lo', 'Hello')
print(result1.group(0))
print(result1.span())
print(result2.group(0))
print(result2.span())

输出:
<re.Match object; span=(0, 3), match='123'>
<re.Match object; span=(5, 10), match='12345'>
He
(0, 2)
lo
(3, 5)

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

在字符串中找到正则表达式所匹配的所有子串,并返回一个列表,如果没有找到匹配的,则返回空列表。
注意: match 和 search 是匹配一次 findall 匹配所有。

ret = re.findall('\d+', 'he23ll34')
print(ret)
ret = re.match('\d+', 'he23ll34')
print(ret)
ret = re.search('\d+', 'he23ll34')
print(ret)

msg = 'abcd7v jkfd8hdf00'
result = re.search('[a-z][0-9][a-z]', msg)#  只要有1个匹配的后面就不会继续检索
print(result.group())#d7v
result = re.findall('[a-z][0-9][a-z]', msg)#  匹配整个字符串,一直到结尾
print(result)#['d7v', 'd8h']
输出:
['23', '34']
None
<re.Match object; span=(2, 4), match='23'>
d7v
['d7v', 'd8h']

注意:
findall方法匹配时,如果匹配规则里有分组,则只匹配分组数据

ret = re.findall(r'\w+@(qq|126|163)\.com', '[email protected];[email protected];[email protected]')
print(ret)#['qq', '163', '126']

如果正则表达式里存在多个分组,则会把多个分组匹配成元组

ret = re.findall(r'\w+@(qq|126|163)(\.com)', '[email protected];[email protected];[email protected]')
print(ret)#[('qq', '.com'), ('163', '.com'), ('126', '.com')]

如果想要让findall匹配所有的内容,而不仅仅只是匹配正则表达式里的分组,可以使用 ?:来将分组标记为非捕获分组。

ret = re.findall(r'\w+@(?:qq|126|163)(\.com)', '[email protected];[email protected];[email protected]')
print(ret)#['.com', '.com', '.com']

ret = re.findall(r'\w+@(?:qq|126|163)\.com', '[email protected];[email protected];[email protected]')
print(ret)#['[email protected]', '[email protected]', '[email protected]']

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

和 findall 类似,在字符串中找到正则表达式所匹配的所有子串,并把它们作为一个迭代器返回。

ret = re.finditer(r'\d+', 'he123456')# 得到的结果是一个可迭代对象
for x in ret:# 遍历 ret 取出里面的每一项匹配
    print(x.group(), x.span())#123456 (2, 8)# 匹配对象里的group保存了匹配的结果

ret = re.finditer(r'\d', 'he123456')
for x in ret:
    print(x.group(), x.span())
输出:
123456 (2, 8)
1 (2, 3)
2 (3, 4)
3 (4, 5)
4 (5, 6)
5 (6, 7)
6 (7, 8)

re.sub(pattern, repl, string, count, flags)

result = re.sub(r'\d+', '90', 'java:99,python:100')
print(result)#java:90,python:90
def func(temp):
    num = temp.group()
    num1 = int(num) + 1
    return str(num1)

result = re.sub(r'\d+', func, 'java:99,python:100')
print(result)#java:100,python:101

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

将分割的内容保存到列表中

result = re.split(r'[,:]', 'java:99,python:100')
print(result)#['java', '99', 'python', '100']

三re.Match类

相关属性:
pos 搜索的开始位置
endpos 搜索的结束位置
string 搜索的字符串
re 当前使用的正则表达式的对象
lastindex 最后匹配的组索引
lastgroup 最后匹配的组名
group(index=0) 某个分组的匹配结果。如果index等于0,便是匹配整个正则表达式
groups() 所有分组的匹配结果,每个分组的结果组成一个列表返回
groupdict() 返回组名作为key,每个分组的匹配结果座位value的字典
start([group]) 获取组的开始位置
end([group]) 获取组的结束位置
span([group]) 获取组的开始和结束位置
expand(template) 使用组的匹配结果来替换模板template中的内容,并把替换后的字符串返回

ret = re.search('(abc)+', 'xxxabcabcabcdef')
print(ret.pos) # 搜索开始的位置,默认是0
print(ret.endpos)# 搜索结束的位置,默认是字符串的长度
print(ret.group(0))# abcabcabc 匹配整个表达式
print(ret.group(1))# abc 第一次匹配到的结果
print(ret.span())#(3, 12) 开始和结束位置
print(ret.groups())# 表示当正则表达式里有多个分组时,多个分组的匹配结果
输出:
0
15
abcabcabc
abc
(3, 12)
('abc',)

四re.compile方法的使用

我们在使用正则表达式时,可以直接调用re 模块的 match,search,findall等方法,传入指定的正则表达式。同时,也可以调用re.compile方法,生成一个正则表达式对象,再调用这个正则表达式对象的相关方法实现匹配

msg = '娜扎热巴黛丝佟丽娅'

pattern = re.compile('佟丽娅')
result = pattern.search(msg)
print(result)
输出:
<re.Match object; span=(6, 9), match='佟丽娅'>

五 正则表达式的字符和特殊字符

\b 匹配一个单词边界也就是指单词和空格间的位置

msg = 'aa*py ab.txt bb.py kk.png uu.py apyb.txt'
result = re.findall(r'\w+\.py\b', msg)#  .前面的\表示转义
print(result)#['bb.py', 'uu.py']

\B 非单词边界

\d 匹配数字,0~9之间任意的数字,等同于[0 ~9]

print(re.search('he\dllo', 'he8llo'))#
print(re.search('he[0-9]llo', 'he9llo'))#
print(re.search('he\dllo', 'heallo'))#None

\D 匹配非数字字符,可以理解为对\d取反 等同于[^ 0 - 9 ]

print(re.search('hello\D', 'hello1'))#None
print(re.search('hello\D', 'hello_'))#
print(re.search('hello\D', 'helloS'))#

\w 匹配数字,字母,下划线 等同于 [0-9a-zA-Z_ ]

print(re.search('hello\w', 'hello!'))#None
print(re.search('hello\w', 'hello9'))#
print(re.search('hello\w', 'hellowe'))#   只匹配一个
print(re.search('hello\w', 'helloD'))#
print(re.search('hello\w', 'hello_'))#

\W 匹配非数字,字母,下划线 等同于 [^0-9a-zA-Z_ ]

print(re.search('hello\W', 'hello!'))#
print(re.search('hell\W', 'hello9'))#None


\s 匹配任意的空白字符 (空格,回车,换行,制表符,换页)等同于[ \r \n \t \f]
\S 匹配任意的非空白字符 (空格,回车,换行,制表符,换页)等同于[ ^ \r \n \t \f]

#\t  是空格
print(re.search('he\sllo', 'he\tllo'))#
print(re.search('he\Sllo', 'he\tllo'))#None

^ 开头
–表示一个区间
. 表示匹配除了换行符之外的任意字符
$ 表示匹配到结尾
* 用于将前面模式匹配0次或者多次(贪婪模式,即尽可能多的匹配)》=0
+ 用于将前面的模式匹配1次或多次(贪婪模式)>=1
? 用于将前面的模式匹配0次或1次(贪婪模式)0,1
{m} 用于验证将前面的模式匹配m次
{m,} 用于验证将前面的模式匹配m次或多次 >=m
{m,n} 用于验证将前面的模式匹配大于等于m次且小于等于n次
(word|word|word) 表示或者 | 表示或者
[abc]表示一个字母而不是一个单词
[ ] 表示范围,用于表示一组字符,如果^ 是第一个字符,则表示的是一个补集。比如 [0-9]表示所有数字 [^ 0-9]表示除了数字外的字符
*? +? ??是 * + ?的非贪婪模式(尽可能少的匹配)

六 正则表达式的模式修饰符

用来修饰正则表达式,是一个可选参数
re.S 可以使正则表达式中的 ’ . ’ 匹配到换行符

import re
print(re.search('shenzhen.', 'shenzhen9'))#
print(re.search('shenzhen.', 'shenzhen\n'))#None
print(re.search('shenzhen.', 'shenzhen\n', re.S))#

re.I 表示正则表达式在匹配后面的内容时忽略大小写。

print(re.search('shenzhen[a-z]', 'shenzhenM'))#None
print(re.search('shenzhen[a-z]', 'shenzhenM', re.I))#

re.M 多行匹配,影响 ^ 和 $ ,每个换行都认为是一个结尾
\w+$ 表示匹配以一个或者多个字母结尾

print(re.findall(r'\w+$', 'i am boy\n you are girl\n he is man\n', re.M))#['boy', 'girl', 'man']
print(re.findall(r'\w+$', 'i am boy\n you are girl\n he is man\n'))#['man']

七 正则表达式贪婪与非贪婪

python里的数量词默认是贪婪的,总是尝试匹配尽可能多的字符
在非贪婪里则相反,总是尝试匹配尽可能少的字符
在“ * ” “ ?” “+” “{m,n}”后面加上?,是贪婪变成非贪婪

#贪婪模式
msg = 'abc123abc'
result = re.match(r'abc(\d+)', msg)
print(result)#输出:
#非贪婪模式
msg1 = 'abc123abc'
result = re.match(r'abc(\d+?)', msg1)
print(result)#输出:

你可能感兴趣的:(python,正则表达式,开发语言)