day23_1-re模块之转义字符、分组、方法

#!/usr/bin/env python
# -*- coding:utf-8 -*-
# ------------------------------------------------------------
# 参考资料：
# python模块（转自Yuan先生） - 狂奔__蜗牛 - 博客园
# https://www.cnblogs.com/guojintao/articles/9070485.html
# Python 正则表达式 | 菜鸟教程
# http://www.runoob.com/python/python-reg-expressions.html
# ------------------------------------------------------------
# ********************day23_1-re模块之转义字符、分组、方法 *******************
# ********************day23_1-re模块之转义字符、分组、方法 *******************
# =====>>>>>>内容概览
# =====>>>>>>内容概览


# ------------------------------------------------------------
# # 1、  与 r字符串
# # #  匹配一个特殊字符边界，比如空格 ，&，＃等
# # #  r字符串：r'': 一般用在正则表达式中，称为原始字符串，作用是将Python语法中的反斜杠转义给
# # #  取消，将其设置成为一个普通的字符串。
# # #  如  re.findall(r'
','I
 AM
 LIST
')，  r'
'中的“
”就只是一个正常的符号，python
# # #  编译器中不再具有“换行”功能，进入re模块处理的时候，按照re对于“
”的含义来处理
# # #
# # #  二十三、正则表达式中的“r”含义 - CSDN博客
# # #  https://blog.csdn.net/chushujin/article/details/81380694
# # #  正则表达式r和re - CSDN博客
# # #  https://blog.csdn.net/y15518325965/article/details/79405779
# ------------------------------------------------------------

# ------------------------------------------------------------
# # 2、r字符串补充
# # #  r字符串：r'': 一般用在正则表达式中，称为原始字符串，作用是将Python语法中的反斜杠转义给
# # #  取消，将其设置成为一个普通的字符串。
# # #  如  re.findall(r'
','I
 AM
 LIST
')，  r'
'中的“
”就只是一个正常的符号，python
# # #  编译器中不再具有“换行”功能，进入re模块处理的时候，按照re对于“
”的含义来处理
# # #
# # #  二十三、正则表达式中的“r”含义 - CSDN博客
# # #  https://blog.csdn.net/chushujin/article/details/81380694
# # #  正则表达式r和re - CSDN博客
# # #  https://blog.csdn.net/y15518325965/article/details/79405779
# ------------------------------------------------------------

# ------------------------------------------------------------
# # 3、元字符或 a|b
# # #  匹配a或b
# ------------------------------------------------------------

# ------------------------------------------------------------
# # 4、元字符之分组()
# # #  匹配括号内的表达式，也表示一个组
# # #
# ------------------------------------------------------------

# ------------------------------------------------------------
# # 5、re.search
# # # 扫描整个字符串并返回第一个成功的匹配。
# # # 匹配成功re.search方法返回一个匹配的对象，否则返回None。
# # # 我们可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。

# ------------------------------------------------------------

# ------------------------------------------------------------
# # 6、re.search.group 与 groups          ？？？
# # # group(num=0) 匹配的整个表达式的字符串，group() 可以一次输入多个组号，
# # # 在这种情况下它将返回一个包含那些组所对应值的元组。
# # #
# # # groups() 返回一个包含所有小组字符串的元组，从 1 到 所含的小组号。
# ------------------------------------------------------------

# ------------------------------------------------------------
# # 7、re.group("标签")，在re.search("(?P<标签>匹配内容与规则)",被匹配字符串)的应用
# # #
# ------------------------------------------------------------

# ------------------------------------------------------------
# # 8、re.group("标签")，在re.search("(?P<标签>匹配内容与规则)",被匹配字符串)的应用
# # #
# ------------------------------------------------------------

# ------------------------------------------------------------
# # 9、re方法的使用
# # # findall、search使用的比较多
# # # march等用的比较少
# ------------------------------------------------------------

# ------------------------------------------------------------
# # 10、re.match
# # # re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，
# # # match()就返回none。 相当于search方法加元字符^
# # #
# # # re.match(pattern, string, flags=0)
# # # pattern  匹配的正则表达式
# # # string   要匹配的字符串。
# # # flags    标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。参见：正则表达式修饰符 - 可选标志
# ------------------------------------------------------------

