Re库正则表达式，知识点，

regular expression regex RE 正则表达式

定义：用来简洁表达一组字符串的表达式

"PN"

"PYN""PYTN" 正则表达式表达这则数据:

"PYTHN" P(Y|YT|YTH|YTHO)?N

"PYTHON"

正则表达式的优势：简洁（非常简单的表达字符串的特征，一行胜千言）

"PY"

"PYY"

"PYYY" 正则表达式表示：（表示无穷多个）"PYYYY" PY+

......"PYYYYYY......"

某种特点的字符串

"PY"开头：

后续存在不多于10个字符串，正则表达式表示：

后续字符不能是"P"或"Y" PY[^PY]{0,10}"PYABC" √ "PYKXYZ" ×

正则表达式是通用的字符串表达框架

简洁表达一组字符串的表达式

针对字符串表达“简洁”和“特征”思想的工具

判断某字符串的特征归属

在文本处理中十分常用（主要应用于字符串匹配中）

表达文本类型的特征（病毒，入侵等）

同时查找或替换一组字符串

正则表达式的使用：编译：将符合正则表达式语法的字符串转换成正则表达式特征

"PN"

"PYN""PYTN" 正则表达式表达这则数据:

"PYTHN" regex= P(Y|YT|YTH|YTHO)?N"PYTHON" 编译（特征）：p = re.compile(regex)

语法：正则表达式语法由字符和操作符构成

常见操作符

表示任何单个字符

[ ]

字符集，对单个字符给出取值范围

[abc]表示a,b,c,

[a-z]表示a到z的单个字符[^ ]

非字符集，对单个字符给出排除范围

[^abc]表示非a或b或c的单个字符

前一个字符0次或无限次扩展

abc*表示ab，abc，abcc，abccc等

前一个字符1次或无限次扩展

abc+表示abc，abcc，abccc等

？

前一个字符0次或1次扩展（匹配）

abc？表示ab，abc

左右表达式任意一个

abc|def表示abc，def

{m}

扩展前一个字符m次（仅一个字符）

ab{2}c表示abbc

{m,n}

扩展前一个字符m至n次（含n）

ab{1,2}c表示abc，abbc

^匹配字符串开头

^abc表示abc且在一个字符串的开头

匹配字符串结尾

abc$表示abc且在一个字符串的结尾

( )

分组标记，内部只能使用 | 操作符

(abc)表示abc,(abc|def)表示abc,def

数字等价于|0-9|

匹配任意非数字

单词字符，等价于|A-Za-z0-9_|

匹配字母数字下划线

匹配非字母数字下划线

匹配任意空白字符，等价于[\t\n\r\f]

匹配任意非空字符

匹配字符串开始

匹配字符串结束，如果存在换行，只匹配到换行前的结束字符串

匹配字符串结束

正则表达式实例：对应字符串

PY[TH]ON "PYTON","PYHON"

PY[^TH]?ON "PYON","PYaON","PYbON","PYcON"...

