正则表达式

  1. #!/usr/bin/env python
  2. # -*- coding: utf-8 -*-
  3. # @Time    : 2018/7/26 16:39
  4. # @Author  : jackendoff
  5. # @Site    :
  6. # @File    : 正则学习.py
  7. # @Software: PyCharm
  8.  
  9. # re模块的使用过程
  10. import re
  11. # '''
  12. # re模块的使用过程
  13. # re.match(pattern, string, flags=0)
  14. # 从头匹配一个符合规则的字符串，从起始位置开始匹配，匹配成功返回一个对象，未匹配成功返回None
  15. #  · pattern: 正则模型
  16. #  · string： 要匹配的字符
  17. #  · flags： 匹配模式
  18. #  这个方法并不是完全匹配，当pattern结束时若string还有剩余字符，仍视为成功，想要完全匹配，可以在表达式末尾加上边界匹配符‘$’
  19. # '''
  20. # result = re.match('^\d{3}$', '124')
  21. # print(result.group())  # 返回被re匹配的字符串124
  22. # print(result.start())  # 返回匹配开始的位置0
  23. # print(result.end())  # 返回匹配结束的位置3
  24. # print(result.span())  # 返回一个元组包含匹配（开始，结束）的位置(0, 3)
  25.  
  26. '''
  27. re.search函数会在字符串内查找模式匹配，只要找到第一个匹配然后返回，如果字符串没有匹配，则返回None
  28. 格式：re.search(pattern, string, flags=0)
  29. match()和search()的区别：
  30. match()函数只检测re是不是在string的开始位置匹配，search()会扫描
  31. 整个string查找匹配；
  32. 也就是说match()只有在0位置匹配成功的化才有返回，如果不是开始位置匹配成功的话，match()就返回none。
  33.  
  34. '''
  35. # import re
  36. # ret = re.search(r'\d+', '阅读次数为9999')
  37. # print(ret.group())  # 运行结果9999
  38. #
  39. # print(re.match('super', 'superstition').span())  # 结果(0, 5)
  40. # print(re.match('super', 'insuperstition'))  # 结果None
  41. # print(re.search('super', 'superstition').span())  # 结果(0, 5)
  42. # print(re.search('super', 'insuperstition').span())  # 结果(2, 7)
  43.  
  44. '''
  45. re.findall遍历匹配，可以获取字符串中所有匹配字符串，返回一个列表
  46. '''
  47. # import re
  48. #
  49. # ret = re.findall(r'\d+', '阅读次数：9999次，转发次数：887次，评论次数：3次')
  50. # print(ret)  # 运行结果['9999', '887', '3']
  51.  
  52. '''
  53. sub将匹配到的数据进行替换
  54. 使用re替换string中每一个匹配的字符串后返回替换后的字符串
  55. 格式：re.sub(pattern, repl, string,count)
  56. '''
  57.  
  58. # import re
  59. #
  60. # ret = re.sub(r'\d+', '10000', '阅读次数：9999次， 转发次数：883次， 评论次数：3次')
  61. # print(ret)  # 运行结果 阅读次数：10000次， 转发次数：10000次， 评论次数：10000次
  62.  
  63. import re
  64. # def add(temp):
  65. #     strNum = temp.group()
  66. #     print(strNum)  # 运行结果997
  67. #     num = int(strNum) + 1
  68. #     return str(num)  # 返回一个字符串
  69.  
  70. # ret = re.sub(r'\d+', add, 'python = 997')  # 可以分解为result = re.search(r'\d+', 'python=997') --》add(result)
  71. # print(ret)  # 运行结果python = 998
  72. #
  73. # ret = re.sub(r'\d+', add, 'python = 99')
  74. # print(ret)  # 运行结果python = 100
  75.  
  76. '''
  77. import re
  78. def add(temp):
  79.     strNum = temp.group()
  80.     print(strNum)  # 运行结果997
  81.     num = int(strNum) + 1
  82.     return str(num)
  83. result = re.search(r'\d+', 'python=997')
  84. print(add(result))
  85. '''
  86.  
  87. '''
  88. split根据匹配进行切割字符串，并返回一个列表
  89. 按照能够匹配的字符串string分割都返回列表。
  90. 可以使用re.split来分割字符串
  91. 格式：re.split(pattern, string[,maxspit])
  92.  
  93. '''
  94.  
  95. import re
  96.  
  97. ret = re.split(r":| ", 'info:xiaozhang 33 shandong')
  98. print(ret)  # 运行结果 ['info', 'xiaozhang', '33', 'shandong']
  99.  
  100. '''
  101. pyhton里数量词默认是贪婪的，总是尽可能多地匹配字符；
  102. 非贪婪则相反，总是尝试匹配尽可能少的字符
  103. 在'*','+','?','{m, n}后面加上？，使贪婪变为非贪婪。'
  104. '''

　　

