python正则表达式

1、概述

"""
python 在1.5以后增加了re模块，提供了正则表达式

re模块使python语言拥有了全部的正则表达式

"""

"""
re模块简介
"""
import  re
#pip  包管理工具
'''
re.match函数
原型：match（pattern，string，flags=0）
参数：pattern:匹配的正则表达式
     string：要匹配的字符串
     flags :标志位，用于控制正则表达式的匹配方式,值如下:
    re.I:忽略大小写
    re.L:做本地化识别
    re.M:多行匹配,影响^和$
    re.S：是匹配包括换行符在内的所有字符
    re.U:根据Unicode字符集解析字符,影响\w \W \b \B
    re.X: 使我们以更灵活的方式理解正则表达式
功能：尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，返回None

'''

#www.baidu.com
a = re.match("www","www.baidu.com")
a1 = re.match("www","ww.baidu.com")
a2 = re.match("www","ww.bawwwwidu.com")
a3 = re.match("www","wwW.bawwwwidu.com",flags = re.I)
#扫描整个字符串，返回从起始位置成功的匹配
print(a,a1,a2,a3)


'''
re.search函数
原型：search（pattern，string，flags=0）
参数 pattern:匹配的正则表达式
     string：要匹配的字符串
     flags :标志位，用于控制正则表达式的匹配方式
功能:扫描整个字符串，并返回第一个成功的匹配
'''
print(re.search("sunck","good man is sunck"))


"""
re.findall函数
原型：findall（pattern，string，flags=0）
参数 pattern:匹配的正则表达式
     string：要匹配的字符串
     flags :标志位，用于控制正则表达式的匹配方式
功能:扫描整个字符串，并返回结果列表
"""

print(re.findall(".*?sunck","good man is suncknice man is sunck"))

2、元字符          \b与\B用法需要好好理解
import re

print("----------匹配单个字符与数字------------")
# .   匹配除换行符以外的任意字符
# print(re.search(".","sunck is a good man"))
# [0123456789]  [字符集合],表示匹配[]中包含的任意一个字符
# [sunck]   匹配"s","u","n""c","k"中任意一个字符
# [a-z]  匹配任意小写字母
# [A-Z]  匹配任意大写字母
# [0-9] 匹配任意数字
# [0-9a-zA-Z_]  匹配任意数字和字母和下划线
# [^sunck] 匹配除了sunck这几个字母以外的所有字符,^称为脱字符，表示不匹配集合中的字符
# [^0-9]  匹配所有非数字字符
# \d  匹配数字，效果同[0-9]   有^时，外面要加[]
# \D  匹配所有非数字
# \w 匹配数字、字母和下划线效果同[0-9a-zA-Z_]
# \W 匹配非数字、字母、下划线
# \s 匹配任意空白符（空格，换行\f，回车\n，换页\r，制表\t）
# \S 匹配任意的非空白符
print(re.search("[0123456789]","sunck is a good man3"))
print(re.search("[sunck]","sunck is a good man3"))
print(re.findall("[^0-9]","sunck is a 3good man"))

print("-----------------锚字符（边界字符）-------------------------")
"""
^    行首匹配，和[^]里的不是一个意思
$    行尾匹配

"""

print(re.search("^sunck","sunck is a good man"))
print(re.search("man$","sunck is a good man"))
print("-------------------------------------------------")
"""
\A  匹配字符串开始，它和^的区别是“\A”只匹配整个字符串的开头，即使在re.M模式下也不会匹配它行的行首
\Z  匹配字符串结束，它和$的区别是“\Z”只匹配整个字符串的结尾，即使在re.M模式下也不会匹配它行的结尾
"""
# print(re.findall("^sunck","sunck is a good man\nsunck is a good man",re.M))
# print(re.findall("\Asunck",'sunck is a good man\nsunck is a good man',re.M))

# print(re.findall("man$","sunck is a good man\nsunck is a good man",re.M))
# print(re.findall("man\Z","sunck is a good man\nsunck is a good man",re.M))

print("-----------------------------------------------")
"""
\b 匹配一个单词的边界，也就是空格边的字符，注意用r进行转义
\B 匹配非单词边界的部分

"""
print(re.findall(r"\bsi\b","si si a dsi"))
print(re.findall(r"\bsi\b"," ernevsi ervsi serve"))

print(re.findall(r"\Ber\B","erv sssersss"))
print(re.findall(r"er\B","erv sssser sssser"))

