Day24 正则表达式 正则函数 正则命名分组 正则表达式修饰符号

1.正则表达式函数

1.1findall 匹配字符串中相应内容,返回列表 [用法: findall("正则表达式","要匹配的字符串")]

finditer 匹配字符串中相应内容,返回迭代器

# finditer 匹配字符串中相应内容,返回迭代器
# finditer 和 findall 用法一样,区别在于返回的是迭代器
# 迭代器里面是一个一个的对象,想获取对象的值用 group()
strvar = "sdfsdff&*&*%^%234sdfsdfskdjfk3sdf23"
lst = re.findall(r"\d",strvar)
print(lst)
# ['2', '3', '4', '3', '2', '3']
res = re.finditer(r"\d",strvar)
print(res)
# <callable_iterator object at 0x00000000027C7EB8>
from collections import Iterator
print(isinstance(res,Iterator))
# True
it = re.finditer(r"\d",strvar)
obj = next(it)
res = obj.group()
print(res)
# 2
for i in it:
    res = i.group()
    print(res)
# 3
# 4
# 3
# 2
# 3

1.2search   通过正则匹配出第一个对象返回，通过group取出对象中的值

match   验证用户输入内容

# (1)search   通过正则匹配出第一个对象返回，通过group取出对象中的值
strvar = "1d2 3&5"
obj = re.search(r"(\d).*?(\d)",strvar)
print(obj)
print(obj.group())

# 拿到分组当中的值用groups
res = obj.groups()
print(res)
# ('1', '2')
# 拿到分组里的元素个数 lastindex
res = obj.lastindex
print(res)
# 2

# search 和 match 用法一样,区别在与match在正则的前面加了一个^ [必须以..开头]
# search 只需要在正则的前面加上^ 就可以取代match
strvar = "uuyydfopopopop3434sdf234"
# obj = re.search("^d.*?\d",strvar) #c 等价于match
obj = re.search(r"d.*?\d",strvar)
res = obj.group()
print(res,"<search>")
# \d 是匹单个的数字字符
# dfopopopop3 <search>
# match
obj = re.match(r"d.*?\d", strvar)
print(obj)
# 对比search而言match相当于内部添加了^符号，意思是必须以某个字符开头
# 所以上面的没有结果

1.3split   切割

# 2)split    切割
strvar = "alex|wusir|secret,boy"
# 传统做法
lst = strvar.replace(",","|").split("|")
print(lst)
# ['alex', 'wusir', 'secret', 'boy']
# 但是对于符号过多的表达式就不能够切割了
strvar = "alex,wusir|secret%boy"
res = re.split(r"[,|%]",strvar)
print(res)
# ['alex', 'wusir', 'secret', 'boy']
# 可以选择分割次数
res = re.split(r"[,|%]",strvar,1)
print(res)
# ['alex', 'wusir|secret%boy']

strvar = "alex234234wusir2secret909090boy"
res = re.split(r"\d+",strvar)
print(res)
# ['alex', 'wusir', 'secret', 'boy']
# 分析得到如果想要得到alex,wusir,secret，boy,只有以数字就行切割就好了

1.4sub     替换

#sub      替换 
strvar = "alex,wusir|secret%boy"
res = re.sub("[,|%]","-",strvar)
print(res)
# alex-wusir-secret-boy
# 后面可以选择替换次数
res = re.sub(r"[|%,]", "_",strvar,1)
print(res)
# alex_wusir|secret%boy
# subn 与 sub 用法一样,最大的区别在于返回值 ,返回一个元组,包含替换的次数
res = re.subn(r"[|,%]","_",strvar)
print(res)
# ('alex_wusir_secret_boy', 3)

1.5compile 指定一个统一的匹配规则

# (5)compile 之的是一个统一的匹配规则

"""
写一套正则,程序就需要重新编译一次,
同一个正则多处使用,反复编译会浪费时间
这样的话,就可以使用compile 来定义一次,终身受益
"""
rule = re.compile(r"\d+")
print(rule)
# re.compile('\\d+')
strvar = "sdfsdfs234kjkjk*(*9343dsf3"
obj = rule.search(strvar)
print(obj)
# <_sre.SRE_Match object; span=(7, 10), match='234'>
print(obj.group())
# 234

lst = rule.findall(strvar)
print(lst)
# ['234', '9343', '3']

2.正则表达式修饰符

# (6) 正则表达式的修饰符
'''
re.I 使匹配对大小写不敏感
re.M 多行匹配，影响 ^ 和 $
re.S 使 . 匹配包括换行在内的所有字符
'''
# re.I 使匹配对大小写不敏感
strvar = "<h1>sdfsfsdfsd</H1>"
# rule = re.compile("<h1>.*?</h1>")
# 推荐使用flags来指定修饰符,预防未知错误
rule = re.compile("<h1>.*?</h1>",flags=re.I)
obj = rule.search(strvar)
print(obj)
# <_sre.SRE_Match object; span=(0, 19), match='<h1>sdfsfsdfsd</H1>'>
print(obj.group())
# <h1>sdfsfsdfsd</H1>
# 这样子写的话，可以匹配到前面"<h1>.*?</h1>" 没有包括后面h是大写的这种情况，
# 使用compile时候可以让表达式能匹配到后面带有大写的这种情况