量词：

　　* 重复0次或更多次

　　+ 重复一次或更多次

　　？重复0次或一次

　　{n} 重复n次

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

　　{n,m} 重复n到m次

　　贪心匹配（默认）

　　惰性匹配： 量词 + ''?''

　　.*?x 前面取任意长度字符直到取到x

字符：

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

　　\w 匹配字母或数字或下划线

　　\d 匹配数字(digit)

　　\s 匹配任意空白符（space）

　　\n 匹配一个换行符

　　\t 匹配一个制表符（TAB）

　　\b 匹配一个单词的结尾

　　^ 匹配字符串的开始

　　$ 匹配字符串的结尾

　　\W 匹配非字母或数字或下划线

　　\D 匹配非数字

　　\S 匹配非空白符

　　a|b 匹配字符a或者字符b

　　( ) 匹配括号内的表达式，也表示一个组（search）

　　[...] 匹配字符组中的字符

　　[^...] 匹配除字符组以外的所有字符

pyhton re模块

python正则

  1.  #!/usr/bin/env python
  2.  # -*- coding: utf-8 -*-
  3.  # @Time    : 2018/7/8 9:27
  4.  # @Author  : jackendoff
  5.  # @Site    :
  6.  # @File    : text.py
  7.  # @Software: PyCharm
  8.  
  9.  import re
  10.  
  11.  # find_str = re.findall('a', 'jai jack')  # 匹配所有，并显示所有
  12.  # print(find_str)
  13.  #
  14.  # search_str = re.search('a', 'jia jack')  # 匹配找到的第一个，并显示
  15.  # print(search_str)
  16.  # search_gp = search_str.group()
  17.  # print(search_gp)
  18.  #
  19.  # match_str = re.match('a', 'a bc')  # 匹配第一个
  20.  # print(match_str)
  21.  # match_gp = match_str.group()
  22.  # print(match_gp)
  23.  #
  24.  # find_str = re.findall('[a-z]\d', 'ji58a991')  # 匹配a-z和数字
  25.  # print(find_str)
  26.  # find_str = re.findall('([a-z])\d', 'ji58a991')  # 匹配a-z和数字
  27.  # print(find_str)
  28.  # find_str = re.findall('(?:[a-z])\d', 'ji58a991')  # ()代表‘组’在findall里优先显示  '?:'代表‘取消优先’
  29.  # print(find_str)
  30.  #
  31.  # search_str = re.search('([a-z])(\d)', 'jia123nfdj8684')  # 匹配a-z和数字 分组
  32.  # search_gpp = search_str.group()  # 显示匹配的数字和字母
  33.  # print(search_gpp)
  34.  # search_gp = search_str.group(1)  # 显示第一个组
  35.  # print(search_gp)
  36.  # search_gp = search_str.group(2)  # 显示第二个组
  37.  # print(search_gp)
  38.  
  39.  # sp_str = re.split('\d', 'jia4jfa5f78a')  # 依据数字分割
  40.  # print(sp_str)
  41.  # split_str = re.split('[a1]', 'jiafd54f1k')  # 先根据a分割，仔根据1分割
  42.  # print(split_str)
  43.  #
  44.  # sub_str = re.sub('[\d]', '0', 'jia123fd6', 2)  # 将数字替换成0，2表示只替换两个
  45.  # print(sub_str)
  46.  # sub_str = re.subn('[\d]', '0', 'jia123fd6')  # 将数字替换成0，返回一个元组（替换的结果，替换了多少次）
  47.  # print(sub_str)
  48.  
  49.  # obj = re.compile('\d{3}')  # 将正则表达式编译成一个正则对象（当表达式特别复杂的时候此对象可以多次使用）匹配三个数字
  50.  # obj_str = obj.search('jia123kill')  # 直接使用对象调用search进行匹配
  51.  # o_str = obj_str.group()
  52.  # print(o_str)
  53.  
  54.  # ret = re.finditer('\d', 'jia5fd55fs6f5')  # finditer返回一个存放匹配结果的迭代器（节省内存)
  55.  # print(ret)
  56.  # # for i in ret:
  57.  #     print(i.group())

