1

2

3

4

5

import re

# match findall经常用

# re.match() #从开头匹配，没有匹配到对象就返回NONE

# re.search() #浏览全部字符，匹配第一个符合规则的字符串

# re.findall() # 将匹配到的所有内容都放置在一个列表中

1

2

3

4

5

6

origin = "hello alex sadf dsaf"

r = re.match("(h)\w+",origin)

print(r.group())  # hello  获取匹配所有结果

print(r.groups())  #('h',)  #获取模型中匹配到的分组 没有分组则为空元组

r = re.match("(?P<n1>h)(?P<n2>\w+)",origin)  #获取模型中匹配到的分组中所有执行力key的组 ?P<KEY>VALUE   {'n2': 'ello', 'n1': 'h'}

print(r.groupdict())   #?P<KEY>VALUE   {'n2': 'ello', 'n1': 'h'}

1

2

3

4

r = re.match("h\w+",origin)

print(r.group()) # 获取匹配所有结果 hello

print(r.groups()) #获取模型中匹配到的分组 ()

print(r.groupdict())  #获取模型中匹配到的分组 {}

1

2

3

4

print(r.group())  # hello  获取匹配所有结果

print(r.groups())  #('h',)  #获取模型中匹配到的分组 没有分组则为空元组

r = re.match("(?P<n1>h)(?P<n2>\w+)",origin)  #获取模型中匹配到的分组中所有执行力key的组 ?P<KEY>VALUE   {'n2': 'ello', 'n1': 'h'}

print(r.groupdict())   #?P<KEY>VALUE   {'n2': 'ello', 'n1': 'h'}

1

2

3

4

5

6

origin = "hello alex alix bcd dsfa lefg abc 199"

r = re.search("a(\w+)",origin)

print(r.group()) #alex

print(r.groups()) #('lex',)

r = re.search("(?P<key1>a)(?P<key2>(\w+))",origin)

print(r.groupdict()) #{'key1': 'a', 'key2': 'lex'}

1

2

3

4

5

origin = "hello alex alix bcd dsfa lefg abc 199"

r = re.search("ali\w+",origin)

print(r.group()) #alix

print(r.groups()) #()

print(r.groupdict()) #{}

1

2

3

origin = "a2b3c4d5"

a=re.findall("\d+\w\d+",origin)   #['2b3', '4d5']

print(a)

1

2

num = "asd"

print(re.findall("",num))  # ['', '', '', '']

1

2

3

4

5

origin = "hello alex alix bcd dsfa lefg abc 199"

print(re.findall("a\w+",origin)) # ['alex', 'alix', 'abc']

print(re.findall("(a\w+)",origin)) #['alex', 'alix', 'abc']

print(re.findall("a(\w+)",origin)) #组 groups ['lex', 'lix', 'bc']

print(re.findall("(a)(\w+)(x)",origin)) # [('a', 'le', 'x'), ('a', 'li', 'x')] 将 三个分组匹配到的做成元组 放到列表作为一个元素

1

2

3

4

5

6

7

8

9

10

11

分组匹配

    * 贪婪匹配： 比如如下的asd 为一个分组，而一旦遇到asd开始的字符串，如果

后面还是asd也会匹配，这就是贪婪匹配。

    findall 特性：

        1 有几个分组返回几个内容：,并将返回内容放到元组内 作为列表的一个元素。

        2 即尽管* 匹配到了两个asd ，但是因为是贪婪虚拟匹配出的，有一个分组，所以，

        只会，取一个。

        3 而findall默认只取最后一组匹配的内容，故此 只返回最后一组asd

        4 findall 如果正则能有空的匹配的话，那么匹配字符串最后还会匹配到一个空

        5 多个分组匹配到做成元组，当成列表的一个元素

        6 多个分组，查找顺序，外到内，左到右 ((\w)(\w)){2,} 先是找到2个字母的，再在这两个字母里面进行局部分组

1

print(re.findall(r'(asd)*','asdasd'))  #['asd', '']

1

2

n = re.findall("(\dasd)+","1asd2asdp2asds") # ['2asd', '2asd']

print(n)

1

2

n = re.findall("(\dasd)*","1asd2asdp2asds") # ['2asd', '', '2asd', '', '']

print(n)

1

2

3

a = "alex"

n = re.findall("(\w){4}",a)

print(n)  # ['x']

1

2

3

a = "alex"

n = re.findall("(\w)*",a)

print(n)  # ['x', '']

1

2

3

a = "alex"

n = re.findall("((\w)(\w)){2,}",a)

print(n)  # [('ex', 'e', 'x')]

1

2

3

origin = "hello ax lex bed alex lge alex acd 19"

n = re.findall("(a)(\w)*" , origin)

print(n)  #[('a', 'x'), ('a', 'x'), ('a', 'x'), ('a', 'd')]