正则和python正则表达式

findall()是以列表的形式返回匹配到的字符串

search()方法用于在字符串中搜索正则表达式模式(前面那个)第一次出现的位置

. 匹配除换行符以外的任意字符

w 匹配字母或数字或下划线或汉字，代码示例：print(re.findall(r'w', '我爱你，塞北的雪! hello_word'))  # 打印出['我', '爱', '你', '塞', '北', '的', '雪', 'h', 'e', 'l', 'l', 'o', '_', 'w', 'o', 'r', 'd']，除了空格和!都打印出来了，

W与w相反

res = re.search(r' (w+) (w+)', 'I love python')  # 正则表达式模式是空格+字母数字下划线+空格+字母数字下划线
print(res) # 打印出<re.Match object; span=(1, 13), match=' love python'>
print(res.group()) # 打印出 love python
print(res.group(1)) # 打印出love
print(res.group(2)) # 打印出python
print(res.start()) # 打印出1
print(res.end()) # 打印出13
print(res.span()) # 打印出(1, 13)

s 匹配任意的空白符，包含空格、换行、回车，多个空格就是空白

d 匹配数字，匹配[0-9]任何一个数字

 匹配单词的开始或结束，匹配一个单词边界，代码示例：print(re.findall(r'hello', 'hello .com|hello_com|(hello)|hello.|hello!|hello3|helloA'))  # 打印出[['hello', 'hello', 'hello', 'hello']，字母、数字、下划线没有被匹配上，加粗的被匹配上了
B 与相反，代码示例：print(re.findall(r'pyB', 'python|py |py!|py_|py3'))  # 打印出['py', 'py', 'py']，字母、数字、下划线被匹配上了，加粗的被匹配上了

^ 匹配字符串的开始，和A一样

$ 匹配字符串的结束，和一样

[a-z] 指定a到z的任一字母

[0-9] 指定0到9的任一数字

[u4e00-u9fa5] 代表汉字，4e00代表中国第一个汉字的编码，9fa5代表最后一个

[asz] 指a，s，z三个字符中取任意一个字符

* 表示重复零次或更多次(零次以上包含零次)

+ 表示重复一次或更多次(一次以上包含一次)

? 表示重复零或一次，遇到?就是非贪婪模式，反之没有?就是贪婪模式

{n} 重复n次

{n,} 重复n次或更多次

{n,m} 重复n到m次

关联：

.* 连在一起就意味着任意数量的不包含换行的字符

*? 重复任意次，但尽可能少重复，如"acbacb"正则"a.*?b"只会取到第一个"acb"，原本可以全部取到，但加了限定符后，只会匹配尽可能少的字符，而"acbacb"最少字符的结果就是"acb"

+? 重复一次或更多次，但尽可能少重复，与上面一样，只是至少要重复一次

?? 重复0次或1次，但尽可能少重复，如"aaacb"正则"a.??b"只会取到最后的三个字符"acb"

{n,m}? 重复n到m次，但尽可能少重复，如"aaaaaaaa"正则"a{0,m}"，因为最少是0次，所以取到结果为空

{n,}? 重复n次以上，但尽可能少重复，如"aaaaaaaa"正则"a{1,}"，因为最少是1次，所以取到结果为"a"

正则表达式：a*        *代表0次或更多次，优先匹配多次，贪婪模式
源文本：asdaadaaaeaw
结果：a aa aaa a ，共10位，aa是一位，aaa是一位，最后的a后面有两个空格，s，d等匹配不上就匹配空白，默认会多出一个空白，代码示例：print(re.findall(r'a*', 'asdaadaaaeaw'))  # 打印出['a', '', '', 'aa', '', 'aaa', '', 'a', '', '']

正则表达式：a+       +代表一次或更多次，优先匹配多次，贪婪模式
源文本：asdaadaaaeaw
结果：a aa aaa a，共4位，4个加粗的，没有空格，代码示例：print(re.findall(r'a+', 'asdaadaaaeaw'))  # 打印出['a', 'aa', 'aaa', 'a']

正则表达式：a?         ?代表零次或一次，要么一个要么零个，空格和a都有
源文本：asdaadaaaeaw
结果：a a a a a a a ，共13位，代码示例：print(re.findall(r'a?', 'asdaadaaaeaw'))  # 打印出['a', '', '', 'a', 'a', '', 'a', 'a', 'a', '', 'a', '', '']

正则表达式：a*?       *?代表零次或更多次，优先匹配零次，非贪婪模式
源文本：asdaadaaaeaw
结果：13位，代码示例：print(re.findall(r'a*?', 'asdaadaaaeaw'))  # 打印出['', '', '', '', '', '', '', '', '', '', '', '', '']

['', 'a', '', '', '', 'a', '', 'a', '', '', 'a', '', 'a', '', 'a', '', '', 'a', '', '']，*代表重复0次或更多次，把12位取0次都为空，取1次就是7个a，再加上一个空