正则案例，windows命令行  超多

  1. 1. 初步使用
  2. In [1]: import re
  3. In [11]: re.match(r"abc","abcde").group()
  4. In [12]: re.match(r"bc","abcde").group()
  5. In [14]: re.search(r"bc","abcde").group()
  6.  
  7. 2. 匹配单个字符
  8. -----------------------.匹配任意字符(除\n)-------------------------------
  9. In [5]: re.match(r".","A").group()
  10. In [6]: re.match(r".","a").group()
  11. In [7]: re.match(r".",".").group()
  12. In [8]: re.match(r".","\n").group()
  13. In [9]: re.match(r".","x").group()
  14. In [10]: re.match(r"A.C","ABC").group()
  15.  
  16. -------------------------[]匹配集合中任何一个字符---------------------------
  17. In [11]: re.match(r"[aA]BC","ABC").group()
  18. In [12]: re.match(r"[aA]BC","aBC").group()
  19. In [13]: re.match(r"[aA]BC","xBC").group()
  20. In [14]: re.match(r"[0123456789]BC","1BC").group()
  21. In [15]: re.match(r"[0123456789]BC","9BC").group()
  22. -------------------------[-]表示范围-----------------------------
  23. In [16]: re.match(r"[0-9]BC","9BC").group()
  24. In [17]: re.match(r"[0-9]BC","2BC").group()
  25. In [18]: re.match(r"[0-9a-zA-Z]BC","ABC").group()
  26. In [19]: re.match(r"[0-9a-zA-Z]BC","aBC").group()
  27. In [21]: re.match(r"[0-9a-zA-Z]BC","&BC").group()
  28. In [22]: re.match(r"[0-35-9]BC","1BC").group()
  29. In [24]: re.match(r"[0-35-9]BC","4BC").group()
  30. -------------------------[^]对匹配范围取反-----------------------------
  31. In [25]: re.match(r"[^4]BC","4BC").group()
  32. In [26]: re.match(r"[^4]BC","1BC").group()
  33. In [27]: re.match(r"[^4]BC","9BC").group()
  34. In [28]: re.match(r"[^4a-z]BC","aBC").group()
  35. In [29]: re.match(r"[^4a-z]BC","zBC").group()
  36. In [30]: re.match(r"[^4a-z]BC","ZBC").group()
  37.  
  38. -------------------------\d匹配数字字符 \D匹配非数字---------------------
  39. In [31]: re.match(r"[0-9]BC","4BC").group()
  40. In [32]: re.match(r"\dBC","4BC").group()
  41. In [33]: re.match(r"\dBC","2BC").group()
  42.  
  43. In [34]: re.match(r"\DBC","2BC").group()
  44. In [35]: re.match(r"\DBC","aBC").group()
  45. In [36]: re.match(r"\DBC","xBC").group()
  46. --------------------------\w匹配单词字符 \w匹配非单词------------------------
  47. In [38]: re.match(r"\wBC", "ABC").group()
  48. In [39]: re.match(r"\wBC", "aBC").group()
  49. In [40]: re.match(r"\wBC", "1BC").group()
  50. In [41]: re.match(r"\wBC", "_BC").group()
  51. In [42]: re.match(r"[\da-zA-Z_]BC", "1BC").group()
  52. In [43]: re.match(r"[\da-zA-Z_]BC", "ABC").group()
  53. In [44]: re.match(r"[\da-zA-Z_]BC", "aBC").group()
  54. In [45]: re.match(r"[\da-zA-Z_]BC", "_BC").group()
  55.  
  56. In [46]: re.match(r"\WBC", "_BC").group()
  57. In [47]: re.match(r"\WBC", "$BC").group()
  58. In [48]: re.match(r"\WBC", " BC").group()
  59.  
  60. 3. 匹配多个字符
  61. In [50]: re.match(r"嫦娥\w号", "嫦娥一号升空了", re.A).group()
  62. In [51]: re.match(r"嫦娥\d号", "嫦娥1号升空了", re.A).group()
  63. In [52]: re.match(r"嫦娥\d\d号", "嫦娥11号升空了", re.A).group()
  64. In [53]: re.match(r"嫦娥\d\d\d号", "嫦娥111号升空了", re.A).group()
  65. In [54]: re.match(r"嫦娥\d\d\d\d\d\d号", "嫦娥111111号升空了", re.A).group()
  66.  
  67. In [55]: re.match(r"嫦娥\d{6}号", "嫦娥111111号升空了", re.A).group()
  68. In [56]: re.match(r"嫦娥\d{6}号", "嫦娥11号升空了", re.A).group()
  69. In [57]: re.match(r"嫦娥\d{2,6}号", "嫦娥11号升空了", re.A).group()
  70. In [58]: re.match(r"嫦娥\d{2,6}号", "嫦娥11111号升空了", re.A).group()
  71.  
  72. In [59]: re.match(r"嫦娥\d{1,}号", "嫦娥11111号升空了").group()
  73. In [60]: re.match(r"嫦娥\d{1,}号", "嫦娥11111111111号升空了").group()
  74. In [61]: re.match(r"嫦娥\d+号", "嫦娥11111111111号升空了").group()
  75. In [63]: re.match(r"嫦娥\d+号", "嫦娥号升空了").group()
  76.  
  77. In [64]: re.match(r"嫦娥\d{0,}号", "嫦娥号升空了").group()
  78. In [65]: re.match(r"嫦娥\d{0,}号", "嫦娥1111号升空了").group()
  79. In [66]: re.match(r"嫦娥\d*号", "嫦娥1111号升空了").group()
  80. In [67]: re.match(r"嫦娥\d*号", "嫦娥号升空了").group()
  81.  
  82. In [81]: re.match(r"嫦娥\d{0,1}号", "嫦娥号升空了").group()
  83. In [82]: re.match(r"嫦娥\d{0,1}号", "嫦娥1号升空了").group()
  84. In [83]: re.match(r"嫦娥\d?号", "嫦娥1号升空了").group()
  85. In [84]: re.match(r"嫦娥\d?号", "嫦娥11号升空了").group()
  86.  
  87. 4. 匹配开始和结束位置
  88. 	.在正则中表示匹配除\n之外的任意字符  如果要再正则中表示.本身的含义 使用\.
  89.  
  90. In [68]: re.match(r"\w@163.com","123456@163.com").group()
  91. In [69]: re.match(r"\w{4,20}@163.com","123456@163.com").group()
  92. In [70]: re.match(r"\w{4,20}@163.com","123456@163Acom").group()
  93. In [71]: re.match(r"\w{4,20}@163\.com","123456@163Acom").group()
  94. In [72]: re.match(r"\w{4,20}@163\.com","123456@163.com").group()
  95.  
  96. In [73]: re.match(r"\w{4,20}@163\.com","123456@163.com.cc").group()
  97. In [74]: re.match(r"\w{4,20}@163\.com",".ccc.123456@163.com").group()
  98. In [75]: re.match(r"\w{4,20}@163\.com","123456@163.com.cc").group()
  99. In [76]: re.match(r"\w{4,20}@163\.com$","123456@163.com.cc").group()
  100. In [77]: re.search(r"\w{4,20}@163\.com$","123456@163.com.cc").group()
  101. In [78]: re.search(r"\w{4,20}@163\.com$","ccc.123456@163.com").group()
  102. In [79]: re.match(r"\w{4,20}@163\.com$","ccc.123456@163.com").group()
  103.  
  104. In [80]: re.search(r"^\w{4,20}@163\.com$","ccc.123456@163.com").group()
  105. In [81]: re.search(r"^\w{4,20}@163\.com$","123456@163.com").group()
  106.  
  107. 5. 分组
  108.  
  109. ----------------------()将感兴趣的数据放到分组中-------------------------
  110. In [86]: re.match(r"嫦娥\d+号", "嫦娥9号升空了").group()
  111. In [87]: re.match(r"嫦娥(\d+)号", "嫦娥9号升空了").group()
  112. In [88]: re.match(r"嫦娥(\d+)号", "嫦娥9号升空了").group(0)
  113. In [89]: re.match(r"嫦娥(\d+)号", "嫦娥9号升空了").group(1)
  114. In [90]: re.search(r"(^\w{4,20})@163\.com$","123456@163.com").group(1)
  115. In [91]: re.search(r"(^\w{4,20})@(163)\.com$","123456@163.com").group(1)
  116. In [92]: re.search(r"(^\w{4,20})@(163)\.com$","123456@163.com").group(2)
  117.  
  118. ----------------------|匹配左右任何一个正则表达式--------------------------
  119. In [93]: re.search(r"(^\w{4,20})@163\.com$|^\w{4,20}@qq\.com$","123456@163.com").group(1)
  120. In [94]: re.search(r"(^\w{4,20})@163\.com$|^\w{4,20}@qq\.com$","123456@163.com").group(0)
  121. In [95]: re.search(r"(^\w{4,20})@163\.com$|^\w{4,20}@qq\.com$","123456@qq.com").group(0)
  122.  
  123. ---------------------(|)匹配()中任何一个正则表达式并将匹配结果放到分组中-------
  124. In [96]: re.search(r"(^\w{4,20})@(163|qq)\.com$","123456@qq.com").group(0)
  125. In [97]: re.search(r"(^\w{4,20})@(163|qq)\.com$","123456@163.com").group(0)
  126. In [98]: re.search(r"(^\w{4,20})@(163|qq)\.com$","123456@263.com").group(0)
  127. In [99]: re.search(r"(^\w{4,20})@(163|qq|263)\.com$","123456@263.com").group(0)
  128. In [100]: re.search(r"(^\w{4,20})@(163|qq|263|126)\.com$","123456@263.com").group(0)
  129. In [101]: re.search(r"(^\w{4,20})@(163|qq|263|126)\.com$","123456@263.com").group(1)
  130. In [102]: re.search(r"(^\w{4,20})@(163|qq|263|126)\.com$","123456@263.com").group(2)
  131.  
  132. ---------------------引用分组(匿名 只能通过分组号引用)--------------------------------
  133. In [103]: re.match(r"<\w+>.*", "<html>hh</html>").group()
  134. In [104]: re.match(r"<(\w+)>.*", "<html>hh</html>").group()
  135. In [105]: re.match(r"<(\w+)>.*", "<html>hh</html>").group(1)
  136. In [106]: re.match(r"<(\w+)>.*</\1>", "<html>hh</html>").group(1)
  137. In [107]: re.match(r"<(\w+)>.*</\1>", "<html>hh</htm>").group(1)
  138. In [108]: re.match(r"<(\w+)><(\w+)>(.*)</\2></\1>", "<html><h1>www.itcast.cn</h1></html>").group(1)
  139. In [109]: re.match(r"<(\w+)><(\w+)>(.*)</\2></\1>", "<html><h1>www.itcast.cn</h1></html>").group()
  140. In [110]: re.match(r"<(\w+)><(\w+)>(.*)</\2></\1>", "<html><h1>www.itcast.cn</h2></html>").group()
  141.  
  142. In [111]: re.match(r"(\d{3,4})-(\d{6,8})", "010-12345678").group(1)
  143. In [112]: re.match(r"(\d{3,4})-(\d{6,8})", "010-12345678").group(2)
  144. In [113]: re.match(r"((\d{3,4})-(\d{6,8}))", "010-12345678").group(2)
  145. In [114]: re.match(r"((\d{3,4})-(\d{6,8}))", "010-12345678").group(1)
  146. In [115]: re.match(r"((\d{3,4})-(\d{6,8}))", "010-12345678").group(3)
  147.  
  148. ------------------创建有名分组 给分组起名  使用有名分组------------------------
  149. In [116]: re.match(r"((?P<quhao>\d{3,4})-(?P<zuoji>\d{6,8}))", "010-12345678").group(3)
  150. In [118]: re.match(r"(?P<quhao>\d{3,4})-(?P<zuoji>\d{6,8}) (?P=quhao)-(?P=zuoji)", "010-12345678 010-12345678").group()
  151.  
  152. In [119]: re.match(r"(?P<quhao>\d{3,4})-(?P<zuoji>\d{6,8}) (?P=quhao)-(?P=zuoji)", "010-12345678 010-12345678").group(1)
  153.  
  154. In [120]: re.match(r"(?P<quhao>\d{3,4})-(?P<zuoji>\d{6,8}) (?P=quhao)-(?P=zuoji)", "010-12345678 010-12345678").group(2)
  155.  
  156. In [121]: re.match(r"((?P<quhao>\d{3,4})-(?P<zuoji>\d{6,8})) (?P=quhao)-(?P=zuoji)", "010-12345678 010-12345678").group(2)
  157.  
  158. In [122]: re.match(r"((?P<quhao>\d{3,4})-(?P<zuoji>\d{6,8})) (?P=quhao)-(?P=zuoji)", "010-12345678 010-12345678").group(1)
  159.  
  160. In [123]: re.match(r"((?P<quhao>\d{3,4})-(?P<zuoji>\d{6,8})) (?P=quhao)-(?P=zuoji)", "010-12345678 010-12345678").group(2)
  161.  
  162. In [124]: re.match(r"((?P<quhao>\d{3,4})-(?P<zuoji>\d{6,8})) (?P=quhao)-(?P=zuoji)", "010-12345678 010-12345678").group(3)
  163.  
  164. 6. 高级函数
  165. ----------------------------------------------------------------------------
  166. In [127]: ret = re.match(r"\d+", "阅读次数为 9999").group()
  167. In [129]: ret = re.search(r"\d+", "阅读次数为 9999").group()
  168. In [131]: re.search(r"\d+", "阅读次数为 9999").group()
  169.  
  170. ----------------------------------------------------------------------------
  171.  
  172. In [132]: re.findall(r"\d+", "阅读次数为 9999").group()  # 不可以用.group()
  173. In [133]: re.findall(r"\d+", "阅读次数为 9999")
  174. In [134]: re.findall(r"\d+", "阅读次数为")  # 没匹配到返回空列表
  175.  
  176. ----------------------------------------------------------------------------
  177. In [135]: re.sub(r"\d+","999", "python=666")
  178. In [136]: re.sub(r"\d+","999", "python=666 cpp=688")
  179. In [137]: re.sub(r"\d+","999", "python=666 cpp=688", 1)
  180. In [138]: re.sub(r"\d+","999", "python=666 cpp=688")
  181.  
  182. In [139]: def add(matchobj):
  183.      ...:     data = matchobj.group()
  184.      ...:     number = int(data) + 1000
  185.      ...:     return str(number)
  186.  
  187. In [140]: re.sub(r"\d+",add, "python=666 cpp=688")
  188.  
  189. In [141]: data = """
  190.      ...: <div>
  191.      ...:         <p>岗位职责：</p>
  192.      ...: <p>完成推荐算法、数据统计、接口、后台等服务器端相关工作</p>
  193.      ...: <p><br></p>
  194.      ...: <p>必备要求：</p>
  195.      ...: <p>良好的自我驱动力和职业素养，工作积极主动、结果导向</p>
  196.      ...: <p> <br></p>
  197.      ...: <p>技术要求：</p>
  198.      ...: <p>1、一年以上 Python 开发经验，掌握面向对象分析和设计，了解设计模式</p>
  199.      ...: <p>2、掌握HTTP协议，熟悉MVC、MVVM等概念以及相关WEB开发框架</p>
  200.      ...: <p>3、掌握关系数据库开发设计，掌握 SQL，熟练使用 MySQL/PostgreSQL 中的一种<br></p>
  201.      ...: <p>4、掌握NoSQL、MQ，熟练使用对应技术解决方案</p>
  202.      ...: <p>5、熟悉 Javascript/CSS/HTML5，JQuery、React、Vue.js</p>
  203.      ...: <p> <br></p>
  204.      ...: <p>加分项：</p>
  205.      ...: <p>大数据，数理统计，机器学习，sklearn，高性能，大并发。</p>
  206.      ...:
  207.      ...:         </div>"""
  208.  
  209. In [142]: re.sub(r"<\w+>","",data)
  210. In [143]: re.sub(r"<\w+>|\n","",data)
  211. In [144]: re.sub(r"<\w+>|\n|</\w+>","",data)
  212. In [145]: re.sub(r"</?\w+>|\n|","",data)
  213. In [146]: re.sub(r"</?\w+>|\n| ","",data)
  214.  
  215. 7. 贪婪模式和非贪婪模式<>
  216. ----------------------------------------------------------------------------
  217. In [147]: re.split(r"\s","123456_abcdef ghjkl\t12312312")
  218. In [148]: re.split(r"\s|_","123456_abcdef ghjkl\t12312312")
  219. In [149]: re.search(r"\d+", "嫦娥199999号升空了")
  220. In [150]: re.search(r"\d+", "嫦娥1999999999号升空了").group()
  221. In [151]: re.search(r"\d+\d+", "1999999999").group()
  222. In [152]: re.search(r"(\d+)(\d+)", "1999999999").group()
  223. In [153]: re.search(r"(\d+)(\d+)", "1999999999").group(1)
  224. In [154]: re.search(r"(\d+)(\d+)", "1999999999").group(2)
  225. In [155]: re.search(r"(\d+?)(\d+)", "1999999999").group(2)
  226.  
  227. In [156]: re.search(r"(\d+?)(\d+)", "1999999999").group(1)
  228. In [157]: url = """<img data-original="https://rpic.douyucdn.cn/appCovers/2016/11/13/1213973_2016111319
  229.      ...: 17_small.jpg" src="https://rpic.douyucdn.cn/appCovers/2016/11/13/1213973_201611131917_small.j
  230.      ...: pg" style="display: inline;">
  231.      ...: """
  232.  
  233. In [158]: re.search(r"https:.*\.jpg",url).group()
  234. In [159]: re.search(r"https:.*?\.jpg",url).group()
  235.  
  236. 8 r标识原生字符串
  237. ----------------------------------------------------------------------------
  238. In [160]: path = "c:\a\b\c"
  239. In [161]: path
  240. Out[161]: 'c:\x07\x08\\c'
  241.  
  242. In [162]: print(path)
  243. c\c
  244. In [163]: path = "c:\\a\\b\\c"
  245.  
  246. In [164]: path
  247. Out[164]: 'c:\\a\\b\\c'
  248.  
  249. In [165]: path = "c:\\a\\b\c"
  250. Out[166]: 'c:\\a\\b\\c'
  251.  
  252. In [167]: re.match("c:\\a",path).group()
  253. In [168]: re.match(r"c:\\a",path).group()
  254. In [169]: re.match("c:\\\\a",path).group()
  255. In [170]: re.match("c:\\\\a\\\\b",path).group()
  256. In [171]: re.match("c:\\\\a\\\\b\\\\c",path).group()
  257. In [172]: re.match(r"c:\\a\\b\\c",path).group()

　　

