应用场景：　　

　　　　1、判断某一个字符串是否符合规则　　（注册时：判断手机号，身份证号，邮箱格式是否正确）

　　　　2、将符合规则的内容从一个庞大的字符串体系中提取出来　　（爬虫，日志分析）

　　什么是正则表达式：

　　　　只和字符串打交道，是一种规则，来约束字符串的规则

　　　　在同一个位置可能出现的各种字符组成了一个字符组，在正则表达式中用 [ ] 表示。

　　　　字符分为很多类，比如数字，字母，标点等等。

　　　　[0123456789]　　表示0-9都可以匹配

　　　　[0-9]　　　　　　 用 – 表示范围，[0-9] 和 [0123456789] 是一样的

　　　　[a-z]　　　　　　 表示所有的小写字母

　　　　[A-Z]　　　　　　表示所有的大写字母

　　　　[0-9a-fA-F]　　　 可以匹配数字，大小写形式的a~f，常用来验证十六进制字符

　　　　原理是通过ASCII编码，小的一个值指向大的一个值

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

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

　　　　\s　　 匹配任意的空白符（空格、换行\n、制表符\t）

　　　　\S　　匹配非空白符

　　　　\d　　匹配数字

　　　　\D　　匹配非数字

　　　　\n　　匹配一个换行符

　　　　\t　　 匹配一个制表符

　　　　\b　　匹配一个单词的边界

　　　　\A　　匹配以什么开头，与 ^ 的功能一样　　（\A匹配内容）

　　　　\Z　　匹配以什么结尾，与 $ 的功能一样　　（匹配内容\Z）

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

　　　　^　　  匹配字符串的开始

　　　　$　　 匹配字符串的结尾

　　　　a|b　  匹配字符a或字符b　　（把长的放前面，如 abc|ab）

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

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

　　　　[^…]　 匹配除了字符组中字符的所有字符

　　　　*　　  重复零次或更多次

　　　　+　　 重复一次或更多次

　　　　？　　重复零次或一次

　　　　{n}　   重复n次

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

　　　　{n,m}　重复n到m次

　　注意：前面的 *，+，？ 等都是贪婪匹配，也就是尽可能多的匹配，后面加？使其变成惰性匹配

身份证号码是一个长度为15或18个字符的字符串，如果是15位则全部由数字组成，首位不能为0；如果是18位的，则前17位全部是数字，末位可以是数字或x

在正则表达式中，有很多有特殊意义的是元字符，比如\n和\s等，如果要在正则中匹配正常的”\n”而不是”换行符”就需要对”\”进行转义，变成\’\\\’。

 贪婪匹配：在满足匹配时，匹配尽可能长的字符串，默认情况下，采用贪婪匹配

　　几个常用的非贪婪匹配

　　　　*? 　　 重复任意次，但尽可能少重复

　　　　+? 　　重复1次或更多次，但尽可能少重复

　　　　?? 　　重复0次或1次，但尽可能少重复

　　　　{n,m}?  重复n到m次，但尽可能少重复

　　　　{n,}? 　重复n次以上，但尽可能少重复

　　　　.　　是任意字符

　　　　*　　是取 0 至 无限长度

　　　　?　　是非贪婪模式

　　　　合在一起就是，取尽量少的任意字符，一般不会这么单独写，大多用在：

