python正则不区分大小写 python 正则判断

正则表达式

正则表达式是一个特殊的字符序列，能方便的检查一个字符串是否与某种模式匹配，通过正则表达式来匹配文本模式能让代码变得十分简洁。

假设你希望在字符串中查找电话号码，模式为：3 个数字，一短横线，3个数字，一短横线，4 个数字。例如：415-555-4242，现在我们使用用正则表达式来匹配该电话号码。

在Python中，d 是一个正则表达式，表示一位数字字符，即任何一位 0 到 9 的数字。Python 使用正则表达式只要通过编写正则表达式ddd-ddd-dddd，就能匹配形似415-555-4242的电话号码。

正则表达式常用操作符

^[A-Za-z]+$：由26个字母组成的字符串
^-?d+$：整数形式的字符串
^[0-9] * [1-9] [0-9] *$：正整数形式的字符串
[1-9]d{5}：中国境内邮政编码，6位
[u4e00-u9fa5]：匹配中文字符
d{1,3}.d{1,3}.d{1,3}.d{1,3}：匹配IP地址

Re库的基本使用

re 模块使 Python 语言拥有全部的正则表达式功能。compile 函数根据一个模式字符串和可选的标志参数生成一个正则表达式对象，该对象拥有一系列方法（re.match( )，re.search( )...)用于正则表达式匹配和替换。

创建正则表达式对象

compile 函数用于编译正则表达式，生成一个正则表达式（ Pattern ）对象，供 re模块功能函数使用。

语法格式为：re.compile(pattern, flags)

• [ ] pattern : 一个字符串形式的正则表达式；
• [ ] flags 可选，表示匹配模式，比如忽略大小写，多行模式等。

正则表达式可以包含一些可选标志修饰符（flags ）来控制匹配的模式，如下：

# 创建匹配邮政编码正则表达式，例如100081。r'...'排除转义字符的干扰
pattern = re.compile(r'[1-9]d{5}')

Re库的主要功能函数

re.match( )函数

从字符串的起始位置开始匹配，并返回一个匹配对象，如果不是起始位置匹配成功的话，match( )就返回none。

函数语法： re.match(pattern， string，flags=0)

函数参数说明

匹配成功re.match方法返回一个匹配的对象，否则返回None。我们可以使用匹配对象的方法来获取匹配表达式。

匹配对象方法

import re
pattern = re.compile(r'[1-9]d{5}')
match = re.match(pattern,'BIT 100081')
if match:
    print(match.group(0))

输出结果：
None

import re
pattern = re.compile(r'[1-9]d{5}')
match = re.match(pattern,'100081 BIT')
if match:
    print(match.group(0))

输出结果：
100081

为了更好理解匹配对象方法，再举两个实例。

import re
pattern = re.compile(r'd+')                    # 用于匹配至少一个数字
m = pattern.match('one12twothree34four')        # 查找头部，没有匹配
print( m )

输出结果：
None

m = pattern.match('one12twothree34four', 2, 10) # 从'e'的位置开始匹配，没有匹配
print( m )

输出结果：
None

m = pattern.match('one12twothree34four', 3, 10) # 从'1'的位置开始匹配，正好匹配
print(m)                                        # 返回一个 Match 对象
print(m.group(0))   # 可省略 0
print(m.start(0))   # 可省略 0
print(m.end(0))     # 可省略 0
print(m.span(0))    # 可省略 0

输出结果：
<re.Match object; span=(3, 5), match='12'>
12
3
5
(3, 5)

import re

# ()用于分组标记，此处有两个分组，re.I 表示忽略大小写
pattern = re.compile(r'([a-z]+) ([a-z]+)', 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))                            # 返回匹配成功的整个子串
print(m.span(0))                             # 返回匹配成功的整个子串的索引
print(m.group(1))                            # 返回第一个分组匹配成功的子串
print(m.span(1))                             # 返回第一个分组匹配成功的子串的索引
print(m.group(2))                            # 返回第二个分组匹配成功的子串
print(m.span(2))                             # 返回第二个分组匹配成功的子串索引
print(m.groups())                            # 等价于 (m.group(1), m.group(2), ...)

输出结果：
Hello World
(0, 11)
Hello
(0, 5)
World
(6, 11)
('Hello', 'World')

print(m.group(3) )                           # 不存在第三个分组

输出结果：
Traceback (most recent call last):
  File "E:test.py", line 13, in <module>
    print(m.group(3) )                           # 不存在第三个分组
IndexError: no such group

扫描整个字符串，匹配成功则返回的是一个匹配对象，search也只能匹配到一个，找到符合规则的就返回，不会一直往后找。

函数语法：re.search(pattern，string，flags=0)

import re
pattern = re.compile(r'[1-9]d{5}')
match = re.search(pattern,'BIT 100081')
if match:
    print(match.group(0))

输出结果：
100081

re.findall( )函数

在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果没有找到匹配的，则返回空列表。

函数语法： re.findall(pattern，string，flags=0)

注意：

import re
pattern = re.compile(r'[1-9]d{5}')
ls=re.findall(pattern,'BIT100081 TSU100084')
print(ls)

输出结果：
['100081', '100084']

re.split( )函数

将匹配的部分删去，将剩余的字符串分割后返回列表。

函数语法：re.split(pattern，string，maxsplit=0，flags=0)

参数maxsplit代表分隔次数，maxsplit=1 分隔一次，默认为 0，不限制次数。

import re
pattern = re.compile(r'[1-9]d{5}')
ls = re.split(pattern,'BIT100081 TSU100084')
print(ls)

输出结果：
['BIT', ' TSU', '']

import re
pattern = re.compile(r'[1-9]d{5}')
# maxsplit=1 只匹配第一个，剩余部分作为最后一个元素输出
ls = re.split(pattern,'BIT100081 TSU100084',maxsplit=1) 
print(ls)

输出结果：
['BIT', ' TSU100084']

re.finditer( )函数

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

函数语法：re.finditer(pattern，string，flags=0)

import re
pattern = re.compile(r'[1-9]d{5}')
for m in re.finditer(pattern,'BIT100081 TSU100084'):
    if m:
        print(m.group(0))

输出结果：
100081
100084

re.sub( )函数

在一个字符串中替换所有匹配正则表达式的子串，返回替换后的字符串

函数语法：re.sub(pattern，repl，string，count=0，flags=0)

参数repl代表替换匹配字符串的字符串；参数count代表匹配的最大替换次数，默认 0 表示替换所有的匹配。

import re
pattern = re.compile(r'[1-9]d{5}')
strings = re.sub(pattern,':zipcode','BIT100081 TSU100084')
print(strings)

输出结果：
BIT:zipcode TSU:zipcode

Re库的最小匹配与贪婪匹配

Re库默认采用贪婪匹配的方式，即输出匹配最长的子串。

# 贪婪匹配
import re
pattern = re.compile(r'sa.*n')
match = re.search(pattern,'sanmanong')
if match:
    print(match.group(0))

输出结果：
sanmanon

# 最小匹配
import re
pattern = re.compile(r'sa.*?n') # 与上面正则表达式相比多了一个？
match = re.search(pattern,'sanmanong')
if match:
    print(match.group(0))

输出结果：
san

问号在正则表达式中可能有两种含义：声明最小匹配或表示可选的分，这两种含义是完全无关的。

最小匹配操作符

精心梳理的Python正则表达式知识点，希望对大家学习有帮助。