# ------------------------------------------------------------
# # 11、re.match.group
# # # 作用于re.search.group相同，见上面
# ------------------------------------------------------------

# ------------------------------------------------------------
# # 12、re.split
# # # split 方法按照能够匹配的子串将字符串分割后返回列表，它的使用形式如下：
# # #
# # # re.split(pattern, string[, maxsplit=0, flags=0])
# # # pattern  匹配的正则表达式
# # # string   要匹配的字符串。
# # # maxsplit 分隔次数，maxsplit=1 分隔一次，默认为 0，不限制次数。
# # # flags        标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。
# # #           参见：正则表达式修饰符 - 可选标志
# ------------------------------------------------------------

# ------------------------------------------------------------
# # 13、re.sub
# # # Python 的 re 模块提供了re.sub用于替换字符串中的匹配项。
# # #
# # # re.sub(pattern, repl, string, count=0, flags=0)
# # # pattern : 正则中的模式字符串。
# # # repl :    替换的字符串，也可为一个函数。
# # # string :  要被查找替换的原始字符串。
# # # count :   模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。
# ------------------------------------------------------------

# ------------------------------------------------------------
# # 14、re.subn
# # # Python 的 re 模块提供了re.subn用于替换字符串中的匹配项。并且返回替换的次数
# ------------------------------------------------------------

# ------------------------------------------------------------
# # 15、re.compile
# # # compile 函数用于编译正则表达式，生成一个正则表达式（ Pattern ）对象，
# # # 供 match() 和 search() 这两个函数使用。
# # # ===>>>只有少数使用的时候，使用该方式与不用，差别不大；但是在数量非常多的时候，能够非常
# # # ===>>>显著的提高程序的运行效率，原因在于，compile提前进行的编译处理，以后用到的该方法都可以不用重新
# # # ===>>>编译就可以使用
# # #
# # # re.compile(pattern[, flags])
# # # pattern : 一个字符串形式的正则表达式
# # # flags : 可选，表示匹配模式，比如忽略大小写，多行模式等，具体参数为：
# # # re.I 忽略大小写
# # # re.L 表示特殊字符集 w, W, , B, s, S 依赖于当前环境
# # # re.M 多行模式
# # # re.S 即为 . 并且包括换行符在内的任意字符（. 不包括换行符）
# # # re.U 表示特殊字符集 w, W, , B, d, D, s, S 依赖于 Unicode 字符属性数据库
# # # re.X 为了增加可读性，忽略空格和 # 后面的注释
# ------------------------------------------------------------

# ------------------------------------------------------------
# # 15、re.finditer
# # # 和 findall 类似，在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回。
# # #
# # # re.finditer(pattern, string, flags=0)
# # # pattern  匹配的正则表达式
# # # string   要匹配的字符串。
# # # flags    标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。参见：正则表
# # # 达式修饰符 - 可选标志
# ------------------------------------------------------------

# ------------------------------------------------------------
# # 16、findall、search在计算表达式中的应用
# # # 使用search 能逐次的将计算表达式中的内容取出来，清晰明了
# # # 使用findall一次性将计算表达式中的内容取出来
# # # 相比之下，在计算表达式上，search更合适一些
# ------------------------------------------------------------

# ------------------------------------------------分割线-------------------------------------------------
# ------------------------------------------------分割线-------------------------------------------------
# ------------------------------------------------分割线-------------------------------------------------

# 01 02 转义字符、分组
# 01 02 转义字符、分组
'''
# ------------------------------------------------------------
# # 1、  与 r字符串
# # #  匹配一个特殊字符边界，比如空格 ，&，＃等
# # #  r字符串：r'': 一般用在正则表达式中，称为原始字符串，作用是将Python语法中的反斜杠转义给
# # #  取消，将其设置成为一个普通的字符串。
# # #  如  re.findall(r'
','I
 AM
 LIST
')，  r'
'中的“
”就只是一个正常的符号，python
# # #  编译器中不再具有“换行”功能，进入re模块处理的时候，按照re对于“
”的含义来处理
# # #
# # #  二十三、正则表达式中的“r”含义 - CSDN博客
# # #  https://blog.csdn.net/chushujin/article/details/81380694
# # #  正则表达式r和re - CSDN博客
# # #  https://blog.csdn.net/y15518325965/article/details/79405779
# ------------------------------------------------------------
'''
#
# import re
#
# # r字符串
# b1 = re.findall('\n','I
 AM
 LIST