　　　　. * ? x　　就是取前面任意长度的字符，直到一个 x 出现

  1. import re
  3. # \w与\W
  4. print(re.findall(\'\w\', \'hello egon 123\'))
  5. # [\'h\', \'e\', \'l\', \'l\', \'o\', \'e\', \'g\', \'o\', \'n\', \'1\', \'2\', \'3\']
  6. print(re.findall(\'\W\', \'hello egon 123\'))
  7. # [\' \', \' \']
  8.  
  9. # \s与\S
  10. print(re.findall(\'\s\', \'hello egon 123\'))
  11. # [\' \', \' \']
  12. print(re.findall(\'\S\', \'hello egon 123\'))
  13. # [\'h\', \'e\', \'l\', \'l\', \'o\', \'e\', \'g\', \'o\', \'n\', \'1\', \'2\', \'3\']
  14.  
  15. # \n与\t都是空，都可以被\s匹配
  16. print(re.findall(\'\s\', \'hello \n egon \t 123\'))
  17. # [\' \', \'\n\', \' \', \' \', \'\t\', \' \']
  18.  
  19. # \n与\t
  20. print(re.findall(r\'\n\', \'hello egon \n123\'))
  21. # [\'\n\']
  22. print(re.findall(r\'\t\', \'hello egon \t 123\'))
  23. # [\'\t\']
  24.  
  25. # \d与\D
  26. print(re.findall(\'\d\', \'hello egon 123\'))
  27. # [\'1\', \'2\', \'3\']
  28. print(re.findall(\'\D\', \'hello egon 123\'))
  29. # [\'h\', \'e\', \'l\', \'l\', \'o\', \' \', \'e\', \'g\', \'o\', \'n\', \' \']
  30.  
  31. # \A与\Z
  32. print(re.findall(\'\Ahe\', \'hello egon 123\'))
  33. # [\'he\']
  34. print(re.findall(\'123\Z\', \'hello egon 123\'))
  35. # [\'123\']
  36.  
  37. # ^与$
  38. print(re.findall(\'^he\', \'hello egon 123\'))
  39. # [\'he\']
  40. print(re.findall(\'123$\', \'hello egon 123\'))
  41. # [\'123\']
  42.  
  43. # 重复匹配：.  *  ?  .*  .*?  +  {n,m}  |
  44.  
  45. # .
  46. print(re.findall(\'a.b\', \'a1b\'))
  47. # [\'a1b\']
  48. print(re.findall(\'a.b\', \'a1b a*b a b aaab\'))
  49. # [\'a1b\', \'a*b\', \'a b\', \'aab\']
  50. print(re.findall(\'a.b\', \'a\nb\'))
  51. # []
  52.  
  53. # *
  54. print(re.findall(\'ab*\', \'bbbbbbb\'))
  55. # []
  56. print(re.findall(\'ab*\', \'a\'))
  57. # [\'a\']
  58. print(re.findall(\'ab*\', \'abbbbbb\'))
  59. # [\'abbbbbb\']
  60.  
  61. # ?
  62. print(re.findall(\'ab?\', \'a\'))
  63. # [\'a\']
  64. print(re.findall(\'ab?\', \'abbbb\'))
  65. # [\'ab\']
  66.  
  67. # 匹配所有包含小数在内的数字
  68. print(re.findall(\'\d+\.?\d*\', \'sdfsdfs231sdsd1.123sdfsfas34jk23kj52k3jh4kj\'))
  69. # [\'231\', \'1.123\', \'34\', \'23\', \'52\', \'3\', \'4\']
  70.  
  71. # .*默认为贪婪匹配
  72. print(re.findall(\'a.*b\', \'a1b222222222b\'))
  73. # [\'a1b222222222b\']
  74.  
  75. # .*? 为非贪婪匹配：推荐使用
  76. print(re.findall(\'a.*?b\', \'a1b22222222b\'))
  77. # [\'a1b\']
  78.  
  79. # +
  80. print(re.findall(\'ab+\', \'a\'))
  81. # []
  82. print(re.findall(\'ab+\', \'abbb\'))
  83. # [\'abbb\']
  84.  
  85. # {n,m}
  86. print(re.findall(\'ab{2}\', \'abbbb\'))
  87. # [\'abb\']
  88. print(re.findall(\'ab{2,4}\', \'abbb\'))
  89. # [\'abbb\']
  90. print(re.findall(\'ab{1,}\', \'abbbbbb\'))
  91. # [\'abbbbbb\']
  92. print(re.findall(\'ab{0,}\', \'a\'))
  93. # [\'a\']
  94.  
  95. #[]
  96. print(re.findall(\'a[1*-]b\', \'a1b a*b a-b\'))
  97. # [\'a1b\', \'a*b\', \'a-b\']     []内的都为普通字符了，且如果-没有被转意的话，应该放到[]的开头或结尾
  98. print(re.findall(\'a[^1*-]b\', \'a1b a*b a-b a=b\'))
  99. # [\'a=b\']       []内的^代表的意思是取反，所以结果为[\'a=b\']
  100. print(re.findall(\'a[0-9]b\', \'a1b a*b a-b a=b\'))
  101. # [\'a1b\']
  102. print(re.findall(\'a[a-z]b\', \'a1b a*b a-b a=b aeb\'))
  103. # [\'aeb\']
  104. print(re.findall(\'a[a-zA-Z]b\', \'a1b a*b a-b a=b aeb aEb\'))
  105. # [\'aeb\', \'aEb\']
  106.  
  107. # 转义\
  108. print(re.findall(\'a\\c\', \'a\c\'))
  109. # 对于正则来说a\\c确实可以匹配到a\c,但是在python解释器读取a\\c时，会发生转义，然后交给re去执行，所以抛出异常
  110. print(re.findall(r\'a\\c\', \'a\c\'))
  111. # [\'a\\c\']  r代表告诉解释器使用rawstring，即原生字符串，把我们正则内的所有符号都当普通字符处理，不要转义
  112. print(re.findall(\'a\\\\c\', \'a\c\'))
  113. # 同上面的意思一样，和上面的结果一样都是[\'a\\c\']
  114.  
  115. # ()分组
  116. print(re.findall(\'ab+\', \'ababab123\'))
  117. # [\'ab\', \'ab\', \'ab\']
  118. print(re.findall(\'(ab)+123\', \'ababab123\'))
  119. # [\'ab\']，匹配到末尾的ab123中的ab
  120. print(re.findall(\'(?:ab)+123\', \'ababab123\'))
  121. # [\'ababab123\']  findall的结果不是匹配的全部内容，而是组内的内容,?:可以让结果为匹配的全部内容
  1. import re
  3. # findall
  4. print(re.findall(\'\d\', \'sdfh34h2h423h2h23h\'))
  5. # [\'3\', \'4\', \'2\', \'4\', \'2\', \'3\', \'2\', \'2\', \'3\']
  6. # 返回值是一个列表，里面的每个元素是所有匹配到的项
  7.  
  8.  
  9. # search
  10. ret = re.search(\'\d\', \'sdfh34h2h423h2h23h\')
  11. print(ret)
  12. # <re.Match object; span=(4, 5), match=\'3\'>
  13. print(ret.group())
  14. # 3
  16. ret = re.search(\'\d\', \'sdhfsd\')
  17. print(ret)
  18. # None
  19. if ret:
  20.     print(ret.group())
  21. # search返回值：
  22. #     返回一个re_Match对象
  23. #     通过group取值
  24. #     且只包含第一个匹配到值
  1. import re
  3. # findall 有一个特点，会优先显示分组中的内容
  4. ret = re.findall(\'www.(baidu|oldboy).com\', \'www.baidu.com\')
  5. print(ret)
  6. # [\'baidu\']
  9. ret = re.search(\'www.(baidu|oldboy).com\', \'www.baidu.com\')
  10. print(ret)
  11. # <re.Match object; span=(0, 13), match=\'www.baidu.com\'>
  12. print(ret.group())
  13. # www.baidu.com

 

版权声明：本文为zyling原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/zyling/p/12780362.html