正则表达式：a+?      +?代表一次或更多次，优先匹配一次，非贪婪模式
源文本：asdaadaaaeaw
结果：7个a，代码示例：print(re.findall(r'a+?', 'asdaadaaaeaw'))  # 打印出['a', 'a', 'a', 'a', 'a', 'a', 'a']

正则表达式：a??       ??重复零次或一次，尽可能少重复，非贪婪模式
源文本：asdaadaaaeaw
结果：20位，代码示例：print(re.findall('a??', 'asdaadaaaeaw'))  # 打印出['', '', '', '', '', '', '', '', '', '', '', '', '']

['', 'a', '', '', '', 'a', '', 'a', '', '', 'a', '', 'a', '', 'a', '', '', 'a', '', '']，?代表重复0次或1次，把12位取0次都为空，取1次就是7个a，再加上一个空

正则表达式：aa*?b
源文本：abaabaseb
结果：ab和aab，代码示例：print(re.findall('aa*?b', 'abaabaseb'))  # 打印出['ab', 'aab']

python正则表达式：

首先导入re

import re
print('hello, world'.find('d'))  # 打印出下标11

print(re.search(r'.', 'hello, world'))  # 打印出<re.Match object; span=(0, 1), match='h'>
print(re.search(r'hello', 'hello,world'))  # 打印出<re.Match object; span=(0, 5), match='hello'>
print(re.search(r'.', 'www.126.com'))  # 打印出<re.Match object; span=(3, 4), match='.'>
print(re.search(r'dd', 'test123'))  # 打印出<re.Match object; span=(4, 6), match='12'>，匹配两位数字
print(re.search(r'd', 'test123'))  # 打印出<re.Match object; span=(4, 5), match='1'>，匹配一位数字
print(re.search(r'[aeiou]', 'I love you too'))  # 打印出<re.Match object; span=(3, 4), match='o'>，匹配小写元音字母
print(re.search(r'[aeiouAEIOU]', 'I love U'))  # 打印出<re.Match object; span=(0, 1), match='I'>，匹配大小写元音字母
print(re.search(r'[a-z]', 'hello,world'))  # 打印出<re.Match object; span=(0, 1), match='h'>
print(re.search(r'[0-9]', 'com123'))  # 打印出<re.Match object; span=(3, 4), match='1'>
print(re.search(r'[3-9]', 'com123'))  # 打印出<re.Match object; span=(5, 6), match='3'>
print(re.search(r'ab{3}c', 'abbbc'))  # 打印出<re.Match object; span=(0, 5), match='abbbc'>，{3}是重复3次b
print(re.search(r'ab{3,10}c', 'abbbbbbbbbbc'))  # 打印出<re.Match object; span=(0, 12), match='abbbbbbbbbbc'>，{3,10}是重复3-10次b，如果多于10个b，会打印None
print(re.search(r'blue(_sky|_lake)', 'blue_sky'))  # |就是逻辑或的意思，匹配blue_sky或blue_lake，|前后不能有空格
print(re.search(r'blue(_sky|_lake)', 'blue_lake'))  # 打印出<re.Match object; span=(0, 9), match='blue_lake'>
s = '<html><title>I love hua</title></html>'
print(re.search(r'<.+>', s))  # <re.Match object; span=(0, 38), match='<html><title>I love hua</title></html>'>，贪婪模式
print(re.search(r'<.+?>', s))  # 打印出<re.Match object; span=(0, 6), match='<html>'>，非贪婪模式
print(re.findall(r'[^a-z]', 'Jiang.com '))  # ^a-z和^(a-z)一样，^元字符如果写到[]字符集里就是反取，匹配除了小写字母以外的任意字符，打印出['J', '.', ' ']
print(re.findall(r'[a-z^]', 'Jiang.com '))  # a-z^和(a-z)^一样，打印出['i', 'a', 'n', 'g', 'c', 'o', 'm']

# 匹配IP地址
print(re.search(r'(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?).){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)', '192.168.0.1')) 
?:是扩展语法，匹配前面的(，表示有0个或1个子组，ip里的每个数不分百位、十位、个位，192就是分别匹配1，9，2，25[0-5]匹配250-255之间的数字，2[0-4][0-9]匹配200-249之间的数字，[01]?[0-9][0-9]?匹配0-199之间的数字，.代表.，{3}代表重复3次，就相当于数字.数字.数字.，重复3次后再加上1个数字，就组成一个IP地址，可以对输入的IP进行测试，0-255范围里的都可以满足，超出这个范围的匹配不上，但是第一个数字输入负数，这个还没有校验出来，直接匹配出正数，有点小瑕疵

p = re.compile(r'[A-Z]')  # 编译模式和模块直接引用没有谁坏谁说的区别
print(type(p))  # 打印出<class 're.Pattern'>
print(p.search('I love You Too'))  # <re.Match object; span=(0, 1), match='I'>
print(p.findall('I love You Too'))  # ['I', 'Y', 'T']