print("--------------匹配多个字符-----------------")
"""
说明：下方的x，y，z、n（数字）均为假设的普通字符，不是正则表达式的元字符
（xyz）  匹配小括号的xyz(作为一个整体去匹配)
x?     匹配0个或者一个x
x*     匹配0个或者任意多个x(.*  表示匹配0个或任意个字符（换行除外））

x+    匹配至少一个x
x{n}  匹配确定的n个x（n是一个非负整数）
x{n,} 匹配至少n个x
x{n,m} 匹配至少n个，最多m个x，n<= x
x|y    |表示或，匹配x或y
"""
# print(re.findall(r"(sunck)","sunck is a good man sunck is a nice man"))
#
# print(re.findall(r"o?","oooooo"))  #非贪婪匹配（尽可能少的匹配）
#
# print(re.findall(r"o*","ooooobbbbbb"))  #贪婪匹配（尽可能多的匹配）
#
# print(re.findall(r"a+","adsfaaa"))
#
# print(re.findall(r"a{3}","aaabaabbbaaaa"))
#
# print(re.findall(r"a{3,}""aabbbaaabbbbaaaabb"))
#

# print(re.findall(r"a{3,4}","aaaaaabaa"))
#
# print(re.findall(r"c|a","ccccaabaaaa"))
# print(re.findall(r"c|a+","ccccaabaaaa"))
# print(re.findall(r"c|a{4}","ccccaabaaaa"))
#需求，提取sunck"""""man
str1 = "sunck is a good man!sunck is a nice man!sunck is a very handsome man"

print(re.findall(r"sunck.*?man",str1))

print("-------------特殊--------------")
"""
x?  *?  +?  最小匹配，通常都是尽可能多的模式，我们可以使用这种方法解决贪婪匹配

"""
str2 = "/*   part1   */   /*    patr2    */"

print(re.findall(r"//*.*?/*/",str2))


#(?:x)    类似（xyz），但是不表示一个组

3、re模块深入

import re


"""
字符串切割

"""
str1 = "sunck          is a good man"
# print(str1.split(" "))

# print(re.split(r" +",str1))  #至少一个空格

"""
re.finditer函数
原型：finditr(pattern,string,flags= 0)
功能与findall类似，扫描整个字符串，返回的是一个迭代器
可以使用group方法
"""
sunck3 = "sunck is a good mansunck is a nice mansunck is a handsome man"
d =re.finditer(r"(.*?man)",sunck3)
while True:
    try:
        l = next(d)
        print(l.group(0))
    except StopIteration as e:
        break
print("----------------------------------------")
"""
字符串的替换和修改
re.sub(pattern, repl, string, count=0, flags=0):
pattern:正则表达式（规则）
repl:   指定的用来替换的字符串
string ： 要被替换的字符串
count ： 最多替换次数
功能：   在目标字符串中，以正则表达式的规则匹配字符串，再把他们替换成指定的字符串，可以指定替换次数，如果不指定，替换所有的字符串
re.subn(pattern, repl, string, count=0, flags=0):

与re.sub的区别:    前者返回一个被替换的字符串，后者返回一个元组，内容为被替换的字符串和被替换的次数

"""
str5 = "sunck is a good good man "
# re.subn()
print(re.subn(r"good","nice",str5,count = 0))

print("----------------------------------------------")
"""
分组：
概念：除了简单的判断是否匹配之外，正则表达式还有提取子串的功能，用（）表示的就是分组
"""
str6 = "010-52314321"

m = re.match(r"((\d{3})-(\d{8}))",str6)
# 查看匹配的各组的内容，使用序号获取对应组的信息，group(0)一直代表的是原始的字符串str6
print(m.group(0))#str6
print(m.group(1))
print(m.group(2))
print(m.group(3))
print(m.groups())  #打印组内的全部信息

print("-----------------2-----------------")
l = re.match(r"(?P<thired>(?P<first>\d{3})-(?P<second>\d{8}))",str6)
print(l.group("first"))#可以起名
print(l.group("thired"))
print("-----------------3-----------------")

"""
编译：使用正则表达式时，re模块会干两件事
1、编译正则表达式，如果正则表达式本身不合法会报错
2、用编译后的正则表达式去匹配对象
compile(pattern)

"""
pat =r"(13\d{9}$)|(15[0-35-9]\d{8}$)|(147\d{8}$)|(18[05-9]\d{8}$)"

re_telephon = re.compile(pat)

k = re_telephon.match("13400000001")
re_telephon.findall("13400000001")
re_telephon.finditer("13400000001")


l =re.match(pat,"13400000001")

print(k,l)