')
# b2 = re.findall(r'
','I
 AM
 LIST
')
# print("b1",b1)
# print("b2",b2)
#
# # 
# a1 = re.findall('I','I AM LIST')
# a2 = re.findall('^I','I AM LIST')
# a3 = re.findall('I\b','I AM LIST')
# # 使在字符串在编译器中扌安照原来的含义，在re中实现功能
# a4 = re.findall(r'I','I AM LIST')
#
# print(a1)
# print(a2)
# print(a3)
# print(a4)
#
# # D:Anaconda3python.exe D:/C_cache/py/day23-re_logging_hashlib_MoKuaiDaoRu/day23_1_re_.py
# # b1 ['
', '
', '
']
# # b2 ['
', '
', '
']
# # ['I', 'I']
# # ['I']
# # ['I']
# # ['I']
# #
# # Process finished with exit code 0






'''
# ------------------------------------------------------------
# # 2、r字符串补充
# # #  r字符串：r'': 一般用在正则表达式中，称为原始字符串，作用是将Python语法中的反斜杠转义给
# # #  取消，将其设置成为一个普通的字符串。
# # #  如  re.findall(r'
','I
 AM
 LIST
')，  r'
'中的“
”就只是一个正常的符号，python
# # #  编译器中不再具有“换行”功能，进入re模块处理的时候，按照re对于“
”的含义来处理
# # #
# # #  二十三、正则表达式中的“r”含义 - CSDN博客
# # #  https://blog.csdn.net/chushujin/article/details/81380694
# # #  正则表达式r和re - CSDN博客
# # #  https://blog.csdn.net/y15518325965/article/details/79405779
# ------------------------------------------------------------
'''
#
# import re
#
# # 这个有四个，是因为，在编译器：\代表一个原生字符，\\代表两个原生字符\,
# # 进入re后，一个是有特殊意义的，因此两个\代表在re中的原生字符，
# # 当处理结束，返回python编译器，应该是一个字符，后面编译器将它翻译为\，以此表示是原生字符
# l2 = re.findall('\\','I AM LIST？')
# l22 = re.findall(r'\','I AM LIST？')
#
# print("l2",l2)
# print("l22",l22)
#
# # D:Anaconda3python.exe D:/C_cache/py/day23-re_logging_hashlib_MoKuaiDaoRu/day23_1_re_.py
# # l2 ['\', '\', '\']
# # l22 ['\', '\', '\']
# #
# # Process finished with exit code 0








'''
# ------------------------------------------------------------
# # 3、元字符或 a|b 
# # #  匹配a或b
# ------------------------------------------------------------
'''

# import re
# # 先匹配ka，后b
# a1 = re.findall('ka|b','kakbkab')
# print(a1)
#
# # D:Anaconda3python.exe D:/C_cache/py/day23-re_logging_hashlib_MoKuaiDaoRu/day23_1_re_.py
# # ['ka', 'b', 'ka', 'b']
# #
# # Process finished with exit code 0







'''
# ------------------------------------------------------------
# # 4、元字符之分组()
# # #  匹配括号内的表达式，也表示一个组
# # #  
# ------------------------------------------------------------
'''
#
# import re
# a1 = re.findall('(abc)','abcabcabc')
# a2 = re.findall('(abc)*','abcabcabc')           # ？？？
# a3 = re.findall('(abc)+','abcabcabc')           # ？？？
# a4 = re.findall('(abc)?','abcabcabc')           # ？？？
#
# b1 = re.findall('(abc)','abccc')
# b2 = re.findall('(abc)*','abccc')
# b3 = re.findall('(abc)+','abccc')
# b4 = re.findall('(abc)?','abccc')
#
# print(a1)
# print(a2)
# print(a3)
# print(a4)
#
# print("b1",b1)
# print("b2",b2)
# print("b3",b3)
# print("b4",b4)
#
#
# # D:Anaconda3python.exe D:/C_cache/py/day23-re_logging_hashlib_MoKuaiDaoRu/day23_1_re_.py
# # ['abc', 'abc', 'abc']
# # ['abc', '']
# # ['abc']
# # ['abc', 'abc', 'abc', '']
# # b1 ['abc']
# # b2 ['abc', '', '', '']
# # b3 ['abc']
# # b4 ['abc', '', '', '']
# #
# # Process finished with exit code 0