# re.M 多行匹配，影响 ^ 和 $
"""
# 每一行都单独的去匹配,卡主开头和结尾,忽略换行. 每一行都拿出来单独匹配
"<h1>sdfsf</h1>"
"<h1>dd22</h1>"
"<h1>aabb</h1>"
"""

strvar = """<h1>sdfsf</h1>
<h1>dd22</h1>
<h1>aabb</h1>"""

rule = re.compile(r"^<h1>(.*?)</h1>$",flags=re.M)
lst = rule.findall(strvar)
print(lst)
# ['sdfsf', 'dd22', 'aabb']
print("<================>")
# re.S 使 . 匹配包括换行在内的所有字符
strvar = '''give
123mefive
'''
# 如果想要去匹配出give/n123mefive
rule = re.compile(r"(.*?)mefive",flags=re.S)
obj = rule.search(strvar)
print(obj.group())

# 其中的.*?是不能匹配换行符的，写了re.S之后，rule就可以匹配换行符。

 3.命名分组

# 2.命名分组
3) (?P<组名>正则表达式) 给这个组起一个名字
4) (?P=组名) 引用之前组的名字,把该组名匹配到的内容放到当前位置
'''
import re
strvar = "<h1>sdfsfsdfsdf</h1>"
lst = re.findall(r"<.*?>.*?<.*?>",strvar)
print(lst)
# ['<h1>sdfsfsdfsdf</h1>']
lst = re.findall(r"<(.*?)>.*?<(.*?)>", strvar)
print(lst)
# [('h1', '/h1')]
lst = re.findall(r"<(.*?)>(.*?)<(.*?)>",strvar)
print(lst)
# [('h1', 'sdfsfsdfsdf', '/h1')]
# 反向引用 拿已经匹配到的值,在引用一次 
# 引用第一个括号里面的内容 \1 
# 引用第二个括号里面的内容 \2 依次类推...
strvar = "123<h1>sdfsdfsdfsdf</h1>  123<h2>ppoo</h2>"
lst = re.findall(r"<(.*?)>(.*?)</\1>",strvar)
print(lst)
# [('h1', 'sdfsdfsdfsdf'), ('h2', 'ppoo')]
# 会将匹配到满足条件的放到一个算式里面


# 命名分组
strvar = "d3j5sdj"
obj = re.search(r"(.*?)\d(.*?)\d(.*?)\1\2",strvar)
print(obj)
# <_sre.SRE_Match object; span=(0, 7), match='d3j5sdj'>
res = obj.group()
print(res)
# d3j5sdj
# 用命名分组进行反向引用
obj = re.search(r"(?P<tag1>.*?)\d(?P<tag2>.*?)\d(?P<tag3>.*?)(?P=tag1)(?P=tag2)",strvar)
print(obj)
res = obj.group()
print(res)
# <_sre.SRE_Match object; span=(0, 7), match='d3j5sdj'>
# d3j5sdj
# 第二种写法
obj = re.search(r"(?P<tag1>.*?)\d(?P<tag2>.*?)\d(?P<tag3>.*?)\1\2", strvar)
print(obj)
res = obj.group()
print(res)
# <_sre.SRE_Match object; span=(0, 7), match='d3j5sdj'>
# d3j5sdj
# 注意格式的书写

4.类中的方法

# 类中的方法
'''
普通方法:没有参数,只能类调用
绑定方法:(1)绑定到对象(自动传递对象参数) (2)绑定到类(自动传递类参数)
静态方法:无论是类还是对象,都能调用的方法
'''

class Dog():
    def __init__(self,name):
        self.name = name
        
    # 普通方法
    def jiao():
        print("小狗看见人就旺旺")
        
    # 绑定到对象方法
    def tian(self):
        print("小狗喜欢舔")
    
    # 绑定到类方法
    @classmethod
    def la(cls):
        print(cls)
        print("小狗会吃屎")
        
    # 静态方法
    @staticmethod
    def jump():
        print("小狗喜欢跳起来接飞盘")

obj = Dog("迈克尔·蛋")

 

 

# (1) 普通方法

Dog.jiao() #小狗看见人就旺旺

 

 

# (2) 绑定到对象方法

obj.tian() #小狗喜欢舔
# Dog.tian(134)  # 如果硬要使用类来调用,满足实参形参一一对应. 

# (3) 绑定到类方法

Dog.la()

#<class '__main__.Dog'>

#小狗会吃屎

# 用对象调用绑定到类的方法是可以的,先找出该对象所归属的类是谁,然后在传递这个类
obj.la()
# 同上

# (4) 静态方法

obj.jump()
Dog.jump()

代码运行结果：

小狗喜欢跳起来接飞盘
小狗喜欢跳起来接飞盘