正则和python正则表达式
findall()是以列表的形式返回匹配到的字符串
search()方法用于在字符串中搜索正则表达式模式(前面那个)第一次出现的位置
. 匹配除换行符以外的任意字符
\w 匹配字母或数字或下划线或汉字，代码示例：print(re.findall(r'\w', '我爱你，塞北的雪! hello_world')) # 打印出['我', '爱', '你', '塞', '北', '的', '雪', 'h', 'e', 'l', 'l', 'o', '_', 'w', 'o', 'r', 'l', 'd']，除了空格和!都打印出来了，前提是导入re
\W与\w相反，print(re.findall(r'\W', '我爱你，塞北的雪! hello_world'))，打印出['，', '!', ' ']
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]任何一个数字
\b 匹配单词的开始或结束，匹配一个单词边界，代码示例：print(re.findall(r'\bhello\b', 'hello .com|hello_com|(hello)|hello.|hello!|hello3|helloA')) # 打印出[['hello', 'hello', 'hello', 'hello']，字母、数字、下划线没有被匹配上，加粗的被匹配上了
\B 与\b相反，代码示例：print(re.findall(r'py\B', 'python|py |py!|py_|py3')) # 打印出['py', 'py', 'py']，字母、数字、下划线被匹配上了，加粗的被匹配上了
^ 匹配字符串的开始，和\A一样
$ 匹配字符串的结束，和\Z一样
[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'\d\d', '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\n')) # ^a-z和^(a-z)一样，^元字符如果写到[]字符集里就是反取，匹配除了小写字母以外的任意字符，打印出['J', '.', '\n']
print(re.findall(r'[a-z^]', 'Jiang.com\n')) # a-z^和(a-z)^一样，打印出['i', 'a', 'n', 'g', 'c', 'o', 'm']
# 匹配IP地址
print(re.search(r'\b(?:(?: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]?)\b', '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']