'''
# ------------------------------------------------------------
# # 5、re.search 
# # # 扫描整个字符串并返回第一个成功的匹配。
# # # 匹配成功re.search方法返回一个匹配的对象，否则返回None。
# # # 我们可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。

# ------------------------------------------------------------
'''
#
import re
#
# a0 = re.search("d","asfd22af33asf555")
# a1 = re.search("d+","asfd22af33asf555")
# a2 = re.search("d+","asfdqwresfad")
# a3 = re.search("d[5]","asfd22af33asf555")
# print(a0)
# print(a1)
# print(a2)
# print(a3)
#
# # D:Anaconda3python.exe D:/C_cache/py/day23-re_logging_hashlib_MoKuaiDaoRu/day23_1_re_.py
# # <_sre.SRE_Match object; span=(4, 5), match='2'>
# # <_sre.SRE_Match object; span=(4, 6), match='22'>
# # None
# # <_sre.SRE_Match object; span=(13, 15), match='55'>
# #
# # Process finished with exit code 0







'''
# ------------------------------------------------------------
# # 6、re.search.group 与 groups          ？？？
# # # group(num=0)	匹配的整个表达式的字符串，group() 可以一次输入多个组号，
# # # 在这种情况下它将返回一个包含那些组所对应值的元组。
# # # 
# # # groups()	返回一个包含所有小组字符串的元组，从 1 到 所含的小组号。
# ------------------------------------------------------------
'''
#
# import re
#
# a0 = re.search("d", "asfd22af33asf555")
# a1 = re.search("d+", "asfd22af33asf555")
# a2 = re.search("d+", "asfdqwresfad")
# a3 = re.search("d[5]", "asfd22af33asf555")
# print(a0.group(),type(a0.group()))
# print(a1.group())
# # # print(a2.group())     # 报错，因为匹配不到，返回的是None，因此无法来取值
# print(a3.group())
#
# print(a0.groups())                  # ？？？？
# print(a1.groups())
# # # print(a2.groups())     # 报错，因为匹配不到，返回的是None，因此无法来取值
# print(a3.groups())
#
# # D:Anaconda3python.exe D:/C_cache/py/day23-re_logging_hashlib_MoKuaiDaoRu/day23_1_re_.py
# # 2
# # 22
# # 55
# # ()
# # ()
# # ()
# #
# # Process finished with exit code 0
#






'''
# ------------------------------------------------------------
# # 7、re.group("标签")，在re.search("(?P<标签>匹配内容与规则)",被匹配字符串)的应用
# # #
# ------------------------------------------------------------
'''
#
# import re
#
# a0 = re.search("(?P<age>d+)","asfd22af33asf555")
# a1 = re.search("(?P<name>[a-z]+)","asfd22af33asf555")
# a2 = re.search("(?P<name>[a-z]+)(?P<age>d+)","asfd22af33asf555")
#
# print(a0.group())
# print(a0.group("age"))
# print(a1.group("name"))
# print(a2.group())
# print(a2.group("name"), a2.group("age"))
#
# # D:Anaconda3python.exe D:/C_cache/py/day23-re_logging_hashlib_MoKuaiDaoRu/day23_1_re_.py
# # 22
# # 22
# # asfd
# # asfd22
# # asfd 22
# #
# # Process finished with exit code 0