PY{:3}N (对大括号签的字符重复0-3次） "PN","PYN","PYYN""PYYYN"

经典正则表达式实例

^[A_Za-z]+$

由26个字母组成的字符串

^[A-Za-z0-9]+$

由26个字母和数字组成的字符串

^-?\d+$

整数形式的字符串

^[0-9]*[1-9][0-9]*$

正整数形式的字符串

[1-9]\d{5}

中国境内邮政编码，6位

[\u4e00-\u9fa5]

匹配中文字符

\d{3}-\d{8}|\d{4}-\d{7}

国内电话号码，010-68913536

匹配IP地址的正则表达式

IP地址字符串形式的正则表达式

（IP地址分四段，每段0-255）

\d+.\d+.\d+.\d+

\d{1,3}.\d{1.3}.\d{1,3}.\d{1,3}

精确表示：

0-99 ： [1-9]?\d 100-199:1\d{2}

200-249 :2[0-4]\d 250-255: 25[0-5]

(([1-9]?\d|1\d{2}|2[0-4]\d|25[0-5].){3}(1-9]?\d|1\d{2}|2[0-4]\d|25[0-5])

RE库的基本使用

Re库是Python的标准库

import re

正则表达式的表示类型：

raw string 类型（原生字符串类型：不包含转义符的字符串）（原生字符串与字符串

的不同是在字符串前面+小写的r）

re库采用raw string类型表示正则表达式，表示为：r"text"

例如：邮编：r "[1-9]\d{5}"

注意：当正则表达式包含转义符时：使用raw string

re.search()

在一个字符串中搜索匹配正则表达式的第一位置，返回match对象

re.match()

从一个字符串的开始位置起匹配正则表达式，返回match对象

re.findall()

搜索字符串，以列表类型返回全部能匹配的子串

re.split()

讲一个字符串按照正则表达式匹配结果进行分割，返回列表类型

re.finditer()

搜索字符串，返回一个匹配结果的迭代类型，每个迭代元素是match对象

re.sub()

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

re.search(pattern,string,flags=0)在一个字符串中搜索匹配正则表达式的第一个位置，返回match对象pattern：正则表达式的字符串或原生字符串表示

string：待匹配字符串

flags：正则表达式使用时的控制标记

常用标记

说明

re.l

忽略正则表达式的大小写，[A-Z]能够匹配小写字符，

又叫：re.IGNORECASE

re.M

正则表达式中^操作符能够将给定的每行当作匹配开始

又叫：re.MULTILINE

re.s

正则表达式中的 . 操作符能够匹配所有字符，默认匹配除换行外的所有字符

又叫：re.DOTALL

import re

match = re.search(r"[1-9]\d{5}","BIT 100081")

if match:

print(match.group(0)) #打印出匹配的结果

# 输出：

100081

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

从一个字符串的的开始位置起匹配正则表达式，返回match对象（参数与search相同）

import re

#match = re.match(r"[1-9]\d{5}","BIT 100081")

#print(match.group(0)) #从开始匹配并不是我们所要求的的，单单输出，会报错

match = re.match(r"[1-9]\d{5}","100081 BIT")

if match:

print(match.group(0))

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

搜索字符串，以列表类型返回全部能匹配的子串 # 类型与上面一样

import re

Is =re.findall(r"[1-9]\d{5}","BIT100081 YSU100084")

print(Is)

# 输出：

['100081', '100084']

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

将一个字符串按照正则表达式匹配结果进行分割，返回列表类型

其中三项与其它相同（匹配的部分去掉）

maxsplit ：最大分割数，剩余部分作为最后一个元素输出

import re

Is = re.split(r"[1-9]\d{5}","BIT100081 TSU100084")

print(Is)

# 输出：

['BIT', ' TSU', '']

# 对上式子加入maxsplit

import re

Is = re.split(r"[1-9]\d{5}","BIT100081 TSU100084",maxsplit=1)

print(Is) #当maxsplit等于，只是将第一个给分割了

#输出：

['BIT', ' TSU100084']

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

搜索字符串，返回一个匹配结果的迭代类型，每个迭代元素是match对象

（参数和第一个一样）

import re

for m in re.finditer(r"[1-9]\d{5}","BIT100081 TSU100084"):

if m:

print(m.group(0))

# 输出：

100081

100084

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

在一个字符串中替换所有匹配正则表达式的子串，返回替代换后的字符串（用一个新的字符串取代正则表达式匹配的字符串，并与原来的字符串相组合，返回一个新的字符串组合）

repl: 替换匹配字符串的字符串

count：匹配的最大替换次数

import re

Is =re.sub(r"[1-9]\d{5}",":zipcode","BIT100081 TSU100084")

print(Is)

# 输出：

BIT:zipcode TSU:zipcode

re库的另一种等价用法

rst = re.search(r"[1-9]\d{5}","BIT 100081")

函数式用法：一次性操作

面向对象用法：编译后的多次操做

pat = re.compite(r"[1-9]\d{5}")

rst = pat.search("BIT 100081")

(通过一次编译，当多次使用时，加快运行速度）

regex = re.compile(pattern,flags=0)

将正则表达式的字符串形式编译成正则表达式对象

（regex才是正则表达式的表示）

regex.search (）# 这样引用时，将参数去去掉

match对象

属性

说明

.string

待匹配的文本

.re

匹配时使用pattern对象

.pos

正则表达式搜索文本的开始位置

.endpos

正则表达式搜索文本的结束位置

import re

match = re.search(r"[1-9]\d{5}","BIT 100081")

if match:

print(match.group(0))

# 使用type来检查type的类型

print(type(match))

# 输出：

100081

match对象的方法：

方法

说明.group(0)

获得匹配后的字符串

.start()

匹配字符串在原始字符串的开始位置

.end()

匹配字符串在原始字符串的结束位置

.span()

返回（.start(), .end()）元组类型，包含两个元素

import re

m= re.search(r"[1-9]\d{5}","BIT 100081 TSU100084")

print(m.string)

print(m.re)

#输出：

BIT 100081 TSU100084

re.compile('[1-9]\\d{5}') # 这代表在内部只有经过compile之后的表达式才是正则表达式

import re

m= re.search(r"[1-9]\d{5}","BIT 100081 TSU100084")

print(m.string)

print(m.re)

print(m.pos)

print(m.endpos) #最开始的位置到最后的位置

print(m.group(0)) # match对象只包含一次对象的结果，返回的是第一次匹配的结果

print(m.start()) # 一个对象的起始位置

print(m.end())

# 输出：

BIT 100081 TSU100084

re.compile('[1-9]\\d{5}')

100081

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

import re

m= re.search(r"PY.*N","PYANBNCNDN")

print(m.group()) # 根据不同长度，会有4种结果

# 输出

PYANBNCNDN # 默认贪婪匹配

贪婪匹配：

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

最小匹配：生成最小匹配

import re

m= re.search(r"PY.*？N","PYANBNCNDN")

print(m.group()) # 根据不同长度，会有4种结果

# 输出

PYAN

操作符

说明

*？

前一个字符0次或无限次扩展，最小匹配

+？

前一个字符1次或无限次扩展，最小匹配

？？

前一个字符0次或1次扩展，最小匹配

{m,n}?

扩展前一个字符m至n次（含n），最小匹配

想要了解更多：您可以关注微信公众号：foryouos

Re库正则表达式，知识点，

你可能感兴趣的:(Re库正则表达式，知识点，)