python正则表达式不分大小写 python 正则忽略大小写

• 正则表达式是一个特殊的字符序列，方便检查一个字符串是否与某种模式匹配。

re.compile

• 根据一个模式字符串和可选的标志参数生成一个正则表达式对象，该对象拥有一系列方法用于正则表达式匹配和替换。
• compile函数用于编译正则表达式，生成一个正则表达式（Pattern）对象，供match（）和search（）这两个函数使用
• 语法：re.compile(pattern[, flags])

• pattern：一个字符串形式的正则表达式
• flags：可选参数，表示匹配模式，比如忽略大小写，多行模式等，例如 re.I：忽略大小写

import re
pattern = re.compile(r'\w+')    # <class 're.Pattern'>正则表达式对象

ret = pattern.match('one12twothree34four',3,10)  
print(ret)  # <re.Match object; span=(3, 5), match='12'>

ret = pattern.search('one12twothree34four')
print(ret)	# <re.Match object; span=(3, 5), match='12'>
ret为re.Match object，即匹配对象

匹配对象有以下方法：

• group([group1, …]) 方法用于获得一个或多个分组匹配的字符串，当要获得整个匹配的子串时，可直接使用 group() 或 group(0)；
• start([group]) 方法用于获取分组匹配的子串在整个字符串中的起始位置（子串第一个字符的索引），参数默认值为 0；
• end([group]) 方法用于获取分组匹配的子串在整个字符串中的结束位置（子串最后一个字符的索引+1），参数默认值为 0；
• span([group]) 方法返回 (start(group), end(group))。

pattern = re.compile(r'([a-z]+) ([a-z]+)', re.I)   # re.I 表示忽略大小写
m = pattern.match('Hello World Wide Web')
print(m)   # 匹配成功，返回一个Match对象 <re.Match object; span=(0, 11), match='Hello World'>
print(m.group(0))    # Hello World 返回匹配成功的整个子串
print(m.group(1))    # Hello 返回第一个分组匹配成功的子串
print(m.group(2))    # World 返回第二个分组匹配成功的子串
print(m.groups(0))   # ('Hello', 'World')
print(m.span(0))    # (0, 11) 返回匹配成功的整个子串的索引
print(m.span(1))    # (0, 5) 返回第一个分组匹配成功的子串的索引
print(m.span(2))    # (6, 11) 返回第二个分组匹配成功的子串的索引

re.match

• 从字符串的起始位置对模式进行匹配，如果匹配成功，则返回一个匹配对象；如果匹配失败，返回None。匹配对象的group()方法能显示成功匹配的对象。
• 语法：re.match(pattern, string, flags=0)

• pattern 匹配的正则表达式，直接传入一个字符串，python会将该字符串作为正则表达式来对待
• string 要匹配的字符串
• flags 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。

import re
ret = re.match("hello","hello word") 
或ret = pattern.match('hello word')
print(ret)  #<re.Match object; span=(0, 5), match='hello'> 匹配对象
print(ret.group())  # hello 使用group()方式返回对应的分组
print(ret.start())	# 0
print(ret.end())	# 5
print(ret.span())  # (0, 5)

re.search

• 扫描整个字符串并返回第一个成功的匹配
• 语法：re.match(pattern, string, flags=0)

import re
ret = re.search("com","www.baidu.com") 
或 pattern = re.compile('com')   ret = pattern.search('www.baidu.com')
print(ret)  # <re.Match object; span=(10, 13), match='com'> 匹配对象
print(ret.group())  # com 使用group()方式返回对应的分组
print(ret.start())	# 0
print(ret.end())	# 5
print(ret.span())  # (0, 5)

match和search区别

• re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，函数返回None
• re.search匹配整个字符串，直到找到一个匹配

re.findall

• 在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果没有找到匹配的，则返回空列表。
• match和search是匹配一次，findall是匹配所有
• 语法：findall(pattern, string, flags=0)

import re
ret = re.findall(r'\d+','run88oob123google456')
或 pattern = re.compile(r'\d+')   ret = pattern.findall('run88oob123google456')
print(ret)  # ['88', '123', '456']  <class 'list'> 列表

re.finditer

• 和findall类似，在字符串中找到正则表达式所匹配的所有字串，并把它们作为迭代器返回。
• 语法：re.finditer(pattern, string, flags=0)

import re
 
it = re.finditer(r"\d+","12a32bc43jf3")   # it为 <callable_iterator object at 0x0000029C1CCE7910>
for match in it: 
    print (match.group() )

re.sub

• re.sub用于替换字符串中的匹配项
• 语法：re.sub(pattern, repl, string, count=0, flags=0)

• pattern：正则中的模式字符串
• repl：（replace）替换的字符串，也可以为一个函数
• string：要被查找替换的原始字符串
• count：模式匹配后替换的最大次数，默认0表示替换所有的匹配

import re
phone = "2004-959-559 # 这是一个国外电话号码"
num = re.sub(r'#.*$', "", phone)
print(num)  # 2004-959-559

num = re.sub(r'\D', "", phone)
print(num) # 2004959559

re.split

• split 方法按照能够匹配的子串将字符串分割后返回列表
• 语法：re.split(pattern, string[, maxsplit=0, flags=0])

• pattern：匹配的正则表达式
• string：要匹配的字符串
• maxsplit：分隔次数，默认为0，不限制次数；maxsplit=1，分隔一次
• flags：可选参数

（根据'\W+'匹配出来的子串,,.作为分割符，进行原字符串的分隔）
re.split('\W+', 'runoob, runoob, runoob.')
# ['runoob', 'runoob', 'runoob', '']
re.split('\W+', 'runoob, runoob, runoob.', 1)
# ['runoob', 'runoob, runoob.']

正则表达式对象

• re.RegexObject

• re.compile()返回RegexObject（正则表达式）对象

• re.MatchObject

• group（）返回被re匹配的字符串；re.match,re.search返回的都是匹配对象
• start（）返回匹配开始的位置
• end（）返回匹配结束的位置
• span（）返回一个元组，包含匹配（开始，结束）的位置

正则表达式语法

• 字符组：

符号	描述
[0-9]	匹配数字
[a-z]	匹配小写字母
[A-Z]	匹配大写字母
[^0-9]	匹配除了数字外的字符

• 元字符：

符号	描述
\d	匹配数字
\w	匹配数字字母下划线
\s	匹配任何空白字符，包括空格、制表符、换页符等等
.	匹配除换行符外任意一个字符
^	匹配以某字符开头
$	匹配以某字符结尾
[]	字符组(只要在[]里面的都匹配)
[^]	非字符组(只要在[]里面的都不匹配)
()	分组

• 量词：

符号	描述
{n}	重复n次
{n,}	重复至少n次,n次以上
{n,m}	重复n-m次
?	0或1次
+	1到不限
*	0到不限

• 贪婪和惰性：

表达式	描述
a.*b	贪婪
a.*?b, a.+?b	惰性

• 贪婪匹配模式：

• 用到量词的匹配时,默认为贪婪模式
• 贪婪模式的意思就是匹配的时候,尽量多匹配,不行再慢慢的减少匹配

import re
lst = "\d{2,4}"
ret = re.search(lst,"12345abcd")
print(ret.group())
结果：
>>>1234

• 惰性匹配模式：

• 惰性匹配模式正好和贪婪模式相对
• 惰性匹配是尽量少的匹配,不行再慢慢去增加匹配的个数
• 惰性匹配只需要在量词后面添加?即可

import re
lst = "\d{2,4}?"
ret = re.search(lst,"12345abcd")
print(ret.group())
结果：
>>>12