'''
# ------------------------------------------------------------
# # 8、re.group("标签")，在re.search("(?P<标签>匹配内容与规则)",被匹配字符串)的应用
# # #
# ------------------------------------------------------------
'''
#
# import re
#
# a0 = re.search("(?P<age>d+)","asfd22af33asf555")
# a1 = re.search("(?P<name>[a-z]+)","asfd22af33asf555")
# a2 = re.search("(?P<name>[a-z]+)(?P<age>d+)","asfd22af33asf555")
#
# print("a0.groups() :        ",a0.groups())
# print("a0.groups("age") :   ",a0.groups("age"))
# print("a1.groups("name") :  ",a1.groups("name"))
# print("a2.groups() :        ",a2.groups())
# print("a2.groups("name") :  ",a2.groups("name"),"a2.groups("age"):    ", a2.group("age"))
#
# # D:Anaconda3python.exe D:/C_cache/py/day23-re_logging_hashlib_MoKuaiDaoRu/day23_1_re_.py
# # a0.groups() :         ('22',)
# # a0.groups("age") :    ('22',)
# # a1.groups("name") :   ('asfd',)
# # a2.groups() :         ('asfd', '22')
# # a2.groups("name") :   ('asfd', '22') a2.groups("age"):     22
# #
# # Process finished with exit code 0






# 03  re模块之方法
# 03  re模块之方法

'''
# ------------------------------------------------------------
# # 9、re方法的使用
# # # findall、search使用的比较多
# # # march等用的比较少
# ------------------------------------------------------------
'''







'''
# ------------------------------------------------------------
# # 10、re.match
# # # re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，
# # # match()就返回none。 相当于search方法加元字符^
# # # 
# # # re.match(pattern, string, flags=0)
# # # pattern	匹配的正则表达式
# # # string	要匹配的字符串。
# # # flags	标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。参见：正则表达式修饰符 - 可选标志
# ------------------------------------------------------------
'''
#
# import re
# a = re.match("d+","asfd22sf33sfd4444")
# a1 = re.match("d+","22sf33sfd4444")
#
# print(a)
# print(a1)
#
# # D:Anaconda3python.exe D:/C_cache/py/day23-re_logging_hashlib_MoKuaiDaoRu/day23_1_re_.py
# # None
# # <_sre.SRE_Match object; span=(0, 2), match='22'>
# #
# # Process finished with exit code 0







'''
# ------------------------------------------------------------
# # 11、re.match.group
# # # 作用于re.search.group相同，见上面
# ------------------------------------------------------------
'''
#
# import re
# a = re.match("d+","asfd22sf33sfd4444")
# a1 = re.match("d+","22sf33sfd4444")
#
# print(a)
# print(a1.group())
#
# # D:Anaconda3python.exe D:/C_cache/py/day23-re_logging_hashlib_MoKuaiDaoRu/day23_1_re_.py
# # None
# # 22
# #
# # Process finished with exit code 0






'''
# ------------------------------------------------------------
# # 12、re.split
# # # split 方法按照能够匹配的子串将字符串分割后返回列表，它的使用形式如下：
# # # 
# # # re.split(pattern, string[, maxsplit=0, flags=0])
# # # pattern	匹配的正则表达式
# # # string	要匹配的字符串。
# # # maxsplit	分隔次数，maxsplit=1 分隔一次，默认为 0，不限制次数。
# # # flags	    标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。
# # #           参见：正则表达式修饰符 - 可选标志
# ------------------------------------------------------------
'''
#
# import re
# a = re.split(" ","hello abc def")
# a1 = re.split("[ |]","hello abc|def")
# a2 = re.split("b","abc")
# a3 = re.split("[b]","abc")
#
# # 先取出分隔字符“a”: "abc"-->"","bc"(说明abc左边没有字符，因此为空)
# # 再取出分隔字符“b”: ("",)"bc"( 括号内表示原来的)-->"","","c"(说明bc左边没有字符，因此为空)
# a4 = re.split("[ab]","abc")
#
# # 先取出分隔字符“a”: "asdabcdabcdassbs"-->("",)"sd","bcd","bcd","ssbs"
# # 再取出分隔字符“b”: ("",)"sd","bcd","bcd","ssbs"--> ("",)"sd","","cd","","cd","ss","s"
# a5 = re.split("[ab]","asdabcdabcdassbs")
#
# print("a    ",a)
# print("a1   ",a1)
# print("a2   ",a2)
# print("a3   ",a3)
# print("a4   ",a4)
# print("a5"  ,a5)
#
#
# # D:Anaconda3python.exe D:/C_cache/py/day23-re_logging_hashlib_MoKuaiDaoRu/day23_1_re_.py
# # a     ['hello', 'abc', 'def']
# # a1    ['hello', 'abc', 'def']
# # a2    ['a', 'c']
# # a3    ['a', 'c']
# # a4    ['', '', 'c']
# # a5 ['', 'sd', '', 'cd', '', 'cd', 'ss', 's']
# #
# # Process finished with exit code 0














