import re
print("--------------匹配单个字符与数字--------------")
'''
r
. 匹配除换行符以外的任意字符
[0123456789] []是字符集合，表示匹配方括号中所包含的任意一个字符
[sunck] 匹配's','u','n','c','k'中任意一个字符
[a-z] 匹配任意小写字母
[A-Z] 匹配任意大写字母
[0-9] 匹配任意数字，类似[0123456789]
[0-9a-zA-Z] 匹配任意的数字和字母（注意之间没有空格）
[0-9a-zA-Z_] 匹配任意的数字、字母、下划线（注意之间没有空格）
[^sunck] 匹配除了sunck这几个字母以外的所有字符
^称为脱字符，表示不匹配集合中的字符
[^0-9] 匹配所有的非数字字符
\d 匹配数字，效果[0-9]
\D 匹配非数字字符，效果同[^0-9]
\w 匹配数字，字母和下划线，效果同[0-9a-zA-Z_]
\W 匹配非数字，字母和下划线，效果同[^0-9a-zA-Z_]
\s 匹配任意的空白符（格，换行，回车，换页，制表），效果同
[ \f\n\r\t]
\S 匹配任意的非空白符，效果同[^ \f\n\r\t]
'''
print(re.search(".","sunck is a good man "))
print(re.search("[0123456789]","sunck is a good man 3"))
print(re.search("[sunck]","sunck is a good man 3"))
print(re.findall("[\d]","sunck is a good man 3"))
print(re.search("\D","sunck is a good man 3"))
print(re.search("\w","_sunck is a good man 3"))
print(re.findall("\d","_sunck is 6a go80d man 3" ))
print("-------------------锚字符（边界字符）-------------------")
'''
^ 行首匹配，和[]里的^不是一个意思
$ 行尾匹配
\A 匹配字符串开始，它和^的区别是，\A只匹配整个字符串的开头，即使
在re.M模式下也不会匹配他行的行首
\Z 匹配字符串的结束，它和$的区别是，\Z只匹配整个字符串的结束，即使
在re.M模式下也不会匹配他行的行尾
\b 匹配一个单词的边界，也就是指单词和空格间的位置
'er\b'可以匹配never,不能匹配nerve
\B 匹配非单词边界
'''
print(re.search("^sunck","sunck si a good man"))
print(re.search("sunck$","sunck si a good man"))
print(re.search("man$","sunck si a good man"))
print(re.search("^man$","sunck si a good man"))
print(re.search("^sunck","sunck si a good man\nsunck is a nice man"))
print(re.search("A\sunck","sunck si a good man\nsunck is a nice man"))
print(re.search("^sunck","sunck si a good man\nsunck is a nice man",re.M))
print(re.search("A\sunck","sunck si a good man\nsunck is a nice man",re.M))
print(re.search(r"er\b","never"))
print(re.search(r"er\b","nerve"))
print(re.search(r"er\B","never"))
print(re.search(r"er\B","nerve"))
print("-------------------------匹配多个字符-------------------------")
'''
说明：下方的x,y,z,n均为假设的普通字符，不是正则表达式的元字符（xyz)
匹配小括号内的xyz(作为一个整体去匹配）
x? 匹配0个或者任意1个x
x* 匹配0个或者任意多个x（.*表示匹配0个或者任意多个字符（换行符除外））
x+ 匹配至少一个x
x{n} 匹配确定的n个x（n是一个非负整数）
x{n,} 匹配至少n个x
x{n,m}匹配至少n个最多m个。注意：n <= m
x|y |表示或，匹配的是x或y
'''
print(re.findall(r"(sunck)","sunck is a good man ,sunck is a nice man "))
print(re.findall(r"0?","sunck is a good man ,sunck is a nice man "))
print(re.findall(r"a?","aaa")) # 非贪婪匹配（尽可能少的匹配）
print(re.findall(r"a*","aaabaa")) # 贪婪匹配（尽可能多的匹配）
print(re.findall(r".*","aaabaa"))# 贪婪匹配（尽可能多的匹配）
print(re.findall(r"a+","aaa"))# 贪婪匹配（尽可能多的匹配）
print(re.findall(r"a+","aaabaa"))# 贪婪匹配（尽可能多的匹配）
print(re.findall(r"a{3}","aa"))
print(re.findall(r"a{3}","aaaa"))
print(re.findall(r"a{3}","aaaaa"))
print(re.findall(r"a{3}","aaabaa"))
print(re.findall(r"a{3,}","aaaaa"))
print(re.findall(r"a{3,}","aaa"))
print(re.findall(r"a{3,}","aa"))
print(re.findall(r"a{3,}","aaaaabaaa"))# 贪婪匹配（尽可能多的匹配）
print(re.findall(r"a{3,6}","aaaaabaaa"))
print(re.findall(r"((s|S)unck)","sunck--Sunck"))
print(re.findall(r"((s|S)unck)","sunck--SuNck"))
# 需求，提取sunck……man,
str = "sunck is a good man!sunck is a nice man!sunck is a very handsome man "
print(re.findall(r"^sunck.*man",str))
print(re.findall(r"^sunck.*man$",str))
print("-------------------特殊-------------------------")
'''
*? +? x? 最小匹配 通常都是尽快可能多的匹配，可以用这种方式解决贪婪匹配
(?:x) 类似（xyz),但不表示一个组
'''
# 注释： /* part1 */ /* part2 /*
print(re.findall(r"//*.*/*/",r"/* part1 */ /* part2 */"))
print(re.findall(r"（^sunck(.*?)man$)",str))
import re
print("--------------匹配单个字符与数字--------------")
'''
r
. 匹配除换行符以外的任意字符
[0123456789] []是字符集合，表示匹配方括号中所包含的任意一个字符
[sunck] 匹配's','u','n','c','k'中任意一个字符
[a-z] 匹配任意小写字母
[A-Z] 匹配任意大写字母
[0-9] 匹配任意数字，类似[0123456789]
[0-9a-zA-Z] 匹配任意的数字和字母（注意之间没有空格）
[0-9a-zA-Z_] 匹配任意的数字、字母、下划线（注意之间没有空格）
[^sunck] 匹配除了sunck这几个字母以外的所有字符
^称为脱字符，表示不匹配集合中的字符
[^0-9] 匹配所有的非数字字符
\d 匹配数字，效果[0-9]
\D 匹配非数字字符，效果同[^0-9]
\w 匹配数字，字母和下划线，效果同[0-9a-zA-Z_]
\W 匹配非数字，字母和下划线，效果同[^0-9a-zA-Z_]
\s 匹配任意的空白符（格，换行，回车，换页，制表），效果同
[ \f\n\r\t]
\S 匹配任意的非空白符，效果同[^ \f\n\r\t]
'''
print(re.search(".","sunck is a good man "))
print(re.search("[0123456789]","sunck is a good man 3"))
print(re.search("[sunck]","sunck is a good man 3"))
print(re.findall("[\d]","sunck is a good man 3"))
print(re.search("\D","sunck is a good man 3"))
print(re.search("\w","_sunck is a good man 3"))
print(re.findall("\d","_sunck is 6a go80d man 3" ))
print("-------------------锚字符（边界字符）-------------------")
'''
^ 行首匹配，和[]里的^不是一个意思
$ 行尾匹配
\A 匹配字符串开始，它和^的区别是，\A只匹配整个字符串的开头，即使
在re.M模式下也不会匹配他行的行首
\Z 匹配字符串的结束，它和$的区别是，\Z只匹配整个字符串的结束，即使
在re.M模式下也不会匹配他行的行尾
\b 匹配一个单词的边界，也就是指单词和空格间的位置
'er\b'可以匹配never,不能匹配nerve
\B 匹配非单词边界
'''
print(re.search("^sunck","sunck si a good man"))
print(re.search("sunck$","sunck si a good man"))
print(re.search("man$","sunck si a good man"))
print(re.search("^man$","sunck si a good man"))
print(re.search("^sunck","sunck si a good man\nsunck is a nice man"))
print(re.search("A\sunck","sunck si a good man\nsunck is a nice man"))
print(re.search("^sunck","sunck si a good man\nsunck is a nice man",re.M))
print(re.search("A\sunck","sunck si a good man\nsunck is a nice man",re.M))
print(re.search(r"er\b","never"))
print(re.search(r"er\b","nerve"))
print(re.search(r"er\B","never"))
print(re.search(r"er\B","nerve"))
print("-------------------------匹配多个字符-------------------------")
'''
说明：下方的x,y,z,n均为假设的普通字符，不是正则表达式的元字符（xyz)
匹配小括号内的xyz(作为一个整体去匹配）
x? 匹配0个或者任意1个x
x* 匹配0个或者任意多个x（.*表示匹配0个或者任意多个字符（换行符除外））
x+ 匹配至少一个x
x{n} 匹配确定的n个x（n是一个非负整数）
x{n,} 匹配至少n个x
x{n,m}匹配至少n个最多m个。注意：n <= m
x|y |表示或，匹配的是x或y
'''
print(re.findall(r"(sunck)","sunck is a good man ,sunck is a nice man "))
print(re.findall(r"0?","sunck is a good man ,sunck is a nice man "))
print(re.findall(r"a?","aaa")) # 非贪婪匹配（尽可能少的匹配）
print(re.findall(r"a*","aaabaa")) # 贪婪匹配（尽可能多的匹配）
print(re.findall(r".*","aaabaa"))# 贪婪匹配（尽可能多的匹配）
print(re.findall(r"a+","aaa"))# 贪婪匹配（尽可能多的匹配）
print(re.findall(r"a+","aaabaa"))# 贪婪匹配（尽可能多的匹配）
print(re.findall(r"a{3}","aa"))
print(re.findall(r"a{3}","aaaa"))
print(re.findall(r"a{3}","aaaaa"))
print(re.findall(r"a{3}","aaabaa"))
print(re.findall(r"a{3,}","aaaaa"))
print(re.findall(r"a{3,}","aaa"))
print(re.findall(r"a{3,}","aa"))
print(re.findall(r"a{3,}","aaaaabaaa"))# 贪婪匹配（尽可能多的匹配）
print(re.findall(r"a{3,6}","aaaaabaaa"))
print(re.findall(r"((s|S)unck)","sunck--Sunck"))
print(re.findall(r"((s|S)unck)","sunck--SuNck"))
# 需求，提取sunck……man,
str = "sunck is a good man!sunck is a nice man!sunck is a very handsome man "
print(re.findall(r"^sunck.*man",str))
print(re.findall(r"^sunck.*man$",str))
print("-------------------特殊-------------------------")
'''
*? +? x? 最小匹配 通常都是尽快可能多的匹配，可以用这种方式解决贪婪匹配
(?:x) 类似（xyz),但不表示一个组
'''
# 注释： /* part1 */ /* part2 /*
print(re.findall(r"//*.*/*/",r"/* part1 */ /* part2 */"))
print(re.findall(r"（^sunck(.*?)man$)",str))
import re
print("--------------匹配单个字符与数字--------------")
'''
r
. 匹配除换行符以外的任意字符
[0123456789] []是字符集合，表示匹配方括号中所包含的任意一个字符
[sunck] 匹配's','u','n','c','k'中任意一个字符
[a-z] 匹配任意小写字母
[A-Z] 匹配任意大写字母
[0-9] 匹配任意数字，类似[0123456789]
[0-9a-zA-Z] 匹配任意的数字和字母（注意之间没有空格）
[0-9a-zA-Z_] 匹配任意的数字、字母、下划线（注意之间没有空格）
[^sunck] 匹配除了sunck这几个字母以外的所有字符
^称为脱字符，表示不匹配集合中的字符
[^0-9] 匹配所有的非数字字符
\d 匹配数字，效果[0-9]
\D 匹配非数字字符，效果同[^0-9]
\w 匹配数字，字母和下划线，效果同[0-9a-zA-Z_]
\W 匹配非数字，字母和下划线，效果同[^0-9a-zA-Z_]
\s 匹配任意的空白符（格，换行，回车，换页，制表），效果同
[ \f\n\r\t]
\S 匹配任意的非空白符，效果同[^ \f\n\r\t]
'''
print(re.search(".","sunck is a good man "))
print(re.search("[0123456789]","sunck is a good man 3"))
print(re.search("[sunck]","sunck is a good man 3"))
print(re.findall("[\d]","sunck is a good man 3"))
print(re.search("\D","sunck is a good man 3"))
print(re.search("\w","_sunck is a good man 3"))
print(re.findall("\d","_sunck is 6a go80d man 3" ))
print("-------------------锚字符（边界字符）-------------------")
'''
^ 行首匹配，和[]里的^不是一个意思
$ 行尾匹配
\A 匹配字符串开始，它和^的区别是，\A只匹配整个字符串的开头，即使
在re.M模式下也不会匹配他行的行首
\Z 匹配字符串的结束，它和$的区别是，\Z只匹配整个字符串的结束，即使
在re.M模式下也不会匹配他行的行尾
\b 匹配一个单词的边界，也就是指单词和空格间的位置
'er\b'可以匹配never,不能匹配nerve
\B 匹配非单词边界
'''
print(re.search("^sunck","sunck si a good man"))
print(re.search("sunck$","sunck si a good man"))
print(re.search("man$","sunck si a good man"))
print(re.search("^man$","sunck si a good man"))
print(re.search("^sunck","sunck si a good man\nsunck is a nice man"))
print(re.search("A\sunck","sunck si a good man\nsunck is a nice man"))
print(re.search("^sunck","sunck si a good man\nsunck is a nice man",re.M))
print(re.search("A\sunck","sunck si a good man\nsunck is a nice man",re.M))
print(re.search(r"er\b","never"))
print(re.search(r"er\b","nerve"))
print(re.search(r"er\B","never"))
print(re.search(r"er\B","nerve"))
print("-------------------------匹配多个字符-------------------------")
'''
说明：下方的x,y,z,n均为假设的普通字符，不是正则表达式的元字符（xyz)
匹配小括号内的xyz(作为一个整体去匹配）
x? 匹配0个或者任意1个x
x* 匹配0个或者任意多个x（.*表示匹配0个或者任意多个字符（换行符除外））
x+ 匹配至少一个x
x{n} 匹配确定的n个x（n是一个非负整数）
x{n,} 匹配至少n个x
x{n,m}匹配至少n个最多m个。注意：n <= m
x|y |表示或，匹配的是x或y
'''
print(re.findall(r"(sunck)","sunck is a good man ,sunck is a nice man "))
print(re.findall(r"0?","sunck is a good man ,sunck is a nice man "))
print(re.findall(r"a?","aaa")) # 非贪婪匹配（尽可能少的匹配）
print(re.findall(r"a*","aaabaa")) # 贪婪匹配（尽可能多的匹配）
print(re.findall(r".*","aaabaa"))# 贪婪匹配（尽可能多的匹配）
print(re.findall(r"a+","aaa"))# 贪婪匹配（尽可能多的匹配）
print(re.findall(r"a+","aaabaa"))# 贪婪匹配（尽可能多的匹配）
print(re.findall(r"a{3}","aa"))
print(re.findall(r"a{3}","aaaa"))
print(re.findall(r"a{3}","aaaaa"))
print(re.findall(r"a{3}","aaabaa"))
print(re.findall(r"a{3,}","aaaaa"))
print(re.findall(r"a{3,}","aaa"))
print(re.findall(r"a{3,}","aa"))
print(re.findall(r"a{3,}","aaaaabaaa"))# 贪婪匹配（尽可能多的匹配）
print(re.findall(r"a{3,6}","aaaaabaaa"))
print(re.findall(r"((s|S)unck)","sunck--Sunck"))
print(re.findall(r"((s|S)unck)","sunck--SuNck"))
# 需求，提取sunck……man,
str = "sunck is a good man!sunck is a nice man!sunck is a very handsome man "
print(re.findall(r"^sunck.*man",str))
print(re.findall(r"^sunck.*man$",str))
print("-------------------特殊-------------------------")
'''
*? +? x? 最小匹配 通常都是尽快可能多的匹配，可以用这种方式解决贪婪匹配
(?:x) 类似（xyz),但不表示一个组
'''
# 注释： /* part1 */ /* part2 /*
print(re.findall(r"//*.*/*/",r"/* part1 */ /* part2 */"))
print(re.findall(r"（^sunck(.*?)man$)",str))
# 测试如下：
--------------匹配单个字符与数字--------------
PycharmProjects/untitled/正则表达式的元字符.py", line 119, in <module>
<_sre.SRE_Match object; span=(0, 1), match='s'>
print(re.findall(r"（^sunck(.*?)man$)",str))
<_sre.SRE_Match object; span=(20, 21), match='3'>
File "E:\lib\re.py", line 222, in findall
<_sre.SRE_Match object; span=(0, 1), match='s'>
return _compile(pattern, flags).findall(string)
['3']
File "E:\lib\re.py", line 301, in _compile
<_sre.SRE_Match object; span=(0, 1), match='s'>
p = sre_compile.compile(pattern, flags)
<_sre.SRE_Match object; span=(0, 1), match='_'>
File "E:\lib\sre_compile.py", line 562, in compile
['6', '8', '0', '3']
p = sre_parse.parse(p, flags)
-------------------锚字符（边界字符）-------------------
File "E:\lib\sre_parse.py", line 869, in parse
<_sre.SRE_Match object; span=(0, 5), match='sunck'>
raise source.error("unbalanced parenthesis")
None
sre_constants.error: unbalanced parenthesis at position 16
<_sre.SRE_Match object; span=(16, 19), match='man'>
None
<_sre.SRE_Match object; span=(0, 5), match='sunck'>
None
<_sre.SRE_Match object; span=(0, 5), match='sunck'>
None
<_sre.SRE_Match object; span=(3, 5), match='er'>
None
None
<_sre.SRE_Match object; span=(1, 3), match='er'>
-------------------------匹配多个字符-------------------------
['sunck', 'sunck']
['', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '']
['a', 'a', 'a', '']
['aaa', '', 'aa', '']
['aaabaa', '']
['aaa']
['aaa', 'aa']
[]
['aaa']
['aaa']
['aaa']
['aaaaa']
['aaa']
[]
['aaaaa', 'aaa']
['aaaaa', 'aaa']
[('sunck', 's'), ('Sunck', 'S')]
[('sunck', 's')]
['sunck is a good man!sunck is a nice man!sunck is a very handsome man']
[]
-------------------特殊-------------------------
['/* part1 */ /* part2 */']
随笔：别拿自己的无知当个性!