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()
代码运行结果：
小狗喜欢跳起来接飞盘
小狗喜欢跳起来接飞盘