'''
# ------------------------------------------------------------
# # 13、re.sub
# # # Python 的 re 模块提供了re.sub用于替换字符串中的匹配项。
# # # 
# # # re.sub(pattern, repl, string, count=0, flags=0)
# # # pattern : 正则中的模式字符串。
# # # repl :    替换的字符串，也可为一个函数。
# # # string :  要被查找替换的原始字符串。
# # # count :   模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。
# ------------------------------------------------------------
'''
#
# import re
# a  = re.sub("d+","??","hello22abc33def44444")      # 连续整数看成一个整体，替换为两个“？”
# a1 = re.sub("d","??","hello22abc33def44444")       # 一个整数替换为两个“？”
#
# a2 = re.sub("d+","??","hello22abc33def44444",1)
# a3 = re.sub("d","??","hello22abc33def44444",1)
#
#
# print("a    ",a)
# print("a1   ",a1)
# print("a2   ",a2)
# print("a3   ",a3)
#
# # D:Anaconda3python.exe D:/C_cache/py/day23-re_logging_hashlib_MoKuaiDaoRu/day23_1_re_.py
# # a     hello??abc??def??
# # a1    hello????abc????def??????????
# # a2    hello??abc33def44444
# # a3    hello??2abc33def44444
# #
# # Process finished with exit code 0








'''
# ------------------------------------------------------------
# # 14、re.subn
# # # Python 的 re 模块提供了re.subn用于替换字符串中的匹配项。并且返回替换的次数
# ------------------------------------------------------------
'''
#
# import re
# a  = re.subn("d+","??","hello22abc33def44444")      # 连续整数看成一个整体，替换为两个“？”
# a1 = re.subn("d","??","hello22abc33def44444")       # 一个整数替换为两个“？”
#
# a2 = re.subn("d+","??","hello22abc33def44444",1)
# a3 = re.subn("d","??","hello22abc33def44444",1)
#
#
# print("a    ",a)
# print("a1   ",a1)
# print("a2   ",a2)
# print("a3   ",a3)
# #
# # D:Anaconda3python.exe D:/C_cache/py/day23-re_logging_hashlib_MoKuaiDaoRu/day23_1_re_.py
# # a     ('hello??abc??def??', 3)
# # a1    ('hello????abc????def??????????', 9)
# # a2    ('hello??abc33def44444', 1)
# # a3    ('hello??2abc33def44444', 1)
# #
# # Process finished with exit code 0