regex(python)的更多相关文章

  1. Python 正则表达式(RegEx)

    版权所有,未经许可,禁止转载 章节 Python 介绍 Python 开发环境搭建 Python 语法 Python 变量 Python 数值类型 Python 类型转换 Python 字符串(Str ...

  2. Python re 模块

    Python re 模块 TOC 介绍 作用 正则表达式语法 贪婪和非贪婪 普通字符和特殊字符 分组(比较重要) re modul level 方法 正则表达式对象 匹配对象 常用例子 注意事项 Ja ...

  3. Python正则表达式与re模块

    在线正则表达式测试 http://tool.oschina.net/regex/ 常见匹配模式 模式 描述 \w 匹配字母数字及下划线 \W 匹配非字母数字下划线 \s 匹配任意空白字符,等价于 [\ ...

  4. Python 删除文件与文件夹

    版权所有,未经许可,禁止转载 章节 Python 介绍 Python 开发环境搭建 Python 语法 Python 变量 Python 数值类型 Python 类型转换 Python 字符串(Str ...

  5. Python 异常处理(Try...Except)

    版权所有,未经许可,禁止转载 章节 Python 介绍 Python 开发环境搭建 Python 语法 Python 变量 Python 数值类型 Python 类型转换 Python 字符串(Str ...

  6. Python 打开文件(File Open)

    版权所有,未经许可,禁止转载 章节 Python 介绍 Python 开发环境搭建 Python 语法 Python 变量 Python 数值类型 Python 类型转换 Python 字符串(Str ...

  7. Python PIP包管理器

    版权所有,未经许可,禁止转载 章节 Python 介绍 Python 开发环境搭建 Python 语法 Python 变量 Python 数值类型 Python 类型转换 Python 字符串(Str ...

  8. 正则表达式(BREs,EREs,PREs)差异比较

    我想各位也和我一样,再linux下使用grep,egrep, awk , sed, vi的搜索时,会经常搞不太清楚,哪此特殊字符得使用转义字符'\' ..   哪些不需要, grep与egrep的差异 ...

  9. 【转】linux shell 正则表达式(BREs,EREs,PREs)差异比较

    我想各位也和我一样,再linux下使用grep,egrep, awk , sed, vi的搜索时,会经常搞不太清楚,哪此特殊字符得使用转义字符'\' ..   哪些不需要, grep与egrep的差异 ...

随机推荐

  1. ntp时间同步服务器

    [root@localhost ~]# ntpdate time.nist.gov 虚拟机时间不对   自动同步   sudo ntpdate asia.pool.ntp.org 要是同步后时间还是不 ...

  2. C语言-逃逸字符、类型转换和布尔类型

    C语言-逃逸字符 逃逸字符是用来表达无法印出来的控制字符或者特殊字符,它由一个反斜杠""开头,后面跟上另一个字符,这两个字符合起来,组成一个字符. \b是backspace,在su ...

  3. [题解] LuoguP4389 付公主的背包

    这个题太神辣- 暴力背包就能获得\(30\)分的好成绩...... \(60\)分不知道咋搞..... 所以直接看\(100\)分吧\(QwQ\) 用一点生成函数的套路,对于一个体积为\(v\)的物品 ...

  4. xxe

    XXE xml external entity injection xml外部实体注入 概述 xml是可扩展的标记语言,涉及被用来传输.存储数据 html被用来显示数据 其中xml的标签没有预定义的, ...

  5. 吴裕雄--天生自然JAVA SPRING框架开发学习笔记：Spring框架的基本思想

    EJB的学习成本很高,开发效率却不高,需要编写很多重复的代码,这些问题阻止了EJB的继续发展.就在EJB技术止步不前的时候,Spring框架在合适的时机出现了,Spring框架和EJB不同,Sprin ...

  6. jobs|ps|杀死nohup

    方法1:如果没有退出客户端界面,可以先通过 “jobs” 命令查看程序是否在运行,此时只有序号没有PID号:输入命令 “jobs -l” 会显示程序的PID号,然后通过 “kill -9 PID”杀死 ...

  7. 2020/1/31 PHP代码审计之目录穿越漏洞

    0x00 目录穿越 目录穿越(Directory Traversal)攻击是黑客能够在Web应用程序所在的根目录以外的文件夹上,任意的存取被限制的文件夹,执行命令或查找数据.目录穿越攻击,也与人称为P ...

  8. part8 vue内置标签keep-alive对网页性能优化

    我们网页请求时候 我们点击路由切换 可以看network中数据请求 因为每次路由切换都会执行mounted钩子函数 我们这个函数中数据请求 //每次切换路由,页面都会重新渲染 在根组件中使用 路由切换 ...

  9. Tensorflow学习教程------softmax简单介绍

    做机器学习的同志们应该对这个都不陌生,这里简单举个例子.一般来说,使用softmax函数来将神经元输出的数值映射到0到1之间,这样神经元输出的值就变为了一个概率值. 公式和例子如下图 公式和例子如下图

  10. 在Azure Storage 托管HTTP静态网站

    本文演示了在Azure Storage托管HTTP静态网站. 注意:HTTP已经不建议使用. 创建Azure StorageV2 存储账户 账户类型选择“StorageV2(通用版V2)”: 本例中, ...