'''
# ------------------------------------------------------------
# # 15、re.compile
# # # compile 函数用于编译正则表达式，生成一个正则表达式（ Pattern ）对象，
# # # 供 match() 和 search() 这两个函数使用。
# # # ===>>>只有少数使用的时候，使用该方式与不用，差别不大；但是在数量非常多的时候，能够非常
# # # ===>>>显著的提高程序的运行效率，原因在于，compile提前进行的编译处理，以后用到的该方法都可以不用重新
# # # ===>>>编译就可以使用
# # #  
# # # re.compile(pattern[, flags])
# # # pattern : 一个字符串形式的正则表达式
# # # flags : 可选，表示匹配模式，比如忽略大小写，多行模式等，具体参数为：
# # # re.I 忽略大小写
# # # re.L 表示特殊字符集 w, W, , B, s, S 依赖于当前环境
# # # re.M 多行模式
# # # re.S 即为 . 并且包括换行符在内的任意字符（. 不包括换行符）
# # # re.U 表示特殊字符集 w, W, , B, d, D, s, S 依赖于 Unicode 字符属性数据库
# # # re.X 为了增加可读性，忽略空格和 # 后面的注释
# ------------------------------------------------------------
'''
#
# import re
# #
# com_num = re.compile("d+")
# a  = com_num.subn("??","hello22abc33def44444")      # 连续整数看成一个整体，替换为两个“？”
# a1 = com_num.subn("??","hello22abc33def44444")       # 一个整数替换为两个“？”
#
# a2 = com_num.subn("??","hello22abc33def44444",1)
# a3 = com_num.subn("??","hello22abc33def44444",1)
#
#
# print("a    ",a)
# print("a1   ",a1)
# print("a2   ",a2)
# print("a3   ",a3)
# #
# # D:Anaconda3python.exe D:/C_cache/py/day23-re_logging_hashlib_MoKuaiDaoRu/day23_1_re_.py
# # a     ('hello??abc??def??', 3)
# # a1    ('hello????abc????def??????????', 9)
# # a2    ('hello??abc33def44444', 1)
# # a3    ('hello??2abc33def44444', 1)
# #
# # Process finished with exit code 0
#









'''
# ------------------------------------------------------------
# # 15、re.finditer
# # # 和 findall 类似，在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回。
# # # 
# # # re.finditer(pattern, string, flags=0)
# # # pattern	匹配的正则表达式
# # # string	要匹配的字符串。
# # # flags	标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。参见：正则表
# # # 达式修饰符 - 可选标志
# ------------------------------------------------------------
'''
#
# import re
# a  = re.finditer("d+","hello22abc33def44444")      # 连续整数看成一个整体，替换为两个“？”
# a1 = re.finditer("d","hello22abc33def44444")       # 一个整数替换为两个“？”
#
# a2 = re.finditer("d+","hello22abc33def44444")
# a3 = re.finditer("d","hello22abc33def44444")
#
#
# print("a    ",a,a.__next__(),"---->>",next(a).group())
# print("a1   ",a1,a1.__next__()," ---->>",next(a1).group())
# print("a2   ",a2,a2.__next__(),"---->>",next(a2).group())
# print("a3   ",a3,a3.__next__()," ---->>",next(a3).group())
#
# # D:Anaconda3python.exe D:/C_cache/py/day23-re_logging_hashlib_MoKuaiDaoRu/day23_1_re_.py
# # a     <callable_iterator object at 0x0000000002971278> <_sre.SRE_Match object; span=(5, 7), match='22'> ---->> 33
# # a1    <callable_iterator object at 0x0000000002956E10> <_sre.SRE_Match object; span=(5, 6), match='2'>  ---->> 2
# # a2    <callable_iterator object at 0x00000000039C7FD0> <_sre.SRE_Match object; span=(5, 7), match='22'> ---->> 33
# # a3    <callable_iterator object at 0x00000000039C7F98> <_sre.SRE_Match object; span=(5, 6), match='2'>  ---->> 2
# #
# # Process finished with exit code 0







'''
# ------------------------------------------------------------
# # 16、findall、search在计算表达式中的应用
# # # 使用search 能逐次的将计算表达式中的内容取出来，清晰明了
# # # 使用findall一次性将计算表达式中的内容取出来
# # # 相比之下，在计算表达式上，search更合适一些
# ------------------------------------------------------------
'''
#
# import re
# s = "12+(34*6+2-5*(10-2*3)+(4*4+4)"
# a = re.findall("([^()]+)",s)
# a1 = re.search("([^()]+)",s)
#
# print("a    ",a)
# print("a1   ",a1,"  group方法:",a1.group())
#
# # D:Anaconda3python.exe D:/C_cache/py/day23-re_logging_hashlib_MoKuaiDaoRu/day23_1_re_.py
# # a     ['(10-2*3)', '(4*4+4)']
# # a1    <_sre.SRE_Match object; span=(13, 21), match='(10-2*3)'>   group方法: (10-2*3)
# #
# # Process finished with exit code 0